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

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

DVD

开发平台：

C/C++

epg.c：源码内容
  1. #include <string.h>
  3. #include "epg.h"
  4. #include "sipsi.h"
  5. #include "db.h"
  7. #include "appltype.h"
  8. #include "dmd.h"
  10. #include "timeclk.h"
  11. #include "db.h"
  13. #include "kb_machblue_client_task.h"
  14. #include "Machblue_defines.h"
  15. #include "Avplay.h"
  16. #include "Nvod.h"
  18. extern KB_DMDTunerParameters CurrentSignal;
  20. static UINT32 gEPGTaskID;
  21. static UINT32 gEpgQueID;
  23. static KB_EPGSchInfo gEpgSchInfo[KB_EPG_MAX_TS_NUM];
  25. static KB_SIEitSch       gEpgSCH[KB_EPG_MAX_TS_NUM][KB_EPG_MAX_SCH];
  27. static KB_EpgPFInfo gEpgPFInfo;
  28. static KB_SIEitPF *gpEpgPF;
  30. static INT32 gEpgToNvod;
  31. static KB_SIEitSchEvent *gEpgSCHEvent;
  32. static time_t epgTime;
  34. static KB_EPGCallBackFunc gpEpgCallback;
  36. static void EpgMsgDisPatch(KB_OSPMsgNode *pInMsg);
  39. static INT32 EpgGetFreeSchNum(UINT32 TsNum);
  40. static INT32 KD_EPGGetSchInfoNumByServiceId(UINT32 TsNum, UINT32 nSvcID);
  41. static void  EpgHandlerEvent(KB_OSPMsgNode *pInMsg);
  42. static INT32 EpgResetPF(void);
  43. static INT32 EpgResetSCH(UINT32 nTsNum, INT32 nSrvNum);
  44. static void  EpgResetUnusedSCH(UINT32 TsNum,
  45.                                    INT32  nSvcCnt, 
  46.                                            UINT32 *pSvcID);
  47. static void  EpgHandleSI(KB_OSPMsgNode *pInMsg);
  48. static INT32 EpgSortSCH(UINT32  TsNum,
  49.                           KB_SIEitSch *pSCHInfo, 
  50.                                      INT32 nEvtNum);
  51. static void  KD_EpgTask(void);
  53. static void QuickSort(KB_SIEitSchEvent *pList, int nLow, int nHigh);
  54. static int Partition(KB_SIEitSchEvent *pList, int nLow, int nHigh);
  55. static UINT8 KB_EPG_GetFreeEpgSchInfo(void);
  57. extern mb_error_t KB_mb_PF_Update(KB_SIEitPF *Cur_ptEitPf,KB_SIEitPF *Fol_ptEitPf);
  58. extern void KB_MENUTranslateMsg(KB_OSPMsgNode* pInMsg);
  61. INT32 KB_EPGGetEITPF(UINT32 nSvcID)
  62. {
  63.     //KB_OSPMsgNode msgNode;
  64.     
  65.     EpgResetPF();    
  67.     KB_SIGetEitPF(nSvcID , KB_SI_EIT_CURRENT_TS,
  68.                       gEpgPFInfo.pPresent,
  69.                       gEpgPFInfo.pFollow, 
  70.                       KB_SI_RECEIVE_ONCE, 
  71.                       -1);
  72.     gEpgPFInfo.nEnable    = FALSE;
  73.     gEpgPFInfo.nSvcID = nSvcID;
  74.     gEpgPFInfo.nState     = EPG_Receiving;
  75.     return RETOK;
  76. }
  78. INT32 KB_EPGGetSch(UINT32 nTsId, INT32 nSvcCnt, UINT32 *pSvcID)
  79. {
  80.     UINT32 i, nNumber, CurrentTsNum;
  81.     KB_OSPMsgNode msgNode;
  82.     
  83.     if (nSvcCnt < 0 || nSvcCnt > KB_EPG_MAX_SCH
  84.         || pSvcID == NULL)
  85.     {
  86.         return RETFAIL3;
  87.     }
  89.     CurrentTsNum = KB_EPG_GetCurrentTsNum();
  90.     if (CurrentTsNum >= KB_EPG_MAX_TS_NUM)
  91.     {
  92.         printf("nKB_EPGGetSch::Serious Error.CurrentTs is NULLn");
  93.         return RETFAIL3;
  94.     }
  95.     
  96.     if (nTsId != gEpgSchInfo[CurrentTsNum].nTsId)
  97.     {
  98.         printf("nKB_EPGGetSch::Serious Error.Ts(%d) is not CurrentTsn", nTsId);
  99.         return RETFAIL3;
  100.     }
  101.     else
  102.     {
  103.         //printf("nKB_EPGGetSch::CurrentTs(%d) search! SrvNum(%d)n", 
  104.         //        nTsId, nSvcCnt);
  105.         EpgResetUnusedSCH(CurrentTsNum, nSvcCnt, pSvcID);
  106.     }
  107.     
  108.     for (i = 0; i < nSvcCnt; i++)
  109.     {
  110.         nNumber = KD_EPGGetSchInfoNumByServiceId(CurrentTsNum, *(pSvcID + i));
  111.         if (nNumber != 0xFFFFFFFF)
  112.         {
  113.             switch (gEpgSchInfo[CurrentTsNum].nSchInfo[nNumber].nState)
  114.             {
  115.             case EPG_Empty:
  116.             case EPG_Timeout:
  117.                 KB_SIGetEitSCH(*(pSvcID + i),
  118.                                     gEpgSchInfo[CurrentTsNum].nSchInfo[nNumber].pDataStruct);
  119.                 gEpgSchInfo[CurrentTsNum].nSchInfo[nNumber].nEnable    = FALSE;
  120.                 gEpgSchInfo[CurrentTsNum].nSchInfo[nNumber].nState     = EPG_Receiving;
  121.                 gEpgSchInfo[CurrentTsNum].nSchInfo[nNumber].nSvcID = *(pSvcID + i);
  122.                 break;            
  124.             case EPG_Recieved: 
  125.                 msgNode.Word1 = J_EPG_MODULE;
  126.                 msgNode.Word2 = EPG_MSG_SCHEDULE_DONE;
  127.                 msgNode.Word3 = (UINT32)(gEpgSchInfo[CurrentTsNum].nSchInfo[nNumber].pDataStruct);
  128.                 msgNode.Word4 = *(pSvcID + i);
  129.                 if (gpEpgCallback)
  130.                 {
  131.                     gpEpgCallback(&msgNode);
  132.                 }   
  133.                 break;
  135.             case EPG_Receiving:
  136.                 KB_SIStopEitSCH(*(pSvcID + i)); 
  137.                 KB_SIGetEitSCH(*(pSvcID + i),
  138.                                  gEpgSchInfo[CurrentTsNum].nSchInfo[nNumber].pDataStruct);
  139.                 gEpgSchInfo[CurrentTsNum].nSchInfo[nNumber].nEnable    = FALSE;
  140.                 gEpgSchInfo[CurrentTsNum].nSchInfo[nNumber].nState     = EPG_Receiving;
  141.                 gEpgSchInfo[CurrentTsNum].nSchInfo[nNumber].nSvcID = *(pSvcID + i);
  142.                 break;
  143.                 
  144.             default:
  145.                 break;
  146.             }
  147.         }
  148.         else
  149.         {
  150.             nNumber = (UINT32)EpgGetFreeSchNum(CurrentTsNum);
  151.             if (nNumber != 0xFFFFFFFF)
  152.             {
  153.                 //printf("nKB_EPGGetSch::start to search ShiftSrv(%d)n", 
  154.                         //*(pSvcID + i));
  155.                 KB_SIGetEitSCH(*(pSvcID + i),
  156.                                  gEpgSchInfo[CurrentTsNum].nSchInfo[nNumber].pDataStruct);  
  157.                 gEpgSchInfo[CurrentTsNum].nSchInfo[nNumber].nEnable = FALSE;
  158.                 gEpgSchInfo[CurrentTsNum].nSchInfo[nNumber].nState  = EPG_Receiving;
  159.                 gEpgSchInfo[CurrentTsNum].nSchInfo[nNumber].nSvcID = *(pSvcID + i);
  160.             }
  161.         }
  162.     }
  163.     return RETOK;
  164. }
  166. KB_EPGCallBackFunc KB_EpgCallBack(KB_EPGCallBackFunc callback)
  167. {
  168.     KB_EPGCallBackFunc ptPreCallback;
  170.     ptPreCallback  = gpEpgCallback;
  171.     gpEpgCallback = callback;
  173.     return ptPreCallback;
  174. }
  176. INT32 KB_EPGStopAllEITPF(void)
  177. {
  178.     KB_SIStopEitPF(KB_SI_STOP_ALL, KB_SI_EIT_CURRENT_TS);    
  179.         
  180.     EpgResetPF();
  182.     return RETOK;
  183. }
  185. INT32 KB_EPGStopAllSCH()
  186. {
  187.     INT32 i, j;
  189.     KB_SIStopEitSCH(KB_SI_STOP_ALL);
  190.     
  191.     //gEpgSchInfo.nTsId = 0xFFFFFFFF;
  192.         
  193.     for (i = 0; i < KB_EPG_MAX_TS_NUM; i++)
  194.     {
  195.         for (j = 0; j < KB_EPG_MAX_SCH; j++)
  196.         {
  197.             EpgResetSCH(i, j);
  198.         }
  199.     }
  200.     return RETOK;
  201. }
  203. #if 0
  204. INT32 KB_EPGStopOneTsAllSCH(UINT32 TsNum)
  205. {
  206.     INT32 i;
  208.     KB_SIStopEitSCH(KB_SI_STOP_ALL);
  209.     
  210.     //gEpgSchInfo.nTsId = 0xFFFFFFFF;
  211.         
  212.     for (i = 0; i < KB_EPG_MAX_SCH; i++)
  213.     {
  214.         EpgResetSCH(TsNum, i);
  215.     }
  216.     
  217.     return RETOK;
  218. }
  219. #endif
  221. INT32 KD_EPGStopPF(UINT32 nSvcID)
  222. {
  223.     KB_SIStopEitPF(nSvcID, KB_SI_EIT_CURRENT_TS);            
  224.     EpgResetPF();
  225.     return RETOK;
  227. }
  229. INT32 KB_EPGStopOneSrvSCH(UINT32 TsNum, UINT32 nSvcID)
  230. {
  231.     int i;    
  232.         
  233.     if (TsNum >= KB_EPG_MAX_TS_NUM)
  234.     {
  235.         return RETFIAL1;
  236.     }
  237.         
  238.     for (i = 0; i < KB_EPG_MAX_SCH; i++)
  239.     {
  240.         if (gEpgSchInfo[TsNum].nSchInfo[i].nEnable == FALSE
  241.             && gEpgSchInfo[TsNum].nSchInfo[i].nSvcID == nSvcID)
  242.         {
  243.             KB_SIStopEitSCH(nSvcID);            
  244.             EpgResetSCH(TsNum, i);
  245.             return RETOK;
  246.         }        
  247.     }
  248.     return RETFIAL1;
  249. }
  251. INT32 KD_EPGTaskInit(void)
  252. {
  253.     int i, j;
  254.     unsigned short  PrgNO;
  255.     unsigned char   PrgType;
  256.     KB_DBPrgInfo    PrgInfo;
  257.     KB_DBChnnlInfo  ChnnlInfo;
  258.     UINT8           Track;
  259.     UINT8           Volume;
  260.     UINT8           LockFlag;
  261.     
  262.     KB_OSPQueInit("EPG", 128, &gEpgQueID);
  263.     KB_OSPTaskInit("EPG",1024 * 32,(void (*)(void*))KD_EpgTask,EPG_PRIORITY,NULL,&gEPGTaskID);
  264.     KB_SIRegisterEitCallBack(EpgHandleSI);
  265.     
  266.     gpEpgPF            = NULL;
  267.     gEpgSCHEvent = NULL;
  268.     gpEpgCallback      = NULL;
  269.     gEpgToNvod   = FALSE;
  270.     memset(gEpgSchInfo, 0, (sizeof(KB_EPGSchInfo)*KB_EPG_MAX_TS_NUM));
  271.     
  272.     gpEpgPF = KB_OSPMalloc(sizeof(KB_SIEitPF) * 2);        
  273.     if (gpEpgPF == NULL)
  274.     {
  275.         return RETFAIL2;
  276.     }
  277.     else
  278.     {
  279.         gEpgPFInfo.nTsId        = 0xFFFFFFFF;
  280.         gEpgPFInfo.nEnable      = TRUE;
  281.         gEpgPFInfo.nState       = EPG_Empty;
  282.         gEpgPFInfo.nSvcID   = 0xFFFFFFFF;
  283.         gEpgPFInfo.pPresent = gpEpgPF;
  284.         gEpgPFInfo.pFollow  = gpEpgPF+ 1;
  286.     }
  287.     
  288.     for (i = 0; i < KB_EPG_MAX_TS_NUM; i++)
  289.     {
  290.         for (j = 0; j < KB_EPG_MAX_SCH; j++)
  291.         {
  292.             gEpgSCH[i][j].service_id = 0xffff;
  293.             gEpgSCH[i][j].num        = 0xffff;
  294.             gEpgSCH[i][j].ptEvent    = NULL;
  295.         }
  296.     }
  297.     
  298.     
  299.     gEpgSCHEvent = KB_OSPMalloc(sizeof(KB_SIEitSchEvent) * KB_EPG_MAX_TS_NUM * KB_EPG_MAX_SCH * KB_SI_MAX_EVENT_NUM_PER_SERVICE);        
  300.     if (gEpgSCHEvent == NULL)
  301.     {
  302.         return RETFAIL2;
  303.     }
  304.     else
  305.     {
  306.         for (i = 0; i < KB_EPG_MAX_TS_NUM; i++)
  307.         {
  308.             gEpgSchInfo[i].nTsId = 0xFFFFFFFF;
  309.             gEpgSchInfo[i].nCurrentTsTag = FALSE;
  310.         
  311.             for (j = 0; j < KB_EPG_MAX_SCH; j++)
  312.         {   
  313.                 gEpgSchInfo[i].nSchInfo[j].nEnable      = TRUE;
  314.                 gEpgSchInfo[i].nSchInfo[j].nState       = EPG_Empty;
  315.                 gEpgSchInfo[i].nSchInfo[j].nSvcID   = 0xFFFFFFFF;
  316.                 gEpgSchInfo[i].nSchInfo[j].pDataStruct = &gEpgSCH[i][j];
  317.                 gEpgSchInfo[i].nSchInfo[j].pDataStruct->ptEvent = gEpgSCHEvent 
  318.                                                                      + i*KB_EPG_MAX_SCH*KB_SI_MAX_EVENT_NUM_PER_SERVICE
  319.                                                                      + j*KB_SI_MAX_EVENT_NUM_PER_SERVICE;
  320.         }
  321.         }
  322.         
  323.         KB_DBGetCurPrgInfo(&PrgNO, &PrgType);
  324.         KB_DBGetPrgInfo(PrgNO, 
  325.                           PrgType, 
  326.                           &PrgInfo, 
  327.                           &ChnnlInfo, 
  328.                           &Track, 
  329.                           &Volume, 
  330.                           &LockFlag);
  332.         KB_EPG_SetCurrentTsNum(ChnnlInfo.TSID);
  333.         printf("nKD_EPGTaskInit::sizeof(gEpgSchInfo)(%d), sizeof(gEpgSCH)(%d), sizeof(gEpgSCHEvent)(%d)",
  334.                 sizeof(gEpgSchInfo), sizeof(gEpgSCH), (sizeof(KB_SIEitSchEvent) * KB_EPG_MAX_TS_NUM * KB_EPG_MAX_SCH * KB_SI_MAX_EVENT_NUM_PER_SERVICE));
  335.         return RETOK;
  336.     }
  337. }
  339. static INT32 EpgGetFreeSchNum(UINT32 TsNum)
  340. {
  341.     INT32 i, nNumber;
  343.     if (TsNum >= KB_EPG_MAX_TS_NUM)
  344.     {
  345.         printf("nEpgGetFreeSchNum::serious error! input TsNum(%d) is too large.",
  346.                 TsNum);
  347.         return 0xFFFFFFFF;
  348.     }
  350.     nNumber = 0xFFFFFFFF; 
  352.     for (i = 0; i < KB_EPG_MAX_SCH; i++)
  353.     {
  354.         if (gEpgSchInfo[TsNum].nSchInfo[i].nEnable == TRUE)
  355.         {
  356.             nNumber = i;
  357.             break;
  358.         }
  359.     }
  361.     if (0xFFFFFFFF == nNumber)
  362.     {
  363.         for (i = 0; i < KB_EPG_MAX_SCH; i++)
  364.         {
  365.             EpgResetSCH(TsNum, i);
  366.         }
  368.         nNumber = 0;
  369.     }
  370.     
  371.     return nNumber;
  372. }
  374. KB_EPGDayInfo *KD_EPGGetSCH(UINT32 TsNum, INT32 nSvcID, INT32 nWeekday)
  375. {
  376. int i;
  377.     
  378.     if (TsNum >= KB_EPG_MAX_TS_NUM)
  379.     {
  380.         printf("nKD_EPGGetSCH::serious error! input TsNum(%d) is too large.",
  381.                 TsNum);
  382.         return NULL;
  383.     }
  385.     
  386. for(i=0; i<KB_EPG_MAX_SCH; i++)
  387. {        
  388. if(gEpgSchInfo[TsNum].nSchInfo[i].nSvcID == nSvcID)
  389. {
  390. return &gEpgSchInfo[TsNum].nSchInfo[i].nDayInfo[nWeekday];
  391. }
  392. }
  394.        return NULL;
  395. }
  397. static INT32 KD_EPGGetSchInfoNumByServiceId(UINT32 TsNum, UINT32 nSvcID)
  398. {
  399.     INT32 i, nNumber;
  401.     nNumber = 0xFFFFFFFF;
  403.     if (TsNum >= KB_EPG_MAX_TS_NUM)
  404.     {
  405.         printf("nKD_EPGGetSchInfoNumByServiceId::serious error! input TsNum(%d) is too large.",
  406.                 TsNum);
  407.         return 0xFFFFFFFF;
  408.     }
  409.     
  410.     for (i = 0; i < KB_EPG_MAX_SCH; i++)
  411.     {
  412.         if (gEpgSchInfo[TsNum].nSchInfo[i].nSvcID == nSvcID)
  413.         {
  414.             nNumber = i;
  415.             break;
  416.         }
  417.     }    
  419.     return nNumber;
  420. }
  422. static void EpgHandlerEvent(KB_OSPMsgNode *pInMsg)
  423. {
  424.     KB_OSPMsgNode msgNode;
  425.     KB_SIEitPF *ptEitPf;
  426.     KB_SIEitSch *ptEitSch = NULL;
  427. INT32 nNumber;
  428.     UINT32 CurrentTsNum;
  430.     CurrentTsNum = KB_EPG_GetCurrentTsNum();
  431.     if ((UINT32)(-1) == CurrentTsNum)
  432.     {
  433.         printf("nEpgHandlerEvent::CurrentTsNum ERROR!n");
  434.         return;
  435.     }
  436.     
  437.     switch (pInMsg->Word1)
  438.     {
  439.       case MOD_SIPSI:
  440.         
  441.         msgNode.Word1 = J_EPG_MODULE;
  442.         if (pInMsg->Word2 >= KB_SI_MSG_EIT_PF_DONE
  443.             && pInMsg->Word2 <= KB_SI_MSG_EIT_SCHEDULE_TIMEOUT)
  444.         {
  445.             switch (pInMsg->Word2)
  446.             {
  447.             case KB_SI_MSG_EIT_PF_DONE:
  448.                 ptEitPf = (KB_SIEitPF*)pInMsg->Word3;
  449.                 if (ptEitPf != NULL)
  450.                 {
  451.                     gEpgPFInfo.nState = EPG_Recieved;
  452.                 }
  453.                 ptEitPf = (KB_SIEitPF*)pInMsg->Word4;
  454.   KB_mb_PF_Update((KB_SIEitPF*)pInMsg->Word3,(KB_SIEitPF*)pInMsg->Word4);
  455.                 break;
  457.             case KB_SI_MSG_EIT_PF_TIMEOUT:
  458.                 ptEitPf = (KB_SIEitPF*)pInMsg->Word3;
  459.                 if (ptEitPf != NULL)
  460.                 {
  461.                   gEpgPFInfo.nState = EPG_Timeout;
  462.                 }
  463.                 break;
  464.                 
  465.             case KB_SI_MSG_EIT_SCHEDULE_EVENT_DONE:
  466.                 //EpgSortSCH((KB_SIEitSch *)pInMsg->Word3, pInMsg->Word4);
  467.                 break;
  468.                 
  469.             case KB_SI_MSG_EIT_SCHEDULE_DONE:
  470.   ptEitSch = (KB_SIEitSch*)pInMsg->Word3;
  471.                     EpgSortSCH(CurrentTsNum, ptEitSch, ptEitSch->num);
  472.                     //printf("nEpgHandlerEvent::epg_task get KB_SI_MSG_EIT_SCHEDULE_DONE, SrvId(%d), num(%d)",
  473.                            // pInMsg->Word4, ptEitSch->num);
  474.                 nNumber = KD_EPGGetSchInfoNumByServiceId(KB_EPG_GetCurrentTsNum(), 
  475.                                                                  pInMsg->Word4);
  476.                 if (nNumber != 0xFFFFFFFF)
  477.                 {                    
  478.                     gEpgSchInfo[CurrentTsNum].nSchInfo[nNumber].nState = EPG_Recieved;
  479.                 }
  480.                      {
  481. KB_OSPMsgNode movie_msg;
  483. movie_msg.Word1=KB_MOVIE_SCHEDULE_CREATE;
  484. movie_msg.Word2=pInMsg->Word4;
  485. kb_machblue_task_post(&movie_msg);
  486. }
  487.                 break;
  489.             case KB_SI_MSG_EIT_SCHEDULE_TIMEOUT:
  490.                 nNumber = KD_EPGGetSchInfoNumByServiceId(KB_EPG_GetCurrentTsNum(), 
  491.                                                                  pInMsg->Word4);
  492.                 if (nNumber != 0xFFFFFFFF)
  493.                 {
  494.                     gEpgSchInfo[CurrentTsNum].nSchInfo[nNumber].nState = EPG_Timeout;
  495.                 }
  496.                 break;
  497.                 
  498.             default:
  499.                 break;
  500.             }
  502.             if (pInMsg->Word2 != KB_SI_MSG_EIT_SCHEDULE_EVENT_DONE)
  503.             {
  504.                 msgNode.Word2 = pInMsg->Word2 - KB_SI_MSG_EIT_PF_DONE;
  505.                 msgNode.Word3 = pInMsg->Word3;
  506.                 msgNode.Word4 = pInMsg->Word4;
  507.                 //EpgMsgDisPatch
  508.                 if (gpEpgCallback)
  509.                 {
  510.                     if (EPG_MSG_SCHEDULE_DONE == msgNode.Word2)
  511.                     {
  512.                         //printf("nEpgHandlerEvent::now send EPG_MSG_SCHEDULE_DONE to osd, SrvId(%d)",
  513.                         //        pInMsg->Word4);
  514.                     }
  515.                     gpEpgCallback(&msgNode);
  516.                 }   
  517.             }
  518.         }                
  519.         
  520.          break;
  522.       default:
  523.          break;
  524.     }
  525. }
  527. static INT32 EpgResetPF()
  528. {
  529.     gEpgPFInfo.nTsId        = 0xFFFFFFFF;    
  530.     gEpgPFInfo.nEnable      = TRUE;
  531.     gEpgPFInfo.nState       = EPG_Empty;
  532.     gEpgPFInfo.nSvcID   = 0xFFFFFFFF;
  533.     memset(gEpgPFInfo.pPresent, 0, sizeof(KB_SIEitPF));
  534.     memset(gEpgPFInfo.pFollow, 0, sizeof(KB_SIEitPF));
  535.     
  536.     return RETOK;
  537. }
  539. static INT32 EpgResetSCH(UINT32 nTsNum, INT32 nSrvNum)
  540. {
  541. UINT16   loop  =  0;
  542. if (nTsNum >= KB_EPG_MAX_TS_NUM)
  543. {
  544.     printf("nEpgResetSCH::serious error! nTsNum(%d) is too large!", nTsNum);
  545.     return RETFIAL1;
  546. }
  548. gEpgSchInfo[nTsNum].nSchInfo[nSrvNum].nEnable      = TRUE;
  549. gEpgSchInfo[nTsNum].nSchInfo[nSrvNum].nState       = EPG_Empty;
  550. gEpgSchInfo[nTsNum].nSchInfo[nSrvNum].nSvcID   = 0xFFFFFFFF;
  552. if (gEpgSchInfo[nTsNum].nSchInfo[nSrvNum].pDataStruct->num > KB_SI_MAX_EVENT_NUM_PER_SERVICE)
  553. {
  554. gEpgSchInfo[nTsNum].nSchInfo[nSrvNum].pDataStruct->num = KB_SI_MAX_EVENT_NUM_PER_SERVICE;
  555. }
  557. for (loop = 0; loop < gEpgSchInfo[nTsNum].nSchInfo[nSrvNum].pDataStruct->num; loop++)
  558. {
  559. if (NULL != (gEpgSchInfo[nTsNum].nSchInfo[nSrvNum].pDataStruct->ptEvent + loop)->chinese.text)
  560. {
  561. KB_OSPFree((gEpgSchInfo[nTsNum].nSchInfo[nSrvNum].pDataStruct->ptEvent + loop)->chinese.text);
  562. (gEpgSchInfo[nTsNum].nSchInfo[nSrvNum].pDataStruct->ptEvent + loop)->chinese.text = NULL;
  563. }
  564. }
  566. gEpgSchInfo[nTsNum].nSchInfo[nSrvNum].pDataStruct->num = 0;
  567. gEpgSchInfo[nTsNum].nSchInfo[nSrvNum].pDataStruct->service_id = 65535;
  568. memset(gEpgSchInfo[nTsNum].nSchInfo[nSrvNum].nDayInfo, 
  569.         0, 
  570.         sizeof(gEpgSchInfo[nTsNum].nSchInfo[nSrvNum].nDayInfo));
  572. return RETOK;
  573. }
  575. static void  EpgResetUnusedSCH(UINT32 TsNum, 
  576.                                    INT32  nSvcCnt, 
  577.                                            UINT32 *pSvcID)
  578. {
  579.     int i, j;
  581.     if (TsNum >= KB_EPG_MAX_TS_NUM)
  582.     {
  583.         printf("nEpgResetSCH::serious error! nTsNum(%d) is too large!", TsNum);
  584.         return;
  585.     }
  587.     for (i = 0; i < KB_EPG_MAX_SCH; i++)
  588.     {
  589.         for (j = 0; j < nSvcCnt; j++)
  590.         {
  591.             if (gEpgSchInfo[TsNum].nSchInfo[i].nSvcID == *(pSvcID + j))
  592.             {
  593.                 break;
  594.             }
  595.         }
  597.         if (j == nSvcCnt && gEpgSchInfo[TsNum].nSchInfo[i].nEnable == FALSE)
  598.         {
  599.             KB_SIStopEitSCH(gEpgSchInfo[TsNum].nSchInfo[i].nSvcID);            
  600.             EpgResetSCH(TsNum, i);
  601.         }
  602.     }
  603. }
  605. static void EpgHandleSI(KB_OSPMsgNode *pInMsg)
  606. {
  607.     KB_OSPMsgSend(gEpgQueID, pInMsg);
  608. }
  610. static INT32 EpgSortSCH(UINT32  TsNum,
  611.                            KB_SIEitSch *pSCHInfo, 
  612.                                              INT32 nEvtNum)
  613. {
  614.     //KB_OSPMsgNode msgNode;
  615. KB_SIEitSchEvent *pList;
  616. int i;
  617.     struct tm tmNow;
  618. time_t now;
  619. int count = 0,weekday = -1,index;
  620.     //KB_SIEitSchEvent *ptFirstList;
  621.     //struct tm tmFirst;
  622. //printf("-=service_id=%x, nEvtNum=%d=-n", pSCHInfo->service_id, nEvtNum);
  623. if(nEvtNum == 0)
  624.     {
  625.         printf("nEpgSortSCH::nEvtNum is NULL!");
  626. return RETFAIL3;
  627.     }
  629.     if (TsNum >= KB_EPG_MAX_TS_NUM)
  630.     {
  631.         printf("nEpgSortSCH::serious error.TsNum(%d) is too large", TsNum);
  632.     }
  634. pList = pSCHInfo->ptEvent;
  636. QuickSort(pList, 0, (int)nEvtNum-1);
  638. for(i=0;i<KB_EPG_MAX_SCH;i++)
  639. {
  640. if(gEpgSchInfo[TsNum].nSchInfo[i].nSvcID == (UINT32)pSCHInfo->service_id)
  641. {
  642. index = i;
  643. break;
  644. }
  645. }
  647. if(i == KB_EPG_MAX_SCH)
  648.     {
  649.         printf("nEpgSortSCH::serious error. SrvId proved to be not exist!");
  650. return RETFIAL1;
  651.     }
  652. for(i=0;i<nEvtNum;i++)
  653. {
  654.         now = KB_TimeGMTTime(pList[i].start_time);
  655.         tmNow = *localtime(&now);
  656. if(tmNow.tm_wday != weekday)
  657. {
  658. gEpgSchInfo[TsNum].nSchInfo[index].nDayInfo[tmNow.tm_wday].ptEvent = &pList[i];
  659. if(weekday != -1)
  660. {
  661. gEpgSchInfo[TsNum].nSchInfo[index].nDayInfo[weekday].nEventCount = count;
  662. count = 0;
  663. }
  664. weekday = tmNow.tm_wday; 
  665. }   
  667.         count++;
  668. }
  669. gEpgSchInfo[TsNum].nSchInfo[index].nDayInfo[weekday].nEventCount = count;
  671. /* msgNode.Word1 = J_EPG_MODULE;
  672.     msgNode.Word2 = EPG_MSG_SCHEDULE_EVENT_DONE;
  673.     msgNode.Word3 = count;//0;
  674.     msgNode.Word4 = gEpgSchInfo.nSchInfo[index].nSvcID;
  675.     if (gpEpgCallback)
  676.     {
  677.         gpEpgCallback(&msgNode);
  678.     }   
  679. */
  680.     return RETOK;
  681. }
  683. static void QuickSort(KB_SIEitSchEvent *pList, int nLow, int nHigh) 
  684. {
  685.     int nSort;                              
  686.     if (nLow < nHigh)
  687.     {
  688.         nSort = Partition(pList, nLow, nHigh);
  689.         QuickSort(pList, nLow, nSort-1);
  690.         QuickSort(pList, nSort+1, nHigh);
  691.     }
  692. }
  694. static int Partition(KB_SIEitSchEvent *pList, int nLow, int nHigh)
  695. {
  696.     KB_SIEitSchEvent nSort;
  697.     UINT8 text[KB_SI_MAX_EVENT_TEXT_LEN + 1];
  698.     time_t PivotKey,TempKey;
  699.     int low,high;
  701.     nSort.chinese.text = text;
  702.     
  703.     low = nLow;
  704.     high = nHigh;
  706.     nSort = pList[nLow];
  707.     PivotKey = nSort.start_time;
  708.     
  709.     while (low < high)
  710.     {
  711.         TempKey = pList[high].start_time;
  712.      while (low<high && TempKey >=PivotKey)
  713.      {
  714.      --high;               
  715.             TempKey = pList[high].start_time;
  716.      }
  717.         pList[low] = pList[high];
  719.         TempKey = pList[low].start_time;
  720.      while (low<high && TempKey<=PivotKey)
  721.      {
  722.      ++low;
  723.             TempKey = pList[low].start_time;
  724.      }
  725.         pList[high] = pList[low];
  726.     }
  727.     
  728.     pList[low] = nSort;
  730.     return low; 
  731. }
  733. INT32 KB_EPGToNvod(INT32 nMute)
  734. {
  735.     if (nMute == TRUE || nMute == FALSE)
  736.     {
  737.         gEpgToNvod = nMute;
  738.     }
  740.     return RETOK;
  741. }
  743. void* KB_EPGGetMemAddress(void)
  744. {
  745.     return gEpgSCHEvent;
  746. }
  748. INT32 KB_EPGInit(void)
  749. {
  750.     INT32 nReturn;
  751.     
  752.     nReturn = KD_EPGTaskInit();
  754.     return nReturn;
  755. }
  757. INT32 KB_EPGCreate(void)
  758. {
  759.     KB_SIGetTime(&epgTime);       
  760.     KB_EpgCallBack(EpgMsgDisPatch);
  761.     return RETOK;
  762. }
  764. INT32 KB_EPGDestroy(void)
  765. {
  766.     return RETOK;
  767. }
  769. static void EpgMsgDisPatch(KB_OSPMsgNode *pInMsg)
  770. {
  771. KB_MENUTranslateMsg(pInMsg);
  773. }
  775. static void KD_EpgTask(void)
  776. {
  777.     int i, nReturn;
  778.     KB_OSPMsgNode msgNode;
  780.     i = 1;
  781.     while (i)
  782.     {
  783.         nReturn = KB_OSPMsgGet(gEpgQueID, KB_Wait, 0, &msgNode);
  784.         if (nReturn != Ret_OK)
  785.         {
  786.             continue;
  787.         }        
  789.         if (gEpgToNvod)
  790.         {
  791.             KD_NVODHandleMsg2(&msgNode);
  792.         }
  793.         else
  794.         {
  795.             EpgHandlerEvent(&msgNode);
  796.         }
  797.     }
  798. }
  800. KB_EPGDayInfo *KB_EPGGetSchInfo(UINT16 TsId, INT32 nSvcID, INT32 nWeekday)
  801. {
  802.     UINT32 TsNum;
  803.     
  804.     TsNum = KB_EPG_GetTsNumFromTsId(TsId);
  805.     
  806.     if ((UINT32)(-1) == TsNum)
  807.     {
  808.         return NULL;
  809.     }
  810.     else
  811. {
  812.         return KD_EPGGetSCH(TsNum, nSvcID, nWeekday);
  813.     }
  814. }
  816. INT32 KB_EPGHandleMsg(KB_OSPMsgNode *pInMsg)
  817. {
  818.    switch (pInMsg->Word1)
  819.     {
  820.       case MOD_SIPSI:
  821.         {
  822. switch(pInMsg->Word2)
  823. {
  824. case KB_SI_MSG_TDT_DONE:
  825. { 
  826. KB_TimeSetCurTime(*((time_t*)pInMsg->Word3));
  827. }
  828. break;
  829. }
  830.  }
  831.         KB_DTVHandleMsg(pInMsg);
  832.         break;
  834.     case MOD_TUNER:
  835.         KB_DTVAVHandleMsg(pInMsg);
  836.         break;
  837.         
  838.     default:
  839.         break;
  840.     }
  841.     return RETOK;    
  842. }
  844. UINT32 KB_EPGGetPrgSCH(unsigned short nPrgType,unsigned short i_nChannel)
  845. {
  846. INT32 nSvcID[KB_EPG_MAX_SCH] = {0};
  847.     INT32  nSvcID2;
  848.     UINT16 nTsID;
  849.     UINT32 nFreq;
  850.     UINT32 nSymbol;
  851.     UINT8  qamtype;
  853.     if (0 == KB_DBGetPrgTotal((UINT8)nPrgType))
  854.     {
  855.         printf("nKB_EPGGetPrgSCH::KB_DBGetPrgTotal return 0. No Services, no search!");
  856.         return -1;
  857.     }
  859. nSvcID[0] = KB_DBGetSvcIDByNO(nPrgType, i_nChannel - 1);
  860.    if (nSvcID[0] != KB_DB_INVALID_PROGRAMNO)
  861.     {
  862.     KB_DBGetChnlInfoByPrgNO(nPrgType, i_nChannel, &nFreq, &nSymbol,  &qamtype);         
  863.     KB_DBGetTsIDByFre(&nTsID, nFreq / 100000);
  864.     nSvcID2 = KB_DBGetSvc2_TSID(nTsID, nPrgType, 
  865.                                     &nSvcID[1], KB_EPG_MAX_SCH - 1,
  866.                                     &nSvcID[0], 1);
  867.         KB_EPGGetSch((UINT32)nTsID, nSvcID2 + 1, (UINT32*)nSvcID);
  868.     }
  870. return nSvcID[0];
  871. }
  873. UINT32 KB_EPG_GetCurrentTsNum(void)
  874. {
  875.     int i;
  877.     for(i = 0; i < KB_EPG_MAX_TS_NUM; i++)
  878.     {
  879.         if (TRUE == gEpgSchInfo[i].nCurrentTsTag)
  880.         {
  881.             return i;
  882.         }
  883.     }
  885.     return (UINT32)(-1);
  886. }
  888. #if 0
  889. void KB_EPG_CurrentInfo(void)
  890. {
  891.     int i, j;
  892.     for (i = 0; i < 7; i++)
  893.     {
  894.         printf("nn----------Srv(%d), totalNum(%d)------------", i, gEpgSchInfo[KB_EPG_GetCurrentTsNum()].nSchInfo[i].pDataStruct->num);
  896.         for (j = 0; j < 7; j++)
  897.         {
  898.             printf("n-----day(%d), EventNum(%d)", j, gEpgSchInfo[KB_EPG_GetCurrentTsNum()].nSchInfo[i].nDayInfo[j].nEventCount);
  899.         }
  900.     }
  902.     return;
  903. }
  904. #endif
  906. UINT32 KB_EPG_GetTsNumFromTsId(UINT16 TsId)
  907. {
  908.     int i;
  910.     for(i = 0; i < KB_EPG_MAX_TS_NUM; i++)
  911.     {
  912.         if (TsId == (UINT16)gEpgSchInfo[i].nTsId)
  913.         {
  914.             return i;
  915.         }
  916.     }
  918.     return (UINT32)(-1);
  919. }
  921. UINT32 KB_EPG_GetTsIdFromTsNum(UINT32 TsNum)
  922. {
  923.     if (TsNum < KB_EPG_MAX_TS_NUM)
  924.     {
  925.         return gEpgSchInfo[TsNum].nTsId;
  926.     }
  927.     else
  928.     {
  929.         printf("nKB_EPG_GetTsIdFromTsNum::input error TsNum(%d)", TsNum);
  930.         return 0xFFFFFFFF;
  931.     }
  932. }
  934. //当其他模块切换ts流的时候，要记得通知EPG设置当前流标志
  935. INT32 KB_EPG_SetCurrentTsNum(UINT32 TsId)
  936. {
  937.     UINT8  i;
  938.     UINT32 preTsNum, NowTsNum;
  940.     preTsNum = KB_EPG_GetCurrentTsNum();
  941.     
  942.     //将原当前流标志修改；如果是第一次搜索，当前流还没有设置
  943.     if ((UINT32)(-1) != preTsNum)
  944.     {
  945.         gEpgSchInfo[preTsNum].nCurrentTsTag = FALSE;
  946.     }
  948.     for (i = 0; i < KB_EPG_MAX_TS_NUM; i++)
  949.     {
  950.         if (gEpgSchInfo[i].nTsId == TsId)
  951.         {
  952.             //该ts流已经申请了gEpgSchInfo，修改当前流标志后return
  953.             gEpgSchInfo[i].nCurrentTsTag = TRUE;
  954.             return RET_OK;
  955.         }
  956.     }
  958.     //该ts流未申请gEpgSchInfo
  959.     NowTsNum = KB_EPG_GetFreeEpgSchInfo();
  960.     
  961.     if (0xFF == NowTsNum)
  962.     {
  963.         printf("nKB_EPG_SetCurrentTsNum::KB_EPG_GetFreeEpgSchInfo fail!n");
  964.         return RET_FAIL;
  965.     }
  966.     else
  967.     {
  968.         gEpgSchInfo[NowTsNum].nTsId         = TsId;
  969.         gEpgSchInfo[NowTsNum].nCurrentTsTag = TRUE;
  970.         return RET_OK;
  971.     }
  972.     
  973. }
  975. static UINT8 KB_EPG_GetFreeEpgSchInfo(void)
  976. {
  977.     UINT8 i, ret = 0xFF;
  978.     
  979.     for (i = 0; i < KB_EPG_MAX_TS_NUM; i++)
  980.     {
  981.         if (0xFFFFFFFF == gEpgSchInfo[i].nTsId)
  982.         {
  983.             ret = i;
  984.             break;
  985.         }
  986.     }
  988.     return ret;
  989. }
  991. void KB_EPG_ResetSchInfoByTsid(UINT16 TsId)
  992. {
  993.     UINT8  i = 0;
  994.     UINT8  j = 0;
  995.     UINT32 TsIndex = 0xffffffff;
  997.     //对全体复位的预先处理
  998.     if (0xffff == TsId)
  999.     {
  1000.         for (i = 0; i < KB_EPG_MAX_TS_NUM; i++)
  1001.         {
  1002.             for (j = 0; j < KB_EPG_MAX_SCH; j++)
  1003.             {
  1004.                 EpgResetSCH(i, j);
  1005.             }
  1006.         }
  1008.         return;
  1009.     }
  1011.     TsIndex = KB_EPG_GetTsNumFromTsId(TsId);
  1012.     if (TsIndex >= KB_EPG_MAX_TS_NUM)
  1013.     {
  1014.         printf("nKB_EPG_ResetSchInfoByTsid::input tsid(%d) donot register in gEpgSchInfo");
  1015.         return;
  1016.     }
  1018.     for (i = 0; i < KB_EPG_MAX_SCH; i++)
  1019.     {
  1020.         EpgResetSCH(TsIndex, i);
  1021.     }
  1022.     
  1023.     return;
  1024. }
  1026. UINT16 KB_EPG_GetCurrentTsid(void)
  1027. {
  1028.     UINT16 CurTsid = 0xffff;
  1029.     UINT32 TmpTsid = 0xffffffff;
  1030.     UINT32 EpgTsIndex = 0xffffffff;
  1031.     
  1032.     if (0 == CurrentSignal.frequency
  1033.         || RET_OK != KB_DBGetTsIDByFre(&CurTsid, CurrentSignal.frequency))
  1034.     {
  1035.         printf("nKB_EPG_GetCurrentTsid::CurrentSignal fre(%ld) error", 
  1036.                 CurrentSignal.frequency);
  1037.         return 0xffff;
  1038.     }
  1039.     
  1040.     EpgTsIndex = KB_EPG_GetCurrentTsNum();
  1041.     TmpTsid = KB_EPG_GetTsIdFromTsNum(EpgTsIndex);
  1042.     if (0xffffffff == TmpTsid || TmpTsid != (UINT32)CurTsid)
  1043.     {
  1044.         KB_EPG_SetCurrentTsNum((UINT32)CurTsid);
  1045.     }
  1046.     
  1047.     return CurTsid;
  1048. }
  1050. /* EOF */