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

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

DVD

开发平台：

C/C++

regevent.c：源码内容
  1. /*****************************************************************************
  3. File name  : regevent.c
  5. Description: Events related functions used by all test applications.
  7. COPYRIGHT (C) 2004 STMicroelectronics
  9. ******************************************************************************/
  11. /* Includes ---------------------------------------------------------------- */
  13. #include <time.h>
  14. #include <stdio.h>
  15. #include <string.h>
  16. #include <stdlib.h>
  17. #include <task.h>
  19. /* STAPI header------------------------------------------------------------- */
  20. #include "stddefs.h"
  21. #include "stlite.h"
  22. #include "stcommon.h"
  23. #include "stdevice.h"
  24. #include "sttbx.h"
  25. #include "stpti.h"
  27. #include "stpti_hal.h"
  28. #include "vid.h"
  29. #include "aud.h"
  30. #include "errors.h"
  31. #include "evt.h"
  32. #include "regevent.h"
  34. #ifdef TTX_SUPPORT
  35. #include "ttx.h"
  36. #endif /* TTX_SUPPORT */
  38. /* Private Types------------------------------------------------------------ */
  40. /* Private Constant--------------------------------------------------------- */
  42. /* Private Variables ------------------------------------------------------- */
  43. /* Required for Video */
  44. U32                      VideoEvent_STVID_NEW_PICTURE_TO_BE_DISPLAYED_EVT_Count   = 0;
  45. U32                      VideoEvent_Errors_Count = 0;
  46. STEVT_EventConstant_t    VideoEvent_NextToPrint  = 0;
  47. semaphore_t              AspectRatioChangedSem;
  48. STGXOBJ_AspectRatio_t    DisplayAspectRatio;
  50. /* Required for Audio */
  51. U32                      AudioEvent_STAUD_NEW_FRAME_EVT_Count = 0;
  52. U32                      AudioEvent_Errors_Count = 0;
  53. STEVT_EventConstant_t    AudioEvent_NextToPrint  = 0;
  55. /* Required for PTI */
  56. U32                      StptiEvent_Errors_Count = 0;
  57. STEVT_EventConstant_t    StptiEvent_NextToPrint  = 0;
  59. #ifdef TTX_SUPPORT
  61. /* Required for Tele Text */
  62. U32                      TeletextEvent_Errors_Count = 0;
  63. STEVT_EventConstant_t    TTXEvent_NextToPrint  = 0;
  65. #endif /* TTX_SUPPORT */
  67. /* Private Functions prototypes --------------------------------------------------- */
  68. /* video events */
  69. static void  VideoEvent_CallbackProc(STEVT_CallReason_t Reason, STEVT_EventConstant_t Event, const void *EventData );
  70. /* audio events */
  71. static void  AudioEvent_CallbackProc(STEVT_CallReason_t Reason, STEVT_EventConstant_t Event, const void *EventData );
  72. /* stpti events */
  73. static void  StptiEvent_CallbackProc(STEVT_CallReason_t Reason, STEVT_EventConstant_t Event, const void *EventData );
  75. #ifdef TTX_SUPPORT
  76. /* ttx events */
  77. static void TTXEvent_CallbackProc(STEVT_CallReason_t Reason, STEVT_EventConstant_t Event, const void *EventData );
  79. #endif /* TTX_SUPPORT */
  81. /*=========================================================================*/
  83. /* Function description */
  84. /*-------------------------------------------------------------------------
  85.  * Function : RegisterEvents
  86.  *
  87.  * Input    : None
  88.  * Output   :
  89.  * Return   : only returns if error when starting up.
  90.  * ----------------------------------------------------------------------*/
  91. ST_ErrorCode_t RegisterEvents(void)
  92. {
  93.     ST_ErrorCode_t                  ST_ErrorCode = ST_NO_ERROR;
  94.     STEVT_SubscribeParams_t         STEVT_SubscribeParams;
  95.     STVID_ConfigureEventParams_t    VID_EvtParams;
  96.     U32                             Event;
  98.     /* subscribe to stpti events */
  99.     STEVT_SubscribeParams.NotifyCallback = StptiEvent_CallbackProc;
  100.     for(Event = STPTI_EVENT_BASE; Event <= (int) STPTI_EVENT_TC_CODE_FAULT_EVT; Event++)
  101.     {
  102.         ST_ErrorCode = STEVT_Subscribe(g_KB_EVTHandle[KB_EVT_PTI], Event, &STEVT_SubscribeParams);
  103.         if ( ST_ErrorCode != ST_NO_ERROR )
  104.         {
  105.             STTBX_Print(("EVT_Subscribe(%d, STPTI)=%sn", Event, KB_ErrorGetText(ST_ErrorCode) ));
  106.             return ST_ErrorCode;
  107.         }
  108.     }
  110.     /* subscribe to audio events */
  111.     STEVT_SubscribeParams.NotifyCallback = AudioEvent_CallbackProc;
  112.     for(Event = STAUD_NEW_FRAME_EVT; Event <= STAUD_LOW_DATA_LEVEL_EVT; Event++)
  113.     {
  114.         ST_ErrorCode = STEVT_Subscribe(g_KB_EVTHandle[KB_EVT_AUD], Event, &STEVT_SubscribeParams);
  115.         if ( ST_ErrorCode != ST_NO_ERROR )
  116.         {
  117.             STTBX_Print(("EVT_Subscribe(%d, AUDIO)=%sn", Event, KB_ErrorGetText(ST_ErrorCode) ));
  118.             return ST_ErrorCode;
  119.         }
  120.     }
  122.     /* init the Aspect ratio semaphore */
  123.     semaphore_init_fifo_timeout ( &AspectRatioChangedSem, 0 );
  125.     /* subscribe to video events */
  126.     VID_EvtParams.Enable                = TRUE;
  127.     VID_EvtParams.NotificationsToSkip   = 0;
  129.     STEVT_SubscribeParams.NotifyCallback = VideoEvent_CallbackProc;
  130.     for(Event = STVID_ASPECT_RATIO_CHANGE_EVT; Event <= STVID_SYNCHRONISATION_CHECK_EVT; Event++)
  131.     {
  132.         /* STVID_NEW_PICTURE_TO_BE_DISPLAYED_EVT is to be removed as and when the STVID API removes it.*/
  133.         if ((Event == STVID_NEW_PICTURE_DECODED_EVT) ||
  134.             (Event == STVID_NEW_PICTURE_TO_BE_DISPLAYED_EVT) ||
  135.             (Event == STVID_DISPLAY_NEW_FRAME_EVT) ||
  136.             (Event == STVID_SYNCHRONISATION_CHECK_EVT))
  137.         {
  138.             ST_ErrorCode = STVID_ConfigureEvent(VID_Handle, Event, &VID_EvtParams);
  139.             if ( ST_ErrorCode != ST_NO_ERROR )
  140.             {
  141.                 STTBX_Print(("STVID_ConfigureEvent(%d, VIDEO)=%sn", Event, KB_ErrorGetText(ST_ErrorCode) ));
  142.                 return ST_ErrorCode;
  143.             }
  144.         }
  145.         ST_ErrorCode = STEVT_Subscribe(g_KB_EVTHandle[KB_EVT_VTG], Event, &STEVT_SubscribeParams);
  146.         if ( ST_ErrorCode != ST_NO_ERROR )
  147.         {
  148.             STTBX_Print(("EVT_Subscribe(%d, VIDEO)=%sn", Event, KB_ErrorGetText(ST_ErrorCode) ));
  149.             return ST_ErrorCode;
  150.         }
  151.     }
  153. #ifdef TTX_SUPPORT
  155.     /* subscribe to ttx events */
  156.     STEVT_SubscribeParams.NotifyCallback = TTXEvent_CallbackProc;
  157.     for(Event = STTTX_EVENT_PES_LOST; Event <= STTTX_EVENT_DATA_OVERFLOW; Event++)
  158.     {
  159.         ST_ErrorCode = STEVT_Subscribe(g_KB_EVTHandle[KB_EVT_TTX], Event, &STEVT_SubscribeParams);
  160.         if ( ST_ErrorCode != ST_NO_ERROR )
  161.         {
  162.             STTBX_Print(("EVT_Subscribe(%d, TTX)=%sn", Event, KB_ErrorGetText(ST_ErrorCode) ));
  163.             return ST_ErrorCode;
  164.         }
  165.     }
  167. #endif
  169.     return ST_ErrorCode;
  170. }
  173. /*-------------------------------------------------------------------------
  174.  * Function : VideoEvent_CallbackProc
  175.  * Input    : Event data
  176.  * Output   :
  177.  * Return   : nothing
  178.  * ----------------------------------------------------------------------*/
  179. static void VideoEvent_CallbackProc(STEVT_CallReason_t Reason, STEVT_EventConstant_t Event, const void *EventData )
  180. {
  181.     if (Reason == CALL_REASON_NOTIFY_CALL)
  182.     {
  183.         switch(Event)
  184.         {
  185.             case STVID_NEW_PICTURE_TO_BE_DISPLAYED_EVT:
  186.                 VideoEvent_STVID_NEW_PICTURE_TO_BE_DISPLAYED_EVT_Count++;
  187.                 AVHandleNewVideoFrame(Reason, Event, EventData);
  188.                 break;
  190.             case STVID_SYNCHRONISATION_CHECK_EVT:
  191.                 {
  192.                     STVID_SynchronisationInfo_t *SynchronisationInfo_p;
  194.                     SynchronisationInfo_p = (STVID_SynchronisationInfo_t *)EventData;
  196.                     if ((SynchronisationInfo_p->IsSynchronisationOk == TRUE) &&
  197.                         (SynchronisationInfo_p->ClocksDifference != 0))
  198.                     {
  200.                         (void) STAUD_DRSetSyncOffset(AUD_Handle,
  201.                                               STAUD_OBJECT_DECODER_COMPRESSED1,
  202.                                               SynchronisationInfo_p->ClocksDifference/90);
  204.                     }
  205.                 }
  206.                 break;
  208.             /* no reporting on these events */
  209.             case STVID_DISPLAY_NEW_FRAME_EVT: /* This Event Should be scraped. As it uses old types */
  210.             case STVID_NEW_PICTURE_DECODED_EVT:
  211.             case STVID_USER_DATA_EVT:
  212.             case STVID_SEQUENCE_INFO_EVT:
  213.             case STVID_SYNCHRO_EVT:
  214.                 break;
  216.             /* general report on these events with error count */
  217.             case STVID_IMPOSSIBLE_WITH_MEM_PROFILE_EVT:
  218.             /*     STTBX_Print(("n STVID_IMPOSSIBLE_WITH_MEM_PROFILE_EVT n"));*/
  219.             case STVID_DATA_ERROR_EVT:
  220.             /*STTBX_Print(("n STVID_DATA_ERROR_EVT n"));*/
  221.             case STVID_DATA_OVERFLOW_EVT:
  222.             /*STTBX_Print(("n STVID_DATA_OVERFLOW_EVT n"));*/
  223.             case STVID_DATA_UNDERFLOW_EVT:
  224.             /*STTBX_Print(("n STVID_DATA_UNDERFLOW_EVT n"));*/
  225.             case STVID_PICTURE_DECODING_ERROR_EVT:
  226.             /*STTBX_Print(("n STVID_PICTURE_DECODING_ERROR_EVT n"));*/
  227.                 VideoEvent_Errors_Count++;
  228.                 /* fall through (to report on other events below, without error counting) */
  230.             case STVID_BACK_TO_SYNC_EVT:
  231.             case STVID_DIGINPUT_WIN_CHANGE_EVT:
  232.             case STVID_FRAME_RATE_CHANGE_EVT:
  233.             case STVID_RESOLUTION_CHANGE_EVT:
  234.             case STVID_SPEED_DRIFT_THRESHOLD_EVT:
  235.             case STVID_STOPPED_EVT:
  236.             case STVID_OUT_OF_SYNC_EVT:
  237.                 /* only process if last Event printed out */
  238.                 if (VideoEvent_NextToPrint == LAST_EVENT_TO_PROCESS) VideoEvent_NextToPrint = Event;
  239.                 break;
  241.             case STVID_ASPECT_RATIO_CHANGE_EVT:
  242.                 DisplayAspectRatio = *((STGXOBJ_AspectRatio_t *)EventData);
  243.                 semaphore_signal ( &AspectRatioChangedSem );
  244.                 break;
  246.             case STVID_SCAN_TYPE_CHANGE_EVT:
  247.                 {
  248.                     /* Layer & Mixer are set to Interlaced scan type in their corresponding setups.
  249.                        Progressive scan type is not handled */
  250.                 }
  251.                 break;
  253.             default:
  254.                 break;
  255.         }
  257. //STTBX_Print(("nVID Event: %s n", VideoEvent_EventToStr(Event)));
  258.     }
  259. }
  261. /*-------------------------------------------------------------------------
  262.  * Function : AudioEvent_CallbackProc
  263.  * Input    : Event data
  264.  * Output   :
  265.  * Return   : nothing
  266.  * ----------------------------------------------------------------------*/
  267. static void AudioEvent_CallbackProc(STEVT_CallReason_t Reason, STEVT_EventConstant_t Event, const void *EventData )
  268. {
  269.     if (Reason == CALL_REASON_NOTIFY_CALL)
  270.     {
  271.         switch(Event)
  272.         {
  273.             case STAUD_NEW_FRAME_EVT:
  274.                 AudioEvent_STAUD_NEW_FRAME_EVT_Count++;
  275.                 break;
  277.             /* no reporting on these events */
  278.             case STAUD_EMPHASIS_EVT:
  279.             case STAUD_PREPARED_EVT:
  280.             case STAUD_RESUME_EVT:
  281.             case STAUD_PCM_BUF_COMPLETE_EVT:
  282.                 break;
  284.             /* general report on these events with error count */
  285.             case STAUD_DATA_ERROR_EVT:
  286.             case STAUD_SYNC_ERROR_EVT:
  287.                 AudioEvent_Errors_Count++;
  288.                 /* fall through (to report on other events below, without error counting) */
  290.             case STAUD_STOPPED_EVT:
  291.             case STAUD_NEW_ROUTING_EVT:
  292.             case STAUD_NEW_FREQUENCY_EVT:
  293.             case STAUD_LOW_DATA_LEVEL_EVT:
  294.             case STAUD_PCM_UNDERFLOW_EVT:
  295.             case STAUD_FIFO_OVERF_EVT:
  296.             case STAUD_CDFIFO_UNDERFLOW_EVT:
  297.                 /* only process if last Event printed out */
  298.                 if (AudioEvent_NextToPrint == LAST_EVENT_TO_PROCESS) AudioEvent_NextToPrint = Event;
  299.                 break;
  301.             default:
  302.                 break;
  303.         }
  304.     }
  305.  }
  308. /*-------------------------------------------------------------------------
  309.  * Function : StptiEvent_CallbackProc
  310.  * Input    : Event data
  311.  * Output   :
  312.  * Return   : nothing
  313.  * ----------------------------------------------------------------------*/
  314. static void StptiEvent_CallbackProc(STEVT_CallReason_t Reason, STEVT_EventConstant_t Event, const void *EventData )
  315. {
  316.     if (Reason == CALL_REASON_NOTIFY_CALL)
  317.     {
  318.         switch(Event)
  319.         {
  320.             /* no reporting on these events */
  321.             #ifdef STPTI_CAROUSEL_SUPPORT
  322.                case STPTI_EVENT_CAROUSEL_CYCLE_COMPLETE_EVT:
  323.                case STPTI_EVENT_CAROUSEL_ENTRY_TIMEOUT_EVT:
  324.                case STPTI_EVENT_CAROUSEL_TIMED_ENTRY_EVT:
  325.             #endif
  326.             #ifdef STPTI_INDEX_SUPPORT
  327.                case STPTI_EVENT_INDEX_MATCH_EVT:
  328.             #endif
  329.             #ifdef STPTI_DTV_SUPPORT
  330.                case STPTI_EVENT_CWP_BLOCK_EVT:
  331.             #endif
  332.             case STPTI_EVENT_CLEAR_TO_SCRAMBLED_EVT:
  333.             case STPTI_EVENT_DMA_COMPLETE_EVT:
  334.             case STPTI_EVENT_PCR_RECEIVED_EVT:
  335.             case STPTI_EVENT_SCRAMBLED_TO_CLEAR_EVT:
  336.                 break;
  338.             /* general report on these events with error count */
  339.             case STPTI_EVENT_CC_ERROR_EVT:
  340.                 (void) STPTI_EnableErrorEvent(KB_PTI_DeviceName, STPTI_EVENT_CC_ERROR_EVT);
  341.                 /* fall through to increment the error count */
  342.             case STPTI_EVENT_BUFFER_OVERFLOW_EVT:
  343.             case STPTI_EVENT_INTERRUPT_FAIL_EVT:
  344.             case STPTI_EVENT_INVALID_DESCRAMBLE_KEY_EVT:
  345.             case STPTI_EVENT_INVALID_LINK_EVT:
  346.             case STPTI_EVENT_INVALID_PARAMETER_EVT:
  347.             case STPTI_EVENT_PACKET_ERROR_EVT:
  348.             case STPTI_EVENT_SECTIONS_DISCARDED_ON_CRC_CHECK_EVT:
  349.             case STPTI_EVENT_TC_CODE_FAULT_EVT:
  350.                 StptiEvent_Errors_Count++;
  352.                 /* only process if last Event printed out */
  353.                 if (StptiEvent_NextToPrint == LAST_EVENT_TO_PROCESS) StptiEvent_NextToPrint = Event;
  354.                 break;
  356.             default:
  357.                 break;
  358.         }
  359.     }
  360. }
  362. #ifdef TTX_SUPPORT
  364. /*-------------------------------------------------------------------------
  365.  * Function : TTXEvent_CallbackProc
  366.  * Input    : event data
  367.  * Output   :
  368.  * Return   : nothing
  369.  * ----------------------------------------------------------------------*/
  370. static void TTXEvent_CallbackProc(STEVT_CallReason_t Reason, STEVT_EventConstant_t Event, const void *EventData )
  371. {
  372.     if (Reason == CALL_REASON_NOTIFY_CALL)
  373.     {
  374.         switch(Event)
  375.         {
  376.             /* no reporting on these events */
  377.             case STTTX_EVENT_PACKET_DISCARDED:
  378.             case STTTX_EVENT_PACKET_CONSUMED:
  379.             case STTTX_EVENT_PES_AVAILABLE:
  380.                 break;
  382.             /* report on other events below (without error counting) */
  383.             case STTTX_EVENT_PES_LOST:
  384.             case STTTX_EVENT_PES_NOT_CONSUMED:
  385.             case STTTX_EVENT_PES_INVALID:
  386.             case STTTX_EVENT_DATA_OVERFLOW:
  387.                 TeletextEvent_Errors_Count ++;
  388.                 if (TTXEvent_NextToPrint == 0) TTXEvent_NextToPrint = Event;  /* only process if last event printed out */
  389.                 break;
  391.             default:
  392.                 break;
  393.         }
  394.     }
  395. }
  397. #endif /* TTX_SUPPORT */
  399. /*-------------------------------------------------------------------------
  400.  * Function : VideoEvent_EventToStr
  401.  * Input    : Event data
  402.  * Output   :
  403.  * Return   : string
  404.  * ----------------------------------------------------------------------*/
  405. char *VideoEvent_EventToStr(STEVT_EventConstant_t Event)
  406. {
  407.     switch(Event)
  408.     {
  409.         case STVID_DISPLAY_NEW_FRAME_EVT:
  410.             return("STVID_DISPLAY_NEW_FRAME_EVT");
  411.         case STVID_IMPOSSIBLE_WITH_MEM_PROFILE_EVT:
  412.             return("STVID_IMPOSSIBLE_WITH_MEM_PROFILE_EVT");
  413.         case STVID_DATA_ERROR_EVT:
  414.             return("STVID_DATA_ERROR_EVT");
  415.         case STVID_DATA_OVERFLOW_EVT:
  416.             return("STVID_DATA_OVERFLOW_EVT");
  417.         case STVID_DATA_UNDERFLOW_EVT:
  418.             return("STVID_DATA_UNDERFLOW_EVT");
  419.         case STVID_PICTURE_DECODING_ERROR_EVT:
  420.             return("STVID_PICTURE_DECODING_ERROR_EVT");
  421.         case STVID_ASPECT_RATIO_CHANGE_EVT:
  422.             return("STVID_ASPECT_RATIO_CHANGE_EVT");
  423.         case STVID_BACK_TO_SYNC_EVT:
  424.             return("STVID_BACK_TO_SYNC_EVT");
  425.         case STVID_DIGINPUT_WIN_CHANGE_EVT:
  426.             return("STVID_DIGINPUT_WIN_CHANGE_EVT");
  427.         case STVID_FRAME_RATE_CHANGE_EVT:
  428.             return("STVID_FRAME_RATE_CHANGE_EVT");
  429.         case STVID_NEW_PICTURE_TO_BE_DISPLAYED_EVT:
  430.             return("STVID_NEW_PICTURE_TO_BE_DISPLAYED_EVT");
  431.         case STVID_NEW_PICTURE_DECODED_EVT:
  432.             return("STVID_NEW_PICTURE_DECODED_EVT");
  433.         case STVID_RESOLUTION_CHANGE_EVT:
  434.             return("STVID_RESOLUTION_CHANGE_EVT");
  435.         case STVID_SCAN_TYPE_CHANGE_EVT:
  436.             return("STVID_SCAN_TYPE_CHANGE_EVT");
  437.         case STVID_SEQUENCE_INFO_EVT:
  438.             return("STVID_SEQUENCE_INFO_EVT");
  439.         case STVID_SPEED_DRIFT_THRESHOLD_EVT:
  440.             return("STVID_SPEED_DRIFT_THRESHOLD_EVT");
  441.         case STVID_STOPPED_EVT:
  442.             return("STVID_STOPPED_EVT");
  443.         case STVID_OUT_OF_SYNC_EVT:
  444.             return("STVID_OUT_OF_SYNC_EVT");
  445.         case STVID_SYNCHRO_EVT:
  446.             return("STVID_SYNCHRO_EVT");
  447.         case STVID_USER_DATA_EVT:
  448.             return("STVID_USER_DATA_EVT");
  449.         case STVID_SYNCHRONISATION_CHECK_EVT:
  450.             return("STVID_SYNCHRONISATION_CHECK_EVT");
  451.         default:
  452.             break;
  453.     }
  454.     return("VID?");
  455. }
  457. /*-------------------------------------------------------------------------
  458.  * Function : AudioEvent_EventToStr
  459.  * Input    : Event data
  460.  * Output   :
  461.  * Return   : string
  462.  * ----------------------------------------------------------------------*/
  463. char *AudioEvent_EventToStr(STEVT_EventConstant_t Event)
  464. {
  465.     switch(Event)
  466.     {
  467.         case STAUD_NEW_FRAME_EVT:
  468.             return("STAUD_NEW_FRAME_EVT");
  469.         case STAUD_DATA_ERROR_EVT:
  470.             return("STAUD_DATA_ERROR_EVT");
  471.         case STAUD_EMPHASIS_EVT:
  472.             return("STAUD_EMPHASIS_EVT");
  473.         case STAUD_PREPARED_EVT:
  474.             return("STAUD_PREPARED_EVT");
  475.         case STAUD_RESUME_EVT:
  476.             return("STAUD_RESUME_EVT");
  477.         case STAUD_STOPPED_EVT:
  478.             return("STAUD_STOPPED_EVT");
  479.         case STAUD_PCM_UNDERFLOW_EVT:
  480.             return("STAUD_PCM_UNDERFLOW_EVT");
  481.         case STAUD_PCM_BUF_COMPLETE_EVT:
  482.             return("STAUD_PCM_BUF_COMPLETE_EVT");
  483.         case STAUD_FIFO_OVERF_EVT:
  484.             return("STAUD_FIFO_OVERF_EVT");
  485.         case STAUD_NEW_ROUTING_EVT:
  486.             return("STAUD_NEW_ROUTING_EVT");
  487.         case STAUD_NEW_FREQUENCY_EVT:
  488.             return("STAUD_NEW_FREQUENCY_EVT");
  489.         case STAUD_CDFIFO_UNDERFLOW_EVT:
  490.             return("STAUD_CDFIFO_UNDERFLOW_EVT");
  491.         case STAUD_SYNC_ERROR_EVT:
  492.             return("STAUD_SYNC_ERROR_EVT");
  493.         case STAUD_LOW_DATA_LEVEL_EVT:
  494.             return("STAUD_LOW_DATA_LEVEL_EVT");
  495.         default:
  496.             break;
  497.     }
  498.     return("AUD?");
  499. }
  501. /*-------------------------------------------------------------------------
  502.  * Function : StptiEvent_EventToStr
  503.  * Input    : Event data
  504.  * Output   :
  505.  * Return   : string
  506.  * ----------------------------------------------------------------------*/
  507. char *StptiEvent_EventToStr(STEVT_EventConstant_t Event)
  508. {
  509.     switch(Event)
  510.     {
  512.         case STPTI_EVENT_BUFFER_OVERFLOW_EVT:
  513.             return("STPTI_EVENT_BUFFER_OVERFLOW_EVT");
  514.         #ifdef STPTI_CAROUSEL_SUPPORT
  515.             case STPTI_EVENT_CAROUSEL_CYCLE_COMPLETE_EVT:
  516.                 return("STPTI_EVENT_CAROUSEL_CYCLE_COMPLETE_EVT");
  517.             case STPTI_EVENT_CAROUSEL_ENTRY_TIMEOUT_EVT:
  518.                 return("STPTI_EVENT_CAROUSEL_ENTRY_TIMEOUT_EVT");
  519.             case STPTI_EVENT_CAROUSEL_TIMED_ENTRY_EVT:
  520.                 return("STPTI_EVENT_CAROUSEL_TIMED_ENTRY_EVT");
  521.         #endif
  522.         case STPTI_EVENT_CC_ERROR_EVT:
  523.             return("STPTI_EVENT_CC_ERROR_EVT");
  524.         case STPTI_EVENT_CLEAR_TO_SCRAMBLED_EVT:
  525.             return("STPTI_EVENT_CLEAR_TO_SCRAMBLED_EVT");
  526.         #ifdef STPTI_DTV_SUPPORT
  527.            case STPTI_EVENT_CWP_BLOCK_EVT:
  528.               return("STPTI_EVENT_CWP_BLOCK_EVT");
  529.         #endif
  530.         case STPTI_EVENT_DMA_COMPLETE_EVT:
  531.             return("STPTI_EVENT_DMA_COMPLETE_EVT");
  532.         #ifdef STPTI_INDEX_SUPPORT
  533.             case STPTI_EVENT_INDEX_MATCH_EVT:
  534.                return("STPTI_EVENT_INDEX_MATCH_EVT");
  535.         #endif
  536.         case STPTI_EVENT_INTERRUPT_FAIL_EVT:
  537.             return("STPTI_EVENT_INTERRUPT_FAIL_EVT");
  538.         case STPTI_EVENT_INVALID_DESCRAMBLE_KEY_EVT:
  539.             return("STPTI_EVENT_INVALID_DESCRAMBLE_KEY_EVT");
  540.         case STPTI_EVENT_INVALID_LINK_EVT:
  541.             return("STPTI_EVENT_INVALID_LINK_EVT");
  542.         case STPTI_EVENT_INVALID_PARAMETER_EVT:
  543.             return("STPTI_EVENT_INVALID_PARAMETER_EVT");
  544.         case STPTI_EVENT_PACKET_ERROR_EVT:
  545.             return("STPTI_EVENT_PACKET_ERROR_EVT");
  546.         case STPTI_EVENT_PCR_RECEIVED_EVT:
  547.             return("STPTI_EVENT_PCR_RECEIVED_EVT");
  548.         case STPTI_EVENT_SCRAMBLED_TO_CLEAR_EVT:
  549.             return("STPTI_EVENT_SCRAMBLED_TO_CLEAR_EVT");
  550.         case STPTI_EVENT_SECTIONS_DISCARDED_ON_CRC_CHECK_EVT:
  551.             return("STPTI_EVENT_SECTIONS_DISCARDED_ON_CRC_CHECK_EVT");
  552.         case STPTI_EVENT_TC_CODE_FAULT_EVT:
  553.             return("STPTI_EVENT_TC_CODE_FAULT_EVT");
  554.         default:
  555.             break;
  556.     }
  557.     return("STPTI?");
  558. }
  561. #ifdef TTX_SUPPORT
  563. /*-------------------------------------------------------------------------
  564.  * Function : TTXEvent_EventToStr
  565.  * Input    : event data
  566.  * Output   :
  567.  * Return   : string
  568.  * ----------------------------------------------------------------------*/
  569. char *TTXEvent_EventToStr(STEVT_EventConstant_t Event)
  570. {
  571.     switch(Event)
  572.     {
  573.         case STTTX_EVENT_PES_LOST:
  574.             return("STTTX_EVENT_PES_LOST");
  575.         case STTTX_EVENT_PES_NOT_CONSUMED:
  576.             return("STTTX_EVENT_PES_NOT_CONSUMED");
  577.         case STTTX_EVENT_PES_INVALID:
  578.             return("STTTX_EVENT_PES_INVALID");
  579.         case STTTX_EVENT_PES_AVAILABLE:
  580.             return("STTTX_EVENT_PES_AVAILABLE");
  581.         case STTTX_EVENT_PACKET_DISCARDED:
  582.             return("STTTX_EVENT_PACKET_DISCARDED");
  583.         case STTTX_EVENT_PACKET_CONSUMED:
  584.             return("STTTX_EVENT_PACKET_CONSUMED");
  585.         case STTTX_EVENT_DATA_OVERFLOW:
  586.             return("STTTX_EVENT_DATA_OVERFLOW");
  587.         default:
  588.             break;
  589.     }
  590.     return("TTX?");
  591. }
  593. #endif /* TTX_SUPPORT */
  595. /* EOF --------------------------------------------------------------------- */