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

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

DVD

开发平台：

C/C++

iframe.c：源码内容
  1. /* Includes ---------------------------------------------------------------- */
  3. #include <time.h>
  4. #include <stdio.h>
  5. #include <string.h>
  6. #include <stdlib.h>
  7. #include <task.h>
  9. /* STAPI header------------------------------------------------------------- */
  10. #include "stddefs.h"
  11. #include "stlite.h"
  12. #include "stcommon.h"
  13. #include "stdevice.h"
  14. #include "sttbx.h"
  15. #include "testtool.h"
  17. #include "section.h"
  18. #include "errors.h"
  19. #include "vid.h"
  20. #include "vtg.h"
  21. #include "avslot.h"
  23. #include "stpti_hal.h"
  24. #include "debug.h"
  25. //#include "viddbg.h"
  27. #include "regevent.h"   /* SLSL */
  29. #define I_FRAME_DATA 0
  31. #if (I_FRAME_DATA == 1)
  32. #include "mwaudio.h"
  33. #define I_FRAME_DATA_POINTER (unsigned char*)MPEG1_DATA
  34. #define I_FRAME_DATA_SIZE    sizeof(MPEG1_DATA)
  35. #endif
  37. #if (I_FRAME_DATA == 2)
  38. #include "test.h"
  39. #define I_FRAME_DATA_POINTER (unsigned char*)ucBitMap
  40. #define I_FRAME_DATA_SIZE    sizeof(ucBitMap)
  41. #endif
  43. #if (I_FRAME_DATA == 3)
  44. #include "ggbmpeg.h"
  45. #define I_FRAME_DATA_POINTER (unsigned char*)GoldenGateBridge
  46. #define I_FRAME_DATA_SIZE    sizeof(GoldenGateBridge)
  47. #endif
  49. #define VD_FEED_SIZE (1024*5)
  50. #define DUMMY_BUF_SIZE  (4096)
  53. static  U8     *VID_Mem_p, *VID_Buffer_p;
  54. static  U32     VID_BufferSize;
  56. /* Parameters required for video injection */
  57. static  void *UserBufferStart_p;
  58. static  void *UserBufferStop_p;
  59. static  void *UserBufferCurrent_P;
  60. static  void *VideoInputBuffWptr;
  61. static  void *VideoInputBuffRptr;
  62. static  void *VideoInputBuffStart;
  63. static  void *VideoInputBuffStop;
  65. static semaphore_t * iframeStopDecodeLock ;
  66. static semaphore_t * iframePicDecodeLock ;
  68. /*-------------------------------------------------------------------------
  69. * Function : BackGround_VID_StartDecode
  70. Start the video decoding for the input parameters passed by the user.
  71. * Input    :
  72. * Output   :
  73. * Return   : TRUE if fails, else FALSE.
  74. * ----------------------------------------------------------------------*/
  75. ST_ErrorCode_t BackGround_VID_StartDecode( void )
  76. {
  77.     ST_ErrorCode_t          ErrCode = ST_NO_ERROR;
  78.     STVID_Freeze_t          Freeze;
  79.     STVID_StartParams_t     VIDStartParams;
  80.     STVID_Stop_t    VID_StopMode = STVID_STOP_NOW;
  81.     STVID_WindowParams_t    WinParams = { STVID_WIN_ALIGN_VCENTRE_HCENTRE, STVID_WIN_SIZE_DONT_CARE };
  82.     S32 InputWinPositionX;
  83.     S32 InputWinPositionY;
  84.     U32 InputWinWidth;
  85.     U32 InputWinHeight;
  86.     S32 OutputWinPositionX;
  87.     S32 OutputWinPositionY;
  88.     U32 OutputWinWidth;
  89.     U32 OutputWinHeight;
  90.     
  91.     /*Primary decode is in auto mode whereas secondary decode is in manual mode which is required for resizing*/
  92.     ErrCode = STVID_SetDisplayAspectRatioConversion(VID_ViewPortHandle_Multiple[0], STVID_DISPLAY_AR_CONVERSION_LETTER_BOX/*STVID_DISPLAY_AR_CONVERSION_LETTER_BOX STVID_DISPLAY_AR_CONVERSION_IGNORE*/);
  93.     if ( ErrCode != ST_NO_ERROR )
  94.     {
  95.         STTBX_Print(("STVID_SetDisplayAspectRatioConversion()Failed 0x%08Xn", ErrCode ));
  96.         //return ErrCode;
  97.     }
  98.     ErrCode = STVID_GetIOWindows( VID_ViewPortHandle_Multiple[0],
  99.         &InputWinPositionX,  &InputWinPositionY,
  100.         &InputWinWidth,      &InputWinHeight,
  101.         &OutputWinPositionX, &OutputWinPositionY,
  102.         &OutputWinWidth,     &OutputWinHeight );
  103.     
  104.     if ( ErrCode != ST_NO_ERROR )
  105.     {
  106.         STTBX_Print(("GetIOWindows=%sn", KB_ErrorGetText(ErrCode)));
  107.         STTBX_Print(("Input %d,%d,%d,%dnOutput %d,%d,%d,%dn",
  108.             InputWinPositionX, InputWinPositionY, InputWinWidth, InputWinHeight,
  109.             OutputWinPositionX, OutputWinPositionY, OutputWinWidth, OutputWinHeight ));
  110.     }
  111.     ErrCode = STVID_SetOutputWindowMode(VID_ViewPortHandle_Multiple[0], FALSE, &WinParams);
  112.     if ( ErrCode != ST_NO_ERROR )
  113.     {
  114.         STTBX_Print(("STVID_SetOutputWindowMode()Failed 0x%08Xn", ErrCode ));
  115.     }
  116.     ErrCode = STVID_SetIOWindows(VID_ViewPortHandle_Multiple[0], InputWinPositionX,  InputWinPositionY,
  117.         InputWinWidth,      InputWinHeight,
  118.         OutputWinPositionX, OutputWinPositionY,
  119.         OutputWinWidth,     OutputWinHeight );
  120.     
  121.     if ( ErrCode != ST_NO_ERROR )
  122.     {
  123.         STTBX_Print(("STVID_SetIOWindows()Failed 0x%08Xn", ErrCode ));
  124.         //return ErrCode;
  125.     }
  126.     
  128.     /* stop video */
  129.     Freeze.Field = STVID_FREEZE_FIELD_TOP;
  130.     Freeze.Mode = STVID_FREEZE_MODE_NO_FLICKER;
  131.     ErrCode = STVID_Stop(VID_Handle_Multiple[0], VID_StopMode, &Freeze);
  132.     STTBX_Print(("IFRAME_BackGround_VID_StartDecode:: STVID_STOPn"));
  133.     
  134.     if ( ErrCode != ST_NO_ERROR )
  135.     {
  136.         STTBX_Print(("BackGround: STVID_Stop()=%sn", KB_ErrorGetText(ErrCode) ));
  137.     }
  138.             
  139.     /* start video */
  140.     VIDStartParams.StreamType    = STVID_STREAM_TYPE_ES;
  141.     VIDStartParams.BrdCstProfile = STVID_BROADCAST_DVB;
  142.     VIDStartParams.RealTime      = FALSE;//TRUE;
  143.     VIDStartParams.UpdateDisplay = TRUE;
  144.     VIDStartParams.StreamID      = STVID_IGNORE_ID;
  145.     VIDStartParams.DecodeOnce    = FALSE;
  146.     
  147.     ErrCode = STVID_Start(VID_Handle_Multiple[0], &VIDStartParams);
  148.     STTBX_Print(("IFRAME:: STVID_STARTn"));
  149.     if ( ErrCode != ST_NO_ERROR )
  150.     {
  151.         STTBX_Print(("BackGround: STVID_Start()=%sn", KB_ErrorGetText(ErrCode) ));
  152.         
  153.        Freeze.Field = STVID_FREEZE_FIELD_TOP;
  154.             Freeze.Mode = STVID_FREEZE_MODE_NO_FLICKER;
  155.             ErrCode = STVID_Stop(VID_Handle_Multiple[0], VID_StopMode, &Freeze);  /*Stop again*/
  156.             STTBX_Print(("IFRAME_BackGround_VID_StartDecode:: STVID_STOPn"));
  157.             
  158.             ErrCode = STVID_Start(VID_Handle_Multiple[0], &VIDStartParams); /*Restart*/
  159.             STTBX_Print(("IFRAME:: STVID_STARTn"));
  160.             if ( ErrCode != ST_NO_ERROR )
  161.                 STTBX_Print(("BackGround: STVID_Start()=%sn", KB_ErrorGetText(ErrCode) ));
  162.     }
  163.     
  164.     ErrCode = STVID_DisableSynchronisation(VID_Handle_Multiple[0]);
  165.     if ( ErrCode != ST_NO_ERROR )
  166.     {
  167.         STTBX_Print(("STVID_DisableSyncronisation()=%sn", KB_ErrorGetText(ErrCode) ));
  168.     }
  169.     
  170.     
  171.     return ErrCode;
  172. }
  174. static ST_ErrorCode_t GetWritePtrPTIFctLive(void * const Handle_p, void ** const Address_p)
  175. {
  176.     ST_ErrorCode_t          ErrCode = ST_NO_ERROR;
  177.     ErrCode = STPTI_BufferGetWritePointer((STPTI_Buffer_t)Handle_p,Address_p);
  178.     if ( ErrCode != ST_NO_ERROR )
  179.     {
  180.         STTBX_Print(("GetWritePtrPTIFctLive()=%sn", KB_ErrorGetText(ErrCode) ));
  181.     }
  182.     return ErrCode;
  183. }
  185. static void SetReadPtrPTIFctLive(void * const Handle_p, void * const Address_p)
  186. {
  187.     ST_ErrorCode_t          ErrCode = ST_NO_ERROR;
  188.     ErrCode = STPTI_BufferSetReadPointer((STPTI_Buffer_t)Handle_p,Address_p);
  189.     if ( ErrCode != ST_NO_ERROR )
  190.     {
  191.         STTBX_Print(("SetReadPtrPTIFctLive()=%sn", KB_ErrorGetText(ErrCode) ));
  192.     }
  193. }
  195. static ST_ErrorCode_t GetWritePtrFctIframe(void * const Handle_p, void ** const Address_p)
  196. {
  197.     *Address_p = VideoInputBuffWptr;
  198.     return(0);
  199. }
  201. static void SetReadPtrFctIframe(void * const Handle_p, void * const Address_p)
  202. {
  203.     VideoInputBuffRptr = Address_p;
  204.     return;
  205. }
  207. /* Start I frame decode */
  208. ST_ErrorCode_t IFrameDecodeStart(void)
  209. {
  210.     ST_ErrorCode_t ErrCode = ST_NO_ERROR;
  211.     STVID_StartParams_t VIDStartParams;
  212.     //STVID_DecodedPictures_t DecodedPictures;
  213.     
  214.     VIDStartParams.StreamType    = STVID_STREAM_TYPE_ES;
  215.     VIDStartParams.BrdCstProfile = STVID_BROADCAST_DVB;
  216.     VIDStartParams.RealTime = FALSE;
  217.     VIDStartParams.DecodeOnce =TRUE;
  218.     VIDStartParams.StreamID = STVID_IGNORE_ID; 
  219.     
  220.     VIDStartParams.UpdateDisplay = TRUE;  /* SLSL */
  221.     
  222.     ErrCode = STVID_Start(VID_Handle, &VIDStartParams);    
  223.     if (ErrCode != ST_NO_ERROR)
  224.     {
  225.         STTBX_Print(("vid start=%sn", KB_ErrorGetText(ErrCode) ));
  226.     }
  227.     
  228.     
  229.     return ErrCode;
  230. }
  233. ST_ErrorCode_t testvideo(void)
  234. {
  235.     STVID_Freeze_t Freeparam;
  236.     ST_ErrorCode_t ErrCode = ST_NO_ERROR;
  237.     
  238.     Freeparam.Mode = STVID_FREEZE_MODE_NO_FLICKER ;
  239.     Freeparam.Field = STVID_FREEZE_FIELD_CURRENT;
  240.     ErrCode=STVID_Freeze(VID_Handle_Multiple[0],&Freeparam);
  241.     if ( ErrCode != ST_NO_ERROR )
  242.     {
  243.         STTBX_Print(("STVID_Freeze()=%sn", KB_ErrorGetText(ErrCode) ));
  244.     }
  245.     
  246.     return ErrCode;
  247. }
  249. /* Stop I frame decode */
  250. ST_ErrorCode_t IFrameStop( void )
  251. {
  252.     ST_ErrorCode_t ErrCode = ST_NO_ERROR;
  253.     STVID_Stop_t    VID_StopMode = STVID_STOP_NOW;
  254.     STVID_Freeze_t  VID_Freeze;
  255.     STVID_ClearParams_t ClearParams;
  256.     
  257.     VID_Freeze.Field    = STVID_FREEZE_FIELD_TOP;
  258.     VID_Freeze.Mode     = STVID_FREEZE_MODE_NO_FLICKER;
  259.     
  260. #if 1
  261.     ErrCode = STVID_Stop(VID_Handle, VID_StopMode, &VID_Freeze);
  262.     //STTBX_Print(("IFRAME_IFrameStop:: STVID_STOPn"));    
  263. #else
  264.     ErrCode = STVID_Freeze(VID_Handle_Multiple[0], &VID_Freeze);
  265. #endif
  266.     if (ErrCode != ST_NO_ERROR)
  267.     {
  268.         STTBX_Print(("vid stop1=%sn", KB_ErrorGetText(ErrCode) ));
  269.     }
  271.     ErrCode = STVID_DisableOutputWindow(VID_ViewPortHandle);
  272.     if (ErrCode != ST_NO_ERROR)
  273.     {
  274.         STTBX_Print(("STVID_DisableOutputWindow()=%sn", KB_ErrorGetText(ErrCode) ));
  275.     }
  276.     
  277.     return ErrCode;
  278. }
  280. static BOOL LiveVideoStart( void )
  281. {
  282.     STVID_StartParams_t VIDStartParams;
  283.     STVID_DecodedPictures_t DecodedPictures;
  284.     #if 1
  285.     STVID_SetDataInputInterface( VID_Handle,
  286.         GetWritePtrPTIFctLive, SetReadPtrPTIFctLive,
  287.         (void * const)PTI_VideoBufferHandle_Multiple[0]);
  288.     #endif
  289.     STVID_EnableSynchronisation(VID_Handle);  
  290. #if 1
  291.     DecodedPictures = STVID_DECODED_PICTURES_ALL;
  292.     STVID_SetDecodedPictures(VID_Handle, DecodedPictures);
  293. #endif
  294.     VIDStartParams.StreamType    = STVID_STREAM_TYPE_ES;
  295.     VIDStartParams.BrdCstProfile = STVID_BROADCAST_DVB;
  296.     VIDStartParams.RealTime = (BOOL)FALSE;
  297.     VIDStartParams.UpdateDisplay = (BOOL)TRUE;
  298.     VIDStartParams.DecodeOnce = (BOOL)FALSE;
  299.     VIDStartParams.StreamID = STVID_IGNORE_ID;
  300.     
  301.     STVID_EnableSynchronisation(VID_Handle_Multiple[0]);
  303.     return TRUE;
  304. }
  306. ST_ErrorCode_t LiveVideoStop( void )
  307. {
  308.     /*STVID_Stop_t    VID_StopMode = STVID_STOP_WHEN_END_OF_DATA; */
  309.     STVID_Stop_t    VID_StopMode = STVID_STOP_NOW; 
  310.     STVID_Freeze_t  VID_Freeze;
  311.     //STVID_ClearParams_t ClearParams;
  312.     ST_ErrorCode_t ErrCode = ST_NO_ERROR;
  313.     VID_Freeze.Field    = STVID_FREEZE_FIELD_TOP;
  314.     VID_Freeze.Mode     = STVID_FREEZE_MODE_NO_FLICKER;
  315.     ErrCode=STVID_Stop(VID_Handle, VID_StopMode, &VID_Freeze);
  316.     if (ErrCode != ST_NO_ERROR)
  317.     {
  318.         STTBX_Print(("vid stop2=%sn", KB_ErrorGetText(ErrCode) ));
  319.     }
  320.     
  321.     ErrCode = STVID_DisableOutputWindow(VID_ViewPortHandle);
  322.     if (ErrCode != ST_NO_ERROR)
  323.     {
  324.         STTBX_Print(("STVID_DisableOutputWindow()=%sn", KB_ErrorGetText(ErrCode) ));
  325.     }
  326.     
  327.     return ErrCode;
  328. }
  330. static BOOL LoadIframe(unsigned char *buffer,int number )
  331. {   
  332.     VID_BufferSize = number;
  333.     VID_Mem_p = buffer;
  334.     VID_Buffer_p = buffer;
  335.     return 0;
  336. } /* end VID_MemLoad */
  338. /* why can not 100% display I frame with 1 time injection?? */
  339. static void InjectIframe(int loop)
  340. {
  341.     U32     MaxDmaTransferSize = 128*1024;
  342.     U32     DmaTransferSize = 0,
  343.         InputBufferFreeSize,
  344.         RemainingSourceDataSize,
  345.         BitBufferThreshold,
  346.         BitBufferFreeSize,
  347.         /*BitBufferSize = 370 * 1024;*//*378800*/
  348.         BitBufferSize = 380928;/*CHENG modify-05/20/2006*/
  349.     U32     SnapInputRead = 0,
  350.         SnapInputWrite = 0;
  351.     BOOL    OneRound = FALSE;
  352.     
  353.     STVID_GetDataInputBufferParams(VID_Handle, &VideoInputBuffStart, &InputBufferFreeSize);
  354.     VideoInputBuffWptr = VideoInputBuffStart;
  355.     VideoInputBuffRptr = VideoInputBuffStart;
  356.     VideoInputBuffStop = (void*)((U32)VideoInputBuffStart+InputBufferFreeSize-1);
  357.     STVID_SetDataInputInterface(VID_Handle,GetWritePtrFctIframe,SetReadPtrFctIframe,(void*)1);
  358.     UserBufferStart_p       = (void*)VID_Buffer_p;
  359.     UserBufferCurrent_P     = UserBufferStart_p;
  360.     UserBufferStop_p        = (void*)((U32)UserBufferStart_p+VID_BufferSize-1);
  361.     
  362. #if 1 /*LYNN COMMENT OFF*/
  363.     /*STVID_GetBitBufferFreeSize(VID_Handle_Multiple[0], &BitBufferSize);*/
  364. #endif
  365.     
  366.     for( ; (loop > 0) ; loop-- )
  367.     {
  368.         while(OneRound == FALSE)
  369.         {
  370.             STVID_GetBitBufferFreeSize(VID_Handle, &BitBufferFreeSize);
  371.             DmaTransferSize = BitBufferFreeSize;
  372.             /* Compute threshold to avoid an overflow */
  373.             BitBufferThreshold = (3*BitBufferSize/4) & (~3);/*284160*/
  374.             
  375.             /* prevent for data pending in input-buffer */
  376.             if(BitBufferThreshold > ((U32)VideoInputBuffStop - (U32)VideoInputBuffStart + 1))
  377.             {
  378.                 BitBufferThreshold = BitBufferThreshold - ((U32)VideoInputBuffStop - (U32)VideoInputBuffStart + 1);
  379.             }
  380.             
  381.             if (BitBufferSize-BitBufferFreeSize > BitBufferThreshold)
  382.             {
  383.                 DmaTransferSize = 0;
  384.                 task_reschedule();
  385.             }
  386.             else
  387.             {
  388.                 DmaTransferSize = BitBufferThreshold-(BitBufferSize-BitBufferFreeSize);
  389.             }
  390.             
  391.             /* Control data size to be injected */
  392.             /* - enough data to fill the bit buffer until Threshold limit */
  393.             /* - 128k bytes maximum */
  394.             /* - remaining source data maximum */
  395.             RemainingSourceDataSize = (U32)VID_BufferSize - (U32)((U32)UserBufferCurrent_P - (U32)UserBufferStart_p);
  396.             
  397.             if (DmaTransferSize > MaxDmaTransferSize)
  398.                 DmaTransferSize = MaxDmaTransferSize;
  400. /*cheng delete-05/20/2006*/            
  401. #if 0 
  402.                 if (DmaTransferSize >= RemainingSourceDataSize)
  403.                 {
  404.                     DmaTransferSize = RemainingSourceDataSize;
  405.                     OneRound = TRUE; /* completed the first round of injection */
  406.                 }
  407. #endif  
  408. /*cheng delete-05/20/2006*/
  409.             
  410.             if (DmaTransferSize > 0)
  411.             {
  412.                 /* store shared pointers in private values */
  413.                 SnapInputRead  = (U32)VideoInputBuffRptr;
  414.                 SnapInputWrite = (U32)VideoInputBuffWptr;
  415.                 
  416.                 if( SnapInputWrite < SnapInputRead )
  417.                 {
  418.                     InputBufferFreeSize = SnapInputRead - SnapInputWrite - 10;
  419.                 }
  420.                 else
  421.                 {
  422.                     InputBufferFreeSize = (U32)VideoInputBuffStop - SnapInputWrite + 1;
  423.                 }
  424.                 
  425.                 if(DmaTransferSize > InputBufferFreeSize)
  426.                 {
  427.                     DmaTransferSize = InputBufferFreeSize;
  428.                 }
  429.                 if(DmaTransferSize > 0x4000)
  430.                 {
  431.                     DmaTransferSize=0x4000;
  432.                 }
  433.                 
  434.                 /*cheng add for right DmaTransferSize-05/20/2006*/
  435.                 if (DmaTransferSize >= RemainingSourceDataSize)
  436.                 {
  437.                     DmaTransferSize = RemainingSourceDataSize;
  438.                     OneRound = TRUE; /* completed the first round of injection */
  439.                 }
  440.                 /*cheng add end*/
  441.                 
  442.                 /* INJECTION BY CPU */
  443.                 memcpy(/* dest */ (void*)SnapInputWrite,
  444.                     /* src  */ UserBufferCurrent_P,
  445.                     DmaTransferSize);
  446.                 /* INJECTION DONE */
  447.                 
  448.                 /* Push the W pointer in video input */
  449.                 if(( SnapInputWrite+ DmaTransferSize) > (U32)VideoInputBuffStop)
  450.                 {
  451.                     SnapInputWrite= (U32)VideoInputBuffStart;
  452.                 }
  453.                 else
  454.                 {
  455.                     SnapInputWrite=  SnapInputWrite + DmaTransferSize;
  456.                 }
  457.                 /* Share the new input ptr */
  458.                 VideoInputBuffWptr = (void*)SnapInputWrite;
  459. #if 1
  460.                 task_delay((30*DmaTransferSize/1024)/8/*(30*DmaTransferSize/1024)/8*/);
  461.                 
  462.                 task_delay(15625); /* temp delay, to be removed*/
  463. #endif
  464.                 
  465.                 /* push our injection ptr */
  466.                 UserBufferCurrent_P = (void*)((U32)UserBufferCurrent_P + DmaTransferSize);
  467.                 if((U32)UserBufferCurrent_P > (U32)UserBufferStop_p)
  468.                 {
  469.                     /*STTBX_Print(("injection loops the streamn"));*/
  470.                     UserBufferCurrent_P = UserBufferStart_p;
  471.                 }
  472.             }
  473. #if 1 /*LYNN COMMENT OFF*/
  474.                 }
  475.                 OneRound = FALSE; /* initialise for the next round of injection */
  476.             }
  477. #endif
  478. }
  480.         
  481.         
  482. /**************************
  483. * ST_ErrorCode_t Switch2Iframe
  484. *
  485. *
  486. *
  487. *
  488. ***************************/
  489. ST_ErrorCode_t Switch2Iframe(unsigned char *buffer,int number)
  490. {  
  491.     ST_ErrorCode_t ErrCode;
  492.     
  493.     
  494.     //STTBX_Print(("nnn ======== Switch2Iframe ( ) =========n"));
  495.     
  496.     /*IFrameStop();*/
  497.     
  498.     /*ErrCode = IFrameDecodeStart();
  499.     if(ErrCode != ST_NO_ERROR)
  500.     {
  501.     STTBX_Print((" Switch2Iframe ( ) -> IFrameDecodeStart() Err = %sn", KB_ErrorGetText(ErrCode)));
  502. } */
  503.     
  504.     ErrCode = BackGround_VID_StartDecode();
  505.     if(ErrCode != ST_NO_ERROR)
  506.     {
  507.         STTBX_Print((" Switch2Iframe ( ) -> BackGround_VID_StartDecode() Err = %sn", KB_ErrorGetText(ErrCode)));
  508.     }
  509.     
  510.     LoadIframe(buffer,number);
  511.     InjectIframe(4);
  512.     //STTBX_Print(("zxqCHK ---------> InjectIframe success; InjectIframe successnn"));  
  513.     
  514. #if 1
  515.     //STVID_DisableOutputWindow(VID_ViewPortHandle_Multiple[0]);
  516.     //ErrCode = STVID_EnableOutputWindow(VID_ViewPortHandle_Multiple[0]);
  517. #else
  518.     STVID_DisableOutputWindow(VID_ViewPortHandle);
  519. #endif
  520.     
  521.     if(ErrCode != ST_NO_ERROR)
  522.     {
  523.         STTBX_Print((" Switch2Iframe ( ) -> STVID_EnableOutputWindow() Err = %sn", KB_ErrorGetText(ErrCode)));
  524.     }
  525.     #if 0
  526.     gnAvVideoEnabled = FALSE;
  527.     gnAvVideoIframeEnabled = TRUE;
  528.     #endif
  529.     
  530.     //STTBX_Print(("n ==========================nnn"));
  531.     return ErrCode;
  532. }
  533.         
  534.         
  535. /**************************
  536. * ST_ErrorCode_t Switch2Live
  537. *
  538. *
  539. *
  540. *
  541. ***************************/
  543. ST_ErrorCode_t Switch2Live(void)
  544. {
  545.     ST_ErrorCode_t ErrCode;
  546.     //STVID_ClearParams_t  ClearParams;
  547.     
  548.     //STTBX_Print(("nnn ======== Switch2Live ( ) =========n"));
  549.     
  550.     
  551.     IFrameStop();
  552.     
  553.     ErrCode = LiveVideoStart();
  554.     if(ErrCode != TRUE)
  555.     {
  556.         STTBX_Print((" Switch2Live ( ) -> LiveVideoStart() Err = %sn", KB_ErrorGetText(ErrCode)));
  557.     }           
  558.     
  559.     //STTBX_Print(("n ==========================nnn"));
  560.     return ErrCode;
  561. }
  563. static void NewVideoFrameEvent(STEVT_CallReason_t Reason, const ST_DeviceName_t RegistrantName, STEVT_EventConstant_t Event, const void *EventData, const void *SubscriberData_p )
  564. {
  565.     ST_ErrorCode_t ErrCode;
  566.     ErrCode = ST_NO_ERROR;
  567.     
  568.     switch (Event)
  569.     {
  570.     case STVID_NEW_PICTURE_DECODED_EVT:
  571.         semaphore_signal(iframePicDecodeLock);
  572. #if 1
  573.         STVID_EnableOutputWindow(VID_ViewPortHandle_Multiple[0]);
  574. #endif
  575.         break;
  576.     case STVID_DISPLAY_NEW_FRAME_EVT:
  577.         STVID_EnableOutputWindow(VID_ViewPortHandle_Multiple[0]);  
  578.         break;
  579.     case STVID_STOPPED_EVT:
  580.         semaphore_signal(iframeStopDecodeLock);
  581.         break;
  582.     }
  583.     return;
  584. }
  587. extern ST_DeviceName_t g_KB_EVTDeviceName[];
  588. extern STEVT_Handle_t  g_KB_EVTHandle[1];
  591. void NewFrameEventSubsvribe( void )
  592. {
  593.     STEVT_DeviceSubscribeParams_t SubscribeParams;
  594.     memset(&SubscribeParams, 0, sizeof(STEVT_DeviceSubscribeParams_t));
  595.     SubscribeParams.NotifyCallback = NewVideoFrameEvent;
  596. STEVT_SubscribeDeviceEvent(g_KB_EVTHandle[0],  VID_DeviceName_Multiple[0], (U32)STVID_NEW_PICTURE_TO_BE_DISPLAYED_EVT, &SubscribeParams);
  597. }
  600. void NewFrameEventSubscribe( void )
  601. {
  602.     STEVT_DeviceSubscribeParams_t SubscribeParams;
  603.     
  604.     iframePicDecodeLock = semaphore_create_fifo_timeout(0);
  605.     iframeStopDecodeLock = semaphore_create_fifo_timeout(0);
  606.     
  607.     memset(&SubscribeParams, 0, sizeof(STEVT_DeviceSubscribeParams_t));
  608.     SubscribeParams.NotifyCallback = NewVideoFrameEvent;
  609.     STEVT_SubscribeDeviceEvent(g_KB_EVTHandle[0],  VID_DeviceName_Multiple[0], (U32)STVID_NEW_PICTURE_DECODED_EVT, &SubscribeParams);
  610. #if 1
  611.     STEVT_SubscribeDeviceEvent(g_KB_EVTHandle[0],  VID_DeviceName_Multiple[0], (U32)STVID_STOPPED_EVT, &SubscribeParams);
  612. #endif
  613.     
  614. }
  617. /* EOF */