开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
vid.c
资源名称：ST_5105DTV.rar　[点击查看]
上传用户：fy98168
上传日期：2015-06-26
资源大小：13771k
文件大小：16k
源码类别：

DVD

开发平台：

C/C++

vid.c：源码内容
  1. /*****************************************************************************
  3. File name: vid.c
  5. Description: STVID interface
  7. COPYRIGHT (C) 2004 STMicroelectronics
  9. *****************************************************************************/
  11. /* Includes --------------------------------------------------------------- */
  13. #include <string.h>
  14. #include <stdio.h>
  15. #include "stddefs.h"
  16. #include "stlite.h"
  17. #include "stdevice.h"
  18. #include "stsys.h"
  20. #include "stvid.h"
  21. #include "sttbx.h"
  23. #include "section.h"   /* memory partitions */
  24. #include "errors.h"
  25. #include "evt.h"
  26. #include "avmem.h"
  27. #include "clkrv.h"
  28. #include "layer.h"
  29. #include "vtg.h"
  30. #include "vid.h"
  31. #include "vmix.h"
  32. #include "stpti_hal.h"
  33. #include "avslot.h"
  35. /* Private Types ------------------------------------------------------ */
  37. /* Private Constants -------------------------------------------------- */
  38. #define NUM_INSTANCE        0
  40. /* Private Variables -------------------------------------------------- */
  42. /* Private Macros ----------------------------------------------------- */
  44. /* Private Function prototypes ---------------------------------------- */
  46. /* Global Variables ------------------------------------------------------- */
  48. STVID_ViewPortHandle_t  VID_ViewPortHandle_Multiple[VIDEO_USED];
  49. STVID_Handle_t          VID_Handle_Multiple[VIDEO_USED];
  50. #if (VIDEO_USED==2)
  51.     ST_DeviceName_t     VID_DeviceName_Multiple[VIDEO_USED] = { "VID", "AUX_VID" };
  52. #else
  53.     ST_DeviceName_t     VID_DeviceName_Multiple[VIDEO_USED] = { "VID" };
  54. #endif
  56. /* Functions ---------------------------------------------------------- */
  58. /* INTERFACE OBJECT: WRAPPER FCT TO LINK PTI AND VIDEO */
  59. /*-------------------------------------------------------------------------
  60.  * Function: GetWritePtrFct
  61.  * Decription: Gets the PES Buffer Write Pointer from PTI
  62.  * Input   : PTI Buffer Handle
  63.  * Output  :
  64.  * Return  : Error code and the Video Input Buffer Address
  65.  * ----------------------------------------------------------------------*/
  66. ST_ErrorCode_t GetWritePtrFct(void * const Handle_p, void ** const Address_p)
  67. {
  68.     ST_ErrorCode_t Err;
  70.     /* just cast the handle */
  71.     Err = STPTI_BufferGetWritePointer((STPTI_Buffer_t)Handle_p,Address_p);
  73.     return(Err);
  74. }
  76. /*-------------------------------------------------------------------------
  77.  * Function: SetReadPtrFct
  78.  * Decription: Sets the PTI Read Pointer.
  79.  * Input   : PTI Buffer Handle and the Video Buffer Address
  80.  * Output  :
  81.  * Return  : Error code
  82.  * ----------------------------------------------------------------------*/
  83. void SetReadPtrFct(void * const Handle_p, void * const Address_p)
  84. {
  85.     ST_ErrorCode_t Err;
  87.     /* just cast the handle */
  88.     Err = STPTI_BufferSetReadPointer((STPTI_Buffer_t)Handle_p,Address_p);
  89.     if ( Err != ST_NO_ERROR )
  90.     {
  91.         STTBX_Print(( "STPTI_BufferSetReadPointer()Failed %sn", KB_ErrorGetText(Err)));
  92.     }
  94.     return;
  95. }
  98. /*-------------------------------------------------------------------------
  99.  * Function : VID_Setup
  100.  * Input    : nothing
  101.  * Output   :
  102.  * Return   : Error Code
  103.  * ----------------------------------------------------------------------*/
  104. ST_ErrorCode_t VID_Setup(void)
  105. {
  106.     ST_ErrorCode_t         ST_ErrorCode;
  107.     STVID_InitParams_t     STVID_InitParams;
  108.     STVID_OpenParams_t     STVID_OpenParams;
  109.     STVID_ViewPortParams_t STVID_ViewPortParams;
  110.     STVID_MemoryProfile_t  STVID_MemoryProfile;
  111.     STVID_DisplayAspectRatioConversion_t STVID_darc = STVID_DISPLAY_AR_CONVERSION_LETTER_BOX;//STVID_DISPLAY_AR_CONVERSION_LETTER_BOX;//STVID_DISPLAY_AR_CONVERSION_PAN_SCAN;
  113.     U8                      Index;
  115.     memset(&STVID_InitParams, 0, sizeof(STVID_InitParams) );    /* clear every parameter */
  117.     STVID_InitParams.DeviceType                   = VID_DEVICE_TYPE;
  119.     STVID_InitParams.BaseAddress_p                = NULL;
  120.     STVID_InitParams.BaseAddress2_p               = (void *) VID_BASE_ADDRESS2;
  121.     STVID_InitParams.BaseAddress3_p               = (void *) VID_BASE_ADDRESS3;
  123.     STVID_InitParams.InstallVideoInterruptHandler = TRUE;
  124.     STVID_InitParams.InterruptNumber              = VIDEO_INTERRUPT;
  125.     STVID_InitParams.InterruptLevel               = VIDEO_INTERRUPT_LEVEL;
  126.     STVID_InitParams.CPUPartition_p               = SystemPartition;
  127.     STVID_InitParams.SharedMemoryBaseAddress_p    = (void*)NULL;
  128.     STVID_InitParams.AVMEMPartition               = g_KBAvmemPartitionHandle[0];
  129.     STVID_InitParams.DeviceBaseAddress_p          = (void *)VIDEO_BASE_ADDRESS;
  131.     STVID_InitParams.BitBufferAllocated           = FALSE;
  132.     STVID_InitParams.BitBufferAddress_p           = NULL;
  133.     STVID_InitParams.BitBufferSize                = 0;
  135.     STVID_InitParams.InterruptEvent               = 0;
  137.     STVID_InitParams.MaxOpen                      = 1;
  138.     STVID_InitParams.UserDataSize                 = 75;
  139.     STVID_InitParams.AVSYNCDriftThreshold         = 0;
  141.     strcpy(STVID_InitParams.InterruptEventName, "EVT" );
  142.     strcpy(STVID_InitParams.EvtHandlerName,     "EVT" );
  143.     strcpy(STVID_InitParams.ClockRecoveryName,  "CLKRV"        );
  145.     for ( Index = 0; Index < VIDEO_USED; Index++ )
  146.     {
  147.         STTBX_Print(("VID_Setup(%s)=", VID_DeviceName_Multiple[Index] ));
  149.         ST_ErrorCode = STVID_Init(VID_DeviceName_Multiple[Index], &STVID_InitParams);
  150.         if (ST_ErrorCode != ST_NO_ERROR)
  151.         {
  152.             STTBX_Print(("%sn", KB_ErrorGetText(ST_ErrorCode) ));
  153.             return( ST_ErrorCode );
  154.         }
  155.         STTBX_Print(("%sn", STVID_GetRevision() ));
  157.         STVID_OpenParams.SyncDelay = -(STC_OFFSET);
  159.         STTBX_Print(("VID_Open="));
  160.         ST_ErrorCode = STVID_Open(VID_DeviceName_Multiple[Index], &STVID_OpenParams, &VID_Handle_Multiple[Index]);
  161.         STTBX_Print(("%sn", KB_ErrorGetText(ST_ErrorCode) ));
  162.         if (ST_ErrorCode != ST_NO_ERROR)
  163.             return( ST_ErrorCode );
  165.         STVID_MemoryProfile.MaxWidth         = 720;
  166.         STVID_MemoryProfile.MaxHeight        = 576;
  168.         if((KB_VMIX_DEVICE_TYPE == STVMIX_COMPOSITOR_FIELD_COMBINED)||((KB_VMIX_DEVICE_TYPE == STVMIX_COMPOSITOR_FIELD_COMBINED_422)))
  169.             STVID_MemoryProfile.NbFrameStore     = 4;   /* Must be 6 for supporting DVR trickmodes */
  170.         else
  171.             STVID_MemoryProfile.NbFrameStore     = 5;   /* Must be 6 for supporting DVR trickmodes */
  173.         STVID_MemoryProfile.CompressionLevel = STVID_COMPRESSION_LEVEL_NONE;
  174.         STVID_MemoryProfile.DecimationFactor = STVID_DECIMATION_FACTOR_NONE;
  176.         ST_ErrorCode = STVID_SetMemoryProfile(VID_Handle_Multiple[Index], &STVID_MemoryProfile );
  177.         if (ST_ErrorCode != ST_NO_ERROR)
  178.         {
  179.             STTBX_Print(("VID_SetMemoryProfile(%d,%d,%d,%d,%d)=%sn",
  180.                     STVID_MemoryProfile.MaxWidth,
  181.                     STVID_MemoryProfile.MaxHeight,
  182.                     STVID_MemoryProfile.NbFrameStore,
  183.                     STVID_MemoryProfile.CompressionLevel,
  184.                     STVID_MemoryProfile.DecimationFactor, KB_ErrorGetText(ST_ErrorCode) ));
  186.             return( ST_ErrorCode );
  187.         }
  189.         memset(&STVID_ViewPortParams, 0, sizeof(STVID_ViewPortParams));
  191.         /* Connect layer to mixer */
  192.         strcpy(STVID_ViewPortParams.LayerName, g_KB_LayerDeviceName[Index] );
  194.         STTBX_Print(("VID_OpenViewPort(%s,%s)=", VID_DeviceName_Multiple[Index], g_KB_LayerDeviceName[Index] ));
  195.         ST_ErrorCode = STVID_OpenViewPort(VID_Handle_Multiple[Index], &STVID_ViewPortParams, &VID_ViewPortHandle_Multiple[Index] );
  196.         STTBX_Print(("%sn", KB_ErrorGetText(ST_ErrorCode) ));
  197.         if (ST_ErrorCode != ST_NO_ERROR)
  198.             return( ST_ErrorCode );
  200.         ST_ErrorCode = STVID_SetDisplayAspectRatioConversion(VID_ViewPortHandle_Multiple[Index], STVID_darc);
  201.         if (ST_ErrorCode != ST_NO_ERROR)
  202.         {
  203.             STTBX_Print(("VID_SetDisplayAspectRatioConversion()=%sn", KB_ErrorGetText(ST_ErrorCode) ));
  204.         }
  206.         ST_ErrorCode = STVID_EnableOutputWindow(VID_ViewPortHandle_Multiple[Index]);
  207.         if (ST_ErrorCode != ST_NO_ERROR)
  208.         {
  209.             STTBX_Print(("VID_EnableOutputindow()=%sn", KB_ErrorGetText(ST_ErrorCode) ));
  210.         }
  212.         /* Link corresponding Video and PTI */
  213.         STTBX_Print(("VID_Link(%d,%d)=", Index, Index));
  214.         ST_ErrorCode = VID_Link(Index, Index);
  215.         STTBX_Print(("%sn", KB_ErrorGetText(ST_ErrorCode)));
  216.         if (ST_ErrorCode != ST_NO_ERROR)
  217.             return( ST_ErrorCode );
  218.     }
  220.     return ( ST_ErrorCode );
  221. }
  223. /*-------------------------------------------------------------------------
  224.  * Function : VID_Link
  225.  *            Link the correspoding PTI to Video
  226.  * Input    :
  227.  * Output   :
  228.  * Return   : ErrorCode
  229.  * ----------------------------------------------------------------------*/
  230. ST_ErrorCode_t VID_Link(U32 VidInst, U32 PTIInst)
  231. {
  232.     ST_ErrorCode_t ST_ErrorCode;
  234.     void*          Video_PESBufferAdd_p;
  235.     U32            Video_PESBufferSize;
  240.     ST_ErrorCode = STVID_GetDataInputBufferParams(VID_Handle_Multiple[VidInst],&Video_PESBufferAdd_p,&Video_PESBufferSize);
  241.     if (ST_ErrorCode != ST_NO_ERROR)
  242.     {
  243.         STTBX_Print (("VID_GetDataInputBufferParams=%sn",KB_ErrorGetText(ST_ErrorCode)));
  244.         return(ST_ErrorCode);
  245.     }
  247.     ST_ErrorCode = STPTI_BufferAllocateManual(  g_KB_PTIHandleMultiple[PTIInst],
  248.                                                 Video_PESBufferAdd_p, Video_PESBufferSize,
  249.                                                 1, &PTI_VideoBufferHandle_Multiple[PTIInst]);
  250.     if (ST_ErrorCode != ST_NO_ERROR)
  251.     {
  252.         STTBX_Print (("PTI_BufferAllocateManual=%sn",KB_ErrorGetText(ST_ErrorCode)));
  253.         return(ST_ErrorCode);
  254.     }
  256.     /* No cd-fifo: Initialise the link between pti and video */
  257.     ST_ErrorCode = STPTI_SlotLinkToBuffer(PTI_SlotHandle_Multiple[PTIInst][SLOTVID], PTI_VideoBufferHandle_Multiple[PTIInst]);
  258.     if (ST_ErrorCode != ST_NO_ERROR)
  259.     {
  260.         STTBX_Print (("PTI_SlotLinkToBuffer=%sn",KB_ErrorGetText(ST_ErrorCode)));
  261.         return(ST_ErrorCode);
  262.     }
  264.     ST_ErrorCode = STPTI_BufferSetOverflowControl(PTI_VideoBufferHandle_Multiple[PTIInst], TRUE);
  265.     if (ST_ErrorCode != ST_NO_ERROR)
  266.     {
  267.         STTBX_Print (("PTI_BufferSetOverflowControl=%sn",KB_ErrorGetText(ST_ErrorCode)));
  268.         return(ST_ErrorCode);
  269.     }
  271.     ST_ErrorCode = STVID_SetDataInputInterface( VID_Handle_Multiple[VidInst],
  272.                                                 GetWritePtrFct, SetReadPtrFct,
  273.                                                 (void * const)PTI_VideoBufferHandle_Multiple[PTIInst]);
  274.     if (ST_ErrorCode != ST_NO_ERROR)
  275.     {
  276.         STTBX_Print (("VID_SetDataInputInterface=%sn",KB_ErrorGetText(ST_ErrorCode)));
  277.         return(ST_ErrorCode);
  278.     }
  281.     return (ST_ErrorCode);
  282. }
  284. /*-------------------------------------------------------------------------
  285.  * Function : VID_Unlink
  286.  *            Unlink the correspoding PTI to Video
  287.  * Input    :
  288.  * Output   :
  289.  * Return   : ErrorCode
  290.  * ----------------------------------------------------------------------*/
  291. ST_ErrorCode_t VID_Unlink(U32 VidInst, U32 PTIInst)
  292. {
  293.     ST_ErrorCode_t ST_ErrorCode;
  295.     ST_ErrorCode = STVID_DeleteDataInputInterface( VID_Handle_Multiple[VidInst] );
  296.     if (ST_ErrorCode != ST_NO_ERROR)
  297.     {
  298.         STTBX_Print (("VID_DeleteDataInputInterface=%sn",KB_ErrorGetText(ST_ErrorCode)));
  299.         return(ST_ErrorCode);
  300.     }
  302.     ST_ErrorCode = STPTI_BufferFlush(PTI_VideoBufferHandle_Multiple[PTIInst]);
  303.     if (ST_ErrorCode != ST_NO_ERROR)
  304.     {
  305.         STTBX_Print (("PTI_BufferFlush=%sn",KB_ErrorGetText(ST_ErrorCode)));
  306.         return(ST_ErrorCode);
  307.     }
  309.     ST_ErrorCode = STPTI_SlotUnLink(PTI_SlotHandle_Multiple[PTIInst][SLOTVID]);
  310.     if (ST_ErrorCode != ST_NO_ERROR)
  311.     {
  312.         STTBX_Print (("PTI_SlotUnLink=%sn",KB_ErrorGetText(ST_ErrorCode)));
  313.         return(ST_ErrorCode);
  314.     }
  316.     ST_ErrorCode = STPTI_BufferDeallocate(PTI_VideoBufferHandle_Multiple[PTIInst]);
  317.     if (ST_ErrorCode != ST_NO_ERROR)
  318.     {
  319.         STTBX_Print (("PTI_BufferDeallocate=%sn",KB_ErrorGetText(ST_ErrorCode)));
  320.         return(ST_ErrorCode);
  321.     }
  323.     return (ST_ErrorCode);
  324. }
  326. /*-------------------------------------------------------------------------
  327.  * Function : VID_Start
  328.  *            Start Decoding Video
  329.  * Input    :
  330.  * Output   :
  331.  * Return   : ErrorCode
  332.  * ----------------------------------------------------------------------*/
  333. ST_ErrorCode_t VID_Start(STVID_StartParams_t *STVID_StartParams_p)
  334. {
  335.     ST_ErrorCode_t ST_ErrorCode;
  337.     ST_ErrorCode = STVID_Start(VID_Handle_Multiple[NUM_INSTANCE], STVID_StartParams_p);
  339.     STTBX_Print(("STVID_Start(%d,%d,%d,%d,%d)=%sn",
  340.             STVID_StartParams_p->RealTime,      STVID_StartParams_p->UpdateDisplay,
  341.             STVID_StartParams_p->StreamType,    STVID_StartParams_p->StreamID,
  342.             STVID_StartParams_p->BrdCstProfile, KB_ErrorGetText(ST_ErrorCode) ));
  343.     return ( ST_ErrorCode );
  344. }
  347. /*-------------------------------------------------------------------------
  348.  * Function : VID_ChangeAspectRatio
  349.  *            Change the layer parameters to set the aspect ratio.
  350.  * Input    :
  351.  * Output   :
  352.  * Return   : ErrorCode
  353.  * ----------------------------------------------------------------------*/
  354. ST_ErrorCode_t VID_ChangeAspectRatio(STGXOBJ_AspectRatio_t *Aspect_p)
  355. {
  356.     ST_ErrorCode_t        ST_ErrorCode;
  357.     STVMIX_ScreenParams_t ScreenParams;
  358.     STLAYER_LayerParams_t LayerParams;
  360.     ST_ErrorCode = STLAYER_GetLayerParams(g_KB_LayerHandle[LAYER_VIDEO], &LayerParams);
  361.     if (ST_ErrorCode != ST_NO_ERROR)
  362.         return ST_ErrorCode;
  364.     ST_ErrorCode = STVMIX_GetScreenParams(g_KB_VmixHandle, &ScreenParams);
  365.     if (ST_ErrorCode != ST_NO_ERROR)
  366.         return ST_ErrorCode;
  368.     LayerParams.AspectRatio  = *Aspect_p;
  369.     ScreenParams.AspectRatio = *Aspect_p;
  371.     ST_ErrorCode = STLAYER_SetLayerParams(g_KB_LayerHandle[LAYER_VIDEO], &LayerParams);
  372.     if (ST_ErrorCode != ST_NO_ERROR)
  373.         return ST_ErrorCode;
  375.     ST_ErrorCode = STVMIX_SetScreenParams(g_KB_VmixHandle, &ScreenParams);
  377.     return ST_ErrorCode;
  378. }
  380. /*-------------------------------------------------------------------------
  381.  * Function : VID_ChangeScanType
  382.  *            Change the layer parameters to set the scan type
  383.  * Input    :
  384.  * Output   :
  385.  * Return   : ErrorCode
  386.  * ----------------------------------------------------------------------*/
  387. ST_ErrorCode_t VID_ChangeScanType(STVID_ScanType_t *ScanType_p)
  388. {
  389.     ST_ErrorCode_t        ST_ErrorCode;
  390.     STVMIX_ScreenParams_t ScreenParams;
  391.     STLAYER_LayerParams_t LayerParams;
  393.     ST_ErrorCode = STLAYER_GetLayerParams(g_KB_LayerHandle[LAYER_VIDEO], &LayerParams);
  394.     if (ST_ErrorCode != ST_NO_ERROR)
  395.         return ST_ErrorCode;
  397.     ST_ErrorCode = STVMIX_GetScreenParams(g_KB_VmixHandle, &ScreenParams);
  398.     if (ST_ErrorCode != ST_NO_ERROR)
  399.         return ST_ErrorCode;
  401.     if (*ScanType_p == STVID_SCAN_TYPE_PROGRESSIVE)
  402.     {
  403.         LayerParams.ScanType = STGXOBJ_PROGRESSIVE_SCAN;
  404.         ScreenParams.ScanType = STGXOBJ_PROGRESSIVE_SCAN;
  405.     }
  406.     else if (*ScanType_p == STVID_SCAN_TYPE_INTERLACED)
  407.     {
  408.         LayerParams.ScanType = STGXOBJ_INTERLACED_SCAN;
  409.         ScreenParams.ScanType = STGXOBJ_INTERLACED_SCAN;
  410.     }
  411.     else
  412.     {
  413.         ST_ErrorCode = ST_ERROR_BAD_PARAMETER;
  414.         return ST_ErrorCode;
  415.     }
  417.     ST_ErrorCode = STLAYER_SetLayerParams(g_KB_LayerHandle[LAYER_VIDEO], &LayerParams);
  418.     if (ST_ErrorCode != ST_NO_ERROR)
  419.         return ST_ErrorCode;
  421.     ST_ErrorCode = STVMIX_SetScreenParams(g_KB_VmixHandle, &ScreenParams);
  423.     return ST_ErrorCode;
  424. }
  426. /* EOF --------------------------------------------------------------------- */