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

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

DVD

开发平台：

C/C++

avplay.c：源码内容
  1. #include <string.h>
  3. #include "avplay.h"
  4. #include "db.h"
  5. #include "dmd.h"
  6. #include "db.h"
  7. #include "appltype.h"
  8. #include "av.h"
  9. #include "epg.h" 
  10. #include "timeclk.h"
  12. #include "ca_user.h"
  14. #include <string.h>
  16. #include "sipsi.h"
  17. #include "timer.h"
  18. #include "KB_MenuData.h"
  19. #include "kb_machblue_client_task.h"
  22. #define J_PLAY_USE_PID FALSE
  23. //#define J_PLAY_USE_PID TRUE
  26. typedef enum
  27. {
  28.     PLAY_START,
  29.     PLAY_STOP,
  30.     PLAY_PAUSE,
  31.     PLAY_RESUME,
  32.     PLAY_START_IFRAME,
  33.     PLAY_STOP_IFRAME
  34. }PlayRequest;
  36. typedef struct
  37. {
  38.     INT32 nTsId;
  39.     INT32 nPgmNum;
  40. INT32 nPmtPid;
  41. INT32 nVideoPid;
  42. INT32 nAudioPid;
  43. INT32 nPcrPid;
  44. INT32 nCaFlag;
  45. }DTV_AVINFO;
  47. static UINT32 gDtvTaskID;
  48. static UINT32 gDtvQueID;
  50. static KB_SIPatStruct   gDtvPat;
  51. static KB_SIPmtStruct   gDtvPmt;
  52. static KB_SICatStruct   gDtvCat;
  53. static KB_SIPmtStruct   gDtvPrePmt;
  54. static KB_SICatStruct   gDtvPreCat;
  56. static DTV_AVINFO gCurPrg;
  58. static KB_DTVRunCallback gDtvCallBack;
  60. static UINT32 gDtvPmtTimer = 0xffffffff;
  61. static UINT32 gDtvCatTimer = 0xffffffff;
  62. static KB_DTVPrgAVInfo gPrePrgInfo;
  63. static KB_DTVPrgAVInfo gCurPrgInfo;
  65. static KB_DTVStatus gPlayStatus;
  66. time_t  g_avTime;
  67. static KB_DBPrgNode gtPgmNode;
  68. static KB_DBPRGPID gPgmPid;
  71. static UINT8 gCurTrace;
  72. static UINT8 gCurVolume = 20;
  73. static INT32 gMuteFlag;
  74. static INT32 gPrgClass[2];
  76. static void DTV_HandleTuner(KB_OSPMsgNode *pInMsg);
  77. static void DTV_HandleSI_AV(KB_OSPMsgNode *pInMsg);
  78. static void DTV_HandleTuner_AV(KB_OSPMsgNode *pInMsg);
  79. static void DTV_HandleMsg_2(KB_OSPMsgNode *pInMsg);
  80. //static void DTV_ChangeType(INT32 nOldType, INT32 nNewType);
  81. static void DTV_AVCallbackHandle(int intype);
  82. static void  DTV_Task(void);
  83. static INT32 DTV_HandleMsg_1(KB_OSPMsgNode *pInMsg);
  84. static INT32 DTV_HandleSI(KB_OSPMsgNode *pInMsg);
  85. static INT32 DTV_HandlePmt(KB_OSPMsgNode *pInMsg);
  86. static INT32 DTV_GetPmtPid(INT32 nSvcNO);
  87. static void  DTV_CallbackHandle(INT32 nSuccess, 
  88.                                INT32 nHours, 
  89.                                INT32 nMinutes, 
  90.                                INT32 nSeconds);
  91. static void  DTV_PmtTimer(void);
  92. static void  DTV_CatTimer(void);
  93. static INT32 DTV_HandleCat(KB_OSPMsgNode *pInMsg);
  94. static KB_DTVSinglePrgInfo gPrePrg;
  95. static KB_DTVSinglePrgInfo gRetPrg;
  97. extern void KB_MENUTranslateMsg(KB_OSPMsgNode* pInMsg);
  98. extern void kb_mb_service_context_evaluation(int serviceIndex,int service_type);
  99. extern INT32 STB_StateSwitch(INT32 nApplet);
  100. extern void LED_ShowString(char *str);
  103. INT32 KB_DTVInit(void)
  104. {
  105.     memset(&gPrePrgInfo, 0, sizeof(KB_DTVPrgAVInfo));
  106.     memset(&gCurPrgInfo,0, sizeof(KB_DTVPrgAVInfo));
  107.     
  108.     gMuteFlag   = FALSE;
  110.     gPrePrg.prgType = 0xFFFFFFFF;
  111.     gPrePrg.ndtvNO    = 0xFFFFFFFF;
  112.     gPrePrg.nradNO = 0xFFFFFFFF;
  113.     
  114.     gRetPrg.prgType = 0xFFFFFFFF;
  115.     gRetPrg.ndtvNO    = 0xFFFFFFFF;
  116.     gRetPrg.nradNO = 0xFFFFFFFF;    
  117.     
  118.     KB_DTVMute(FALSE);
  120.     KB_OSPQueInit("PLAY", 64, &gDtvQueID);
  121.     KB_OSPTaskInit("PLAY",
  122.                      1024 * 32,
  123.                      (void (*)(void*))DTV_Task,
  124.                      PLAY_PRIORITY,
  125.                      NULL,
  126.                      &gDtvTaskID);
  128.     gDtvPmtTimer = KB_TimerCreate(KB_TIMER_REPEAT, 
  129.                                     (KB_TIMER_FUNC_POINTER)DTV_PmtTimer, 
  130.                                     NULL);
  131.     gDtvCatTimer = KB_TimerCreate(KB_TIMER_REPEAT, 
  132.                                     (KB_TIMER_FUNC_POINTER)DTV_CatTimer, 
  133.                                     NULL);
  134.     
  135.     memset(&gCurPrg, 0, sizeof(DTV_AVINFO));
  137.     gDtvCallBack = NULL;
  138.     KB_AVHandlePlayState(DTV_CallbackHandle);
  140.     return RETOK;
  141. }
  143. INT32 KB_DTVCreate(void)
  144. {        
  145.     KB_EpgCallBack(DTV_HandleTuner_AV);
  146.     KB_DTVCallBack(DTV_AVCallbackHandle);
  147.     
  148.     KB_SIGetTime(&g_avTime);
  150.     if (gCurPrgInfo.prgNO == 0xFFFFFFFF)
  151.     {
  152.         KB_DTVSetPreChnnl();
  153.     }
  154.     
  155.     KB_DTVRun();
  156.     KB_DTVGetEitPF();
  157.     
  158.     return RETOK;    
  159. }
  161. INT32 KB_DTVDestroy(void)
  162. {
  163.     KB_DTVStopAV();
  164.     return RETOK;    
  165. }
  167. INT32 KB_DTVAVHandleMsg(KB_OSPMsgNode *pInMsg)
  168. {
  169.     switch (pInMsg->Word1)
  170.     {
  171.     case MOD_TUNER:
  172.         DTV_HandleTuner(pInMsg);
  173.         break;
  175.     case MOD_SIPSI:
  176.         DTV_HandleSI_AV(pInMsg);
  177.         KB_DTVHandleMsg(pInMsg);
  178.         break;
  180.     case J_EPG_MODULE:
  181.         DTV_HandleTuner_AV(pInMsg);
  182.         break;
  183.     case J_AVAPPLET_MODULE:
  184.         DTV_HandleMsg_2(pInMsg);
  185.         break;
  186.         
  187.     default:
  188.         break;
  189.     }
  190.     return RETOK;    
  191. }
  193. INT32 KB_DTVSetPreChnnl(void)
  194. {
  195.     INT32 prgType, nProgram, nTotalProgram;
  196.     
  197.     prgType = KB_DTVGetPrePrgType();
  198.     switch (prgType)
  199.     {
  200.     case DTVPRG:
  201.         nProgram = KB_DTVGetPreDtvNO();
  202.         break;
  204.     case RADIOPRG:
  205.         nProgram = KB_DTVGetPreRadNO();
  206.         break;
  208.     default:
  209.         prgType = DTVPRG;
  210.         nProgram     = 1;
  211.         break;
  212.     }
  213.     
  214. nTotalProgram = KB_DBGetPrgTotal((UINT8)prgType);
  215. if (nProgram > nTotalProgram || nProgram <= 0)
  216. {
  217. nProgram = 1;
  218. }
  221.     KB_DTVSetPrg((int)prgType, (int)nProgram);
  222.     
  223.     return RETOK;    
  224. }
  226. static void KB_ProcDtvrunCheck(int PrgType, int PrgNO)
  227. {
  228.     INT32 nTotal = 0;
  229.     
  230.     if (PrgType != DTVPRG && PrgType != RADIOPRG)
  231.     {
  232.         printf("nKB_ProcDtvrunCheck::input prgType(%d) error!", PrgType);
  233.         
  234.         PrgType = DTVPRG;
  235.         PrgNO   = 1;
  236.         nTotal = KB_DBGetPrgTotal(PrgType);
  237.         if (nTotal > KB_DB_MAX_DTV || 0 == nTotal)
  238.         {
  239.             printf("nKB_ProcDtvrunCheck::There is no way now, dtv total(%d)!", nTotal);
  240.             return;
  241.         }
  242.         KB_DTVSetPrg(PrgType, PrgNO);
  243.         return;
  244.     }
  246.     nTotal = KB_DBGetPrgTotal(PrgType);
  247.     if (DTVPRG == PrgType)
  248.     {
  249.         if (nTotal > KB_DB_MAX_DTV || 0 == nTotal)
  250.         {
  251.             printf("nKB_ProcDtvrunCheck::dtv nTotal(%d) error!", nTotal);
  252.             return;
  253.         }
  254.     }
  255.     else if (RADIOPRG == PrgType)
  256.     {
  257.         if (nTotal > KB_DB_MAX_RAD || 0 == nTotal)
  258.         {
  259.             printf("nKB_ProcDtvrunCheck::rad nTotal(%d) error!", nTotal);
  260.             return;
  261.         }
  262.     }
  263.     else
  264.     {
  265.         printf("nKB_ProcDtvrunCheck::PrgType(%d) error", PrgType);
  266.         return;
  267.     }
  269.     if (PrgNO > nTotal)
  270.     {
  271.         PrgNO = 1;
  272.         KB_DTVSetPrg(PrgType, PrgNO);
  273.     }
  275.     return;
  276. }
  279. INT32 KB_DTVSetPrg(int prgType, int prgNO)
  280. {  
  281.     if (prgType != DTVPRG && prgType != RADIOPRG)
  282.     {
  283.         return RETFAIL3;
  284.     }
  286.     if (gPrePrgInfo.prgType == prgType
  287.         && gPrePrgInfo.prgNO == prgNO)
  288.     {
  289.         return RETOK;
  290.     }
  291.     
  292.     gPrePrgInfo.prgType = prgType;
  293.     gPrePrgInfo.prgNO = prgNO;
  295.     gRetPrg.prgType = gPrePrg.prgType;        
  296.     gPrePrg.prgType = prgType;
  297.     
  298.     if (prgType == DTVPRG)
  299.     {
  300.         if (gRetPrg.ndtvNO != gPrePrg.ndtvNO)
  301.         {
  302.             gRetPrg.ndtvNO = gPrePrg.ndtvNO;
  303.         }
  304.         gPrePrg.ndtvNO = prgNO;        
  305.     }
  306.     else
  307.     {
  308.         if (gRetPrg.nradNO != gPrePrg.nradNO)
  309.         {
  310.             gRetPrg.nradNO = gPrePrg.nradNO;
  311.         }
  312.         gPrePrg.nradNO = prgNO;        
  313.     }
  315.     return RETOK;    
  316. }
  318. INT32 KB_DTVGetPrg(int *pPrgType, int *pPrgNO)
  319. {
  320.     *pPrgType = gPrePrgInfo.prgType;
  321.     *pPrgNO  = gPrePrgInfo.prgNO;
  322.     return RETOK;    
  323. }
  325. INT32 KB_DTVGetPreDtvNO(void)
  326. {
  327.     return gPrePrg.ndtvNO;
  328. }
  330. INT32 KB_DTVGetPreRadNO(void)
  331. {
  332.     return gPrePrg.nradNO;
  333. }
  335. void PlayCurrectProgram(void)
  336. {
  337. KB_DTVStart(gtPgmNode.Video_Pid, gtPgmNode.Audio_Pid, gtPgmNode.PCR_Pid);
  339. }
  341. INT32 KB_DTVGetPrePrgType(void)
  342. {
  343.     return gPrePrg.prgType;
  344. }
  346. static void DTV_HandleTuner(KB_OSPMsgNode *pInMsg)
  347. {
  348.     switch (pInMsg->Word2)
  349.     {
  350.     case DMD_CALLBACK_SIGNAL_CONNECTED:
  351.         gPlayStatus = KB_DTVRUN;
  352.         #if (J_PLAY_USE_PID == TRUE)
  353.         {
  354.             KB_DTVStart(gPgmPid.Video_Pid, gPgmPid.Audio_Pid, gPgmPid.PCR_Pid);
  355.         }
  356.         #else
  357.         {
  358.            KB_DTVStartCA(0, gCurPrgInfo.nSvcID);
  359.         }
  360.         #endif
  361.         KB_MENUTranslateMsg(pInMsg);
  362.         break;
  364.     case DMD_CALLBACK_SIGNAL_LOST:
  365. {
  366.             KB_MENUTranslateMsg(pInMsg);
  367. }
  368.         break;
  369.         
  370.     default:
  371.         break;
  372.     }
  373.     return;
  374. }
  376. INT32 KB_DTVRun(void)
  377. {
  378.     KB_DMDTunerParameters tTs;
  379.     //INT32 nSvcID;
  380. UINT16 ndbTIMER_Mode;
  381. KB_OSPMsgNode msg;
  382. KB_ProcDtvrunCheck(gPrePrgInfo.prgType, gPrePrgInfo.prgNO);
  384.     ndbTIMER_Mode = KB_DBGetChnlInfoByPrgNO(gPrePrgInfo.prgType, gPrePrgInfo.prgNO, 
  385.                                       &gPrePrgInfo.nFrequency, &gPrePrgInfo.nSymbol, 
  386.                                       &gPrePrgInfo.nQamTyep);  
  388.     gPrePrgInfo.nSvcID = KB_DBGetSvcIDByNO(gPrePrgInfo.prgType, 
  389.                                         gPrePrgInfo.prgNO - 1);    
  391.     if (gPrePrgInfo.prgType == gCurPrgInfo.prgType 
  392.         && gPrePrgInfo.prgNO == gCurPrgInfo.prgNO
  393.         && gPrePrgInfo.nSvcID== gCurPrgInfo.nSvcID
  394.         && gPlayStatus == KB_DTVRUN)
  395.     {
  396.         return RETOK;
  397.     }
  398. KB_CAService(KB_CA_CLOSE,0);
  399. KB_DTVStop();
  400.     if ((KB_AVGetIFrameFlag() == FALSE) 
  401.         && gPrePrgInfo.prgType == RADIOPRG)
  402.     {
  403.      //KB_DTVStop();
  404.      KB_AVPlayIFrame((UINT8 *)IFrmae_Logo_Data, 
  405.                           IFrmae_Logo_Data_length);
  406.     }
  408. if ((KB_AVGetIFrameFlag() == TRUE)
  409. && gPrePrgInfo.prgType == DTVPRG)
  410. {
  411. //KB_DTVStop();
  412.         KB_AVStopIFrame();
  413. }
  415.     KB_DBSaveCurPrgInfo(gPrePrgInfo.prgNO, 
  416.                                  gPrePrgInfo.prgType);
  417.         
  418.     gCurPrgInfo.prgType = gPrePrgInfo.prgType;
  419.     gCurPrgInfo.prgNO  = gPrePrgInfo.prgNO;
  420.     gCurPrgInfo.nSvcID   = gPrePrgInfo.nSvcID;
  423.     //added by whale 07/06/03
  424.     //KB_DBGetVolumeByPrgNo(&gCurVolume, gPrePrgInfo.prgType,gPrePrgInfo.prgNO);
  426.     //added by yyj 2007.6.14
  427.     KB_DBGetPgmCurVol(&gCurVolume);
  428.     KB_DTVSetVolume(gCurVolume);   
  429.     //printf("n[KB_DTVRun]:gCurVolume=%dn",gCurVolume);
  431.     gCurTrace = KB_DTVGetTrack();
  432.     KB_AVSetPrgTrack(gCurTrace);
  434. KB_DBGetPrgAvInfoByPrgNo(gPrePrgInfo.prgType,gPrePrgInfo.prgNO,&gPgmPid);
  436.     gPlayStatus = KB_DTVSTOP;
  437.     //KB_DTVStop();
  438.     KB_EPGStopAllEITPF();
  439.     
  440.     if (gPrePrgInfo.nFrequency == gCurPrgInfo.nFrequency
  441.         && gPrePrgInfo.nSymbol == gCurPrgInfo.nSymbol
  442.         && gPrePrgInfo.nQamTyep == gCurPrgInfo.nQamTyep)
  443.     {           
  444.         KB_DMDGetSignalParameters(&tTs);
  445.         if (KB_DMDQuerySignalStatus() == TRUE
  446.             && tTs.frequency == gCurPrgInfo.nFrequency / 1000
  447.             && tTs.details.qam.symbolRatekSs == gCurPrgInfo.nSymbol / 1000
  448.             && tTs.details.qam.modulation    == gCurPrgInfo.nQamTyep)
  449.         {
  450.             gPlayStatus = KB_DTVRUN;
  451.             #if (J_PLAY_USE_PID == TRUE)
  452.             {
  453.                 KB_DTVStart(gPgmPid.Video_Pid, gPgmPid.Audio_Pid, gPgmPid.PCR_Pid);
  454.             }
  455.             #else
  456.             {
  457.                 KB_DTVStartCA(0, gCurPrgInfo.nSvcID);
  458.             }
  459.             #endif
  460.         }
  461.         else
  462.         {
  463.             tTs.type      = DMD_TYPE_QAM;
  464.             tTs.inversion = INVERSION_AUTO;
  465.             tTs.frequency = gCurPrgInfo.nFrequency / 1000;
  466.             tTs.details.qam.symbolRatekSs = gCurPrgInfo.nSymbol / 1000;
  467.             tTs.details.qam.modulation    = gCurPrgInfo.nQamTyep;
  468.             KB_DMDDropSignal();
  469.             KB_DMDConnectSignal(&tTs);
  471.      //msg to movie client
  472.      msg.Word1=KB_CLIENT_FRE_SWITCH;
  473.      msg.Word2=gCurPrgInfo.nFrequency;
  474.      msg.Word3=gCurPrgInfo.nSymbol;
  475.      msg.Word4=gCurPrgInfo.nQamTyep;
  476.      kb_machblue_task_post(&msg);
  477.         }
  478.     }
  479.     else
  480.     {
  481.         tTs.type      = DMD_TYPE_QAM;
  482.         tTs.inversion = INVERSION_AUTO;
  483.         tTs.frequency = gPrePrgInfo.nFrequency / 1000;
  484.         tTs.details.qam.symbolRatekSs = gPrePrgInfo.nSymbol / 1000;
  485.         tTs.details.qam.modulation    = gPrePrgInfo.nQamTyep;
  487.         gCurPrgInfo.nFrequency  = gPrePrgInfo.nFrequency;
  488.         gCurPrgInfo.nSymbol     = gPrePrgInfo.nSymbol;
  489.         gCurPrgInfo.nQamTyep = gPrePrgInfo.nQamTyep;
  490.         
  491.         KB_DMDDropSignal();
  492.    KB_DMDConnectSignal(&tTs);
  494.         //msg to movie client
  495.         msg.Word1=KB_CLIENT_FRE_SWITCH;
  496.  msg.Word2=gCurPrgInfo.nFrequency;
  497.  msg.Word3=gCurPrgInfo.nSymbol;
  498.  msg.Word4=gCurPrgInfo.nQamTyep;
  499.  kb_machblue_task_post(&msg);
  500.     }    
  503.     //add by steven
  504.     //led show
  505.     {
  506.      char pLED[4];  
  508. if((gCurPrgInfo.prgNO>0)&&(gCurPrgInfo.prgNO<10))
  509. sprintf(pLED,"%s%d","C00",gCurPrgInfo.prgNO);
  510. else if((gCurPrgInfo.prgNO>=10)&&(gCurPrgInfo.prgNO<100))
  511. sprintf(pLED,"%s%d","C0",gCurPrgInfo.prgNO);
  512. else if((gCurPrgInfo.prgNO>=100)&&(gCurPrgInfo.prgNO<1000))
  513. sprintf(pLED,"%s%d","C",gCurPrgInfo.prgNO);
  515. LED_ShowString(pLED);
  516.     }
  517.     //end add by steven
  518.     
  519. kb_mb_service_context_evaluation(gCurPrgInfo.prgNO,gCurPrgInfo.prgType);
  520.     
  521.     return RETOK;
  522. }
  524. INT32 KB_DTVStopAV(void)
  525. {
  526.     gPlayStatus = KB_DTVSTOP;
  527.     KB_DTVStop();
  528.     KB_EPGStopAllEITPF();
  529.     
  530.     if (gCurPrgInfo.prgType == RADIOPRG)
  531.     {
  532.         KB_DTVStopIFrame();
  533.     }
  534.     
  535.     gCurPrgInfo.prgNO = 0xFFFFFFFF;
  537.     return RETOK;
  538. }
  539. void KB_DTVPlayPrg(int  prgType, int prgNO)
  540. {
  541.       KB_DTVSetPrg(prgType, prgNO);
  542. KB_DTVRun();
  543. }
  544. INT32 KB_DTVRunNextPrg(KB_DBPRGType prgType)
  545. {
  546.     KB_DTVSetNextPrg(prgType);
  547.     KB_DTVRun();
  549.     return RETOK;
  550. }
  552. INT32 KB_DTVRunPrePrg(KB_DBPRGType prgType)
  553. {
  554.     KB_DTVSetPrePrg(prgType);
  555.     KB_DTVRun();
  557.     return RETOK;
  558. }
  560. KB_DTVStatus KB_DTVGetRunFlag(void)
  561. {
  562.     return gPlayStatus;
  563. }
  565. INT32 KB_DTVSetVolume(UINT8 nVolume)
  566. { 
  567.     if (nVolume < 0 || nVolume > KB_AV_MAX_VOLUME - 1)
  568.     {
  569.         return RETFAIL3;
  570.     }
  571.     
  572.     gCurVolume = nVolume;    
  573.     KB_AVSetVolume(nVolume);
  575.     //added by yyj 2007.6.14
  576.     KB_DBSavePgmCurVol(gCurVolume);
  578.     return RETOK;
  579. }
  581. INT32 KB_DTVGetVolume(void)
  582. {
  583.     return gCurVolume;
  584. }
  586. INT32 KB_DTVMute(BOOL nMute)
  587. {    
  588.     if (nMute != TRUE && nMute != FALSE)
  589.     {
  590.         return RETFAIL3;
  591.     }
  592.     
  593.     if (gMuteFlag != nMute)
  594.     {
  595.         gMuteFlag = nMute;
  596. KB_AVSetMute(nMute);
  597.     }
  599.     return RETOK;
  600. }
  602. INT32 KB_DTVGetMuteFlag(void)
  603. {
  604.     return gMuteFlag;
  605. }
  607. INT32 KB_DTVGetEitPF(void)
  608. {    
  609.     KB_EPGStopAllEITPF();
  611.     KB_EPGGetEITPF(gCurPrgInfo.nSvcID);
  614.     return RETOK;
  615. }
  617. static void DTV_HandleSI_AV(KB_OSPMsgNode *pInMsg)
  618. {    
  619.     switch (pInMsg->Word2)
  620.     {
  621.     case KB_SI_MSG_TDT_DONE:
  622.         KB_TimeSetCurTime(*((time_t*)pInMsg->Word3));
  623.         KB_MENUTranslateMsg(pInMsg);
  624.         break;            
  625.     case KB_SI_MSG_NIT_CHANGE:
  626.         KB_MENUTranslateMsg(pInMsg);
  627.         break;            
  628.     case KB_SI_MSG_SDT_CHANGE:
  629.         KB_MENUTranslateMsg(pInMsg);
  630.         break;            
  631.         
  632.     default:
  633.         break;
  634.     }
  635.     return;
  636. }
  638. static void DTV_HandleTuner_AV(KB_OSPMsgNode *pInMsg)
  639. {
  640.     KB_SIEitPF *ptEitPf;
  641.     
  642.     switch (pInMsg->Word2)
  643.     {       
  644.     case EPG_MSG_PF_DONE:
  645.         ptEitPf = (KB_SIEitPF*)pInMsg->Word3;
  646.         if (ptEitPf != NULL)
  647.         {
  648.             if (gCurPrgInfo.nSvcID == ptEitPf->service_id)
  649.             {
  650.                 KB_MENUTranslateMsg(pInMsg);
  651.             }
  652.         }
  653.         
  654.         break;
  656.     case EPG_MSG_PF_TIMEOUT:
  657.         break;
  658.         
  659.     default:
  660.         break;
  661.     }
  662.     return;
  663. }
  665. static void DTV_HandleMsg_2(KB_OSPMsgNode *pInMsg)
  666. {
  668.     switch (pInMsg->Word2)
  669.     {       
  671.     case KB_DTVOK:
  672.             KB_MENUTranslateMsg(pInMsg);
  673.         break;
  674.     case KB_DTVFAIL:
  675.             KB_MENUTranslateMsg(pInMsg);
  676.         break;
  677.         
  678.     default:
  679.         break;
  680.     }
  681.     return;
  682. }
  684. INT32 KB_DTVGetClass(INT32 nPrgType)
  685. {
  686. return gPrgClass[nPrgType];
  687. }
  689. void KB_DTVSetClass(INT32 nPrgType, INT32 iPlayClass)
  690. {
  691.     
  692.     gPrgClass[nPrgType] = iPlayClass;
  693. }
  694. #if 0
  695. static void DTV_ChangeType(INT32 nOldType, INT32 nNewType)
  696. {
  697.     if (nOldType == DTVPRG)
  698.     {
  699.         KB_DTVStop();
  700.         //DTV_StartIFrame(gatPlayIframeData, J_PLAY_IFRAME_DATA_SIZE);
  701.     }
  702.     else
  703.     {
  704.         //DTV_StopIFrame();
  705.     }
  706. }
  707. #endif
  708. INT32 KB_DTVSetTrack(KB_DBTRACK nTrackType)
  709. {
  711. //UINT8 bTrackAndVol = 0;
  712.     if (nTrackType != gCurTrace)
  713.     {
  714. gCurTrace = nTrackType;
  715.         KB_AVSetPrgTrack(gCurTrace);
  717. //modified by yyj 2007.6.27
  718.         KB_DBSavePgmCurTrack(gCurTrace);
  719.  //bTrackAndVol = ((gCurTrace & 0x03) << 5) | (gCurVolume & 0x1F);
  720.         //KB_DBSaveTrace(gCurPrgInfo.prgType, gCurPrgInfo.prgNO, 
  721.  //                     bTrackAndVol);
  722.     }
  724.     return RETOK;
  725. }
  727. INT32 KB_DTVSetPrePrg(KB_DBPRGType prgType)
  728. {
  729.     int channelNo, totalChannels;
  730.     
  731.     channelNo = gPrePrgInfo.prgNO;
  732. totalChannels = KB_DBGetPrgTotal(prgType);
  734.     if((channelNo <= 1) || (channelNo > totalChannels))
  735. {
  736. channelNo = (totalChannels + 1);
  737. }
  738. channelNo --;
  739. if(channelNo == 0) 
  740. {
  741. channelNo = 1;
  742. }
  744.     KB_DTVSetPrg(prgType, channelNo);
  746.     return RETOK;
  747. }
  749. KB_DBTRACK KB_DTVGetTrack(void)
  750. {
  751.    // UINT8 bTrack;
  752.     
  753.    //KB_DBGetPgmCurTrack(&bTrack);
  754.    // bTrack = KB_DBGetPrgTrace(gCurPrgInfo.prgType, 
  755.    //                               gCurPrgInfo.prgNO);
  757.    //return bTrack;
  759.    //modified by yyj 2007.6.27
  760.    return gCurTrace;
  761. }
  763. INT32 KB_DTVSaveCurVolume(void)
  764. {
  766. UINT8 bTrackAndVol = 0;
  767. bTrackAndVol = ((gCurTrace & 0x03) << 5) | (gCurVolume & 0x1F);
  768.     KB_DBSaveTrace(gCurPrgInfo.prgType, gCurPrgInfo.prgNO, 
  769.                     bTrackAndVol);
  771.     return RETOK;
  772. }
  774. INT32 KB_DTVSetNextPrg(KB_DBPRGType prgType)
  775. {
  776.     int channelNo, totalChannels;
  777.     
  778.     channelNo = gPrePrgInfo.prgNO;
  779.     totalChannels = KB_DBGetPrgTotal(prgType);
  781.     channelNo ++;
  782. if(channelNo > totalChannels)
  783. channelNo = 1;
  785.     KB_DTVSetPrg(prgType, channelNo);
  787.     return RETOK;
  788. }
  790. INT32 KB_DTVSetRetPrg(KB_DBPRGType nCurPrg)
  791. {
  792.     INT32 prgType, nProgram, nTotalProgram;
  793.     
  794.     prgType = KB_DTVGetPrePrgType();
  795.     if (prgType == 0xFFFFFFFF)
  796.     {
  797.         nProgram = 0xFFFFFFFF;
  798.     }
  799.     else
  800.     {
  801.         if (nCurPrg == prgType)
  802.         {
  803.             switch (prgType)
  804.             {
  805.             case DTVPRG:
  806.                 nProgram = KB_DTVGetPreDtvNO();
  807.                 break;
  809.             case RADIOPRG:
  810.                 nProgram = KB_DTVGetPreRadNO();
  811.                 break;
  813.             default:
  814.                 prgType = DTVPRG;
  815.                 nProgram     = 1;
  816.                 break;
  817.             }
  818.         }
  819.         else
  820.         {
  821.             switch (prgType)
  822.             {
  823.             case DTVPRG:
  824.                 nProgram = KB_DTVGetPreDtvNO();
  825.                 break;
  827.             case RADIOPRG:
  828.                 nProgram = KB_DTVGetPreRadNO();
  829.                 break;
  831.             default:
  832.                 prgType = DTVPRG;
  833.                 nProgram     = 1;
  834.                 break;
  835.             }
  836.         }
  837.     }
  838.     
  839. nTotalProgram = KB_DBGetPrgTotal((UINT8)prgType);
  840. if (nProgram < nTotalProgram && nProgram > 0)
  841.     {
  842.         KB_DTVSetPrg((int)prgType, (int)nProgram);
  843.     }
  844.     
  845.     return RETOK;    
  846. }
  848. INT32 DTV_GetRetChnnl(KB_DBPRGType nCurPrg)
  849. {
  850.     INT32 prgType, nProgram, nTotalProgram;
  851.     
  852.     prgType = KB_DTVGetPrePrgType();
  853.     if (nCurPrg == prgType)
  854.     {
  855.         switch (prgType)
  856.         {
  857.         case DTVPRG:
  858.             nProgram = KB_DTVGetPreDtvNO();
  859.             break;
  861.         case RADIOPRG:
  862.             nProgram = KB_DTVGetPreRadNO();
  863.             break;
  865.         default:
  866.             prgType = DTVPRG;
  867.             nProgram     = 1;
  868.             break;
  869.         }
  870.     }
  871.     else
  872.     {
  873.         switch (prgType)
  874.         {
  875.         case DTVPRG:
  876.             nProgram = KB_DTVGetPreDtvNO();
  877.             break;
  879.         case RADIOPRG:
  880.             nProgram = KB_DTVGetPreRadNO();
  881.             break;
  883.         default:
  884.             prgType = DTVPRG;
  885.             nProgram     = 1;
  886.             break;
  887.         }
  888.     }
  889.     
  890. nTotalProgram = KB_DBGetPrgTotal((UINT8)prgType);
  891. if (nProgram > nTotalProgram || nProgram <= 0)
  892. {
  893. nProgram = 1;
  894. }
  895.     KB_DTVSetPrg((int)prgType, (int)nProgram);
  896.     
  897.     return RETOK;    
  898. }
  900. INT32 KB_DTVGetRetDtvNO(void)
  901. {
  902.     return gRetPrg.ndtvNO;
  903. }
  905. INT32 KB_DTVGetRetRadNO(void)
  906. {
  907.     return gRetPrg.nradNO;
  908. }
  910. INT32 KB_DTVGetRetPrgType(void)
  911. {
  912.     return gRetPrg.prgType;
  913. }
  915. INT32 KB_DTVStart(UINT32 nVideoPid, UINT32 nAudioPid, UINT32 nPcrPid)
  916. {
  917.     KB_OSPMsgNode msgNode;
  919.     msgNode.Word1 = PLAY_START;
  920.     msgNode.Word2 = nVideoPid;
  921.     msgNode.Word3 = nAudioPid;
  922.     msgNode.Word4 = nPcrPid;
  924.     KB_OSPMsgSend(gDtvQueID, &msgNode);
  926.     return RETOK;
  927. }
  929. INT32 KB_DTVStop(void)
  930. {
  931.     KB_OSPMsgNode msgNode;
  933.     msgNode.Word1 = PLAY_STOP;
  934.     
  935.     KB_OSPMsgSend(gDtvQueID, &msgNode);
  937.     KB_TimerDisable(gDtvPmtTimer);
  938.     
  939.     return RETOK;
  940. }
  942. INT32 KB_DTVStartIFrame(UINT8 *pInData, INT32 nDataSize)
  943. {
  944.     KB_OSPMsgNode msgNode;
  946.     msgNode.Word1 = PLAY_START_IFRAME;
  947.     msgNode.Word2 = (UINT32)pInData;
  948.     msgNode.Word3 = (UINT32)nDataSize;
  950.     KB_OSPMsgSend(gDtvQueID, &msgNode);
  951.     
  952.     return RETOK;
  953. }
  955. INT32 KB_DTVStopIFrame(void)
  956. {
  957.     KB_OSPMsgNode msgNode;
  959.     msgNode.Word1 = PLAY_STOP_IFRAME;
  960.     
  961.     KB_OSPMsgSend(gDtvQueID, &msgNode);
  962.     return RETOK;
  963. }
  965. static void DTV_Task(void)
  966. {
  967.     int i, nReturn;
  968.     KB_OSPMsgNode msgNode;
  969.     
  970.     i = 1;
  971.     while (i)
  972.     {
  973.         nReturn = KB_OSPMsgGet(gDtvQueID, KB_Wait, 0, &msgNode);
  974.         if (nReturn != Ret_OK)
  975.         {
  976.             continue;
  977.         }        
  978.         DTV_HandleMsg_1(&msgNode);
  979.     }
  980.     
  981.     return;
  982. }
  984. INT32 KB_DTVHandleMsg(KB_OSPMsgNode *pInMsg)
  985. {
  986.     switch (pInMsg->Word1)
  987.     {
  988.     case MOD_SIPSI:
  989.         DTV_HandleSI(pInMsg);
  990.         break;
  992.     default:
  993.         break;
  994.     }
  995.     return RETOK;
  996. }
  998. static INT32 DTV_HandleMsg_1(KB_OSPMsgNode *pInMsg)
  999. {
  1000.     switch (pInMsg->Word1)
  1001.     {
  1002.     case PLAY_START:
  1003.         KB_AVPlay(pInMsg->Word2, pInMsg->Word3, pInMsg->Word4);
  1004.         break;
  1006.     case PLAY_STOP:
  1007.         KB_AVStop();
  1008.         break;
  1010.     case PLAY_START_IFRAME:
  1011.         KB_AVPlayIFrame((UINT8*)pInMsg->Word2, pInMsg->Word3);
  1012.         break;
  1014.     case PLAY_STOP_IFRAME:
  1015.         KB_AVStopIFrame();
  1016.         
  1017.     default:
  1018.         break;
  1019.     }
  1020.     return RETOK;
  1021. }
  1023. INT32 KB_DTVStartCA(INT32 nTsId, INT32 nSvcID)
  1024. {
  1025.     gCurPrg.nPgmNum    = nSvcID;
  1026.     gCurPrg.nVideoPid = 0;
  1027.     gCurPrg.nAudioPid = 0;
  1028.     gCurPrg.nPcrPid   = 0;
  1030.     memset(&gDtvPrePmt, 0, sizeof(KB_SIPmtStruct));
  1033.     KB_SIStopPat();
  1034.     KB_SIGetPat(&gDtvPat, KB_SI_RECEIVE_ONCE, -1);
  1036.     KB_SIStopCat();
  1037.     KB_SIGetCat(&gDtvCat, KB_SI_RECEIVE_ONCE, -1);
  1038.     
  1039.    KB_TimerEnable(gDtvPmtTimer, 5000);
  1041.     memset(&gDtvPreCat, 0, sizeof(KB_SICatStruct));
  1042.    KB_TimerEnable(gDtvCatTimer, 5000);
  1043.     
  1044.     return RETOK;
  1045. }
  1047. static INT32 DTV_HandleSI(KB_OSPMsgNode *pInMsg)
  1048. {    
  1049.     switch (pInMsg->Word2)
  1050.     {
  1051.     case KB_SI_MSG_PAT_DONE:
  1052.         gCurPrg.nPmtPid = DTV_GetPmtPid(gCurPrg.nPgmNum);
  1053.         if (gCurPrg.nPmtPid)
  1054.         {
  1055.             KB_SIStopPmt(-1);
  1056.             KB_SIGetPmt(gCurPrg.nPmtPid, gCurPrg.nPgmNum, &gDtvPmt, KB_SI_RECEIVE_ONCE, -1);
  1057.             KB_TimerEnable(gDtvPmtTimer, 5000);
  1058.         }
  1059.         break;
  1061.     case KB_SI_MSG_PAT_TIMEOUT:
  1062.         break;
  1064.     case KB_SI_MSG_PMT_DONE:    
  1065.         DTV_HandlePmt(pInMsg);
  1066.         break;
  1068.     case KB_SI_MSG_PMT_TIMEOUT:
  1069.         break;
  1071.     case KB_SI_MSG_CAT_DONE:
  1072.         DTV_HandleCat(pInMsg);
  1073.         break;
  1075.     case KB_SI_MSG_CAT_TIMEOUT:
  1076.         break;
  1077.     case KB_SI_MSG_NIT_DONE:
  1078.         break;
  1080.     case KB_SI_MSG_NIT_TIMEOUT:
  1081.         break;
  1082.         
  1083.     default:
  1084.         break;
  1085.     }
  1087.     return RETOK;
  1088. }
  1090. static INT32 DTV_GetPmtPid(INT32 nSvcNO)
  1091. {
  1092. int  i;
  1093. int num;
  1094. num = gDtvPat.num;
  1096. for(i = 0; i < num; i ++)
  1097. {
  1098. if( gDtvPat.program[i].program_number == nSvcNO)
  1099. {
  1100. return (INT32)gDtvPat.program[i].program_map_PID;
  1101. }
  1102. }
  1103.     
  1104. return 0;
  1105. }
  1107. static INT32 DTV_HandlePmt(KB_OSPMsgNode *pInMsg)
  1108. {
  1109.     INT32 i;
  1110.     KB_SIPmtStruct *ptPmt;
  1111.     //static  KB_SIPmtStruct thePre_pmt;
  1112.     INT32 nVideoPid, nAudioPid, nPcrPid;
  1113.     
  1114.     ptPmt = (KB_SIPmtStruct*)pInMsg->Word3;
  1115.     nVideoPid = nAudioPid = nPcrPid = 0;
  1116.     if (memcmp(&gDtvPrePmt, ptPmt, sizeof(KB_SIPmtStruct)) != 0)
  1117.     {        
  1118.         for(i = 0;i< ptPmt->num;i++)
  1119.         {
  1120.             if ((ptPmt->stream[i].stream_type == 0x01) 
  1121.                || (ptPmt->stream[i].stream_type == 0x02))
  1122.             {
  1123.                 nVideoPid = ptPmt->stream[i].elementary_PID;
  1124.             }
  1126.             if ((ptPmt->stream[i].stream_type == 0x03) 
  1127.                || (ptPmt->stream[i].stream_type == 0x04)) 
  1128.             {
  1129.                 nAudioPid = ptPmt->stream[i].elementary_PID;
  1130.             }
  1132.             if (nVideoPid != 0 && nAudioPid != 0)
  1133.             {
  1134.                 break;
  1135.             }
  1136.         }
  1137.         nPcrPid = ptPmt->PCR_PID;        
  1139. //printf("nChannel switch gCurPrg.nVideoPid[%d]nVideoPid[%d]  gCurPrg.nAudioPid[%d]nAudioPid[%d]  gCurPrg.nPcrPid [%d]nPcrPid[%d]",gCurPrg.nVideoPid,nVideoPid,gCurPrg.nAudioPid,nAudioPid,gCurPrg.nPcrPid,nPcrPid);
  1140.         if (   gCurPrg.nVideoPid != nVideoPid
  1141.             || gCurPrg.nAudioPid != nAudioPid
  1142.             || gCurPrg.nPcrPid   != nPcrPid)
  1143.         {
  1144.             gCurPrg.nVideoPid = nVideoPid;
  1145.             gCurPrg.nAudioPid = nAudioPid;
  1146.             gCurPrg.nPcrPid   = nPcrPid;
  1148.             KB_TimerDisable(gDtvPmtTimer);
  1149.             KB_TimerDisable(gDtvCatTimer);
  1150.             
  1151.             KB_DTVStart(nVideoPid, nAudioPid, nPcrPid);
  1152.         }
  1153.                 
  1154.         memcpy(&gDtvPrePmt, ptPmt, sizeof(KB_SIPmtStruct));
  1155. KB_CAService(KB_CA_PMTUPDATE, (void *)ptPmt);
  1156.         
  1157.         
  1158.     }   
  1160.     return RETOK;
  1161. }
  1163. static void DTV_CallbackHandle(INT32 nSuccess, 
  1164.                               INT32 nHours, 
  1165.                               INT32 nMinutes, 
  1166.                               INT32 nSeconds)
  1167. {
  1168.     INT32 nPlay;
  1169.     
  1170. if(nSuccess)
  1171. {
  1172. nPlay = 0;
  1173. }
  1174. else
  1175. {
  1176. nPlay = 1;
  1177. }
  1179.     if (gDtvCallBack)
  1180.     {
  1181.         gDtvCallBack((int)nPlay);
  1182.     }
  1183. }
  1186. KB_DTVRunCallback KB_DTVCallBack(KB_DTVRunCallback ptCallback)
  1187. {
  1188.     KB_DTVRunCallback ptPreCallback;
  1190.     ptPreCallback = gDtvCallBack;
  1191.     gDtvCallBack = ptCallback;
  1193.     return ptPreCallback;
  1194. }
  1196. static void DTV_PmtTimer(void)
  1197. {
  1198.     KB_SIStopPat();
  1199. KB_SIGetPat(&gDtvPat, KB_SI_RECEIVE_ONCE, -1);
  1200. }
  1202. static void DTV_CatTimer(void)
  1203. {
  1204.     KB_SIStopCat();
  1205.     KB_SIGetCat(&gDtvCat, KB_SI_RECEIVE_ONCE, -1);
  1206. }
  1209. static INT32 DTV_HandleCat(KB_OSPMsgNode *pInMsg)
  1210. {
  1211.     KB_SICatStruct *ptCat;
  1213.     ptCat = (KB_SICatStruct*)pInMsg->Word3;
  1214.     if (memcmp(&gDtvPreCat, ptCat, sizeof(KB_SICatStruct)) != 0)
  1215.     {
  1216.         memcpy(&gDtvPreCat, ptCat, sizeof(KB_SICatStruct));
  1217. KB_CAService(KB_CA_CATUPDATE, (void *)ptCat);//播放第一个加密节目时，调用这个函数有问题。
  1218.     }
  1220.     return RETOK;
  1221. }
  1224. static void DTV_AVCallbackHandle(int intype)
  1225. {
  1226. KB_OSPMsgNode pInMsg;
  1228. pInMsg.Word1 = J_AVAPPLET_MODULE;
  1229.     pInMsg.Word2 = 0;
  1230. pInMsg.Word3 = 0;
  1231. pInMsg.Word4 = 0;
  1233.     switch (intype)
  1234.     {
  1235.     case 0:
  1236.         pInMsg.Word2 = KB_DTVOK;
  1237.         break;
  1239.     case 1:
  1240.         pInMsg.Word2 = KB_DTVFAIL;
  1241.         break;
  1243.     default:
  1244.         break;
  1245.     }
  1247.     DTV_HandleMsg_2(&pInMsg);
  1248.         
  1249. }
  1252. //播放当前节目
  1253. void KB_DTVPlayCurPrg(void)
  1254. {
  1255. UINT8  prgType;
  1256.      unsigned short prgNO;
  1258. KB_DBGetCurPrgInfo(&prgNO,&prgType);
  1259. KB_DTVSetPrg(prgType, prgNO);
  1260. KB_DTVRun();
  1261.     KB_DTVGetEitPF();
  1262. }
  1264. //播放上一节目
  1265. void KB_DTVPlayPrePrg(void)
  1266. {
  1267. KB_DTVSetPrePrg(KB_DTVGetPrePrgType());
  1268. KB_OSPTaskDelay(500);        
  1269. STB_StateSwitch(State_AV); 
  1270. }
  1272. //播放下一节目
  1273. void KB_DTVPlayNexPrg(void)
  1274. {
  1275. KB_DTVSetNextPrg(KB_DTVGetPrePrgType());
  1276. KB_OSPTaskDelay(500);        
  1277. STB_StateSwitch(State_AV);
  1278. }
  1281. int KB_DTVGetCurrentProgramNo(void)
  1282. {
  1283. return gCurPrgInfo.prgNO;
  1284. }
  1286. //切换节目类型
  1287. INT32 KB_DTVPrgSwitch(KB_DBPRGType type)
  1288. {
  1289. if(KB_DBGetPrgTotal(type)==0)
  1290. {
  1291. return RETFIAL1;
  1292. }
  1294.       KB_DTVSetPrg(type,1);
  1295. KB_OSPTaskDelay(500);
  1296.        STB_StateSwitch(State_AV);     
  1298. return RETOK;
  1299. }
  1301. void KB_DTVVolumeAdd(void)
  1302. {
  1303. UINT8 vol;
  1305. vol=(UINT8)KB_DTVGetVolume();
  1306. printf("n[Han]:Volume add [%d]",vol);
  1307. if(vol<KB_AV_MAX_VOLUME)
  1308. {
  1309. vol+=1;
  1310. KB_DTVSetVolume(vol);
  1311. }
  1312. }
  1314. void KB_DTVVolumeReduce(void)
  1315. {
  1316. UINT8 vol;
  1318. vol=(UINT8)KB_DTVGetVolume();
  1319. printf("n[Han]:Volume reduce [%d]",vol);
  1320. if(vol>0)
  1321. {
  1322. vol-=1;
  1323. KB_DTVSetVolume(vol);
  1324. }
  1325. }
  1327. void KB_DTVDisplayCurPrgInfo(void)
  1328. {
  1329.     printf("nn--------KB_DTVDisplayCurPrgInfo---------");
  1330.     printf("nprgType:     %d", gCurPrgInfo.prgType);
  1331.     printf("nprgNO:       %d", gCurPrgInfo.prgNO);
  1332.     printf("nnSvcID:      %d", gCurPrgInfo.nSvcID);
  1333.     printf("nnFrequency:  %d", gCurPrgInfo.nFrequency);
  1334.     printf("nnSymbol:     %d", gCurPrgInfo.nSymbol);
  1335.     printf("nnQamTyep:    %d", gCurPrgInfo.nQamTyep);
  1337.     return;
  1338. }
  1342. BOOL KB_DTVGetCurPrgInfo(unsigned short *pTsID, unsigned short *pServID)
  1343. {
  1344.     BOOL ret;
  1345. unsigned long fre=gCurPrgInfo.nFrequency/100000;
  1346.     if (!KB_DBGetTsIDByFre(pTsID,fre))
  1347.     {
  1348.         *pServID = gCurPrgInfo.nSvcID;
  1349.    ret = TRUE;
  1350.     }
  1351.     else
  1352.     {
  1353.    ret = FALSE;
  1354.     }
  1355.     return ret;
  1356. }
  1359. //将VEDIO的编码状态设置为VIDEO_STATUS_STOPPED
  1360. void KB_DTVRunForNvod(void)
  1361. {
  1362.     KB_CAService(KB_CA_CLOSE, 0);
  1364.     KB_DTVSetVolume(gCurVolume);   
  1366.     gCurTrace = KB_DTVGetTrack();
  1367.     KB_AVSetPrgTrack(gCurTrace);
  1369.     gPlayStatus = KB_DTVSTOP;
  1370.     KB_DTVStop();
  1371.     KB_DTVStopIFrame();
  1372. }
  1374.  void KB_DTVStartCurCAProg(void)
  1375.  {
  1376.    KB_DTVStartCA(0, gCurPrgInfo.nSvcID);
  1377.  }
  1378. /* EOF */