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

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

DVD

开发平台：

C/C++

sipsi.c：源码内容
  1. {
  2. memcpy(l_pstCurrTotPara, l_pstPendingTotPara, sizeof(TOTINFO));
  3. l_pstCurrTotPara->nUsedFlag = 1;
  5. SISubTableStart(TOTSubTableID, 0, -1, l_pstCurrTotPara->handle);
  7. return 0;
  8. }
  10. static INT32 SIStopTOT()
  11. {
  12. SISubTableStop(TOTSubTableID);
  13. memset(l_pstCurrTotPara, 0, sizeof(TOTINFO));
  15. return 0;
  16. }
  18. INT32 SIGetCAT()
  19. {
  20. memcpy(l_pstCurrCatPara, l_pstPendingCatPara, sizeof(CATINFO));
  21. l_pstCurrCatPara->nCurrVersionNumber = -1;
  22. l_pstCurrCatPara->nUsedFlag = 1;
  23. SISubTableStart(CATSubTableID, 0, l_pstCurrCatPara->nVersionNumber, l_pstCurrCatPara->handle);
  25. return 0;
  26. }
  28. static INT32 SIStopCAT()
  29. {
  30. SISubTableStop(CATSubTableID);
  31. memset(l_pstCurrCatPara, 0, sizeof(CATINFO));
  33. return 0;
  34. }
  36. INT32 SIGetRst()
  37. {
  38. memcpy(l_pstCurrRstPara, l_pstPendingRstPara, sizeof(RSTINFO));
  39. l_pstCurrRstPara->nUsedFlag = 1;
  40. SISubTableStart(RSTSubTableID, 0, -1, l_pstCurrRstPara->handle);
  42. return 0;
  43. }
  45. static INT32 SIStopRst()
  46. {
  47. SISubTableStop(RSTSubTableID);
  48. memset(l_pstCurrRstPara, 0, sizeof(RSTINFO));
  50. return 0;
  51. }
  53. static void SIParsePAT(MepgData *section)
  54. {
  55. T_SubTableFilter *filter;
  56. UINT8 *pInData;
  57. INT32 dataLength;
  58. KB_SIPatStruct* pstPat;
  59. INT32 i;
  60. INT8 version_number;
  61. INT32 nOldNum;
  63. filter = &SISubTable[section->subTableID].filter[section->filterNumber];
  64. if(l_pstCurrPatPara->handle != filter->handle)
  65. {
  66. SIFreeSectionData(section);
  67. return;
  68. }
  70. pInData = section->data;
  71. dataLength = section->length;
  73. pstPat = l_pstCurrPatPara->pstPat;
  75. version_number = (UINT8)((pInData[5] & 0x3E) >> 1);
  76. if(l_pstCurrPatPara->nCurrVersionNumber == -1)
  77. {
  78. l_pstCurrPatPara->nCurrVersionNumber = version_number;
  79. memset(pstPat, 0, sizeof(KB_SIPatStruct));
  80. }
  81. else if(l_pstCurrPatPara->nCurrVersionNumber != version_number)
  82. {
  83. SIFreeSectionData(section);
  84. l_pstCurrPatPara->handle = l_nHandle++;
  85. l_pstCurrPatPara->nCurrVersionNumber = -1;
  86. SISubTableStart(PATSubTableID, 0, l_pstCurrPatPara->nVersionNumber, l_pstCurrPatPara->handle);
  87. return;
  88. }
  90. pstPat->transport_stream_id = (UINT16)(pInData[3] * 0x100 + pInData[4]);
  91. pstPat->version_number = (UINT8)((pInData[5] & 0x3E) >> 1);
  93. pInData += 8;
  94. dataLength -= 8;
  96. if( dataLength <= 0 )
  97. {
  98. SIFreeSectionData(section);
  99. return;
  100. }
  102. nOldNum = pstPat->num;
  103. pstPat->num += (UINT16)(dataLength / 4);
  104. if(pstPat->num > KB_SI_MAX_PAT_PROGRAM_NUM)
  105. {
  106. pstPat->num = KB_SI_MAX_PAT_PROGRAM_NUM;
  107. }
  109. for(i = 0; i < pstPat->num - nOldNum; i++)
  110. {
  111. pstPat->program[i + nOldNum].program_number = (UINT16)(pInData[i * 4] * 0x100 + pInData[i * 4 + 1]);
  112. pstPat->program[i + nOldNum].program_map_PID = (UINT16)((pInData[i * 4 + 2] * 0x100 + pInData[i * 4 + 3]) & 0x1FFF);
  113. }
  115. pInData += dataLength;
  116. pstPat->CRC_32 = (UINT32)pInData[0] * 0x1000000 + (UINT32)pInData[1] * 0x10000 + (UINT32)pInData[2] * 0x100 + (UINT32)pInData[3];
  118. SIFreeSectionData(section);
  120. }
  122. static void SIParseNIT(MepgData *section)
  123. {
  124. T_SubTableFilter *filter;
  125. UINT8 *pInData;
  126. UINT8 *endPtr;
  127. INT32 dataLength;
  128. KB_SINitStruct* pstNit;
  129. INT32 network_descriptors_length;
  130. INT32 transport_stream_loop_length;
  131. INT8 version_number;
  134. filter = &SISubTable[section->subTableID].filter[section->filterNumber];
  135. if(l_pstCurrNitPara->handle != filter->handle)
  136. {
  137. SIFreeSectionData(section);
  138. return;
  139. }
  141. pInData = section->data;
  142. dataLength = section->length;
  144. pstNit = l_pstCurrNitPara->pstNit;
  146. version_number = (UINT8)((pInData[5] & 0x3E) >> 1);
  147. if(l_pstCurrNitPara->nCurrVersionNumber == -1)
  148. {
  149. l_pstCurrNitPara->nCurrVersionNumber = version_number;
  150. memset(pstNit, 0, sizeof(KB_SINitStruct));
  151. }
  152. else if(l_pstCurrNitPara->nCurrVersionNumber != version_number)
  153. {
  154. SIFreeSectionData(section);
  155. l_pstCurrNitPara->handle = l_nHandle++;
  156. l_pstCurrNitPara->nCurrVersionNumber = -1;
  157. /* Start the NIT filtering. */
  158. SISubTableStart(NITSubTableID, 0, l_pstCurrNitPara->nVersionNumber, l_pstCurrNitPara->handle);
  159. return;
  160. }
  162. pstNit->network_id = (UINT16)(pInData[3] * 0x100 + pInData[4]);
  163. pstNit->version_number = (UINT8)((pInData[5] & 0x3E) >> 1);
  165. /*
  166. ** Skip past the standard SI Table header (contains tableID, section Length, etc)
  167. */
  168. pInData += 8;
  169. dataLength -= 8;
  171. if( dataLength <= 0 )
  172. {
  173. SIFreeSectionData(section);
  174. return;
  175. }
  177. network_descriptors_length = ((INT32)pInData[0] * 0x100 + (INT32)pInData[1]) & 0x0FFF;
  178. pInData += 2;
  179. SINITDescs(pInData, network_descriptors_length, pstNit);
  180. pInData += network_descriptors_length;
  182. transport_stream_loop_length = ((INT32)pInData[0] * 0x100 + (INT32)pInData[1]) & 0x0FFF;
  183. pInData += 2;
  185. endPtr = pInData + transport_stream_loop_length;
  186. while( pInData < endPtr && pstNit->num < KB_SI_MAX_NIT_CHANNEL_NUM)
  187. {
  188. int transport_descriptors_length;
  190. pstNit->network[pstNit->num].transport_stream_id = (UINT16)(pInData[0] * 0x100 + pInData[1]);
  191. pInData += 2;
  193. pstNit->network[pstNit->num].original_network_id = (UINT16)(pInData[0] * 0x100 + pInData[1]);
  194. pInData += 2;
  196. transport_descriptors_length = (pInData[0] * 0x100 + pInData[1]) & 0x0FFF;
  197. pInData += 2;
  198. SINITDescs(pInData, transport_descriptors_length, pstNit);
  199. pInData += transport_descriptors_length;
  201. pstNit->num++;
  202. }
  204. pInData = endPtr;
  205. pstNit->CRC_32 = (UINT32)pInData[0] * 0x1000000 + (UINT32)pInData[1] * 0x10000 + (UINT32)pInData[2] * 0x100 + (UINT32)pInData[3];
  207. SIFreeSectionData(section);
  209. }
  211. static void SIParsePMT(MepgData *section)
  212. {
  213. T_SubTableFilter *filter;
  214. UINT8 *pInData;
  215. INT32 dataLength;
  216. KB_SIPmtStruct* pstPmt = NULL;
  217. UINT32 program_info_length;
  218. UINT32 ES_info_length;
  219. INT32 i;
  220. INT8 version_number;
  221.     
  222. filter = &SISubTable[section->subTableID].filter[section->filterNumber];
  224. pInData = section->data;
  225. dataLength = section->length;
  227.      //cCopyFlag = FALSE;
  228. for(i = 0; i < SI_NO_PMT_TABLES; i++)
  229. {
  230. if(l_pstCurrPmtPara[i]->handle == filter->handle &&
  231.    l_pstCurrPmtPara[i]->nUsedFlag == 1 &&
  232.    l_pstCurrPmtPara[i]->nSvcNO == filter->tableIDExt)
  233. {
  234. pstPmt = l_pstCurrPmtPara[i]->pstPmt;
  236. version_number = (UINT8)((pInData[5] & 0x3E) >> 1);
  237. if(l_pstCurrPmtPara[i]->nCurrVersionNumber == -1)
  238. {
  239. l_pstCurrPmtPara[i]->nCurrVersionNumber = version_number;
  240. memset(pstPmt, 0, sizeof(KB_SIPmtStruct));
  241. }
  242. else if(l_pstCurrPmtPara[i]->nCurrVersionNumber != version_number)
  243. {
  244. INT32 subTableID;
  245. subTableID = section->subTableID;
  246. SIFreeSectionData(section);
  247. l_pstCurrPmtPara[i]->handle = l_nHandle++;
  248. l_pstCurrPmtPara[i]->nCurrVersionNumber = -1;
  249. SISubTable[subTableID].details.tableIDExt = l_pstCurrPmtPara[i]->nSvcNO;
  250. SISubTable[subTableID].details.PID = l_pstCurrPmtPara[i]->nProgramMapPid;
  251. SISubTableStart(subTableID, 0, l_pstCurrPmtPara[i]->nVersionNumber, l_pstCurrPmtPara[i]->handle);
  252. return;
  253. }            
  255. break;
  256. }
  257. }
  259. if(pstPmt == NULL)
  260. {
  261. SIFreeSectionData(section);
  262. return;
  263. }
  265. pstPmt->program_number = (UINT16)(pInData[3] * 0x100 + pInData[4]);
  266. pstPmt->version_number = (UINT8)((pInData[5] & 0x3E) >> 1);
  268. pInData += 8;
  269. dataLength -= 8;
  271. if( dataLength <= 0 )
  272. {
  273. SIFreeSectionData(section);
  274. return;
  275. }
  277. pstPmt->PCR_PID = (UINT16)((pInData[0] * 0x100 + pInData[1]) & 0x1FFF);
  278. program_info_length = ((UINT32)pInData[2] * 0x100 + (UINT32)pInData[3]) & 0x0FFF;
  279. pInData += 4;
  280. dataLength -= 4;
  282. SIPMTDescs(pInData, program_info_length, pstPmt, 0);
  284. pInData += program_info_length;
  285. dataLength -= program_info_length;
  287. while((dataLength > 0) && (pstPmt->num < KB_SI_MAX_PMT_STREAM_NUM)) //Modified by dts 2005-8-8
  288. {
  289. pstPmt->stream[pstPmt->num].stream_type = pInData[0];
  290. pstPmt->stream[pstPmt->num].elementary_PID = (UINT16)((pInData[1] * 0x100 + pInData[2]) & 0x1FFF);
  291. ES_info_length = ((UINT32)pInData[3] * 0x100 + (UINT32)pInData[4]) & 0x0FFF;
  292. pInData += 5;
  293. dataLength -= 5;
  295. SIPMTDescs(pInData, ES_info_length, pstPmt, 1);
  297. pInData += ES_info_length;
  298. dataLength -= ES_info_length;
  300. pstPmt->num++;
  301. }
  303. SIFreeSectionData(section);
  305. }
  308. static INT32 SIParseDuration(UINT8* pInData, UINT32* pOutDuration)
  309. {
  310. INT32 nHour, nMin, nSec;
  312. nHour = ((INT32)pInData[0] >> 4) * 10 + ((INT32)pInData[0] & 0x0F);
  313. nMin = ((INT32)pInData[1] >> 4) * 10 + ((INT32)pInData[1] & 0x0F);
  314. nSec = ((INT32)pInData[2] >> 4) * 10 + ((INT32)pInData[2] & 0x0F);
  316. *pOutDuration = nHour * 3600 + nMin * 60 + nSec;
  318. return 0;
  319. }
  322. static INT32 SIParseTime(UINT8* pInData, time_t* pOutTime)
  323. {
  324. UINT16 MJD;
  325. INT32 nYear, nYear1, nMon, nMon1, nDay, nHour, nMin, nSec, nAdjust;
  326. struct tm tm;
  328. memset(&tm, 0, sizeof(struct tm));
  330. MJD = (UINT16)(pInData[0] << 8) | (pInData[1]);
  332. nYear1 = (INT32)((MJD - 15078.2) / 365.25);
  333. nMon1 = (INT32)((MJD - 14956.1 - (INT32)(nYear1 * 365.25)) / 30.6001);
  335. nDay = (INT32)MJD - 14956 - (INT32)(nYear1 * 365.25) - (INT32)(nMon1 * 30.6001);
  337. nAdjust = 0;
  338. if(nMon1 == 14 || nMon1 == 15)
  339. {
  340. nAdjust = 1;
  341. }
  343. nYear = nYear1 + nAdjust + 1900;
  344. nMon = nMon1 - 1 - nAdjust * 12;
  346. nHour = ((INT32)pInData[2] >> 4) * 10 + ((INT32)pInData[2] & 0x0F);
  347. nMin  = ((INT32)pInData[3] >> 4) * 10 + ((INT32)pInData[3] & 0x0F);
  348. nSec  = ((INT32)pInData[4] >> 4) * 10 + ((INT32)pInData[4] & 0x0F);
  350. tm.tm_isdst = 0;
  351. tm.tm_year = (UINT16)(nYear - 1900);
  352. tm.tm_mon = (UINT16)(nMon - 1);
  353. tm.tm_mday = (UINT16)nDay;
  354. tm.tm_hour = (UINT16)nHour;
  355. tm.tm_min = (UINT16)nMin;
  356. tm.tm_sec = (UINT16)nSec;
  357. *(pOutTime) = mktime(&tm);
  359. return 0;
  360. }
  361. static void SIParseTDT(MepgData *section)
  362. {
  363. T_SubTableFilter *filter;
  364. UINT8 *pInData;
  365. INT32 dataLength;
  366. KB_OSPMsgNode message;
  369. filter = &SISubTable[section->subTableID].filter[section->filterNumber];
  370. if(l_pstCurrTdtPara->handle != filter->handle)
  371. {
  372. SIFreeSectionData(section);
  373. return;
  374. }
  376. pInData = section->data;
  377. dataLength = section->length;
  378. pInData += 3;
  379. dataLength -= 3;
  381. if(dataLength <= 0)
  382. {
  383. SIFreeSectionData(section);
  384. return;
  385. }
  387. if(l_pstCurrTdtPara->ptCurrentTime == NULL)
  388. {
  389. SIFreeSectionData(section);
  390. return;
  391. }
  393. SIParseTime(pInData, l_pstCurrTdtPara->ptCurrentTime);
  394. SIFreeSectionData(section);
  396. memset(&message, 0, sizeof(KB_OSPMsgNode));
  397. message.Word1 = MOD_SIPSI;
  398. message.Word2 = KB_SI_MSG_TDT_DONE;
  399. message.Word3 = (UINT32)l_pstCurrTdtPara->ptCurrentTime;
  401. KD_DTVSendMsg(&message);
  403. memset(l_pstCurrTdtPara, 0, sizeof(TDTINFO));
  404. }
  406. static void SIParseTOT(MepgData *section)
  407. {
  408. T_SubTableFilter *filter;
  409. UINT8 *pInData, *ptr;
  410. INT32 dataLength;
  411. KB_OSPMsgNode message;
  412. INT16 total_descriptor_length;
  413. UINT8 descriptor_length;
  414. UINT8 descriptor_tag;
  415. INT16 i;
  416. KB_SITot *pTot;
  417. UINT8 tmp;
  418. UINT8 count=0;
  420. filter = &SISubTable[section->subTableID].filter[section->filterNumber];
  421. if(l_pstCurrTotPara->handle != filter->handle)
  422. {
  423. J_SI_Print("nerr1");
  424. SIFreeSectionData(section);
  425. return;
  426. }
  428. pInData = section->data;
  429. if(*pInData != 0x73)
  430. {
  431. J_SI_Print("nid %d",*pInData);
  432. return;
  433. }
  435. dataLength = section->length;
  437. pInData += 8;
  438. dataLength -= 8;
  440. if(dataLength <= 0)
  441. {
  442. J_SI_Print("nlen=%d",(int)dataLength);
  443. SIFreeSectionData(section);
  444. return;
  445. }
  448. if(l_pstCurrTotPara->pTot == NULL)
  449. {
  450. J_SI_Print("ntot null");
  451. SIFreeSectionData(section);
  452. return;
  453. }
  455. pTot = l_pstCurrTotPara->pTot;
  457. total_descriptor_length = (INT16)(*((INT16 *)pInData) & 0x0fff);
  458. pInData += 2;
  459. ptr = pInData;
  461. J_SI_Print("n");
  462. for(i=0;i<total_descriptor_length;i++)
  463. {
  464. J_SI_Print("%02x ",*pInData);
  465. pInData++;
  466. }
  467. pInData = ptr;
  469. while(total_descriptor_length >= 15)
  470. {
  471. descriptor_tag = *pInData;
  472. pInData++;
  473. descriptor_length = *pInData;
  474. pInData++;
  475. total_descriptor_length -= 2;
  477. if(descriptor_tag != KB_FILTER_SI_LOCAL_TIME_OFFSET)
  478. {
  479. total_descriptor_length -= descriptor_length;
  480. pInData += descriptor_length;
  482. continue;
  483. }
  485. if(descriptor_length != 13)
  486. {
  487. total_descriptor_length -= descriptor_length;
  488. pInData += descriptor_length;
  490. continue;
  491. }
  493. pTot->country_code[0] = *pInData;
  494. pInData++;
  495. pTot->country_code[1] = *pInData;
  496. pInData++;
  497. pTot->country_code[2] = *pInData;
  498. pInData++;
  500. tmp = *pInData;
  501. pInData++;
  502. pTot->country_region_id = (UINT8)((tmp >> 2) & 0x3f);
  503. pTot->polarity = (UINT8)(tmp & 1);
  505. pTot->local_time_offset = *((UINT16 *)pInData);
  506. pInData+=2;
  507. pInData+=7;
  509. total_descriptor_length -= 13;
  510. count++;
  512. if(count >= KB_SI_MAX_TOT_SECTION)
  513. break;
  515. }
  517. SIFreeSectionData(section);
  519. memset(&message, 0, sizeof(KB_OSPMsgNode));
  520. message.Word1 = MOD_SIPSI;
  521. message.Word2 = KB_SI_MSG_TOT_DONE;
  522. message.Word3 = (UINT32)l_pstCurrTotPara->pTot;
  523. message.Word4 = count;
  525. KD_DTVSendMsg(&message);
  527. memset(l_pstCurrTotPara, 0, sizeof(TOTINFO));
  528. }
  530. static void SIParseCAT(MepgData *section)
  531. {
  532. T_SubTableFilter *filter;
  533. UINT8 *pInData;
  534. INT32 dataLength;
  535. KB_SICatStruct* pstCat;
  536. UINT8 version_number;
  539. filter = &SISubTable[section->subTableID].filter[section->filterNumber];
  540. if(l_pstCurrCatPara->handle != filter->handle)
  541. {
  542. SIFreeSectionData(section);
  543. return;
  544. }
  546. pInData = section->data;
  547. dataLength = section->length;
  549. pstCat = l_pstCurrCatPara->pstCat;
  551. version_number = (UINT8)((pInData[5] & 0x3E) >> 1);
  552. if(l_pstCurrCatPara->nCurrVersionNumber == -1)
  553. {
  554. l_pstCurrCatPara->nCurrVersionNumber = version_number;
  555. memset(pstCat, 0, sizeof(KB_SICatStruct));
  556. }
  557. else if(l_pstCurrCatPara->nCurrVersionNumber != version_number)
  558. {
  559. SIFreeSectionData(section);
  560. l_pstCurrCatPara->handle = l_nHandle++;
  561. l_pstCurrCatPara->nCurrVersionNumber = -1;
  562. SISubTableStart(CATSubTableID, 0, l_pstCurrCatPara->nVersionNumber, l_pstCurrCatPara->handle);
  563. return;
  564. }
  566. pstCat->version_number = (UINT8)((pInData[5] & 0x3E) >> 1);
  568. pInData += 8;
  569. dataLength -= 8;
  571. if( dataLength <= 0 )
  572. {
  573. SIFreeSectionData(section);
  574. return;
  575. }
  577. SICATDescs(pInData, dataLength, pstCat);
  579. SIFreeSectionData(section);
  580. }
  582. static void SIParseRST(MepgData *section)
  583. {
  584. T_SubTableFilter *filter;
  585. UINT8 *pInData;
  586. INT32 dataLength;
  587. KB_OSPMsgNode message;
  588. KB_SIRstStruct* pstRst;
  590. filter = &SISubTable[section->subTableID].filter[section->filterNumber];
  591. if(l_pstCurrRstPara->handle != filter->handle)
  592. {
  593. SIFreeSectionData(section);
  594. return;
  595. }
  597. pInData = section->data;
  598. dataLength = section->length;
  600. pInData += 3;
  601. dataLength -= 3;
  603. if(dataLength <= 0)
  604. {
  605. SIFreeSectionData(section);
  606. return;
  607. }
  609. if(l_pstCurrRstPara->pstRst == NULL)
  610. {
  611. SIFreeSectionData(section);
  612. return;
  613. }
  615. l_pstCurrRstPara->nEventStatusNum = 0;
  616. while(dataLength > 0 &&
  617.       l_pstCurrRstPara->nEventStatusNum < l_pstCurrRstPara->nMaxEventStatusNum)
  618. {
  619. pstRst = &l_pstCurrRstPara->pstRst[l_pstCurrRstPara->nEventStatusNum];
  620. memset(pstRst, 0, sizeof(KB_SIRstStruct));
  622. pstRst->transport_stream_id = (UINT16)(pInData[0] * 0x100 + pInData[1]);
  623. pInData += 2;
  624. dataLength -= 2;
  626. pstRst->original_network_id = (UINT16)(pInData[0] * 0x100 + pInData[1]);
  627. pInData += 2;
  628. dataLength -= 2;
  630. pstRst->service_id = (UINT16)(pInData[0] * 0x100 + pInData[1]);
  631. pInData += 2;
  632. dataLength -= 2;
  634. pstRst->event_id = (UINT16)(pInData[0] * 0x100 + pInData[1]);
  635. pInData += 2;
  636. dataLength -= 2;
  638. pstRst->running_status = (UINT8)(pInData[0] & 0x7);
  639. pInData++;
  640. dataLength--;
  642. l_pstCurrRstPara->nEventStatusNum++;
  643. }
  645. SIFreeSectionData(section);
  647. memset(&message, 0, sizeof(KB_OSPMsgNode));
  648. message.Word1 = MOD_SIPSI;
  649. message.Word2 = KB_SI_MSG_RST_DONE;
  650. message.Word3 = (UINT32)l_pstCurrRstPara->pstRst;
  651. message.Word4 = (UINT32)l_pstCurrRstPara->nEventStatusNum;
  652. KD_DTVSendMsg(&message);
  654. SISubTableStart(RSTSubTableID, 0, -1, l_pstCurrRstPara->handle);
  655. }
  657. static void SINITDescs( UINT8* pInData, INT32 dataLen, KB_SINitStruct* pstNit)
  658. {
  659. UINT8 *data;
  660. UINT8 tag;
  661. UINT8 length;
  663. UINT16 transport_stream_id;
  664. UINT16 original_network_id;
  665. UINT16 service_id;
  666. UINT8 linkage_type;
  667.     UINT8 service_num;
  668.     
  669. while( dataLen > 0 )
  670. {
  671. tag = *pInData++;
  672. length = *pInData++;
  674. data = pInData;
  675. pInData += length;
  676. dataLen -= ((INT32)length + 2);
  678. if(length == 0)
  679. continue;
  681. switch(tag)
  682. {
  683. case KB_FILTER_SI_NETWORK_NAME:
  684. SIStoreText(pstNit->network_name, data, ((length > KB_SI_MAX_NETWORK_NAME_LEN)
  685. ? KB_SI_MAX_NETWORK_NAME_LEN : length) );
  686. break;
  687. case KB_FILTER_SI_LINKAGE:
  688. transport_stream_id = (UINT16)(data[0] * 0x100 + data[1]);
  689. original_network_id = (UINT16)(data[2] * 0x100 + data[3]);
  690. service_id          = (UINT16)(data[4] * 0x100 + data[5]);
  691. data += 6;
  692. linkage_type = data[0];
  693. data++;
  694. if(linkage_type == 0x84 && length >= 12) // 确保足够的长度
  695. {
  696. UINT8 descriptor_tag;
  697. UINT8 stbVersion;
  698. UINT8 Flags;
  699. UINT8 descriptor_length;
  700. descriptor_tag = data[0];
  701. data++;
  702. if(descriptor_tag == 0x81)
  703. {
  704. stbVersion = (UINT8)(data[0]>>2);
  705. Flags = (UINT8)(data[0] & 0x3);
  706. data++;
  707. if(Flags == 3)
  708. {
  709. INT32 i;
  710. UINT16 bouquet_id;
  711. descriptor_length = data[0];
  712. data++;
  713. for(i = 0; i < descriptor_length; i += 2)
  714. {
  715. bouquet_id = (UINT16)(data[i] * 0x100 + data[i+1]);
  716. if(bouquet_id == 0x0A)
  717. {
  718. pstNit->loader_flag = 1;
  719. pstNit->loader.transport_stream_id = transport_stream_id;
  720. pstNit->loader.original_network_id = original_network_id;
  721. pstNit->loader.service_id = service_id;
  722. pstNit->loader.stbVersion = stbVersion;
  723. break;
  724. }
  725. }
  726. }
  727. }
  728. }
  729. break;
  730. case KB_FILTER_SI_CABLE_DELIVERY:            
  731. pstNit->network[pstNit->num].frequency = ((UINT32)data[0] >> 4)   * 10000000 +
  732.                                  ((UINT32)data[0] & 0x0F) *  1000000 +
  733.                                  ((UINT32)data[1] >> 4)   *   100000 +
  734.                                  ((UINT32)data[1] & 0x0F) *    10000 +
  735.                                  ((UINT32)data[2] >> 4)   *     1000 +
  736.                                   ((UINT32)data[2] & 0x0F) *      100 +
  737.                                   ((UINT32)data[3] >> 4)   *       10 +
  738.                                   ((UINT32)data[3] & 0x0F) *        1;
  739. data += 4 + 1;
  740. pstNit->network[pstNit->num].FEC_outer = data[0] & 0x0F;
  741. data++;
  743. pstNit->network[pstNit->num].modulation = data[0];
  744. data++;
  746. pstNit->network[pstNit->num].symbol_rate = ((UINT32)data[0] >> 4)   * 1000000 +
  747.    ((UINT32)data[0] & 0x0F) *  100000 +
  748.    ((UINT32)data[1] >> 4)   *   10000 +
  749.    ((UINT32)data[1] & 0x0F) *    1000 +
  750.    ((UINT32)data[2] >> 4)   *     100 +
  751.    ((UINT32)data[2] & 0x0F) *      10 +
  752.    ((UINT32)data[3] >> 4)   *       1;
  753. data += 3;
  755. pstNit->network[pstNit->num].FEC_inner = data[0] & 0x0F;
  756. break;
  757. case KB_FILTER_SI_SERVICE_LIST:
  758.             service_num = 0;
  759.          
  760.             while( data < pInData && service_num < KB_SI_MAX_CHANNEL_SERVIC_NUM)
  761.             {
  762.                pstNit->network[pstNit->num].service_list[service_num].service_id = (UINT16)(data[0] * 0x100 + data[1]);
  763.      pstNit->network[pstNit->num].service_list[service_num].service_type = data[2];
  764.                 data +=3;
  765.                 
  766.                 service_num ++;
  767.             }
  768.             pstNit->network[pstNit->num].service_num = service_num;
  770.             break;
  771. case KB_FILTER_SI_STUFFING:
  772. case KB_FILTER_SI_SATELLITE_DELIVERY:
  773. case KB_FILTER_SI_TERRESTRIAL_DELIVERY:
  774. case KB_FILTER_SI_MULTILINGUAL_NETWORK_NAME:
  775. case KB_FILTER_SI_PRIVATE_DATA_SPECIFIER:
  776. break;
  778. default:
  779. break;
  780. }
  781. }
  782. }
  784. static void SIPMTDescs(UINT8* pInData, INT32 dataLen, KB_SIPmtStruct* pstPmt, INT32 inLoop)
  785. {
  786. UINT8 *data;
  787. UINT32 tag;
  788. UINT8 length;
  789. UINT16 oldLength;
  791. while(dataLen >= 2)
  792. {
  793. tag = *pInData++;
  794. length = *pInData++;
  796. data = pInData;
  797. pInData += length;
  798. dataLen -= ((INT32)length + 2);
  800. if(length == 0)
  801. continue;
  803. switch(tag)
  804. {
  805. case KB_FILTER_SI_CA:
  806. if(!inLoop)
  807. {
  808. oldLength = pstPmt->CA_descriptor_buffer_len;
  809. pstPmt->CA_descriptor_buffer_len += (UINT16)(2 + length);
  810. if(pstPmt->CA_descriptor_buffer_len > KB_SI_MAX_CA_BUFFER_LEN)
  811. {
  812. pstPmt->CA_descriptor_buffer_len = KB_SI_MAX_CA_BUFFER_LEN;
  813. }
  814. memcpy(pstPmt->CA_descriptor + oldLength, data - 2, pstPmt->CA_descriptor_buffer_len - oldLength);
  815. }
  816. else
  817. {
  818. INT32 nCurrNo;
  819. nCurrNo = pstPmt->num;
  820. oldLength = pstPmt->stream[nCurrNo].CA_descriptor_buffer_len;
  821. pstPmt->stream[nCurrNo].CA_descriptor_buffer_len += (UINT16)(2 + length);
  822. if(pstPmt->stream[nCurrNo].CA_descriptor_buffer_len > KB_SI_MAX_CA_BUFFER_LEN)
  823. {
  824. pstPmt->stream[nCurrNo].CA_descriptor_buffer_len = KB_SI_MAX_CA_BUFFER_LEN;
  825. }
  826. memcpy(pstPmt->stream[nCurrNo].CA_descriptor + oldLength, data - 2, pstPmt->stream[nCurrNo].CA_descriptor_buffer_len - oldLength);
  827. }
  828. break;
  829. case KB_FILTER_SI_STREAM_IDENTIFIER:
  830. if(inLoop)
  831. {
  832. pstPmt->stream[pstPmt->num].component_tag = *data;
  833. }
  834. break;
  835. case KB_FILTER_SI_TELETEXT:
  836. case KB_FILTER_SI_SUBTITLING:
  837. case KB_FILTER_SI_LANGUAGE:
  838. case KB_FILTER_SI_COPYRIGHT:
  839. case KB_FILTER_SI_MOSAIC:
  840. case KB_FILTER_SI_PRIVATE_DATA_SPECIFIER:
  841. case KB_FILTER_SI_SERVICE_MOVE:
  842. case KB_FILTER_SI_CA_SYSTEM:
  843. case KB_FILTER_SI_DATA_BROADCAST_ID:
  844. break;
  846. default:
  847. break;
  848. }
  849. }
  850. }
  852. static void SIParseSDT(MepgData *section)
  853. {
  854. T_SubTableFilter *filter;
  855. UINT8 *pInData;
  856. INT32 dataLength;
  857. KB_SISdtStruct stTempSdt;
  858. KB_SISdtStruct* pstSdt = NULL;
  859. KB_SIBatStruct* pstBat = NULL;
  860. UINT16 table_id_extension;
  861. UINT8 version_number;
  863. filter = &SISubTable[section->subTableID].filter[section->filterNumber];
  864. if(filter->filterNumber == 0)
  865. {
  866. if(l_pstCurrSdtPara->handle != filter->handle)
  867. {
  868. SIFreeSectionData(section);
  869. return;
  870. }
  872. pstSdt = &stTempSdt;
  873. }
  874. else
  875. {
  876. if(l_pstCurrBatPara->handle != filter->handle)
  877. {
  878. SIFreeSectionData(section);
  879. return;
  880. }
  881. pstBat = &l_pstCurrBatPara->pstBat[l_pstCurrBatPara->nBatNumber];
  882. }
  884. pInData = section->data;
  885. dataLength = section->length;
  887. table_id_extension = (UINT16)(pInData[3] * 0x100 + pInData[4]);
  888. version_number = (UINT8)((pInData[5] & 0x3E) >> 1);
  890. if(filter->filterNumber == 0)
  891. {
  892. if(l_pstCurrSdtPara->nCurrVersionNumber == -1)
  893. {
  894. l_pstCurrSdtPara->nCurrVersionNumber = version_number;
  895. }
  896. else if(l_pstCurrSdtPara->nCurrVersionNumber != version_number)
  897. {
  898. SIFreeSectionData(section);
  899. l_pstCurrSdtPara->handle = l_nHandle++;
  900. l_pstCurrSdtPara->nServiceNum = 0;
  901. l_pstCurrSdtPara->nCurrVersionNumber = -1;
  902. /* Start the SDT filtering. */
  903. SISubTable[SDTSubTableID].details.tableID = 0x42;
  904. SISubTable[SDTSubTableID].details.tableIDExt = -1;
  905. SISubTableStart(SDTSubTableID, 0, l_pstCurrSdtPara->nVersionNumber, l_pstCurrSdtPara->handle);
  906. return;
  907. }
  908. }
  909. else
  910. {
  911. if(l_pstCurrBatPara->nCurrVersionNumber == -1)
  912. {
  913. l_pstCurrBatPara->nCurrVersionNumber = version_number;
  914. memset(pstBat, 0, sizeof(KB_SIBatStruct));
  915. }
  916. else if(l_pstCurrBatPara->nCurrVersionNumber != version_number)
  917. {
  918. SIFreeSectionData(section);
  919. l_pstCurrBatPara->handle = l_nHandle++;
  920. l_pstCurrBatPara->nCurrVersionNumber = -1;
  921. SISubTable[SDTSubTableID].details.tableID = 0x4A;
  922. SISubTable[SDTSubTableID].details.tableIDExt = l_pstCurrBatPara->nBouquetId;
  923. SISubTableStart(SDTSubTableID, 1, l_pstCurrBatPara->nVersionNumber, l_pstCurrBatPara->handle);
  924. return;
  925. }
  926. }
  928. pInData += 8;
  929. dataLength -= 8;
  931. if( dataLength <= 0 )
  932. {
  933. SIFreeSectionData(section);
  934. return;
  935. }
  937. if(filter->filterNumber == 0)
  938. {
  939. pInData += 3;
  940. dataLength -= 3;
  941. while(dataLength > 0 && l_pstCurrSdtPara->nServiceNum < l_pstCurrSdtPara->nMaxServiceNum)
  942. {
  943. INT32 descriptors_loop_length;
  945. memset(pstSdt, 0, sizeof(KB_SISdtStruct));
  946. pstSdt->TSID = table_id_extension;
  947. pstSdt->version_number = version_number;
  949. pstSdt->service_id = (UINT16)(pInData[0] * 0x100 + pInData[1]);
  950. pInData += 2;
  951. dataLength -= 2;
  953. pstSdt->EIT_schedule_flag = (UINT8)((pInData[0] & 0x2) >> 1);
  954. pstSdt->EIT_present_following_flag = pInData[0] & 0x1;
  955. pInData++;
  956. dataLength--;
  958. pstSdt->running_status = (UINT8)(pInData[0] >> 5);
  959. pstSdt->free_CA_mode = (UINT8)((pInData[0] & 0x10) >> 4);
  960. descriptors_loop_length = ((INT32)pInData[0] & 0x0F) * 0x100  + (INT32)pInData[1];
  961. pInData += 2;
  962. dataLength -= 2;
  964. SISDTDescs(pInData, descriptors_loop_length, pstSdt);
  965. pInData += descriptors_loop_length;
  966. dataLength -= descriptors_loop_length;
  968. if(l_pstCurrSdtPara->nSvcID == pstSdt->service_id)
  969. {
  970. memcpy(l_pstCurrSdtPara->pstSdt, pstSdt, sizeof(KB_SISdtStruct));
  971. l_pstCurrSdtPara->nServiceNum++;
  972. break;
  973. }
  974. else if(l_pstCurrSdtPara->nSvcID == -1)
  975. {
  976. if((l_pstCurrSdtPara->nType & KB_SI_RECEIVE_DTV) == 0 ||
  977. pstSdt->service_type == SI_SERVICE_TYPE_DTV)
  978. {
  979. memcpy(&(l_pstCurrSdtPara->pstSdt[l_pstCurrSdtPara->nServiceNum]),
  980. pstSdt, sizeof(KB_SISdtStruct));
  981. l_pstCurrSdtPara->nServiceNum++;
  982. }
  984. }
  985. }
  986. }
  987. else
  988. {
  989. INT32 bouquet_descriptors_length;
  990. INT32 transport_stream_loop_length;
  991. bouquet_descriptors_length = ((INT32)pInData[0] * 0x100 + (INT32)pInData[1]) & 0x0FFF;
  992. pInData += 2;
  994. pstBat->bouquet_id = table_id_extension;
  995. pstBat->version_number = version_number;
  997. SIBATDescs(pInData, bouquet_descriptors_length, pstBat, 0);
  998. pInData += bouquet_descriptors_length;
  1000. transport_stream_loop_length = ((INT32)pInData[0] * 0x100 + (INT32)pInData[1]) & 0x0FFF;
  1001. pInData += 2;
  1003. while(transport_stream_loop_length > 0 && pstBat->num < KB_SI_MAX_NIT_CHANNEL_NUM)
  1004. {
  1005. INT32 transport_descriptors_length;
  1006. pstBat->transport_stream[pstBat->num].transport_stream_id = (UINT16)(pInData[0] * 0x100 + pInData[1]);
  1007. pInData += 2;
  1008. transport_stream_loop_length -= 2;
  1010. pstBat->transport_stream[pstBat->num].original_network_id = (UINT16)(pInData[0] * 0x100 + pInData[1]);
  1011. pInData += 2;
  1012. transport_stream_loop_length -= 2;
  1014. transport_descriptors_length = ((INT32)pInData[0] * 0x100 + (INT32)pInData[1]) & 0x0FFF;
  1015. pInData += 2;
  1016. transport_stream_loop_length -= 2;
  1018. SIBATDescs(pInData, transport_descriptors_length, pstBat, 1);
  1019. pInData += transport_descriptors_length;
  1020. transport_stream_loop_length -= transport_descriptors_length;
  1021. pstBat->num++;
  1022. }
  1023. l_pstCurrBatPara->nBatNumber ++;
  1024. }
  1026. SIFreeSectionData(section);
  1027. }
  1029. static void SISDTDescs( UINT8* pInData, INT32 dataLen, KB_SISdtStruct* pstSdt)
  1030. {
  1031. UINT8 *data;
  1032. UINT32 tag;
  1033. UINT8 length;
  1035. int i;
  1037. int service_provider_name_length;
  1038. int service_name_length;
  1039. char ISO_639_language_code[4];
  1041. while( dataLen > 0 )
  1042. {
  1043. tag = *pInData++;
  1044. length = *pInData++;
  1046. data = pInData;
  1047. pInData += length;
  1048. dataLen -= ((INT32)length + 2);
  1050. if(length == 0)
  1051. continue;
  1053. switch(tag)
  1054. {
  1055. case KB_FILTER_SI_SERVICE:
  1056. pstSdt->service_type = *data++;
  1058. service_provider_name_length = *data++;
  1059. SIStoreText(pstSdt->chinese.service_provider_name, data, ((service_provider_name_length > KB_SI_MAX_SERVICE_PROVIDER_NAME_LEN)
  1060. ? KB_SI_MAX_SERVICE_PROVIDER_NAME_LEN : service_provider_name_length) );
  1061. data += service_provider_name_length;
  1063. service_name_length = *data++;
  1064. SIStoreText(pstSdt->chinese.service_name, data, ((service_name_length > KB_SI_MAX_SERVICE_NAME_LEN)
  1065. ? KB_SI_MAX_SERVICE_NAME_LEN : service_name_length) );
  1066. break;
  1067. case KB_FILTER_SI_MULTILINGUAL_SERVICE_NAME:
  1068. memcpy(ISO_639_language_code, data, 3);
  1069. ISO_639_language_code[3] = '';
  1070. SIToLower(ISO_639_language_code);
  1071. data += 3;
  1073. service_provider_name_length = *data++;
  1074. if(!strcmp(ISO_639_language_code, "chi") ||
  1075.    !strcmp(ISO_639_language_code, "chn") ||
  1076.    !strcmp(ISO_639_language_code, "zho"))
  1077. {
  1078. SIStoreText(pstSdt->chinese.service_provider_name, data, ((service_provider_name_length > KB_SI_MAX_SERVICE_PROVIDER_NAME_LEN)
  1079. ? KB_SI_MAX_SERVICE_PROVIDER_NAME_LEN : service_provider_name_length) );
  1080. }
  1081. else if(!strcmp(ISO_639_language_code, "eng"))
  1082. {
  1083. SIStoreText(pstSdt->english.service_provider_name, data, ((service_provider_name_length > KB_SI_MAX_SERVICE_PROVIDER_NAME_LEN)
  1084. ? KB_SI_MAX_SERVICE_PROVIDER_NAME_LEN : service_provider_name_length) );
  1085. }
  1087. data += service_provider_name_length;
  1089. service_name_length = *data++;
  1090. if(!strcmp(ISO_639_language_code, "chi") ||
  1091.    !strcmp(ISO_639_language_code, "chn") ||
  1092.    !strcmp(ISO_639_language_code, "zho"))
  1093. {
  1094. SIStoreText(pstSdt->chinese.service_name, data, ((service_name_length > KB_SI_MAX_SERVICE_NAME_LEN)
  1095. ? KB_SI_MAX_SERVICE_NAME_LEN : service_name_length) );
  1096. }
  1097. else if(!strcmp(ISO_639_language_code, "eng"))
  1098. {
  1099. SIStoreText(pstSdt->english.service_name, data, ((service_name_length > KB_SI_MAX_SERVICE_NAME_LEN)
  1100. ? KB_SI_MAX_SERVICE_NAME_LEN : service_name_length) );
  1101. }
  1103. break;
  1104. case KB_FILTER_SI_DATA_BROADCAST:
  1105. data += 2;
  1106. pstSdt->component_tag = *data;
  1107. break;
  1108. case KB_FILTER_SI_COUNTRY_AVAILABILITY:
  1109. case KB_FILTER_SI_LINKAGE:
  1110. case KB_FILTER_SI_NVOD_REFERENCE:
  1111. case KB_FILTER_SI_TIME_SHIFTED_SERVICE:
  1112. case KB_FILTER_SI_MOSAIC:
  1113. case KB_FILTER_SI_CA_IDENTIFIER:
  1114. case KB_FILTER_SI_TELEPHONE:
  1115. case KB_FILTER_SI_PRIVATE_DATA_SPECIFIER:
  1116. case KB_FILTER_SI_STUFFING:
  1117. case KB_FILTER_SI_BOUQUET_NAME:
  1118. switch(tag)
  1119. {
  1120. case 0x4B:
  1121. pstSdt->TimeShiftedNum = (UINT8)(length / 6);
  1122. for(i = 0; i < pstSdt->TimeShiftedNum; i ++)
  1123. {
  1124. pstSdt->TimeShift[i].TS_ID = (data[0] << 8) | (data[1]);
  1125. data += 2;
  1126. pstSdt->TimeShift[i].OrgnetID = (data[0] << 8) | (data[1]);
  1127. data += 2;
  1128. pstSdt->TimeShift[i].ServiceID = (data[0] << 8) | (data[1]);
  1129. data += 2;
  1130. }
  1131. break;
  1133. case 0x4C:
  1134.                 pstSdt->reference_service_id = (data[0] << 8) | (data[1]);
  1135.                 
  1136. break;
  1137. }
  1138. break;
  1140. default:
  1141. break;
  1142. }
  1143. }
  1144. }
  1146. static void SIBATDescs(UINT8* pInData, INT32 dataLen, KB_SIBatStruct* pstBat, INT32 inLoop)
  1147. {
  1148. UINT8 *data;
  1149. UINT32 tag;
  1150. UINT8 length;
  1151. char ISO_639_language_code[4];
  1153. while(dataLen > 0)
  1154. {
  1155. tag = *pInData++;
  1156. length = *pInData++;
  1158. data = pInData;
  1159. pInData += length;
  1160. dataLen -= ((INT32)length + 2);
  1162. if(length == 0)
  1163. continue;
  1165. switch(tag)
  1166. {
  1167. case KB_FILTER_SI_BOUQUET_NAME:
  1168. if(!inLoop)
  1169. {
  1170. SIStoreText(pstBat->bouquet_name, data, ((length > KB_SI_MAX_BOUQUET_NAME_LEN)
  1171. ? KB_SI_MAX_BOUQUET_NAME_LEN : length) );
  1172. }
  1173. break;
  1174. case KB_FILTER_SI_MULTILINGUAL_BOUQUET_NAME:
  1175. if(!inLoop)
  1176. {
  1177. INT32 bouquet_name_length;
  1179. memcpy(ISO_639_language_code, data, 3);
  1180. ISO_639_language_code[3] = '';
  1181. SIToLower(ISO_639_language_code);
  1182. data += 3;
  1184. bouquet_name_length = *data++;
  1185. if(!strcmp(ISO_639_language_code, "chi") ||
  1186.    !strcmp(ISO_639_language_code, "chn") ||
  1187.    !strcmp(ISO_639_language_code, "zho"))
  1188. {
  1189. SIStoreText(pstBat->bouquet_name, data, ((bouquet_name_length > KB_SI_MAX_BOUQUET_NAME_LEN)
  1190. ? KB_SI_MAX_BOUQUET_NAME_LEN : bouquet_name_length) );
  1191. }
  1192. else if(!strcmp(ISO_639_language_code, "eng"))
  1193. {
  1194. SIStoreText(pstBat->english_bouquet_name, data, ((bouquet_name_length > KB_SI_MAX_BOUQUET_NAME_LEN)
  1195. ? KB_SI_MAX_BOUQUET_NAME_LEN : bouquet_name_length) );
  1196. }
  1197. }
  1198. break;
  1199. case KB_FILTER_SI_SERVICE_LIST:
  1200. if(inLoop)
  1201. {
  1202. while(length > 0 && pstBat->transport_stream[pstBat->num].num < KB_SI_MAX_BAT_SERVICE_NUM_PER_TS)
  1203. {
  1204. if((l_pstCurrBatPara->nType & KB_SI_RECEIVE_DTV) == 0 ||
  1205. data[2] == SI_SERVICE_TYPE_DTV)
  1206. {
  1207. INT32 service_num;
  1208. service_num = pstBat->transport_stream[pstBat->num].num;
  1209. pstBat->transport_stream[pstBat->num].service[service_num].service_id =
  1210. (UINT16)(data[0] * 0x100 + data[1]);
  1211. pstBat->transport_stream[pstBat->num].service[service_num].service_type = data[2];
  1212. pstBat->transport_stream[pstBat->num].num++;
  1213. }
  1214. data += 3;
  1215. length -= 3;
  1216. }
  1217. }
  1218. break;
  1219. case KB_FILTER_SI_COUNTRY_AVAILABILITY:
  1220. case KB_FILTER_SI_LINKAGE:
  1221. case KB_FILTER_SI_CA_IDENTIFIER:
  1222. case KB_FILTER_SI_PRIVATE_DATA_SPECIFIER:
  1223. case KB_FILTER_SI_STUFFING:
  1224. break;
  1226. default:
  1227. break;
  1228. }
  1229. }
  1230. }
  1232. static void SIEitPFDescs(UINT8* pInData, INT32 dataLen, KB_SIEitPF* pstEitPF)
  1233. {
  1234. UINT8 *data;
  1235. UINT32 tag;
  1236. UINT8 length;
  1237. UINT8 event_name_length;
  1238. UINT8 text_length;
  1240. char ISO_639_language_code[4];
  1242. while(dataLen > 0)
  1243. {
  1244. tag = *pInData++;
  1245. length = *pInData++;
  1247. data = pInData;
  1248. pInData += length;
  1249. dataLen -= ((INT32)length + 2);
  1251. if(length == 0)
  1252. continue;
  1254. switch(tag)
  1255. {
  1256. case KB_FILTER_SI_SHORT_EVENT:
  1257. memcpy(ISO_639_language_code, data, 3);
  1258. ISO_639_language_code[3] = '';
  1259. SIToLower(ISO_639_language_code);
  1260. data += 3;
  1263. event_name_length = *data++;
  1264. if(!strcmp(ISO_639_language_code, "chi") ||
  1265.    !strcmp(ISO_639_language_code, "chn") ||
  1266.    !strcmp(ISO_639_language_code, "zho") ||
  1267.    !strcmp(ISO_639_language_code, "eng"))
  1268. {
  1269. SIStoreText(pstEitPF->chinese.event_name, data, ((event_name_length > KB_SI_MAX_EVENT_NAME_LEN)
  1270. ? KB_SI_MAX_EVENT_NAME_LEN : event_name_length));
  1271. }
  1273. data += event_name_length;
  1275. text_length = *data++;
  1276. if(!strcmp(ISO_639_language_code, "chi") ||
  1277.    !strcmp(ISO_639_language_code, "chn") ||
  1278.    !strcmp(ISO_639_language_code, "zho") ||
  1279.    !strcmp(ISO_639_language_code, "eng"))
  1280. {
  1281. SIStoreText(pstEitPF->chinese.text, data, ((text_length > KB_SI_MAX_EVENT_TEXT_LEN)
  1282. ? KB_SI_MAX_EVENT_TEXT_LEN: text_length));
  1283. }
  1285. break;
  1287. case KB_FILTER_SI_EXTENDED_EVENT:
  1288. data ++;
  1289.             
  1290.             memcpy(ISO_639_language_code, data, 3);
  1291. ISO_639_language_code[3] = '';
  1292. SIToLower(ISO_639_language_code);
  1293. data += 4;
  1294. text_length = *data++;
  1295. if(!strcmp(ISO_639_language_code, "chi") ||
  1296.    !strcmp(ISO_639_language_code, "chn") ||
  1297.    !strcmp(ISO_639_language_code, "zho") ||
  1298.    !strcmp(ISO_639_language_code, "eng"))
  1299. { 
  1300. SIStoreText(pstEitPF->extended_event.text_char, data, ((text_length > KB_SI_MAX_TEXT_CHAR_LEN)
  1301. ? KB_SI_MAX_TEXT_CHAR_LEN : text_length));
  1302. }
  1303. break;
  1305. case KB_FILTER_SI_STUFFING:
  1306. case KB_FILTER_SI_LINKAGE:
  1307. case KB_FILTER_SI_TIME_SHIFTED_EVENT:
  1308. case KB_FILTER_SI_COMPONENT:
  1309. case KB_FILTER_SI_CA_IDENTIFIER:
  1310. case KB_FILTER_SI_CONTENT:
  1311. case KB_FILTER_SI_PARENTAL_RATING:
  1312. case KB_FILTER_SI_TELEPHONE:
  1313. case KB_FILTER_SI_MULTILINGUAL_COMPONENT:
  1314. case KB_FILTER_SI_PRIVATE_DATA_SPECIFIER:
  1315. case KB_FILTER_SI_SHORT_SMOOTHING_BUFFER:
  1316. case KB_FILTER_SI_DATA_BROADCAST:
  1317. break;
  1319. default:
  1320. break;
  1321. }
  1322. }
  1323. }
  1325. static void SIEitSCHDescs(UINT8* pInData, INT32 dataLen, KB_SIEitSchEvent* pstEvent)
  1326. {
  1327. UINT8 *data;
  1328. UINT32 tag;
  1329. UINT8 length;
  1330. UINT8 event_name_length;
  1331. UINT8 text_length;
  1333. char ISO_639_language_code[4];
  1335. while(dataLen > 0)
  1336. {
  1337. tag = *pInData++;
  1338. length = *pInData++;
  1340. data = pInData;
  1341. pInData += length;
  1342. dataLen -= ((INT32)length + 2);
  1344. if(length == 0)
  1345. continue;
  1347. switch(tag)
  1348. {
  1349. case KB_FILTER_SI_SHORT_EVENT:
  1350. memcpy(ISO_639_language_code, data, 3);
  1351. ISO_639_language_code[3] = '';
  1352. SIToLower(ISO_639_language_code);
  1353. data += 3;
  1355. event_name_length = *data++;
  1356. if(!strcmp(ISO_639_language_code, "chi") ||
  1357.    !strcmp(ISO_639_language_code, "chn") ||
  1358.    !strcmp(ISO_639_language_code, "zho"))
  1359. {
  1360. SIStoreText(pstEvent->chinese.event_name, data, ((event_name_length > KB_SI_MAX_EVENT_NAME_LEN)
  1361. ? KB_SI_MAX_EVENT_NAME_LEN : event_name_length));
  1362. }
  1363. else if(!strcmp(ISO_639_language_code, "eng"))
  1364. {
  1365. SIStoreText(pstEvent->chinese.event_name, data, ((event_name_length > KB_SI_MAX_EVENT_NAME_LEN)
  1366. ? KB_SI_MAX_EVENT_NAME_LEN : event_name_length));
  1367. }
  1369. data += event_name_length;
  1371. text_length = *data++;
  1372. if(!strcmp(ISO_639_language_code, "chi") ||
  1373.    !strcmp(ISO_639_language_code, "chn") ||
  1374.    !strcmp(ISO_639_language_code, "zho"))
  1375. {
  1376.     if (NULL != pstEvent->chinese.text)
  1377.         {
  1378. SIStoreText(pstEvent->chinese.text, data, ((text_length > KB_SI_MAX_EVENT_TEXT_LEN)
  1379. ? KB_SI_MAX_EVENT_TEXT_LEN: text_length));
  1380. }
  1381.                 else
  1382.                 {
  1383.                     printf("nSIEitSCHDescs::serious error! pointer text is NULL!");
  1384.                 }
  1385. }
  1386. else if(!strcmp(ISO_639_language_code, "eng"))
  1387. {
  1388.     if (NULL != pstEvent->chinese.text)
  1389.         {
  1390.          SIStoreText(pstEvent->chinese.text, data, ((text_length > KB_SI_MAX_EVENT_TEXT_LEN)
  1391. ? KB_SI_MAX_EVENT_TEXT_LEN: text_length));
  1392. }
  1393.                 else
  1394.                 {
  1395.                     printf("nSIEitSCHDescs::serious error! pointer text is NULL!");
  1396.                 }
  1397. }
  1399. break;
  1400. case KB_FILTER_SI_STUFFING:
  1401. case KB_FILTER_SI_LINKAGE:
  1402. case KB_FILTER_SI_EXTENDED_EVENT:
  1403. case KB_FILTER_SI_COMPONENT:
  1404. case KB_FILTER_SI_CA_IDENTIFIER:
  1405. case KB_FILTER_SI_CONTENT:
  1406. case KB_FILTER_SI_PARENTAL_RATING:
  1407. case KB_FILTER_SI_TELEPHONE:
  1408. case KB_FILTER_SI_MULTILINGUAL_COMPONENT:
  1409. case KB_FILTER_SI_PRIVATE_DATA_SPECIFIER:
  1410. case KB_FILTER_SI_SHORT_SMOOTHING_BUFFER:
  1411. case KB_FILTER_SI_DATA_BROADCAST:
  1412. break;
  1413. case KB_FILTER_SI_TIME_SHIFTED_EVENT:
  1414. pstEvent->reference_service_id = (data[0] << 8) | (data[1]);
  1415.             data += 2;
  1416. pstEvent->reference_event_id = (data[0] << 8) | (data[1]);
  1417. break;
  1419. default:
  1420. break;
  1421. }
  1422. }
  1423. }
  1425. static void SICATDescs(UINT8* pInData, INT32 dataLen, KB_SICatStruct* pstCat)
  1426. {
  1427. UINT8 *data;
  1428. UINT32 tag;
  1429. UINT8 length;
  1430. UINT16 oldLength;
  1432. while( dataLen > 0 )
  1433. {
  1434. tag = *pInData++;
  1435. length = *pInData++;
  1437. data = pInData;
  1438. pInData += length;
  1439. dataLen -= ((INT32)length + 2);
  1441. if(length == 0)
  1442. continue;
  1444. switch(tag)
  1445. {
  1446. case KB_FILTER_SI_CA:
  1447. oldLength = pstCat->CA_descriptor_buffer_len;
  1448. pstCat->CA_descriptor_buffer_len += (UINT16)(2 + length);
  1449. if(pstCat->CA_descriptor_buffer_len > KB_SI_MAX_CA_BUFFER_LEN)
  1450. {
  1451. pstCat->CA_descriptor_buffer_len = KB_SI_MAX_CA_BUFFER_LEN;
  1452. }
  1453. memcpy(pstCat->CA_descriptor + oldLength, data - 2, pstCat->CA_descriptor_buffer_len - oldLength);
  1454. break;
  1455. default:
  1456. break;
  1457. }
  1458. }
  1459. }
  1461. static void SIHandlePat(T_SubTableID subTableID, UINT32 filterNumber, UINT32 handle)
  1462. {
  1463. KB_OSPMsgNode message;
  1464. T_SubTableFilter *filter;
  1466. filter = &SISubTable[subTableID].filter[filterNumber];
  1468. filter->tableIDExt = filter->data.tableIDExt;
  1470. memset(&message, 0, sizeof(KB_OSPMsgNode));
  1471. message.Word1 = MOD_SIPSI;
  1473. if(l_pstCurrPatPara->nType & KB_SI_RECEIVE_CHANGE)
  1474. {
  1475. message.Word2 = KB_SI_MSG_PAT_CHANGE;
  1476. }
  1477. else
  1478. {
  1479. message.Word2 = KB_SI_MSG_PAT_DONE;
  1480. }
  1481. message.Word3 = (UINT32)l_pstCurrPatPara->pstPat;
  1483. KD_DTVSendMsg(&message);
  1485. if(l_pstCurrPatPara->nType & KB_SI_RECEIVE_CHANGE)
  1486. {
  1487. l_pstCurrPatPara->nCurrVersionNumber = -1;
  1488. SISubTableStart(subTableID, filterNumber, filter->data.version, handle);
  1489. }
  1490. else
  1491. {
  1492. memset(l_pstCurrPatPara, 0, sizeof(PATINFO));
  1493. }
  1494. }
  1496. static void SIHandleNit(T_SubTableID subTableID, UINT32 filterNumber, UINT32 handle)
  1497. {
  1498. KB_OSPMsgNode message;
  1499. T_SubTableFilter *filter;
  1501. filter = &SISubTable[subTableID].filter[filterNumber];
  1503. filter->tableIDExt = filter->data.tableIDExt;
  1505. memset(&message, 0, sizeof(KB_OSPMsgNode));
  1506. message.Word1 = MOD_SIPSI;
  1507. if(l_pstCurrNitPara->nType & KB_SI_RECEIVE_CHANGE)
  1508. {
  1509. message.Word2 = KB_SI_MSG_NIT_CHANGE;
  1510. }
  1511. else
  1512. {
  1513. message.Word2 = KB_SI_MSG_NIT_DONE;
  1514. }
  1515. message.Word3 = (UINT32)l_pstCurrNitPara->pstNit;
  1517. KD_DTVSendMsg(&message);
  1519. if(l_pstCurrNitPara->nType & KB_SI_RECEIVE_CHANGE)
  1520. {
  1521. l_pstCurrNitPara->nCurrVersionNumber = -1;
  1522. SISubTableStart(subTableID, filterNumber, filter->data.version, handle);
  1523. }
  1524. else
  1525. {
  1526. memset(l_pstCurrNitPara, 0, sizeof(NITINFO));
  1527. }
  1528. }
  1530. static void SIHandlePmt(T_SubTableID subTableID, UINT32 filterNumber, UINT32 handle)
  1531. {
  1532. KB_OSPMsgNode message;
  1533. T_SubTableFilter *filter;
  1534. INT32 i;
  1536. filter = &SISubTable[subTableID].filter[filterNumber];
  1538. filter->tableIDExt = filter->data.tableIDExt;
  1540. for(i = 0; i < SI_NO_PMT_TABLES; i++)
  1541. {
  1542. if(l_pstCurrPmtPara[i]->nUsedFlag == 1 &&
  1543.    l_pstCurrPmtPara[i]->nSvcNO == filter->tableIDExt)
  1544. {
  1545. memset(&message, 0, sizeof(KB_OSPMsgNode));
  1546. message.Word1 = MOD_SIPSI;
  1548. if(l_pstCurrPmtPara[i]->nType & KB_SI_RECEIVE_CHANGE)
  1549. {
  1550. message.Word2 = KB_SI_MSG_PMT_CHANGE;
  1551. }
  1552. else
  1553. {
  1554. message.Word2 = KB_SI_MSG_PMT_DONE;
  1555. }
  1556. message.Word3 = (UINT32)l_pstCurrPmtPara[i]->pstPmt;
  1558. KD_DTVSendMsg(&message);
  1561. if(l_pstCurrPmtPara[i]->nType & KB_SI_RECEIVE_CHANGE)
  1562. {
  1563. l_pstCurrPmtPara[i]->nCurrVersionNumber = -1;
  1564. SISubTable[subTableID].details.tableIDExt = l_pstCurrPmtPara[i]->nSvcNO;
  1565. SISubTable[subTableID].details.PID = l_pstCurrPmtPara[i]->nProgramMapPid;
  1566. SISubTableStart(subTableID, filterNumber, filter->data.version, handle);
  1567. }
  1568. else
  1569. {
  1570. memset(l_pstCurrPmtPara[i], 0, sizeof(PMTINFO));
  1571. }
  1572. break;
  1573. }
  1574. }
  1576. }
  1578. static void SIHandleSdt(T_SubTableID subTableID, UINT32 filterNumber, UINT32 handle)
  1579. {
  1580. KB_OSPMsgNode message;
  1581. T_SubTableFilter *filter;
  1584. filter = &SISubTable[subTableID].filter[filterNumber];
  1587. filter->tableIDExt = filter->data.tableIDExt;
  1589. memset(&message, 0, sizeof(KB_OSPMsgNode));
  1590. message.Word1 = MOD_SIPSI;
  1592. if(filter->tableID == 0x42)
  1593. {
  1594. if(l_pstCurrSdtPara->nType & KB_SI_RECEIVE_CHANGE)
  1595. {
  1596. message.Word2 = KB_SI_MSG_SDT_CHANGE;
  1597. }
  1598. else
  1599. {
  1600. message.Word2 = KB_SI_MSG_SDT_DONE;
  1601. }
  1602. message.Word3 = (UINT32)l_pstCurrSdtPara->pstSdt;
  1603. message.Word4 = l_pstCurrSdtPara->nServiceNum;
  1604. }
  1605. else
  1606. {
  1607. if(l_pstCurrBatPara->nType & KB_SI_RECEIVE_CHANGE)
  1608. {
  1609. message.Word2 = KB_SI_MSG_BAT_CHANGE;
  1610. }
  1611. else
  1612. {
  1613. message.Word2 = KB_SI_MSG_BAT_DONE;
  1614. }
  1615. message.Word3 = (UINT32)l_pstCurrBatPara->pstBat;
  1616. message.Word4 = l_pstCurrBatPara->nBatNumber;
  1617. }
  1619. KD_DTVSendMsg(&message);
  1622. if(filter->tableID == 0x42)
  1623. {
  1624. if(l_pstCurrSdtPara->nType & KB_SI_RECEIVE_CHANGE)
  1625. {
  1626. l_pstCurrSdtPara->nServiceNum = 0;
  1627. l_pstCurrSdtPara->nCurrVersionNumber = -1;
  1628. SISubTable[SDTSubTableID].details.tableID = 0x42;
  1629. SISubTable[SDTSubTableID].details.tableIDExt = -1;
  1630. SISubTableStart(subTableID, filterNumber, filter->data.version, handle);
  1631. }
  1632. else
  1633. {
  1634. memset(l_pstCurrSdtPara, 0, sizeof(SDTINFO));
  1635. }
  1636. }
  1637. else
  1638. {
  1639. if(l_pstCurrBatPara->nType & KB_SI_RECEIVE_CHANGE)
  1640. {
  1641. l_pstCurrBatPara->nCurrVersionNumber = -1;
  1642. l_pstCurrBatPara->nBatNumber = 0;
  1643. SISubTable[SDTSubTableID].details.tableID = 0x4A;
  1644. //J_SI_Print("sipsi rec bat:::[%d]n",l_pstCurrBatPara->nBouquetId);
  1645. SISubTable[SDTSubTableID].details.tableIDExt = l_pstCurrBatPara->nBouquetId;
  1646. SISubTableStart(subTableID, filterNumber, filter->data.version, handle);
  1647. }
  1648. else
  1649. {
  1650. memset(l_pstCurrBatPara, 0, sizeof(BATINFO));
  1651. }
  1652. }
  1654. }
  1656. static void SIHandleEit(T_SubTableID subTableID, UINT32 filterNumber, UINT32 handle)
  1657. {
  1658. KB_OSPMsgNode message;
  1659. T_SubTableFilter *filter;
  1660. int nIsMulti = 0;
  1661.     int i, nCurrentNo;
  1663. filter = &SISubTable[subTableID].filter[filterNumber];        
  1665. if(filter->subTableID == 0x50 && filter->tableIDExt == -1)
  1666. nIsMulti = 1;
  1668. if(filterNumber < KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT)
  1669. {
  1670.         for (i = 0; i < KB_SI_EIT_SCHEDULE_SERVICE_COUNT; i++)
  1671.      {        
  1672.      if(l_pstCurrEinSchInfoPara[i]->handle == filter->handle)
  1673.      {
  1674.                 nCurrentNo = i;
  1675.      break;
  1676.      }
  1677.      }
  1678.         
  1679.         if (i >= KB_SI_EIT_SCHEDULE_SERVICE_COUNT)
  1680.         {
  1681.          return;
  1682.         }
  1683.     
  1684. filter->tableIDExt = filter->data.tableIDExt;
  1685. memset(&message, 0, sizeof(KB_OSPMsgNode));
  1686. message.Word1 = MOD_SIPSI;
  1687. if(nIsMulti)
  1688. {
  1689. message.Word2 = KB_SI_MSG_EIT_SCHEDULE_DONE;
  1690. message.Word3 = (UINT32)l_pstCurrMultiEinSchInfoPara->pstEinSchInfo;
  1691. KD_DTVSendMsg(&message);
  1692. memset(l_pstCurrMultiEinSchInfoPara, 0, sizeof(MULTEITSCHINFO));
  1693. }
  1694. else
  1695. {
  1696. message.Word2 = KB_SI_MSG_EIT_SCHEDULE_DONE;
  1697. message.Word3 = (UINT32)l_pstCurrEinSchInfoPara[nCurrentNo]->pstEinSchInfo;
  1698.              message.Word4 = l_pstCurrEinSchInfoPara[nCurrentNo]->nSvcID;
  1699. KD_DTVSendMsg(&message);
  1700. memset(l_pstCurrEinSchInfoPara[nCurrentNo], 0, sizeof(EITSCHINFO));
  1701. }
  1702. }
  1703. else
  1704. {                 
  1705.         if (filterNumber >= SI_EIT_SCHEDULE_SHIFT_FILTER_START_NUMBER
  1706.             && filterNumber < SI_EIT_SCHEDULE_SHIFT_FILTER_END_NUMBER)
  1707.         {
  1708.             for (i = 0; i < SI_NO_EIT_SCHEDULE_TIME_SHIFT_FILTERS; i++)
  1709.          {        
  1710.          if(gptCurrSchShiftPara[i]->handle == filter->handle)
  1711.          {
  1712.                     nCurrentNo = i;
  1713.          break;
  1714.          }
  1715.          }
  1716.             
  1717.             if (i >= SI_NO_EIT_SCHEDULE_TIME_SHIFT_FILTERS)
  1718.             {
  1719.              return;
  1720.             }
  1721.         
  1722.             memset(&message, 0, sizeof(KB_OSPMsgNode));
  1723.      message.Word1 = MOD_SIPSI;
  1724. message.Word2 = KB_SI_MSG_EIT_SCHEDULE_DONE;
  1725. message.Word3 = (UINT32)gptCurrSchShiftPara[nCurrentNo]->ptTimeShift;
  1726.             
  1727.             KD_DTVSendMsg(&message);
  1728.         }
  1729.         else
  1730.         {
  1731.      for(i = 0; i < SI_NO_EIT_PF_FILTERS; i++)
  1732.      {
  1733.      if(l_pstCurrEitPFPara[i]->nUsedFlag == 1 &&
  1734.         l_pstCurrEitPFPara[i]->nSvcID == filter->data.tableIDExt
  1735.         && l_pstCurrEitPFPara[i]->nTableId == filter->tableID)
  1736.      {
  1737.      filter->tableIDExt = filter->data.tableIDExt;
  1738.     
  1739.      memset(&message, 0, sizeof(KB_OSPMsgNode));
  1740.      message.Word1 = MOD_SIPSI;
  1741.      if(l_pstCurrEitPFPara[i]->nType & KB_SI_RECEIVE_CHANGE)
  1742.      {
  1743.      message.Word2 = KB_SI_MSG_EIT_PF_CHANGE;
  1744.      }
  1745.      else
  1746.      {
  1747.      message.Word2 = KB_SI_MSG_EIT_PF_DONE;
  1748.      }
  1749.      message.Word3 = (UINT32)l_pstCurrEitPFPara[i]->pstEitPresent;
  1750.      message.Word4 = (UINT32)l_pstCurrEitPFPara[i]->pstEitFollow;
  1752.      KD_DTVSendMsg(&message);
  1754.      if(l_pstCurrEitPFPara[i]->nType & KB_SI_RECEIVE_CHANGE)
  1755.      {
  1756.      l_pstCurrEitPFPara[i]->nCurrVersionNumber = -1;
  1757.      SISubTable[EITSubTableID].details.tableID = l_pstCurrEitPFPara[i]->nTableId;
  1758.      SISubTable[EITSubTableID].details.tableIDExt = l_pstCurrEitPFPara[i]->nSvcID;
  1759.      SISubTableStart(subTableID, filterNumber, filter->data.version, handle);
  1760.      }
  1761.      else
  1762.      {
  1763.      memset(l_pstCurrEitPFPara[i], 0, sizeof(EITPFINFO));
  1764.      }
  1766.      break;
  1767.      }
  1768.      }
  1769.         }
  1770. }
  1772. }
  1774. static void SIHandleCat(T_SubTableID subTableID, UINT32 filterNumber, UINT32 handle)
  1775. {
  1776. KB_OSPMsgNode message;
  1777. T_SubTableFilter *filter;
  1780. filter = &SISubTable[subTableID].filter[filterNumber];
  1783. filter->tableIDExt = filter->data.tableIDExt;
  1785. memset(&message, 0, sizeof(KB_OSPMsgNode));
  1786. message.Word1 = MOD_SIPSI;
  1787. if(l_pstCurrCatPara->nType & KB_SI_RECEIVE_CHANGE)
  1788. {
  1789. message.Word2 = KB_SI_MSG_CAT_CHANGE;
  1790. }
  1791. else
  1792. {
  1793. message.Word2 = KB_SI_MSG_CAT_DONE;
  1794. }
  1795. message.Word3 = (UINT32)l_pstCurrCatPara->pstCat;
  1797. KD_DTVSendMsg(&message);
  1799. if(l_pstCurrCatPara->nType & KB_SI_RECEIVE_CHANGE)
  1800. {
  1801. l_pstCurrCatPara->nCurrVersionNumber = -1;
  1802. SISubTableStart(subTableID, filterNumber, filter->data.version, handle);
  1803. }
  1804. else
  1805. {
  1806. memset(l_pstCurrCatPara, 0, sizeof(CATINFO));
  1807. }
  1809. }
  1811. static INT32 SIHandlePatTimeout(UINT32 filterID)
  1812. {
  1813. KB_OSPMsgNode message;
  1815. SISubTableStop(PATSubTableID);
  1817. memset(&message, 0, sizeof(KB_OSPMsgNode));
  1818. message.Word1 = MOD_SIPSI;
  1819. message.Word2 = KB_SI_MSG_PAT_TIMEOUT;
  1820. KD_DTVSendMsg(&message);
  1821. memset(l_pstCurrPatPara, 0, sizeof(PATINFO));
  1823. return -1;
  1824. }
  1826. static INT32 SIHandleNitTimeout(UINT32 filterID)
  1827. {
  1828. KB_OSPMsgNode message;
  1831. SISubTableStop(NITSubTableID);
  1833. memset(&message, 0, sizeof(KB_OSPMsgNode));
  1834. message.Word1 = MOD_SIPSI;
  1835. message.Word2 = KB_SI_MSG_NIT_TIMEOUT;
  1836. KD_DTVSendMsg(&message);
  1838. memset(l_pstCurrNitPara, 0, sizeof(NITINFO));
  1841. return -1;
  1842. }
  1844. static INT32 SIHandlePmtTimeout(UINT32 filterID)
  1845. {
  1846. KB_OSPMsgNode message;
  1847. INT32 i;
  1850. SIFilterStop(SISubTable[SIFilters[filterID].subTableID].details.channelID, &SIFilters[filterID]);
  1852. memset(&message, 0, sizeof(KB_OSPMsgNode));
  1853. message.Word1 = MOD_SIPSI;
  1854. message.Word2 = KB_SI_MSG_PMT_TIMEOUT;
  1855. message.Word3 = SIFilters[filterID].tableIDExt;
  1856. KD_DTVSendMsg(&message);
  1858. for(i = 0; i < SI_NO_PMT_TABLES; i++)
  1859. {
  1860. if(l_pstCurrPmtPara[i]->nUsedFlag == 1 &&
  1861.    l_pstCurrPmtPara[i]->nSvcNO == SIFilters[filterID].tableIDExt)
  1862. {
  1863. memset(l_pstCurrPmtPara[i], 0, sizeof(PMTINFO));
  1864. break;
  1865. }
  1866. }
  1868. return -1;
  1869. }
  1871. static INT32 SIHandleSdtTimeout(UINT32 filterID)
  1872. {
  1873. KB_OSPMsgNode message;
  1875. SIFilterStop(SISubTable[SDTSubTableID].details.channelID, &SIFilters[filterID]);
  1877. memset(&message, 0, sizeof(KB_OSPMsgNode));
  1878. message.Word1 = MOD_SIPSI;
  1879. if(SIFilters[filterID].tableID == 0x42 /* SDT */)
  1880. {
  1881. message.Word2 = KB_SI_MSG_SDT_TIMEOUT;
  1882. }
  1883. else
  1884. {
  1885. message.Word2 = KB_SI_MSG_BAT_TIMEOUT;
  1886. message.Word3 = SIFilters[filterID].tableIDExt;
  1887. }
  1889. KD_DTVSendMsg(&message);
  1891. if(SIFilters[filterID].tableID == 0x42 /* SDT */)
  1892. {
  1893. memset(l_pstCurrSdtPara, 0, sizeof(SDTINFO));
  1894. }
  1895. else
  1896. {
  1897. memset(l_pstCurrBatPara, 0, sizeof(BATINFO));
  1898. }
  1900. return -1;
  1901. }
  1903. static INT32 SIHandleEitTimeout(UINT32 filterID)
  1904. {
  1905. KB_OSPMsgNode message;
  1906. INT32 i, nCurrentNo, filterNumber;
  1907.     T_SubTableFilter *filter;
  1909.     filter = &SIFilters[filterID];      
  1910.     
  1911. if(SIFilters[filterID].tableID == 0x4E || SIFilters[filterID].tableID == 0x4F)
  1912. {
  1913. SIFilterStop(SISubTable[EITSubTableID].details.channelID, &SIFilters[filterID]);       
  1914.         SIFilters[filterID].used = FALSE;
  1915. }
  1916. else
  1917. {        
  1919.         if (filterNumber >= SI_EIT_SCHEDULE_SHIFT_FILTER_START_NUMBER
  1920.             && filterNumber < SI_EIT_SCHEDULE_SHIFT_FILTER_END_NUMBER)
  1921.         {
  1922.             for (i = 0; i < SI_NO_EIT_SCHEDULE_TIME_SHIFT_FILTERS; i++)
  1923.          {        
  1924.          if(gptCurrSchShiftPara[i]->handle == filter->handle)
  1925.          {
  1926.                     nCurrentNo = i;
  1927.          break;
  1928.          }
  1929.          }
  1930.             
  1931.             if (i >= SI_NO_EIT_SCHEDULE_TIME_SHIFT_FILTERS)
  1932.             {
  1933.              return -1;
  1934.             }
  1936.             memset(gptCurrSchShiftPara[i], 0, sizeof(T_EIT_SCHEDULE_TIME_SHIFT_PARA));
  1937.         
  1938.             SIFilterStop(SISubTable[EITSubTableID].details.channelID, &SIFilters[filterID]);
  1939.             SISubTable[EITSubTableID].filter[filterNumber].used = FALSE;
  1940.         }
  1941.         else
  1942.         {    
  1943.             if (filter->tableID == 0x50)
  1944.             {
  1945.                 SIFilterStop(SISubTable[EITSubTableID].details.channelID, filter);
  1946.                 SIFilters[filterID].used = FALSE;
  1947.                 filterNumber = SIGetFilterNum(EITSubTableID, 0x51, filter->tableIDExt);
  1948.                 if (filterNumber != 0xFFFFFFFF)
  1949.                 {
  1950.                     SIFilterStop(SISubTable[EITSubTableID].details.channelID, 
  1951.                                  &SISubTable[EITSubTableID].filter[filterNumber]);
  1952.                     SISubTable[EITSubTableID].filter[filterNumber].used = FALSE;
  1953.                 }
  1954.             }
  1955.             else
  1956.             {
  1957.                 if (filter->tableID == 0x51)
  1958.                 {
  1959.                     SIFilterStop(SISubTable[EITSubTableID].details.channelID, filter);
  1960.                     SIFilters[filterID].used = FALSE;
  1961.                     filterNumber = SIGetFilterNum(EITSubTableID, 0x50, filter->tableIDExt);
  1962.                     if (filterNumber != 0xFFFFFFFF)
  1963.                     {
  1964.                         SIFilterStop(SISubTable[EITSubTableID].details.channelID, 
  1965.                                      &SISubTable[EITSubTableID].filter[filterNumber]);
  1966.                         SISubTable[EITSubTableID].filter[filterNumber].used = FALSE;
  1967.                     }
  1968.                 }
  1969.             }
  1970.         }
  1971. }
  1973. memset(&message, 0, sizeof(KB_OSPMsgNode));
  1974. message.Word1 = MOD_SIPSI;
  1975. if(SIFilters[filterID].tableID == 0x4E || SIFilters[filterID].tableID == 0x4F)
  1976. {
  1977. message.Word2 = KB_SI_MSG_EIT_PF_TIMEOUT;
  1978. }
  1979. else
  1980. {
  1981. message.Word2 = KB_SI_MSG_EIT_SCHEDULE_TIMEOUT;
  1982. }
  1983. message.Word4 = SIFilters[filterID].tableIDExt;
  1984.     
  1985. KD_DTVSendMsg(&message);
  1987. if(SIFilters[filterID].tableID == 0x4E || SIFilters[filterID].tableID == 0x4F)
  1988. {
  1989. for(i = 0; i < SI_NO_EIT_PF_FILTERS; i++)
  1990. {
  1991. if(l_pstCurrEitPFPara[i]->nUsedFlag == 1 &&
  1992.    l_pstCurrEitPFPara[i]->nSvcID == SIFilters[filterID].tableIDExt
  1993.    && l_pstCurrEitPFPara[i]->nTableId == SIFilters[filterID].tableID)
  1994. {
  1995. memset(l_pstCurrEitPFPara[i], 0, sizeof(EITPFINFO));
  1996. }
  1997. }
  1998. }
  1999. else
  2000. {
  2001.         for (i = 0; i < KB_SI_EIT_SCHEDULE_SERVICE_COUNT; i++)
  2002.      {        
  2003.      if(l_pstCurrEinSchInfoPara[i]->handle == filter->handle)
  2004.      {
  2005.                 nCurrentNo = i;
  2006.      break;
  2007.      }
  2008.      }
  2010.         if (i >= KB_SI_EIT_SCHEDULE_SERVICE_COUNT)
  2011.         {
  2012.             return -1;
  2013.         }
  2014. memset(l_pstCurrEinSchInfoPara[nCurrentNo], 0, sizeof(EITSCHINFO));
  2015. }
  2017. return -1;
  2018. }
  2020. static INT32 SIHandleTdtTimeout(UINT32 filterID)
  2021. {
  2022. KB_OSPMsgNode message;
  2025. SIFilterStop(SISubTable[TDTSubTableID].details.channelID, &SIFilters[filterID]);
  2027. memset(&message, 0, sizeof(KB_OSPMsgNode));
  2028. message.Word1 = MOD_SIPSI;
  2029. message.Word2 = KB_SI_MSG_TDT_TIMEOUT;
  2030. KD_DTVSendMsg(&message);
  2032. memset(l_pstCurrTdtPara, 0, sizeof(TDTINFO));
  2034. return -1;
  2035. }
  2037. static INT32 SIHandleTotTimeout(UINT32 filterID)
  2038. {
  2039. KB_OSPMsgNode message;
  2041. SIFilterStop(SISubTable[TOTSubTableID].details.channelID, &SIFilters[filterID]);
  2043. memset(&message, 0, sizeof(KB_OSPMsgNode));
  2044. message.Word1 = MOD_SIPSI;
  2045. message.Word2 = KB_SI_MSG_TOT_TIMEOUT;
  2046. KD_DTVSendMsg(&message);
  2048. memset(l_pstCurrTotPara, 0, sizeof(TOTINFO));
  2050. return -1;
  2051. }
  2053. static INT32 SIHandleCatTimeout(UINT32 filterID)
  2054. {
  2055. KB_OSPMsgNode message;
  2057. SISubTableStop(CATSubTableID);
  2059. memset(&message, 0, sizeof(KB_OSPMsgNode));
  2060. message.Word1 = MOD_SIPSI;
  2061. message.Word2 = KB_SI_MSG_CAT_TIMEOUT;
  2062. KD_DTVSendMsg(&message);
  2064. memset(l_pstCurrCatPara, 0, sizeof(CATINFO));
  2066. return -1;
  2067. }
  2069. static INT32 SIStopMultEitSCH()
  2070. {
  2072. SIFilterStop(SISubTable[EITSubTableID].details.channelID, &(SISubTable[EITSubTableID].filter[0]));
  2073. memset(l_pstCurrMultiEinSchInfoPara, 0, sizeof(MULTEITSCHINFO));
  2075. return 0;
  2076. }
  2078. static INT32 SIGetMultEitSCH()
  2079. {
  2080. memcpy(l_pstCurrMultiEinSchInfoPara, l_pstPendingMultiEinSchInfoPara, sizeof(MULTEITSCHINFO));
  2082. l_pstCurrMultiEinSchInfoPara->nCurrVersionNumber = -1;
  2083. l_pstCurrMultiEinSchInfoPara->nUsedFlag = 1;
  2085. memset(l_pstCurrMultiEinSchInfoPara->pstEinSchInfo, 0, 
  2086. l_pstCurrMultiEinSchInfoPara->nServiceNum * sizeof(KB_SIMultiEitSchedule));
  2089. //SISubTable[EITSubTableID].details.noFilters = 1;
  2090. SISubTable[EITSubTableID].details.tableID = 0x50;
  2091. SISubTable[EITSubTableID].details.timeout = 20;
  2092. SISubTable[EITSubTableID].details.tableIDExt = -1;//l_pstCurrMultiEinSchInfoPara->nSvcID[0];//-1;//l_pstCurrMultiEinSchInfoPara->nSvcID;
  2093. SISubTableStart(EITSubTableID, 0, -1, l_pstCurrMultiEinSchInfoPara->handle);
  2095. return 0;
  2096. }
  2098. static void SIParseEit(MepgData *section)
  2099. {
  2101. T_SubTableFilter *filter;
  2102. UINT8 *pInData;
  2103. INT32 dataLength;
  2104. KB_SIEitPF* pstEitPF;
  2105.     KB_SINVODEitPF *ptEitNvod;
  2106.     
  2107. UINT16 table_id;
  2108. UINT16 table_id_extension;
  2109. UINT8 version_number;
  2110. UINT8 section_number;
  2111. UINT8 last_section_number;
  2112. UINT16 serID;
  2114. UINT16 transport_stream_id;
  2115. UINT8 segment_last_section_number;
  2117. int i;
  2118. INT32 nCurrNo = 0;
  2119. time_t start_time; 
  2120. KB_SIEitPF siEitPF;
  2121. UINT32 duration;
  2122. int nvod=0;
  2124. int   circle;
  2125.     INT32 filterNumber;
  2126. //INT16 section_length = 0;
  2127. //KB_OSPMsgNode message;
  2128.         
  2129. memset(&siEitPF,0,sizeof(KB_SIEitPF));
  2130. filter = &SISubTable[section->subTableID].filter[section->filterNumber];
  2132. pInData = section->data;
  2133. dataLength = section->length;
  2135. table_id = pInData[0];
  2136. table_id_extension = (UINT16)(pInData[3] * 0x100 + pInData[4]); //ServiceID
  2138. serID = pInData[3] << 8 | pInData[4];
  2140.     if (table_id == 0x50 || table_id == 0x51 || table_id == 0x60 || table_id == 0x61)
  2141.     {
  2142.         SISectionEinSchInfo(section);
  2143.         SIFreeSectionData(section);
  2144.         return;
  2145.     }
  2147. version_number = (UINT8)((pInData[5] & 0x3E) >> 1);
  2148. section_number = pInData[6];
  2149. last_section_number = pInData[7];
  2150. transport_stream_id = pInData[8] << 8 | pInData[9];
  2152. pInData += 8;
  2153. dataLength -= 8;
  2155. if( dataLength <= 0 )
  2156. {
  2157. SIFreeSectionData(section);
  2158. return;
  2159. }
  2161. segment_last_section_number = pInData[4];
  2163. pInData += 6;
  2164. dataLength -= 6;
  2166. if(table_id == 0x4E || table_id == 0x4f)
  2167. {
  2168.     int descriptors_loop_length;
  2169.         
  2170. for(i = 0; i < SI_NO_EIT_PF_FILTERS; i++)
  2171. {
  2172. if(l_pstCurrEitPFPara[i]->handle == filter->handle &&
  2173.    l_pstCurrEitPFPara[i]->nUsedFlag == 1 &&
  2174.    l_pstCurrEitPFPara[i]->nSvcID == table_id_extension
  2175.    && l_pstCurrEitPFPara[i]->nTableId == table_id)
  2176. {
  2177. nCurrNo = i;
  2178. break;
  2179. }
  2180. }
  2181. if(i == SI_NO_EIT_PF_FILTERS)
  2182. {
  2183. SIFreeSectionData(section);
  2184. return;
  2185. }
  2187. if(section_number == 0)
  2188. {
  2189. pstEitPF = l_pstCurrEitPFPara[nCurrNo]->pstEitPresent;
  2190. }
  2191. else if(section_number == 1)
  2192. {
  2193. pstEitPF = l_pstCurrEitPFPara[nCurrNo]->pstEitFollow;
  2194. }
  2195. else
  2196. {
  2197. pstEitPF = NULL;
  2198. }
  2200. if(pstEitPF == NULL)
  2201. {
  2202. SIFreeSectionData(section);
  2203. return;
  2204. }
  2205.         
  2206.         pstEitPF->NVODEventNum = 0;
  2207. pstEitPF->service_id = table_id_extension;
  2209. if(l_pstCurrEitPFPara[nCurrNo]->nCurrVersionNumber == -1)
  2210. {
  2211. l_pstCurrEitPFPara[nCurrNo]->nCurrVersionNumber = version_number;
  2212. }
  2213. else if(l_pstCurrEitPFPara[nCurrNo]->nCurrVersionNumber != version_number)
  2214. {
  2215. filterNumber = section->filterNumber;
  2216. SIFreeSectionData(section);
  2217. l_pstCurrEitPFPara[nCurrNo]->handle = l_nHandle++;
  2218. l_pstCurrEitPFPara[nCurrNo]->nCurrVersionNumber = -1;
  2219. SISubTable[EITSubTableID].details.tableID = l_pstCurrEitPFPara[nCurrNo]->nTableId;
  2220. SISubTable[EITSubTableID].details.tableIDExt = l_pstCurrEitPFPara[nCurrNo]->nSvcID;
  2222.             SISubTable[EITSubTableID].details.timeout = J_SI_EIT_PF_TIMEOUT;
  2223.             
  2224. SISubTableStart(EITSubTableID, filterNumber, l_pstCurrEitPFPara[nCurrNo]->nVersionNumber, l_pstCurrEitPFPara[nCurrNo]->handle);
  2225. return;
  2226. }
  2228. pstEitPF->version_number = version_number;
  2230. circle = 0;
  2231. while(dataLength > 0)
  2232. {
  2233. siEitPF.event_id = (UINT16)(pInData[0] * 0x100 + pInData[1]);
  2234. siEitPF.service_id = serID;
  2236. pInData += 2;
  2237. dataLength -= 2;
  2239. if(pInData[0] != 0xFF || pInData[1] != 0xFF || pInData[2] != 0xFF
  2240. || pInData[3] != 0xFF || pInData[4] != 0xFF)
  2241. {
  2242. SIParseTime(pInData, &start_time);
  2243. }
  2244. else
  2245. {
  2246. nvod = 1;
  2247. start_time = 0;
  2248. }
  2249. pInData += 5;
  2250. dataLength -= 5;
  2251. siEitPF.start_time = start_time;
  2253. SIParseDuration(pInData, &duration);
  2254. siEitPF.duration = duration;
  2256. pInData += 3;
  2257. dataLength -= 3;
  2259. if(circle == 0)
  2260. {
  2261. pstEitPF->running_status = (UINT8)(pInData[0] >> 5);
  2262. pstEitPF->free_CA_mode = (UINT8)((pInData[0] & 0x10) >> 4);
  2263. }
  2264. descriptors_loop_length = (pInData[0] & 0x0F) * 0x100  + pInData[1];
  2265. pInData += 2;
  2266. dataLength -= 2;
  2268. SIEitPFDescs(pInData, descriptors_loop_length, &siEitPF);
  2269. if(circle == 0)
  2270. {
  2271.                 siEitPF.NVODEvent = pstEitPF->NVODEvent;
  2272.                 siEitPF.NVODEventNum = pstEitPF->NVODEventNum;
  2273. memcpy(pstEitPF,&siEitPF,sizeof(KB_SIEitPF));
  2274. }
  2276. if (nvod == 1 
  2277.                 && pstEitPF->NVODEvent != NULL 
  2278.                 && pstEitPF->NVODEventNum < KB_SI_EIT_PF_MAX_NVOD_EVENT_NUMBER)
  2279. {
  2280.                 ptEitNvod = pstEitPF->NVODEvent + pstEitPF->NVODEventNum;
  2281.                 ptEitNvod->service_id = siEitPF.service_id;
  2282.                 ptEitNvod->event_id = siEitPF.event_id;
  2283.                 ptEitNvod->duration = siEitPF.duration;
  2284.                 strcpy((char*)ptEitNvod->chinese.event_name, (char*)siEitPF.chinese.event_name);
  2285.                 strcpy((char*)ptEitNvod->chinese.text, (char*)siEitPF.chinese.text);
  2286.                 pstEitPF->NVODEventNum++;
  2287. }
  2289. pInData += descriptors_loop_length;
  2290. dataLength -= (INT32)descriptors_loop_length;
  2291. circle ++;
  2292. }
  2293. }
  2294.     
  2295.     SIFreeSectionData(section);
  2296.     return;
  2297. }
  2299. void SIToLower(char* str)
  2300. {
  2301. short len;
  2302. short i;
  2304. #ifdef _DBG_
  2305. if (str == NULL)
  2306. {
  2307. J_SI_Print("[SIPSI] The string is emptyn");
  2308. return;
  2309. }
  2310. #endif
  2311. len = strlen(str);
  2312. for (i = 0; i < len; i++)
  2313. {
  2314. str[i] = tolower(str[i]);
  2315. }
  2316. }
  2318. static void SIGetSection(UINT32 nChannelID, UINT8 *pData, UINT32 nDataLength)
  2319. {
  2320. T_DMX_Notify notify;
  2322.     if (pData == NULL)
  2323.     {
  2324.         return;
  2325.     }
  2326.     
  2327. /* Parpare the notify header */
  2328. memset(&notify, 0, sizeof(notify));
  2329. notify.whichChannel = nChannelID;
  2331. /* Call SIHandleNewSection first */
  2332. if(!SIHandleNewSection(pData, &notify))
  2333. {
  2334.         KB_DmxUnlock(nChannelID, pData);
  2335.         
  2336. return;
  2337. }
  2339. /* Check length */
  2340. if((notify.copyLength + notify.skipLength) > nDataLength)
  2341. {
  2342. J_SI_Print("nSI: Copy section length too large");
  2343. }
  2345. /*
  2346. ** When parameters ara illegal, call the SISectionCopied so to
  2347. ** release buffers.
  2348. */
  2349. if(!notify.outputBuffer || !notify.copyLength || ((notify.copyLength + notify.skipLength) > nDataLength))
  2350. {        
  2351. SISectionCopied(DMX_ERROR, pData, nDataLength, notify.tag);
  2352. return;
  2353. }
  2355.     notify.outputBuffer = pData + notify.skipLength;
  2356. SISectionCopied(DMX_AVAILABLE, notify.outputBuffer, notify.copyLength, notify.tag);
  2358. }
  2360. static int KD_DTVSendMsg(KB_OSPMsgNode * pMsg)
  2361. {
  2362.     if (pMsg->Word2 >= KB_SI_MSG_EIT_PF_DONE 
  2363.         && pMsg->Word2 <= KB_SI_MSG_EIT_SCHEDULE_TIMEOUT)
  2364.     {
  2365.         if (gptSiEitCallbackFunction && pMsg->Word2 != KB_SI_MSG_EIT_SCHEDULE_EVENT_DONE)
  2366.         {
  2367.             gptSiEitCallbackFunction(pMsg);
  2368.         }
  2369.     }
  2370.     else
  2371.     {
  2372.         if (gptSiCallbackFunction)
  2373.         {
  2374.             gptSiCallbackFunction(pMsg);
  2375.         }
  2376.     }
  2377.     return 0;
  2378. }
  2380. KB_SICallbackFunc KB_SICallback(KB_SICallbackFunc callback)
  2381. {
  2382.     KB_SICallbackFunc ptPrvCallback;
  2384.     ptPrvCallback = gptSiCallbackFunction;
  2385. gptSiCallbackFunction = callback;
  2387.     return ptPrvCallback;
  2388. }
  2390. KB_SICallbackFunc KB_SIRegisterEitCallBack(KB_SICallbackFunc callback)
  2391. {
  2392.     KB_SICallbackFunc ptPrvCallback;
  2394.     ptPrvCallback = gptSiEitCallbackFunction;
  2395.     gptSiEitCallbackFunction = callback;
  2397.     return ptPrvCallback;
  2398. }
  2400. static void SiEitSetup(T_SubTableID subTableID, UINT32 filterNumber, 
  2401.                           INT32 version, UINT32 handle)
  2402. {
  2403.     UINT32 i;
  2404. T_SubTableFilter *filterDetails;
  2405. UINT32 channelID;
  2406. UINT32 filterID;
  2407. UINT8 filterMask[16];
  2408. UINT8 filterMatch[16];
  2409. UINT32 filterNegate;
  2411.     memset(filterMatch, 0, sizeof(filterMatch));
  2412.     memset(filterMask, 0, sizeof(filterMask));
  2413.     
  2414. filterDetails = &SISubTable[subTableID].filter[filterNumber];
  2415.     filterID = filterDetails->filterID;
  2416. channelID = SISubTable[subTableID].details.channelID;
  2417.     
  2418. filterDetails->data.total = -1;
  2419. filterDetails->data.received = 0;
  2421. for(i = 0; i < SI_MAX_SECTION_PER_TABLE; i++)
  2422. {
  2423. if( (filterDetails->data.sectionData[i] != SI_SECTION_NOT_RECEIVED) &&
  2424. (filterDetails->data.sectionData[i] != SI_SECTION_RECEIVED) )
  2425. {
  2426. SIFreeSectionData(filterDetails->data.sectionData[i]);
  2427. }
  2428. filterDetails->data.sectionData[i] = SI_SECTION_NOT_RECEIVED;
  2429. }
  2431. filterDetails->tableID = SISubTable[subTableID].details.tableID;
  2432. filterDetails->tableIDExt = SISubTable[subTableID].details.tableIDExt;
  2433. filterDetails->version = version;
  2434. filterDetails->timeout = SISubTable[subTableID].details.timeout;
  2435. filterDetails->handle = handle;
  2437. filterDetails->enabled = TRUE;     
  2438.        filterDetails->used    = TRUE;
  2440.     if (SISubTable[subTableID].details.channelStarted != TRUE)
  2441.     {
  2442.         KB_DmxAssociateFilter(channelID, filterID);        
  2443.     KB_DmxSetFilter(filterID, filterMatch, filterMask, filterNegate);
  2444.     }
  2445. }
  2447. static UINT32 SIGetFilterNum(T_SubTableID subTableID, INT32 tableId,
  2448.                                      INT32 tableIDExt)
  2449. {
  2450.     UINT32 i, nNumber;
  2452.     nNumber = 0XFFFFFFFF;
  2453.     for (i = 0; i < SISubTable[subTableID].details.noFilters; i++)
  2454.     {
  2455.         if (SISubTable[subTableID].filter[i].tableID == tableId
  2456.             && SISubTable[subTableID].filter[i].tableIDExt == tableIDExt)
  2457.         {
  2458.             nNumber = i;
  2459.             break;
  2460.         }
  2461.     }
  2463.     return nNumber;
  2464. }
  2466. INT32 KB_SIGetEITSCHShift(INT32 nSvcID, 
  2467.                                    KB_SIEitTs eTs,
  2468.                                    KB_SIEitSchTimeShift *ptSchShift)
  2469. {
  2470.     int i;
  2471.     KB_OSPMsgNode message;
  2472.     INT16 nTableId;
  2473.     
  2475.     nTableId = 0;
  2476.     switch (eTs)
  2477.     {
  2478.     case KB_SI_EIT_CURRENT_TS:
  2479.         nTableId = 0x50;
  2480.         break;
  2482.         case KB_SI_EIT_CURRENT_TS_FOR_0x51_table:
  2483.             nTableId = 0x51;
  2484.             break;
  2486.     case KB_SI_EIT_OTHER_TS:
  2487.         nTableId = 0x60;
  2488.         break;
  2489.         
  2490.     case KB_SI_EIT_OTHER_TS_FOR_0x61_table:
  2491.         nTableId = 0x61;
  2492.         break;
  2493.         
  2494.     default:
  2495.         break;
  2496.     }
  2498.     for (i = 0; i < SI_NO_EIT_SCHEDULE_TIME_SHIFT_FILTERS; i++)
  2499.     {
  2500.         if (gptPendingSchShiftPara[i]->nUsedFlag == 0)
  2501.         {
  2502.             memset(gptPendingSchShiftPara[i], 0, sizeof(T_EIT_SCHEDULE_TIME_SHIFT_PARA));
  2503.             gptPendingSchShiftPara[i]->nUsedFlag = 1;
  2504.          gptPendingSchShiftPara[i]->handle = l_nHandle++;
  2505.          gptPendingSchShiftPara[i]->nSvcID = nSvcID;
  2506.             gptPendingSchShiftPara[i]->nTableId[0] = nTableId;
  2507.         gptPendingSchShiftPara[i]->ptTimeShift = ptSchShift;
  2509.             memset(&message, 0, sizeof(KB_OSPMsgNode));
  2510.         message.Word1 = MSG_SI_EIT_SCHEDULE_SHIFT_RECEIVE;
  2511.             message.Word2 = i;
  2512.             break;
  2513.         }
  2514.     }
  2515.     
  2516.     if(i >= SI_NO_EIT_SCHEDULE_TIME_SHIFT_FILTERS)
  2517. {
  2518. return KB_SI_ERR_TOO_MANY_PROGRAMS;
  2519. }
  2521. if(KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&message) != Ret_OK)
  2522. {
  2523. return KB_SI_ERR_SEND_MESSAGE;
  2524. }
  2525. return 0;
  2526. }
  2528. INT32 KB_SIStopEitSCHShift(INT32 nSvcID, KB_SIEitTs eTs)
  2529. {
  2530.     //KB_OSPMsgNode message;
  2531.     INT32 nTableId;
  2532.     
  2533.     nTableId = 0;
  2535.     //对于nSvcID为KB_SI_STOP_ALL的情况，ets类型对后面的处理无影响
  2536.     switch (eTs)
  2537.     {
  2538.     case KB_SI_EIT_CURRENT_TS:
  2539.         nTableId = 0x50;
  2540.         break;
  2542.         case KB_SI_EIT_CURRENT_TS_FOR_0x51_table:
  2543.             nTableId = 0x51;
  2544.             break;
  2546.     case KB_SI_EIT_OTHER_TS:
  2547.         nTableId = 0x60;
  2548.         break;
  2549.         
  2550.         case KB_SI_EIT_OTHER_TS_FOR_0x61_table:
  2551.             nTableId = 0x61;
  2552.             break; 
  2553.             
  2554.     default:
  2555.         break;
  2556.     }
  2558.     SIStopEitSCHShiftEX(nSvcID, nTableId);
  2559. return 0;
  2560. }
  2562. static void SIGetEitSCHShift(UINT32 nPendingNo, UINT32 nSvcID)
  2563. {
  2564.     int i, nCurrentParaNum;
  2565.     KB_OSPMsgNode msgNode;
  2566.     
  2567.     for (i = 0; i < SI_NO_EIT_SCHEDULE_TIME_SHIFT_FILTERS; i++)
  2568. {        
  2569. if(gptCurrSchShiftPara[i]->nUsedFlag == 0)
  2570. {
  2571. memcpy(gptCurrSchShiftPara[i], gptPendingSchShiftPara[nPendingNo], sizeof(T_EIT_SCHEDULE_TIME_SHIFT_PARA));
  2573. gptCurrSchShiftPara[i]->nCurrVersionNumber = -1;
  2574. gptCurrSchShiftPara[i]->nUsedFlag = 1;
  2575.   
  2576.             gptCurrSchShiftPara[i]->ptTimeShift->num = 0;
  2577.             gptCurrSchShiftPara[i]->ptTimeShift->service_id = (UINT16)gptCurrSchShiftPara[i]->nSvcID;
  2578.             nCurrentParaNum = i;           
  2579. break;
  2580. }
  2581. }
  2583.     if (i >= SI_NO_EIT_SCHEDULE_TIME_SHIFT_FILTERS)
  2584.     {
  2585.         memset(&msgNode, 0, sizeof(KB_OSPMsgNode));
  2586. msgNode.Word1 = MSG_SI_EIT_SCHEDULE_SHIFT_RECEIVE;
  2587. msgNode.Word2 = nPendingNo;
  2589. KB_OSPMsgSend(l_nQueueId, (KB_OSPMsgNode *)&msgNode);
  2590.         return;
  2591.     }
  2593.     /* 把当前pending结构清零 */
  2594.     memset(gptPendingSchShiftPara[nPendingNo], 0, sizeof(T_EIT_SCHEDULE_TIME_SHIFT_PARA));   
  2595.    
  2596.     for (i = SI_EIT_SCHEDULE_SHIFT_FILTER_START_NUMBER; i < SI_EIT_SCHEDULE_SHIFT_FILTER_END_NUMBER; i++)
  2597.     {
  2598.         if (SISubTable[EITSubTableID].filter[i].used == FALSE)
  2599.         {            
  2600.             SISubTable[EITSubTableID].details.tableID = gptCurrSchShiftPara[nCurrentParaNum]->nTableId[0];
  2601.             SISubTable[EITSubTableID].details.timeout = J_SI_EIT_SCHEDULE_TIMEOUT;
  2602.             SISubTable[EITSubTableID].details.tableIDExt = gptCurrSchShiftPara[nCurrentParaNum]->nSvcID;
  2603.             //DBGPrint("SIGetEitSCHShift i = %d nSvcID = 0x%xn", i, gptCurrSchShiftPara[nCurrentParaNum]->nSvcID);
  2604.         SISubTableStart(EITSubTableID, i, -1, gptCurrSchShiftPara[nCurrentParaNum]->handle);
  2605.             break;
  2606.         }
  2607.     }
  2609.     return;
  2610. }
  2612. static INT32 SIStopEitSCHShift(INT32 nSvcID, INT32 nTableId)
  2613. {
  2614. INT32 i;
  2616. if(nSvcID == -1)
  2617. {
  2618. for(i = 0; i < SI_NO_EIT_SCHEDULE_TIME_SHIFT_FILTERS; i++)
  2619. {
  2620. SIFilterStop(SISubTable[EITSubTableID].details.channelID, &(SISubTable[EITSubTableID].filter[SI_EIT_SCHEDULE_SHIFT_FILTER_START_NUMBER + i]));
  2621. memset(gptCurrSchShiftPara[i], 0, sizeof(T_EIT_SCHEDULE_TIME_SHIFT_PARA));
  2622. }
  2623. }
  2624. else
  2625. {
  2626. for(i = 0; i < SI_NO_EIT_SCHEDULE_TIME_SHIFT_FILTERS; i++)
  2627. {
  2628. if(gptCurrSchShiftPara[i]->nUsedFlag == 1 &&
  2629.    gptCurrSchShiftPara[i]->nSvcID == nSvcID
  2630.    && gptCurrSchShiftPara[i]->nTableId[0] == nTableId)
  2631. { 
  2632. memset(gptCurrSchShiftPara[i], 0, sizeof(T_EIT_SCHEDULE_TIME_SHIFT_PARA));
  2633. break;
  2634. }
  2635. }
  2637. for(i = 0; i < SI_NO_EIT_SCHEDULE_TIME_SHIFT_FILTERS; i++)
  2638. {
  2639. if(SISubTable[EITSubTableID].filter[SI_EIT_SCHEDULE_SHIFT_FILTER_START_NUMBER + i].enabled == TRUE &&
  2640.    SISubTable[EITSubTableID].filter[SI_EIT_SCHEDULE_SHIFT_FILTER_START_NUMBER + i].tableIDExt == nSvcID)
  2641. {
  2642. SIFilterStop(SISubTable[EITSubTableID].details.channelID, &(SISubTable[EITSubTableID].filter[SI_EIT_SCHEDULE_SHIFT_FILTER_START_NUMBER + i]));
  2643. break;
  2644. }
  2645. }
  2646. }
  2648. return 0;
  2649. }
  2651. static INT32 SIStopEitSCHShiftEX(INT32 nSvcID, INT32 nTableId)
  2652. {
  2653. INT32 i;
  2655. if(nSvcID == -1)
  2656. {
  2657. for(i = 0; i < SI_NO_EIT_SCHEDULE_TIME_SHIFT_FILTERS; i++)
  2658. {
  2659. SIFilterStop(SISubTable[EITSubTableID].details.channelID, &(SISubTable[EITSubTableID].filter[SI_EIT_SCHEDULE_SHIFT_FILTER_START_NUMBER + i]));
  2660.             SISubTable[EITSubTableID].filter[SI_EIT_SCHEDULE_SHIFT_FILTER_START_NUMBER + i].used = FALSE;
  2661. memset(gptCurrSchShiftPara[i], 0, sizeof(T_EIT_SCHEDULE_TIME_SHIFT_PARA));
  2662. }
  2663. }
  2664. else
  2665. {
  2666. for(i = 0; i < SI_NO_EIT_SCHEDULE_TIME_SHIFT_FILTERS; i++)
  2667. {
  2668. if(gptCurrSchShiftPara[i]->nUsedFlag == 1 &&
  2669.    gptCurrSchShiftPara[i]->nSvcID == nSvcID
  2670.    && gptCurrSchShiftPara[i]->nTableId[0] == nTableId)
  2671. { 
  2672. memset(gptCurrSchShiftPara[i], 0, sizeof(T_EIT_SCHEDULE_TIME_SHIFT_PARA));
  2673. break;
  2674. }
  2675. }
  2677. for(i = 0; i < SI_NO_EIT_SCHEDULE_TIME_SHIFT_FILTERS; i++)
  2678. {
  2679. if(SISubTable[EITSubTableID].filter[SI_EIT_SCHEDULE_SHIFT_FILTER_START_NUMBER + i].enabled == TRUE &&
  2680.    SISubTable[EITSubTableID].filter[SI_EIT_SCHEDULE_SHIFT_FILTER_START_NUMBER + i].tableIDExt == nSvcID)
  2681. {
  2682. SIFilterStop(SISubTable[EITSubTableID].details.channelID, &(SISubTable[EITSubTableID].filter[SI_EIT_SCHEDULE_SHIFT_FILTER_START_NUMBER + i]));
  2683.                 SISubTable[EITSubTableID].filter[SI_EIT_SCHEDULE_SHIFT_FILTER_START_NUMBER + i].used = FALSE;
  2684. break;
  2685. }
  2686. }
  2687. }
  2689. return 0;
  2690. }
  2693. static void SISectionEinSchInfo(MepgData *section)
  2694. {
  2695.     T_SubTableFilter *filter;
  2696. UINT8 *pInData;
  2697. INT32 dataLength;
  2699.     KB_SIEitSchEvent stEvent;
  2700. KB_SIEitSchEvent* pstEvent;
  2701.     UINT8 text[KB_SI_MAX_EVENT_TEXT_LEN + 1]; 
  2702. KB_SIEitSch* pstEinSchInfo;
  2704. UINT16 table_id;
  2705. UINT16 table_id_extension;
  2706. UINT8 version_number;
  2707. UINT8 section_number;
  2708. UINT8 last_section_number;
  2709. UINT16 serID;
  2711. UINT16 transport_stream_id;
  2712. UINT8 segment_last_section_number;
  2713.     
  2714. int i;
  2716. INT32 nWday;
  2718. INT32 nOneDayFinishedFlag = 0;
  2719. int   nCurrentNo, nStartPos;
  2721. int nIsMulti = 0;
  2722. int nServicePos = 0;
  2724.     INT32 filterNumber;    
  2725.     KB_OSPMsgNode message;
  2726.     
  2727.     if (section->filterNumber >= KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT && section->filterNumber < KB_SI_EIT_SCHEDULE_SOFT_FILTER_COUNT + SI_NO_EIT_PF_FILTERS)
  2728.     {
  2729.         J_SI_Print("SISectionEinSchInfo filter not match!n");
  2730.         return;
  2731.     }
  2732.     else
  2733.     {
  2734.         if (section->filterNumber >= SI_EIT_SCHEDULE_SHIFT_FILTER_START_NUMBER && section->filterNumber < SI_EIT_SCHEDULE_SHIFT_FILTER_END_NUMBER)
  2735.         {
  2736.             SISectionEinSchInfoShift(section);
  2737.             return;
  2738.         }
  2739.     }
  2740.     stEvent.chinese.text = text;
  2741.     
  2742.     pstEvent = &stEvent;
  2743.         
  2744.     pInData = section->data;
  2745. dataLength = section->length;
  2747. table_id = pInData[0];
  2748. table_id_extension = (UINT16)(pInData[3] * 0x100 + pInData[4]); //ServiceID
  2750. serID = pInData[3] << 8 | pInData[4];
  2751.     
  2752. version_number = (UINT8)((pInData[5] & 0x3E) >> 1);
  2753. section_number = pInData[6];
  2754. last_section_number = pInData[7];
  2755. transport_stream_id = pInData[8] << 8 | pInData[9];
  2757.     filter = &SISubTable[section->subTableID].filter[section->filterNumber];
  2758.     for (i = 0; i < KB_SI_EIT_SCHEDULE_SERVICE_COUNT; i++)
  2759. {        
  2760. //是否需要匹配tableid、servid，校验usedflag?
  2761. if(l_pstCurrEinSchInfoPara[i]->handle == filter->handle)
  2762. {
  2763.             nCurrentNo = i;
  2764. break;
  2765. }
  2766. }
  2768.     /* 无法找到匹配的指针，直接返回错误。 */
  2769.     if (i >= KB_SI_EIT_SCHEDULE_SERVICE_COUNT)
  2770.     {
  2771.         return;
  2772.     }
  2774.   l_pstCurrEinSchInfoPara[nCurrentNo]->nReceivedFlag[section_number + (table_id - 0x50) * 256] = 1;
  2776. /*
  2777. ** Skip past the standard SI Table header (contains tableID, section Length, etc)
  2778. */
  2779. pInData += 8;
  2780. dataLength -= 8;
  2782. if( dataLength <= 0 || (table_id == 0x51 && section_number >= 192)/* 不存储第八天 */)
  2783. {
  2784. return;
  2785. }
  2787. segment_last_section_number = pInData[4];
  2789.     if(section_number == segment_last_section_number)
  2790. {
  2791. for(i = (int)section_number + 1; i < ((int)segment_last_section_number / 8 + 1)* 8; i++)
  2792. {
  2793. if(nIsMulti)
  2794. l_pstCurrMultiEinSchInfoPara->nReceivedFlag[nServicePos][i + (table_id - 0x50) * 256] = 1;
  2795. else
  2796. l_pstCurrEinSchInfoPara[nCurrentNo]->nReceivedFlag[i + (table_id - 0x50) * 256] = 1;
  2797. }
  2798. }
  2800. nStartPos = (int)section_number / 64 * 64 + ((int)table_id - 0x50) * 256;
  2802. nOneDayFinishedFlag = 1;
  2803. for(i = nStartPos; i < nStartPos + 64 && i <= (int)last_section_number + (table_id - 0x50) * 256; i++)
  2804. {
  2805. if(l_pstCurrEinSchInfoPara[nCurrentNo]->nReceivedFlag[i] != 1)
  2806. {
  2807. break;
  2808. }
  2809. }
  2811. pInData += 6;
  2812. dataLength -= 6;
  2813.    
  2814. if(l_pstCurrEinSchInfoPara[nCurrentNo]->handle != filter->handle)
  2815. {
  2816. return;
  2817. }
  2819. if(l_pstCurrEinSchInfoPara[nCurrentNo]->nCurrVersionNumber == -1)
  2820. {
  2821. l_pstCurrEinSchInfoPara[nCurrentNo]->nCurrVersionNumber = version_number;
  2822. l_pstCurrEinSchInfoPara[nCurrentNo]->pstEinSchInfo->num = 0;
  2824. }
  2825. else if(l_pstCurrEinSchInfoPara[nCurrentNo]->nCurrVersionNumber != version_number)
  2826. {
  2827. l_pstCurrEinSchInfoPara[nCurrentNo]->handle = l_nHandle++;
  2828. l_pstCurrEinSchInfoPara[nCurrentNo]->nCurrVersionNumber = -1;
  2829. l_pstCurrEinSchInfoPara[nCurrentNo]->nTableDone[0] = 0;
  2830. l_pstCurrEinSchInfoPara[nCurrentNo]->nTableDone[1] = 0;
  2833.         SISubTable[EITSubTableID].details.timeout = J_SI_EIT_SCHEDULE_TIMEOUT;
  2834.         if (filter->tableID == 0x50)
  2835.         {                    
  2836.             SISubTable[EITSubTableID].details.tableID = 0x50;
  2837.             SISubTable[EITSubTableID].details.tableIDExt = l_pstCurrEinSchInfoPara[nCurrentNo]->nSvcID;
  2838.             SISubTableStart(EITSubTableID, filter->filterNumber, -1, 
  2839.                             l_pstCurrEinSchInfoPara[nCurrentNo]->handle);
  2840.             
  2841.             filterNumber = SIGetFilterNum(EITSubTableID, 0x51, filter->tableIDExt);
  2842.             if (filterNumber != 0xFFFFFFFF)
  2843.             {
  2844.                 SISubTable[EITSubTableID].details.tableID = 0x51;
  2845.                 SISubTable[EITSubTableID].details.tableIDExt = l_pstCurrEinSchInfoPara[nCurrentNo]->nSvcID;
  2846.                 SISubTableStart(EITSubTableID, filterNumber, -1, 
  2847.                                 l_pstCurrEinSchInfoPara[nCurrentNo]->handle);
  2848.             }
  2849.         }
  2850.         else
  2851.         {
  2852.             SISubTable[EITSubTableID].details.tableID = 0x51;
  2853.             SISubTable[EITSubTableID].details.tableIDExt = l_pstCurrEinSchInfoPara[nCurrentNo]->nSvcID;
  2854.             SISubTableStart(EITSubTableID, filter->filterNumber, -1, 
  2855.                             l_pstCurrEinSchInfoPara[nCurrentNo]->handle);
  2856.             
  2857.             filterNumber = SIGetFilterNum(EITSubTableID, 0x50, filter->tableIDExt);
  2858.             if (filterNumber != 0xFFFFFFFF)
  2859.             {
  2860.                 SISubTable[EITSubTableID].details.tableID = 0x50;
  2861.                 SISubTable[EITSubTableID].details.tableIDExt = l_pstCurrEinSchInfoPara[nCurrentNo]->nSvcID;
  2862.                 SISubTableStart(EITSubTableID, filterNumber, -1, 
  2863.                                 l_pstCurrEinSchInfoPara[nCurrentNo]->handle);
  2864.             }
  2865.         }
  2866. return ;
  2868.     }
  2870. pstEinSchInfo = l_pstCurrEinSchInfoPara[nCurrentNo]->pstEinSchInfo;
  2871. if(pstEinSchInfo == NULL)
  2872. {
  2873. return;
  2874. }
  2875. pstEinSchInfo->service_id = table_id_extension;
  2877. nWday = -1;
  2878. while(dataLength > 0)
  2879. {
  2880. int descriptors_loop_length;
  2882. memset(pstEvent, 0, sizeof(KB_SIEitSchEvent));
  2883.         memset(text, 0, sizeof(text));
  2884.         pstEvent->chinese.text = text;
  2885. pstEvent->event_id = (UINT16)(pInData[0] * 0x100 + pInData[1]);
  2887. pInData += 2;
  2888. dataLength -= 2;
  2890. if(pInData[0] != 0xFF || pInData[1] != 0xFF || pInData[2] != 0xFF
  2891. || pInData[3] != 0xFF || pInData[4] != 0xFF)
  2892. {
  2893.             SIParseTime(pInData, &(pstEvent->start_time));
  2894. }
  2895. else
  2896. {
  2897. pstEvent->start_time = 0;
  2898. }
  2899. pInData += 5;
  2900. dataLength -= 5;
  2902. SIParseDuration(pInData, &(pstEvent->duration));
  2904. pInData += 3;
  2905. dataLength -= 3;
  2907. pstEvent->running_status = (UINT8)(pInData[0] >> 5);
  2908. pstEvent->free_CA_mode = (UINT8)((pInData[0] & 0x10) >> 4);
  2910. descriptors_loop_length = (pInData[0] & 0x0F) * 0x100  + pInData[1];
  2911. pInData += 2;
  2912. dataLength -= 2;
  2914. SIEitSCHDescs(pInData, descriptors_loop_length, pstEvent);
  2916. pInData += descriptors_loop_length;
  2917. dataLength -= descriptors_loop_length;
  2919. if(pstEinSchInfo->num < KB_SI_MAX_EVENT_NUM_PER_SERVICE)
  2920. {
  2921.     KB_SIEitSchEvent *pTmp = pstEinSchInfo->ptEvent + pstEinSchInfo->num;
  2922.     pTmp->chinese.text = (UINT8 *)KB_OSPMalloc(KB_SI_MAX_EVENT_TEXT_LEN + 1);
  2923.             
  2924.             if (NULL != pTmp->chinese.text)
  2925.             {
  2926.                 pTmp->event_id       = pstEvent->event_id;
  2927.                 pTmp->start_time     = pstEvent->start_time;
  2928.                 pTmp->duration       = pstEvent->duration;
  2929.                 pTmp->running_status = pstEvent->running_status;
  2930.                 pTmp->free_CA_mode   = pstEvent->free_CA_mode;
  2931.                 pTmp->content_level1 = pstEvent->content_level1;
  2932.                 pTmp->reference_service_id  = pstEvent->reference_service_id;
  2933.                 pTmp->reference_event_id    = pstEvent->reference_event_id;
  2934.                 memcpy(pTmp->chinese.event_name, 
  2935.                         pstEvent->chinese.event_name, 
  2936.                         KB_SI_MAX_EVENT_NAME_LEN + 1);
  2937.         memcpy(pTmp->chinese.text, 
  2938.                         pstEvent->chinese.text, 
  2939.                         KB_SI_MAX_EVENT_TEXT_LEN + 1);
  2940.             }
  2941.             else
  2942.             {
  2943.                 printf("nSISectionEinSchInfo::KB_OSPMalloc text fail!n");
  2944.             }
  2945. pstEinSchInfo->num++;
  2946. }
  2948. }
  2950.     memset(&message, 0, sizeof(KB_OSPMsgNode));
  2951. message.Word1 = MOD_SIPSI;
  2952. message.Word2 = (UINT32)(KB_SI_MSG_EIT_SCHEDULE_EVENT_DONE);
  2953.     message.Word3 = (UINT32)pstEinSchInfo;
  2954. message.Word4 = (UINT32)pstEinSchInfo->num;
  2955. //KD_DTVSendMsg(&message);            
  2957.     return;
  2958. }
  2960. static void SISectionEinSchInfoShift(MepgData *section)
  2961. {
  2962. UINT8 *pInData;
  2963. INT32 dataLength;
  2965.     KB_SIEitSchTimeShiftNode tShiftEvent;
  2966. KB_SIEitSchTimeShift      *ptShift;
  2967.     KB_SIEitSchTimeShiftNode *ptShiftEvent;
  2969. UINT16 table_id;
  2970. UINT16 table_id_extension;
  2971. UINT8 version_number;
  2972. UINT8 section_number;
  2973. UINT8 last_section_number;
  2974. UINT16 serID;
  2976. UINT16 transport_stream_id;
  2977. UINT8 segment_last_section_number;
  2978.     
  2979. int i;
  2980.     
  2981.     INT32 nCurrParaNum;    
  2982.     KB_OSPMsgNode message;
  2984.     ptShiftEvent = &tShiftEvent;
  2985.     
  2986.     pInData = section->data;
  2987. dataLength = section->length;
  2989. table_id = pInData[0];
  2990. table_id_extension = (UINT16)(pInData[3] * 0x100 + pInData[4]); //ServiceID
  2992. serID = pInData[3] << 8 | pInData[4];
  2994.     for(i = 0; i < SI_NO_EIT_SCHEDULE_TIME_SHIFT_FILTERS; i ++)
  2995. {
  2996. if(gptCurrSchShiftPara[i]->nSvcID == table_id_extension)
  2997. {
  2998.             nCurrParaNum = i;   
  2999.             ptShift = gptCurrSchShiftPara[i]->ptTimeShift;            
  3000. break;
  3001. }
  3003.         if (i >= SI_NO_EIT_SCHEDULE_TIME_SHIFT_FILTERS)
  3004.         {
  3005.             return;
  3006.         }
  3007. }
  3008.     
  3009. version_number = (UINT8)((pInData[5] & 0x3E) >> 1);
  3010. section_number = pInData[6];
  3011. last_section_number = pInData[7];
  3012. transport_stream_id = pInData[8] << 8 | pInData[9];
  3013.     
  3014.     if (gptCurrSchShiftPara[nCurrParaNum]->nReceivedFlag[section_number] == 1)
  3015.     {
  3016.         return;
  3017.     }
  3018.     else
  3019.     {
  3020.         gptCurrSchShiftPara[nCurrParaNum]->nReceivedFlag[section_number] = 1;
  3021.     }
  3023. pInData += 8;
  3024. dataLength -= 8;
  3026. if( dataLength <= 0)
  3027. {
  3028. return;
  3029. }
  3031. segment_last_section_number = pInData[4];
  3033. if(section_number == segment_last_section_number)
  3034. {
  3035. for(i = (int)section_number + 1; i < ((int)segment_last_section_number / 8 + 1)* 8; i++)
  3036. {
  3037. gptCurrSchShiftPara[nCurrParaNum]->nReceivedFlag[i] = 1;
  3038. }
  3039. }
  3040.     
  3041. pInData += 6;
  3042. dataLength -= 6;
  3043.    
  3044. {
  3045. while(dataLength > 0)
  3046. {
  3047. int descriptors_loop_length;
  3049. memset(ptShiftEvent, 0, sizeof(KB_SIEitSchTimeShiftNode));
  3050. ptShiftEvent->event_id = (UINT16)(pInData[0] * 0x100 + pInData[1]);
  3053. pInData += 2;
  3054. dataLength -= 2;
  3056. if(pInData[0] != 0xFF || pInData[1] != 0xFF || pInData[2] != 0xFF
  3057. || pInData[3] != 0xFF || pInData[4] != 0xFF)
  3058. {
  3059.     SIParseTime(pInData, &(ptShiftEvent->start_time));
  3060. }
  3061. else
  3062. {
  3063.                 ptShiftEvent->start_time = 0;
  3064. }
  3065. pInData += 5;
  3066. dataLength -= 5;
  3067.             
  3068. pInData += 3;
  3069. dataLength -= 3;
  3071. descriptors_loop_length = (pInData[0] & 0x0F) * 0x100  + pInData[1];
  3072. pInData += 2;
  3073. dataLength -= 2;
  3075.             SISectionEITScheduleShiftDescriptors(pInData, descriptors_loop_length, ptShiftEvent);
  3077. pInData += descriptors_loop_length;
  3078. dataLength -= descriptors_loop_length;
  3080. {
  3081.                 if(ptShift->num < KB_SI_MAX_SHIFT_EVENT_NUM_PER_SERVICE)
  3082. {
  3083. memcpy(ptShift->ptTimeShift+ ptShift->num, ptShiftEvent, sizeof(KB_SIEitSchTimeShiftNode));
  3084. ptShift->num++;
  3085. }
  3086. }
  3087. }
  3088.         
  3089.         memset(&message, 0, sizeof(KB_OSPMsgNode));
  3090. message.Word1 = MOD_SIPSI;
  3091. message.Word2 = (UINT32)(KB_SI_MSG_EIT_SCHEDULE_EVENT_DONE);
  3092.         message.Word3 = (UINT32)ptShift;
  3093. message.Word4 = (UINT32)ptShift->num;
  3095. //KD_DTVSendMsg(&message);            
  3096. }
  3098.     
  3099. }
  3101. static void SISectionEITScheduleShiftDescriptors(UINT8* pInData, 
  3102.                                                  INT32 dataLen, 
  3103.                                                  KB_SIEitSchTimeShiftNode* pstEvent)
  3104. {
  3105. UINT8 *data;
  3106. UINT32 tag;
  3107. UINT8 length;
  3108. UINT8 event_name_length;
  3109. UINT8 text_length;
  3111. while(dataLen > 0)
  3112. {
  3113. tag = *pInData++;
  3114. length = *pInData++;
  3116. data = pInData;
  3117. pInData += length;
  3118. dataLen -= ((INT32)length + 2);
  3120. if(length == 0)
  3121. continue;
  3123. switch(tag)
  3124. {
  3125. case KB_FILTER_SI_SHORT_EVENT:
  3126. data += 3;
  3127. event_name_length = *data++;
  3128. data += event_name_length;
  3129. text_length = *data++;
  3130. //data += text_length;
  3131. break;
  3132. case KB_FILTER_SI_STUFFING:
  3133. case KB_FILTER_SI_LINKAGE:
  3134. case KB_FILTER_SI_EXTENDED_EVENT:
  3135. case KB_FILTER_SI_COMPONENT:
  3136. case KB_FILTER_SI_CA_IDENTIFIER:
  3137. case KB_FILTER_SI_CONTENT:
  3138. case KB_FILTER_SI_PARENTAL_RATING:
  3139. case KB_FILTER_SI_TELEPHONE:
  3140. case KB_FILTER_SI_MULTILINGUAL_COMPONENT:
  3141. case KB_FILTER_SI_PRIVATE_DATA_SPECIFIER:
  3142. case KB_FILTER_SI_SHORT_SMOOTHING_BUFFER:
  3143. case KB_FILTER_SI_DATA_BROADCAST:
  3144. break;
  3145. case KB_FILTER_SI_TIME_SHIFTED_EVENT:
  3146. pstEvent->reference_service_id = (data[0] << 8) | (data[1]);
  3147.             data += 2;
  3148. pstEvent->reference_event_id = (data[0] << 8) | (data[1]);
  3149.             
  3150. break;
  3152. default:
  3153. break;
  3154. }
  3155. }
  3156. }
  3158. /* EOF */