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

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

DVD

开发平台：

C/C++

nvod.c：源码内容
  1. #include <string.h>
  3. #include "nvod.h"
  4. #include "appltype.h"
  5. #include "epg.h"
  6. #include "sipsi.h"
  8. #include "db.h"
  9. #include "avplay.h"
  10. #include "av.h"
  11. #include "Search.h"
  12. #include "kb_machblue_client_task.h"
  13. #include "Timer.h"
  14. #include "Timeclk.h"
  16. typedef enum
  17. {
  18.     NVOD_Connect,
  19.     NVOD_Play,
  20.     NVOD_Stop
  21. }NVOD_Mode;
  23. KB_SINitStruct  g_novdNit;
  25. static KB_SIRefSvcCell gNvodSvcInfo[KB_NVOD_MAX_REF];
  26. static UINT8 gNvodRefSvcNum; 
  27. static INT32 gSvcNum;
  28. static int gArriveNum;
  29. static int gTimeOutNum;
  30. //目前仅支持EIT时间表0x50、0x51
  31. static UINT8 gNvodEitSchTableSwitchFlag = KB_EIT_SCHEDULE_CURRENT_TS_TABLE_DEFAULT;  
  33. //当前正在执行搜索任务的gatNvod数组索引号
  34. static UINT32  CurrentSearchTsNum = KB_NVOD_MAX_TS_NUM;
  35. //用来标识搜索当前Ts中的参考事件是否已经完成
  36. static UINT32  CurrentPFCompleteFlag = 0;
  37. static KB_NVOD_Info gatNvod[KB_NVOD_MAX_TS_NUM];   
  39. //static KB_DMDTunerParameters NvodCurrentTs;
  40. static KB_DMDTunerParameters gNvodRefFre[KB_NVOD_MAX_REF];
  41. static KB_NVODReceive gRecieveState[KB_NVOD_MAX_REF];
  42. static UINT8 gNvodRefSvcEachFre[KB_NVOD_MAX_REF];
  43. static UINT8 gFreqInd = 0;
  44. static UINT8 gFreqNum =0 ;
  47. static time_t gNvodTime;
  48. //static struct tm  gNvodtmTime;
  49. //static time_t gSchTime;
  50. static time_t gPrgEndTime;
  52. static BOOL gNewFlag = FALSE;
  54. static INT32 gCurTsID;
  55. static INT32 gCurSvcID;
  57. static NVOD_Mode gPrgPlayStatus;
  60. static KB_NVODPfInfo gNvodPFInfo[KB_SI_MAX_REF_SVC_NUMS];
  61. static KB_SIEitPF *gNvodPF;
  62. static KB_SINVODEitPF *gNvodPFEvent;
  63.     
  64. static KB_NVODSch      gNvodSch[KB_NVOD_MAX_ShiftSrv_One_Ts];
  65. static KB_SIEitSchTimeShiftNode *gNvodSchEvent;
  67. static UINT32 EitSrhTimer;
  69. //static void KD_NVODHandleMsg3(KB_OSPMsgNode *pInMsg);
  70. static BOOL KD_NVODRefSvcReceiveStatus(UINT16 refScvId, BOOL bTimeout);
  71. static void KD_NVODHandleEitSch(KB_OSPMsgNode *pInMsg);
  72. static INT32 KD_NVODGetFreePF(void);
  73. static INT32 KD_NVODGetFreeSch(void);
  74. static INT32 KD_NVODResetPF(INT32 nNumber);
  75. static INT32 KD_ResetSCH(INT32 nNumber);
  76. static void quicksortEit(KB_NVODTime *pbuf,int low,int high);
  77. static int quickpartEit(KB_NVODTime *pbuf,int i,int j);
  79. static INT32 KD_NVODHandlePFOver(KB_OSPMsgNode *pInMsg);
  80. static INT32 KD_NVODHandleSCHOver(KB_OSPMsgNode *pInMsg);
  81. static void KD_NVODHandleTuner(KB_OSPMsgNode *pInMsg);
  82. static INT32 KB_NVODGetEitPF(UINT32 TsSequence);
  83. static void KB_NvodHandleEitSrhTimeOut(void);
  84. static INT32 KD_NVODInitTask(void);
  85. static INT32 KD_NVODPlayInit(void);
  86. static UINT8 KB_NVOD_AllocategatNvodInfo(UINT32 frequency);
  87. static void KB_NVOD_ResetTsData(UINT32 TsSequence);
  88. static INT32 KB_NVOD_SetCurrentTsPara(KB_DMDTunerParameters TsPara);
  89. static INT32 KD_NVODGetPF(INT32 nTsId, INT32 nSvcID, KB_SIEitTs eTs);
  90. static UINT32 KB_NVOD_GetNullPFTsNum(void);
  91. static INT32 KB_NVODGetEitSch(UINT32 TsSequence);
  92. static INT32 KD_NVODGetSchTimeShift(INT32 nTsId, INT32 nSvcID, KB_SIEitTs eTs);
  93. static void KB_NVOD_DirectInsertSort(KB_NVODTime TimeNode[], UINT16 TimeNum);
  94. static UINT32 KB_NVOD_GetNullSchTsNum(void);
  96. extern void KB_MENUTranslateMsg(KB_OSPMsgNode* pInMsg);
  98. INT32 KB_NVODInit(void)
  99. {
  100.     KD_NVODInitTask();
  102. KD_NVODPlayInit();
  103.     
  104.     
  105.     return RETOK;
  106. }
  108. INT32 KB_NVODCreate(void)
  109. {
  110.     KB_SIGetTime(&gNvodTime);  
  111. KB_EPGToNvod(TRUE);
  112.     if (KB_DB_DTV_SUCCESS != KB_NVODInit2())
  113.     {
  114.         printf("nKB_NVODCreate::KB_NVODInit2 failed!n");
  115.     }
  116.    
  117.     if(gNewFlag)
  118.     {
  119.         KB_EPGStopAllSCH();
  121.     KD_NVODStopAllPF();
  122.     KD_NVODStopAllSch();
  124.         KB_TimerDisable(EitSrhTimer);
  125.         printf("nKB_NVODCreate::关闭定时期 EitSrhTimer");
  126.     memset(gNvodSvcInfo, 0, sizeof(gNvodSvcInfo));
  127.     memset(gatNvod, 0, sizeof(gatNvod));
  128. gNvodRefSvcNum = 0;
  129.     gArriveNum = 0;
  130. gTimeOutNum = 0;
  131.         gNvodEitSchTableSwitchFlag = KB_EIT_SCHEDULE_CURRENT_TS_TABLE_DEFAULT;
  133. memset(gNvodRefFre,0,sizeof(gNvodRefFre));
  134. memset(gNvodRefSvcEachFre,0,sizeof(gNvodRefSvcEachFre));
  135. gFreqInd = 0;
  136. gFreqNum = 0;
  138. //memset(&NvodCurrentTs,0,sizeof(KB_DMDTunerParameters));
  139.     KB_NVODInit();
  140.     }
  141.     
  142.     return RETOK;
  143. }
  145. static void KD_NVODHandleTuner(KB_OSPMsgNode *pInMsg)
  146. {
  147.     switch (pInMsg->Word2)
  148.     {
  149.     case DMD_CALLBACK_SIGNAL_CONNECTED:
  150.         if (gPrgPlayStatus == NVOD_Connect)
  151.         {
  152.             gPrgPlayStatus = NVOD_Play;
  153.             KB_DTVStartCA(gCurTsID, gCurSvcID);
  154.         }
  155.         break;
  157.     case DMD_CALLBACK_SIGNAL_LOST:
  158.         break;
  159.         
  160.     default:
  161.         break;
  162.     }
  163. }
  165. void quicksortEit(KB_NVODTime *pbuf,int low,int high)
  166. {
  167. int i;
  168. if(low < high)
  169. {
  170. i = quickpartEit(pbuf,low,high);
  171. quicksortEit(pbuf,low,i-1);
  172. quicksortEit(pbuf,i + 1,high);
  173. }
  174. }
  176. int quickpartEit(KB_NVODTime *pbuf,int i,int j)
  177. {
  178. KB_NVODTime b;
  180. memcpy(&b,&pbuf[i],sizeof(KB_NVODTime));
  181. while(i<j)
  182. {
  183. while(i<j && pbuf[j].startTime >= b.startTime)
  184. {
  185. j --;
  186. }
  187. if(i< j)
  188. {
  189. memcpy(&pbuf[i++],&pbuf[j],sizeof(KB_NVODTime));
  190. }
  192. while(i<j && pbuf[i].startTime <= b.startTime)
  193. {
  194. i ++;
  195. }
  196. if(i<j)
  197. {
  198. memcpy(&pbuf[j --],&pbuf[i],sizeof(KB_NVODTime));
  199. }
  200. }
  202. memcpy(&pbuf[i],&b,sizeof(KB_NVODTime));
  203. return i;
  204. }
  206. static INT32 KD_NVODPlayInit(void)
  207. {
  208. UINT8 i =0;
  210.     gCurTsID  = 0xFFFFFFFF;
  211.     gCurSvcID = 0xFFFFFFFF;
  212.     gPrgPlayStatus = NVOD_Stop;
  214. memset(gatNvod, 0, sizeof(gatNvod));
  215. for (i = 0; i < KB_NVOD_MAX_TS_NUM; i++)
  216. {
  217. gatNvod[i].CurrentTsFlag = FALSE;
  218.         gatNvod[i].SearchStartFlag = FALSE;
  219. gatNvod[i].SearchCompleteFlag = FALSE;
  220. }
  221.    
  222.     return RETOK;
  223. }
  225. INT32 KD_NVODPlayStop(void)
  226. {
  227.     gCurTsID  = 0xFFFFFFFF;
  228.     gCurSvcID = 0xFFFFFFFF;
  229.     gPrgPlayStatus = NVOD_Stop;
  230.     KB_DTVStop();
  231.     return RETOK;
  232. }
  234. INT32 KD_NVODStartPlay(INT32 nTsId, INT32 nSvcID)
  235. {
  236.     unsigned short pFreq,pSymbl;
  237. unsigned char qam;
  238. KB_DMDTunerParameters tReqDmdPara, tCurrDmdPara;
  239.     
  240.     KB_DBGetChnlInfoByTsID((UINT16)nTsId,&pFreq,&pSymbl,&qam);
  242.     tReqDmdPara.type      = DMD_TYPE_QAM;
  243.     tReqDmdPara.inversion = INVERSION_AUTO;
  244.     tReqDmdPara.frequency = (UINT32)pFreq * 100;
  245.     tReqDmdPara.details.qam.symbolRatekSs = pSymbl;
  246.     tReqDmdPara.details.qam.modulation    = qam;
  248.     KB_DMDGetSignalParameters(&tCurrDmdPara);
  249.     //printf("nCur(%d, %d, %d), Play(%d, %d, %d)n",
  250.     //        tCurrDmdPara.frequency, tCurrDmdPara.details.qam.symbolRatekSs, tCurrDmdPara.details.qam.modulation,
  251.     //        tReqDmdPara.frequency, tReqDmdPara.details.qam.symbolRatekSs, tReqDmdPara.details.qam.modulation);
  252.     //printf("nTsId(%d), nSvcID(%d), gCurSvcID(%d)", nTsId, nSvcID, gCurSvcID);
  253.     if (KB_DMDQuerySignalStatus() == TRUE
  254.         && tCurrDmdPara.frequency == tReqDmdPara.frequency
  255.         && tCurrDmdPara.details.qam.symbolRatekSs == tReqDmdPara.details.qam.symbolRatekSs 
  256.         && tCurrDmdPara.details.qam.modulation    == tReqDmdPara.details.qam.modulation)
  257.     {        
  258.         if (0xFFFFFFFF == gCurSvcID)
  259.         {
  260.             gCurTsID  = nTsId;
  261.             gCurSvcID = nSvcID;
  262.             gPrgPlayStatus = NVOD_Play;
  263.             KB_DTVRunForNvod();
  264.             KB_DTVStartCA(nTsId, nSvcID); 
  265.             return RETOK;
  266.         }
  267.         else if (gCurSvcID != nSvcID)
  268.         {
  269.             KD_NVODPlayStop();
  270.             gPrgPlayStatus = NVOD_Play;
  271.             KB_DTVRunForNvod();
  272.             KB_DTVStartCA(nTsId, nSvcID);        
  273.         }
  274.     }
  275.     else
  276.     {
  277.         KD_NVODPlayStop();
  278.         gPrgPlayStatus = NVOD_Connect;
  279.         KB_DMDConnectSignal(&tReqDmdPara);
  280.     }
  282.     gCurTsID  = nTsId;
  283.     gCurSvcID = nSvcID;
  284.     
  285.     return RETOK;
  286. }
  288. INT32 KD_NVODSetVolume(INT32 nVolume)
  289. {       
  290.     if (nVolume < 0 || nVolume > KB_AV_MAX_VOLUME)
  291.     {
  292.         return RETFAIL3;
  293.     }
  294.     
  295.     KB_AVSetVolume(nVolume);
  297.     return RETOK;
  298. }
  300. INT32 KD_NVODGetVolume(void)
  301. {
  302.     return KB_AVGetVolume();
  303. }
  305. INT32 KD_NVODMute(BOOL nMute)
  306. {    
  307.     INT32 nCurrMute;
  308.     
  309.     if (nMute != TRUE && nMute != FALSE)
  310.     {
  311.         return RETFAIL3;
  312.     }
  314.     nCurrMute = KB_AVGetMuteFlag();
  315.     if (nCurrMute != nMute)
  316.     {
  317.      KB_AVSetMute(nMute);
  318.     }
  320.     return RETOK;
  321. }
  323. INT32 KD_NVODDestoryPlay(void)
  324. {
  325.     gNvodTime = 0;
  326.     gCurTsID  = 0xFFFFFFFF;
  327.     gCurSvcID = 0xFFFFFFFF;
  328.     gPrgPlayStatus = NVOD_Stop;
  330.     KD_NVODPlayStop();
  331.     
  332.     return RETOK;
  333. }
  335. BOOL KD_NVODGetMute(void)
  336. {
  337.     return (BOOL)KB_AVGetMuteFlag();
  338. }
  340. INT32 KD_NVODSetTrack(KB_DBTRACK nTrackType)
  341. {
  342.     KB_AVSetPrgTrack(nTrackType);
  344.     return RETOK;
  345. }
  347. KB_DBTRACK KD_NVODGetTrack(void)
  348. {    
  349. return KB_AVGetTrack();
  350. }
  352. INT32 KB_NVODDestroy(void)
  353. {
  354.     KB_EPGToNvod(FALSE);
  355.     KD_NVODStopAllPF();
  356.     KD_NVODStopAllSch();
  357.     KB_TimerDisable(EitSrhTimer);
  358.     printf("nKB_NVODDestroy::关闭定时期 EitSrhTimer");
  359.     KD_NVODDestoryPlay();
  360.     
  361.     return RETOK;
  362. }
  364. INT32 NVOD_HandleMsg(KB_OSPMsgNode *pInMsg)
  365. {
  366.     //UINT32 CurrentTsNum;
  368.     switch (pInMsg->Word1)
  369.     {
  370.         case MOD_SIPSI:
  371.             {                        
  372.          KB_DTVHandleMsg(pInMsg);
  373.          switch(pInMsg->Word2)
  374.          {
  375.          case KB_SI_MSG_TDT_DONE:
  376.          { 
  377.          KB_TimeSetCurTime(*((time_t*)pInMsg->Word3));
  378.                         gNvodTime = KB_TimeGetCurGMTTime();
  379.              //KB_TimeGetCurTime(&gNvodTime);  
  380.                         printf("nNVOD_HandleMsg::get gNvodTime(0x%x) ok",
  381.                                 gNvodTime);
  382.          }
  383.          break;
  384.          }            
  385.          }
  386.             break;
  387.             
  388.         case MOD_TUNER: 
  389.             {            
  390.          KD_NVODHandleTuner(pInMsg);
  391.              switch (pInMsg->Word2)
  392.              {
  393.                     case DMD_CALLBACK_SIGNAL_LOST:
  394.                         {
  395.                         }
  396.                         break;
  397.                     case DMD_CALLBACK_SIGNAL_CONNECTED:
  398.                         {
  399.                         }
  400.                         break;
  402.                     default:
  403.                         break;
  404.              }
  405.             }
  406.             break;
  408.         default:
  409.             break;
  410.     }
  411.     return RETOK;    
  412. }
  414. int KB_NVODInit2(void)
  415. {
  416.     UINT8   TsSequence;
  417. int i,j;
  418. int rt = KB_DB_DTV_FAILURE;
  420. //KB_SINitStruct * nit;
  421. int num;
  422. int ret;
  423. UINT16 tsid;
  424.     UINT32 CurrentTsTsSequence;
  425. unsigned short pFreq,pSymbl;
  426. unsigned char qam;
  427. KB_DMDTunerParameters    ts;
  428. #if 1
  429.     //对已初始化过的，不再进行初始化
  430.     CurrentTsTsSequence = KB_NVOD_GetCurrentTsNum();
  431.     if ((UINT32)(-1) != CurrentTsTsSequence
  432.         && gatNvod[CurrentTsTsSequence].TsPara.frequency == CurrentSignal.frequency)
  433.     {
  434.         printf("nKB_NVODInit2::不再重复初始化");
  435.         return KB_DB_DTV_SUCCESS;
  436.     }
  437. #endif
  438.     memset(gNvodSvcInfo, 0, sizeof(gNvodSvcInfo));
  439. gNvodRefSvcNum = 0;
  440.     gArriveNum = 0;
  441. gTimeOutNum = 0;
  442.     gNvodEitSchTableSwitchFlag = KB_EIT_SCHEDULE_CURRENT_TS_TABLE_DEFAULT;
  444.     memset(gRecieveState,0,sizeof(gRecieveState));
  445. memset(gNvodRefFre,0,sizeof(gNvodRefFre));
  446. memset(gNvodRefSvcEachFre,0,sizeof(gNvodRefSvcEachFre));
  447. gFreqInd = 0;
  448. gFreqNum = 0;
  450. ret = KB_DBGetNvodInfo(gNvodSvcInfo,&num);
  452. if(ret != RET_OK)
  453. {
  454. gSvcNum = 0;
  455. return rt;
  456. }
  458. gNvodRefSvcNum = num;
  460. if (0 == gNvodRefSvcNum)
  461.     {
  462.         gSvcNum = 0;
  463.         return KB_DB_DTV_SUCCESS;
  464.     }
  466. j = 1;
  467. for(i=1; i<gNvodRefSvcNum; i++)
  468. {
  469. if (gNvodSvcInfo[i-1].TsID != gNvodSvcInfo[i].TsID)
  470. {
  471. tsid = gNvodSvcInfo[i-1].TsID;
  472. KB_DBGetChnlInfoByTsID(tsid,&pFreq,&pSymbl,&qam);
  474.         ts.type      = DMD_TYPE_QAM;
  475.         ts.inversion = INVERSION_AUTO;
  476.         ts.frequency = ((UINT32)pFreq * 100);
  477.         ts.details.qam.symbolRatekSs = pSymbl;
  478.         ts.details.qam.modulation    = qam;
  480.             TsSequence = KB_NVOD_AllocategatNvodInfo(ts.frequency);
  481.             if (TsSequence < KB_NVOD_MAX_TS_NUM)
  482.             {
  483.                 memcpy(&gatNvod[TsSequence].TsPara, &ts, sizeof(KB_DMDTunerParameters));
  484.                 gatNvod[TsSequence].SearchStartFlag = FALSE;
  485.                 gatNvod[TsSequence].SearchCompleteFlag = FALSE;
  486.                 gatNvod[TsSequence].CurrentTsFlag = FALSE;
  487.             }
  488.             else if (TsSequence == KB_NVOD_ALLOCATE_REPEAT)
  489.             {
  490.                 printf("nKB_NVODInit2::KB_NVOD_AllocategatNvodInfo ALLOCATE REPEAT!n");
  491.             }
  492.             else
  493.             {
  494.                 printf("nKB_NVODInit2::KB_NVOD_AllocategatNvodInfo error!n");
  495.                 return KB_DB_DTV_FAILURE;
  496.             }
  497.             
  498. gNvodRefFre[gFreqInd] = ts;
  499. gNvodRefSvcEachFre[gFreqInd] = j;
  500. gFreqInd++;
  501. j = 1;
  502. }
  503. else
  504. {
  505. j++;
  506. }
  507. }
  509. tsid = gNvodSvcInfo[i-1].TsID;
  510. KB_DBGetChnlInfoByTsID(tsid,&pFreq,&pSymbl,&qam);
  512.     ts.type      = DMD_TYPE_QAM;
  513.     ts.inversion = INVERSION_AUTO;
  514.     ts.frequency = ((UINT32)pFreq * 100);
  515.     ts.details.qam.symbolRatekSs = pSymbl;
  516.     ts.details.qam.modulation    = qam;
  518.     TsSequence = KB_NVOD_AllocategatNvodInfo(ts.frequency);
  519.     if (TsSequence < KB_NVOD_MAX_TS_NUM)
  520.     {
  521.         memcpy(&gatNvod[TsSequence].TsPara, &ts, sizeof(KB_DMDTunerParameters));
  522.         gatNvod[TsSequence].SearchStartFlag = FALSE;
  523.         gatNvod[TsSequence].SearchCompleteFlag = FALSE;
  524.         gatNvod[TsSequence].CurrentTsFlag = FALSE;
  525.     }
  526.     else if (TsSequence == KB_NVOD_ALLOCATE_REPEAT)
  527.     {
  528.         printf("nKB_NVODInit2::KB_NVOD_AllocategatNvodInfo ALLOCATE REPEAT!n");
  529.     }
  530.     else
  531.     {
  532.         printf("nKB_NVODInit2::KB_NVOD_AllocategatNvodInfo error!n");
  533.         
  534.         for (i = 0; i < KB_NVOD_MAX_TS_NUM; i++)
  535.         {
  536.             KB_NVOD_ResetTsData(i);
  537.         }
  538.         
  539.         memcpy(&gatNvod[0].TsPara, &ts, sizeof(KB_DMDTunerParameters));
  540.         gatNvod[0].SearchStartFlag = FALSE;
  541.         gatNvod[0].SearchCompleteFlag = FALSE;
  542.         gatNvod[0].CurrentTsFlag = FALSE;
  543.     }
  545. gNvodRefFre[gFreqInd] = ts;
  546. gNvodRefSvcEachFre[gFreqInd] = j;
  547. gFreqInd++;
  549. gFreqNum = gFreqInd;
  550. gFreqInd = 0;
  552. ts = gNvodRefFre[gFreqInd];
  553. gSvcNum = gNvodRefSvcEachFre[gFreqInd];
  555.     if (0 == CurrentSignal.frequency)
  556.     {
  557.         printf("nKB_NVODInit2::serious error! CurrentSignal is NULL!");
  558.         if (0 != gatNvod[0].TsPara.frequency)
  559.         {
  560.             if (RET_OK != KB_NVOD_SetCurrentTsPara(gatNvod[0].TsPara))
  561.             {
  562.                 printf("nKB_NVODInit2::KB_NVOD_SetCurrentTsPara fail!n");
  563.                 return KB_DB_DTV_FAILURE;
  564.             }
  565.             KB_DMDDropSignal();
  566.             KB_DMDConnectSignal(&(gatNvod[0].TsPara));
  567.         }
  568.     }
  569.     else
  570.     {
  571.         if (RET_OK != KB_NVOD_SetCurrentTsPara(CurrentSignal))
  572.         {
  573.             printf("nKB_NVODInit2::KB_NVOD_SetCurrentTsPara fail!n");
  574.             return KB_DB_DTV_FAILURE;
  575.         }
  576.     }
  577.     
  578. //memcpy(&NvodCurrentTs, &ts, sizeof(KB_DMDTunerParameters));
  579. gArriveNum = 0;
  580. gTimeOutNum = 0;
  581.     gNvodEitSchTableSwitchFlag = KB_EIT_SCHEDULE_CURRENT_TS_TABLE_DEFAULT;
  582. gFreqInd++;
  584. if(ret == RET_OK)
  585. {
  586. if(num > KB_SI_MAX_REF_SVC_NUMS)
  587. {
  588. num = KB_SI_MAX_REF_SVC_NUMS;
  589. }
  591.         //先用gRecieveState记录下所有的参考业务ID和它对应的时移业务数
  592.           //以后只需将各参考业务收到的时移业务数(gRecieveState[i].recvSvcNum)清零,
  593.           //并更新该频点中的参考业务数(gSvcNum)即可
  594. for(i = 0; i < gNvodRefSvcNum; i ++)
  595. {
  596. if(gNvodSvcInfo[i].shiftSvcNum > KB_SI_MAX_SHIFT_SVC_NUMS)
  597. {
  598. gNvodSvcInfo[i].shiftSvcNum = KB_SI_MAX_SHIFT_SVC_NUMS;
  599. }
  601. gRecieveState[i].refScvId = gNvodSvcInfo[i].refScvId;
  602. gRecieveState[i].shiftSvcNum = gNvodSvcInfo[i].shiftSvcNum;
  603. gRecieveState[i].recvSvcNum = 0;
  604. }
  605. }
  607. return KB_DB_DTV_SUCCESS;
  608. }
  611. //NVOD的搜索总入口, 次序所有频点的CurrentTsEitPF-->所有频点的CurrentTsEitSch
  612. INT32 KB_NVODGetEit(void)
  613. {
  614.     UINT32 CurrentTsNum;
  615.     INT32  status;
  617.     if (0 ==gNvodRefSvcNum)
  618.     {
  619.         printf("nKB_NVODGetEit::无参考业务!n");
  620.         return  RETOK;
  621.     }
  622.     
  623.     CurrentTsNum = KB_NVOD_GetCurrentTsNum();
  624.     if ((UINT32)(-1) == CurrentTsNum)
  625.     {
  626.         printf("nKB_NVODGetEit::serious error! KB_NVOD_GetCurrentTsNum fail!n");
  627.         return  RETFIAL1;
  628.     }
  629.     
  630.     printf("nKB_NVODGetEit::启动定时器  EitSrhTimer");
  631.     status = KB_TimerEnable(EitSrhTimer, 90*1000);
  632. if(status != RETOK)
  633. {
  634.         printf("nKB_NVODGetEit::EitSrhTimer Enable failed!");
  635.     }
  636.     
  637. KB_NVODGetEitPF(CurrentTsNum);
  639.     return RET_OK;
  640. }
  643. static INT32 KB_NVODGetEitPF(UINT32 TsSequence)
  644. {
  645. int i;
  646.     UINT32   NullDataTsNum = (UINT32)(-1);
  647.     UINT32   CurrentTsNum = (UINT32)(-1);
  648.     BOOL    StartFlag = FALSE, NeedSrhPFFlag = FALSE;
  649. KB_SIEitTs eTs;
  650.     KB_OSPMsgNode message;
  651.     KB_DMDTunerParameters  *pTsPara = NULL;
  653.     //对搜索过程中,中途被打断的ts流, 先清掉以前的不完整数据
  654.     if (TRUE == gatNvod[TsSequence].SearchStartFlag
  655.         && FALSE ==gatNvod[TsSequence].SearchCompleteFlag)
  656.     {
  657.         KB_NVOD_ResetTsData(TsSequence);
  658.     }
  660.     if (TsSequence == KB_NVOD_GetCurrentTsNum())
  661.     {
  662.         eTs = KB_SI_EIT_CURRENT_TS;
  663.     }
  664.     else
  665.     {
  666.         eTs = KB_SI_EIT_OTHER_TS;
  667.     }
  669.     if (FALSE == gatNvod[TsSequence].SearchStartFlag
  670.         && FALSE == gatNvod[TsSequence].SearchCompleteFlag)
  671.     {          
  672.         //该标志的作用是防止本频点无NVOD参考事件, 产生死循环
  673.         NeedSrhPFFlag = TRUE;
  674.         for(i=0; i<gNvodRefSvcNum; i++)
  675.         {
  676.          if (((UINT32)gNvodSvcInfo[i].freq*100) == gatNvod[TsSequence].TsPara.frequency)
  677.          {
  678.              KD_NVODGetPF(gNvodSvcInfo[i].TsID, 
  679.                         gNvodSvcInfo[i].refScvId, 
  680.                         eTs);
  681.                 ++gatNvod[TsSequence].RefSrvNum;  //通常1个RefSrv只含有1一个RefEvent
  682.                 StartFlag = TRUE;
  683.          }
  684.         }
  685.     }
  687.     //本频点无NVOD参考事件, 无需继续搜索, 仅将标志设置即可
  688.     if (TRUE == NeedSrhPFFlag && FALSE == StartFlag)
  689.     {
  690.         gatNvod[TsSequence].SearchStartFlag = TRUE;
  691.         gatNvod[TsSequence].SearchCompleteFlag = TRUE;
  692.         printf("nWARNING: KB_NVODGetEitPF::there is no EIT-PF on the fre(%ld)",
  693.                 gatNvod[TsSequence].TsPara.frequency);
  694.     }
  696.     if (TRUE == StartFlag)
  697.     {
  698.         gatNvod[TsSequence].SearchStartFlag = TRUE;        
  699.         CurrentSearchTsNum = TsSequence;
  700.         CurrentPFCompleteFlag = 0;
  701.     }
  702.     //如果本频点无参考事件需要查找, 则启动下一个未搜索的TS流的数据搜索
  703.     else 
  704.     {
  705.         NullDataTsNum = KB_NVOD_GetNullPFTsNum();
  707.         //用户正在播放本频点节目时,不切换频点, 只搜索本频点数据
  708.         if (NVOD_Play != gPrgPlayStatus
  709.             && NullDataTsNum < KB_NVOD_MAX_TS_NUM)
  710.         {
  711.             //启动下一个Ts的参考事件搜索
  712.             printf("nKB_NVODGetEitPF::本频点(%d)无参考事件需要搜索, 启动下一个Ts的参考事件搜索",
  713.                     gatNvod[TsSequence].TsPara.frequency);
  714.             KD_NVODStopAllPF();
  715.             KB_DMDDropSignal();
  717.             pTsPara = KB_NVOD_GetTsParaFromTsSequence(NullDataTsNum);
  718.             if (NULL == pTsPara)
  719.             {
  720.                 printf("nKB_NVODGetEitSch::KB_NVOD_GetTsParaFromTsSequence error!n");
  721.                 return RETFIAL1;
  722.             }
  723.             KB_DMDConnectSignal(pTsPara);
  724.             KB_OSPTaskDelay(50);
  725.             KB_NVODGetEitPF(NullDataTsNum);
  726.         }
  727.         //如果所有的参考事件已经搜索完成, 则启动时移事件搜索
  728.         else
  729.         {
  730.             printf("nKB_NVODGetEitPF::所有的参考事件已经搜索完成, 则启动时移事件搜索");
  731.             KD_NVODStopAllPF();
  732.             
  733.             message.Word1 = MOD_NVOD;
  734. message.Word2 = KB_NVOD_OVER;
  735. message.Word3 = 0;
  736. message.Word4 = 0;
  737. KB_MENUTranslateMsg(&message);
  738.             
  739.             CurrentTsNum = KB_NVOD_GetCurrentTsNum();
  740.             if ((UINT32)(-1) == CurrentTsNum)
  741.             {
  742.                 printf("nKB_NVODGetEitPF::serious error! KB_NVOD_GetCurrentTsNum fail!n");
  743.                 return  RETFIAL1;
  744.             }
  746.             KB_NVODGetEitSch(CurrentTsNum);
  747.         }
  748.     }
  750.     return RETOK;
  751. }
  753. //目前仅搜索当前流SCh的0x50, 0x51表; 若不够用,可按模式添加
  754. //本函数仅负责0x50表， 其扩展表0x51的搜索在KD_NVODHandleEitSch进行
  755. static INT32 KB_NVODGetEitSch(UINT32 TsSequence)
  756. {
  757.     int i, j;
  758.     UINT32   NullDataTsNum = (UINT32)(-1);
  759.     //UINT32   CurrentTsNum = (UINT32)(-1);
  760.     BOOL    StartFlag = FALSE;
  761. KB_SIEitTs eTs;
  762.     //KB_OSPMsgNode message;
  763.     KB_DMDTunerParameters  *pTsPara = NULL;
  765.     //搜索总是从PF开始, 所以在这里不再无需再作数据完整性检查
  766.     //这里仅启动0x50的搜索, 0x51的搜索在KD_NVODHandleEitSch启动
  767.     if (TsSequence == KB_NVOD_GetCurrentTsNum())
  768.     {
  769.         eTs = KB_SI_EIT_CURRENT_TS;
  770.         gNvodEitSchTableSwitchFlag = KB_EIT_SCHEDULE_CURRENT_TS_TABLE_DEFAULT;
  771.         //printf("nKB_NVODGetEitSch::eTs = KB_SI_EIT_CURRENT_TSn");
  772.     }
  773.     else
  774.     {
  775.         eTs = KB_SI_EIT_OTHER_TS;
  776.         gNvodEitSchTableSwitchFlag = KB_EIT_SCHEDULE_OTHER_TS_TABLE_DEFAULT;
  777.         //printf("nKB_NVODGetEitSch::eTs = KB_SI_EIT_OTHER_TSn");
  778.     }
  779.     
  780.     if (FALSE == gatNvod[TsSequence].SearchCompleteFlag)
  781.     {
  782.         for(i=0; i<gNvodRefSvcNum; i++)
  783.         {
  784.          if (((UINT32)gNvodSvcInfo[i].freq*100) == gatNvod[TsSequence].TsPara.frequency)
  785.          {
  786.              for (j = 0; j < gNvodSvcInfo[i].shiftSvcNum; j++)
  787.                 {
  788.                     KD_NVODGetSchTimeShift(gNvodSvcInfo[i].shiftSvc[j].tsId, 
  789.                                        gNvodSvcInfo[i].shiftSvc[j].svcId, 
  790.                                        eTs);
  791.                 }
  792.                 StartFlag = TRUE;
  793.          }
  794.         }
  795.     }
  797.     if (TRUE == StartFlag)
  798.     {
  799.         CurrentSearchTsNum = TsSequence;
  800.         gSvcNum   = gatNvod[TsSequence].RefSrvNum;
  801.         gArriveNum = 0;
  802.     gTimeOutNum = 0;
  803.         //printf("nKB_NVODGetEitSch::gSvcNum(%d), gNvodRefSvcNum(%d)n",
  804.         //        gSvcNum, gNvodRefSvcNum);
  805.        
  806.         for(i = 0; i < gNvodRefSvcNum; i ++)
  807. {
  808. gRecieveState[i].recvSvcNum = 0;
  809. }
  810.     }
  811.     //如果本频点无参考事件需要查找, 则启动下一个未搜索频点的数据搜索
  812.     else 
  813.     {
  814.         printf("nKB_NVODGetEitSch::本频点无参考事件需要查找, 则启动下一个未搜索频点的数据搜索n");
  815.         NullDataTsNum = KB_NVOD_GetNullSchTsNum();
  817.         //用户正在播放本频点节目时,不切换频点, 只搜索本频点数据
  818.         if (NVOD_Play != gPrgPlayStatus
  819.             && NullDataTsNum < KB_NVOD_MAX_TS_NUM)
  820.         {
  821.             //启动下一个Ts的时移事件搜索
  822.             KD_NVODStopAllPF();
  823.             KD_NVODStopAllSch();
  824.             KB_DMDDropSignal();
  826.             pTsPara = KB_NVOD_GetTsParaFromTsSequence(NullDataTsNum);
  827.             if (NULL == pTsPara)
  828.             {
  829.                 printf("nKB_NVODGetEitSch::KB_NVOD_GetTsParaFromTsSequence error!n");
  830.                 return RETFIAL1;
  831.             }
  832.             KB_DMDConnectSignal(pTsPara);
  833.             KB_OSPTaskDelay(50);
  834.             KB_NVODGetEitSch(NullDataTsNum);
  835.         }
  836.         //如果所有的时移事件已经搜索完成, 则停止所有搜索,发送刷新消息到MENU
  837.         else
  838.         {
  839.          KB_OSPMsgNode movie_msg;
  840.             KD_NVODStopAllPF();
  841.         KD_NVODStopAllSch();
  842.             
  843.             KB_TimerDisable(EitSrhTimer);
  844.             printf("nKB_NVODGetEitSch::关闭定时期 EitSrhTimer");
  845.             //message.Word1 = MOD_NVOD;
  846. // message.Word2 = KB_NVOD_OVER;
  847. // message.Word3 = 0;
  848. // message.Word4 = 0;
  851. movie_msg.Word1 = KB_MOVIE_NVOD_TO_MOVIE;
  852. kb_machblue_task_post(&movie_msg);
  853. printf("nKB_NVODGetEitSch::XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
  855.         }
  856.     }
  858.     return RETOK;
  859. }
  863. int KB_NVODAddTime(UINT16 SerID,UINT16 refSerID,UINT16 evtID,UINT16 refEvtID,time_t start_time)
  864. {
  865. int index, ShiftEventNum, i = 0;
  866. //int add = 0;
  867.     UINT16 TsId = 0;
  870. index = KB_NVODFindEveInd(CurrentSearchTsNum, refSerID, refEvtID);
  871. if(index == -1)
  872. {
  873. return 0;
  874. }
  876. #if 0
  877. gSchTime = gNvodTime + 24 * 3600;//AcquireSixTime(pT);
  878. start_time += 8*3600;
  879. if((gatNvod[index].refSerID == refSerID) && (gatNvod[index].refEvtID == refEvtID ))
  880. {
  881. if( start_time + gatNvod[index].durTime < gNvodTime)
  882. {
  883. add = -1;
  884. }
  885. else  if( start_time + gatNvod[index].durTime > gSchTime )
  886. {
  887. add = -2;
  888. }
  889. else if((( start_time >= gNvodTime) && (start_time + gatNvod[index].durTime <= gSchTime))
  890.  || (( start_time < gNvodTime) && (start_time + gatNvod[index].durTime >= gNvodTime)))
  891. {
  892. add = 1;
  893. }
  894. }
  895. #endif
  896.     
  897. #if 0
  898.     //抛弃过期的SCH事件
  899.     if (0 == gNvodTime)
  900.     {
  901.         printf("nKB_NVODAddTime::gNvodTime 未获取");
  902.     }
  903.     else
  904.     {
  905.         if (start_time + gatNvod[CurrentSearchTsNum].RefEventData[index].durTime < gNvodTime)
  906.         {
  907.             return 0;
  908.         }
  909.     }
  910. #endif
  911. //if(add == 1)
  912. //{
  913. //if(gatNvod[index].TimeNum >= 200)
  914. //{
  915. // quicksortEit(gatNvod[index].TimeNode,0,gatNvod[index].TimeNum - 1);
  916. // gatNvod[index].TimeNum = 120;
  917. //return;
  918. //}
  920.     //超出最大限制  
  921.     ShiftEventNum = gatNvod[CurrentSearchTsNum].RefEventData[index].TimeNum;
  922.     if (ShiftEventNum >= 500)
  923. {
  924.     printf("nKB_NVODAddTime::ShiftEventNum 超出最大限制 n");
  925.         return 0;
  926.     }
  928.     //防止重复添加
  929.     for (i = 0; i < gatNvod[CurrentSearchTsNum].RefEventData[index].TimeNum; i++)
  930.     {
  931.         if (gatNvod[CurrentSearchTsNum].RefEventData[index].TimeNode[i].EvtID == evtID
  932.         &&gatNvod[CurrentSearchTsNum].RefEventData[index].TimeNode[i].SerID == SerID
  933.         &&gatNvod[CurrentSearchTsNum].RefEventData[index].TimeNode[i].startTime == start_time)
  934.         {
  935.             return 0;
  936.         }
  937.     }
  939.     if (RET_OK != KB_DBGetTsIDByFre(&TsId, 
  940.                                  gatNvod[CurrentSearchTsNum].TsPara.frequency/ 100))
  941.     {
  942.         printf("nKB_NVODAddTime::serious error! KB_DBGetTsIDByFre fail!n");
  943.         return 0;
  944.     }
  945.     
  946.     if (0 != TsId)
  947. {
  948.         gatNvod[CurrentSearchTsNum].RefEventData[index].TimeNode[ShiftEventNum].tsID = TsId;
  949. }
  950. gatNvod[CurrentSearchTsNum].RefEventData[index].TimeNode[ShiftEventNum].EvtID = evtID;
  951. gatNvod[CurrentSearchTsNum].RefEventData[index].TimeNode[ShiftEventNum].SerID = SerID;
  952. gatNvod[CurrentSearchTsNum].RefEventData[index].TimeNode[ShiftEventNum].startTime = start_time;
  953. gatNvod[CurrentSearchTsNum].RefEventData[index].TimeNum ++;
  954. //}
  956. return 1;
  957. }
  959. int KB_NVODFindEveInd(UINT32 TsSequence, UINT16 refSerID,UINT16 refEvtID)
  960. {
  961. int i;
  963. for(i = 0;i<gatNvod[TsSequence].RefEventNum; i++)
  964. {
  965. if((gatNvod[TsSequence].RefEventData[i].refEvtID == refEvtID) 
  966.             && (gatNvod[TsSequence].RefEventData[i].refSerID == refSerID))
  967. {
  968. return i;
  969. }
  970. }
  971. return -1;
  972. }
  974. int KB_NVODAddRefSvc(unsigned short tsID,
  975. unsigned short  refEvtID,
  976. unsigned short  refSerID,
  977. char  *PrgName,
  978. char *PrgTxt,
  979. UINT16  durTime)
  980. {
  981. int i;
  982. //int index;
  983. int len;
  984.     UINT8  EventNum;
  986. if((PrgName == NULL) || (PrgTxt == NULL) )
  987. {
  988. return -1;
  989. }
  991. if(gatNvod[CurrentSearchTsNum].RefEventNum >= KB_NVOD_MAX_RefEvent_One_Ts)
  992. {
  993. return -1;
  994. }
  996.     //目前本ts流的参考事件数目
  997.     EventNum = gatNvod[CurrentSearchTsNum].RefEventNum;
  998. for( i = 0;i < EventNum;i++)
  999. {
  1000. if((gatNvod[CurrentSearchTsNum].RefEventData[i].refEvtID ==refEvtID ) 
  1001.            && (gatNvod[CurrentSearchTsNum].RefEventData[i].refSerID ==refSerID ))
  1002. {
  1003. return -1;
  1004. }
  1005. }
  1007. gatNvod[CurrentSearchTsNum].RefEventData[EventNum].durTime = durTime;
  1008. gatNvod[CurrentSearchTsNum].RefEventData[EventNum].refSerID = refSerID;
  1009. gatNvod[CurrentSearchTsNum].RefEventData[EventNum].refEvtID = refEvtID;
  1011. memcpy(gatNvod[CurrentSearchTsNum].RefEventData[EventNum].PrgName,
  1012.             PrgName,
  1013.             30);
  1014. gatNvod[CurrentSearchTsNum].RefEventData[EventNum].PrgName[28] = '';
  1015. gatNvod[CurrentSearchTsNum].RefEventData[EventNum].PrgName[29] = '';
  1017. len = strlen(PrgTxt);
  1018. if(len >= 400)
  1019. {
  1020. len = 390;
  1021. }
  1022. memcpy(gatNvod[CurrentSearchTsNum].RefEventData[EventNum].PrgTxt,
  1023.             PrgTxt,
  1024.             len);
  1026. gatNvod[CurrentSearchTsNum].RefEventNum++;
  1027. return 0;
  1028. }
  1030. //static void KD_NVODHandleMsg3(KB_OSPMsgNode *pInMsg)
  1031. //{
  1032. // int j;
  1033. //
  1034. // for(j = 0;j<nvodEvent;j++)
  1035. // {
  1036. // quicksortEit(gatNvod[j].TimeNode,0,gatNvod[j].TimeNum - 1);
  1037. // }
  1038. //}
  1040. INT32 KB_NVODHandleMsg(KB_OSPMsgNode *pInMsg)
  1041. {
  1042.     //UINT32        CurrentTsNum = (UINT32)(-1);
  1043. KB_OSPMsgNode pSendMsg;
  1044. //KB_DMDTunerParameters    ts;
  1046.     switch (pInMsg->Word1)
  1047.     {
  1048.     case MOD_NVOD: 
  1049.         {
  1050.     switch (pInMsg->Word2)
  1051.     {
  1052.     case KB_NVOD_PF_OVER:
  1053.         
  1054.         break;
  1055.     case KB_NVOD_PF_TIMEOUT:
  1056.         {
  1057.          gTimeOutNum++;
  1058.          if(KD_NVODRefSvcReceiveStatus((UINT16)pInMsg->Word4, TRUE))
  1059.          {
  1060.          KD_NVODStopAllSch();
  1061. gNvodEitSchTableSwitchFlag = KB_EIT_SCHEDULE_CURRENT_TS_TABLE_DEFAULT;
  1063. //if (gFreqInd == gFreqNum)
  1064. {
  1065.          pSendMsg.Word1 = pInMsg->Word1;
  1066.          pSendMsg.Word2 = KB_NVOD_OVER;
  1067.          pSendMsg.Word3 = 0;
  1068.          pSendMsg.Word4 = 0;
  1069. KB_MENUTranslateMsg(&pSendMsg);
  1070. }
  1071. #if 0
  1072. else
  1073. {
  1074.         KB_EPGStopAllSCH();
  1075.     KD_NVODStopAllPF();
  1076.     KD_NVODStopAllSch();
  1077. KB_DMDDropSignal();
  1079. ts = gNvodRefFre[gFreqInd];
  1080. gSvcNum = gNvodRefSvcEachFre[gFreqInd];
  1081. gArriveNum = 0;
  1082. gTimeOutNum = 0;
  1083. gFreqInd++;
  1084. KB_DMDConnectSignal(&ts);
  1085.                             if (RET_OK != KB_NVOD_SetCurrentTsPara(ts))
  1086.                             {
  1087.                                 printf("nKB_NVODHandleMsg::KB_NVOD_SetCurrentTsPara fail!n");
  1088.                                 return KB_DB_DTV_FAILURE;
  1089.                             }
  1090. //memcpy(&NvodCurrentTs, &ts, sizeof(KB_DMDTunerParameters));
  1091. }
  1092. #endif
  1093. }
  1094.         }
  1095.         break;
  1096.     case KB_NVOD_SCH_OVER:
  1097.         {
  1098.         //KB_NVODHandleMsg(pInMsg);
  1100. KD_NVODHandleEitSch(pInMsg);
  1101.         }
  1102.         break;
  1103. case KB_NVOD_SCH_TIMEOUT:
  1104. KD_NVODHandleEitSch(pInMsg);
  1105. break;
  1106.     default:
  1107.         break;
  1108.     }
  1109.         }
  1110.         break;
  1111.     default :
  1112.      break;
  1113.     }
  1114. return 0;
  1116. }
  1118. INT32 KB_NVODGetPrgNum(UINT32 TsSequence)
  1119. {
  1120. return gatNvod[TsSequence].RefEventNum;
  1121. }
  1123. char *KB_NVODGetPrgName(UINT32 TsSequence, INT32 RefEventIndex)
  1124. {
  1125. if(RefEventIndex < 0 
  1126.    || RefEventIndex >= KB_NVOD_MAX_RefEvent_One_Ts 
  1127.    || TsSequence >= KB_NVOD_MAX_TS_NUM)
  1128. {
  1129. return NULL;
  1130. }
  1132. return gatNvod[TsSequence].RefEventData[RefEventIndex].PrgName;
  1133. }
  1135. char *KB_NVODGetPrgContent(UINT32 TsSequence, INT32 RefEventIndex)
  1136. {
  1137. if(RefEventIndex < 0 
  1138.    || RefEventIndex >= KB_NVOD_MAX_RefEvent_One_Ts 
  1139.    || TsSequence >= KB_NVOD_MAX_TS_NUM)
  1140. {
  1141. return NULL;
  1142. }
  1144. return gatNvod[TsSequence].RefEventData[RefEventIndex].PrgTxt;
  1145. }
  1147. INT32 KB_NVODGetPrgDuring(UINT32 TsSequence, INT32 RefEventIndex)
  1148. {
  1149. if(RefEventIndex < 0 
  1150.    || RefEventIndex >= KB_NVOD_MAX_RefEvent_One_Ts 
  1151.    || TsSequence >= KB_NVOD_MAX_TS_NUM)
  1152. {
  1153. return 0;
  1154. }
  1156. return (INT32)(gatNvod[TsSequence].RefEventData[RefEventIndex].durTime);
  1157. }
  1159. INT32 KB_NVODGetPrgTimeNum(UINT32 TsSequence, INT32 RefEventIndex)
  1160. {
  1161. if(RefEventIndex < 0 
  1162.    || RefEventIndex >= KB_NVOD_MAX_RefEvent_One_Ts 
  1163.    || TsSequence >= KB_NVOD_MAX_TS_NUM)
  1164. {
  1165. return 0;
  1166. }
  1168. return (INT32)(gatNvod[TsSequence].RefEventData[RefEventIndex].TimeNum);
  1169. }
  1171. BOOL KB_NVODGetPrgRefSvcFlag(UINT32 TsSequence, 
  1172.                                   INT32 RefEventIndex, 
  1173.                                   UINT16 nRefSvcID)
  1174. {
  1175. if(RefEventIndex < 0 
  1176.    || RefEventIndex >= KB_NVOD_MAX_RefEvent_One_Ts 
  1177.    || TsSequence >= KB_NVOD_MAX_TS_NUM)
  1178. {
  1179. return 0;
  1180. }
  1182. return (gatNvod[TsSequence].RefEventData[RefEventIndex].refSerID == nRefSvcID);
  1183. }
  1185. time_t KB_NVODGetPrgStartTime(UINT32 TsSequence, 
  1186.                                    INT32 RefEventIndex, 
  1187.                                    INT32 ShiftEventIndex)
  1188. {
  1189. if(RefEventIndex < 0 
  1190.    || RefEventIndex >= KB_NVOD_MAX_RefEvent_One_Ts 
  1191.    || TsSequence >= KB_NVOD_MAX_TS_NUM)
  1192. {
  1193. return 0;
  1194. }
  1195. if(ShiftEventIndex<0 
  1196.    || ShiftEventIndex>=(INT32)(gatNvod[TsSequence].RefEventData[RefEventIndex].TimeNum))
  1197. {
  1198. return 0;
  1199. }
  1201. return gatNvod[TsSequence].RefEventData[RefEventIndex].TimeNode[ShiftEventIndex].startTime;
  1202. }
  1205. static BOOL KD_NVODRefSvcReceiveStatus(UINT16 refScvId, BOOL bTimeout)
  1206. {
  1207. int i;
  1209.   if(refScvId == (UINT16)(-1))
  1210.   {
  1211.   gArriveNum++;
  1212.   }
  1213.   else
  1214.   {
  1215. if(!bTimeout)
  1216. {
  1217. for(i=0; i<gSvcNum; i++)
  1218. {
  1219. if(gRecieveState[i].refScvId == refScvId)
  1220. {
  1221. ++gRecieveState[i].recvSvcNum;
  1223. if( gRecieveState[i].recvSvcNum == gRecieveState[i].shiftSvcNum)
  1224. {
  1225.     gArriveNum++;
  1226. }
  1228. break;
  1229. }
  1230. }
  1231. }
  1232. }
  1234.     if((UINT32)gArriveNum+ (UINT32)gTimeOutNum == gSvcNum)
  1235.     {
  1236.      return TRUE;
  1237.     }
  1239. return FALSE;
  1240. }
  1242. BOOL KB_NVODGetTimeInfo(UINT32 TsSequence, 
  1243.                             INT32 RefEventIndex, 
  1244.                             INT32 ShiftEventIndex,
  1245. INT32 *nTsId, 
  1246. INT32 *nSvcID)
  1247. {
  1248. unsigned short serID,refSerID;
  1249. int i,j;
  1251. if(RefEventIndex < 0 
  1252.    || RefEventIndex >= KB_NVOD_MAX_RefEvent_One_Ts 
  1253.    || TsSequence >= KB_NVOD_MAX_TS_NUM)
  1254. {
  1255. return FALSE;
  1256. }
  1257. if(ShiftEventIndex<0 
  1258.    || ShiftEventIndex>=(INT32)(gatNvod[TsSequence].RefEventData[RefEventIndex].TimeNum))
  1259. {
  1260. return FALSE;
  1261. }
  1263. *nSvcID = gatNvod[TsSequence].RefEventData[RefEventIndex].TimeNode[ShiftEventIndex].SerID;
  1265. refSerID = gatNvod[TsSequence].RefEventData[RefEventIndex].refSerID;
  1266. serID = gatNvod[TsSequence].RefEventData[RefEventIndex].TimeNode[ShiftEventIndex].SerID;
  1268. for(i = 0;i<gSvcNum;i++)
  1269. {
  1270. if(gNvodSvcInfo[i].refScvId == refSerID)
  1271. {
  1272. for(j = 0;j<gNvodSvcInfo[i].shiftSvcNum;j++)
  1273. {
  1274. if(gNvodSvcInfo[i].shiftSvc[j].svcId ==serID)
  1275. {
  1276. *nTsId = gNvodSvcInfo[i].shiftSvc[j].tsId;
  1277. return TRUE;
  1278. }
  1279. }
  1280. }
  1281. }
  1283. return FALSE;
  1284. }
  1286. INT32 KB_NVODGetClassNum(void)
  1287. {
  1288. return gNvodRefSvcNum;
  1289. }
  1291. char *KB_NVODGetClassName(INT32 index)
  1292. {
  1293. if(index<0 || index>=gNvodRefSvcNum)
  1294. {
  1295. return NULL;
  1296. }
  1298. return (char *)gNvodSvcInfo[index].refScvName;
  1299. }
  1301. UINT16 KB_NVODGetClassRefSvc(INT32 index)
  1302. {
  1303. if(index<0 || index>=gNvodRefSvcNum)
  1304. {
  1305. return (UINT16)-1;
  1306. }
  1308. return gNvodSvcInfo[index].refScvId;
  1309. }
  1311. void KB_NVODSetNewFlag(BOOL bFlag)
  1312. {
  1313. gNewFlag = bFlag;
  1314. }
  1316. BOOL KB_NVODGetNewFlag(void)
  1317. {
  1318. return gNewFlag;
  1319. }
  1321. void KB_NVODSetPrgEnd(time_t tTime)
  1322. {
  1323. gPrgEndTime = tTime;
  1324. }
  1326. time_t KB_NVODGetPrgEnd(void)
  1327. {
  1328. return gPrgEndTime;
  1329. }
  1331. static void KD_NVODHandleEitSch(KB_OSPMsgNode *pInMsg)
  1332. {
  1333. UINT16 time_shifted_service_id = 0xffff;
  1334. UINT16 reference_Service_id = 0xffff;
  1335. UINT16 shiftSvcNum;
  1336. UINT32 i,j;
  1337.     UINT32   NullDataTsNum = (UINT32)(-1);
  1338. KB_OSPMsgNode message;
  1339. //KB_DMDTunerParameters    ts;
  1340.     KB_DMDTunerParameters    *pTsPara = NULL;
  1342. time_shifted_service_id = (UINT16)pInMsg->Word3;
  1344. for(i=0; i<gNvodRefSvcNum; i++)
  1345. {
  1346.     shiftSvcNum = gNvodSvcInfo[i].shiftSvcNum;
  1347. for(j=0; j<shiftSvcNum; j++)
  1348. {
  1349. if (time_shifted_service_id == gNvodSvcInfo[i].shiftSvc[j].svcId)
  1350. {
  1351. reference_Service_id = gNvodSvcInfo[i].refScvId;
  1352. break;
  1353. }
  1354. }
  1356. if (reference_Service_id != 0xffff)
  1357. {
  1358. break;
  1359. }
  1360. }
  1362. for(i=0; i<KB_NVOD_MAX_REF; i++)
  1363. {
  1364. if (gRecieveState[i].refScvId == reference_Service_id)
  1365. {
  1366. gRecieveState[i].recvSvcNum++;                  
  1367. break;
  1368. }
  1369. }
  1371. if( gRecieveState[i].recvSvcNum == gRecieveState[i].shiftSvcNum)
  1372. {
  1373.      gArriveNum++;
  1374.     //printf("nKD_NVODHandleEitSch::gArriveNum++, gArriveNum(%d), gSvcNum(%d)n", 
  1375.         //        gArriveNum, gSvcNum);
  1376. }
  1378. if((UINT32)gArriveNum+ (UINT32)gTimeOutNum == gSvcNum)
  1379.     {
  1380. KD_NVODStopAllSch();
  1381. #if 1
  1382. message.Word1 = MOD_NVOD;
  1383. message.Word2 = KB_NVOD_OVER;
  1384. message.Word3 = 0;
  1385. message.Word4 = 0;
  1386. KB_MENUTranslateMsg(&message);
  1387. #endif
  1388.         //printf("nKD_NVODHandleEitSch::gArriveNum == gSvcNumn");
  1389.         
  1390.         switch(gNvodEitSchTableSwitchFlag)
  1391.         {
  1392.             //增加对表0x51的处理
  1393.             case KB_EIT_SCHEDULE_CURRENT_TS_TABLE_DEFAULT:
  1394. #if 0
  1395.                 //printf("nKD_NVODHandleEitSch::EIT_SCHEDULE_DONE 0x50n");
  1396.                 {
  1397.                     gNvodEitSchTableSwitchFlag = KB_EIT_SCHEDULE_CURRENT_TS_TABLE_0X51;
  1398.                     gArriveNum = 0;
  1399.              gTimeOutNum = 0;
  1400.                     for(i = 0; i < gNvodRefSvcNum; i ++)
  1401.              {
  1402.              gRecieveState[i].recvSvcNum = 0;
  1403.              }
  1405.                     if (FALSE == gatNvod[CurrentSearchTsNum].SearchCompleteFlag)
  1406.                     {
  1407.                         for(i = 0; i <gNvodRefSvcNum; i++)
  1408.                      {
  1409.                      if ((gNvodSvcInfo[i].freq*100) == gatNvod[CurrentSearchTsNum].TsPara.frequency)
  1410.                      {
  1411.                                 for (j = 0; j < gNvodSvcInfo[i].shiftSvcNum; j++)
  1412.                                 {
  1413.                               KD_NVODGetSchTimeShift(gNvodSvcInfo[i].shiftSvc[j].tsId, 
  1414.                                                      gNvodSvcInfo[i].shiftSvc[j].svcId, 
  1415.                                                      KB_SI_EIT_CURRENT_TS_FOR_0x51_table);
  1416.                                 }
  1417.                      }
  1418.                         }
  1419.                     }
  1420.                 }
  1421.                 break;
  1423.             //当前流0x50、0x51搜索完成， 首次启动各个其他流的搜索, 先找0x60
  1424.             case KB_EIT_SCHEDULE_CURRENT_TS_TABLE_0X51:
  1425. #endif
  1426.                 //printf("nKD_NVODHandleEitSch::EIT_SCHEDULE_DONE 0x51n");
  1427.                 {
  1428.                      gatNvod[CurrentSearchTsNum].SearchCompleteFlag = TRUE;
  1429. #if 0
  1430.                     message.Word1 = MOD_NVOD;
  1431.                     message.Word2 = KB_NVOD_OVER;
  1432.                     message.Word3 = 0;
  1433.                     message.Word4 = 0;
  1434.                     KB_MENUTranslateMsg(&message);
  1435. #endif        
  1436.                     NullDataTsNum = KB_NVOD_GetNullSchTsNum();
  1438.                     //用户正在播放本频点节目时,不切换频点, 只搜索本频点数据
  1439.                     if (NVOD_Play != gPrgPlayStatus
  1440.                         && NullDataTsNum < KB_NVOD_MAX_TS_NUM)
  1441.                     {
  1442.                         //启动下一个其他流的时移事件搜索
  1443.                         KD_NVODStopAllPF();
  1444.                         KB_DMDDropSignal();
  1446.                         pTsPara = KB_NVOD_GetTsParaFromTsSequence(NullDataTsNum);
  1447.                         if (NULL == pTsPara)
  1448.                         {
  1449.                             printf("nKD_NVODHandleEitSch::KB_NVOD_GetTsParaFromTsSequence error!n");
  1450.                             return;
  1451.                         }
  1452.                         KB_DMDConnectSignal(pTsPara);
  1453.                         KB_OSPTaskDelay(50);
  1454.                         KB_NVODGetEitSch(NullDataTsNum);
  1455.                     }
  1456.                     else
  1457.                     {
  1458.                      KB_OSPMsgNode movie_msg;
  1460. movie_msg.Word1 = KB_MOVIE_NVOD_TO_MOVIE;
  1461. kb_machblue_task_post(&movie_msg);
  1462.                         KB_TimerDisable(EitSrhTimer);
  1463.                         printf("nKD_NVODHandleEitSch::关闭定时期 EitSrhTimer");
  1464.                          printf("nKD_NVODHandleEitSch::没有其他流SCHn");
  1465.                     }
  1466.                 }
  1467.                 break;
  1469. //目前流程下面的代码不会执行到
  1470. #if 0
  1471.             //启动0x61的搜索
  1472.             case KB_EIT_SCHEDULE_OTHER_TS_TABLE_DEFAULT:
  1473.                 printf("nKD_NVODHandleEitSch::EIT_SCHEDULE_DONE 0x60n");
  1474.                 {
  1475.                     gNvodEitSchTableSwitchFlag = KB_EIT_SCHEDULE_OTHER_TS_TABLE_0X61;
  1476.                     gArriveNum = 0;
  1477.              gTimeOutNum = 0;
  1478.                     for(i = 0; i < gNvodRefSvcNum; i ++)
  1479.              {
  1480.              gRecieveState[i].recvSvcNum = 0;
  1481.              }
  1482.                     
  1483.                     for(i = 0; i <gNvodRefSvcNum; i++)
  1484.                  {
  1485.                  if ((gNvodSvcInfo[i].freq*100) == gatNvod[CurrentSearchTsNum].TsPara.frequency
  1486.                             && gatNvod[CurrentSearchTsNum].SearchCompleteFlag == FALSE)
  1487.                  {
  1488.                             for (j = 0; j < gNvodSvcInfo[i].shiftSvcNum; j++)
  1489.                             {
  1490.                           KD_NVODGetSchTimeShift(gNvodSvcInfo[i].shiftSvc[j].tsId, 
  1491.                                                  gNvodSvcInfo[i].shiftSvc[j].svcId, 
  1492.                                                  KB_SI_EIT_OTHER_TS_FOR_0x61_table);
  1493.                             }
  1494.                  }
  1495.                     }
  1496.                 }
  1497.                 break;
  1499.             //非首次启动其他频点的参考事件搜索
  1500.             case KB_EIT_SCHEDULE_OTHER_TS_TABLE_0X61:
  1501.                 printf("nKD_NVODHandleEitSch::EIT_SCHEDULE_DONE 0x61n");
  1502.                 {
  1503.                     gatNvod[CurrentSearchTsNum].SearchCompleteFlag = TRUE;
  1504.                     NullDataTsNum = KB_NVOD_GetNullSchTsNum();
  1505.                     //启动下一个其他流的时移事件搜索
  1506.                     if (NullDataTsNum < KB_NVOD_MAX_TS_NUM)
  1507.                     {
  1508.                         KB_NVODGetEitSch(NullDataTsNum);
  1509.                     }
  1510.                 }
  1511.                 break;
  1512. #endif
  1513.             default:
  1514.                 printf("nKD_NVODHandleEitSch::error!");
  1515.                 break;
  1516.         }
  1517. }
  1518. }
  1521. static INT32 KD_NVODInitTask(void)
  1522. {
  1523.     int i;
  1525.     gNvodPF = KB_OSPMalloc(sizeof(KB_SIEitPF) * KB_SI_MAX_REF_SVC_NUMS);  
  1526.     gNvodPFEvent = KB_OSPMalloc(sizeof(KB_SINVODEitPF) * KB_SI_MAX_REF_SVC_NUMS * KB_SI_EIT_PF_MAX_NVOD_EVENT_NUMBER);
  1528.     if (gNvodPF == NULL)
  1529.     {
  1530.         printf("KD_NVODInitTask gNvodPF == NULLn");
  1531.         return RETFAIL2;
  1532.     }
  1533.     else
  1534.     {
  1535.         for (i = 0; i < KB_SI_MAX_REF_SVC_NUMS; i++)
  1536.         {
  1537.             gNvodPFInfo[i].nTsId        = 0xFFFFFFFF;
  1538.             gNvodPFInfo[i].nEnable      = TRUE;
  1539.             gNvodPFInfo[i].nState       = KB_NVOD_EMPTY;
  1540.             gNvodPFInfo[i].nSvcID   = 0xFFFFFFFF;
  1541.             gNvodPFInfo[i].pPresent = gNvodPF + i;
  1542.             gNvodPFInfo[i].pPresent->NVODEvent = gNvodPFEvent + i * KB_SI_EIT_PF_MAX_NVOD_EVENT_NUMBER;
  1543.             
  1544.         }
  1545.     }
  1546.     
  1547.     //gNvodSchEvent = (KB_SIEitSchTimeShiftNode*)KB_EPGGetMemAddress();
  1548.     gNvodSchEvent = (KB_SIEitSchTimeShiftNode*)KB_OSPMalloc(sizeof(KB_SIEitSchTimeShiftNode) * KB_NVOD_MAX_ShiftSrv_One_Ts * KB_SI_MAX_SHIFT_EVENT_NUM_PER_SERVICE);  
  1549.     for (i = 0; i < KB_NVOD_MAX_ShiftSrv_One_Ts; i++)
  1550.     {
  1551.         gNvodSch[i].nTsId        = 0xFFFFFFFF;
  1552.         gNvodSch[i].nEnable      = TRUE;
  1553.         gNvodSch[i].nState       = KB_NVOD_EMPTY;
  1554.         gNvodSch[i].nSvcID   = 0xFFFFFFFF;
  1555.         gNvodSch[i].nSchInfo.ptTimeShift = gNvodSchEvent + i * KB_SI_MAX_SHIFT_EVENT_NUM_PER_SERVICE;
  1556.     }
  1557.     EitSrhTimer = KB_TimerCreate(KB_TIMER_ONCE,
  1558.                                  (KB_TIMER_FUNC_POINTER)KB_NvodHandleEitSrhTimeOut, 
  1559.                                  NULL);
  1560.     if (KB_TIMER_INVALID_ID == EitSrhTimer)
  1561.     {
  1562.        printf("nKD_NVODInitTask::EitSrhTimer create failed!");
  1563.     }
  1564.         
  1565.     return RETOK;
  1566. }
  1568. static void KB_NvodHandleEitSrhTimeOut(void)
  1569. {
  1570. KB_OSPMsgNode movie_msg;
  1572. KD_NVODStopAllPF();
  1573. KD_NVODStopAllSch();
  1574. movie_msg.Word1 = KB_MOVIE_NVOD_TO_MOVIE;
  1575. kb_machblue_task_post(&movie_msg);
  1576. printf("nKB_NVODGetEitSch::XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
  1577. printf("nKB_NvodHandleEitSrhTimeOut::EIT数据搜索超时");
  1579. return;
  1580. }
  1582. void KD_NVODHandleMsg2(KB_OSPMsgNode *pInMsg)
  1583. {
  1584.     UINT32   NullDataTsNum = (UINT32)(-1);
  1585.     UINT32   CurrentTsNum = (UINT32)(-1);
  1586.     KB_OSPMsgNode msgNode;
  1587.     //KB_SIEitPF *ptEitPf;
  1588.     KB_OSPMsgNode message;
  1589.     KB_DMDTunerParameters  *pTsPara = NULL;
  1590.     
  1591.     switch (pInMsg->Word1)
  1592.     {
  1593.     case MOD_SIPSI:
  1594.         
  1595.         msgNode.Word1 = J_EPG_MODULE;
  1596.         if (pInMsg->Word2 >= KB_SI_MSG_EIT_PF_DONE
  1597.             && pInMsg->Word2 <= KB_SI_MSG_EIT_SCHEDULE_TIMEOUT)
  1598.         {
  1599.             switch (pInMsg->Word2)
  1600.             {
  1601.             case KB_SI_MSG_EIT_PF_DONE: 
  1602.                 //printf("nKD_NVODHandleMsg2::SrvId(%d)n",
  1603.                 //        ((KB_SIEitPF*)pInMsg->Word3)->service_id);
  1604.                 KD_NVODHandlePFOver(pInMsg);
  1605.                 ++CurrentPFCompleteFlag;
  1606.                 if (CurrentSearchTsNum < KB_NVOD_MAX_TS_NUM
  1607.                     && CurrentPFCompleteFlag == gatNvod[CurrentSearchTsNum].RefSrvNum)
  1608.                 {
  1609.                     KD_NVODStopAllPF();
  1610.                     NullDataTsNum = KB_NVOD_GetNullPFTsNum();
  1611.                     //用户正在播放本频点节目时,不切换频点, 只搜索本频点数据
  1612.                     if (NVOD_Play != gPrgPlayStatus
  1613.                         && NullDataTsNum < KB_NVOD_MAX_TS_NUM)
  1614.                     {
  1615.                         //启动下一个Ts的参考事件搜索
  1616.                         KD_NVODStopAllPF();
  1617.                         KB_DMDDropSignal();
  1619.                         pTsPara = KB_NVOD_GetTsParaFromTsSequence(NullDataTsNum);
  1620.                         if (NULL == pTsPara)
  1621.                         {
  1622.                             printf("nKB_NVODGetEitSch::KB_NVOD_GetTsParaFromTsSequence error!n");
  1623.                             return;
  1624.                         }
  1625.                         KB_DMDConnectSignal(pTsPara);
  1626.                         KB_OSPTaskDelay(50);
  1627.                         KB_NVODGetEitPF(NullDataTsNum);
  1628.                     }
  1629.                     //如果所有的参考事件已经搜索完成, 则启动时移事件搜索
  1630.                     else
  1631.                     {
  1632.                         //printf("nKD_NVODHandleMsg2::EIT_PF_DONEn");
  1633.                         message.Word1 = MOD_NVOD;
  1634.              message.Word2 = KB_NVOD_OVER;
  1635.              message.Word3 = 0;
  1636.              message.Word4 = 0;
  1637.              KB_MENUTranslateMsg(&message);
  1638.                         
  1639.                         CurrentTsNum = KB_NVOD_GetCurrentTsNum();
  1640.                         if ((UINT32)(-1) == CurrentTsNum)
  1641.                         {
  1642.                             printf("nKD_NVODHandleMsg2::serious error! KB_NVOD_GetCurrentTsNum fail!n");
  1643.                             return;
  1644.                         }
  1646.                         KB_NVODGetEitSch(CurrentTsNum);
  1647.                     }
  1648.                 }
  1649.                 break;
  1651.             case KB_SI_MSG_EIT_PF_TIMEOUT:
  1652.                 msgNode.Word1 = MOD_NVOD;
  1653.                 msgNode.Word2 = KB_NVOD_PF_TIMEOUT;
  1654.                 msgNode.Word4 = pInMsg->Word4;
  1655.                 KB_NVODHandleMsg(&msgNode);
  1656.                 break;
  1657.                 
  1658.             case KB_SI_MSG_EIT_SCHEDULE_EVENT_DONE:
  1659.                 break;
  1660.                 
  1661.             case KB_SI_MSG_EIT_SCHEDULE_DONE: 
  1662.                 KD_NVODHandleSCHOver(pInMsg);
  1663.                 break;
  1665.             case KB_SI_MSG_EIT_SCHEDULE_TIMEOUT:
  1666.                 msgNode.Word1 = MOD_NVOD;
  1667.                 msgNode.Word2 = KB_NVOD_SCH_TIMEOUT;
  1668.                 msgNode.Word3 = pInMsg->Word4; 
  1669. msgNode.Word4 = 0xFFFFFFFF;
  1670.                 KB_NVODHandleMsg(&msgNode);
  1671.                 break;
  1672.                 
  1673.             default:
  1674.                 break;
  1675.             }           
  1676.         }                
  1677.         
  1678.         break;
  1679.     default:
  1680.         break;
  1681.     }
  1682. }
  1684. static INT32 KD_NVODGetPF(INT32 nTsId, INT32 nSvcID, KB_SIEitTs eTs)
  1685. {    
  1686.     INT32 nReturn, nNumber;
  1688.     nNumber = KD_NVODGetFreePF();
  1689.     if (nNumber == 0xFFFFFFFF)
  1690.     {
  1691.         return RETFIAL1;
  1692.     }
  1693.     nReturn = KB_SIGetEitPF(nSvcID, eTs,
  1694.                                 gNvodPFInfo[nNumber].pPresent,
  1695.                                 gNvodPFInfo[nNumber].pPresent, 
  1696.                                 KB_SI_RECEIVE_ONCE, 
  1697.                                 -1);       
  1699.     if (nReturn != 0)
  1700.     {
  1701.         return RETFIAL1;
  1702.     }
  1703.     else
  1704.     {
  1705.         gNvodPFInfo[nNumber].nTsId      = nTsId;
  1706.         gNvodPFInfo[nNumber].nSvcID = nSvcID;
  1707.         gNvodPFInfo[nNumber].nEnable    = FALSE;
  1708.         gNvodPFInfo[nNumber].nState     = KB_NVOD_RECEIVING;
  1709.         //printf("nKD_NVODGetPF::RefSrvId(%d), eTs(%d)n", nSvcID, eTs);
  1710.         return RETOK;
  1711.     }
  1712. }
  1714. static INT32 KD_NVODGetSchTimeShift(INT32 nTsId, 
  1715.                                          INT32 nSvcID, 
  1716.                                          KB_SIEitTs eTs)
  1717. {
  1718.     INT32 nNumber, nReturn;
  1720.     nNumber = KD_NVODGetFreeSch();
  1721.     if (nNumber == 0xFFFFFFFF)
  1722.     {
  1723.         return RETFIAL1;
  1724.     }
  1725.     
  1726.     nReturn = KB_SIGetEITSCHShift(nSvcID, 
  1727.                                     eTs, 
  1728.                                     &gNvodSch[nNumber].nSchInfo);
  1729.     if (nReturn != 0)
  1730.     {
  1731.         return RETFIAL1;
  1732.     }
  1733.     else
  1734.     {
  1735.         gNvodSch[nNumber].nTsId      = nTsId;
  1736.         gNvodSch[nNumber].nSvcID     = nSvcID;
  1737.         gNvodSch[nNumber].nEnable    = FALSE;
  1738.         gNvodSch[nNumber].nState     = KB_NVOD_RECEIVING;
  1739.         return RETOK;
  1740.     }
  1741. }
  1743. INT32 KD_NVODStopAllPF(void)
  1744. {
  1745.     int i;
  1747.     //对于KB_SI_STOP_ALL的情况, 第二个参数是不起作用的
  1748.     KB_SIStopEitPF(KB_SI_STOP_ALL, KB_SI_EIT_CURRENT_TS);    
  1749.         
  1750.     for (i = 0; i < KB_SI_MAX_REF_SVC_NUMS; i++)
  1751.     {
  1752.         KD_NVODResetPF(i);
  1753.     }
  1754.     return RETOK;
  1755. }
  1757. INT32 KD_NVODStopAllSch(void)
  1758. {
  1759.     int i;
  1761.     KB_SIStopEitSCHShift(KB_SI_STOP_ALL, KB_SI_EIT_CURRENT_TS);    
  1762.         
  1763.     for (i = 0; i < KB_NVOD_MAX_REF; i++)
  1764.     {
  1765.         KD_ResetSCH(i);
  1766.     }
  1767.     return RETOK;
  1768. }
  1770. static INT32 KD_NVODGetFreePF(void)
  1771. {
  1772.     INT32 i, nNumber;
  1774.     nNumber = 0xFFFFFFFF;
  1776.     for (i = 0; i < KB_SI_MAX_REF_SVC_NUMS; i++)
  1777.     {
  1778.         if (gNvodPFInfo[i].nEnable == TRUE)
  1779.         {
  1780.             nNumber = i;
  1781.             break;
  1782.         }
  1783.     }
  1785.     return nNumber;
  1786. }
  1788. static INT32 KD_NVODGetFreeSch(void)
  1789. {
  1790.     INT32 i, nNumber;
  1792.     nNumber = 0xFFFFFFFF;
  1794.     for (i = 0; i < KB_NVOD_MAX_ShiftSrv_One_Ts; i++)
  1795.     {
  1796.         if (gNvodSch[i].nEnable == TRUE)
  1797.         {
  1798.             nNumber = i;
  1799.             break;
  1800.         }
  1801.     }
  1803.     return nNumber;
  1804. }
  1806. static INT32 KD_NVODResetPF(INT32 nNumber)
  1807. {
  1808.     gNvodPFInfo[nNumber].nTsId        = 0xFFFFFFFF;    
  1809.     gNvodPFInfo[nNumber].nEnable      = TRUE;
  1810.     gNvodPFInfo[nNumber].nState       = KB_NVOD_EMPTY;
  1811.     gNvodPFInfo[nNumber].nSvcID   = 0xFFFFFFFF;    
  1812.     
  1813.     return RETOK;
  1814. }
  1816. static INT32 KD_ResetSCH(INT32 nNumber)
  1817. {
  1818.     gNvodSch[nNumber].nEnable      = TRUE;
  1819.     gNvodSch[nNumber].nState       = KB_NVOD_EMPTY;
  1820.     gNvodSch[nNumber].nSvcID   = 0xFFFFFFFF;
  1821.     gNvodSch[nNumber].nSchInfo.num = 0;
  1822.     gNvodSch[nNumber].nSchInfo.service_id = 65535;    
  1824.     return RETOK;
  1825. }
  1827. static INT32 KD_NVODHandlePFOver(KB_OSPMsgNode *pInMsg)
  1828. {
  1829.     KB_SIEitPF *ptEitPf;
  1830.     KB_SINVODEitPF *ptNvod;
  1831.     KB_OSPMsgNode msgNode;
  1832.     int i;
  1833.     
  1834.     ptEitPf = (KB_SIEitPF*)pInMsg->Word3;
  1836.     for (i = 0; i < ptEitPf->NVODEventNum; i++)
  1837.     {
  1838.         ptNvod = ptEitPf->NVODEvent + i;
  1839.         KB_NVODAddRefSvc(0, 
  1840.                           ptNvod->event_id, 
  1841.                           ptNvod->service_id, 
  1842.                           (char*)ptNvod->chinese.event_name,
  1843.                           (char*)ptNvod->chinese.text,
  1844.                           (UINT16)ptNvod->duration);        
  1845.     }
  1847.     msgNode.Word1 = MOD_NVOD;
  1848.     msgNode.Word2 = KB_NVOD_PF_OVER;
  1849.     msgNode.Word3 = ptEitPf->service_id;
  1850.     KB_NVODHandleMsg(&msgNode);
  1851.     
  1852.     return RETOK;
  1853. }
  1855. static INT32 KD_NVODHandleSCHOver(KB_OSPMsgNode *pInMsg)
  1856. {
  1857.     KB_SIEitSchTimeShift *ptShift;
  1858.     KB_SIEitSchTimeShiftNode *ptShiftEvent;
  1859.     KB_OSPMsgNode msgNode;
  1860.     int i;
  1861.     
  1862.     ptShift = (KB_SIEitSchTimeShift*)pInMsg->Word3;
  1863.     //printf("nKD_NVODHandleSCHOver::SrvId(%d), num(%d), RefSrvId(%d)",
  1864.     //        ptShift->service_id, ptShift->num, (ptShift->ptTimeShift)->reference_service_id);
  1865.     
  1866.     for (i = 0; i < ptShift->num; i++)
  1867.     {
  1868.         ptShiftEvent = ptShift->ptTimeShift + i;
  1869.         KB_NVODAddTime(ptShift->service_id, 
  1870.                     ptShiftEvent->reference_service_id,
  1871.                     ptShiftEvent->event_id,
  1872.                     ptShiftEvent->reference_event_id,
  1873.                     ptShiftEvent->start_time);
  1874.     }
  1876.     msgNode.Word1 = MOD_NVOD;
  1877.     msgNode.Word2 = KB_NVOD_SCH_OVER;
  1878.     msgNode.Word3 = ptShift->service_id; 
  1880.     if (ptShift->num == 0)
  1881.     {
  1882.         msgNode.Word4 = 0xFFFFFFFF;
  1883.     }
  1884.     else
  1885.     {
  1886.         msgNode.Word4 = ptShift->ptTimeShift->reference_service_id; 
  1887.     }
  1889.     KB_NVODHandleMsg(&msgNode);
  1890.     
  1891.     return RETOK;
  1892. }
  1894. INT32 KB_NvodGetRefEventNum(UINT32 TsSequence)
  1895. {
  1896.     return gatNvod[TsSequence].RefEventNum;
  1897. }
  1899. INT32 KB_NvodGetFreNum(UINT32 TsSequence)
  1900. {
  1901.     int i, count = 0;
  1902.     
  1903.     for (i = 0; i < KB_NVOD_MAX_TS_NUM; i++)
  1904.     {
  1905.         if (gatNvod[i].TsPara.frequency != 0)
  1906.         {
  1907.             count++;
  1908.         }
  1909.     }
  1910.     
  1911.     return count;
  1912. }
  1914. KB_NVOD_Info *KB_NvodGetRefNodeHead(void)
  1915. {
  1916.     return gatNvod;
  1917. }
  1919. #if 0
  1920. UINT16 KB_NvodGetTsIdFromRefsrvIdSrvId(UINT16 refSerID,UINT16 SerID)
  1921. {
  1922.     int i = 0, j = 0;
  1923.     UINT16   ret = 0;
  1924.         
  1925.     for (i = 0; i <gNvodRefSvcNum; i++)
  1926. {
  1927. if (gNvodSvcInfo[i].refScvId == refSerID)
  1928. {
  1929.             for (j = 0; j < gNvodSvcInfo[i].shiftSvcNum; j++)
  1930.             {
  1931.          if (gNvodSvcInfo[i].shiftSvc[j].svcId == SerID)
  1932.              {
  1933.                  ret = gNvodSvcInfo[i].shiftSvc[j].tsId;
  1934.                     break;
  1935.              }
  1936.             }
  1937. }
  1938. }
  1940.     return ret;
  1941. }
  1942. #endif
  1944. KB_NVODStruct *KB_NVOD_GetTsIndexFromCur(int CursorIndex)
  1945. {
  1946.     int i, j, count;
  1947.     KB_NVOD_Info       *pstNvodNodeHead;
  1949.     if (CursorIndex < 0)
  1950.     {
  1951.         printf("nKB_NVOD_GetTsIndexFromCur::input(%d) error!", CursorIndex);
  1952.         return NULL;
  1953.     }
  1955.     count = (int)CursorIndex;
  1956.     pstNvodNodeHead = KB_NvodGetRefNodeHead();
  1957.     
  1958.     for (i = 0; i < KB_NVOD_MAX_TS_NUM; i++)
  1959.     {
  1960.         for(j = 0; j < KB_NvodGetRefEventNum(i); j++)
  1961.         {
  1962.             if (--count < 0)
  1963.             {
  1964.                 return &(pstNvodNodeHead[i].RefEventData[j]);
  1965.             }
  1966.         }
  1967.     }
  1969.     return NULL;
  1970. }
  1972. UINT32 KB_NVOD_GetCurrentTsNum(void)
  1973. {
  1974.     int i;
  1976.     for(i = 0; i < KB_NVOD_MAX_TS_NUM; i++)
  1977.     {
  1978.         if (TRUE == gatNvod[i].CurrentTsFlag)
  1979.         {
  1980.             return i;
  1981.         }
  1982.     }
  1984.     return (UINT32)(-1);
  1985. }
  1987. static UINT32 KB_NVOD_GetNullPFTsNum(void)
  1988. {
  1989.     UINT8 i;
  1991.     for(i = 0; i < KB_NVOD_MAX_TS_NUM; i++)
  1992.     {
  1993.         if (0 != gatNvod[i].TsPara.frequency
  1994.             && FALSE == gatNvod[i].SearchStartFlag
  1995.             && FALSE == gatNvod[i].SearchCompleteFlag)
  1996.         {
  1997.             return i;
  1998.         }
  1999.     }
  2001.     return (UINT32)(-1);
  2002. }
  2004. static UINT32 KB_NVOD_GetNullSchTsNum(void)
  2005. {
  2006.     UINT8 i;
  2008.     for(i = 0; i < KB_NVOD_MAX_TS_NUM; i++)
  2009.     {
  2010.         if (0 != gatNvod[i].TsPara.frequency
  2011.             && TRUE == gatNvod[i].SearchStartFlag
  2012.             && FALSE == gatNvod[i].SearchCompleteFlag)
  2013.         {
  2014.             return i;
  2015.         }
  2016.     }
  2018.     return (UINT32)(-1);
  2019. }
  2021. static void KB_NVOD_ResetTsData(UINT32 TsSequence)
  2022. {
  2023.     KD_NVODStopAllPF();
  2024.     KD_NVODStopAllSch();
  2025.     memset(gatNvod[TsSequence].RefEventData, 
  2026.            0, 
  2027.            (sizeof(KB_NVODStruct)*KB_NVOD_MAX_RefEvent_One_Ts));
  2028.     gatNvod[TsSequence].RefSrvNum = 0;
  2029.     gatNvod[TsSequence].RefEventNum = 0;
  2030.     gatNvod[TsSequence].SearchStartFlag = FALSE;
  2031. gatNvod[TsSequence].SearchCompleteFlag = FALSE;
  2033.     return;
  2034. }
  2036. UINT32 KB_NVOD_GetTsSequenceFromFrequency(UINT32  frequency)
  2037. {
  2038.     int i;
  2040.     for(i = 0; i < KB_NVOD_MAX_TS_NUM; i++)
  2041.     {
  2042.         if (frequency == gatNvod[i].TsPara.frequency)
  2043.         {
  2044.             return i;
  2045.         }
  2046.     }
  2048.     return (UINT32)(-1);
  2049. }
  2051. KB_DMDTunerParameters *KB_NVOD_GetTsParaFromTsSequence(UINT32  TsSequence)
  2052. {
  2053.     if (TsSequence < KB_NVOD_MAX_TS_NUM
  2054.         && 0 != gatNvod[TsSequence].TsPara.frequency)
  2055.     {
  2056.         return &(gatNvod[TsSequence].TsPara);
  2057.     }
  2059.     return NULL;
  2060. }
  2062. static INT32 KB_NVOD_SetCurrentTsPara(KB_DMDTunerParameters TsPara)
  2063. {
  2064.     UINT8  i;
  2065.     UINT32 preTsNum, NowTsNum;
  2067.     preTsNum = KB_NVOD_GetCurrentTsNum();
  2068.     
  2069.     //将原当前流标志修改；如果是第一次搜索，当前流还没有设置
  2070.     if ((UINT32)(-1) != preTsNum)
  2071.     {
  2072.         gatNvod[preTsNum].CurrentTsFlag = FALSE;
  2073.     }
  2075.     for (i = 0; i < KB_NVOD_MAX_TS_NUM; i++)
  2076.     {
  2077.         if (gatNvod[i].TsPara.frequency == TsPara.frequency)
  2078.         {
  2079.             //该ts流已经申请了gatNvod，修改当前流标志后return
  2080.             gatNvod[i].CurrentTsFlag = TRUE;
  2081.             return RET_OK;
  2082.         }
  2083.     }
  2085.     //该ts流未申请gatNvod
  2086.     NowTsNum = KB_NVOD_AllocategatNvodInfo(TsPara.frequency);
  2087.     
  2088.     if (KB_NVOD_ALLOCATE_FAIL == NowTsNum)
  2089.     {
  2090.         printf("nKB_EPG_SetCurrentTsNum::KB_NVOD_AllocategatNvodInfo fail!n");
  2091.         return RET_FAIL;
  2092.     }
  2093.     //理论上是不可能出现的情况, 因为前面已处理已申请的情况
  2094.     else if (KB_NVOD_ALLOCATE_REPEAT == NowTsNum)
  2095.     {
  2096.         for (i = 0; i < KB_NVOD_MAX_TS_NUM; i++)
  2097.         {
  2098.             if (gatNvod[i].TsPara.frequency == TsPara.frequency)
  2099.             {
  2100.                 gatNvod[i].CurrentTsFlag = TRUE;
  2101.                 return RET_OK;
  2102.             }
  2103.         }
  2104.     }
  2105.     else
  2106.     {
  2107.      memcpy(&gatNvod[NowTsNum].TsPara, &TsPara, sizeof(KB_DMDTunerParameters));
  2108.         gatNvod[NowTsNum].CurrentTsFlag = TRUE;
  2109.         return RET_OK;
  2110.     }
  2111.     
  2112.     return RET_OK;
  2113. }
  2115. static UINT8 KB_NVOD_AllocategatNvodInfo(UINT32 frequency)
  2116. {
  2117.     UINT8 i, ret = KB_NVOD_ALLOCATE_FAIL;
  2119.     for(i = 0; i < KB_NVOD_MAX_TS_NUM; i++)
  2120.     {
  2121.         if (frequency == gatNvod[i].TsPara.frequency)
  2122.         {
  2123.             return KB_NVOD_ALLOCATE_REPEAT;
  2124.         }
  2125.     }
  2126.     
  2127.     for (i = 0; i < KB_NVOD_MAX_TS_NUM; i++)
  2128.     {
  2129.         if (0 == gatNvod[i].TsPara.frequency)
  2130.         {
  2131.             ret = i;
  2132.             break;
  2133.         }
  2134.     }
  2136.     return ret;
  2137. }
  2139. void KB_NVOD_FreegatNvodInfo(UINT32 frequency)
  2140. {
  2141.     UINT8 i;
  2142.     
  2143.     for (i = 0; i < KB_NVOD_MAX_TS_NUM; i++)
  2144.     {
  2145.         if (frequency == gatNvod[i].TsPara.frequency)
  2146.         {
  2147.             memset(&gatNvod[i], 0, sizeof(KB_NVOD_Info));
  2148.      gatNvod[i].CurrentTsFlag = FALSE;
  2149.      gatNvod[i].SearchCompleteFlag = FALSE;
  2150.             return;
  2151.         }
  2152.     }
  2154.     return;
  2155. }
  2157. BOOL KB_NVOD_IsThisTsShallSearched(UINT32 frequency)
  2158. {
  2159.     UINT8 i;
  2161.     for(i = 0; i < KB_NVOD_MAX_TS_NUM; i++)
  2162.     {
  2163.         if (frequency == gatNvod[i].TsPara.frequency)
  2164.         {
  2165.             return gatNvod[i].SearchCompleteFlag;
  2166.         }
  2167.     }
  2169.     printf("nKB_NVOD_IsThisTsShallSearch::input frequency error!n");
  2171.     return FALSE;
  2172. }
  2174. BOOL KB_NVOD_IsTsShallSearched(void)
  2175. {
  2176.     UINT8 i;
  2177.     //UINT8 flag = 0xff; 
  2179.     for(i = 0; i < KB_NVOD_MAX_TS_NUM; i++)
  2180.     {
  2181.         if (0 != gatNvod[i].TsPara.frequency
  2182.             && TRUE == gatNvod[i].SearchStartFlag
  2183.             && TRUE == gatNvod[i].SearchCompleteFlag)
  2184.         {
  2185.             
  2186.         }
  2187.         else
  2188.         {
  2189.             return TRUE;
  2190.         }
  2191.     }
  2193.     return FALSE;
  2194. }
  2196. void KB_NVOD_GetValidFreInfo(UINT8 *pNum, KB_NVOD_Info *Address[])
  2197. {
  2198.     UINT8 i = 0;
  2200.     if (NULL == pNum || NULL == Address)
  2201.     {
  2202.         printf("nKB_NVOD_GetValidFreInfo::input err!");
  2203.         return;
  2204.     }
  2205. #if 1
  2206.     //刷新播放时间列表，干掉所有过期的ShiftEvent
  2207.     if (TRUE != KB_NVOD_RefreshSchEvent())
  2208.     {
  2209.         printf("nKB_NVOD_GetValidFreInfo::refresh ShiftEvent failed.");
  2210.     }
  2211. #endif
  2212.     *pNum = 0;
  2213.     
  2214.     for(i = 0; i < KB_NVOD_MAX_TS_NUM; i++)
  2215.     {
  2216.         if (0 != gatNvod[i].TsPara.frequency)
  2217.         {
  2218.             Address[(*pNum)] = gatNvod + i;
  2219.             (*pNum)++;      
  2220.         }
  2221.     }
  2223.     return;
  2224. }
  2226. BOOL KB_NVOD_PlayForGrap(int nPrgCurRow, int nSchCurRow)
  2227. {
  2228.     UINT32 i = 0;
  2229.     UINT8 TsIndex = 0xff, RefEventIndex = 0xff;
  2230.     
  2231.     KB_DMDTunerParameters *pTsPara = NULL;
  2233.     //参数自减的原因是: 界面传入的RefEvent条目(即nPrgCurRow)、SchEvent条目(即nSchCurRow)编号从1开始
  2234.     nPrgCurRow--;
  2235.     nSchCurRow--;
  2237.     if (nPrgCurRow < 0 || nSchCurRow < 0)
  2238.     {
  2239.         printf("nKB_NVOD_PlayForGrap::input error!");
  2240.         return FALSE;
  2241.     }
  2243.     for (i = 0; i < KB_NVOD_MAX_TS_NUM; i++)
  2244.     {
  2245.         if (0 != gatNvod[i].TsPara.frequency)
  2246.         {
  2247.             nPrgCurRow -= (int)(KB_NvodGetRefEventNum(i));
  2248.         }
  2250.         if (nPrgCurRow < 0)
  2251.         {
  2252.             TsIndex = (UINT8)i;
  2253.             RefEventIndex = (UINT8)(nPrgCurRow + KB_NvodGetRefEventNum(i));
  2254.             break;
  2255.         }
  2256.     }
  2258.     if (TsIndex >= KB_NVOD_MAX_TS_NUM || RefEventIndex >= KB_NVOD_MAX_RefEvent_One_Ts)
  2259.     {
  2260.         printf("nKB_NVOD_PlayForGrap::TsIndex or RefEventIndex error!n");
  2261.         return FALSE;
  2262.     }
  2263.         
  2264.     if (TsIndex != KB_NVOD_GetCurrentTsNum())
  2265.     {
  2266.         printf("nKB_NVOD_PlayForGrap::Ts switched!n");
  2267.         KD_NVODStopAllPF();
  2268.         KD_NVODStopAllSch();
  2269.         KB_DMDDropSignal();
  2271.         pTsPara = KB_NVOD_GetTsParaFromTsSequence(TsIndex);
  2272.         if (NULL == pTsPara)
  2273.         {
  2274.             printf("nKB_NVOD_PlayForGrap::KB_NVOD_GetTsParaFromTsSequence error!n");
  2275.             return FALSE;
  2276.         }
  2277.         KB_DMDConnectSignal(pTsPara);
  2278.         KB_OSPTaskDelay(50);
  2279.         KB_NVODGetEit();
  2280.     }
  2281.     KD_NVODStartPlay((gatNvod[TsIndex].RefEventData[RefEventIndex].TimeNode[nSchCurRow].tsID), 
  2282.                        (gatNvod[TsIndex].RefEventData[RefEventIndex].TimeNode[nSchCurRow].SerID));
  2284.     return TRUE;
  2285. }
  2287. const KB_NVODStruct *KB_NVOD_GetCurRefEventInfoForGrap(int nPrgCurRow)
  2288. {
  2289.     UINT32 i = 0;
  2290.     UINT8 TsIndex = 0xff, RefEventIndex = 0xff;
  2292.     //参数自减的原因是: 界面传入的RefEvent条目(即nPrgCurRow)、SchEvent条目(即nSchCurRow)编号从1开始
  2293.     nPrgCurRow--;
  2295.     if (nPrgCurRow < 0)
  2296.     {
  2297.         printf("nKB_NVOD_GetCurRefEventInfoForGrap::input error!");
  2298.         return NULL;
  2299.     }
  2301.     for (i = 0; i < KB_NVOD_MAX_TS_NUM; i++)
  2302.     {
  2303.         if (0 != gatNvod[i].TsPara.frequency)
  2304.         {
  2305.             nPrgCurRow -= (int)(KB_NvodGetRefEventNum(i));
  2306.         }
  2308.         if (nPrgCurRow < 0)
  2309.         {
  2310.             TsIndex = (UINT8)i;
  2311.             RefEventIndex = (UINT8)(nPrgCurRow + KB_NvodGetRefEventNum(i));
  2312.             break;
  2313.         }
  2314.     }
  2316.     if (TsIndex >= KB_NVOD_MAX_TS_NUM || RefEventIndex >= KB_NVOD_MAX_RefEvent_One_Ts)
  2317.     {
  2318.         printf("nKB_NVOD_GetCurRefEventInfoForGrap::TsIndex or RefEventIndex error!n");
  2319.         return NULL;
  2320.     }
  2321.         
  2322.     
  2323.     return &(gatNvod[TsIndex].RefEventData[RefEventIndex]);
  2324. }
  2326. //刷新已搜索好的每个NVOD参考时间的ShiftEvent列表, 干掉所有过期的ShiftEvent
  2327. BOOL KB_NVOD_RefreshSchEvent(void)
  2328. {
  2329.     UINT16  i = 0;          //频点循环参数
  2330.     UINT16  j = 0;          //参考事件循环参数
  2331.     UINT16  k = 0;          //ShiftEvent循环参数
  2332.     UINT16  count = 0;      //计算过期的ShiftEvent个数
  2333.     
  2334.     
  2335.     if (0 == gNvodTime)
  2336.     {
  2337.         printf("nKB_NVOD_RefreshSchEvent::gNvodTime 未获取");
  2338.         return FALSE;
  2339.     }
  2341.     for(i = 0; i < KB_NVOD_MAX_TS_NUM; i++)
  2342.     {
  2343.         //该频点没有参考事件，则察看下一频点信息
  2344.         if (0 == gatNvod[i].RefEventNum)
  2345.         {
  2346.             continue;
  2347.         }
  2349.         for (j = 0; j < gatNvod[i].RefEventNum; j++)
  2350.         {
  2351.             //本参考事件无时移事件，则察看本频点的下一个参考事件信息
  2352.             if (0 == gatNvod[i].RefEventData[j].TimeNum)
  2353.             {
  2354.                 continue;
  2355.             }
  2357.             //对频点i的第j个参考事件的ShiftEvent列表, 按时间先后进行排序
  2358.             KB_NVOD_DirectInsertSort(gatNvod[i].RefEventData[j].TimeNode,
  2359.                                          gatNvod[i].RefEventData[j].TimeNum);
  2361.             count = 0;
  2363.             //计算目前总共有几个ShiftEvent过期
  2364.             for (k = 0; k < gatNvod[i].RefEventData[j].TimeNum; k++)
  2365.             {
  2366.                 if (gatNvod[i].RefEventData[j].TimeNode[k].startTime + gatNvod[i].RefEventData[j].durTime < gNvodTime)
  2367.                 {
  2368.                     count++;
  2369.                 }
  2370.                 else
  2371.                 {
  2372.                     break;
  2373.                 }
  2374.             }
  2376.             if (count > 0)
  2377.             {
  2378.                 for (k = 0; (k + count) < gatNvod[i].RefEventData[j].TimeNum; k++)
  2379.                 {
  2380.                     gatNvod[i].RefEventData[j].TimeNode[k].tsID      = gatNvod[i].RefEventData[j].TimeNode[(k+count)].tsID;
  2381.                     gatNvod[i].RefEventData[j].TimeNode[k].SerID     = gatNvod[i].RefEventData[j].TimeNode[(k+count)].SerID;
  2382.                     gatNvod[i].RefEventData[j].TimeNode[k].EvtID     = gatNvod[i].RefEventData[j].TimeNode[(k+count)].EvtID;
  2383.                     gatNvod[i].RefEventData[j].TimeNode[k].startTime = gatNvod[i].RefEventData[j].TimeNode[(k+count)].startTime;
  2384.                 }
  2385.             }
  2387.             gatNvod[i].RefEventData[j].TimeNum -= count;
  2388.         }
  2389.     }
  2391.     return TRUE;
  2392. }
  2394. //直接插入排序, 在基本有序和SIZE很小时是最好的排序方法
  2395. static void KB_NVOD_DirectInsertSort(KB_NVODTime TimeNode[], UINT16 TimeNum)
  2396. {
  2397.     int i = 0, j = 0;
  2398.     KB_NVODTime tmp;
  2400.     if (0 == TimeNum || TimeNum > 500 || NULL == TimeNode)
  2401.     {
  2402.         printf("nKB_NVOD_DirectInsertSort::input TimeNum(%d) error.", TimeNum);
  2403.         return;
  2404.     }
  2406.     for (i = 1; i < TimeNum; i++)
  2407.     {
  2408.         if (TimeNode[i].startTime < TimeNode[i-1].startTime)
  2409.         {
  2410.             tmp.tsID        = TimeNode[i].tsID;
  2411.             tmp.SerID       = TimeNode[i].SerID;
  2412.             tmp.EvtID       = TimeNode[i].EvtID;
  2413.             tmp.startTime   = TimeNode[i].startTime;
  2415.             TimeNode[i].tsID        = TimeNode[i-1].tsID;        
  2416.             TimeNode[i].SerID       = TimeNode[i-1].SerID;       
  2417.             TimeNode[i].EvtID       = TimeNode[i-1].EvtID;       
  2418.             TimeNode[i].startTime   = TimeNode[i-1].startTime;   
  2419.             
  2420.             for(j = i-2; j >= 0 && tmp.startTime < TimeNode[j].startTime; --j)
  2421.             {
  2422.                 TimeNode[j+1].tsID        = TimeNode[j].tsID;        
  2423.                 TimeNode[j+1].SerID       = TimeNode[j].SerID;       
  2424.                 TimeNode[j+1].EvtID       = TimeNode[j].EvtID;       
  2425.                 TimeNode[j+1].startTime   = TimeNode[j].startTime;  
  2426.             }
  2428.             TimeNode[j+1].tsID        = tmp.tsID;        
  2429.             TimeNode[j+1].SerID       = tmp.SerID;       
  2430.             TimeNode[j+1].EvtID       = tmp.EvtID;       
  2431.             TimeNode[j+1].startTime   = tmp.startTime; 
  2432.         }
  2433.     }
  2435.     return;
  2436. }
  2438. time_t KB_NVOD_GetNvodTime(void)
  2439. {
  2440.     return gNvodTime;
  2441. }
  2443. /* EOF */