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

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

DVD

开发平台：

C/C++

sipsi.c：源码内容
  1. #include <stdio.h>
  2. #include <ctype.h>
  3. #include <string.h>
  5. #include "gendef.h"
  6. #include "osp.h"
  7. #include "dmx.h"
  8. #include "timer.h"
  9. #include "sipsi.h"
  10. #include "sipsiprv.h"
  11. #include "unicode.h"
  13. #include "appltype.h"
  14. #include "db.h"
  16. #include "Ca_user.h"
  17. #include "task.h"
  19. #define J_SI_Print    DBGPrint
  20. #define J_SI_Malloc   KB_OSPMalloc
  21. #define J_SI_Free     KB_OSPFree
  23. #define SI_TIMER_TICK_PERIOD (500)
  25. #define SI_HEADER_LENGTH     (13)
  26. #define SI_FILTER_DEPTH      (8)
  28. #define SI_SECTION_NOT_RECEIVED  ((MepgData*)0x00000000)
  29. #define SI_SECTION_RECEIVED      ((MepgData*)0xFFFFFFFF)
  31. #define J_SI_EIT_PF_TIMEOUT       20 
  32. #define J_SI_EIT_SCHEDULE_TIMEOUT 50
  34. extern BOOL TFReceiveNitFlag;
  37. static T_SubTableID PATSubTableID;
  38. static T_SubTableID NITSubTableID;
  39. static T_SubTableID SDTSubTableID;
  40. static T_SubTableID PMTSubTableID[SI_NO_PMT_TABLES];
  41. static T_SubTableID EITSubTableID;
  42. static T_SubTableID CATSubTableID;
  43. static T_SubTableID TDTSubTableID;
  44. static T_SubTableID RSTSubTableID;
  45. static T_SubTableID TOTSubTableID;
  47. static T_SubTable SISubTable[SI_MAX_SUB_TABLES];
  49. static UINT32 l_nQueueId;
  50. static UINT32 l_nTaskId;
  52. static UINT32 SITimer = KB_TIMER_INVALID_ID;
  54. static INT8 l_nInitFlag = 0;
  55. static UINT32 l_nHandle = 1;
  57. static PATINFO* l_pstCurrPatPara;
  58. static PATINFO* l_pstPendingPatPara;
  60. static NITINFO* l_pstCurrNitPara;
  61. static NITINFO* l_pstPendingNitPara;
  63. static PMTINFO* l_pstCurrPmtPara[SI_NO_PMT_TABLES];
  64. static PMTINFO* l_pstPendingPmtPara[SI_NO_PMT_TABLES_QUEUE];
  66. static SDTINFO* l_pstCurrSdtPara;
  67. static SDTINFO* l_pstPendingSdtPara;
  69. static BATINFO* l_pstCurrBatPara;
  70. static BATINFO* l_pstPendingBatPara;
  72. static EITPFINFO* l_pstCurrEitPFPara[SI_NO_EIT_PF_FILTERS];
  73. static EITPFINFO* l_pstPendingEitPFPara[SI_NO_EIT_PF_TABLES_QUEUE];
  75. static EITSCHINFO* l_pstCurrEinSchInfoPara[KB_SI_EIT_SCHEDULE_SERVICE_COUNT];
  76. static EITSCHINFO* l_pstPendingEinSchInfoPara[KB_SI_EIT_SCHEDULE_SERVICE_COUNT];
  77. static MULTEITSCHINFO* l_pstCurrMultiEinSchInfoPara;
  78. static MULTEITSCHINFO* l_pstPendingMultiEinSchInfoPara;
  80. static TDTINFO* l_pstCurrTdtPara;
  81. static TDTINFO* l_pstPendingTdtPara;
  83. static TOTINFO* l_pstCurrTotPara;
  84. static TOTINFO* l_pstPendingTotPara;
  86. static CATINFO* l_pstCurrCatPara;
  87. static CATINFO* l_pstPendingCatPara;
  89. static RSTINFO* l_pstCurrRstPara;
  90. static RSTINFO* l_pstPendingRstPara;
  92. static T_EIT_SCHEDULE_TIME_SHIFT_PARA *gptCurrSchShiftPara[SI_NO_EIT_SCHEDULE_TIME_SHIFT_FILTERS];
  93. static T_EIT_SCHEDULE_TIME_SHIFT_PARA *gptPendingSchShiftPara[SI_NO_EIT_SCHEDULE_TIME_SHIFT_FILTERS];
  95. static MepgData SISectionSmallData[SI_MAX_SECTION_SMALL_DATA];
  96. static MepgData SISectionLargeData[SI_MAX_SECTION_LARGE_DATA];
  98. static T_ChannelToSubtable        SIChannelToSubTableMap[SI_DMX_NO_CHANNELS];
  100. static T_SubTableFilter SIFilters[SI_DMX_NO_FILTERS];
  101. static UINT32           SICurrentFilter;
  103. static UINT32        SISubTableListData[SI_MAX_SUB_TABLES];
  104. static UINT32        SISectionLargeDataListBuffer[SI_MAX_SECTION_LARGE_DATA];
  105. static UINT32        SISectionSmallDataListBuffer[SI_MAX_SECTION_SMALL_DATA];
  108. static SIFIFO SISubTableList = {SI_MAX_SUB_TABLES, SISubTableListData};
  109. static SIFIFO SISectionLargeDataList = {SI_MAX_SECTION_LARGE_DATA, SISectionLargeDataListBuffer};
  110. static SIFIFO SISectionSmallDataList = {SI_MAX_SECTION_SMALL_DATA, SISectionSmallDataListBuffer};
  112. static T_SubTableDetails PATDetails = { 0x0000, 33, TRUE,  0x00, -1, 10,  1,                 FALSE };
  113. static T_SubTableDetails CATDetails = { 0x0001, 33, TRUE,  0x01, -1, 10,  1,                 FALSE };
  114. static T_SubTableDetails PMTDetails = { -1,     33, TRUE,  0x02, -1, 10,  1,                 FALSE };
  115. static T_SubTableDetails NITDetails = { 0x0010, 33, TRUE,  0x40, -1, 40,  1,                 FALSE };
  116. static T_SubTableDetails SDTDetails = { 0x0011, 33, TRUE,  0x42, -1, 40,  2,                 FALSE };
  117. static T_SubTableDetails EITDetails = { 0x0012, 33, TRUE,  0x4E, -1, 25,  SI_NO_EIT_FILTERS, FALSE };
  118. static T_SubTableDetails TDTDetails = { 0x0014, 33, FALSE, 0x70, -1, 120, 1,                 FALSE };
  119. static T_SubTableDetails RSTDetails = { 0x0013, 33, FALSE, 0x71, -1, -1,  1,                 FALSE };
  120. static T_SubTableDetails TOTDetails = { 0x0014, 33, FALSE, 0x73, -1, 120, 1,                 FALSE };
  122. static UINT32 semCritical;    /* 保护LIFO的资源共享的信号量 */
  124. static KB_SICallbackFunc gptSiCallbackFunction = NULL;
  125. static KB_SICallbackFunc gptSiEitCallbackFunction = NULL;
  127. /*******************************************************************************
  128. **                            Local Function Prototype
  129. *******************************************************************************/
  130. static void SIToLower(char* str);
  131. static void SIGetSection(UINT32 nChannelID, UINT8 *pData, UINT32 nDataLength);
  132. static int KD_DTVSendMsg(KB_OSPMsgNode * pMsg);
  133. static void SiEitSetup(T_SubTableID subTableID, UINT32 filterNumber, 
  134.                           INT32 version, UINT32 handle);
  135. static UINT32 SIGetFilterNum(T_SubTableID subTableID, INT32 tableId,
  136.                                       INT32 tableIDExt);
  137. static INT32 SIStopEitPF(INT32 nSvcID, INT32 nTableId);
  141. INT32 KB_SIInit()
  142. {
  143.     int i;
  145. if(l_nInitFlag == 1)
  146. {
  147. return RETOK;
  148. }
  149. l_nInitFlag = 1;
  151. if(KB_OSPSemInit("SI-S", 1, J_OSP_WAIT_FIFO, &semCritical) != Ret_OK)
  152. {
  153. return RETFIAL1;
  154. }    
  155.     
  156.     for(i=0; i<SI_DMX_NO_CHANNELS; i++)
  157. {
  158. SIChannelToSubTableMap[i].valid = 0;
  159. }
  160.     
  161.     if (SIAlloc() != SI_OK)
  162.     {
  163.         return RETFIAL1;
  164.     }
  165.     
  166. if (SISubTableInitialize() != SI_OK)
  167.     {
  168.         return RETFIAL1;
  169.     }
  170. return RETOK;
  171. }
  172.     
  173. INT32 KB_SIDestroy()
  174. {
  175. if(l_nInitFlag == 0)
  176. {
  177. return 0;
  178. }
  179. l_nInitFlag = 0;
  181. KB_SIStopAllSection();
  182. SISubTableDestroy();
  183. SIFree();
  185.     KB_OSPSemDel(semCritical);
  187. return 0;
  188. }
  190. static INT32 SIAlloc(void)
  191. {
  192. int i;
  194. if( (l_pstCurrPatPara = J_SI_Malloc( sizeof(PATINFO) )) == NULL )
  195. {
  196. return SI_MEMORY_FULL;
  197. }
  198. memset(l_pstCurrPatPara, 0, sizeof(PATINFO));
  200. if( (l_pstPendingPatPara = J_SI_Malloc( sizeof(PATINFO) )) == NULL )
  201. {
  202. return SI_MEMORY_FULL;
  203. }
  204. memset(l_pstPendingPatPara, 0, sizeof(PATINFO));
  206. if( (l_pstCurrNitPara = J_SI_Malloc( sizeof(NITINFO) )) == NULL )
  207. {
  208. return SI_MEMORY_FULL;
  209. }
  210. memset(l_pstCurrNitPara, 0, sizeof(NITINFO));
  212. if( (l_pstPendingNitPara = J_SI_Malloc( sizeof(NITINFO) )) == NULL )
  213. {
  214. return SI_MEMORY_FULL;
  215. }
  216. memset(l_pstPendingNitPara, 0, sizeof(NITINFO));
  218. for(i = 0; i < SI_NO_PMT_TABLES; i++)
  219. {
  220. if( (l_pstCurrPmtPara[i] = J_SI_Malloc( sizeof(PMTINFO) )) == NULL )
  221. {
  222. return SI_MEMORY_FULL;
  223. }
  224. memset(l_pstCurrPmtPara[i], 0, sizeof(PMTINFO));
  225. }
  227. for(i = 0; i < SI_NO_PMT_TABLES_QUEUE; i++)
  228. {
  229. if( (l_pstPendingPmtPara[i] = J_SI_Malloc( sizeof(PMTINFO) )) == NULL )
  230. {
  231. return SI_MEMORY_FULL;
  232. }
  233. memset(l_pstPendingPmtPara[i], 0, sizeof(PMTINFO));
  234. }
  236. if( (l_pstCurrSdtPara = J_SI_Malloc( sizeof(SDTINFO) )) == NULL )
  237. {
  238. return SI_MEMORY_FULL;
  239. }
  240. memset(l_pstCurrSdtPara, 0, sizeof(SDTINFO));
  242. if( (l_pstPendingSdtPara = J_SI_Malloc( sizeof(SDTINFO) )) == NULL )
  243. {
  244. return SI_MEMORY_FULL;
  245. }
  246. memset(l_pstPendingSdtPara, 0, sizeof(SDTINFO));
  248. if( (l_pstCurrBatPara = J_SI_Malloc( sizeof(BATINFO) )) == NULL )
  249. {
  250. return SI_MEMORY_FULL;
  251. }
  252. memset(l_pstCurrBatPara, 0, sizeof(BATINFO));
  254. if( (l_pstPendingBatPara = J_SI_Malloc( sizeof(BATINFO) )) == NULL )
  255. {
  256. return SI_MEMORY_FULL;
  257. }
  258. memset(l_pstPendingBatPara, 0, sizeof(BATINFO));
  260. for(i = 0; i < SI_NO_EIT_PF_FILTERS; i++)
  261. {
  262. if( (l_pstCurrEitPFPara[i] = J_SI_Malloc( sizeof(EITPFINFO) )) == NULL )
  263. {
  264. return SI_MEMORY_FULL;
  265. }
  266. memset(l_pstCurrEitPFPara[i], 0, sizeof(EITPFINFO));
  267. }
  269. for(i = 0; i < SI_NO_EIT_PF_TABLES_QUEUE; i++)
  270. {
  271. if( (l_pstPendingEitPFPara[i] = J_SI_Malloc( sizeof(EITPFINFO) )) == NULL )
  272. {
  273. return SI_MEMORY_FULL;
  274. }
  275. memset(l_pstPendingEitPFPara[i], 0, sizeof(EITPFINFO));
  276. }
  277.     
  278.     for (i = 0; i < KB_SI_EIT_SCHEDULE_SERVICE_COUNT; i++)
  279.     {
  280.         if( (l_pstCurrEinSchInfoPara[i] = J_SI_Malloc( sizeof(EITSCHINFO) )) == NULL )
  281.     {
  282.     return SI_MEMORY_FULL;
  283.     }
  284.     memset(l_pstCurrEinSchInfoPara[i], 0, sizeof(EITSCHINFO));
  286.         if( (l_pstPendingEinSchInfoPara[i] = J_SI_Malloc( sizeof(EITSCHINFO) )) == NULL )
  287.     {
  288.     return SI_MEMORY_FULL;
  289.     }
  290.     memset(l_pstPendingEinSchInfoPara[i], 0, sizeof(EITSCHINFO));
  291.     }
  293. if( (l_pstCurrMultiEinSchInfoPara = J_SI_Malloc( sizeof(MULTEITSCHINFO) )) == NULL )
  294. {
  295. return SI_MEMORY_FULL;
  296. }
  297. memset(l_pstCurrMultiEinSchInfoPara, 0, sizeof(MULTEITSCHINFO));
  299. if( (l_pstPendingMultiEinSchInfoPara = J_SI_Malloc( sizeof(MULTEITSCHINFO) )) == NULL )
  300. {
  301. return SI_MEMORY_FULL;
  302. }
  303. memset(l_pstPendingMultiEinSchInfoPara, 0, sizeof(MULTEITSCHINFO));
  305. if( (l_pstCurrTdtPara = J_SI_Malloc( sizeof(TDTINFO) )) == NULL )
  306. {
  307. return SI_MEMORY_FULL;
  308. }
  309. memset(l_pstCurrTdtPara, 0, sizeof(TDTINFO));
  311. if( (l_pstPendingTdtPara = J_SI_Malloc( sizeof(TDTINFO) )) == NULL )
  312. {
  313. return SI_MEMORY_FULL;
  314. }
  315. memset(l_pstPendingTdtPara, 0, sizeof(TDTINFO));
  317. if( (l_pstCurrCatPara = J_SI_Malloc( sizeof(CATINFO) )) == NULL )
  318. {
  319. return SI_MEMORY_FULL;
  320. }
  321. memset(l_pstCurrCatPara, 0, sizeof(CATINFO));
  323. if( (l_pstPendingCatPara = J_SI_Malloc( sizeof(CATINFO) )) == NULL )
  324. {
  325. return SI_MEMORY_FULL;
  326. }
  327. memset(l_pstPendingCatPara, 0, sizeof(CATINFO));
  329. if( (l_pstCurrRstPara = J_SI_Malloc( sizeof(RSTINFO) )) == NULL )
  330. {
  331. return SI_MEMORY_FULL;
  332. }
  333. memset(l_pstCurrRstPara, 0, sizeof(RSTINFO));
  335. if( (l_pstPendingRstPara = J_SI_Malloc( sizeof(RSTINFO) )) == NULL )
  336. {
  337. return SI_MEMORY_FULL;
  338. }
  339. memset(l_pstPendingRstPara, 0, sizeof(RSTINFO));
  341. if( (l_pstCurrTotPara = J_SI_Malloc( sizeof(TOTINFO) )) == NULL )
  342. {
  343. return SI_MEMORY_FULL;
  344. }
  345. memset(l_pstCurrTotPara, 0, sizeof(TOTINFO));
  347. if( (l_pstPendingTotPara = J_SI_Malloc( sizeof(TOTINFO) )) == NULL )
  348. {
  349. return SI_MEMORY_FULL;
  350. }
  351. memset(l_pstPendingTotPara, 0, sizeof(TOTINFO));
  353.     for (i = 0;i < SI_NO_EIT_SCHEDULE_TIME_SHIFT_FILTERS; i++)
  354.     {        
  355.         gptCurrSchShiftPara[i] = J_SI_Malloc(sizeof(T_EIT_SCHEDULE_TIME_SHIFT_PARA));
  356.         if (gptCurrSchShiftPara[i] == NULL)
  357.         {
  358.             return SI_MEMORY_FULL;
  359.         }
  360.         memset(gptCurrSchShiftPara[i], 0, sizeof(T_EIT_SCHEDULE_TIME_SHIFT_PARA));
  362.         gptPendingSchShiftPara[i] = J_SI_Malloc(sizeof(T_EIT_SCHEDULE_TIME_SHIFT_PARA));
  363.         if (gptPendingSchShiftPara[i] == NULL)
  364.         {
  365.             return SI_MEMORY_FULL;
  366.         }
  367.         memset(gptPendingSchShiftPara[i], 0, sizeof(T_EIT_SCHEDULE_TIME_SHIFT_PARA));
  368.     }
  369.     
  370. return SI_OK;
  371. }
  373. void SIFree(void)
  374. {
  375. int i;
  377. J_SI_Free(l_pstCurrPatPara);
  378. J_SI_Free(l_pstPendingPatPara);
  380. J_SI_Free(l_pstCurrNitPara);
  381. J_SI_Free(l_pstPendingNitPara);
  383. for(i = 0; i < SI_NO_PMT_TABLES; i++)
  384. {
  385. J_SI_Free(l_pstCurrPmtPara[i]);
  386. }
  388. for(i = 0; i < SI_NO_PMT_TABLES_QUEUE; i++)
  389. {
  390. J_SI_Free(l_pstPendingPmtPara[i]);
  391. }
  393. J_SI_Free(l_pstCurrSdtPara);
  394. J_SI_Free(l_pstPendingSdtPara);
  396. J_SI_Free(l_pstCurrBatPara);
  397. J_SI_Free(l_pstPendingBatPara);
  399. for(i = 0; i < SI_NO_EIT_PF_FILTERS; i++)
  400. {
  401. J_SI_Free(l_pstCurrEitPFPara[i]);
  402. }
  404. for(i = 0; i < SI_NO_EIT_PF_TABLES_QUEUE; i++)
  405. {
  406. J_SI_Free(l_pstPendingEitPFPara[i]);
  407. }
  409.     for (i = 0; i < KB_SI_EIT_SCHEDULE_SERVICE_COUNT; i++)
  410.     {
  411.         if (l_pstCurrEinSchInfoPara[i])
  412.         {
  413.             J_SI_Free(l_pstCurrEinSchInfoPara[i]);
  414.         }
  416.         if (l_pstPendingEinSchInfoPara[i])
  417.         {
  418.             J_SI_Free(l_pstPendingEinSchInfoPara[i]);
  419.         }
  420.     }
  421. J_SI_Free(l_pstCurrMultiEinSchInfoPara);
  422. J_SI_Free(l_pstPendingMultiEinSchInfoPara);
  423. J_SI_Free(l_pstCurrTdtPara);
  424. J_SI_Free(l_pstPendingTdtPara);
  426. J_SI_Free(l_pstCurrCatPara);
  427. J_SI_Free(l_pstPendingCatPara);
  429. J_SI_Free(l_pstCurrRstPara);
  430. J_SI_Free(l_pstPendingRstPara);
  432. J_SI_Free(l_pstCurrTotPara);
  433. J_SI_Free(l_pstPendingTotPara);
  435.     for (i = 0;i < SI_NO_EIT_SCHEDULE_TIME_SHIFT_FILTERS; i++)
  436.     {
  437.         if (gptCurrSchShiftPara[i])
  438.         {
  439.             J_SI_Free(gptCurrSchShiftPara[i]);
  440.         }
  441.         
  442.         if (gptPendingSchShiftPara[i])
  443.         {
  444.             J_SI_Free(gptPendingSchShiftPara[i]);
  445.         }
  446.     }
  447. }
  449. INT32 KB_SIStopAllSection()
  450. {
  451. UINT32 i;
  452.     
  453. SISubTableStop(PATSubTableID);
  454. SISubTableStop(NITSubTableID);
  455. SISubTableStop(SDTSubTableID); 
  456. SISubTableStop(EITSubTableID);
  457. SISubTableStop(CATSubTableID);
  458. SISubTableStop(TDTSubTableID);
  459. SISubTableStop(RSTSubTableID);
  460. SISubTableStop(TOTSubTableID);
  462. for(i = 0; i < SI_NO_PMT_TABLES; i++)
  463. SISubTableStop(PMTSubTableID[i]);
  465. memset(l_pstCurrPatPara, 0, sizeof(PATINFO));
  466. memset(l_pstPendingPatPara, 0, sizeof(PATINFO));
  468. memset(l_pstCurrNitPara, 0, sizeof(NITINFO));
  469. memset(l_pstPendingNitPara, 0, sizeof(NITINFO));
  471. memset(l_pstCurrSdtPara, 0, sizeof(SDTINFO));
  472. memset(l_pstPendingSdtPara, 0, sizeof(SDTINFO));
  474. memset(l_pstCurrBatPara, 0, sizeof(BATINFO));
  475. memset(l_pstPendingBatPara, 0, sizeof(BATINFO));
  477. for(i = 0; i < SI_NO_PMT_TABLES; i++)
  478. {
  479. memset(l_pstCurrPmtPara[i], 0, sizeof(PMTINFO));
  480. memset(l_pstPendingPmtPara[i], 0, sizeof(PMTINFO));
  481. }
  483. for(i = 0; i < SI_NO_EIT_PF_FILTERS; i++)
  484. {
  485. memset(l_pstCurrEitPFPara[i], 0, sizeof(EITPFINFO));
  486. memset(l_pstPendingEitPFPara[i], 0, sizeof(EITPFINFO));
  487. }
  489.     for (i = 0; i < KB_SI_EIT_SCHEDULE_SERVICE_COUNT; i++)
  490.     {
  491.     memset(l_pstCurrEinSchInfoPara[i], 0, sizeof(EITSCHINFO));
  492.     memset(l_pstPendingEinSchInfoPara[i], 0, sizeof(EITSCHINFO));
  493.     }
  495. memset(l_pstCurrMultiEinSchInfoPara, 0, sizeof(MULTEITSCHINFO));
  496. memset(l_pstPendingMultiEinSchInfoPara, 0, sizeof(MULTEITSCHINFO));
  498. memset(l_pstCurrTdtPara, 0, sizeof(TDTINFO));
  499. memset(l_pstPendingTdtPara, 0, sizeof(TDTINFO));
  501. memset(l_pstCurrCatPara, 0, sizeof(CATINFO));
  502. memset(l_pstPendingCatPara, 0, sizeof(CATINFO));
  504. memset(l_pstCurrRstPara, 0, sizeof(RSTINFO));
  505. memset(l_pstPendingRstPara, 0, sizeof(RSTINFO));
  507. memset(l_pstCurrTotPara, 0, sizeof(TOTINFO));
  508. memset(l_pstPendingTotPara, 0, sizeof(TOTINFO));
  510.     for (i = 0; i < SI_NO_EIT_SCHEDULE_TIME_SHIFT_FILTERS; i++)
  511.     {
  512.  memset(gptCurrSchShiftPara[i], 0, sizeof(T_EIT_SCHEDULE_TIME_SHIFT_PARA));
  513.         memset(gptPendingSchShiftPara[i], 0, sizeof(T_EIT_SCHEDULE_TIME_SHIFT_PARA));
  514.     }
  515. return 0;
  516. }
  518. static INT32 SISubTableInitialize(void)
  519. {
  520. INT32 status;
  521. INT32 i;
  523. LIFOInitialize(&SISubTableList);   
  524. LIFOInitialize(&SISectionSmallDataList);
  525. LIFOInitialize(&SISectionLargeDataList);
  527. for(i = 0; i < SI_MAX_SUB_TABLES; i++)
  528. {
  529. LIFOPush(&SISubTableList, i);
  530. }
  531.     
  532. for(i = 0; i < SI_MAX_SECTION_SMALL_DATA; i++)
  533. {
  534.     SISectionSmallData[i].data = NULL;
  535.         
  536. LIFOPush(&SISectionSmallDataList, (UINT32)&SISectionSmallData[i]);
  537. }
  538.     
  539. for(i = 0; i < SI_MAX_SECTION_LARGE_DATA; i++)
  540. {
  541.         SISectionLargeData[i].data = NULL;
  542.         
  543. LIFOPush(&SISectionLargeDataList, (UINT32)&SISectionLargeData[i]);
  544. }
  546. status = KB_OSPQueInit("SI_Q", 128, &l_nQueueId);
  547. if (status != Ret_OK)
  548. {
  549.         return SI_OSP_ERROR;
  550. }
  552. status = KB_OSPTaskInit ("SI_T", 8 * 1024, (void (*)(void*))SITask, SIPSI_PRIORITY, NULL, (UINT32*)&l_nTaskId);
  553. if (status != Ret_OK)
  554. {
  555.         return SI_OSP_ERROR;
  556. }
  558. /*
  559. ** Initialize the number of filters
  560. */
  561. SICurrentFilter = 0;
  563. /* Create the various sub tables: */
  565. PATSubTableID = SISubTableCreate(&PATDetails, SIParsePAT, SIHandlePat, SIHandlePatTimeout, NULL);
  566.     if (PATSubTableID < 0)
  567.     {
  568.         return SI_NO_FREE_SUBTABLES;
  569.     }
  570.     
  571. NITSubTableID = SISubTableCreate(&NITDetails, SIParseNIT, SIHandleNit, SIHandleNitTimeout, NULL);
  572.     if (NITSubTableID < 0)
  573.     {
  574.         return SI_NO_FREE_SUBTABLES;
  575.     }
  576.     
  577. SDTSubTableID = SISubTableCreate(&SDTDetails, SIParseSDT, SIHandleSdt, SIHandleSdtTimeout, NULL);
  578.     if (SDTSubTableID < 0)
  579.     {
  580.         return SI_NO_FREE_SUBTABLES;
  581.     }
  582.     
  583. EITSubTableID = SISubTableCreate(&EITDetails, SIParseEit, SIHandleEit, SIHandleEitTimeout, SiEitSetup);
  584.     if (EITSubTableID < 0)
  585.     {
  586.         return SI_NO_FREE_SUBTABLES;
  587.     }
  588.     
  589. CATSubTableID = SISubTableCreate(&CATDetails, SIParseCAT, SIHandleCat, SIHandleCatTimeout, NULL);
  590.     if (CATSubTableID < 0)
  591.     {
  592.         return SI_NO_FREE_SUBTABLES;
  593.     }
  594.     
  595. TDTSubTableID = SISubTableCreate(&TDTDetails, SIParseTDT, NULL,       SIHandleTdtTimeout, NULL);
  596.     if (TDTSubTableID < 0)
  597.     {
  598.         return SI_NO_FREE_SUBTABLES;
  599.     }
  600.     
  601. RSTSubTableID = SISubTableCreate(&RSTDetails, SIParseRST, NULL,       NULL,              NULL);
  602.     if (RSTSubTableID < 0)
  603.     {
  604.         return SI_NO_FREE_SUBTABLES;
  605.     }
  606.     
  607. TOTSubTableID = SISubTableCreate(&TOTDetails, SIParseTOT, NULL,       SIHandleTotTimeout, NULL);
  608.     if (TOTSubTableID < 0)
  609.     {
  610.         return SI_NO_FREE_SUBTABLES;
  611.     }
  613.     PMTDetails.noFilters = SI_NO_PMT_FILTERS;
  614. PMTSubTableID[0] = SISubTableCreate(&PMTDetails, SIParsePMT, SIHandlePmt, SIHandlePmtTimeout, NULL);
  615.     if (PMTSubTableID[0] < 0)
  616.     {
  617.         return SI_NO_FREE_SUBTABLES;
  618.     }
  619.     
  620. PMTDetails.noFilters = 1;
  621. for(i = 1; i < SI_NO_PMT_TABLES; i++)
  622. {
  623. PMTSubTableID[i] = SISubTableCreate(&PMTDetails, SIParsePMT, SIHandlePmt, SIHandlePmtTimeout, NULL);
  624.         if (PMTSubTableID[i] < 0)
  625.         {
  626.             return SI_NO_FREE_SUBTABLES;
  627.         }
  628. }
  629. SITimer = KB_TimerCreate(KB_TIMER_REPEAT , (KB_TIMER_FUNC_POINTER)SISendTimerMessage,NULL);
  630. if(SITimer == KB_TIMER_INVALID_ID )
  631. {
  632.         
  633. return SI_UNKNOWN_ERROR;
  634. }
  635.     
  636. status = KB_TimerEnable(SITimer, SI_TIMER_TICK_PERIOD);
  637. if(status != RETOK)
  638. {
  639.         
  640. return SI_UNKNOWN_ERROR;
  641. }
  643. return SI_OK;
  644. }
  646. static INT32 SISubTableDestroy(void)
  647. {
  648. INT32 status;
  649. INT32 i, j;
  651. /*
  652. ** Stop the SI Timer tick.
  653. */
  654. KB_TimerDisable(SITimer);
  655. status = KB_TimerDel(SITimer);
  656. for(i = 0; i < SI_MAX_SUB_TABLES; i++)
  657. {
  658. INT32 nFilterNumber;
  660. nFilterNumber = SISubTable[i].details.noFilters;
  661. for(j = 0; j < nFilterNumber; j++)
  662. {
  663. KB_DmxFreeFilter( SISubTable[i].filter[j].filterID);
  664. }
  666. KB_DmxFreeChnnl(SISubTable[i].details.channelID);
  668. }
  670. KB_OSPTaskDel(l_nTaskId);
  672. KB_OSPQueDel(l_nQueueId);
  674. return SI_OK;
  675. }
  677. static T_SubTableID SISubTableCreate(T_SubTableDetails* details,
  678.                                      T_SectionCallback sectionCallback,
  679.                                      T_SubTableCallback tableCallback,
  680.                                      T_TimeoutCallback timeoutCallback,
  681.                                      T_SetupCallback setupCallback)
  682. {
  683. UINT32 i;
  684. UINT32 subTableID, channelID;
  685. INT32  nReturn;
  686.     UINT32 filterID;
  687. UINT32 j;
  688. T_SubTableFilter *filterDetails;
  689.         
  690. /*
  691. ** Get a free sub-table. Return an error if no free storage is available.
  692. */
  693. if(LIFOPop(&SISubTableList, &subTableID) != LIFO_OK)
  694. {
  695. return SI_NO_FREE_SUBTABLES;
  696. }
  698. /*
  699. ** Allocate the Demux resources
  700. */
  701. if (details == &EITDetails)
  702. {
  703.         nReturn = KB_DmxAllocateChnnl(DMX_CHANNEL_SECTION, 256 * 1024, FALSE, &channelID);
  704. }
  705.     else
  706. {
  707.     nReturn = KB_DmxAllocateChnnl(DMX_CHANNEL_SECTION, SI_DMX_BUFFER_SIZE, FALSE, &channelID);
  708. }
  709. if(nReturn != RETOK)
  710. {
  711.     channelID = 0xFFFFFFFF;
  712. return SI_NO_AVAILABLE_CHANNELS;
  713. }
  714.     
  715. KB_DmxRegNotice(channelID, SIGetSection);
  717. SISubTable[subTableID].filter = &SIFilters[SICurrentFilter];
  718. SICurrentFilter += details->noFilters;
  719. if(SICurrentFilter > SI_DMX_NO_FILTERS)
  720. {
  721. SICurrentFilter -= details->noFilters;
  722. LIFOPush(&SISubTableList, subTableID);
  724. return SI_NO_AVAILABLE_FILTERS;
  725. }
  727. /*
  728. ** Store the sub-table details
  729. */
  730. SISubTable[subTableID].sectionCallback = sectionCallback;
  731. SISubTable[subTableID].tableCallback = tableCallback;
  732. SISubTable[subTableID].setupCallback = setupCallback;
  733. SISubTable[subTableID].details.PID = details->PID;
  734. SISubTable[subTableID].details.channelID = channelID;
  735. SISubTable[subTableID].details.multipleSections = details->multipleSections;
  736. SISubTable[subTableID].details.tableID = details->tableID;
  737. SISubTable[subTableID].details.tableIDExt = details->tableIDExt;
  738. SISubTable[subTableID].details.timeout = details->timeout;
  739. SISubTable[subTableID].details.noFilters = details->noFilters;
  740. SISubTable[subTableID].details.channelStarted = FALSE;
  742. /*
  743. ** Store which sub table is using the channel
  744. */
  745. /* SIChannelToSubTableMap[channelID] = subTableID; */
  746.     for(i=0; i<SI_DMX_NO_CHANNELS; i++)
  747. {
  748. if(!SIChannelToSubTableMap[i].valid)
  749. {
  750. SIChannelToSubTableMap[i].channelId = channelID;
  751. SIChannelToSubTableMap[i].subTableId = subTableID;
  752. SIChannelToSubTableMap[i].valid = 1;
  753. break;
  754. }
  755. }
  757. /*
  758. ** Allocate the filters
  759. */
  760. /* EIT只使用一个硬件filter */
  761. if (details == &EITDetails)
  762. {
  763.         nReturn = KB_DmxAllocateFilter(DMX_SECTION_FILTER, SI_FILTER_DEPTH, &filterID);
  764. if(nReturn != RETOK)
  765. {
  766. return SI_NO_AVAILABLE_FILTERS;
  767. }
  769.         for(i = 0; i < details->noFilters; i++)
  770.         {
  771.             filterDetails = &SISubTable[subTableID].filter[i];
  773.      /* Store the initial values for the filter */
  774.      filterDetails->tableID = details->tableID;
  775.      filterDetails->tableIDExt = details->tableIDExt;
  776.      filterDetails->version = -1;
  777.      filterDetails->timeout = -1; //details->timeout
  778.      filterDetails->filterID = filterID;
  779.      filterDetails->filterNumber = i;
  780.      filterDetails->timeoutCallback = timeoutCallback;
  781.      filterDetails->subTableID = subTableID;
  782.      filterDetails->enabled = FALSE;
  783.             filterDetails->used    = FALSE;
  784.             
  785.      for( j = 0; j < SI_MAX_SECTION_PER_TABLE; j++ )
  786.      {
  787.      filterDetails->data.sectionData[j] = SI_SECTION_NOT_RECEIVED;
  788.      }
  789.         }
  790. }
  791.     else
  792.     {
  793.      for(i = 0; i < details->noFilters; i++)
  794.      {
  795.      /*
  796.      ** Setup the static parts of the H/W
  797.      */
  798.      nReturn = KB_DmxAllocateFilter(DMX_SECTION_FILTER, SI_FILTER_DEPTH, &filterID);
  799.      if(nReturn != RETOK)
  800.      {
  801.      return SI_NO_AVAILABLE_FILTERS;
  802.      }        
  803.             
  804.      filterDetails = &SISubTable[subTableID].filter[i];
  806.      /* Store the initial values for the filter */
  807.      filterDetails->tableID = details->tableID;
  808.      filterDetails->tableIDExt = details->tableIDExt;
  809.      filterDetails->version = -1;
  810.      filterDetails->timeout = -1; //details->timeout
  811.      filterDetails->filterID = filterID;
  812.      filterDetails->filterNumber = i;
  813.      filterDetails->timeoutCallback = timeoutCallback;
  814.      filterDetails->subTableID = subTableID;
  815.      filterDetails->enabled = FALSE;
  816.             filterDetails->used    = FALSE;
  817.             
  818.      for( j = 0; j < SI_MAX_SECTION_PER_TABLE; j++ )
  819.      {
  820.      filterDetails->data.sectionData[j] = SI_SECTION_NOT_RECEIVED;
  821.      }
  822.             
  823.      }
  824.     }
  825.     
  826. return subTableID;
  827. }
  829. INT32 SIFreeSectionData(MepgData *section)
  830. {
  831. INT32 status = SI_INVALID_SECTION_DATA_ID;
  833. /* Validate the sectionData before adding it to the free list */
  834. if(section != NULL)
  835. {
  836. if(section >= &SISectionSmallData[0] && section <= &SISectionSmallData[SI_MAX_SECTION_SMALL_DATA])
  837. {
  838.             KB_DmxUnlock(SISubTable[section->subTableID].details.channelID,
  839.                              section->data);
  840.             section->data = NULL;
  841.             
  842. LIFOPush(&SISectionSmallDataList, (UINT32)section);
  843. status = SI_OK;
  844. }
  845. else if(section >= &SISectionLargeData[0] && section <= &SISectionLargeData[SI_MAX_SECTION_LARGE_DATA])
  846. {
  847.             KB_DmxUnlock(SISubTable[section->subTableID].details.channelID,
  848.                              section->data);
  849.             section->data = NULL;
  850.             
  851. LIFOPush(&SISectionLargeDataList, (UINT32)section);
  852. status = SI_OK;
  853. }
  854.         
  855. }
  856.     
  857. return status;
  858. }
  860. /*
  861. ** Private Functions
  862. */
  863. static void SIFilterStopHelper(UINT32 channelID, T_SubTableFilter *filter)
  864. {
  865.     int i;
  866. T_SubTableID  subTableID = 0;
  869. for(i=0; i<SI_DMX_NO_CHANNELS; i++)
  870. {
  871. if(SIChannelToSubTableMap[i].valid &&
  872. (SIChannelToSubTableMap[i].channelId == channelID))
  873. {
  874. subTableID = SIChannelToSubTableMap[i].subTableId;
  875. break;
  876. }
  877. }
  879. if(i >= SI_DMX_NO_CHANNELS)
  880. {
  881. return;
  882. }
  883.     
  884. /* Reset the timer */
  885. filter->timeout = -1;
  887.     /* 把sub table filter设为不可用状态 */
  888.     filter->enabled = FALSE;
  889.     //filter->used    = FALSE;
  890.     
  891.     if (subTableID == EITSubTableID)
  892.     {
  893.         for (i = 0; i < SI_NO_EIT_FILTERS; i++)
  894.         {
  895.             if (SISubTable[subTableID].filter[i].enabled == TRUE)
  896.             {
  897.                 break;
  898.             }            
  899.         }
  901.         /* 当所有过滤器都停止时才停止通道和过滤器 */
  902.         if(i >= SI_NO_EIT_FILTERS)
  903. {
  904.             if (SISubTable[subTableID].details.channelStarted == TRUE)
  905.             {                
  906.     SISubTable[subTableID].details.channelStarted = FALSE;  
  908.                 DBGPrint("Stop helper eitn");
  909.                 KB_DmxControlChnnl(channelID, KB_DMX_STOP);
  910.                 KB_DmxDisassociateFilter(channelID, filter->filterID);
  911.             }
  912. }         
  913.     }
  914.     else
  915.     {
  916.         SISubTable[subTableID].details.channelStarted = FALSE;
  917.      KB_DmxControlChnnl(channelID, KB_DMX_STOP);
  918.      KB_DmxDisassociateFilter(channelID, filter->filterID);
  919.     }
  920. //KB_DmxControlChnnl(channelID, KB_DMX_START);
  921. }
  923. static void SIFilterStop(UINT32 channelID, T_SubTableFilter *filter)
  924. {
  925. SIFilterStopHelper(channelID, filter);
  927. }
  929. static void SIFilterDetach(UINT32 channelID, T_SubTableFilter *filter)
  930. {
  931. /* Reset the timer */
  932. filter->timeout = -1;
  934. KB_DmxDisassociateFilter(channelID, filter->filterID);
  936. filter->enabled = FALSE;
  937.     filter->used    = FALSE;
  938. }
  940. static void SISubTableStop(T_SubTableID subTableID)
  941. {
  942. UINT32 i;
  944.     KB_DmxControlChnnl(SISubTable[subTableID].details.channelID, KB_DMX_STOP);
  946. SISubTable[subTableID].details.channelStarted = FALSE;
  948. for(i = 0; i < SISubTable[subTableID].details.noFilters; i++)
  949. {
  950. SIFilterDetach(SISubTable[subTableID].details.channelID, &SISubTable[subTableID].filter[i]);
  951. }
  952. }
  954. static void SISubTableStart(T_SubTableID subTableID, UINT32 filterNumber, INT32 version, UINT32 handle)
  955. {
  956. UINT32 i;
  957. T_SubTableFilter *filterDetails;
  958. UINT32 channelID;
  959. UINT32 filterID;
  960. UINT8 filterMask[16];
  961. UINT8 filterMatch[16];
  962. UINT32 filterNegate;
  964.     memset(filterMatch, 0, sizeof(filterMatch));
  965.     memset(filterMask, 0, sizeof(filterMask));
  967. /*
  968. ** Update the filter values
  969. */
  970. filterDetails = &SISubTable[subTableID].filter[filterNumber];
  971. filterID = filterDetails->filterID;
  972. channelID = SISubTable[subTableID].details.channelID;
  974. /*
  975. ** First of all stop the demux channel to prevent any more data from being received.
  976. */
  977. if (subTableID == EITSubTableID)
  978. {
  979.         if (SISubTable[subTableID].details.channelStarted != TRUE)
  980.         {
  981.       KB_DmxControlChnnl(channelID, KB_DMX_STOP);
  982.             SISubTable[subTableID].details.channelStarted = FALSE;
  983.         }
  984. }
  985.     else
  986.     {
  987.         KB_DmxControlChnnl(channelID, KB_DMX_STOP);
  988.         SISubTable[subTableID].details.channelStarted = FALSE;
  989.     }
  991.     task_lock();
  993. if( SISubTable[subTableID].setupCallback != NULL )
  994. {
  995. SISubTable[subTableID].setupCallback(subTableID, filterNumber, version, handle);
  996. }
  997. else
  998. {
  999. /*
  1000. ** Update the filter values
  1001. */
  1002. filterDetails = &SISubTable[subTableID].filter[filterNumber];
  1004. filterDetails->data.total = -1;
  1005. filterDetails->data.received = 0;
  1007. for(i = 0; i < SI_MAX_SECTION_PER_TABLE; i++)
  1008. {
  1009. /* Before resetting the section data list check to make sure no section data buffers are still waiting for data */
  1010. //防止内存泄漏
  1011. if( (filterDetails->data.sectionData[i] != SI_SECTION_NOT_RECEIVED) &&
  1012. (filterDetails->data.sectionData[i] != SI_SECTION_RECEIVED) )
  1013. {
  1014. SIFreeSectionData(filterDetails->data.sectionData[i]);
  1015. }
  1016. filterDetails->data.sectionData[i] = SI_SECTION_NOT_RECEIVED;
  1017. }
  1019. filterDetails->tableID = SISubTable[subTableID].details.tableID;
  1020. filterDetails->tableIDExt = SISubTable[subTableID].details.tableIDExt;
  1021. filterDetails->version = version;
  1022. filterDetails->timeout = SISubTable[subTableID].details.timeout;
  1023. filterDetails->handle = handle;
  1025. if( filterDetails->tableID != -1 )
  1026. {
  1027. filterMask[0] = 0xFF;
  1028. filterMatch[0] = (UINT8) (filterDetails->tableID & 0xFF);
  1029. }
  1030. else
  1031. {
  1032. filterMask[0] = 0x00;
  1033. filterMatch[0] = 0x00;
  1034. }
  1036. if( filterDetails->tableIDExt != -1 )
  1037. {
  1038. filterMask[3] = 0xFF;
  1039. filterMask[4] = 0xFF;
  1040. filterMatch[3] = (UINT8)((filterDetails->tableIDExt >> 8) & 0xFF);
  1041. filterMatch[4] = (UINT8) (filterDetails->tableIDExt & 0xFF);
  1042. }
  1043. else
  1044. {
  1045. filterMask[3] = 0x00;
  1046. filterMask[4] = 0x00;
  1047. filterMatch[3] = 0x00;
  1048. filterMatch[4] = 0x00;
  1049. }
  1051. if( filterDetails->version != -1 )
  1052. {
  1053. filterMask[5] = 0x3E;
  1054. filterMatch[5] = (UINT8)((filterDetails->version & 0x1F) << 1);
  1056. filterNegate = (1 << 5);
  1057. }
  1058. else
  1059. {
  1060. filterMask[5] = 0x00;
  1061. filterMatch[5] = 0x00;
  1063. filterNegate = 0;
  1064. }      
  1067. filterDetails->enabled = TRUE;   
  1068.          filterDetails->used    = TRUE;
  1070.         KB_DmxAssociateFilter(channelID, filterID);        
  1071. KB_DmxSetFilter(filterID, filterMatch, filterMask, filterNegate);
  1072. }
  1074.     task_unlock();
  1075.     
  1076.     if (subTableID == EITSubTableID)
  1077. {
  1078.         if (SISubTable[subTableID].details.channelStarted != TRUE)
  1079.         {
  1080.         KB_DmxSetChnnlPID(channelID, (UINT16)SISubTable[subTableID].details.PID);
  1081.          SISubTable[subTableID].details.channelStarted = TRUE;
  1082.         }
  1083. }
  1084.     else
  1085.     {
  1086.         KB_DmxSetChnnlPID(channelID, (UINT16)SISubTable[subTableID].details.PID);
  1087.      SISubTable[subTableID].details.channelStarted = TRUE;
  1088.     }
  1089.     
  1090. }
  1092. static BOOL SIHandleNewSection(UINT8* headerMPEGSection, T_DMX_Notify* notifyData)
  1093. {
  1094. T_SubTableID subTableID = 0;
  1095. T_SubTableFilter *filter;
  1096. UINT32 filterNumber;
  1097. UINT32 sectionNumber;
  1098. UINT32 sectionLength;
  1099. UINT32 i;
  1100. UINT16 tableIDExt;
  1101. UINT8 *data;
  1102. UINT8 version;
  1103. UINT8 tableID;
  1104. MepgData *sectionData;
  1105. SIFIFO *sectionDataList;
  1106. int nIsMulti = 0;
  1108. /* Assume we do not want the section. */
  1109. notifyData->copyLength = 0;
  1111.     if(notifyData->whichChannel == 0xFFFFFFFF)
  1112. {
  1113. return (FALSE);
  1114. }
  1116. /*
  1117. ** Get the subTable ID associated with this section.
  1118. */
  1119. /* subTableID = SIChannelToSubTableMap[notifyData->whichChannel]; */
  1120.     for(i=0; i<SI_DMX_NO_CHANNELS; i++)
  1121. {
  1122. if (SIChannelToSubTableMap[i].valid 
  1123.             && (SIChannelToSubTableMap[i].channelId == notifyData->whichChannel))
  1124. {
  1125. subTableID = SIChannelToSubTableMap[i].subTableId;
  1126. break;
  1127. }
  1128. }
  1130.     if(i >= SI_DMX_NO_CHANNELS)
  1131. {
  1132. return FALSE;
  1133. }
  1134.     
  1135. if(subTableID > SI_MAX_SUB_TABLES || subTableID < 0)
  1136. {
  1137. return (FALSE);
  1138. }
  1140. data = headerMPEGSection;
  1143. /*
  1144. ** Store the section information
  1145. */
  1146. tableID = data[0];
  1147. sectionLength = ((((UINT32)data[1] & 0x0F) << 8) + (UINT32)data[2]) + 3;
  1148. tableIDExt = (UINT16)(data[3] << 8) | data[4];
  1149. version = (UINT8)((data[5] & 0x3E) >> 1);
  1151.     
  1152. /*
  1153. ** If the section syntax is set then remove the CRC from the data to be
  1154. ** copied
  1155. */
  1156. if( data[1] & 0x80 )
  1157. {
  1158. sectionLength -= 4;
  1159. }
  1161. /*
  1162. ** Ensure there is enough space to perform the copy. Note. The only DVB
  1163. ** section allowed to be longer than 1024 bytes are EIT scheduling
  1164. ** information.
  1165. */
  1166. if(sectionLength > 4096)
  1167. {
  1168. return (FALSE);
  1169. }
  1170. else 
  1171.     {
  1172.         if(sectionLength > 1024)
  1173.         {
  1174.          sectionDataList = &SISectionLargeDataList;
  1175.         }
  1176.         else
  1177.         {
  1178.          sectionDataList = &SISectionSmallDataList;
  1179.         }
  1180. }
  1182. /*
  1183. ** Locate which filter this section passed. Initially assume it was the
  1184. ** first.
  1185. */
  1186. filter = &SISubTable[subTableID].filter[0];
  1187. filterNumber = 0;
  1189. /*
  1190. ** Check to ensure that the section we have just received is one we currently want.
  1191. */
  1192. for(i = 0; i < SISubTable[subTableID].details.noFilters; i++)
  1193. {
  1194. filter = &SISubTable[subTableID].filter[i];
  1196. if((filter->enabled == TRUE) &&
  1197.    (filter->tableID == tableID || filter->tableID == -1 ) &&
  1198.    (filter->tableIDExt == tableIDExt || filter->tableIDExt == -1 ) &&
  1199.    (filter->version == version || filter->version == -1 ) )
  1200. {
  1201. filterNumber = i;
  1202. break;
  1203. }
  1204. }
  1205.     
  1206. if( i == SISubTable[subTableID].details.noFilters )
  1207. {
  1208. return (FALSE);
  1209. }
  1211. if(SISubTable[subTableID].details.multipleSections == TRUE)
  1212. {        
  1213. if(filter->tableID == 0x50 && filter->tableIDExt == -1)
  1214. {
  1215. nIsMulti = 1;
  1216. }
  1217. /*
  1218. ** Is this section needed.
  1219. */
  1220. sectionNumber = data[6];
  1222.         
  1223. if( nIsMulti ? 1 :(filter->data.sectionData[sectionNumber] == SI_SECTION_NOT_RECEIVED))
  1224. {
  1225. /*
  1226. ** Get the next free section data area. If there are none available,
  1227. ** then do nothing and wait for the section to be repeated.
  1228. */
  1229. if( LIFOPop(sectionDataList, (UINT32*)&sectionData) == LIFO_OK)
  1230. {
  1231. //J_SI_Print("Success....n");
  1232. /*
  1233. ** Update the sub table details
  1234. */
  1235. filter->data.sectionData[sectionNumber] = sectionData;
  1236. /*
  1237. ** Check to see if this is the first section received.
  1238. */
  1239. if( filter->data.total == -1 )
  1240. {
  1241. filter->data.total = data[7];
  1242. }
  1244. if(tableID == 0x50 
  1245.                                    || tableID == 0x51 
  1246.                                    || tableID == 0x60 
  1247.                                    || tableID == 0x61
  1248.                                    || tableID == 0x4F) /* EIT Specific */
  1249. {
  1250. /* data[6] :section_number, data[7]:last_section_number, 
  1251. ** data[12]: segment_last_section_number 
  1252. ** 每一个segment可以包含8个section，同时包含三个小时内开始的事件信息。
  1253. */
  1254. if( (sectionNumber == data[12]) && (data[7] != data[12]) )
  1255. {
  1256. filter->data.received += (0x7 - (sectionNumber & 0x7));
  1257. }
  1258. }
  1259. filter->data.version = version;
  1260. filter->data.tableIDExt = tableIDExt;
  1262. /*
  1263. ** Update the section data details.
  1264. */
  1265. sectionData->length = sectionLength;
  1266. sectionData->subTableID = subTableID;
  1267. sectionData->filterNumber = filterNumber;
  1269. /*
  1270. ** Is there any data to copy. If not call SISectionCopied directly,
  1271. ** which will in turn call the high level.
  1272. */
  1274. if( sectionData->length != 0 )
  1275. {
  1276.                      sectionData->data = headerMPEGSection;
  1278. notifyData->skipLength = 0;
  1279. notifyData->copyLength = sectionData->length + 4; // 包含了CRC_32
  1280. notifyData->tag = (void*)sectionData;
  1281. notifyData->outputBuffer = (UINT8*)sectionData->data;
  1282. }
  1283. else
  1284. {
  1285. SISectionCopied( DMX_AVAILABLE,
  1286. (UINT8*)sectionData->data,
  1287.  0, (void*)sectionData );
  1288.                     return FALSE;
  1289. }
  1290. }
  1291. else
  1292. {                
  1293.                 return FALSE;
  1294. }
  1295. }
  1296.         else
  1297.         {
  1298.             return FALSE;
  1299.         }
  1300. }
  1301. else /* multipleSections == FALSE */
  1302. {
  1303. if(LIFOPop(sectionDataList, (UINT32*)&sectionData) == LIFO_OK)
  1304. {
  1305. sectionData->length = sectionLength;
  1306. sectionData->subTableID = subTableID;
  1307. sectionData->filterNumber = filterNumber;
  1309.             sectionData->data = headerMPEGSection;
  1310.             
  1311. /*
  1312. ** Setup the information for the copy.
  1313. */
  1314. notifyData->skipLength  = 0;
  1315. notifyData->copyLength  = sectionData->length;
  1316. notifyData->tag  = (void*)sectionData;
  1317. notifyData->outputBuffer = (UINT8*)sectionData->data;
  1318. }
  1319. else
  1320. {
  1321.             return FALSE;
  1322. }
  1323. }
  1325. return( TRUE );
  1326. }
  1329. /****************************************************************************
  1330. ** Function     SISectionCopied()
  1331. **
  1332. ** Description  Called by the Demux driver when a section has been copied.
  1333. **              Performs the following:
  1334. **               o Inform the SI Task of the new section
  1335. **               o If all the section of the sub table have been received then:
  1336. **                  Inform the SI task that the table is complete
  1337. **                  Stop the reception of the table.
  1338. **
  1339. ** Input        INT32 condition
  1340. **                Whether the section was copied successfully or not.
  1341. **              UINT8* buffer
  1342. **                The buffer containing the data. NOT USED
  1343. **              UINT32 length
  1344. **                The total number of bytes copied. NOT USED
  1345. **              void *tag
  1346. **                The section data identifier passed to the section copy
  1347. **                routine by the header notify callback. Indicates which
  1348. **                section the data belongs to.
  1349. **
  1350. ** Modified     None
  1351. **
  1352. ** Return       Nothing
  1353. **
  1354. *****************************************************************************/
  1355. static void SISectionCopied( INT32 condition, UINT8 *buffer, UINT32 length, void *tag)
  1356. {
  1357. KB_OSPMsgNode message;
  1358. T_SubTableFilter *filter;
  1359. T_SubTableID subTableID;
  1360. UINT32      filterNumber;
  1361. MepgData *sectionData;
  1362. UINT32     channelID;
  1363. UINT32     sectionNumber;
  1364. UINT8 nitbuffer[300];
  1365. UINT32 i;
  1366. int nIsMulti = 0;
  1367.     int nCurrentNo;
  1369. sectionData = (MepgData*)tag;
  1371. /* Validate the tag */
  1372. if( (sectionData < &SISectionSmallData[0] ||
  1373.      sectionData > &SISectionSmallData[SI_MAX_SECTION_SMALL_DATA]) &&
  1374.     (sectionData < &SISectionLargeData[0] ||
  1375.      sectionData > &SISectionLargeData[SI_MAX_SECTION_LARGE_DATA]) )
  1376. {
  1377. J_SI_Print("[SI] Near Fatal Error: Tag invalid: %x (%d %x %d)n",
  1378. (int)tag, (int)condition, (int)buffer, (int)length );
  1379. return;
  1380. }
  1382. subTableID = sectionData->subTableID;
  1384. if(subTableID==NITSubTableID)
  1385. {
  1387. if (TFReceiveNitFlag == TRUE)
  1388. {
  1389. KB_CASetNIT(buffer,length); 
  1390. TFReceiveNitFlag = FALSE;
  1391. }
  1392. else
  1393. {
  1394. for(i=0;i<length;i++)
  1395. {
  1396. if (buffer[i] == 0xa1 && buffer[i+1] == 0x2B && buffer[i+2] ==0x00 && buffer[i+3] ==0xDF )
  1397. {
  1398.        break;
  1399. }
  1400. }
  1401. if (i<length-43)
  1402. {
  1403.     memcpy(nitbuffer,&buffer[i],43);
  1404.      CA_CheckNit(nitbuffer, 43);
  1405. }
  1406. }
  1407. }
  1408.     
  1409. filterNumber = sectionData->filterNumber;
  1410. filter = &SISubTable[subTableID].filter[filterNumber];
  1411. channelID = SISubTable[subTableID].details.channelID;
  1412.     
  1413. if(filter->tableIDExt == -1 && buffer[0] == 0x50)
  1414. {
  1415. nIsMulti = 1;
  1416. }
  1417.     
  1418.     //End addition
  1419. if(condition != DMX_AVAILABLE)
  1420. {
  1421. //if(!nIsMulti)
  1422. J_SI_Print("[SI] Lost section %xn", (int)sectionData);
  1424. if( SISubTable[subTableID].details.multipleSections == TRUE )
  1425. {
  1426. sectionNumber = buffer[6];
  1427. if(filter->data.sectionData[sectionNumber] == sectionData)
  1428. {
  1429. filter->data.sectionData[sectionNumber] = SI_SECTION_NOT_RECEIVED;
  1430. }
  1431. }
  1433. SIFreeSectionData(sectionData);
  1435. return;
  1436. }
  1438. message.Word1 = SI_MSG_COPY;
  1439. message.Word2/*sectionData*/ = (UINT32)sectionData;
  1440. message.Word3/*handle*/ = filter->handle;
  1441. message.Word4/*filterNumber*/ = filterNumber;
  1443. if( KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message) != Ret_OK )
  1444. {
  1445. /* Error sending message so clean up section */
  1446. SIFreeSectionData(sectionData);
  1448. /*
  1449. ** Since the section wasn't sent correctly, remove it from the received
  1450. ** list. The total value has yet to be incremented, so we do not need to
  1451. ** decrement it.
  1452. */
  1453. if(SISubTable[subTableID].details.multipleSections == TRUE)
  1454. {
  1455. sectionNumber = buffer[6];
  1456. if(filter->data.sectionData[sectionNumber] == sectionData)
  1457. {
  1458. filter->data.sectionData[sectionNumber] = SI_SECTION_NOT_RECEIVED;
  1459. }
  1460. }
  1462. }
  1463. else
  1464. {
  1466. /*
  1467. ** Check to see whether this sub-table is completed.
  1468. */
  1469. if(nIsMulti)
  1470. {
  1471. static int nMsgSent = 0; //SI_MSG_COMPLETED的消息已发出
  1472. INT16 nServiceNum;
  1473. int i, nDone = 1;
  1475. nServiceNum = l_pstCurrMultiEinSchInfoPara->nServiceNum;
  1476. for(i = 0; i < nServiceNum; i ++)
  1477. {
  1478. if(l_pstCurrMultiEinSchInfoPara->nTableDone[i][0] != 1)
  1479. {
  1480. nDone = 0;
  1481. break;
  1482. }
  1483. }
  1485. if(nDone)
  1486. {
  1487. if(!nMsgSent)
  1488. {
  1489. //所有的EIT schedule表接收完
  1490. nMsgSent = 1;
  1491. message.Word1 = SI_MSG_COMPLETED;
  1492. /*
  1493. ** Completed the sub-table, so reset the current filter to block
  1494. ** all data and then inform the user.
  1495. */
  1496. SIFilterStopHelper(channelID, filter);
  1497. KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message);
  1498. }
  1499. else
  1500. { nMsgSent = 0;} //保证下一次接收完的正确判断
  1501. }
  1502. else
  1503. nMsgSent = 0;
  1505. return;
  1506. }
  1508. if( SISubTable[subTableID].details.multipleSections == TRUE )
  1509. {
  1510. /*
  1511. ** The message has been successfully sent to the SI task, so we can now
  1512. ** updated the section state to say it has been received.
  1513. */
  1514. sectionNumber = buffer[6];
  1515. if( filter->data.sectionData[sectionNumber] == sectionData )
  1516. {
  1517. filter->data.sectionData[sectionNumber] = SI_SECTION_RECEIVED;
  1518. }
  1519. }
  1521.         /* 以下一段代码应该考虑去掉，因为在这里判断影响了程序的处理流程，不易修改 */
  1522. if( SISubTable[subTableID].details.multipleSections == TRUE )
  1523. {
  1524. if(filter->data.received == filter->data.total)
  1525. {                                    
  1526. if(subTableID == EITSubTableID && filterNumber < KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT)
  1527. {
  1528.                     int i;
  1529.                 
  1530.                     for (i = 0; i < KB_SI_EIT_SCHEDULE_SERVICE_COUNT; i++)
  1531.                     {
  1532.                         if(l_pstCurrEinSchInfoPara[i]->handle == filter->handle)
  1533.                      {
  1534.                             nCurrentNo = i;
  1535.                      break;
  1536.                      }
  1537.                     }  
  1538.                 
  1539. if(l_pstCurrEinSchInfoPara[nCurrentNo]->nTableDone[1] == 0)
  1540. {
  1541. // 兼容前端系统只发table_id=50的情形
  1542. if(buffer[13]/* last_table_id */ == 0x50)
  1543. {
  1544. l_pstCurrEinSchInfoPara[nCurrentNo]->nTableDone[1] = 1;
  1545. }
  1546. }
  1548.                     if (filter->tableID == 0x50)
  1549.                     {
  1550.     l_pstCurrEinSchInfoPara[nCurrentNo]->nTableDone[0] = 1;
  1551.                     }
  1552.                     else
  1553.                     {
  1554.                         if (filter->tableID == 0x51)
  1555.                         {
  1556.                             l_pstCurrEinSchInfoPara[nCurrentNo]->nTableDone[1] = 1;
  1557.                         }
  1558.                     }
  1560. if(l_pstCurrEinSchInfoPara[nCurrentNo]->nTableDone[0] == 1 &&
  1561.    l_pstCurrEinSchInfoPara[nCurrentNo]->nTableDone[1] == 1)
  1562. {
  1563. message.Word1 = SI_MSG_COMPLETED;
  1565. /*
  1566. ** Completed the sub-table, so reset the current filter to block
  1567. ** all data and then inform the user.
  1568. */        
  1569.                         
  1570.                         if (filter->tableID == 0x50)
  1571.                         {
  1572.                             SIFilterStopHelper(channelID, &SISubTable[EITSubTableID].filter[filterNumber]);
  1573.                             filterNumber = SIGetFilterNum(EITSubTableID, 0x51, filter->tableIDExt);
  1574.                             if (filterNumber != 0xFFFFFFFF)
  1575.                             {
  1576.                                 SIFilterStopHelper(channelID, &SISubTable[EITSubTableID].filter[filterNumber]);
  1577.                             }
  1578.                         }
  1579.                         else
  1580.                         {
  1581.                             if (filter->tableID == 0x51)
  1582.                             {
  1583.                                 SIFilterStopHelper(channelID, &SISubTable[EITSubTableID].filter[filterNumber]);
  1584.                                 filterNumber = SIGetFilterNum(EITSubTableID, 0x50, filter->tableIDExt);
  1585.                                 if (filterNumber != 0xFFFFFFFF)
  1586.                                 {
  1587.                                     SIFilterStopHelper(channelID, &SISubTable[EITSubTableID].filter[filterNumber]);
  1588.                                 }
  1589.                             }
  1590.                         }
  1591. KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message) ;
  1593. }
  1594. }
  1595. else
  1596. {
  1597. message.Word1 = SI_MSG_COMPLETED;
  1599. /*
  1600. ** Completed the sub-table, so reset the current filter to block
  1601. ** all data and then inform the user.
  1602. */
  1604. SIFilterStopHelper(channelID, filter);
  1606. KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message) ;
  1608. }
  1609. }
  1610. else
  1611. {
  1612. filter->data.received++;
  1613. }
  1614. }
  1615. else
  1616. {
  1617. SIFilterStopHelper(channelID, filter);
  1618. }
  1619. }
  1620. }
  1622. static void SITask(void)
  1623. {
  1624. KB_OSPMsgNode message;
  1625. MepgData *sectionData;
  1626. T_SubTableID subTableID;
  1627. INT32 status;
  1629. while(TRUE)
  1630. {
  1631. status = KB_OSPMsgGet(l_nQueueId, KB_Wait, 0, (KB_OSPMsgNode *)&message);
  1632. if(status != Ret_OK)
  1633. {
  1634. continue;
  1635. }
  1637. switch (message.Word1)
  1638. {
  1639. case SI_MSG_TIMER_TICK:
  1640. SIHandleTimerTick();
  1641. break;
  1642. case SI_MSG_COPY:
  1643. sectionData = (MepgData*)message.Word2/*sectionData*/;
  1644. subTableID = sectionData->subTableID;
  1646. /*
  1647. ** Has the application made a new request.
  1648. */
  1649. #if 1
  1650. if(message.Word3/*handle*/ != SISubTable[subTableID].filter[message.Word4/*filterNumber*/].handle)
  1651. {
  1652. J_SI_Print("message.Word3=%d, message.Word4/*filterNumber*/].handle=%dn", 
  1653. (int)message.Word3, (int)SISubTable[subTableID].filter[message.Word4/*filterNumber*/].handle);
  1656. /* Check to ensure no buffers are left if the message is discarded */
  1657. SIFreeSectionData(sectionData);
  1658. if(subTableID == TDTSubTableID || subTableID == RSTSubTableID)
  1659. {
  1660. SISubTable[subTableID].filter[message.Word4/*filterNumber*/].enabled = FALSE;
  1661.                     SISubTable[subTableID].filter[message.Word4/*filterNumber*/].used    = FALSE;
  1662. }
  1663. break;
  1664. }
  1665. #endif
  1667. /*
  1668. ** Inform the user the section copy has completed
  1669. */
  1670. if( SISubTable[subTableID].sectionCallback != NULL )
  1671. {
  1672. SISubTable[subTableID].sectionCallback(sectionData);
  1673. }
  1674. if(subTableID == TDTSubTableID || subTableID == RSTSubTableID || subTableID == TOTSubTableID)
  1675. {
  1676. SISubTable[subTableID].filter[message.Word4/*filterNumber*/].enabled = FALSE;
  1677.                 SISubTable[subTableID].filter[message.Word4/*filterNumber*/].used    = FALSE;
  1678. }
  1679. break;
  1680. case SI_MSG_COMPLETED:
  1681. sectionData = (MepgData*)message.Word2/*sectionData*/;
  1682. subTableID = sectionData->subTableID;
  1684. /*
  1685. ** Has the application made a new request.
  1686. */
  1687. if(message.Word3/*handle*/ != SISubTable[subTableID].filter[message.Word4/*filterNumber*/].handle)
  1688. {
  1689. J_SI_Print("[SI] handle difference message.Word3 = %ld message.Word4 = %ld handle = %ldn", 
  1690.                            message.Word3, message.Word4, 
  1691.                            SISubTable[subTableID].filter[message.Word4/*filterNumber*/].handle);
  1692. break;
  1693. }
  1695. /*
  1696. ** Inform the user the table has been completed.
  1697. */
  1698. if( SISubTable[subTableID].tableCallback != NULL )
  1699. {
  1700. SISubTable[subTableID].tableCallback(subTableID, message.Word4/*filterNumber*/, message.Word3/*handle*/);
  1701. }
  1703. break;
  1704. case MSG_SI_PAT_RECEIVE:
  1705. SIGetPAT();
  1706. break;
  1707. case MSG_SI_PAT_STOP_RECEIVE:
  1708. SIStopPAT();
  1709. break;
  1710. case MSG_SI_NIT_RECEIVE:
  1711. SIGetNIT();
  1712. break;
  1713. case MSG_SI_NIT_STOP_RECEIVE:
  1714. SIStopNIT();
  1715. break;
  1716. case MSG_SI_PMT_RECEIVE:
  1717. SIGetPmt(message.Word2);
  1718. break;
  1719. case MSG_SI_PMT_STOP_RECEIVE:
  1720. SIStopPmt(message.Word2);
  1721. break;
  1722. case MSG_SI_SDT_RECEIVE:
  1723. SIGetSDT();
  1724. break;
  1725. case MSG_SI_SDT_STOP_RECEIVE:
  1726. SIStopSdt();
  1727. break;
  1728. case MSG_SI_BAT_RECEIVE:
  1729. SIGetBat();
  1730. break;
  1731. case MSG_SI_BAT_STOP_RECEIVE:
  1732. SIStopBat();
  1733. break;
  1734. case MSG_SI_EIT_PF_RECEIVE:
  1735. SIGetEitPF(message.Word2);
  1736. break;
  1737. case MSG_SI_EIT_PF_STOP_RECEIVE:
  1738. SIStopEitPF(message.Word2, message.Word3);
  1739. break;
  1740. case MSG_SI_EIT_SCHEDULE_RECEIVE:
  1741. SIGetEitSCH(message.Word2);
  1742. break;
  1743. case MSG_SI_MULTI_EIT_SCHEDULE_RECEIVE:
  1744. SIGetMultEitSCH();
  1745. break;
  1747. case MSG_SI_EIT_SCHEDULE_STOP_RECEIVE:
  1748. SIStopEitSCH(message.Word2);
  1749. break;
  1751. case MSG_SI_MULTI_EIT_SCHEDULE_STOP_RECEIVE:
  1752. SIStopMultEitSCH();
  1753. break;
  1755. case MSG_SI_TDT_RECEIVE:
  1756. SIGetTDT();
  1757. break;
  1758. case MSG_SI_TDT_STOP_RECEIVE:
  1759. SIStopTDT();
  1760. break;
  1761. case MSG_SI_CAT_RECEIVE:
  1762. SIGetCAT();
  1763. break;
  1764. case MSG_SI_CAT_STOP_RECEIVE:
  1765. SIStopCAT();
  1766. break;
  1767. case MSG_SI_RST_RECEIVE:
  1768. SIGetRst();
  1769. break;
  1770. case MSG_SI_RST_STOP_RECEIVE:
  1771. SIStopRst();
  1772. break;
  1774. case MSG_SI_TOT_RECEIVE:
  1775. SIGetTOT();
  1776. break;
  1777. case MSG_SI_TOT_STOP_RECEIVE:
  1778. SIStopTOT();
  1779. break;
  1781.         case MSG_SI_EIT_SCHEDULE_SHIFT_RECEIVE:
  1782.             SIGetEitSCHShift(message.Word2, message.Word3);
  1783.             break;
  1785.         case MSG_SI_EIT_SCHEDULE_SHIFT_STOP_RECEIVE:
  1786.             SIStopEitSCHShift(message.Word2, message.Word3);
  1787.             break;
  1788.             
  1789. default:
  1790. J_SI_Print( "SI: Internal case state error. Line %dn", __LINE__ );
  1791. break;
  1792. }
  1793. }
  1794. }
  1796. /*****************************************************************************
  1797.  **
  1798.  ** Part 2 - SubTable Parsing
  1799.  **
  1800.  *****************************************************************************/
  1801. /****************************************************************************
  1802. ** Function     SISendTimerMessage
  1803. **
  1804. ** Description  Timer callback. Called periodically as a timer tick. Generates
  1805. **              messages to the SI Task informing it of the tick.
  1806. **
  1807. ** Input        None
  1808. **
  1809. ** Modified     None
  1810. **
  1811. ** Return       Nothing
  1812. **
  1813. *****************************************************************************/
  1814. static void SISendTimerMessage(void)
  1815. {
  1816. KB_OSPMsgNode message;
  1818. message.Word1 = SI_MSG_TIMER_TICK;
  1819. KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode*)&message);
  1820. }
  1821. extern void LED_ShowNum(int i);
  1822. /****************************************************************************
  1823. ** Function     SIHandleTimerTick
  1824. **
  1825. ** Description  Called by SI Task whenever an SI Tick occurs. Performs the
  1826. **              following:
  1827. **               o For each filter decrement the timer (if enabled)
  1828. **               o If the timer expires:
  1829. **                  Generate the timeout callback (if present)
  1830. **                  Reset the timer (if requested by the callback)
  1831. **
  1832. ** Input        None
  1833. **
  1834. ** Modified     None
  1835. **
  1836. ** Return       Nothing
  1837. **
  1838. *****************************************************************************/
  1839. static void SIHandleTimerTick(void)
  1840. {
  1841. UINT32 i;
  1843. /*
  1844. ** Check each of the filters for a timeout.
  1845. */
  1847. for(i = 0; i < SICurrentFilter; i++)
  1848. {
  1849. if(SIFilters[i].version == -1 && SIFilters[i].timeout != -1)
  1850. {
  1851.             #if 0
  1852.             DBGPrint("i = %d, o = %dn", i, SIFilters[i].timeout);
  1853.             #endif
  1854. //LED_ShowNum((int)SIFilters[i].timeout);
  1855. SIFilters[i].timeout--;
  1856. if(SIFilters[i].timeout == 0)
  1857. {
  1858. /* Timer expired so call the associated callback if present */
  1859. if(SIFilters[i].timeoutCallback != NULL)
  1860. {
  1861. SIFilters[i].timeout = SIFilters[i].timeoutCallback(i);
  1862. }
  1863. else
  1864. {
  1865. /*
  1866. ** Since there is no timer callback associated disable the
  1867. ** timeout
  1868. */
  1869. SIFilters[i].timeout = -1;
  1870. }
  1871. }
  1872. }
  1873. }
  1874. }
  1876. /****************************************************************************
  1877. ** Function     SIStoreText
  1878. **
  1879. ** Description  Helper function for SI parsing which will take any DVB
  1880. **              encoded text streams and store them, taking into account any
  1881. **              control codes. This may be better performed by the applets or
  1882. **              font engine.
  1883. **
  1884. ** Input        UINT8* dst
  1885. **                Pointer to the destination.
  1886. **              UINT8* src
  1887. **                Pointer to the source of the data
  1888. **              UINT32 length
  1889. **                Amount of data (in bytes) to copy.
  1890. **
  1891. ** Modified     none
  1892. **
  1893. ** Return       nothing
  1894. **
  1895. *****************************************************************************/
  1896. static void SIStoreText(UINT8 *dst, UINT8 *src, UINT32 length)
  1897. {
  1898. INT32 nCharSet = 0x13; // 0x13 gb2312 0x11 unicode
  1899. UINT16 gb2312_code;
  1901. if(length == 0)
  1902. {
  1903. *dst = 0;
  1904. return;
  1905. }
  1908. if(*src < 0x20)
  1909. {
  1910. nCharSet = *src;
  1911. length--;
  1912. src++;
  1913. }
  1915. while(length-- > 0)
  1916. {
  1917. if(nCharSet == 0x11)
  1918. {
  1919. if(length == 0)
  1920. break;
  1921. if(*src != 0)
  1922. {
  1923. gb2312_code = UnicodeToGB2312((UINT16)(*src * 0x100 + *(src+1)));
  1924. length--;
  1925. src += 2;
  1926. if(gb2312_code)
  1927. {
  1928. *dst++ = (UINT8)(gb2312_code>>8);
  1929. *dst++ = (UINT8)(gb2312_code & 0xFF);
  1930. }
  1931. else
  1932. {
  1933. *dst++ = ' ';
  1934. *dst++ = ' ';
  1935. }
  1936. }
  1937. else
  1938. {
  1939. length--;
  1940. src++;
  1941. if(*src >= 0x20 && *src < 0x7F)
  1942. {
  1943. *dst++ = *src++;
  1944. }
  1945. else
  1946. {
  1947. src++;
  1948. }
  1949. }
  1950. continue;
  1951. }
  1952. if(*src < 0x20)
  1953. {
  1954. src++;
  1955. continue;
  1956. }
  1957. if(*src > 0x7F)
  1958. {
  1959. if(length == 0)
  1960. break;
  1961. length--;
  1962. *dst++ = *src++;
  1963. *dst++ = *src++;
  1964. continue;
  1965. }
  1967. *dst++ = *src++;
  1969. }
  1970. *dst = '';
  1971. }
  1973. /****************************************************************************
  1974.  **
  1975.  ** LIFO (Last-In First-Out)
  1976.  **
  1977.  ** The following set of functions implement a generic LIFO. The current
  1978.  ** implementation isn't very space efficient, however it is reasonably quick
  1979.  **
  1980.  ***************************************************************************/
  1982. /****************************************************************************
  1983. ** Function     LIFOInitialize()
  1984. **
  1985. ** Description
  1986. **
  1987. ** Input        none
  1988. **
  1989. ** Modified     none
  1990. **
  1991. ** Return       INT32 - Always LIFO_OK
  1992. **
  1993. *****************************************************************************/
  1994. static INT32 LIFOInitialize(SIFIFO* lifo)
  1995. {
  1996. lifo->end      = lifo->buffer + lifo->size;
  1997. lifo->position = lifo->buffer;
  1999. return LIFO_OK;
  2000. }
  2002. /****************************************************************************
  2003. ** Function     LIFOPush()
  2004. **
  2005. ** Description  Place a new entry on the list
  2006. **
  2007. ** Input        T_FIFODetails* - the list to use
  2008. **              UINT32         - item to add
  2009. **
  2010. ** Modified     none
  2011. **
  2012. ** Return       INT32 -
  2013. **                LIFO_OK - item added
  2014. **                LIFO_FULL - no space left on the list
  2015. **
  2016. *****************************************************************************/
  2017. static INT32 LIFOPush(SIFIFO* lifo, UINT32 newItem)
  2018. {
  2019. INT32 status = LIFO_OK;
  2021.     KB_OSPSemGet(semCritical, KB_Wait, 0);
  2022.     
  2023. /* Check size */
  2024. if(lifo->position == lifo->end)
  2025. {
  2026. status = LIFO_FULL;
  2027. }
  2028. else
  2029. {
  2030. /* Add item to list */
  2031. *(lifo->position++) = newItem;
  2032. }
  2034. KB_OSPSemSet(semCritical);
  2036. return status;
  2037. }
  2039. /****************************************************************************
  2040. ** Function     LIFOPop()
  2041. **
  2042. ** Description  Get the next item from the list
  2043. **
  2044. ** Input        T_FIFODetails* - the list to use
  2045. **
  2046. ** Modified     UINT32         - item removed from list
  2047. **
  2048. ** Return       INT32 -
  2049. **                LIFO_OK    - item removed
  2050. **                LIFO_EMPTY - no items available
  2051. **
  2052. *****************************************************************************/
  2053. static INT32 LIFOPop(SIFIFO* lifo, UINT32* item)
  2054. {
  2055. INT32 status = LIFO_OK;
  2057. KB_OSPSemGet(semCritical, KB_Wait, 0);
  2059. /* Check size */
  2060. if(lifo->position == lifo->buffer)
  2061. {
  2062. status = LIFO_EMPTY;
  2063. }
  2064. else
  2065. {
  2066. /* Update pointers */
  2067. lifo->position--;
  2069. /* Get item from list */
  2070. *item = *(lifo->position);
  2071. }
  2073. KB_OSPSemSet(semCritical);
  2075. return status;
  2076. }
  2079. INT32 KB_SIGetPat(const KB_SIPatStruct* i_pstPat, INT32 nType, INT32 i_nVersionNumber)
  2080. {
  2081. KB_OSPMsgNode message;
  2082.     
  2084. memset(l_pstPendingPatPara, 0, sizeof(PATINFO));
  2085. l_pstPendingPatPara->handle = l_nHandle++;
  2086. l_pstPendingPatPara->pstPat = (KB_SIPatStruct*)i_pstPat;
  2087. l_pstPendingPatPara->nType = (UINT8)nType;
  2088. if(nType == KB_SI_RECEIVE_CHANGE)
  2089. l_pstPendingPatPara->nVersionNumber = (INT8)i_nVersionNumber;
  2090. else
  2091. l_pstPendingPatPara->nVersionNumber = -1;
  2093. memset(&message, 0, sizeof(KB_OSPMsgNode));
  2094. message.Word1 = MSG_SI_PAT_RECEIVE;
  2096. if(KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message) != Ret_OK)
  2097. {
  2098. return KB_SI_ERR_SEND_MESSAGE;
  2099. }
  2100. return 0;
  2101. }
  2103. INT32 KB_SIStopPat()
  2104. {
  2105. //KB_OSPMsgNode message;
  2108.     SIStopPAT();
  2109.     
  2110. return 0;
  2111. }
  2113. INT32 KB_SIGetNit(UINT32 i_nNitPid, const KB_SINitStruct* i_pstNit, INT32 nType, INT32 i_nVersionNumber)
  2114. {
  2115. KB_OSPMsgNode message;
  2118. memset(l_pstPendingNitPara, 0, sizeof(NITINFO));
  2119. l_pstPendingNitPara->handle = l_nHandle++;
  2120. l_pstPendingNitPara->nNitPid = (UINT16)i_nNitPid;
  2121. l_pstPendingNitPara->pstNit = (KB_SINitStruct*)i_pstNit;
  2122. l_pstPendingNitPara->nType = (UINT8)nType;
  2123. if(nType == KB_SI_RECEIVE_CHANGE)
  2124. l_pstPendingNitPara->nVersionNumber = (INT8)i_nVersionNumber;
  2125. else
  2126. l_pstPendingNitPara->nVersionNumber = -1;
  2128. memset(&message, 0, sizeof(KB_OSPMsgNode));
  2129. message.Word1 = MSG_SI_NIT_RECEIVE;
  2131. if(KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message) != Ret_OK)
  2132. {
  2133. return KB_SI_ERR_SEND_MESSAGE;
  2134. }
  2135. return 0;
  2136. }
  2138. INT32 KB_SIStopNit()
  2139. {
  2140. KB_OSPMsgNode message;
  2142. memset(&message, 0, sizeof(KB_OSPMsgNode));
  2143. message.Word1 = MSG_SI_NIT_STOP_RECEIVE;
  2145. if(KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message) != Ret_OK)
  2146. {
  2147. return KB_SI_ERR_SEND_MESSAGE;
  2148. }
  2149. return 0;
  2150. }
  2152. INT32 KB_SIGetPmt(INT32 i_nProgramMapPid, INT32 nSvcID, const KB_SIPmtStruct* i_pstPmt, INT32 nType, INT32 i_nVersionNumber)
  2153. {
  2154. KB_OSPMsgNode message;
  2155. int i;
  2157. for(i = 0; i < SI_NO_PMT_TABLES_QUEUE; i++)
  2158. {
  2159. if(l_pstPendingPmtPara[i]->nUsedFlag == 0)
  2160. {
  2161. memset(l_pstPendingPmtPara[i], 0, sizeof(PMTINFO));
  2162. l_pstPendingPmtPara[i]->nUsedFlag = 1;
  2163. l_pstPendingPmtPara[i]->handle = l_nHandle++;
  2164. l_pstPendingPmtPara[i]->nProgramMapPid = (UINT16)i_nProgramMapPid;
  2165. l_pstPendingPmtPara[i]->nSvcNO = (UINT16)nSvcID;
  2166. l_pstPendingPmtPara[i]->pstPmt = (KB_SIPmtStruct*)i_pstPmt;
  2167. l_pstPendingPmtPara[i]->nType = (UINT8)nType;
  2168. if(nType == KB_SI_RECEIVE_CHANGE)
  2169. l_pstPendingPmtPara[i]->nVersionNumber = (INT8)i_nVersionNumber;
  2170. else
  2171. l_pstPendingPmtPara[i]->nVersionNumber = -1;
  2173. memset(&message, 0, sizeof(KB_OSPMsgNode));
  2174. message.Word1 = MSG_SI_PMT_RECEIVE;
  2175. message.Word2 = i;
  2177. if(KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message) != Ret_OK)
  2178. {
  2179. memset(l_pstPendingPmtPara[i], 0, sizeof(PMTINFO));
  2180. return KB_SI_ERR_SEND_MESSAGE;
  2181. }
  2182. break;
  2183. }
  2184. }
  2185. if(i == SI_NO_PMT_TABLES_QUEUE)
  2186. {
  2187. return KB_SI_ERR_TOO_MANY_PROGRAMS;
  2188. }
  2190. return 0;
  2191. }
  2193. INT32 KB_SIStopPmt(INT32 nSvcID)
  2194. {
  2195. //KB_OSPMsgNode message;
  2197.     SIStopPmt(nSvcID);
  2198. return 0;
  2199. }
  2201. INT32 KB_SIGetSdt(INT32 nSvcID, INT32 i_nMaxServiceNum, const KB_SISdtStruct* i_pstSdt, INT32 nType, INT32 i_nVersionNumber)
  2202. {
  2203. KB_OSPMsgNode message;
  2205. memset(l_pstPendingSdtPara, 0, sizeof(SDTINFO));
  2206. l_pstPendingSdtPara->handle = l_nHandle++;
  2207. l_pstPendingSdtPara->nSvcID = nSvcID;
  2208. l_pstPendingSdtPara->nMaxServiceNum = (INT16)i_nMaxServiceNum;
  2209. l_pstPendingSdtPara->pstSdt = (KB_SISdtStruct*)i_pstSdt;
  2210. l_pstPendingSdtPara->nType = (UINT8)nType;
  2211. if(nType & KB_SI_RECEIVE_CHANGE)
  2212. l_pstPendingSdtPara->nVersionNumber = (INT8)i_nVersionNumber;
  2213. else
  2214. l_pstPendingSdtPara->nVersionNumber = -1;
  2216. memset(&message, 0, sizeof(KB_OSPMsgNode));
  2217. message.Word1 = MSG_SI_SDT_RECEIVE;
  2219. if(KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message) != Ret_OK)
  2220. {
  2221. return KB_SI_ERR_SEND_MESSAGE;
  2222. }
  2223. return 0;
  2224. }
  2226. INT32 KB_SIStopSdt()
  2227. {
  2228. KB_OSPMsgNode message;
  2230. memset(&message, 0, sizeof(KB_OSPMsgNode));
  2231. message.Word1 = MSG_SI_SDT_STOP_RECEIVE;
  2233. if(KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message) != Ret_OK)
  2234. {
  2235. return KB_SI_ERR_SEND_MESSAGE;
  2236. }
  2237. return 0;
  2238. }
  2240. INT32 KB_SIGetBat(INT32 nbatID, const KB_SIBatStruct* i_pstBat, INT32 nType, INT32 i_nVersionNumber)
  2241. {
  2242. KB_OSPMsgNode message;
  2244. memset(l_pstPendingBatPara, 0, sizeof(BATINFO));
  2245. l_pstPendingBatPara->handle = l_nHandle++;
  2246. l_pstPendingBatPara->nBouquetId = nbatID;
  2247. l_pstPendingBatPara->pstBat = (KB_SIBatStruct*)i_pstBat;
  2248. l_pstPendingBatPara->nType = (UINT8)nType;
  2249. if(nType & KB_SI_RECEIVE_CHANGE)
  2250. l_pstPendingBatPara->nVersionNumber = (INT8)i_nVersionNumber;
  2251. else
  2252. l_pstPendingBatPara->nVersionNumber = -1;
  2254. memset(&message, 0, sizeof(KB_OSPMsgNode));
  2255. message.Word1 = MSG_SI_BAT_RECEIVE;
  2257. if(KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message) != Ret_OK)
  2258. {
  2259. return KB_SI_ERR_SEND_MESSAGE;
  2260. }
  2261. return 0;
  2262. }
  2264. INT32 KB_SIStopBat()
  2265. {
  2266. KB_OSPMsgNode message;
  2268. memset(&message, 0, sizeof(KB_OSPMsgNode));
  2269. message.Word1 = MSG_SI_BAT_STOP_RECEIVE;
  2271. if(KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message) != Ret_OK)
  2272. {
  2273. return KB_SI_ERR_SEND_MESSAGE;
  2274. }
  2275. return 0;
  2276. }
  2278. INT32 KB_SIGetEitPF(INT32 nSvcID, KB_SIEitTs eTs, const KB_SIEitPF* i_pstEitPresent, const KB_SIEitPF* i_pstEitFollow, INT32 nType, INT32 i_nVersionNumber)
  2279. {
  2280. KB_OSPMsgNode message;
  2282. int i;
  2283.     INT32 nTableId;
  2285.     nTableId = 0;
  2286.     switch (eTs)
  2287.     {
  2288.     case KB_SI_EIT_CURRENT_TS:
  2289.         nTableId = 0x4e;
  2290.         break;
  2292.     case KB_SI_EIT_OTHER_TS:
  2293.         nTableId = 0x4f;
  2294.         break;
  2295.         
  2296.     default:
  2297.         break;
  2298.     }
  2299. for(i = 0; i < SI_NO_EIT_PF_TABLES_QUEUE; i++)
  2300. {
  2301. if(l_pstPendingEitPFPara[i]->nUsedFlag == 0)
  2302. {
  2303. memset(l_pstPendingEitPFPara[i], 0, sizeof(EITPFINFO));
  2304. l_pstPendingEitPFPara[i]->nUsedFlag = 1;
  2305. l_pstPendingEitPFPara[i]->handle = l_nHandle++;
  2306. l_pstPendingEitPFPara[i]->nSvcID = (UINT16)nSvcID;
  2307. l_pstPendingEitPFPara[i]->pstEitPresent = (KB_SIEitPF*)i_pstEitPresent;
  2308. l_pstPendingEitPFPara[i]->pstEitFollow = (KB_SIEitPF*)i_pstEitFollow;
  2309. l_pstPendingEitPFPara[i]->nType = (UINT8)nType;
  2310.             l_pstPendingEitPFPara[i]->nTableId = (INT16)nTableId;
  2311. if(nType == KB_SI_RECEIVE_CHANGE)
  2312. l_pstPendingEitPFPara[i]->nVersionNumber = (INT8)i_nVersionNumber;
  2313. else
  2314. l_pstPendingEitPFPara[i]->nVersionNumber = -1;
  2316. memset(&message, 0, sizeof(KB_OSPMsgNode));
  2317. message.Word1 = MSG_SI_EIT_PF_RECEIVE;
  2318. message.Word2 = i;
  2320. if(KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message) != Ret_OK)
  2321. {
  2322. memset(l_pstPendingEitPFPara[i], 0, sizeof(EITPFINFO));
  2323. return KB_SI_ERR_SEND_MESSAGE;
  2324. }
  2325. break;
  2326. }
  2327. }
  2328. if(i == SI_NO_EIT_PF_TABLES_QUEUE)
  2329. {
  2330. return KB_SI_ERR_TOO_MANY_PROGRAMS;
  2331. }
  2333. return 0;
  2334. }
  2337. INT32 KB_SIStopEitPF(INT32 nSvcID, KB_SIEitTs eTs)
  2338. {
  2339. INT32 i, nTableId = 0;
  2340.     
  2341.     switch (eTs)
  2342.     {
  2343.     case KB_SI_EIT_CURRENT_TS:
  2344.         nTableId = 0x4e;
  2345.         break;
  2347.     case KB_SI_EIT_OTHER_TS:
  2348.         nTableId = 0x4f;
  2349.         break;
  2350.         
  2351.     default:
  2352.         break;
  2353.     }
  2355. if(nSvcID == -1)
  2356. {
  2357. for(i = 0; i < SI_NO_EIT_PF_FILTERS; i++)
  2358. {
  2359. SIFilterStop(SISubTable[EITSubTableID].details.channelID, &(SISubTable[EITSubTableID].filter[KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT + i]));
  2360.             SISubTable[EITSubTableID].filter[KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT + i].used = FALSE;
  2361. memset(l_pstCurrEitPFPara[i], 0, sizeof(EITPFINFO));
  2362. }
  2363. }
  2364. else
  2365. {
  2366. for(i = 0; i < SI_NO_EIT_PF_FILTERS; i++)
  2367. {
  2368. if(l_pstCurrEitPFPara[i]->nUsedFlag == 1 &&
  2369.    l_pstCurrEitPFPara[i]->nSvcID == nSvcID
  2370.    && l_pstCurrEitPFPara[i]->nTableId == nTableId)
  2371. { 
  2372. memset(l_pstCurrEitPFPara[i], 0, sizeof(EITPFINFO));
  2373. break;
  2374. }
  2375. }
  2377. for(i = 0; i < SI_NO_EIT_PF_FILTERS; i++)
  2378. {
  2379. if(SISubTable[EITSubTableID].filter[KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT + i].enabled == TRUE &&
  2380.    SISubTable[EITSubTableID].filter[KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT + i].tableIDExt == nSvcID)
  2381. {
  2382. SIFilterStop(SISubTable[EITSubTableID].details.channelID, &(SISubTable[EITSubTableID].filter[KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT + i]));
  2383.                 SISubTable[EITSubTableID].filter[KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT + i].used = FALSE;
  2384. break;
  2385. }
  2386. }
  2387. }
  2389. return 0;
  2390. }
  2392. INT32 KB_SIGetEitSCH(INT32 nSvcID, const KB_SIEitSch* i_pstEinSchInfo)
  2393. {
  2394. KB_OSPMsgNode message;
  2395.     int i;
  2397.     for (i = 0; i < KB_SI_EIT_SCHEDULE_SERVICE_COUNT; i++)
  2398.     {
  2399.         if (l_pstPendingEinSchInfoPara[i]->nUsedFlag == 0)
  2400.         {
  2401.             memset(l_pstPendingEinSchInfoPara[i], 0, sizeof(EITSCHINFO));
  2402.             l_pstPendingEinSchInfoPara[i]->nUsedFlag = 1;
  2403.          l_pstPendingEinSchInfoPara[i]->handle = l_nHandle++;
  2404.          l_pstPendingEinSchInfoPara[i]->nSvcID = nSvcID;
  2405.         l_pstPendingEinSchInfoPara[i]->pstEinSchInfo = (KB_SIEitSch*)i_pstEinSchInfo;
  2407.             memset(&message, 0, sizeof(KB_OSPMsgNode));
  2408.         message.Word1 = MSG_SI_EIT_SCHEDULE_RECEIVE;
  2409.             message.Word2 = i;
  2410.             break;
  2411.         }
  2412.     }
  2413.     
  2414.     if(i >= KB_SI_EIT_SCHEDULE_SERVICE_COUNT)
  2415. {
  2416. return KB_SI_ERR_TOO_MANY_PROGRAMS;
  2417. }
  2419. if(KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message) != Ret_OK)
  2420. {
  2421. return KB_SI_ERR_SEND_MESSAGE;
  2422. }
  2423. return 0;
  2424. }
  2426. INT32 KB_SIStopEitSCH(INT32 nSvcID)
  2427. {
  2428.     int i;
  2429.     
  2430.     if (nSvcID == KB_SI_STOP_ALL)
  2431.     {                
  2432.         for (i = 0; i < KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT; i++)
  2433.         {            
  2434.             SIFilterStop(SISubTable[EITSubTableID].details.channelID, &(SISubTable[EITSubTableID].filter[i]));        
  2435.             SISubTable[EITSubTableID].filter[i].used = FALSE;
  2436.         }
  2438.         for (i = 0; i < KB_SI_EIT_SCHEDULE_SERVICE_COUNT; i++)
  2439.         {
  2440.             memset(l_pstCurrEinSchInfoPara[i], 0, sizeof(EITSCHINFO));
  2441.         }
  2442.     }
  2443.     else
  2444.     {
  2445.         for (i = 0; i < KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT; i++)
  2446.         {            
  2447.             if (SISubTable[EITSubTableID].filter[i].tableIDExt == nSvcID)
  2448.             {
  2449.                 /* 注意:schedule中可能用到两个fileter，所以不能用break */
  2450.                 SIFilterStop(SISubTable[EITSubTableID].details.channelID, &(SISubTable[EITSubTableID].filter[i]));         
  2451.                 SISubTable[EITSubTableID].filter[i].used = FALSE;
  2452.             }
  2453.         }
  2454.         
  2455.         for (i = 0; i < KB_SI_EIT_SCHEDULE_SERVICE_COUNT; i++)
  2456.         {
  2457.             if (l_pstCurrEinSchInfoPara[i]->nUsedFlag == 1
  2458.                 && l_pstCurrEinSchInfoPara[i]->nSvcID == nSvcID)
  2459.             {
  2460.                 memset(l_pstCurrEinSchInfoPara[i], 0, sizeof(EITSCHINFO));
  2461.                 break;
  2462.             }
  2463.         }
  2464.     }
  2465.     
  2466. return 0;
  2467. }
  2469. INT32 KB_SIGetTime(time_t* pTimeNode)
  2470. {
  2471. KB_OSPMsgNode message;
  2474. SIStopTOT();
  2476. memset(l_pstPendingTdtPara, 0, sizeof(TDTINFO));
  2477. l_pstPendingTdtPara->handle = l_nHandle++;
  2478. l_pstPendingTdtPara->ptCurrentTime = (time_t*)pTimeNode;
  2480. memset(&message, 0, sizeof(KB_OSPMsgNode));
  2481. message.Word1 = MSG_SI_TDT_RECEIVE;
  2483. if(KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message) != Ret_OK)
  2484. {
  2485. return KB_SI_ERR_SEND_MESSAGE;
  2486. }
  2487. return 0;
  2488. }
  2490. INT32 KB_SIStopTDT()
  2491. {
  2492. KB_OSPMsgNode message;
  2495. memset(&message, 0, sizeof(KB_OSPMsgNode));
  2496. message.Word1 = MSG_SI_TDT_STOP_RECEIVE;
  2498. if(KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message) != Ret_OK)
  2499. {
  2500. return KB_SI_ERR_SEND_MESSAGE;
  2501. }
  2502. return 0;
  2503. }
  2505. INT32 KB_SIStopTOT()
  2506. {
  2507. KB_OSPMsgNode message;
  2510. memset(&message, 0, sizeof(KB_OSPMsgNode));
  2511. message.Word1 = MSG_SI_TOT_STOP_RECEIVE;
  2513. if(KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message) != Ret_OK)
  2514. {
  2515. return KB_SI_ERR_SEND_MESSAGE;
  2516. }
  2517. return 0;
  2518. }
  2520. INT32 KB_SIGetTOT(KB_SITot* pTot)
  2521. {
  2522. return 0;
  2523. }
  2524. INT32 KB_SIGetCat(const KB_SICatStruct* pCatNode, INT32 nType, INT32 i_nVersionNumber)
  2525. {
  2526. KB_OSPMsgNode message;
  2528. memset(l_pstPendingCatPara, 0, sizeof(CATINFO));
  2529. l_pstPendingCatPara->handle = l_nHandle++;
  2530. l_pstPendingCatPara->pstCat = (KB_SICatStruct*)pCatNode;
  2531. l_pstPendingCatPara->nType = (UINT8)nType;
  2532. if(nType & KB_SI_RECEIVE_CHANGE)
  2533. l_pstPendingCatPara->nVersionNumber = (INT8)i_nVersionNumber;
  2534. else
  2535. l_pstPendingCatPara->nVersionNumber = -1;
  2537. memset(&message, 0, sizeof(KB_OSPMsgNode));
  2538. message.Word1 = MSG_SI_CAT_RECEIVE;
  2540. if(KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message) != Ret_OK)
  2541. {
  2542. return KB_SI_ERR_SEND_MESSAGE;
  2543. }
  2544. return 0;
  2545. }
  2547. INT32 KB_SIStopCat()
  2548. {
  2549. //KB_OSPMsgNode message;
  2552.     SIStopCAT();
  2553.     
  2554. return 0;
  2555. }
  2557. INT32 KB_SIGetRst(INT32 nMaxEvent, const KB_SIRstStruct* i_pstRst)
  2558. {
  2559. KB_OSPMsgNode message;
  2562. memset(l_pstPendingRstPara, 0, sizeof(RSTINFO));
  2563. l_pstPendingRstPara->handle = l_nHandle++;
  2564. l_pstPendingRstPara->nMaxEventStatusNum = (INT16)nMaxEvent;
  2565. l_pstPendingRstPara->pstRst = (KB_SIRstStruct*)i_pstRst;
  2567. memset(&message, 0, sizeof(KB_OSPMsgNode));
  2568. message.Word1 = MSG_SI_RST_RECEIVE;
  2570. if(KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message) != Ret_OK)
  2571. {
  2572. return KB_SI_ERR_SEND_MESSAGE;
  2573. }
  2574. return 0;
  2575. }
  2577. INT32 KB_SIStopRst()
  2578. {
  2579. KB_OSPMsgNode message;
  2582. memset(&message, 0, sizeof(KB_OSPMsgNode));
  2583. message.Word1 = MSG_SI_RST_STOP_RECEIVE;
  2585. if(KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message) != Ret_OK)
  2586. {
  2587. return KB_SI_ERR_SEND_MESSAGE;
  2588. }
  2589. return 0;
  2590. }
  2592. static INT32 SIGetPAT()
  2593. {
  2595. memcpy(l_pstCurrPatPara, l_pstPendingPatPara, sizeof(PATINFO));
  2596. l_pstCurrPatPara->nCurrVersionNumber = -1;
  2597. l_pstCurrPatPara->nUsedFlag = 1;
  2598. SISubTableStart(PATSubTableID, 0, l_pstCurrPatPara->nVersionNumber, l_pstCurrPatPara->handle);
  2600. return 0;
  2601. }
  2603. static INT32 SIStopPAT()
  2604. {
  2606. SISubTableStop(PATSubTableID);
  2607. memset(l_pstCurrPatPara, 0, sizeof(PATINFO));
  2610. return 0;
  2611. }
  2613. INT32 SIGetNIT()
  2614. {
  2616. memcpy(l_pstCurrNitPara, l_pstPendingNitPara, sizeof(NITINFO));
  2617. l_pstCurrNitPara->nCurrVersionNumber = -1;
  2618. l_pstCurrNitPara->nUsedFlag = 1;
  2619. SISubTableStart(NITSubTableID, 0, l_pstCurrNitPara->nVersionNumber, l_pstCurrNitPara->handle);
  2622. return 0;
  2623. }
  2625. static INT32 SIStopNIT()
  2626. {
  2628. SISubTableStop(NITSubTableID);
  2629. memset(l_pstCurrNitPara, 0, sizeof(NITINFO));
  2631. return 0;
  2632. }
  2634. static INT32 SIGetPmt(INT32 nPendingNo)
  2635. {
  2636. KB_OSPMsgNode message;
  2638. UINT32 i, j;
  2639. INT8 done;
  2640. INT32 nTempProgramNumber;
  2641. INT32 nCurrNo = 0;
  2642. INT32 nTempEnabled;
  2645. if(l_pstPendingPmtPara[nPendingNo]->nType == KB_SI_RECEIVE_CHANGE)
  2646. {
  2647. nTempProgramNumber = -1;
  2648. for(i = 0; i < SI_NO_PMT_TABLES; i++)
  2649. {
  2650. if(l_pstCurrPmtPara[i]->nUsedFlag == 1 &&
  2651.    l_pstCurrPmtPara[i]->nType == KB_SI_RECEIVE_CHANGE)
  2652. {
  2653. nTempProgramNumber = l_pstCurrPmtPara[i]->nSvcNO;
  2654. memset(l_pstCurrPmtPara[i], 0, sizeof(PMTINFO));
  2655. break;
  2656. }
  2657. }
  2658. if(i < SI_NO_PMT_TABLES)
  2659. {
  2660. done = 0;
  2661. for(i = 0; i < SI_NO_PMT_TABLES; i++)
  2662. {
  2663. for(j = 0; j < SISubTable[PMTSubTableID[i]].details.noFilters; j++)
  2664. {
  2665. if(SISubTable[PMTSubTableID[i]].filter[j].enabled == TRUE &&
  2666.    SISubTable[PMTSubTableID[i]].filter[j].tableIDExt == nTempProgramNumber)
  2667. {
  2668. SIFilterStop(SISubTable[PMTSubTableID[i]].details.channelID, &(SISubTable[PMTSubTableID[i]].filter[j]));
  2669. done = 1;
  2670. break;
  2671. }
  2672. }
  2673. if(done)
  2674. break;
  2675. }
  2676. }
  2677. }
  2679. done = 0;
  2680. nTempProgramNumber = l_pstPendingPmtPara[nPendingNo]->nSvcNO;
  2681. for(i = 0; i < SI_NO_PMT_TABLES; i++)
  2682. {
  2683. if(l_pstCurrPmtPara[i]->nUsedFlag == 1 &&
  2684.    l_pstCurrPmtPara[i]->nSvcNO == nTempProgramNumber)
  2685. {
  2686. memset(l_pstCurrPmtPara[i], 0, sizeof(PMTINFO));
  2687. break;
  2688. }
  2689. }
  2691. if(i < SI_NO_PMT_TABLES)
  2692. {
  2693. for(i = 0; i < SI_NO_PMT_TABLES; i++)
  2694. {
  2695. for(j = 0; j < SISubTable[PMTSubTableID[i]].details.noFilters; j++)
  2696. {
  2697. if(SISubTable[PMTSubTableID[i]].filter[j].enabled == TRUE &&
  2698.    SISubTable[PMTSubTableID[i]].filter[j].tableIDExt == nTempProgramNumber)
  2699. {
  2700. SIFilterStop(SISubTable[PMTSubTableID[i]].details.channelID, &(SISubTable[PMTSubTableID[i]].filter[j]));
  2701. done = 1;
  2702. break;
  2703. }
  2704. }
  2705. if(done)
  2706. break;
  2707. }
  2708. }
  2710. for(i = 0; i < SI_NO_PMT_TABLES; i++)
  2711. {
  2712. if(l_pstCurrPmtPara[i]->nUsedFlag == 0)
  2713. {
  2714. break;
  2715. }
  2716. }
  2717. if(i == SI_NO_PMT_TABLES)
  2718. {
  2719. memset(&message, 0, sizeof(KB_OSPMsgNode));
  2720. message.Word1 = MSG_SI_PMT_RECEIVE;
  2721. message.Word2 = nPendingNo;
  2723. if(KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message) != Ret_OK)
  2724. {
  2725. memset(l_pstPendingPmtPara[nPendingNo], 0, sizeof(PMTINFO));
  2726. return KB_SI_ERR_SEND_MESSAGE;
  2727. }
  2728. return 0;
  2729. }
  2731. done = 0;
  2732. for(i = 0; i < SI_NO_PMT_TABLES; i++)
  2733. {
  2734. for(j = 0; j < SISubTable[PMTSubTableID[i]].details.noFilters; j++)
  2735. {
  2736. if(SISubTable[PMTSubTableID[i]].filter[j].enabled == TRUE &&
  2737.    SISubTable[PMTSubTableID[i]].details.PID == l_pstPendingPmtPara[nPendingNo]->nProgramMapPid)
  2738. {
  2739. if(i > 0)
  2740. {
  2741. memset(&message, 0, sizeof(KB_OSPMsgNode));
  2742. message.Word1 = MSG_SI_PMT_RECEIVE;
  2743. message.Word2 = nPendingNo;
  2745. if(KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message) != Ret_OK)
  2746. {
  2747. memset(l_pstPendingPmtPara[nPendingNo], 0, sizeof(PMTINFO));
  2748. return KB_SI_ERR_SEND_MESSAGE;
  2749. }
  2750. return 0;
  2751. }
  2752. done = 1;
  2753. break;
  2754. }
  2755. }
  2756. if(done == 1)
  2757. break;
  2758. }
  2760. for(i = 0; i < SI_NO_PMT_TABLES; i++)
  2761. {
  2762. if(l_pstCurrPmtPara[i]->nUsedFlag == 0)
  2763. {
  2764. memcpy(l_pstCurrPmtPara[i], l_pstPendingPmtPara[nPendingNo], sizeof(PMTINFO));
  2765. memset(l_pstPendingPmtPara[nPendingNo], 0, sizeof(PMTINFO));
  2766. l_pstCurrPmtPara[i]->nCurrVersionNumber = -1;
  2767. l_pstCurrPmtPara[i]->nUsedFlag = 1;
  2768. nCurrNo = i;
  2769. break;
  2770. }
  2771. }
  2773. nTempEnabled = FALSE;
  2774. for(j = 0; j < SISubTable[PMTSubTableID[0]].details.noFilters; j++)
  2775. {
  2776. if(SISubTable[PMTSubTableID[0]].filter[j].enabled == TRUE)
  2777. {
  2778. nTempEnabled = TRUE;
  2779. break;
  2780. }
  2781. }
  2783. if(nTempEnabled == TRUE &&
  2784.    SISubTable[PMTSubTableID[0]].details.PID == l_pstCurrPmtPara[nCurrNo]->nProgramMapPid)
  2785. {
  2786. for(j = 0; j < SISubTable[PMTSubTableID[0]].details.noFilters; j++)
  2787. {
  2788. if(SISubTable[PMTSubTableID[0]].filter[j].enabled == FALSE)
  2789. {
  2790. SISubTable[PMTSubTableID[0]].details.tableIDExt = l_pstCurrPmtPara[nCurrNo]->nSvcNO;
  2791. SISubTable[PMTSubTableID[0]].details.PID = l_pstCurrPmtPara[nCurrNo]->nProgramMapPid;
  2792. SISubTableStart(PMTSubTableID[0], j, l_pstCurrPmtPara[nCurrNo]->nVersionNumber, l_pstCurrPmtPara[nCurrNo]->handle);
  2793. break;
  2794. }
  2795. }
  2796. }
  2797. else
  2798. {
  2799. INT32 nStart = 0;
  2800. if(nTempEnabled == TRUE)
  2801. {
  2802. nStart = 1;
  2803. }
  2804. for(i = nStart; i < SI_NO_PMT_TABLES; i++)
  2805. {
  2806. if(SISubTable[PMTSubTableID[i]].filter[0].enabled == FALSE)
  2807. {
  2808. /* Start the PMT filtering. */
  2809. SISubTable[PMTSubTableID[i]].details.tableIDExt = l_pstCurrPmtPara[nCurrNo]->nSvcNO;
  2810. SISubTable[PMTSubTableID[i]].details.PID = l_pstCurrPmtPara[nCurrNo]->nProgramMapPid;
  2811. SISubTableStart(PMTSubTableID[i], 0, l_pstCurrPmtPara[nCurrNo]->nVersionNumber, l_pstCurrPmtPara[nCurrNo]->handle);
  2812. break;
  2813. }
  2814. }
  2815. }
  2817. return 0;
  2818. }
  2820. static INT32 SIStopPmt(INT32 nSvcID)
  2821. {
  2822. UINT32 i, j;
  2823. INT8 done = 0;
  2825. if(nSvcID == -1)
  2826. {
  2827. for(i = 0; i < SI_NO_PMT_TABLES; i++)
  2828. {
  2829. SISubTableStop(PMTSubTableID[i]);
  2830. memset(l_pstCurrPmtPara[i], 0, sizeof(PMTINFO));
  2831. }
  2832. }
  2833. else
  2834. {
  2835. for(i = 0; i < SI_NO_PMT_TABLES; i++)
  2836. {
  2837. if(l_pstCurrPmtPara[i]->nUsedFlag == 1 &&
  2838.    l_pstCurrPmtPara[i]->nSvcNO == nSvcID)
  2839. { 
  2840. memset(l_pstCurrPmtPara[i], 0, sizeof(PMTINFO));
  2841. break;
  2842. }
  2843. }
  2845. for(i = 0; i < SI_NO_PMT_TABLES; i++)
  2846. {
  2847. for(j = 0; j < SISubTable[PMTSubTableID[i]].details.noFilters; j++)
  2848. {
  2849. if(SISubTable[PMTSubTableID[i]].filter[j].enabled == TRUE &&
  2850.    SISubTable[PMTSubTableID[i]].filter[j].tableIDExt == nSvcID)
  2851. {
  2852. SIFilterStop(SISubTable[PMTSubTableID[i]].details.channelID, &(SISubTable[PMTSubTableID[i]].filter[j]));
  2853. done = 1;
  2854. break;
  2855. }
  2856. }
  2857. if(done)
  2858. break;
  2859. }
  2860. }
  2862. return 0;
  2863. }
  2865. static INT32 SIGetSDT()
  2866. {
  2867. memcpy(l_pstCurrSdtPara, l_pstPendingSdtPara, sizeof(SDTINFO));
  2868. l_pstCurrSdtPara->nCurrVersionNumber = -1;
  2869. l_pstCurrSdtPara->nUsedFlag = 1;
  2870. SISubTable[SDTSubTableID].details.tableID = 0x42;
  2871. SISubTable[SDTSubTableID].details.tableIDExt = -1;
  2872. SISubTableStart(SDTSubTableID, 0, l_pstCurrSdtPara->nVersionNumber, l_pstCurrSdtPara->handle);
  2874. return 0;
  2875. }
  2877. static INT32 SIStopSdt()
  2878. {
  2879. SIFilterStop(SISubTable[SDTSubTableID].details.channelID, &(SISubTable[SDTSubTableID].filter[0]));
  2880. memset(l_pstCurrSdtPara, 0, sizeof(SDTINFO));
  2882. return 0;
  2883. }
  2885. static INT32 SIGetBat()
  2886. {
  2888. memcpy(l_pstCurrBatPara, l_pstPendingBatPara, sizeof(BATINFO));
  2889. l_pstCurrBatPara->nCurrVersionNumber = -1;
  2890. l_pstCurrBatPara->nUsedFlag = 1;
  2891. SISubTable[SDTSubTableID].details.tableID = 0x4A;
  2892. SISubTable[SDTSubTableID].details.tableIDExt = l_pstCurrBatPara->nBouquetId;
  2893. SISubTableStart(SDTSubTableID, 1, l_pstCurrBatPara->nVersionNumber, l_pstCurrBatPara->handle);
  2895. return 0;
  2896. }
  2898. static INT32 SIStopBat()
  2899. {
  2900. SIFilterStop(SISubTable[SDTSubTableID].details.channelID, &(SISubTable[SDTSubTableID].filter[1]));
  2901. memset(l_pstCurrBatPara, 0, sizeof(BATINFO));
  2903. return 0;
  2904. }
  2906. static INT32 SIGetEitPF(INT32 nPendingNo)
  2907. {
  2908. KB_OSPMsgNode message;
  2910. INT32 i;
  2911. INT32 nTempServiceId = 0;
  2912. INT32 nCurrNo = 0;
  2914. if(l_pstPendingEitPFPara[nPendingNo]->nType == KB_SI_RECEIVE_CHANGE)
  2915. {
  2916. for(i = 0; i < SI_NO_EIT_PF_FILTERS; i++)
  2917. {
  2918. if(l_pstCurrEitPFPara[i]->nUsedFlag == 1 &&
  2919.    l_pstCurrEitPFPara[i]->nType == KB_SI_RECEIVE_CHANGE)
  2920. {
  2921. nTempServiceId = l_pstCurrEitPFPara[i]->nSvcID;
  2922. memset(l_pstCurrEitPFPara[i], 0, sizeof(EITPFINFO));
  2923. break;
  2924. }
  2925. }
  2926. if(i < SI_NO_EIT_PF_FILTERS)
  2927. {
  2928. for(i = KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT; i < SI_NO_EIT_PF_FILTERS + KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT; i++)
  2929. {
  2930. if(SISubTable[EITSubTableID].filter[i].enabled == TRUE &&
  2931.                    SISubTable[EITSubTableID].filter[i].tableIDExt == nTempServiceId
  2932.                    && SISubTable[EITSubTableID].filter[i].tableID == l_pstPendingEitPFPara[nPendingNo]->nTableId)
  2933. {
  2934. SIFilterStop(SISubTable[EITSubTableID].details.channelID, &(SISubTable[EITSubTableID].filter[i]));
  2935. break;
  2936. }
  2937. }
  2938. }
  2939. }
  2941. nTempServiceId = l_pstPendingEitPFPara[nPendingNo]->nSvcID;
  2943. for(i = 0; i < SI_NO_EIT_PF_FILTERS; i++)
  2944. {
  2945. if(l_pstCurrEitPFPara[i]->nUsedFlag == 1 &&
  2946.    l_pstCurrEitPFPara[i]->nSvcID == nTempServiceId)
  2947. {
  2948. memset(l_pstCurrEitPFPara[i], 0, sizeof(EITPFINFO));
  2949. break;
  2950. }
  2951. }
  2954. for(i = 0; i < SI_NO_EIT_PF_FILTERS; i++)
  2955. {
  2956. if(l_pstCurrEitPFPara[i]->nUsedFlag == 0)
  2957. {
  2958. memcpy(l_pstCurrEitPFPara[i], l_pstPendingEitPFPara[nPendingNo], sizeof(EITPFINFO));
  2959. memset(l_pstPendingEitPFPara[nPendingNo], 0, sizeof(EITPFINFO));
  2961. l_pstCurrEitPFPara[i]->nCurrVersionNumber = -1;
  2962. l_pstCurrEitPFPara[i]->nUsedFlag = 1;
  2963. nCurrNo = i;
  2964. break;
  2965. }
  2966. }
  2968. if(i == SI_NO_EIT_PF_FILTERS)//无可用空间
  2969. {
  2970. memset(&message, 0, sizeof(KB_OSPMsgNode));
  2971. message.Word1 = MSG_SI_EIT_PF_RECEIVE;
  2972. message.Word2 = nPendingNo;
  2974. if(KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message) != Ret_OK)
  2975. {
  2976. memset(l_pstPendingEitPFPara[nPendingNo], 0, sizeof(EITPFINFO));
  2977. return KB_SI_ERR_SEND_MESSAGE;
  2978. }
  2979. return 0;
  2980. }
  2982. for(i = KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT; i < SI_NO_EIT_PF_FILTERS + KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT; i++)
  2983. {        
  2984. if(SISubTable[EITSubTableID].filter[i].used == FALSE)
  2985. {
  2986. SISubTable[EITSubTableID].details.tableID = l_pstCurrEitPFPara[nCurrNo]->nTableId;
  2987. SISubTable[EITSubTableID].details.timeout = J_SI_EIT_PF_TIMEOUT;
  2988. SISubTable[EITSubTableID].details.tableIDExt = l_pstCurrEitPFPara[nCurrNo]->nSvcID;     
  2989. SISubTableStart(EITSubTableID, i, l_pstCurrEitPFPara[nCurrNo]->nVersionNumber, l_pstCurrEitPFPara[nCurrNo]->handle);
  2990. break;
  2991. }
  2992. }
  2994. return 0;
  2995. }
  2997. static INT32 SIStopEitPF(INT32 nSvcID, INT32 nTableId)
  2998. {
  2999. INT32 i;
  3001. if(nSvcID == -1)
  3002. {
  3003. for(i = 0; i < SI_NO_EIT_PF_FILTERS; i++)
  3004. {
  3005. SIFilterStop(SISubTable[EITSubTableID].details.channelID, &(SISubTable[EITSubTableID].filter[KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT + i]));
  3006. memset(l_pstCurrEitPFPara[i], 0, sizeof(EITPFINFO));
  3007. }
  3008. }
  3009. else
  3010. {
  3011. for(i = 0; i < SI_NO_EIT_PF_FILTERS; i++)
  3012. {
  3013. if(l_pstCurrEitPFPara[i]->nUsedFlag == 1 &&
  3014.    l_pstCurrEitPFPara[i]->nSvcID == nSvcID
  3015.    && l_pstCurrEitPFPara[i]->nTableId == nTableId)
  3016. { 
  3017. memset(l_pstCurrEitPFPara[i], 0, sizeof(EITPFINFO));
  3018. break;
  3019. }
  3020. }
  3022. for(i = 0; i < SI_NO_EIT_PF_FILTERS; i++)
  3023. {
  3024. if(SISubTable[EITSubTableID].filter[KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT + i].enabled == TRUE &&
  3025.    SISubTable[EITSubTableID].filter[KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT + i].tableIDExt == nSvcID)
  3026. {
  3027. SIFilterStop(SISubTable[EITSubTableID].details.channelID, &(SISubTable[EITSubTableID].filter[KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT + i]));
  3028. break;
  3029. }
  3030. }
  3031. }
  3033. return 0;
  3034. }
  3037. static INT32 SIGetEitSCH(UINT32 nPendingNo)
  3038. {
  3039.     int i, nCurrentParaNum;
  3040.     KB_OSPMsgNode msgNode;
  3041.     
  3042.     for (i = 0; i < KB_SI_EIT_SCHEDULE_SERVICE_COUNT; i++)
  3043. {        
  3044. if(l_pstCurrEinSchInfoPara[i]->nUsedFlag == 0)
  3045. {
  3046. memcpy(l_pstCurrEinSchInfoPara[i], l_pstPendingEinSchInfoPara[nPendingNo], sizeof(EITSCHINFO));
  3048. l_pstCurrEinSchInfoPara[i]->nCurrVersionNumber = -1;
  3049. l_pstCurrEinSchInfoPara[i]->nUsedFlag = 1;
  3051.             //memset(l_pstCurrEinSchInfoPara[i]->pstEinSchInfo, 0, sizeof(KB_SIEitSch));            
  3052.             l_pstCurrEinSchInfoPara[i]->pstEinSchInfo->num = 0;
  3053.             nCurrentParaNum = i;
  3054.             #if 0
  3055.             DBGPrint("[j_sipsi.c] i = %d ServiceId = %dn", i, l_pstCurrEinSchInfoPara[i]->nSvcID);
  3056.             #endif
  3057. break;
  3058. }
  3059. }
  3061.     if (i >= KB_SI_EIT_SCHEDULE_SERVICE_COUNT)
  3062.     {
  3063.         memset(&msgNode, 0, sizeof(KB_OSPMsgNode));
  3064. msgNode.Word1 = MSG_SI_EIT_SCHEDULE_RECEIVE;
  3065. msgNode.Word2 = nPendingNo;
  3067. KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&msgNode);
  3068.     }
  3070.     /* 把当前pending结构清零 */
  3071.     memset(l_pstPendingEinSchInfoPara[nPendingNo], 0, sizeof(EITSCHINFO));
  3072.     
  3073.    
  3074.     for (i = 0; i < KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT; i++)
  3075.     {
  3076.         if (SISubTable[EITSubTableID].filter[i].used == FALSE)
  3077.         {            
  3078.             SISubTable[EITSubTableID].details.tableID = 0x50;
  3079.             SISubTable[EITSubTableID].details.timeout = J_SI_EIT_SCHEDULE_TIMEOUT;
  3080.             SISubTable[EITSubTableID].details.tableIDExt = l_pstCurrEinSchInfoPara[nCurrentParaNum]->nSvcID;
  3081.         SISubTableStart(EITSubTableID, i, -1, l_pstCurrEinSchInfoPara[nCurrentParaNum]->handle);
  3082.             break;
  3083.         }
  3084.     }
  3086.     for (i = 0; i < KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT; i++)
  3087.     {
  3088.         if (SISubTable[EITSubTableID].filter[i].used == FALSE)
  3089.         {            
  3090.             SISubTable[EITSubTableID].details.tableID = 0x51;
  3091.             SISubTable[EITSubTableID].details.timeout = J_SI_EIT_SCHEDULE_TIMEOUT;
  3092.             SISubTable[EITSubTableID].details.tableIDExt = l_pstCurrEinSchInfoPara[nCurrentParaNum]->nSvcID;
  3093.         SISubTableStart(EITSubTableID, i, -1, l_pstCurrEinSchInfoPara[nCurrentParaNum]->handle);
  3094.             break;
  3095.         }
  3096.     }
  3099. return 0;
  3100. }
  3102. static INT32 SIStopEitSCH(INT32 nSvcID)
  3103. {
  3104.     int i;
  3105.     
  3106.     if (nSvcID == KB_SI_STOP_ALL)
  3107.     {                
  3108.         for (i = 0; i < KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT; i++)
  3109.         {
  3110.             SIFilterStop(SISubTable[EITSubTableID].details.channelID, &(SISubTable[EITSubTableID].filter[i]));        
  3111.         }
  3113.         for (i = 0; i < KB_SI_EIT_SCHEDULE_SERVICE_COUNT; i++)
  3114.         {
  3115.             memset(l_pstCurrEinSchInfoPara[i], 0, sizeof(EITSCHINFO));
  3116.         }
  3117.     }
  3118.     else
  3119.     {
  3120.         for (i = 0; i < KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT; i++)
  3121.         {            
  3122.             if (SISubTable[EITSubTableID].filter[i].tableIDExt == nSvcID)
  3123.             {
  3124.                 SIFilterStop(SISubTable[EITSubTableID].details.channelID, &(SISubTable[EITSubTableID].filter[i]));         
  3125.             }
  3126.         }
  3127.         
  3128.         for (i = 0; i < KB_SI_EIT_SCHEDULE_SERVICE_COUNT; i++)
  3129.         {
  3130.             if (l_pstCurrEinSchInfoPara[i]->nUsedFlag == 1
  3131.                 && l_pstCurrEinSchInfoPara[i]->nSvcID == nSvcID)
  3132.             {
  3133.                 memset(l_pstCurrEinSchInfoPara[i], 0, sizeof(EITSCHINFO));
  3134.                 break;
  3135.             }
  3136.         }
  3137.     }
  3138.     
  3139. return 0;
  3140. }
  3142. INT32 SIGetTDT()
  3143. {
  3144. memcpy(l_pstCurrTdtPara, l_pstPendingTdtPara, sizeof(TDTINFO));
  3145. l_pstCurrTdtPara->nUsedFlag = 1;
  3147. SISubTableStart(TDTSubTableID, 0, -1, l_pstCurrTdtPara->handle);
  3149. return 0;
  3150. }
  3152. static INT32 SIStopTDT()
  3153. {
  3154. SISubTableStop(TDTSubTableID);
  3155. memset(l_pstCurrTdtPara, 0, sizeof(TDTINFO));
  3157. return 0;
  3158. }
  3160. INT32 SIGetTOT()