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

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

DVD

开发平台：

C/C++

db.c：源码内容
  1. #include <string.h>
  2. #include <assert.h>
  4. #include "flash.h"
  5. #include "db.h"
  7. #include "sipsi.h"  
  8. #include "dmd.h"  
  9. #include "eprom.h"
  10. #include "av.h"
  11. //added by yyj 2007.7.3
  12. #include "demand.h"
  13. //added by yyj 2007.7.16
  14. #include "gendef.h"
  17. KB_DBPrgAllInfo gPrgAllInfo;
  18. KB_DBE2PDATA gE2pData;
  20. static UINT8 gDtvCfgFlag[KB_DB_MAX_DTV];
  21. static UINT8 gRadCfgFlag[KB_DB_MAX_RAD];
  22. //added by whale 07/05/25
  23. static UINT8 gDataCfgFlag[KB_DB_MAX_DATA];
  25. static KB_DBMailNode gMailInfo[KB_DB_MAX_MAIL];
  26. //added by yyj 2007.6.27 start
  27. static UINT8 gVidDispMode;// 视频制式
  28. static UINT8 gVidAspectRatio;// 屏幕宽高比
  29. static UINT8 gConfigAudioVol; // 统一音量
  30. static UINT8 gConfigAudioTrack; // 统一声道
  31. static UINT8 gConfigAdultRank;// 成人级别
  32. static UINT8 gConfigMenuLan;//菜单语言
  33. static UINT8 gConfigMenuTran;// 菜单透明度
  34. //added by yyj 2007.6.27 end
  36. static UINT16 KD_GetFreeNumCfg(UINT8 nPrgType);
  38. static KB_DBRET KD_ResetMailInfo(void);
  39. static KB_DBRET KD_InitMail(void);
  40. static KB_DBRET KD_InitChnnlInfo(void);
  41. static KB_DBRET KD_InitDtvInfo(void);
  42. //added by whale 07/05/25
  43. static KB_DBRET KD_InitDataInfo(void);
  44. static KB_DBRET KD_InitRadInfo(void);
  45. static KB_DBRET KD_ResetNvodInfo(UINT8 bType);
  46. static KB_DBRET KD_InitNvodInfo(void);
  47. static KB_DBRET KD_InitCurPrgInfo(void);
  48. static KB_DBRET KD_InitCurPrgInfo(void);
  49. KB_DBRET KD_ResetCurPrgInfo(void);
  50. static KB_DBRET KD_ResetNetInfo(void);
  52. static KB_DBRET KD_InitNetInfo(void);
  53. static KB_DBRET KD_ResetSysparInfo(void);
  54. static KB_DBRET KD_InitSysparInfo(void);
  55. static KB_DBRET KD_ResetPwdInfo(void);
  56. static KB_DBRET KD_InitPwdInfo(void);
  57. static KB_DBRET KD_ResetSrchInfo(void);
  58. static KB_DBRET KD_InitSrchInfo(void);
  59. static KB_DBRET KD_ResetFavDtv(void);
  60. static KB_DBRET KD_InitFavDtv(void);
  61. static KB_DBRET KD_ResetFavRad(void);
  62. static KB_DBRET KD_InitFavRad(void);
  63. static KB_DBRET KD_ResetSerList(void);
  64. static KB_DBRET KD_InitSerList(void);
  65. static void KD_InitPrgConfig(void);
  66. //static KB_DBRET KD_InitPrgNum(void);
  67. //static KB_DBRET KD_GetPrgNum(void);
  69. static void quicksort(KB_DBPrgInfo *pbuf,int low,int high);
  70. static int quickpart(KB_DBPrgInfo *pbuf,int i,int j);
  72. static KB_DBRET KD_GetPrgConfig(void);
  74. //added by yyj 2007.6.15 start
  75. static KB_DBRET KD_InitPgmCurVol(void);
  76. static KB_DBRET KD_ResetPgmCurVol(void);
  77. //added by yyj 2007.6.15 end
  79. //added by yyj 2007.6.27 start
  80. static KB_DBRET KD_InitVideoDispMode(void);
  81. static KB_DBRET KD_ResetVideoDispMode(void);
  82. static KB_DBRET KD_InitVideoAspectRatio(void);
  83. static KB_DBRET KD_ResetVideoAspectRatio(void);
  84. static KB_DBRET KD_InitPgmCurTrack(void);
  85. static KB_DBRET KD_ResetPgmCurTrack(void);
  86. static KB_DBRET KD_InitAdultRank(void);
  87. static KB_DBRET KD_ResetAdultRank(void);
  88. static KB_DBRET KD_InitMenuLan(void);
  89. static KB_DBRET KD_ResetMenuLan(void);
  90. static KB_DBRET KD_InitMenuTran(void);
  91. static KB_DBRET KD_ResetMenuTran(void);
  92. //added by yyj 2007.6.27 end
  95. //added by yyj 2007.6.27 
  96. #define KB_DB_DEFAULT_MENU_LAN CHINESE
  97. #define KB_DB_DEFAULT_MENU_TRAN  LEVEL_3
  98. /////////////////////
  100. //added by yyj 2007.6.19
  101. static KB_DBRET KD_InitSTBInfo(void);
  102. static KB_DBRET KD_ResetSTBInfo(void);
  103. /////////////////////
  105. //added by yyj 2007.7.3 
  106. //static KB_DBRET KD_ResetDemandInfo(void);
  109. KB_DBRET KB_DBInit(void)
  110. {
  111.     KB_DBRET tRet;
  112.     //UINT8 updateInfo[2];    
  113.      //moved by lsp 07/3/14
  114.      printf("nKB_DBInit");
  115.      if (KD_InitSysparInfo() != RET_OK)
  116.      {
  117.          printf("nKD_InitSysparInfo() != RET_OKn");//lsp 07/3/14
  118.          tRet = KD_ResetSysparInfo();
  119.          if (tRet != RET_OK)
  120.          {
  121.              return tRet;
  122.          }
  123.      }
  124.     //lsp 07/3/14
  125.     if (KB_FlashRead(KB_DB_SECTOR, 0, (UINT8*)&gPrgAllInfo, sizeof(KB_DBPrgAllInfo)) != RETOK)
  126.     {
  127.         return RET_FAIL;
  128.     }
  129.     else
  130.     {
  131.        if(gPrgAllInfo.gChnnlInfo.nTotal==0xFF)
  132.     gPrgAllInfo.gChnnlInfo.nTotal=0;
  133.      if(gPrgAllInfo.gDTVInfo.nTotal==0xFFFF)
  134. gPrgAllInfo.gDTVInfo.nTotal=0;
  135. if(gPrgAllInfo.gRADInfo.nTotal==0xFFFF)
  136. gPrgAllInfo.gRADInfo.nTotal=0;
  137. //added by whale 07/05/25 start
  138. if(gPrgAllInfo.gDATAInfo.nTotal==0xFFFF)
  139. gPrgAllInfo.gDATAInfo.nTotal=0;
  140. //added by whale 07/05/25 end
  141.     }
  143. tRet = KD_GetPrgConfig();
  144. if (tRet != RET_OK)
  145. {
  146. return tRet;
  147. }
  148.     
  149.     if (KD_InitMail() != RET_OK)
  150.     {
  151.         tRet = KD_ResetMailInfo();
  152.         if (tRet != RET_OK)
  153.         {
  154.             return tRet;
  155.         }
  156.     }
  157.     
  158.     if (KD_InitChnnlInfo() != RET_OK)
  159.     {
  160.         tRet = KB_DBResetChnnlInfo(BufferSave);
  161.         if (tRet != RET_OK)
  162.         {   
  163.             return tRet;
  164.         }
  165.     }
  166. else
  167. {
  168.     if (KD_InitDtvInfo() != RET_OK)
  169.     {
  170.         tRet = KB_DBResetDtvInfo(FlashSave);
  171.         if (tRet != RET_OK)
  172.         {
  173.             return tRet;
  174.         }
  175.     }
  177.     if (KD_InitFavDtv() != RET_OK)
  178.     {
  179.         tRet = KD_ResetFavDtv();
  180.         if (tRet != RET_OK)
  181.         {
  182.             return tRet;
  183.         }
  184.     }
  185.         
  186.     if (KD_InitRadInfo() != RET_OK)
  187.     {        
  188.         tRet = KB_DBResetRadInfo(FlashSave);
  189.         if (tRet != RET_OK)
  190.         {
  191.             return tRet;
  192.         }        
  193.     }
  195.     if (KD_InitFavRad() != RET_OK)
  196.     {
  197.         tRet = KD_ResetFavRad();
  198.         if (tRet != RET_OK)
  199.         {
  200.             return tRet;
  201.         }
  202.     }
  203.     //added by whale 07/05/25 start
  204.     if (KD_InitDataInfo() != RET_OK)
  205.     {
  206.         tRet = KB_DBResetDataInfo(FlashSave);
  207.         if (tRet != RET_OK)
  208.         {
  209.             return tRet;
  210.         }
  211.     }     
  212.     //added by whale 07/05/25 end
  213.     if (KD_InitNvodInfo() != RET_OK)
  214.     {
  215.         tRet = KD_ResetNvodInfo(FlashSave);
  216.         if (tRet != RET_OK)
  217.         {
  218.             return tRet;
  219.         }
  220.     }         
  221.         
  222.     if (KD_InitCurPrgInfo() != RET_OK)
  223.     {
  224.         tRet = KD_ResetCurPrgInfo();
  225.         if (tRet != RET_OK)
  226.         {
  227.             return tRet;
  228.         }
  229.     }
  230. }
  233.     if (KD_InitNetInfo() != RET_OK)
  234.     {
  235.         tRet = KD_ResetNetInfo();
  236.         if (tRet != RET_OK)
  237.         {
  238.             return tRet;
  239.         }
  240.     }
  241.      //moved by lsp 07/3/14
  242.      /* if (KD_InitSysparInfo() != RET_OK)
  243.     {
  244.         tRet = KD_ResetSysparInfo();
  245.         if (tRet != RET_OK)
  246.         {
  247.             return tRet;
  248.         }
  249.     }*/
  250.     //lsp 07/3/14
  251.     
  252.     if (KD_InitPwdInfo() != RET_OK)
  253.     {
  254.         tRet = KD_ResetPwdInfo();
  255.         if (tRet != RET_OK)
  256.         {
  257.             return tRet;
  258.         }
  259.     }
  260.     
  261.     if (KD_InitSrchInfo() != RET_OK)
  262.     {
  263.         tRet = KD_ResetSrchInfo();
  264.         if (tRet != RET_OK)
  265.         {
  266.             return tRet;
  267.         }
  268.     }
  270.     if (KD_InitSerList() != RET_OK)
  271.     {
  272.         tRet = KD_ResetSerList();
  273.         if (tRet != RET_OK)
  274.         {
  275.             return tRet;
  276.         }
  277.     }
  279.     //added by yyj 2007.6.15 start
  280.     if (KD_InitPgmCurVol() != RET_OK)
  281.     {
  282.         tRet = KD_ResetPgmCurVol();
  283.         if (tRet != RET_OK)
  284.         {
  285.             return tRet;
  286.         }
  287.     }
  288.     //added by yyj 2007.6.15 end
  290.     //added by yyj 2007.6.19 start
  291.     if (KD_InitSTBInfo() != RET_OK)
  292.     {
  293.         tRet = KD_ResetSTBInfo();
  294.         if (tRet != RET_OK)
  295.         {
  296.             return tRet;
  297.         }
  298.     }
  299.   //added by yyj 2007.6.19 end
  301.   //added by yyj 2007.6.27 start
  302.  if (KD_InitVideoDispMode() != RET_OK)
  303. {
  304.     tRet = KD_ResetVideoDispMode();
  305.     if (tRet != RET_OK)
  306.     {
  307.         return tRet;
  308.     }
  309. }
  311.     if (KD_InitVideoAspectRatio() != RET_OK)
  312. {
  313.     tRet = KD_ResetVideoAspectRatio();
  314.     if (tRet != RET_OK)
  315.     {
  316.         return tRet;
  317.     }
  318. }
  320. if (KD_InitPgmCurTrack() != RET_OK)
  321. {
  322.     tRet = KD_ResetPgmCurTrack();
  323.     if (tRet != RET_OK)
  324.     {
  325.         return tRet;
  326.     }
  327. }
  329. if (KD_InitAdultRank() != RET_OK)
  330. {
  331.     tRet = KD_ResetAdultRank();
  332.     if (tRet != RET_OK)
  333.     {
  334.         return tRet;
  335.     }
  336. }
  338. if (KD_InitMenuLan() != RET_OK)
  339. {
  340.     tRet = KD_ResetMenuLan();
  341.     if (tRet != RET_OK)
  342.     {
  343.         return tRet;
  344.     }
  345. }
  347. if (KD_InitMenuTran() != RET_OK)
  348. {
  349.     tRet = KD_ResetMenuTran();
  350.     if (tRet != RET_OK)
  351.     {
  352.         return tRet;
  353.     }
  354. }
  355.   //added by yyj 2007.6.27 end
  357.     
  358.     KD_InitPrgConfig();
  359.     
  360.     return RET_OK;
  361. }
  363. static void quicksort(KB_DBPrgInfo *pbuf,int low,int high)
  364. {
  365.     int i;
  366.     if(low < high)
  367.     {
  368.         i = quickpart(pbuf,low,high);
  369.         quicksort(pbuf,low,i-1);
  370.         quicksort(pbuf,i+ 1,high);
  371.     }
  372. }
  374. static int quickpart(KB_DBPrgInfo *pbuf,int i,int j)
  375. {
  376.     KB_DBPrgInfo b;
  377.     
  378.     memcpy(&b,&pbuf[i],sizeof(KB_DBPrgInfo));
  379.     while(i<j)
  380.     {
  381.         while(i<j && pbuf[j].SvcID >= b.SvcID)
  382.         {
  383.             j --;
  384.         }
  385.         if(i< j)
  386.             memcpy(&pbuf[i++],&pbuf[j],sizeof(KB_DBPrgInfo));
  387.         
  388.         while(i<j && pbuf[i].SvcID <= b.SvcID)
  389.         {
  390.             i ++;
  391.         }
  392.         if(i<j)
  393.             memcpy(&pbuf[j --],&pbuf[i],sizeof(KB_DBPrgInfo));
  394.     }
  395.     
  396.     memcpy(&pbuf[i],&b,sizeof(KB_DBPrgInfo));
  397.     return i;
  398. }
  400. KB_DBRET KB_DBSaveChlPatVer(UINT16  Freq,UINT8 patVer)
  401. {
  402.     KB_DBRET ret = RET_FAIL;
  403.     int i,find = 0;
  404.     
  405.     for(i = 0;i< gPrgAllInfo.gChnnlInfo.nTotal;i++)
  406.     {
  407.         if(Freq == gPrgAllInfo.gChnnlInfo.ChannelList[i].Freq)
  408.         {
  409.             find = 1;
  410.             break;
  411.         }
  412.     }
  413.     
  414.     if(find == 1)
  415.     {
  416.         gPrgAllInfo.gChnnlInfo.ChannelList[i].PATVersion = patVer;
  417.         ret = RET_OK;
  418.     }
  419.     
  420.     return  ret ;
  421. }
  423. KB_DBRET KB_DBSaveChlSdtVer(UINT16  Freq,UINT8 sdtVer)
  424. {
  425.     KB_DBRET ret = RET_FAIL;
  426.     int i,find = 0;
  427.     
  428.     for(i = 0;i< gPrgAllInfo.gChnnlInfo.nTotal;i++)
  429.     {
  430.         if(Freq == gPrgAllInfo.gChnnlInfo.ChannelList[i].Freq)
  431.         {
  432.             find = 1;
  433.             break;
  434.         }
  435.     }
  436.     
  437.     if(find == 1)
  438.     {
  439.         gPrgAllInfo.gChnnlInfo.ChannelList[i].SDTVersion = sdtVer;
  440.         ret = RET_OK;
  441.     }
  442.     
  443.     return  ret ;
  444. }
  445. KB_DBRET KB_DBSaveChlInfo(UINT8 addtype,UINT16 OrgNetID,UINT16  tsID,
  446.                                                UINT16  Freq, UINT16  Symb,UINT8   QAM)
  447. {
  448.     int i;
  450.     for(i = 0;i< gPrgAllInfo.gChnnlInfo.nTotal;i++)
  451.     {
  452.         if(Freq == gPrgAllInfo.gChnnlInfo.ChannelList[i].Freq)  
  453.         {
  454.             gPrgAllInfo.gChnnlInfo.ChannelList[i].TSID = tsID;
  455.             gPrgAllInfo.gChnnlInfo.ChannelList[i].Freq = Freq;
  456.             gPrgAllInfo.gChnnlInfo.ChannelList[i].Symb = Symb;
  457.             gPrgAllInfo.gChnnlInfo.ChannelList[i].QAM = QAM;
  458.             if(addtype == 0)
  459.             {
  460.                 gPrgAllInfo.gChnnlInfo.ChannelList[i].NitAddType = addtype;
  461.             }
  463.             return RET_OK;
  464.         }
  465.     }
  466.     
  467.     if ( i >= KB_DB_MAX_CHANNEL_NUM )
  468.     {
  469.         return RET_FAIL; 
  470.     }
  471.     
  472.     gPrgAllInfo.gChnnlInfo.ChannelList[i].TSID = tsID;
  473.     gPrgAllInfo.gChnnlInfo.ChannelList[i].OrgNetID = OrgNetID;
  474.     gPrgAllInfo.gChnnlInfo.ChannelList[i].Freq = Freq;
  475.     gPrgAllInfo.gChnnlInfo.ChannelList[i].Symb = Symb;
  476.     gPrgAllInfo.gChnnlInfo.ChannelList[i].QAM = QAM;
  477.     gPrgAllInfo.gChnnlInfo.ChannelList[i].NitAddType = addtype;
  478.     gPrgAllInfo.gChnnlInfo.nTotal ++;
  480.     return RET_OK;
  481. }
  483. KB_DBRET KD_GetNitInfo(unsigned char *o_pcNITName,
  484.                                     UINT8 *NitVersion)
  485. {
  486.     o_pcNITName = gE2pData.gNetInfo.NetworkName;
  487.     *NitVersion = gE2pData.gNetInfo.NitVersion;
  488.     return RET_OK;
  489. }
  491. KB_DBRET KB_DBSaveNitInfo(KB_DBNetInfo *ptNetworkInfo)
  492. {
  493.     
  494.     gE2pData.gNetInfo = *ptNetworkInfo;
  495.     
  496.     if (KB_E2PWrite(KB_NVM_NETWORK_INFO_ADDR, (UINT8 *)&gE2pData.gNetInfo, sizeof(KB_DBNetInfo), NULL) != RETOK)
  497.     {
  498.         return RET_FAIL;
  499.     }
  500.     
  501.     return RET_OK;
  502. }
  504. UINT16  KB_DBGetPrgTotal(UINT8 nPrgType)
  505. {
  506.     UINT16 ret = 0;
  508.     
  509.     if (nPrgType == DTVPRG)
  510.     {
  511.         ret = gPrgAllInfo.gDTVInfo.nTotal;
  512.     }
  513.     else if (nPrgType == RADIOPRG)
  514.     {
  515.         ret = gPrgAllInfo.gRADInfo.nTotal;
  516.     }
  517.     //added by whale 07/05/25 start
  518.     else if (nPrgType == DATAPRG)
  519.     {
  520.         ret = gPrgAllInfo.gDATAInfo.nTotal;
  521.     }
  522.     //added by whale 07/05/25 end
  523.     else
  524.     {
  525. ret = 0;
  526.     }
  528.     if (ret == 65535)
  529.     {
  530. ret = 0;
  531.     }
  533.     //--add by shriek gPrgAllInfo.gDATAInfo.nTotal=623669
  534.     if(ret>=23669) 
  535. ret = 0;
  536.     //--end
  539.     return ret;
  540. }
  542. UINT16 KB_DBGetFavPrgTotal(UINT8 nPrgType)
  543. {
  544.     UINT16 ret =  0xffff;
  545.     if(nPrgType != DTVPRG && nPrgType != RADIOPRG)
  546.     {
  547.         printf("nKB_DBGetFavPrgTotal::input PrgType(%d) error",
  548.                 nPrgType);
  549.         return ret;
  550.     }
  551.     
  552.     if (DTVPRG == nPrgType)
  553.     {
  554.         ret = gE2pData.gDTVFavInfo.nTotal;
  555.     }
  556.     else if (RADIOPRG == nPrgType)
  557.     {
  558.         ret = gE2pData.gRADFavInfo.nTotal;
  559.     }
  560.     
  561.     return ret;
  562. }
  564. KB_DBRET KB_DBGetPrgInfo(UINT16 nPrgInx,
  565.                                     UINT8 nPrgType,
  566.                                     KB_DBPrgInfo *pPrgInfo,
  567.                                     KB_DBChnnlInfo *pChnnlInfo,
  568.                                     UINT8 *pTrack,
  569.                                     UINT8 *pbVolume,
  570.                                     UINT8 *pLockFlag)
  571. {
  572.     
  573.     UINT8  nConfigInfo = 0;
  574. UINT8 i;
  576.     if((nPrgInx <0 ) || (nPrgInx >= KB_DBGetPrgTotal(nPrgType)))
  577.     {
  578.         return RET_FAIL;
  579.     }
  580.     
  581.     if (nPrgType == DTVPRG)
  582.     {
  583.         memcpy(pPrgInfo,&gPrgAllInfo.gDTVInfo.PgmList[nPrgInx],sizeof(KB_DBPrgInfo));
  584.         
  585.         nConfigInfo = gE2pData.gDTVPrgCfgInfo[pPrgInfo->IndexOfConfigInfo].Lock_Track_Vol;
  586.     }
  587.     else if (nPrgType == RADIOPRG)
  588.     {
  589.         memcpy(pPrgInfo,&gPrgAllInfo.gRADInfo.PgmList[nPrgInx],sizeof(KB_DBPrgInfo));
  590.         
  591.         nConfigInfo = gE2pData.gRADPrgCfgInfo[pPrgInfo->IndexOfConfigInfo].Lock_Track_Vol;
  592.     }
  593.     //added by whale 07/05/25 start
  594.     else if (nPrgType == DATAPRG)
  595.     {
  596.         memcpy(pPrgInfo,&gPrgAllInfo.gDATAInfo.PgmList[nPrgInx],sizeof(KB_DBPrgInfo));
  597.         
  598.         nConfigInfo = gE2pData.gDATAPrgCfgInfo[pPrgInfo->IndexOfConfigInfo].Lock_Track_Vol;
  599.     }
  600.     //added by whale 07/05/25 end
  601.     
  602.     *pLockFlag = (UINT8)((nConfigInfo >> 7) & 0x01);
  603.     *pTrack    = (UINT8)((nConfigInfo >> 5) & 0x03);
  604.     *pbVolume   = (UINT8)(nConfigInfo & 0x1F);
  606. for (i=0; i<gPrgAllInfo.gChnnlInfo.nTotal; i++)
  607. {
  608.     if (nPrgType == DTVPRG)
  609.     {
  610. if (gPrgAllInfo.gChnnlInfo.ChannelList[i].TSID 
  611.  == gPrgAllInfo.gDTVInfo.PgmList[nPrgInx].TSID)
  612. {
  613. break;
  614. }
  615.     }
  616.     else if (nPrgType == RADIOPRG)
  617.     {
  618. if (gPrgAllInfo.gChnnlInfo.ChannelList[i].TSID 
  619.  == gPrgAllInfo.gRADInfo.PgmList[nPrgInx].TSID)
  620. {
  621. break;
  622. }
  623.     }
  624.     //added by whale 07/05/25 start
  625.     else if (nPrgType == DATAPRG)
  626.     {
  627. if (gPrgAllInfo.gChnnlInfo.ChannelList[i].TSID 
  628.  == gPrgAllInfo.gDATAInfo.PgmList[nPrgInx].TSID)
  629. {
  630. break;
  631. }
  632.     }
  633.     //added by whale 07/05/25 end
  635. }
  637. if (i < gPrgAllInfo.gChnnlInfo.nTotal)
  638. {
  639. memcpy(pChnnlInfo,
  640.                 &gPrgAllInfo.gChnnlInfo.ChannelList[i],
  641.                 sizeof(KB_DBChnnlInfo));
  642. }
  643. else
  644. {
  645. memset(pChnnlInfo,0,sizeof(KB_DBChnnlInfo));
  646. return RET_FAIL;
  647. }
  648.     
  649.     return RET_OK;
  650. }
  652. KB_DBRET KB_DBGetAllPrgConfig(void)
  653. {
  654.     UINT16 i, sum, indexofconfig;
  655.     KB_DBPrgConfigNode *confignode;
  656.     
  657.     sum = gPrgAllInfo.gDTVInfo.nTotal;
  658.     for (i = 0; i < sum; ++i)
  659.     {
  660.         indexofconfig = gPrgAllInfo.gDTVInfo.PgmList[i].IndexOfConfigInfo;
  661.         confignode = &gE2pData.gDTVPrgCfgInfo[indexofconfig];
  662.         if (confignode->Flag == CONFIG_USED + 1)
  663.         {
  664.             if (KB_E2PRead((UINT16)(KB_NVM_DTV_PGM_CFG_ADDR + indexofconfig * sizeof(KB_DBPrgConfigNode)),
  665.                 (UINT8 *)confignode, sizeof(KB_DBPrgConfigNode), NULL) != RETOK)
  666.             {
  667.                 return RET_FAIL;
  668.             }
  669.         }
  670.     }
  671.     sum = gPrgAllInfo.gRADInfo.nTotal;
  672.     for (i = 0; i < sum; ++i)
  673.     {
  674.         indexofconfig = gPrgAllInfo.gRADInfo.PgmList[i].IndexOfConfigInfo;
  675.         confignode = &gE2pData.gRADPrgCfgInfo[indexofconfig];
  676.         if (confignode->Flag == CONFIG_USED + 1)
  677.         {
  678.             if (KB_E2PRead((UINT16)(KB_NVM_RAD_PGM_CFG_ADDR + indexofconfig * sizeof(KB_DBPrgConfigNode)),
  679.                 (UINT8 *)confignode, sizeof(KB_DBPrgConfigNode), NULL) != RETOK)
  680.             {
  681.                 return RET_FAIL;
  682.             }
  683.             
  684.         }
  685.     }
  686.     //added by whale 07/05/25 start
  687.     sum = gPrgAllInfo.gDATAInfo.nTotal;
  688.     for (i = 0; i < sum; ++i)
  689.     {
  690.         indexofconfig = gPrgAllInfo.gDATAInfo.PgmList[i].IndexOfConfigInfo;
  691.         confignode = &gE2pData.gDATAPrgCfgInfo[indexofconfig];
  692.         if (confignode->Flag == CONFIG_USED + 1)
  693.         {
  694.             if (KB_E2PRead((UINT16)(KB_NVM_DATA_PGM_CFG_ADDR + indexofconfig * sizeof(KB_DBPrgConfigNode)),
  695.                 (UINT8 *)confignode, sizeof(KB_DBPrgConfigNode), NULL) != RETOK)
  696.             {
  697.                 return RET_FAIL;
  698.             }
  699.             
  700.         }
  701.     }
  702.     //added by whale 07/05/25 end
  703.     
  704.     return RET_OK;
  705. }
  708. KB_DBRET KB_DBGetPrgConfig(UINT8 PrgType, UINT16 PrgNo)
  709. {
  710.     UINT16 indexofconfig;
  711.     UINT16 readstartaddress;
  712.     UINT8 *confignode;
  713.     
  714.     if (PrgType == DTVPRG)
  715.     {
  716.         readstartaddress = KB_NVM_DTV_PGM_CFG_ADDR;
  717.         indexofconfig = gPrgAllInfo.gDTVInfo.PgmList[PrgNo].IndexOfConfigInfo;
  718.         confignode = (UINT8 *)&gE2pData.gDTVPrgCfgInfo[indexofconfig];
  719.     }
  720.     else if (PrgType == RADIOPRG)
  721.     {
  722.         readstartaddress = KB_NVM_RAD_PGM_CFG_ADDR;
  723.         indexofconfig = gPrgAllInfo.gRADInfo.PgmList[PrgNo].IndexOfConfigInfo;
  724.         confignode = (UINT8 *)&gE2pData.gRADPrgCfgInfo[indexofconfig];
  725.     }
  726.     //added by whale 07/05/25 start
  727.     else if (PrgType == DATAPRG)
  728.     {
  729.         readstartaddress = KB_NVM_DATA_PGM_CFG_ADDR;
  730.         indexofconfig = gPrgAllInfo.gDATAInfo.PgmList[PrgNo].IndexOfConfigInfo;
  731.         confignode = (UINT8 *)&gE2pData.gDATAPrgCfgInfo[indexofconfig];
  732.     }
  733.     //added by whale 07/05/25 end
  734.     if (KB_E2PRead((UINT16)(readstartaddress + indexofconfig * sizeof(KB_DBPrgConfigNode)),
  735.         confignode, sizeof(KB_DBPrgConfigNode), NULL) != RETOK)
  736.     {
  737.         return RET_FAIL;
  738.     }
  740.     return RET_OK;
  741. }
  743. UINT16 KB_DBGetSvcIDByNO(UINT8 prgType, UINT16 prgInx)
  744. {
  745. UINT16 service_id;
  747. switch (prgType)
  748. {
  749. case DTVPRG:
  750. service_id = gPrgAllInfo.gDTVInfo.PgmList[prgInx].SvcID;
  751. break;
  752. case RADIOPRG:
  753. service_id = gPrgAllInfo.gRADInfo.PgmList[prgInx].SvcID;
  754. break;
  755. //added by whale 07/05/25 start
  756. case DATAPRG:
  757. service_id = gPrgAllInfo.gDATAInfo.PgmList[prgInx].SvcID;
  758. break;
  759. //added by whale 07/05/25 end
  760. default:
  761. service_id = KB_DB_INVALID_PROGRAMNO;
  762. break;
  763. }
  765. return service_id;
  767. }
  769. UINT16 KD_GetPrgInxBySvcID(UINT8 PrgType, UINT16 ServiceID)
  770. {
  771.     UINT16 i = 0, sum = 0;
  772.     
  773.     sum = KB_DBGetPrgTotal(PrgType);
  775. if (DTVPRG == PrgType)
  776. {
  777.     for (i = 0; i < sum; ++i)
  778.     {
  779.         if (gPrgAllInfo.gDTVInfo.PgmList[i].SvcID == ServiceID)
  780.         {
  781. return i;
  782.         }
  783.     }
  784. }
  785. else if (RADIOPRG== PrgType)
  786. {
  787.     for (i = 0; i < sum; ++i)
  788.     {
  789.         if (gPrgAllInfo.gRADInfo.PgmList[i].SvcID == ServiceID)
  790.         {
  791. return i;
  792.         }
  793.     }
  794. }
  795. //added by whale 07/05/25 start
  796. else if (DATAPRG== PrgType)
  797. {
  798.     for (i = 0; i < sum; ++i)
  799.     {
  800.         if (gPrgAllInfo.gDATAInfo.PgmList[i].SvcID == ServiceID)
  801.         {
  802. return i;
  803.         }
  804.     }
  805. }
  806. //added by whale 07/05/25 end
  807. else
  808. {
  809. return KB_DB_INVALID_PROGRAMNO;
  810. }
  812. return KB_DB_INVALID_PROGRAMNO;
  813.     
  814. }
  817. KB_DBRET KB_DBGetFavPrgInfoByFavInx(UINT8 Favindex, 
  818.                                             UINT8 nPrgType,
  819.                                             UINT16 *pwPrgInx,
  820.                                             KB_DBPrgInfo *pPrgInfo,
  821.                                             KB_DBChnnlInfo *pChnnlInfo,
  822.                                             UINT8 *pTrack,
  823.                                             UINT8 *pbVolume,
  824.                                             UINT8 *pLockFlag)
  825. {
  826.     if(pwPrgInx == NULL || pPrgInfo == NULL || pChnnlInfo == NULL
  827.         || pTrack == NULL || pbVolume == NULL || pLockFlag == NULL)
  828.     {
  829.         return RET_FAIL;
  830.     }
  831.     
  832.     if (nPrgType == DTVPRG)
  833.     {
  834.         *pwPrgInx = KD_GetPrgInxByTsidSvcID(nPrgType, 
  835.                                                 gE2pData.gDTVFavInfo.FavList[Favindex].TsId,
  836.                                                 gE2pData.gDTVFavInfo.FavList[Favindex].SrvId);
  837.         if (*pwPrgInx == KB_DB_INVALID_PROGRAMNO || KB_DBGetPrgInfo(*pwPrgInx, DTVPRG, pPrgInfo,
  838.             pChnnlInfo, pTrack, pbVolume, pLockFlag) != RET_OK)
  839.         {
  840.             return RET_FAIL;
  841.         }
  842.     }
  843.     else if (nPrgType == RADIOPRG)
  844.     {
  845.         *pwPrgInx = KD_GetPrgInxByTsidSvcID(nPrgType, 
  846.                                                 gE2pData.gRADFavInfo.FavList[Favindex].TsId,
  847.                                                 gE2pData.gRADFavInfo.FavList[Favindex].SrvId);
  848.         if (*pwPrgInx == KB_DB_INVALID_PROGRAMNO || KB_DBGetPrgInfo(*pwPrgInx, RADIOPRG, pPrgInfo,
  849.             pChnnlInfo, pTrack, pbVolume, pLockFlag) != RET_OK)
  850.         {
  851.             return RET_FAIL;
  852.         }
  853.     }
  854.     
  855.     return RET_OK;
  856. }
  858. KB_DBRET KB_DBGetChlNoByModPara(UINT16 pFreq,UINT16 wSymb,
  859.                                                     UINT8 bQam,UINT8 *pbChannelNo)
  860. {
  861.     UINT8 i;
  862.     
  863.     for (i = 0; i < gPrgAllInfo.gChnnlInfo.nTotal; ++i)
  864.     {
  865.         if (gPrgAllInfo.gChnnlInfo.ChannelList[i].Freq == pFreq
  866.             && gPrgAllInfo.gChnnlInfo.ChannelList[i].Symb == wSymb
  867.             && gPrgAllInfo.gChnnlInfo.ChannelList[i].QAM  == bQam)
  868.         {
  869.             *pbChannelNo = i;
  870.             return RET_OK;
  871.         }
  872.     }
  873.     
  874.     return RET_FAIL;
  875. }
  877. KB_DBRET KB_DBGetModParaByChlNo(UINT8 bChannelNo,UINT16 *pFre,
  878.                                             UINT16 *pSymb,UINT8 *pQam)
  879.                                             
  880. {  
  881.     *pFre = gPrgAllInfo.gChnnlInfo.ChannelList[bChannelNo].Freq;
  882.     *pSymb = gPrgAllInfo.gChnnlInfo.ChannelList[bChannelNo].Symb;
  883.     *pQam  = gPrgAllInfo.gChnnlInfo.ChannelList[bChannelNo].QAM;
  884.     return RET_OK;
  885. }
  887. KB_DBRET KB_DBGetSrchInfo(KB_DBSrchInfo *pSrchInfo)
  888. {
  889.     *pSrchInfo = gE2pData.gSrchInfo;
  890.     return RET_OK;
  891. }
  893. KB_DBRET KB_DBSaveSrchInfo(KB_DBSrchInfo *pSrchInfo)
  894. {
  895.     gE2pData.gSrchInfo = *pSrchInfo;
  896.     
  897.     if (KB_E2PWrite(KB_NVM_SEARCH_INFO_ADDR, (UINT8 *)&gE2pData.gSrchInfo, sizeof(KB_DBSrchInfo), NULL) != RETOK)
  898.     {
  899.         return RET_FAIL;
  900.     }
  901.     
  902.     return RET_OK;
  903. }
  905. KB_DBRET KB_DBGetCurPrgInfo(unsigned short *pPrgNO, unsigned char *pPrgType)
  906. {
  907.     *pPrgNO = gE2pData.gCurPrgInfo.prgNO;
  908.     *pPrgType = gE2pData.gCurPrgInfo.prgType;
  909.     return RET_OK;
  910. }
  912. KB_DBRET KB_DBGetTsIDByFre(UINT16 *TsID,unsigned long Fre)
  913. {
  914.     int i;
  915.     
  916.     if(TsID == NULL)
  917.     {
  918.         return RET_FAIL;
  919.     }
  920.     
  921.     for(i = 0;i< gPrgAllInfo.gChnnlInfo.nTotal;i++)
  922.     {
  923.         if(gPrgAllInfo.gChnnlInfo.ChannelList[i].Freq == Fre)
  924.         {
  925.             *TsID = gPrgAllInfo.gChnnlInfo.ChannelList[i].TSID;
  926.             return RET_OK;
  927.         }
  928.     }
  929.     
  930.     return RET_FAIL;
  931. }
  933. KB_DBRET KB_DBSaveCurPrgInfo(UINT16 nPrgNO, UINT8 nPrgType)
  934. {
  935.    
  936.     gE2pData.gCurPrgInfo.prgNO = nPrgNO;
  937.     gE2pData.gCurPrgInfo.prgType= nPrgType;
  939.    
  940.     if(KB_E2PWrite(KB_NVM_CUR_PGM_ADDR, (UINT8 *)&gE2pData.gCurPrgInfo, sizeof(KB_DBCurPrgInd), NULL) != RETOK)
  941.     {
  942.         return RET_FAIL;
  943.     }
  944.     
  945.     return RET_OK;
  946. }
  949. KB_DBRET KB_DBSavePrgAVPara(UINT16 nPrgNO, UINT8 nPrgType,unsigned short nPcrPID, 
  950.                                        unsigned short nAudioPID, 
  951.                                        unsigned short nVideoPID)
  952. {
  953.     unsigned short totalChannels;
  954.     
  955.     switch(nPrgType)
  956.     {
  957.     case RADIOPRG:
  958.         totalChannels = KB_DBGetPrgTotal(nPrgType);
  959.         if(nPrgNO > totalChannels || nPrgNO == 0)
  960.             return RET_FAIL;
  961.         
  962.         gPrgAllInfo.gRADInfo.PgmList[nPrgNO - 1].AudioPID  = nAudioPID;
  963.         gPrgAllInfo.gRADInfo.PgmList[nPrgNO - 1].VideoPID  = nVideoPID;
  964.         gPrgAllInfo.gRADInfo.PgmList[nPrgNO - 1].PCRPID  = nPcrPID;
  965.         
  966.         break;
  967.     //added by whale 07/05/25 start
  968.     case DATAPRG:
  969.         totalChannels = KB_DBGetPrgTotal(nPrgType);
  970.         if(nPrgNO > totalChannels || nPrgNO == 0)
  971.             return RET_FAIL;
  972.         
  973.         gPrgAllInfo.gDATAInfo.PgmList[nPrgNO - 1].AudioPID  = nAudioPID;
  974.         gPrgAllInfo.gDATAInfo.PgmList[nPrgNO - 1].VideoPID  = nVideoPID;
  975.         gPrgAllInfo.gDATAInfo.PgmList[nPrgNO - 1].PCRPID  = nPcrPID;
  976.         
  977.         break;
  978.     //added by whale 07/05/25 end
  979.     default:
  980.         totalChannels = KB_DBGetPrgTotal(nPrgType);
  981.         if(nPrgNO > totalChannels || nPrgNO == 0)
  982.             return RET_FAIL;
  983.         
  984.         gPrgAllInfo.gDTVInfo.PgmList[nPrgNO - 1].AudioPID  = nAudioPID;
  985.         gPrgAllInfo.gDTVInfo.PgmList[nPrgNO - 1].VideoPID  = nVideoPID;
  986.         gPrgAllInfo.gDTVInfo.PgmList[nPrgNO - 1].PCRPID  = nPcrPID;
  987.         
  988.         break;
  989.     }
  990.     return RET_OK;
  991. }
  993. KB_DBRET KB_DBChangePrgInfo(UINT16 nPrgInx, UINT8 nPrgType, 
  994.                                            KB_DBPrgInfo *pPrgInfo)
  995. {
  996.     
  997.     if (nPrgType == DTVPRG)
  998.     {
  999.         gPrgAllInfo.gDTVInfo.PgmList[nPrgInx] = *pPrgInfo;
  1000.         
  1001.         if (KB_FlashWrite(KB_DB_SECTOR, 0, (UINT8*)&gPrgAllInfo, sizeof(KB_DBPrgAllInfo)) != RETOK)
  1002.         {
  1003.             return RET_FAIL;
  1004.         }
  1005.     }
  1006.     else if (nPrgType == RADIOPRG)
  1007.     {
  1008.         gPrgAllInfo.gRADInfo.PgmList[nPrgInx] = *pPrgInfo;
  1009.         
  1010.         if (KB_FlashWrite(KB_DB_SECTOR, 0, (UINT8*)&gPrgAllInfo, sizeof(KB_DBPrgAllInfo)) != RETOK)
  1011.         {
  1012.             return RET_FAIL;
  1013.         }
  1014.     }
  1015.     //added by whale 07/05/25 start
  1016.     else if (nPrgType == DATAPRG)
  1017.     {
  1018.         gPrgAllInfo.gDATAInfo.PgmList[nPrgInx] = *pPrgInfo;
  1019.         
  1020.         if (KB_FlashWrite(KB_DB_SECTOR, 0, (UINT8*)&gPrgAllInfo, sizeof(KB_DBPrgAllInfo)) != RETOK)
  1021.         {
  1022.             return RET_FAIL;
  1023.         }
  1024.     }
  1025.     //added by whale 07/05/25 end
  1026.     return RET_OK;
  1027. }
  1032. static void KD_AddPrgToBuffer(UINT8 nPrgType, KB_DBPrgInfo *pPrgInfo)
  1033. {
  1034.     UINT16 indexofconfig;
  1035.     KB_DBPrgConfigNode *ptConfigNode;
  1036.     KB_DBPrgInfo *ptPgmNode;
  1037.     
  1038.     if (nPrgType == DTVPRG)
  1039.     {
  1040.         ptPgmNode = &gPrgAllInfo.gDTVInfo.PgmList[gPrgAllInfo.gDTVInfo.nTotal];
  1042.         indexofconfig = KD_GetFreeNumCfg(DTVPRG);
  1044.         gDtvCfgFlag[indexofconfig] = 1;
  1045.         ptConfigNode = &gE2pData.gDTVPrgCfgInfo[indexofconfig];
  1047.         ++gPrgAllInfo.gDTVInfo.nTotal;
  1048.     }
  1049.     else if (nPrgType == RADIOPRG)
  1050.     {
  1051.         ptPgmNode = &gPrgAllInfo.gRADInfo.PgmList[gPrgAllInfo.gRADInfo.nTotal];
  1053.         indexofconfig = KD_GetFreeNumCfg(RADIOPRG);
  1054.         gRadCfgFlag[indexofconfig] = 1;
  1055.         ptConfigNode = &gE2pData.gRADPrgCfgInfo[indexofconfig];
  1057.         ++gPrgAllInfo.gRADInfo.nTotal;
  1058.     }
  1059.     //added by whale 07/05/25 start
  1060.     else if (nPrgType == DATAPRG)
  1061.     {
  1062.         ptPgmNode = &gPrgAllInfo.gDATAInfo.PgmList[gPrgAllInfo.gDATAInfo.nTotal];
  1064.         indexofconfig = KD_GetFreeNumCfg(DATAPRG);
  1065.         gDataCfgFlag[indexofconfig] = 1;
  1066.         ptConfigNode = &gE2pData.gRADPrgCfgInfo[indexofconfig];
  1068.         ++gPrgAllInfo.gDATAInfo.nTotal;
  1069.     }
  1070.     //added by whale 07/05/25 end
  1071.     ptConfigNode->Lock_Track_Vol = 0x14;
  1072.     ptConfigNode->Flag = CONFIG_USED;
  1073.     ptPgmNode->IndexOfConfigInfo = indexofconfig;
  1074. }
  1076. void KB_DBAddPrgInfo(KB_DBPrgNode *prginfo,UINT16 prgSum,
  1077.                        unsigned short *addDtv, unsigned short *addMusic)
  1078. {
  1079.     int i, j;
  1080.     UINT16 prgtotal,prgMax;
  1081.     int found = 0;
  1082.     int len = 0;
  1083.     UINT8 prgType;
  1084.     unsigned short addDtvprg = 0,addMusicprg = 0;
  1085.     
  1086.     KB_DBPrgInfo *prgInfoPos = NULL;
  1087.     
  1088.     for(i = 0; i < prgSum; i ++)
  1089.     {
  1090.         if(prginfo[i].PATVersion != KB_DB_UNKNOWN_VERSION 
  1091. && prginfo[i].PMTVersion != KB_DB_UNKNOWN_VERSION)
  1092.         {
  1093.             //预防没有SDT下发的情况Srv_name,Srv_type,bCAFlag的设置，但是按现在的流程是走不到的
  1094.             if(prginfo[i].SDTVersion == KB_DB_UNKNOWN_VERSION)
  1095.             {
  1096.                 strcpy(prginfo[i].name, "未知节目名");
  1097.                 prginfo[i].bCAFlag = 0; 
  1098.                 if((prginfo[i].Video_Pid != 0) 
  1099. && (prginfo[i].Audio_Pid != 0) 
  1100. && (prginfo[i].PCR_Pid != 0))
  1101.                 {
  1102.                     prginfo[i].service_type = 0x01;
  1103.                 }
  1104.                 else if(prginfo[i].Video_Pid == 0 
  1105.     && prginfo[i].Audio_Pid != 0 
  1106.     && prginfo[i].PCR_Pid != 0)
  1107.                 {
  1108.                     prginfo[i].service_type = 0x02;
  1109.                 }
  1110.                 else
  1111.                 {
  1112.                     prginfo[i].service_type = 0;
  1113.                 }
  1114.             }
  1115.             //printf("-=prginfo[%d].service_type=0x%x=-n", i, prginfo[i].service_type);
  1116.             switch(prginfo[i].service_type)
  1117.             {
  1118.             case 0x01:
  1119.             case 0x02:
  1120.      //added by whale 07/05/25
  1121.      case 0x0C: 
  1122.                 if(prginfo[i].service_type == 0x01)
  1123.                 {
  1124.                     prgInfoPos = gPrgAllInfo.gDTVInfo.PgmList;
  1125.                     prgMax = KB_DB_MAX_DTV;
  1126.                     prgtotal = gPrgAllInfo.gDTVInfo.nTotal;
  1127.                     prgType = DTVPRG;
  1128.                     addDtvprg++;
  1129.                 }
  1130.                 else if(prginfo[i].service_type == 0x02)
  1131.                 {
  1132.                     prgInfoPos = gPrgAllInfo.gRADInfo.PgmList;
  1133.                     prgMax   = KB_DB_MAX_RAD;
  1134.                     prgtotal = gPrgAllInfo.gRADInfo.nTotal;
  1135.                     prgType = RADIOPRG;
  1136.                     addMusicprg ++;
  1137.                 }
  1138.                 //added by whale 07/05/25 start
  1139.                 else if(prginfo[i].service_type == 0x0C)
  1140.                 {
  1141.                     prgInfoPos = gPrgAllInfo.gDATAInfo.PgmList;
  1142.                     prgMax   = KB_DB_MAX_DATA;
  1143.                     prgtotal = gPrgAllInfo.gDATAInfo.nTotal;
  1144.                     prgType = DATAPRG;
  1145.       //printf("-=prgtotal=%d, prgType=%d=-n", prgtotal, prgType);
  1146.                  }
  1147.                 //added by whale 07/05/25 end
  1148.                 if(prgInfoPos == NULL)
  1149.                 {
  1150.                     return;
  1151.                 }
  1152.                 
  1153.                 if(prgtotal >= prgMax)
  1154.                 {
  1155.                     return;
  1156.                 }
  1157.                 for(j = 0; j < prgtotal; j++)
  1158.                 {
  1159.                     if( prgInfoPos[j].TSID == prginfo[i].TSID)
  1160.                     {
  1161.                         if(prgInfoPos[j].SvcID != prginfo[i].SerID)
  1162.                         {                        
  1163.                             continue;
  1164.                         }
  1165.                         prgInfoPos[j].AudioPID  = prginfo[i].Audio_Pid;
  1166.                         prgInfoPos[j].PCRPID  = prginfo[i].PCR_Pid;
  1167.                         prgInfoPos[j].VideoPID  = prginfo[i].Video_Pid;
  1168.                         prgInfoPos[j].ScrambleFlag = prginfo[i].bCAFlag;
  1169.                         len = strlen(prginfo[i].name);
  1170.                         if(len >= 20)
  1171.                         {
  1172.                             len = 18;
  1173.                         }
  1174.                         memset(prgInfoPos[j].Name,0,20);
  1175.                         memcpy(prgInfoPos[j].Name,prginfo[i].name,len);
  1176.                         prgInfoPos[j].Name[len] = '';
  1177.                         prgInfoPos[j].Name[len + 1] = '';
  1178.                         found = 1;
  1179.                         break;
  1180.                     }
  1181.                 }
  1183.                 if(found  == 1)
  1184.                 {
  1185.                     found = 0;
  1186.                     continue;
  1187.                 }
  1188.                 
  1189.                 prgInfoPos[j].TSID = prginfo[i].TSID;
  1190.                 prgInfoPos[j].PMTPID = prginfo[i].PMTPid;
  1191.                 prgInfoPos[j].PMTVersion = prginfo[i].PMTVersion;
  1192.                 prgInfoPos[j].SvcID = prginfo[i].SerID;
  1193.                 prgInfoPos[j].VideoPID = prginfo[i].Video_Pid;
  1194.                 prgInfoPos[j].AudioPID = prginfo[i].Audio_Pid;
  1195.                 prgInfoPos[j].PCRPID= prginfo[i].PCR_Pid;
  1196.                 prgInfoPos[j].ScrambleFlag = prginfo[i].bCAFlag;
  1197.                 
  1198.                 len = strlen(prginfo[i].name);
  1199.                 if(len >= 18)
  1200.                 {
  1201.                     len = 18;
  1202.                 }
  1203.                 
  1204.                 memset(prgInfoPos[j].Name,0,20);
  1205.                 memcpy(prgInfoPos[j].Name,prginfo[i].name,len);
  1206.                 prgInfoPos[j].Name[len] = '';
  1207.                 prgInfoPos[j].Name[len + 1] = '';
  1209.                 //IndexOfConfigInfo是 gPrgAllInfo中业务 与 gE2pData 联系的索引
  1210.                 //仅在下面函数申请连接一次,并更新全局数组gDtvCfgFlag/gRadCfgFlag/gDataCfgFlag
  1211.                 //                         更新gPrgAllInfo中某业务类型的nTotal  
  1212.                 KD_AddPrgToBuffer(prgType,NULL);
  1213.                 
  1214.                 break;
  1215.             case 0x04:
  1216.             case 0x05:
  1217.                 break;
  1218.      //masked by whale 07/05/25 start
  1219.             //case 0x0C:                
  1220.             //    break;
  1221.             //masked by whale 07/05/25 end
  1222.          }
  1223. }
  1224.     }
  1225.     
  1226.     *addDtv = addDtvprg;
  1227.     *addMusic = addMusicprg;
  1228.     return;
  1229. }
  1231. KB_DBRET KB_DBSavePrgInfo(int saveType)
  1232. {
  1233.     int i;
  1234.   
  1235.     if(saveType == 1)
  1236.     {
  1237.         //quicksort(gPrgAllInfo.gDTVInfo.PgmList,0,gPrgAllInfo.gDTVInfo.nTotal - 1);
  1238.         //quicksort(gPrgAllInfo.gRADInfo.PgmList,0,gPrgAllInfo.gRADInfo.nTotal - 1);
  1239.  //added by whale 07/05/25
  1240.  //quicksort(gPrgAllInfo.gDATAInfo.PgmList,0,gPrgAllInfo.gDATAInfo.nTotal - 1);
  1241.         //KB_DBSavePrgFavFlag(2,0,DTVPRG,NULL);
  1242.         //KB_DBSavePrgFavFlag(2,0,RADIOPRG,NULL);
  1243.     }
  1244.     
  1245.     KB_DBSaveToFlash();
  1246.     KB_DBFavPrgRefresh();
  1247.     
  1248.     for (i = 0; i < KB_DB_MAX_DTV; ++i)
  1249.     {
  1250.         if (gDtvCfgFlag[i] == 1)
  1251.         {
  1252.             if (KB_E2PWrite((UINT16)(KB_NVM_DTV_PGM_CFG_ADDR + i * sizeof(KB_DBPrgConfigNode)),
  1253.                 (UINT8 *)&gE2pData.gDTVPrgCfgInfo[i], 
  1254.                 sizeof(KB_DBPrgConfigNode), NULL) != RETOK)
  1255.             {
  1256.                 return RET_FAIL;
  1257.             }
  1258.             
  1259.         }
  1260.     }
  1261.     
  1262.     for (i = 0; i < KB_DB_MAX_RAD; ++i)
  1263.     {
  1264.         if (gRadCfgFlag[i] == 1)
  1265.         {
  1266.             if (KB_E2PWrite((UINT16)(KB_NVM_RAD_PGM_CFG_ADDR + i * sizeof(KB_DBPrgConfigNode)),
  1267.                 (UINT8 *)&gE2pData.gRADPrgCfgInfo[i],
  1268.                 sizeof(KB_DBPrgConfigNode), NULL) != RETOK)
  1269.             {
  1270.                 return RET_FAIL;
  1271.             }
  1272.             
  1273.         }
  1274.     }
  1275.     //added by whale 07/05/25 start
  1276.     for (i = 0; i < KB_DB_MAX_DATA; ++i)
  1277.     {
  1278.         if (gDataCfgFlag[i] == 1)
  1279.         {
  1280.             if (KB_E2PWrite((UINT16)(KB_NVM_DATA_PGM_CFG_ADDR + i * sizeof(KB_DBPrgConfigNode)),
  1281.                 (UINT8 *)&gE2pData.gDATAPrgCfgInfo[i],
  1282.                 sizeof(KB_DBPrgConfigNode), NULL) != RETOK)
  1283.             {
  1284.                 return RET_FAIL;
  1285.             }
  1286.             
  1287.         }
  1288.     }
  1289.     //added by whale 07/05/25 end
  1290.     KD_InitPrgConfig();
  1291.     
  1292.     return RET_OK;
  1293. }
  1295. static BOOL KB_DBIsPrgExist(UINT8    PrgType,
  1296.                              UINT16   TsId,
  1297.                              UINT16   SrvId)
  1298. {
  1299.     UINT16          i = 0;
  1300.     UINT16          max = 0;
  1301.     UINT16          total = 0;
  1302.     BOOL            ret = FALSE;
  1303.     KB_DBPrgInfo *prgInfo;
  1304.     
  1305.     switch(PrgType)
  1306.     {
  1307.     case DTVPRG:
  1308.         total = gPrgAllInfo.gDTVInfo.nTotal;
  1309.         max = KB_DB_MAX_DTV;
  1310.         prgInfo = gPrgAllInfo.gDTVInfo.PgmList;
  1311.         break;
  1312.         
  1313.     case RADIOPRG:
  1314.         total = gPrgAllInfo.gRADInfo.nTotal;
  1315.         max = KB_DB_MAX_RAD;
  1316.         prgInfo = gPrgAllInfo.gRADInfo.PgmList;
  1317.         break;
  1319.         default:
  1320.             printf("nKB_DBCheckPrgByTsIdSrvId::PrgType(%d) not support",
  1321.                     PrgType);
  1322.             return FALSE;
  1323.     }
  1324.     
  1325.     if ((NULL == prgInfo) || (0 == total) || (total > max)) 
  1326.     {
  1327.         printf("nKB_DBCheckPrgByTsIdSrvId::unknown error! prgInfo(0x%x), total(%d)",
  1328.                 prgInfo, total);
  1329.         return FALSE;
  1330.     }
  1331.     
  1332.     for(i = 0;i<total;i++)
  1333.     {
  1334.         if (prgInfo[i].SvcID == SrvId
  1335.             && prgInfo[i].TSID == TsId)
  1336.         {
  1337.             ret = TRUE;
  1338.             break;
  1339.         }
  1340.     }
  1341.     return ret;
  1342. }
  1343. #if 0
  1344. KB_DBRET KB_DBSavePrgFavFlag(UINT8 FavType,UINT16 nNumPrg, UINT8 nPrgType, UINT16 *pPrgToAdd)
  1345. {
  1346.     int total = 0;
  1347.     UINT8 *favTotal = NULL,numprg;
  1348.     int i,j,writeLen = 0,writeLen2 = 0;
  1349.     KB_DBFavNode *favPrgNo = NULL;
  1350.     UINT16 addrFav;
  1351.     UINT8 *writeAddr = NULL;
  1352.     UINT8 *writeAddr2 = NULL;
  1353.     KB_DBPrgInfo programInfo;
  1354.     KB_DBChnnlInfo channelInfo;
  1355.     UINT8 track;
  1356.     UINT8 volume;
  1357.     UINT8 lockFlag;
  1358.     
  1359.     if((pPrgToAdd == NULL) && (FavType != 2))
  1360.     {
  1361.         return RET_FAIL;
  1362.     }
  1363.     
  1364.     if(nPrgType != DTVPRG && nPrgType != RADIOPRG)
  1365.     {
  1366.         return RET_FAIL;
  1367.     }
  1368.     
  1369.     switch(nPrgType)
  1370.     {
  1371.     case DTVPRG:
  1372.         total = KB_DB_MAX_FAV_DTV;
  1373.         favTotal = &gE2pData.gDTVFavInfo.nTotal;
  1374.         favPrgNo  = gE2pData.gDTVFavInfo.FavList;
  1375.         addrFav = KB_NVM_FAV_DTV_ADDR;
  1376.         writeAddr = (UINT8 *)&gE2pData.gDTVFavInfo;
  1377.         writeLen = sizeof(KB_DBFavDtvInfo);
  1378.         writeAddr2 = (UINT8 *)&gE2pData.gDTVFavInfo;
  1379.         writeLen2 = sizeof(KB_DBFavDtvInfo);
  1380.         break;
  1381.         
  1382.     case RADIOPRG:
  1383.         total = KB_DB_MAX_FAV_RAD;
  1384.         favTotal = &gE2pData.gRADFavInfo.nTotal;
  1385.         favPrgNo  = gE2pData.gRADFavInfo.FavList;
  1386.         addrFav = KB_NVM_FAV_RAD_ADDR;
  1387.         writeAddr = (UINT8*)&gE2pData.gRADFavInfo;
  1388.         writeLen = sizeof(KB_DBPrgConfigNode);
  1389.         writeAddr2 = (UINT8 *)&gE2pData.gRADFavInfo;
  1390.         writeLen2 = sizeof(KB_DBFavRadInfo);
  1391.         break;
  1392.     }
  1393.     
  1394.     switch(FavType)
  1395.     {
  1396.     case 0:
  1397.         *favTotal = 0;
  1398.         numprg = 1;
  1399.         for( i = 1; i<= nNumPrg;i++)
  1400.         {
  1401.             if((pPrgToAdd[i] == KB_DB_PGM_FAVORITE) && ( numprg < total))
  1402.             {
  1403.                 if (KB_DBGetPrgInfo(i - 1, nPrgType, &programInfo, &channelInfo, &track, &volume, &lockFlag) == RET_OK)
  1404.                 {
  1405.                     favPrgNo[numprg].TsId = programInfo.TSID;
  1406.                     favPrgNo[numprg].SrvId = programInfo.SvcID;
  1407.                     *favTotal = numprg;
  1408.                     numprg ++;
  1409.                 }
  1410.             }
  1411.         }
  1412.         break;
  1413.         
  1414.     case 1:
  1415.         for( i = 1; i<= nNumPrg;i++)
  1416.         {
  1417.             {
  1418.                 favPrgNo[i ] = pPrgToAdd[i];
  1419.             }
  1420.         }
  1421.         break;
  1422.     case 2:
  1423.         numprg = *favTotal;
  1424.         for(i = 1;i <= numprg ;)
  1425.         {
  1426.             if(KB_DBIsPrgExist(nPrgType, favPrgNo[i].TsId, favPrgNo[i].SrvId) == FALSE)
  1427.             {
  1428.                 j = i;
  1429.                 for(j = i;j < numprg - 1 ;j++)
  1430.                 {
  1431.                     favPrgNo[j] = favPrgNo[j + 1];
  1432.                 }
  1433.                 numprg --;
  1434.             }
  1435.             else
  1436.             {
  1437.                 i++;
  1438.             }
  1439.         }
  1440.         *favTotal = numprg;
  1441.         break;
  1442.     default:
  1443.         break;
  1444.     }
  1445.     
  1446.     if(KB_E2PWrite(addrFav, writeAddr, writeLen, NULL) != RETOK)
  1447.     {
  1448.         return RET_FAIL;
  1449.     }
  1450.     
  1451.     return RET_OK;
  1452. }
  1453. #endif
  1454. KB_DBRET KB_DBGetSysPara(KB_DBSysInfo *pSysPara)
  1455. {
  1456.     *pSysPara = gE2pData.gSysPara;
  1457.     return RET_OK;
  1458. }
  1460. KB_DBRET KB_DBSaveSysPara(KB_DBSysInfo *pSysPara)
  1461. {
  1462.     
  1463.     gE2pData.gSysPara = *pSysPara;
  1464.     
  1465.     if (KB_E2PWrite(KB_NVM_SYS_PARA_ADDR, (UINT8 *)&gE2pData.gSysPara, sizeof(KB_DBSysInfo), NULL) != RETOK)
  1466.     {
  1467.         return RET_FAIL;
  1468.     }
  1469.     
  1470.     return RET_OK;
  1471. }
  1473. KB_DBRET KB_DBGetPwdInfo(KB_DBPwdInfo *pPwdInfo)
  1474. {
  1475.     *pPwdInfo = gE2pData.gPwdInfo;
  1476.     
  1477.     return RET_OK;
  1478. }
  1480. void KB_DBDelFavPrg(unsigned char type, UINT16 TsId, UINT16 SrvId)
  1481. {
  1482.     UINT8      find = 0;
  1483.     UINT16     i = 0;
  1484.     UINT16     j = 0;
  1485.     UINT16     nTotalNo = 0;  
  1486.     
  1487.     nTotalNo  = KB_DBGetFavPrgTotal(type) ;        
  1488.     
  1489.     if (DTVPRG == type)
  1490.     {
  1491.         if (nTotalNo == 0 || nTotalNo > KB_DB_MAX_FAV_DTV)
  1492.         {
  1493.             printf("nKB_DBDelFavPrg::dtv Total(%d) error", nTotalNo);
  1494.             return;
  1495.         }
  1496.         
  1497.         for(i = 0; i < nTotalNo; i++)
  1498.         {
  1499.             if(TsId == gE2pData.gDTVFavInfo.FavList[i].TsId
  1500.                && SrvId == gE2pData.gDTVFavInfo.FavList[i].SrvId)
  1501.             {
  1502.                 find = 1;
  1503.                 break;
  1504.             }
  1505.         }
  1506.         
  1507.         if (1 == find)
  1508.         {
  1509.             for(j = i; j < (nTotalNo - 1); j++)
  1510.             {
  1511.                 memcpy(&gE2pData.gDTVFavInfo.FavList[j], 
  1512.                        &gE2pData.gDTVFavInfo.FavList[j+1], 
  1513.                        sizeof(KB_DBFavNode));
  1514.             }
  1515.             gE2pData.gDTVFavInfo.nTotal --;
  1516.             
  1517.             if(KB_E2PWrite(KB_NVM_FAV_DTV_ADDR, ( UINT8 *)&gE2pData.gDTVFavInfo, sizeof(KB_DBFavDtvInfo), NULL) != RETOK)
  1518.          {
  1519.                 printf("nKB_DBDelFavPrg::KB_E2PWrite dtv fail");
  1520.                 return ;
  1521.          }
  1522.             
  1523.         }
  1524.     else
  1525.     {
  1526.             printf("nKB_DBDelFavPrg::specified type(0x%x)-TsId(0x%x)-SrvId(0x%x) not found in gE2pData",
  1527.                     type, TsId, SrvId);
  1528.         }
  1529.         return;
  1530.     }
  1531.     else if (RADIOPRG == type)
  1532.     {
  1533.         if (nTotalNo == 0 || nTotalNo > KB_DB_MAX_FAV_RAD)
  1534.         {
  1535.             printf("nKB_DBDelFavPrg::radio Total(%d) error", nTotalNo);
  1536.             return;
  1537.         }
  1538.         
  1539.         for(i = 0; i < nTotalNo;i++)
  1540.         {
  1541.             if(TsId == gE2pData.gRADFavInfo.FavList[i].TsId
  1542.                && SrvId == gE2pData.gRADFavInfo.FavList[i].SrvId)
  1543.             {
  1544.                 find = 1;
  1545.                 break;
  1546.             }
  1547.         }
  1548.         
  1549.         if(1 == find)
  1550.         {
  1551.             for(j = i; j < (nTotalNo - 1); j++)
  1552.             {
  1553.                 memcpy(&gE2pData.gRADFavInfo.FavList[j], 
  1554.                        &gE2pData.gRADFavInfo.FavList[j+1], 
  1555.                        sizeof(KB_DBFavNode));
  1556.             }
  1557.             gE2pData.gRADFavInfo.nTotal -- ;
  1558.             
  1559.             if(KB_E2PWrite(KB_NVM_FAV_DTV_ADDR, ( UINT8 *)&gE2pData.gRADFavInfo, sizeof(KB_DBPrgConfigNode), NULL) != RETOK)
  1560.          {
  1561.                 printf("nKB_DBDelFavPrg::KB_E2PWrite rad fail");
  1562.                 return ;
  1563.          }
  1564.         }
  1565.         else
  1566.         {
  1567.             printf("nKB_DBDelFavPrg::specified type(0x%x)-TsId(0x%x)-SrvId(0x%x) not found in gE2pData",
  1568.                     type, TsId, SrvId);
  1569.         }
  1570.         return;
  1571.     }
  1572.     else
  1573.     {
  1574.         printf("nKB_DBDelFavPrg::input type(%d) error", type);
  1575.         return;
  1576.     }
  1577.     
  1578.     return;
  1579. }
  1580. unsigned short KB_DBDelPrgInfo(unsigned char type,unsigned short nPrgInx)
  1581. {
  1582.     int nPgmNo = nPrgInx,i;
  1583.     int total;
  1584.     KB_DBPrgInfo *tmpPrgInfo = NULL;
  1585.     UINT16 SerID;
  1586.     
  1587.     total = KB_DBGetPrgTotal(type);
  1588.     
  1589.     if(nPgmNo >= total || nPgmNo < 0)
  1590.     {
  1591.         return KB_DB_DTV_FAILURE;
  1592.     }
  1593.     
  1594.     if (DTVPRG == type)
  1595.     {
  1596.         tmpPrgInfo = gPrgAllInfo.gDTVInfo.PgmList;
  1597.     }
  1598.     else if (RADIOPRG == type)
  1599.     {
  1600.         tmpPrgInfo = gPrgAllInfo.gRADInfo.PgmList;
  1601.     }
  1602.     else
  1603.     {
  1604.         printf("nKB_DBDelPrgInfo::input PrgType(%d) error!", type);
  1605.         return KB_DB_DTV_FAILURE;
  1606.     }
  1607.     SerID = tmpPrgInfo[nPgmNo].SvcID;
  1608.     KB_DBDelFavPrg(type, tmpPrgInfo[nPgmNo].TSID, SerID);
  1609.     
  1610.     for(i = nPgmNo;i < total - 1; i++)
  1611.     {
  1612.         memcpy(&tmpPrgInfo[i],&tmpPrgInfo[i + 1],sizeof(KB_DBPrgInfo));
  1613.     }
  1614.     
  1615.     if (DTVPRG == type)
  1616.     {
  1617.         gPrgAllInfo.gDTVInfo.nTotal --;
  1618.     }
  1619.     else if (RADIOPRG == type)
  1620.     {
  1621.         gPrgAllInfo.gRADInfo.nTotal --;
  1622.     }
  1623.     return KB_DB_DTV_SUCCESS;
  1624. }
  1626. KB_DBRET KB_DBSavePwdInfo(KB_DBPwdInfo *pPwdInfo)
  1627. {
  1628.     gE2pData.gPwdInfo = *pPwdInfo;
  1629.     
  1630.     if (KB_E2PWrite(KB_NVM_PASSWORD_ADDR, (UINT8* )&gE2pData.gPwdInfo, sizeof(KB_DBPwdInfo), NULL) != RETOK)
  1631.     {
  1632.         return RET_FAIL;
  1633.     }
  1634.     
  1635.     return RET_OK;
  1636. }
  1638. KB_DBRET KB_DBGetMailNum(UINT8 *pMailNum)
  1639. {
  1640.     if(pMailNum == NULL)
  1641.     {
  1642.         return RET_FAIL;
  1643.     }
  1644.     
  1645.     *pMailNum = gE2pData.gMailInfo.nTotal;
  1646.     return RET_OK;
  1647. }
  1650. KB_DBRET KB_DBSaveNvodInfo(KB_SIRefSvcCell AddNvodInfo)
  1651. {
  1652.     int total,i;
  1653.     total = gPrgAllInfo.gNVODInfo.nTotal;
  1654.     
  1655.     if(total >= KB_DB_MAX_NVOD)
  1656.     {
  1657.         return RET_FAIL;
  1658.     }
  1659.     //added by whale 07/03/28 for judging refsvcid repeat 
  1660.     for (i=0; i<total; i++)
  1661.     {
  1662. if (gPrgAllInfo.gNVODInfo.RefSvc[i].RefSvcId == AddNvodInfo.refScvId)
  1663. {
  1664. return RET_FAIL;
  1665. }
  1666.     }
  1667.     //add end
  1668.     gPrgAllInfo.gNVODInfo.RefSvc[total].RefSvcId = AddNvodInfo.refScvId;
  1669.     strcpy((char*)gPrgAllInfo.gNVODInfo.RefSvc[total].RefSvcName,(char*)AddNvodInfo.refScvName);
  1670.     gPrgAllInfo.gNVODInfo.RefSvc[total].TsID = AddNvodInfo.TsID;
  1671.     gPrgAllInfo.gNVODInfo.RefSvc[total].ShiftNum = 0;
  1672.     
  1673.     for(i = 0;i< AddNvodInfo.shiftSvcNum;i++)
  1674.     {
  1675.         gPrgAllInfo.gNVODInfo.RefSvc[total].ShiftList[i].ServiceId = 
  1676.             AddNvodInfo.shiftSvc[i].svcId;
  1677.         gPrgAllInfo.gNVODInfo.RefSvc[total].ShiftList[i].TSID= 
  1678.             AddNvodInfo.shiftSvc[i].tsId;
  1679.         gPrgAllInfo.gNVODInfo.RefSvc[total].ShiftNum ++;
  1680.     }
  1681.     gPrgAllInfo.gNVODInfo.nTotal ++;
  1682.     return RET_OK;
  1683. }
  1685. /*KB_DBRET KD_GetNvodNum(UINT8 *pNvodNum)
  1686. {
  1687.     *pNvodNum = gPrgAllInfo.gNVODInfo.nTotal;
  1688.     return RET_OK;
  1689. }*/
  1690. UINT8 KB_DBGetNvodNum(void)
  1691. {
  1692.     return gPrgAllInfo.gNVODInfo.nTotal;
  1693. }
  1695. KB_DBRET KB_DBGetNvodInfo(KB_SIRefSvcCell * pRefSvcInfo, int * o_pNums)
  1696. {
  1697.     int i,total,j;
  1699.     if((pRefSvcInfo == NULL ) || (o_pNums == NULL))
  1700.     {
  1701.         return RET_FAIL;
  1702.     }
  1703.     
  1704.     total = gPrgAllInfo.gNVODInfo.nTotal;
  1705.     * o_pNums = total;
  1706.     
  1707.     for(i = 0;i<total;i++)
  1708.     {
  1709.         pRefSvcInfo[i].refScvId = gPrgAllInfo.gNVODInfo.RefSvc[i].RefSvcId;
  1710. strcpy((char*)pRefSvcInfo[i].refScvName,
  1711. (char*)gPrgAllInfo.gNVODInfo.RefSvc[i].RefSvcName);
  1712.         pRefSvcInfo[i].TsID     = gPrgAllInfo.gNVODInfo.RefSvc[i].TsID;
  1713.         pRefSvcInfo[i].shiftSvcNum = gPrgAllInfo.gNVODInfo.RefSvc[i].ShiftNum;
  1714.         KB_DBGetChnlInfoByTsID(pRefSvcInfo[i].TsID,
  1715. &pRefSvcInfo[i].freq,&pRefSvcInfo[i].symb,(UINT8*)&pRefSvcInfo[i].qam);
  1717.         for( j = 0;j < gPrgAllInfo.gNVODInfo.RefSvc[i].ShiftNum;j++)
  1718.         {
  1719.             pRefSvcInfo[i].shiftSvc[j].svcId = gPrgAllInfo.gNVODInfo.RefSvc[i].ShiftList[j].ServiceId;
  1720.             pRefSvcInfo[i].shiftSvc[j].tsId = gPrgAllInfo.gNVODInfo.RefSvc[i].ShiftList[j].TSID;
  1721.         }
  1722.     }
  1723.     
  1724.     return RET_OK;
  1725. }
  1727. KB_DBRET KB_DBGetChnlInfoByTsID(UINT16 TSID,
  1728.                                              unsigned short *pFreq,unsigned short *pSymbl,unsigned char  *pQam)
  1729. {
  1730.     int i,find = 0;
  1731.     
  1732.     if( (pFreq == NULL) || (pSymbl == NULL) || (pQam == NULL))
  1733.     {
  1734.         return RET_FAIL;
  1735.     }
  1736.     
  1737.     for(i = 0;i< gPrgAllInfo.gChnnlInfo.nTotal;i++)
  1738.     {
  1739.         if(gPrgAllInfo.gChnnlInfo.ChannelList[i].TSID == TSID)
  1740.         {
  1741.             find = 1;
  1742.             break;
  1743.         }
  1744.     }
  1745.     
  1746.     if(find == 1)
  1747.     {
  1748.         *pFreq = gPrgAllInfo.gChnnlInfo.ChannelList[i].Freq;
  1749.         *pSymbl = gPrgAllInfo.gChnnlInfo.ChannelList[i].Symb;
  1750.         *pQam = gPrgAllInfo.gChnnlInfo.ChannelList[i].QAM;
  1751.     }
  1752.     else
  1753.     {
  1754.         *pFreq = 0;
  1755.         *pSymbl = 0;
  1756.         *pQam = 0;
  1757.     }
  1758.     
  1759.     return RET_OK;
  1760. }
  1762. KB_DBRET KB_DBSaveToFlash()
  1763. {
  1764.     
  1765.     if (KB_FlashWrite(KB_DB_SECTOR, 0, (UINT8*)&gPrgAllInfo, sizeof(KB_DBPrgAllInfo)) != RETOK)
  1766.     {
  1767.         return RET_FAIL;
  1768.     }
  1769.     
  1770.     return RET_OK;
  1771. }
  1773. static UINT16 KD_GetFreeNumCfg(UINT8 nPrgType) 
  1774. {
  1775.     UINT16 i;
  1776.     
  1777.     switch(nPrgType)
  1778.     {
  1779.     case DTVPRG: 
  1780.         for (i = 0; i < KB_DB_MAX_DTV; ++i)
  1781.         {
  1782.             if(gE2pData.gDTVPrgCfgInfo[i].Flag == CONFIG_NO_USED)
  1783.             {
  1784.                 return i;
  1785.             }
  1786.         }
  1787.         break;
  1788.         
  1789.     case RADIOPRG:
  1790.         for (i = 0; i < KB_DB_MAX_RAD; ++i)
  1791.         {
  1792.             if(gE2pData.gRADPrgCfgInfo[i].Flag == CONFIG_NO_USED)
  1793.             {
  1794.                 return i;
  1795.             }
  1796.         }
  1797.         break;
  1798.     //added by whale 07/05/25 start
  1799.     case DATAPRG:
  1800.         for (i = 0; i < KB_DB_MAX_DATA; ++i)
  1801.         {
  1802.             if(gE2pData.gDATAPrgCfgInfo[i].Flag == CONFIG_NO_USED)
  1803.             {
  1804.                 return i;
  1805.             }
  1806.         }
  1807.         break;
  1808.     //added by whale 07/05/25 end
  1809.     }
  1810.     
  1811.     return RET_OK;
  1812. }
  1814. KB_DBRET KB_DBReset(void)
  1815. {
  1816.     KB_DBRET tRet;
  1817.     
  1818.     gPrgAllInfo.gChnnlInfo.nTotal = 0;
  1819.     memset(&gPrgAllInfo.gChnnlInfo,0,sizeof(KB_DBDTVChnnlInfo));
  1820.     if (KB_DBResetDtvInfo(BufferSave) != RET_OK)
  1821.     {
  1822.         printf("n[DB]:KB_DBResetDtvInfo error");
  1823.         return RET_FAIL;
  1824.     }
  1825.     
  1826.     if (KD_ResetFavDtv() != RET_OK)
  1827.     {
  1828.      printf("n[DB]:KD_ResetFavDtv error");
  1829.         return RET_FAIL;
  1830.     }
  1831.     
  1832.     if (KB_DBResetRadInfo(BufferSave) != RET_OK)
  1833.     {
  1834.      printf("n[DB]:KB_DBResetRadInfo error");
  1835.         return RET_FAIL;
  1836.     }
  1837.     
  1838.     if (KD_ResetFavRad() != RET_OK)
  1839.     {
  1840.      printf("n[DB]:KD_ResetFavRad error");
  1841.         return RET_FAIL;
  1842.     }
  1843.     //added by whale 07/05/25 start
  1844.     if (KB_DBResetDataInfo(BufferSave) != RET_OK)
  1845.     {
  1846.         printf("n[DB]:KB_DBResetDataInfo error");
  1847.         return RET_FAIL;
  1848.     }
  1849.     //added by whale 07/05/25 end
  1850.     KD_ResetNvodInfo(BufferSave);
  1851.     
  1852.     tRet = KD_ResetCurPrgInfo();
  1853.     if (tRet != RET_OK)
  1854.     {
  1855.      printf("n[DB]:KD_ResetCurPrgInfo error");
  1856.         return tRet;
  1857.     }
  1858.     tRet = KD_ResetSysparInfo();
  1859.     if (tRet != RET_OK)
  1860.     {
  1861.      printf("n[DB]:KD_ResetSysparInfo error");
  1862.         return tRet;
  1863.     }
  1864.     
  1865.     tRet = KD_ResetPwdInfo();
  1866.     if (tRet != RET_OK)
  1867.     {
  1868.      printf("n[DB]:KD_ResetPwdInfo error");
  1869.         return tRet;
  1870.     }
  1871.     
  1872.     
  1873.     tRet = KD_ResetSrchInfo();
  1874.     if (tRet != RET_OK)
  1875.     {
  1876.      printf("n[DB]:KD_ResetSrchInfo error");
  1877.         return tRet;
  1878.     }
  1879.     
  1880.     tRet = KD_ResetMailInfo();
  1881.     if (tRet != RET_OK)
  1882.     {
  1883.      printf("n[DB]:KD_ResetMailInfo error");
  1884.         return tRet;
  1885.     }
  1886.     
  1887.     //added by yyj 2007.6.27 start
  1889. tRet = KD_ResetVideoDispMode();
  1890. if (tRet != RET_OK)
  1891. {
  1892.     printf("n[DB]:KD_ResetVideoDispMode error");
  1893.     return tRet;
  1894. }
  1896. tRet = KD_ResetVideoAspectRatio();
  1897. if (tRet != RET_OK)
  1898. {
  1899.     printf("n[DB]:KD_ResetVideoAspectRatio error");
  1900.     return tRet;
  1901. }
  1903. tRet = KD_ResetPgmCurVol();
  1904. if (tRet != RET_OK)
  1905. {
  1906.     printf("n[DB]:KD_ResetPgmCurVol error");
  1907.     return tRet;
  1908. }
  1910. tRet = KD_ResetPgmCurTrack();
  1911. if (tRet != RET_OK)
  1912. {
  1913.     printf("n[DB]:KD_ResetPgmCurTrack error");
  1914.     return tRet;
  1915. }
  1917. tRet = KD_ResetAdultRank();
  1918. if (tRet != RET_OK)
  1919. {
  1920.     printf("n[DB]:KD_ResetAdultRank error");
  1921.     return tRet;
  1922. }
  1924. tRet = KD_ResetMenuLan();
  1925. if (tRet != RET_OK)
  1926. {
  1927.     printf("n[DB]:KD_ResetMenuLan error");
  1928.     return tRet;
  1929. }
  1931. tRet = KD_ResetMenuTran();
  1932. if (tRet != RET_OK)
  1933. {
  1934.     printf("n[DB]:KD_ResetMenuTran error");
  1935.     return tRet;
  1936. }
  1937.     //added by yyj 2007.6.27 end
  1938.     
  1939. //added by yyj 2007.7.3 start
  1940.  tRet = KD_ResetDemandInfo();
  1941. if (tRet != RET_OK)
  1942. {
  1943.     printf("n[DB]:KD_ResetDemandInfo error");
  1944.     return tRet;
  1945. }
  1946. //added by yyj 2007.7.3 end
  1948.     if (KB_FlashWrite(KB_DB_SECTOR, 0, (UINT8*)&gPrgAllInfo, sizeof(KB_DBPrgAllInfo)) != RETOK)
  1949.     {
  1950.         printf("n[DB]:KB_FlashWrite error");
  1951.         return RET_FAIL;
  1952.     }
  1953. printf("n[DB]:Data base reset ok.");
  1954.     return RET_OK;
  1955. }
  1957. KB_DBRET KD_GetSvcList(KB_DBListInfo *pSvcList)
  1958. {
  1959.     *pSvcList = gE2pData.stServiceListInfo;
  1960.     
  1961.     return RET_OK;
  1962. }
  1964. KB_DBRET KD_SaveSvcList(KB_DBListInfo *pSvcList)
  1965. {
  1966.     gE2pData.stServiceListInfo = *pSvcList;
  1967.     
  1968.     if (KB_E2PWrite(KB_NVM_SERVICELIST_INFO_ADDR, (UINT8* )&gE2pData.stServiceListInfo, sizeof(KB_DBListInfo), NULL) != RETOK)
  1969.     {
  1970.         return RET_FAIL;
  1971.     }
  1972.     
  1973.     return RET_OK;
  1974. }
  1976. static KB_DBRET KD_ResetMailInfo(void)
  1977. {
  1978.     UINT8 i;
  1979.     
  1980.     gE2pData.gMailInfo.nTotal = 0;
  1981.     
  1982.     if (KB_E2PWrite(KB_NVM_MAIL_INDEX_ADDR, (UINT8 *)(&gE2pData.gMailInfo), sizeof(KB_DBMailIndex), NULL) != RETOK)
  1983.     {
  1984.         return RET_FAIL;
  1985.     }
  1986.     
  1987.     
  1988.     for (i = 0; i < KB_DB_MAX_MAIL; ++i)
  1989.     {
  1990.         gMailInfo[i].Flag = CONFIG_NO_USED;
  1991.     }
  1992.     
  1993.     return RET_OK;
  1994. }
  1996. KB_DBRET KB_DBResetChnnlInfo(UINT8 bType)
  1997. {
  1998.     gPrgAllInfo.gChnnlInfo.nTotal = 0;
  1999.     memset(&gPrgAllInfo.gChnnlInfo,0,sizeof(KB_DBDTVChnnlInfo));
  2000.     KD_ResetNvodInfo(BufferSave);
  2002.     return RET_OK;
  2003. }
  2005. static KB_DBRET KD_InitChnnlInfo()
  2006. {
  2007.     if (gPrgAllInfo.gChnnlInfo.nTotal > KB_DB_MAX_CHANNEL_NUM)
  2008.     {
  2009.         return RET_FAIL;
  2010.     }
  2011.     
  2012.     return RET_OK;
  2013. }
  2014. static KB_DBRET KD_InitCurPrgInfo(void)
  2015. {
  2016.     if (KB_E2PRead(KB_NVM_CUR_PGM_ADDR, (UINT8 *)&gE2pData.gCurPrgInfo, sizeof(KB_DBCurPrgInd), NULL) != RETOK)
  2017.     {
  2018.         return RET_FAIL;
  2019.     }
  2020.     
  2021.     return RET_OK;
  2022. }
  2024. static KB_DBRET KD_InitDtvInfo()
  2025. {
  2026.     UINT16 i, sum;
  2027.     
  2028.     sum = gPrgAllInfo.gDTVInfo.nTotal;
  2029.     if (sum > KB_DB_MAX_DTV)
  2030.     {
  2031.         return RET_FAIL;
  2032.     }
  2033.     
  2034.     for (i = 0; i < sum; ++i)
  2035.     {
  2036.         gE2pData.gDTVPrgCfgInfo[i].Flag = CONFIG_USED + 1;
  2037.     }
  2038.     
  2039.     return RET_OK;
  2040. }
  2041. //added by whale 07/05/25 start
  2042. static KB_DBRET KD_InitDataInfo(void)
  2043. {
  2044.     UINT16 i, sum;
  2045.     
  2046.     sum = gPrgAllInfo.gDATAInfo.nTotal;
  2047.     if (sum > KB_DB_MAX_DATA)
  2048.     {
  2049.         return RET_FAIL;
  2050.     }
  2051.     
  2052.     for (i = 0; i < sum; ++i)
  2053.     {
  2054.         gE2pData.gDATAPrgCfgInfo[i].Flag = CONFIG_USED + 1;
  2055.     }
  2056.     
  2057.     return RET_OK;
  2058. }
  2059. //added by whale 07/05/25 end
  2060. KB_DBRET KB_DBResetDtvInfo(UINT8 bType)
  2061. {
  2062.     UINT16 i,len;
  2063.     UINT8 flag = CONFIG_NO_USED;
  2064.     
  2065.     
  2066.     len = gPrgAllInfo.gDTVInfo.nTotal ;
  2067.     if(len > KB_DB_MAX_DTV)
  2068.     {
  2069.         len = KB_DB_MAX_DTV;
  2070.     }
  2071. gPrgAllInfo.gDTVInfo.nTotal = 0;
  2073.     for (i = 0; i < KB_DB_MAX_DTV; ++i)
  2074.     {
  2075.         if (gE2pData.gDTVPrgCfgInfo[i].Flag == CONFIG_USED
  2076.             || gE2pData.gDTVPrgCfgInfo[i].Flag == CONFIG_USED + 1)
  2077.         {
  2078.             gE2pData.gDTVPrgCfgInfo[i].Flag = CONFIG_NO_USED;
  2079.             if (KB_E2PWrite((UINT16)(KB_NVM_DTV_PGM_CFG_ADDR + i * sizeof(KB_DBPrgConfigNode)),
  2080.                 (UINT8 *)&flag, sizeof(UINT8), NULL) != RETOK)
  2081.             {
  2082.                 return RET_FAIL;
  2083.             }
  2084.         }
  2085.     }
  2086.     
  2087.     if (bType == FlashSave)
  2088.     {
  2089.         if (KB_FlashWrite(KB_DB_SECTOR, 0, (UINT8*)&gPrgAllInfo, sizeof(KB_DBPrgAllInfo)) != RETOK)
  2090.         {
  2091.             return RET_FAIL;
  2092.         }
  2093.     }
  2094.     
  2095.     return RET_OK;
  2096. }
  2098. KB_DBRET KB_DBResetRadInfo(UINT8 bType)
  2099. {
  2100.     UINT16 i,serID,len;
  2101.     UINT8 flag = CONFIG_NO_USED;
  2102.     
  2103.     
  2104.     len = gPrgAllInfo.gRADInfo.nTotal ;
  2105.     if(len > KB_DB_MAX_RAD)
  2106.     {
  2107.         len = KB_DB_MAX_RAD;
  2108.     }
  2109.     for(i = 0;i< len;i++)
  2110.     {
  2111.         serID = gPrgAllInfo.gRADInfo.PgmList[i].SvcID;
  2112.     }
  2113.     gPrgAllInfo.gRADInfo.nTotal = 0;
  2114.     
  2115.     for (i = 0; i < KB_DB_MAX_RAD; ++i)
  2116.     {
  2117.         if (gE2pData.gRADPrgCfgInfo[i].Flag == CONFIG_USED
  2118.             || gE2pData.gRADPrgCfgInfo[i].Flag == CONFIG_USED + 1)
  2119.         {
  2120.             gE2pData.gRADPrgCfgInfo[i].Flag = CONFIG_NO_USED;
  2121.             
  2122.             if (KB_E2PWrite((UINT16)(KB_NVM_RAD_PGM_CFG_ADDR + i * sizeof(KB_DBPrgConfigNode)),
  2123.                 (UINT8 *)&flag, sizeof(UINT8), NULL) != RETOK)
  2124.             {
  2125.                 return RET_FAIL;
  2126.             }
  2127.             
  2128.         }
  2129.     }
  2130.     
  2131.     if (bType == FlashSave)
  2132.     {
  2133.         if (KB_FlashWrite(KB_DB_SECTOR, 0, (UINT8*)&gPrgAllInfo, sizeof(KB_DBPrgAllInfo)) != RETOK)
  2134.         {
  2135.             return RET_FAIL;
  2136.         }
  2137.     }
  2138.     
  2139.     return RET_OK;
  2140. }
  2141. //added by whale 07/05/25 start
  2142. KB_DBRET KB_DBResetDataInfo(UINT8 bType)
  2143. {
  2144.     UINT16 i,len;
  2145.     UINT8 flag = CONFIG_NO_USED;
  2146.     
  2147.     
  2148.     len = gPrgAllInfo.gDATAInfo.nTotal ;
  2149.     if(len > KB_DB_MAX_DATA)
  2150.     {
  2151.         len = KB_DB_MAX_DATA;
  2152.     }
  2153. gPrgAllInfo.gDATAInfo.nTotal = 0;
  2155.     for (i = 0; i < KB_DB_MAX_DATA; ++i)
  2156.     {
  2157.         if (gE2pData.gDATAPrgCfgInfo[i].Flag == CONFIG_USED
  2158.             || gE2pData.gDATAPrgCfgInfo[i].Flag == CONFIG_USED + 1)
  2159.         {
  2160.             gE2pData.gDATAPrgCfgInfo[i].Flag = CONFIG_NO_USED;
  2161.             if (KB_E2PWrite((UINT16)(KB_NVM_DTV_PGM_CFG_ADDR + i * sizeof(KB_DBPrgConfigNode)),
  2162.                 (UINT8 *)&flag, sizeof(UINT8), NULL) != RETOK)
  2163.             {
  2164.                 return RET_FAIL;
  2165.             }
  2166.         }
  2167.     }
  2168.     
  2169.     if (bType == FlashSave)
  2170.     {
  2171.         if (KB_FlashWrite(KB_DB_SECTOR, 0, (UINT8*)&gPrgAllInfo, sizeof(KB_DBPrgAllInfo)) != RETOK)
  2172.         {
  2173.             return RET_FAIL;
  2174.         }
  2175.     }
  2176.     
  2177.     return RET_OK;
  2178. }
  2179. //added by whale 07/05/25 end
  2180. static KB_DBRET KD_ResetNvodInfo(UINT8 bType)
  2181. {
  2182.     gPrgAllInfo.gNVODInfo.nTotal = 0;
  2183.     return RET_OK;
  2184. }
  2185. //added by whale 07/06/01 start
  2186. void KB_DBClearAllProg (void)
  2187. {
  2188. KB_DBResetDtvInfo(BufferSave);
  2189. KB_DBResetRadInfo(BufferSave);
  2190. KB_DBResetDataInfo(BufferSave);
  2191. KD_ResetNvodInfo(BufferSave);
  2192. KB_DBResetChnnlInfo(BufferSave);
  2193. KB_FlashErase(KB_DB_SECTOR);
  2194. }
  2195. //added by whale 07/06/01 end
  2196. static KB_DBRET KD_InitNvodInfo(void)
  2197. {
  2198.     UINT16 sum;
  2199.     
  2200.     sum = gPrgAllInfo.gNVODInfo.nTotal;
  2201.     if (sum > KB_DB_MAX_NVOD)
  2202.     {
  2203.         return RET_FAIL;
  2204.     }
  2205.     
  2206.     return RET_OK;
  2207. }
  2208. static KB_DBRET KD_InitSysparInfo(void)
  2209. {
  2210.     if (KB_E2PRead(KB_NVM_SYS_PARA_ADDR, (UINT8 *)&gE2pData.gSysPara, sizeof(KB_DBSysInfo), NULL) != RETOK)
  2211.     {
  2212.         return RET_FAIL;
  2213.     }
  2215.     return RET_OK;
  2216. }
  2217. KB_DBRET KD_ResetCurPrgInfo(void)
  2218. {
  2219.     gE2pData.gCurPrgInfo.prgNO = 1;
  2220.     gE2pData.gCurPrgInfo.prgType = DTVPRG;
  2221.     
  2222.     if (KB_E2PWrite(KB_NVM_CUR_PGM_ADDR, (UINT8 *)&gE2pData.gCurPrgInfo, sizeof(KB_DBCurPrgInd), NULL) != RETOK)
  2223.     {
  2224.         return RET_FAIL;
  2225.     }
  2226.     else
  2227.         
  2228.     {
  2229.         return RET_OK;
  2230.     }
  2231. }
  2233. static KB_DBRET KD_ResetNetInfo(void)
  2234. {
  2235.     gE2pData.gNetInfo.NetworkName[0] = '';
  2236.     gE2pData.gNetInfo.NitVersion = 0;
  2237.     
  2238.     if (KB_E2PWrite(KB_NVM_NETWORK_INFO_ADDR, (UINT8 *)&gE2pData.gNetInfo, sizeof(KB_DBNetInfo), NULL) != RETOK)
  2239.     {
  2240.         return RET_FAIL;
  2241.     }
  2242.     else
  2243.         
  2244.     {
  2245.         return RET_OK;
  2246.     }
  2247. }
  2249. static KB_DBRET KD_ResetPwdInfo(void)
  2250. {
  2251.     gE2pData.gPwdInfo.PwdSwitch = PSW_OFF;
  2252.     strcpy((char *)gE2pData.gPwdInfo.Password, "8888");
  2253.     
  2254.     if (KB_E2PWrite(KB_NVM_PASSWORD_ADDR, (UINT8 *)&gE2pData.gPwdInfo, sizeof(KB_DBPwdInfo), NULL) != RETOK)
  2255.     {
  2256.         return RET_FAIL;
  2257.     }
  2258.     
  2259.     
  2260.     return RET_OK;
  2261. }
  2263. static KB_DBRET KD_ResetSysparInfo(void)
  2264. {
  2265.     gE2pData.gSysPara.ScreenFormat = KB_AV_ASPECT_RATIO_4TO3;
  2266.     gE2pData.gSysPara.Language = CHINESE;
  2267.     gE2pData.gSysPara.IPAddress[0] =  192;
  2268.     gE2pData.gSysPara.IPAddress[1] =  168;
  2269.     gE2pData.gSysPara.IPAddress[2] =  0;
  2270.     gE2pData.gSysPara.IPAddress[3] =  96;
  2271.     gE2pData.gSysPara.Mask[0] = 255;
  2272.     gE2pData.gSysPara.Mask[1] = 255;
  2273.     gE2pData.gSysPara.Mask[2] = 255;
  2274.     gE2pData.gSysPara.Mask[3] = 0;
  2275.     gE2pData.gSysPara.TimeZone = 8;
  2276.     gE2pData.gSysPara.timeDateUserOffset=0;//lsp 07/3/14
  2277.     gE2pData.gSysPara.ShutDownInfo = 0xff;
  2278.     gE2pData.gSysPara.SetUpInfo    = 0xff;
  2279.     
  2280.     if (KB_E2PWrite(KB_NVM_SYS_PARA_ADDR, (UINT8 *)&gE2pData.gSysPara, sizeof(KB_DBSysInfo), NULL) != RETOK)
  2281.     {
  2282.         return RET_FAIL;
  2283.     }
  2284.     else
  2285.     {
  2286.         return RET_OK;
  2287.     }
  2288. }
  2290. static KB_DBRET KD_ResetFavRad(void)
  2291. {
  2292.     gE2pData.gRADFavInfo.nTotal = 0;
  2293.     
  2294.     
  2295.     if (KB_E2PWrite(KB_NVM_FAV_RAD_ADDR, (UINT8 *)&gE2pData.gRADFavInfo, sizeof(KB_DBFavRadInfo), NULL) != RETOK)
  2296.     {
  2297.         printf("nKD_ResetFavRad::KB_E2PWrite fail");
  2298.         return RET_FAIL;
  2299.     }
  2300.     else
  2301.     {
  2302.         return RET_OK;
  2303.     }
  2304. }
  2306. static KB_DBRET KD_InitPwdInfo(void)
  2307. {
  2308.     if (KB_E2PRead(KB_NVM_PASSWORD_ADDR, (UINT8 *)&gE2pData.gPwdInfo, sizeof(KB_DBPwdInfo), NULL) != RETOK)
  2309.     {
  2310.         return RET_FAIL;
  2311.     }
  2312.     return RET_OK;
  2313. }
  2314. static KB_DBRET KD_InitRadInfo()
  2315. {
  2316.     UINT16 i, sum;
  2317.     
  2318.     sum = gPrgAllInfo.gRADInfo.nTotal;
  2319.     if (sum > KB_DB_MAX_RAD)
  2320.     {
  2321.         return RET_FAIL;
  2322.     }
  2323.     
  2324.     for (i = 0; i < sum; ++i)
  2325.     {
  2326.         gE2pData.gRADPrgCfgInfo[i].Flag = CONFIG_USED + 1;
  2327.     }
  2328.     
  2329.     return RET_OK;
  2330. }
  2331. static KB_DBRET KD_InitSrchInfo(void)
  2332. {
  2333.     if (KB_E2PRead(KB_NVM_SEARCH_INFO_ADDR, (UINT8 *)&gE2pData.gSrchInfo, sizeof(KB_DBSrchInfo), NULL) != RETOK)
  2334.     {
  2335.         return RET_FAIL;
  2336.     }
  2338.     return RET_OK;
  2339. }
  2340. static KB_DBRET KD_ResetSrchInfo(void)
  2341. {
  2342.     
  2343.     gE2pData.gSrchInfo.Frequency = 256 * 10;
  2344.     gE2pData.gSrchInfo.SymbolRate = 6875;
  2345.     gE2pData.gSrchInfo.QamType =  QAM64;
  2346.     gE2pData.gSrchInfo.SearchNIT = 1;
  2347.     
  2348.     
  2349.     if (KB_E2PWrite(KB_NVM_SEARCH_INFO_ADDR, (UINT8 *)&gE2pData.gSrchInfo, sizeof(KB_DBSrchInfo), NULL) != RETOK)
  2350.     {
  2351.         return RET_FAIL;
  2352.     }
  2353.     else
  2354.     {
  2355.         return RET_OK;
  2356.     }
  2357.     
  2358.     
  2359. }
  2361. static KB_DBRET KD_ResetFavDtv(void)
  2362. {
  2363.     gE2pData.gDTVFavInfo.nTotal = 0;
  2364.     
  2365.     
  2366.     if (KB_E2PWrite(KB_NVM_FAV_DTV_ADDR, (UINT8 *)&gE2pData.gDTVFavInfo, sizeof(KB_DBFavDtvInfo), NULL) != RETOK)
  2367.     {
  2368.         printf("nKD_ResetFavDtv::KB_E2PWrite fail");
  2369.         return RET_FAIL;
  2370.     }
  2371.     else
  2372.     {
  2373.         return RET_OK;
  2374.     }
  2375. }
  2377. static KB_DBRET KD_InitFavDtv(void)
  2378. {
  2379.     if (KB_E2PRead(KB_NVM_FAV_DTV_ADDR, (UINT8 *)&gE2pData.gDTVFavInfo, sizeof(KB_DBFavDtvInfo), NULL) != RETOK)
  2380.     {
  2381.         printf("nKD_InitFavDtv::KB_E2PRead fail");
  2382.         return RET_FAIL;
  2383.     }
  2384.     
  2385.     return RET_OK;
  2386. }
  2388. static KB_DBRET KD_InitFavRad(void)
  2389. {
  2390.     if (KB_E2PRead(KB_NVM_FAV_RAD_ADDR, (UINT8*)&gE2pData.gRADFavInfo, sizeof(KB_DBFavRadInfo), NULL) != RETOK)
  2391.     {
  2392.         printf("nKD_InitFavRad::KB_E2PRead fail");
  2393.         return RET_FAIL;
  2394.     }
  2395.     
  2396.     return RET_OK;
  2397. }
  2400. static void KD_InitPrgConfig(void)
  2401. {
  2402.     UINT16 i;
  2403.     
  2404.     for (i = 0; i < KB_DB_MAX_DTV; ++i)
  2405.     {
  2406.         gDtvCfgFlag[i] = 0;
  2407.     }
  2408.     for (i = 0; i < KB_DB_MAX_RAD; ++i)
  2409.     {
  2410.         gRadCfgFlag[i] = 0;
  2411.     }
  2412.     //added by whale 07/05/25 start
  2413.     for (i = 0; i < KB_DB_MAX_DATA; ++i)
  2414.     {
  2415.         gDataCfgFlag[i] = 0;
  2416.     }
  2417.     //added by whale 07/05/25 end
  2418. }
  2420. static KB_DBRET KD_InitNetInfo(void)
  2421. {
  2422.     if (KB_E2PRead(KB_NVM_NETWORK_INFO_ADDR, (UINT8 *)&gE2pData.gNetInfo, sizeof(KB_DBNetInfo), NULL) != RETOK)
  2423.     {
  2424.         return RET_FAIL;
  2425.     }
  2426.     
  2427.     return RET_OK;
  2428. }
  2430. static KB_DBRET KD_InitMail(void)
  2431. {
  2432.     UINT8 i, bIndex;
  2433.     
  2434.     if (KB_E2PRead(KB_NVM_MAIL_INDEX_ADDR, (UINT8 *)&gE2pData.gMailInfo, sizeof(KB_DBMailIndex), NULL) != RETOK)
  2435.     {
  2436.         return RET_FAIL;
  2437.     }
  2438.     
  2439.     for (i = 0; i < KB_DB_MAX_MAIL; ++i)
  2440.     {
  2441.         if (gMailInfo[i].Flag != CONFIG_USED
  2442.             && gMailInfo[i].Flag != CONFIG_NO_USED)
  2443.         {
  2444.             return RET_FAIL;
  2445.         }
  2446.     }
  2447.     
  2448.     for (i = 0; i < gE2pData.gMailInfo.nTotal; ++i)
  2449.     {
  2450.         bIndex = gE2pData.gMailInfo.MailIndexList[i].Index;
  2451.         
  2452.         if (gMailInfo[bIndex].Flag != CONFIG_USED)
  2453.         {
  2454.             return RET_FAIL;
  2455.         }
  2456.     }
  2457.     return RET_OK;
  2458. }
  2460. unsigned short KB_DBGetPrgAvInfoByPrgNo(UINT8 prgType,
  2461. unsigned short nPrgNO, 
  2462. KB_DBPRGPID *pPrgPid)
  2463. {
  2464.   
  2465.     if (prgType == DTVPRG)
  2466.     {
  2467.         pPrgPid->PCR_Pid = gPrgAllInfo.gDTVInfo.PgmList[nPrgNO-1].PCRPID;
  2468. pPrgPid->Audio_Pid = gPrgAllInfo.gDTVInfo.PgmList[nPrgNO-1].AudioPID;
  2469. pPrgPid->Video_Pid = gPrgAllInfo.gDTVInfo.PgmList[nPrgNO-1].VideoPID;
  2470.     }
  2471.     else if (prgType == RADIOPRG)
  2472.     {
  2473.         pPrgPid->PCR_Pid = gPrgAllInfo.gRADInfo.PgmList[nPrgNO-1].PCRPID;
  2474. pPrgPid->Audio_Pid = gPrgAllInfo.gRADInfo.PgmList[nPrgNO-1].AudioPID;
  2475. pPrgPid->Video_Pid = gPrgAllInfo.gRADInfo.PgmList[nPrgNO-1].VideoPID;
  2476.     }
  2477.     //added by whale 07/05/25 start
  2478.     else if (prgType == DATAPRG)
  2479.     {
  2480.         pPrgPid->PCR_Pid = gPrgAllInfo.gDATAInfo.PgmList[nPrgNO-1].PCRPID;
  2481. pPrgPid->Audio_Pid = gPrgAllInfo.gDATAInfo.PgmList[nPrgNO-1].AudioPID;
  2482. pPrgPid->Video_Pid = gPrgAllInfo.gDATAInfo.PgmList[nPrgNO-1].VideoPID;
  2483.     }
  2484.     //added by whale 07/05/25 end
  2486.   return KB_DB_DTV_SUCCESS;
  2487. }
  2489. static KB_DBRET KD_ResetSerList(void)
  2490. {
  2491.     gE2pData.stServiceListInfo.DtvNum = 0;
  2492.     gE2pData.stServiceListInfo.RadNum = 0;
  2493.     
  2494.     if (KB_E2PWrite(KB_NVM_SERVICELIST_INFO_ADDR, (UINT8 *)&gE2pData.stServiceListInfo, sizeof(KB_DBListInfo), NULL) != RETOK)
  2495.     {
  2496.         return RET_FAIL;
  2497.     }
  2498.     
  2499.     return RET_OK;
  2500. }
  2502. static KB_DBRET KD_InitSerList(void)
  2503. {
  2504.     if (KB_E2PRead(KB_NVM_SERVICELIST_INFO_ADDR, (UINT8 *)&gE2pData.stServiceListInfo, sizeof(KB_DBListInfo), NULL) != RETOK)
  2505.     {
  2506.         return RET_FAIL;
  2507.     }
  2508.     
  2509.     return RET_OK;
  2510. }
  2512. INT32 KB_DBGetSvc2_TSID(INT32 nTsId, INT32 nPrgType, 
  2513.                                    INT32 *pSvcID1,    INT32 nCount1,
  2514.                                    INT32 *pSvcID2, INT32 nCount2)
  2515. {
  2516.     UINT16 i = 0, sum = 0, j;
  2517.     KB_DBPrgInfo programInfo;
  2518.     KB_DBChnnlInfo channelInfo;
  2519.     UINT8 track;
  2520.     UINT8 volume;
  2521.     UINT8 lockFlag;
  2522.     INT32 nNumber;
  2523.     
  2524.     sum = KB_DBGetPrgTotal((UINT8)nPrgType);
  2525.     nNumber = 0;
  2526.     for (i = 0; i < sum; ++i)
  2527.     {
  2528.         if (KB_DBGetPrgInfo(i, (UINT8)nPrgType, &programInfo, &channelInfo, &track, &volume, &lockFlag) == RET_OK)
  2529.         {
  2530.             if (programInfo.TSID == nTsId)
  2531.             {
  2532.                 for (j = 0; j < nCount2; j++)
  2533.                 {                    
  2534.                     if (programInfo.SvcID== *(pSvcID2 + j))
  2535.                     {
  2536.                         break;
  2537.                     }
  2538.                 }
  2539.                 
  2540.                 if (j >= nCount2)
  2541.                 {
  2542.                     *(pSvcID1 + nNumber) = programInfo.SvcID;
  2543.                     nNumber ++;
  2544.                     
  2545.                     if (nNumber == nCount1)
  2546.                     {
  2547.                         break;
  2548.                     }
  2549.                 }                
  2550.             }
  2551.         }
  2552.     }
  2553.     
  2554.     return nNumber;
  2555. }
  2557. KB_DBRET KD_GetNVOD_Svc(KB_SIRefSvcCell *refSvc)
  2558. {
  2560. UINT16 loop,i;
  2562.     for (loop=0;loop<gPrgAllInfo.gNVODInfo.nTotal;loop++)
  2563.    {
  2564.    if (gPrgAllInfo.gNVODInfo.RefSvc[loop].RefSvcId==refSvc->refScvId)
  2565.    {
  2566.         strcpy((char*)gPrgAllInfo.gNVODInfo.RefSvc[loop].RefSvcName,(char*)refSvc->refScvName);
  2567.         gPrgAllInfo.gNVODInfo.RefSvc[loop].TsID = refSvc->TsID;
  2568.         gPrgAllInfo.gNVODInfo.RefSvc[loop].ShiftNum = 0;
  2570.             for(i = 0;i< refSvc->shiftSvcNum;i++)
  2571.         {
  2572.         gPrgAllInfo.gNVODInfo.RefSvc[loop].ShiftList[i].ServiceId = 
  2573. refSvc->shiftSvc[i].svcId;
  2574.         gPrgAllInfo.gNVODInfo.RefSvc[loop].ShiftList[i].TSID= 
  2575. refSvc->shiftSvc[i].tsId;
  2576.         gPrgAllInfo.gNVODInfo.RefSvc[loop].ShiftNum ++;
  2577.         }
  2578.             return RET_OK;
  2579.    }
  2580.    }
  2581.   
  2582.    return RET_FAIL;
  2583. }
  2585. static KB_DBRET KD_GetPrgConfig(void)
  2586. {
  2587.     UINT16 i, sum, indexofconfig;
  2588.     KB_DBPrgConfigNode *pConfignode;
  2589.     
  2590.     sum = gPrgAllInfo.gDTVInfo.nTotal;
  2591. if (sum == 65535)
  2592. {
  2593. sum = 0;
  2594. }
  2595.     for (i = 0; i < sum; ++i)
  2596.     {
  2597.         indexofconfig = gPrgAllInfo.gDTVInfo.PgmList[i].IndexOfConfigInfo;
  2598.         pConfignode = &gE2pData.gDTVPrgCfgInfo[indexofconfig];
  2600.         if (KB_E2PRead((UINT16)(KB_NVM_DTV_PGM_CFG_ADDR + indexofconfig * sizeof(KB_DBPrgConfigNode)),
  2601.                 (UINT8 *)pConfignode, sizeof(KB_DBPrgConfigNode), NULL) != RETOK)
  2602.         {
  2603.             return RET_FAIL;
  2604.         }
  2605.     }
  2606.     sum = gPrgAllInfo.gRADInfo.nTotal;
  2607. if (sum == 65535)
  2608. {
  2609. sum = 0;
  2610. }
  2611.     for (i = 0; i < sum; ++i)
  2612.     {
  2613.         indexofconfig = gPrgAllInfo.gRADInfo.PgmList[i].IndexOfConfigInfo;
  2614.         pConfignode = &gE2pData.gRADPrgCfgInfo[indexofconfig];
  2615.  
  2616.         if (KB_E2PRead((UINT16)(KB_NVM_RAD_PGM_CFG_ADDR + indexofconfig * sizeof(KB_DBPrgConfigNode)),
  2617.                 (UINT8 *)pConfignode, sizeof(KB_DBPrgConfigNode), NULL) != RETOK)
  2618.         {
  2619.             return RET_FAIL;
  2620.         }
  2621.     }
  2622.     //added by whale 07/05/25 start
  2623.     sum = gPrgAllInfo.gDATAInfo.nTotal;
  2624. if (sum == 65535)
  2625. {
  2626. sum = 0;
  2627. }
  2628.     for (i = 0; i < sum; ++i)
  2629.     {
  2630.         indexofconfig = gPrgAllInfo.gDATAInfo.PgmList[i].IndexOfConfigInfo;
  2631.         pConfignode = &gE2pData.gDATAPrgCfgInfo[indexofconfig];
  2632.  
  2633.         if (KB_E2PRead((UINT16)(KB_NVM_DATA_PGM_CFG_ADDR + indexofconfig * sizeof(KB_DBPrgConfigNode)),
  2634.                 (UINT8 *)pConfignode, sizeof(KB_DBPrgConfigNode), NULL) != RETOK)
  2635.         {
  2636.             return RET_FAIL;
  2637.         }
  2638.     }
  2639.     //added by whale 07/05/25 end
  2640.     return RET_OK;
  2641. }
  2644. unsigned short KB_DBGetChnlInfoByPrgNO(UINT8 prgType,
  2645. unsigned short nPrgNO, 
  2646.   unsigned long * pFrea, 
  2647.   unsigned long * pSymb, 
  2648.   unsigned char * pQam)
  2649. {
  2650.     UINT16 i;
  2653. for (i=0; i<gPrgAllInfo.gChnnlInfo.nTotal; i++)
  2654. {
  2655.     if (prgType == DTVPRG)
  2656.     {
  2657. if (gPrgAllInfo.gChnnlInfo.ChannelList[i].TSID 
  2658.  == gPrgAllInfo.gDTVInfo.PgmList[nPrgNO-1].TSID)
  2659. {
  2660. break;
  2661. }
  2662.     }
  2663.     else if (prgType == RADIOPRG)
  2664.     {
  2665. if (gPrgAllInfo.gChnnlInfo.ChannelList[i].TSID 
  2666.  == gPrgAllInfo.gRADInfo.PgmList[nPrgNO-1].TSID)
  2667. {
  2668. break;
  2669. }
  2670.     }
  2671.     //added by whale 07/05/25 start
  2672.     else if (prgType == DATAPRG)
  2673.     {
  2674. if (gPrgAllInfo.gChnnlInfo.ChannelList[i].TSID 
  2675.  == gPrgAllInfo.gDATAInfo.PgmList[nPrgNO-1].TSID)
  2676. {
  2677. break;
  2678. }
  2679.     }
  2680.     //added by whale 07/05/25 end
  2681. }
  2683.     *pFrea = (unsigned long)gPrgAllInfo.gChnnlInfo.ChannelList[i].Freq* 100000;
  2684.     *pSymb = (unsigned long)gPrgAllInfo.gChnnlInfo.ChannelList[i].Symb* 1000;
  2685.     *pQam  = (unsigned char)gPrgAllInfo.gChnnlInfo.ChannelList[i].QAM;
  2687.     return KB_DB_DTV_SUCCESS;
  2688. }
  2690. INT8 KD_GetNITVer(void)
  2691. {
  2692. UINT8 ver;
  2693. UINT8 networkName[22];
  2694. KB_DBRET ret;
  2696. ret = KD_GetNitInfo(networkName,&ver);
  2698. if(ret != RET_OK)
  2699. {
  2700. //ver = -1;
  2701. return -1;
  2702. }
  2703. return ver;
  2704. }
  2707. unsigned short KB_DBGetPrgPMT(UINT8 prgType,
  2708. unsigned short nPrgNO, 
  2709.   unsigned short * pPmtPID, 
  2710.   unsigned short * pSvcID)
  2711. {
  2712. KB_DBPrgInfo prgInfo;
  2713. KB_DBChnnlInfo chnnlInfo;
  2714. UINT8 bTrack;
  2715. UINT8 bVolume;
  2716. UINT8 bLockFlag;
  2718. if (KB_DBGetPrgInfo(nPrgNO - 1, prgType, &prgInfo, &chnnlInfo, &bTrack, &bVolume, &bLockFlag) != RET_OK)
  2719. return KB_DB_DTV_FAILURE;
  2721. *pPmtPID = prgInfo.PMTPID;
  2722. *pSvcID = prgInfo.SvcID;
  2724. return KB_DB_DTV_SUCCESS;
  2725. }
  2727. unsigned char * KB_DBGetPrgName(UINT8 type,int nPrgNO)
  2728. {
  2729. static KB_DBPrgInfo prgInfo;
  2730. KB_DBChnnlInfo chnnlInfo;
  2731. UINT8 bTrack;
  2732. UINT8 bVolume;
  2733. UINT8 bLockFlag;
  2734. KB_DBGetPrgInfo(nPrgNO - 1, type, &prgInfo, &chnnlInfo, &bTrack, &bVolume, &bLockFlag);
  2735. return prgInfo.Name;
  2736. }
  2738. unsigned short KB_DBGetCAFlagByPrgNo(int type,unsigned short nPrgNO)
  2739. {
  2740.   KB_DBPrgInfo prgInfo;
  2741.   KB_DBChnnlInfo chnnlInfo;
  2742.   UINT8 bTrack;
  2743.   UINT8 bVolume;
  2744.   UINT8 bLockFlag;
  2746.   KB_DBGetPrgInfo(nPrgNO - 1, type, &prgInfo, &chnnlInfo, &bTrack, &bVolume, &bLockFlag);
  2748.   return prgInfo.ScrambleFlag;
  2749. }
  2751. KB_DBRET KB_DBSaveCAFlagByPrgNo(int type,unsigned short nPrgNO,unsigned char i_bCAFlag)
  2752. {
  2755.     if(((nPrgNO - 1) <0 ) || ((nPrgNO - 1) >= KB_DBGetPrgTotal(type)))
  2756.     {
  2757.         return RET_FAIL;
  2758.     }
  2759.     
  2760.     if (type == DTVPRG)
  2761. {
  2762.         gPrgAllInfo.gDTVInfo.PgmList[nPrgNO - 1].ScrambleFlag = i_bCAFlag;
  2763.     }
  2764.     else if (type == RADIOPRG)
  2765.     {
  2766.         gPrgAllInfo.gRADInfo.PgmList[nPrgNO - 1].ScrambleFlag = i_bCAFlag;
  2767.     }
  2768.     return RET_OK;
  2770. }
  2772. unsigned char  KB_DBGetPatVerByPrgNo(UINT8 prgType,unsigned short nPrgNO)
  2773. {
  2774.   KB_DBPrgInfo prgInfo;
  2775.   KB_DBChnnlInfo chnnlInfo;
  2776.   UINT8 bTrack;
  2777.   UINT8 bVolume;
  2778.   UINT8 bLockFlag;
  2779.   KB_DBGetPrgInfo(nPrgNO - 1, prgType, &prgInfo, &chnnlInfo, &bTrack, &bVolume, &bLockFlag);
  2781.   return chnnlInfo.PATVersion;
  2782. }
  2784. unsigned char KB_DBGetPmtVerByPrgNo(UINT8 prgType,unsigned short nPrgNO)
  2785. {
  2786.   KB_DBPrgInfo prgInfo;
  2787.   KB_DBChnnlInfo chnnlInfo;
  2788.   UINT8 bTrack;
  2789.   UINT8 bVolume;
  2790.   UINT8 bLockFlag;
  2792.   KB_DBGetPrgInfo(nPrgNO - 1, prgType, &prgInfo, &chnnlInfo, &bTrack, &bVolume, &bLockFlag);
  2794.   return prgInfo.PMTVersion;
  2795. }
  2797. unsigned char  KB_DBGetSdtVer(UINT8 prgType,unsigned short nPrgNO)
  2798. {
  2799.   KB_DBPrgInfo prgInfo;
  2800.   KB_DBChnnlInfo chnnlInfo;
  2801.   UINT8 bTrack;
  2802.   UINT8 bVolume;
  2803.   UINT8 bLockFlag;
  2805.   KB_DBGetPrgInfo(nPrgNO - 1, prgType, &prgInfo, &chnnlInfo, &bTrack, &bVolume, &bLockFlag);
  2807.   return chnnlInfo.SDTVersion;
  2808. }
  2810. char  KB_DBGetPrgTrace(UINT8 bPrgType,unsigned short nPrgNO)
  2811. {
  2812. UINT16 nConfigInd;
  2813.     UINT8 nConfigInfo;
  2814. UINT8 bTrack;
  2816.     if (bPrgType == DTVPRG)
  2817.     {
  2818.         nConfigInd = gPrgAllInfo.gDTVInfo.PgmList[nPrgNO-1].IndexOfConfigInfo;
  2819.         nConfigInfo = gE2pData.gDTVPrgCfgInfo[nConfigInd].Lock_Track_Vol;
  2820.     }
  2821.     else if (bPrgType == RADIOPRG)
  2822.     {
  2823.         nConfigInd = gPrgAllInfo.gRADInfo.PgmList[nPrgNO-1].IndexOfConfigInfo;
  2824.         nConfigInfo = gE2pData.gRADPrgCfgInfo[nConfigInd].Lock_Track_Vol;
  2825.     }
  2826.     //added by whale 07/05/25 start
  2827.     else if (bPrgType == DATAPRG)
  2828.     {
  2829.         nConfigInd = gPrgAllInfo.gDATAInfo.PgmList[nPrgNO-1].IndexOfConfigInfo;
  2830.         nConfigInfo = gE2pData.gDATAPrgCfgInfo[nConfigInd].Lock_Track_Vol;
  2831.     }
  2832.     //added by whale 07/05/25 end
  2834. bTrack  = ((nConfigInfo >> 5) & 0x03);
  2836.     return bTrack;
  2837. }
  2838.  /* ---------------------------------
  2839. * | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
  2840. * =================================
  2841. * |锁 | 声道  |       音量        |
  2842. * ---------------------------------*/
  2843. KB_DBRET  KB_DBSaveTrace(UINT8 bPrgType,unsigned short nPrgNO,UINT8  nTrack)
  2844. {
  2846.     UINT16 indexofconfig;
  2847.     UINT8  nConfigInfo;
  2848.     UINT32 nAddress1, nAddress2, nOffset;
  2849.     
  2850.     if (bPrgType == DTVPRG)
  2851.     {
  2852.         indexofconfig = gPrgAllInfo.gDTVInfo.PgmList[nPrgNO-1].IndexOfConfigInfo;
  2853.         
  2854.         nConfigInfo = gE2pData.gDTVPrgCfgInfo[indexofconfig].Lock_Track_Vol;
  2855.         
  2856.         nConfigInfo &= 0x80;
  2857.         nConfigInfo |= (nTrack & 0x7f);
  2858.         gE2pData.gDTVPrgCfgInfo[indexofconfig].Lock_Track_Vol = nConfigInfo;
  2860.         nAddress1 = (UINT32)&(gE2pData.gDTVPrgCfgInfo[indexofconfig].Flag);
  2861.         nAddress2 = (UINT32)&(gE2pData.gDTVPrgCfgInfo[indexofconfig].Lock_Track_Vol);
  2862.         nOffset   = nAddress2 - nAddress1;        
  2863.         if (KB_E2PWrite((UINT16)(KB_NVM_DTV_PGM_CFG_ADDR + sizeof(KB_DBPrgConfigNode) * indexofconfig + (int)nOffset),
  2864.             (UINT8 *)&nConfigInfo, sizeof(UINT8), NULL) != RETOK)
  2865.         {
  2866.             return RET_FAIL;
  2867.         }
  2868.     }
  2869.     else if (bPrgType == RADIOPRG)
  2870.     {
  2871.         indexofconfig = gPrgAllInfo.gRADInfo.PgmList[nPrgNO-1].IndexOfConfigInfo;
  2872.         
  2873.         nConfigInfo = gE2pData.gRADPrgCfgInfo[indexofconfig].Lock_Track_Vol;
  2874.         
  2875.         nConfigInfo &= 0x80;
  2876.         nConfigInfo |= (nTrack & 0x7f);
  2877.         gE2pData.gRADPrgCfgInfo[indexofconfig].Lock_Track_Vol = nConfigInfo;
  2879.         nAddress1 = (UINT32)&(gE2pData.gRADPrgCfgInfo[indexofconfig].Flag);
  2880.         nAddress2 = (UINT32)&(gE2pData.gRADPrgCfgInfo[indexofconfig].Lock_Track_Vol);
  2881.         nOffset   = nAddress2 - nAddress1;      
  2882.         if (KB_E2PWrite((UINT16)(KB_NVM_RAD_PGM_CFG_ADDR + indexofconfig * sizeof(KB_DBPrgConfigNode) + (int)nOffset),
  2883.             (UINT8 *)&nConfigInfo, sizeof(UINT8), NULL) != RETOK)
  2884.         {
  2885.             return RET_FAIL;
  2886.         }
  2887.     }
  2888.     //added by whale 07/05/25 start
  2889.     else if (bPrgType == DATAPRG)
  2890.     {
  2891.         indexofconfig = gPrgAllInfo.gDATAInfo.PgmList[nPrgNO-1].IndexOfConfigInfo;
  2892.         
  2893.         nConfigInfo = gE2pData.gDATAPrgCfgInfo[indexofconfig].Lock_Track_Vol;
  2894.         
  2895.         nConfigInfo &= 0x80;
  2896.         nConfigInfo |= (nTrack & 0x7f);
  2897.         gE2pData.gDATAPrgCfgInfo[indexofconfig].Lock_Track_Vol = nConfigInfo;
  2899.         nAddress1 = (UINT32)&(gE2pData.gDATAPrgCfgInfo[indexofconfig].Flag);
  2900.         nAddress2 = (UINT32)&(gE2pData.gDATAPrgCfgInfo[indexofconfig].Lock_Track_Vol);
  2901.         nOffset   = nAddress2 - nAddress1;      
  2902.         if (KB_E2PWrite((UINT16)(KB_NVM_DATA_PGM_CFG_ADDR + indexofconfig * sizeof(KB_DBPrgConfigNode) + (int)nOffset),
  2903.             (UINT8 *)&nConfigInfo, sizeof(UINT8), NULL) != RETOK)
  2904.         {
  2905.             return RET_FAIL;
  2906.         }
  2907.     }
  2908.     //added by whale 07/05/25 end
  2909.     return RET_OK;
  2910. }
  2912. KB_DBRET KB_DBSaveDemandInfo(UINT16 size, UINT8 *buff )
  2913. {
  2914.    
  2915.   if(KB_E2PWrite(KB_NVM_DEMAND_INFO_ADDR, buff, size, NULL) != RETOK)
  2916.     {
  2917.         return RET_FAIL;
  2918.     }
  2919.     
  2920.     return RET_OK;
  2921. }
  2922.   KB_DBRET KB_DBGetDemandInfo(UINT16 size, UINT8 *buff )
  2923. {
  2924.    
  2925.   if(KB_E2PRead(KB_NVM_DEMAND_INFO_ADDR, buff, size, NULL) != RETOK)
  2926. {
  2927.         return RET_FAIL;
  2928.     }
  2929.     
  2930.     return RET_OK;
  2931. }
  2933. unsigned char KB_DBGetVolumeByPrgNo(unsigned char *pVolume, unsigned char bType,
  2934.                                            unsigned short nPrgNO)
  2935. {
  2936. UINT16 nConfigInd;
  2937.      UINT8 nConfigInfo;
  2938. UINT8 bVolume;
  2940.     if (bType == DTVPRG)
  2941.     {
  2942.         nConfigInd = gPrgAllInfo.gDTVInfo.PgmList[nPrgNO-1].IndexOfConfigInfo;
  2943.         nConfigInfo = gE2pData.gDTVPrgCfgInfo[nConfigInd].Lock_Track_Vol;
  2944.     }
  2945.     else if (bType == RADIOPRG)
  2946.     {
  2947.         nConfigInd = gPrgAllInfo.gRADInfo.PgmList[nPrgNO-1].IndexOfConfigInfo;
  2948.         nConfigInfo = gE2pData.gRADPrgCfgInfo[nConfigInd].Lock_Track_Vol;
  2949.     }
  2950.     //added by whale 07/05/25 start
  2951.     else if (bType == DATAPRG)
  2952.     {
  2953.         nConfigInd = gPrgAllInfo.gDATAInfo.PgmList[nPrgNO-1].IndexOfConfigInfo;
  2954.         nConfigInfo = gE2pData.gDATAPrgCfgInfo[nConfigInd].Lock_Track_Vol;
  2955.     }
  2956.     //added by whale 07/05/25 end
  2957. bVolume  = (nConfigInfo & 0x1F); 
  2958.     *pVolume = bVolume;
  2960. return bVolume;
  2961. }
  2963. KB_DBRET KB_DBSaveVolume(unsigned char nVolume, UINT8 bPrgType,unsigned short nPrgNO)
  2964. {
  2965.   KB_DBPrgInfo prgInfo;
  2966.   KB_DBChnnlInfo chnnlInfo;
  2967.   UINT8 bTrack;
  2968.   UINT8 bVolume;
  2969.   UINT8 bLockFlag;
  2970.   UINT8 bTrackVolume;
  2972.   KB_DBGetPrgInfo(nPrgNO - 1, bPrgType, &prgInfo, &chnnlInfo, &bTrack, &bVolume, &bLockFlag);
  2974.   bTrackVolume = bTrack << 5 | nVolume;
  2975.   KB_DBSaveTrace(bPrgType,nPrgNO,bTrackVolume);
  2977.   return RET_OK;
  2978. }
  2980. unsigned char KB_DBGetZone(signed char *pTimeZone)
  2981. {
  2982. #if 1
  2983.    *pTimeZone=8;
  2984. #else
  2985.   KB_DBSysInfo params;
  2987.   KB_DBGetSysPara(&params);
  2989.   if( (params.TimeZone > 12) || (params.TimeZone < -12) )
  2990.     return KB_DB_DTV_FAILURE;
  2992.   *pTimeZone = params.TimeZone;
  2993. #endif
  2994.    return KB_DB_DTV_SUCCESS;
  2995. }
  2996. //lsp  07/3/14
  2997. unsigned char KB_DBSaveZone(signed char pTimeZone)
  2998. {
  2999.      KB_DBSysInfo params;
  3001.      KB_DBGetSysPara(&params);
  3003.      if( (params.TimeZone > 12) || (params.TimeZone < -12) )
  3004.      return KB_DB_DTV_FAILURE;
  3006.      params.TimeZone= pTimeZone;
  3007.      KB_DBSaveSysPara(&params);
  3008.     return KB_DB_DTV_SUCCESS;
  3009. }
  3010. UINT32 KB_DBGetTimeDateUserOffset(void)
  3011. {
  3012.       KB_DBSysInfo params; 
  3013.       KB_DBGetSysPara(&params);
  3014.       return  params.timeDateUserOffset;
  3015. }
  3016. void KB_DBSaveTimeDateUserOffset(UINT32 tDUserOffset)
  3017. {
  3018.       KB_DBSysInfo params; 
  3019.       KB_DBGetSysPara(&params);
  3020.       params.timeDateUserOffset= tDUserOffset;
  3021.       KB_DBSaveSysPara(&params);
  3022. }
  3023. //end lsp 07/3/14
  3024. unsigned char KB_DBGetLanguageFlag(void)
  3025. {
  3026.   KB_DBSysInfo params;
  3027.   unsigned char type = 0;
  3029.   KB_DBGetSysPara(&params);
  3030.   if(params.Language >= 2)
  3031.    return type;
  3033.   return params.Language;
  3034. }
  3035. /*=============================================================
  3036.  函数名称 : KB_DBSetLanguageFlag
  3037.  功    能 : 设置语言类型标志
  3038.  入    口 : nLanFlag---语言类型
  3039.  出    口 : 无
  3040.  返    回 : RET_OK---成功，RET_FAIL---失败
  3041. =============================================================*/
  3042. KB_DBRET KB_DBSaveLanguageFlag(UINT8 nLanFlag)
  3043. {
  3044.     gE2pData.gSysPara.Language = nLanFlag;
  3045.         
  3046.     if (KB_E2PWrite(KB_NVM_SYS_PARA_ADDR, (UINT8 *)&gE2pData.gSysPara, sizeof(KB_DBSysInfo), NULL) != RETOK)
  3047.     {
  3048.         return RET_FAIL;
  3049.     }
  3050.     else
  3051.     {
  3052.         return RET_OK;
  3053.     }
  3054. }
  3059. void KB_DBSwitchProInfo(UINT8 nPrgType ,int oldnitem,int newnitem)
  3060. {
  3061. KB_DBPrgInfo  tempPrg;
  3062. if(nPrgType==DTVPRG)
  3063. {
  3064. tempPrg=gPrgAllInfo.gDTVInfo.PgmList[oldnitem];
  3065. gPrgAllInfo.gDTVInfo.PgmList[oldnitem]=gPrgAllInfo.gDTVInfo.PgmList[newnitem];
  3066. gPrgAllInfo.gDTVInfo.PgmList[newnitem]=tempPrg;
  3067. }
  3068. //modified by whale 07/05/25
  3069. //else
  3070. else if (nPrgType==RADIOPRG)
  3071. {
  3072. tempPrg= gPrgAllInfo.gRADInfo.PgmList[oldnitem];
  3073. gPrgAllInfo.gRADInfo.PgmList[oldnitem]=gPrgAllInfo.gRADInfo.PgmList[newnitem];
  3074. gPrgAllInfo.gRADInfo.PgmList[newnitem]=tempPrg;
  3075. }
  3076. }
  3077. UINT16 KB_DBGetPrgNoByFavIndex(UINT8 nPrgType ,int FavIndex)
  3078. {
  3079.   UINT16 uiRealPgmNo;
  3080.   KB_DBPrgInfo tPlayInfo;
  3081.   KB_DBChnnlInfo chnnlInfo;
  3082.   UINT8 bTrack, bVol, bLockFlag;
  3083.   
  3084.   KB_DBGetFavPrgInfoByFavInx(FavIndex , nPrgType, &uiRealPgmNo, &tPlayInfo, &chnnlInfo, &bTrack, &bVol, &bLockFlag);
  3086.   return uiRealPgmNo;
  3087. }
  3089. int KB_PrgSort(UINT8 Prgtype,UINT16 *changeState)
  3090. {
  3091.     int total,i,find,tmpPos = -1;
  3092.     int okSort = 0;
  3093.     unsigned char  *name = NULL;
  3094.     KB_DBPrgInfo  tmpPrg,tmpPrg2;
  3095.     UINT16 sortstate[200 + 1],AfterSortState[200 + 1],AfterSort[ 201 ];
  3096.     int end = 0;
  3097.     KB_DBPrgInfo  *changeInfo = NULL;
  3098.     int changeTotal;
  3099.     
  3100.     total = KB_DBGetPrgTotal(Prgtype);
  3101.     switch(Prgtype)
  3102.     {
  3103.     case DTVPRG:
  3104.         changeInfo = gPrgAllInfo.gDTVInfo.PgmList;
  3105.         changeTotal = gPrgAllInfo.gDTVInfo.nTotal;
  3106.         break;
  3107.     case RADIOPRG:
  3108.         changeInfo = gPrgAllInfo.gRADInfo.PgmList;
  3109.         changeTotal = gPrgAllInfo.gRADInfo.nTotal;
  3110.         break;
  3111.     //added by whale 07/05/25 start
  3112.     case DATAPRG:
  3113.         changeInfo = gPrgAllInfo.gDATAInfo.PgmList;
  3114.         changeTotal = gPrgAllInfo.gDATAInfo.nTotal;
  3115.         break;
  3116.     //added by whale 07/05/25 end
  3117.     default:
  3118.         return -1;
  3119.     }
  3120.     
  3121.     for( i = 0; i < total + 1;i ++ )
  3122.     {
  3123.         sortstate[i] = i ;
  3124.         AfterSort[i] = i ;
  3125.         AfterSortState[i] = 0;
  3126.     }
  3127.     
  3128.     while(okSort < total)
  3129.     {
  3130.         if(tmpPos != -1)
  3131.         {
  3132.             for(i = 1 ;i < total + 1;i++)
  3133.             {
  3134.                 if(changeState[i] == tmpPos)
  3135.                 {
  3136.                     break;
  3137.                 }
  3138.             }
  3139.             
  3140.             {
  3141.                 memcpy(&tmpPrg2,&tmpPrg,sizeof(KB_DBPrgInfo));
  3142.                 memcpy(&tmpPrg,&changeInfo[i - 1],sizeof(KB_DBPrgInfo));
  3143.                 memcpy(&changeInfo[i - 1],&tmpPrg2,sizeof(KB_DBPrgInfo));
  3144.                 AfterSort[i] = tmpPos;
  3145.             }
  3146.             AfterSortState[i] = 1;
  3147.             tmpPos = sortstate [ i ] ;
  3148.             
  3149.             for( i = 1 ; i< total + 1 ;i++)
  3150.             {
  3151.                 if((AfterSortState[ i ] == 1) && (tmpPos == AfterSort[i] ))
  3152.                 {
  3153.                     tmpPos = -1;
  3154.                 }
  3155.             }
  3156.         }
  3157.         else
  3158.         {
  3159.             end = 1;
  3160.             for(i = 1;i < total + 1;i++)
  3161.             {
  3162.                 if(changeState[i] != AfterSort[i])
  3163.                 {
  3164.                     find = i;
  3165.                     end = 0;
  3166.                     break;
  3167.                 }
  3168.                 else
  3169.                 {
  3170.                     AfterSortState[i] = 1;
  3171.                 }
  3172.             }
  3173.             
  3174.             if(end == 1)
  3175.             {
  3176.                 okSort = total;
  3177.             }
  3178.             else
  3179.             {
  3180.                 {
  3181.                     memcpy(&tmpPrg,&changeInfo[find - 1],sizeof(KB_DBPrgInfo));
  3182.                     memcpy(&changeInfo[find - 1],&changeInfo[changeState[find] - 1],sizeof(KB_DBPrgInfo));
  3183.                     AfterSort[find] = changeState[find];
  3184.                 }
  3185.                 tmpPos = sortstate[find];
  3186.                 AfterSortState[find] = 1;
  3187.             }
  3188.         }
  3189.     }
  3190.     
  3191.     for(i = 0;i< total;i++)
  3192.     {
  3193.         {
  3194.             name = changeInfo[i].Name;
  3195.         }
  3196.     }
  3197.     KB_DBSavePrgInfo(0);
  3198.     
  3199.     return 0;
  3200. }
  3203. /*KB_DBRET KB_DBSaveCurPrg(unsigned short nPrgNO, unsigned char nPrgType)
  3204. {
  3206.    
  3207.     gE2pData.gCurPrgInfo.prgNO = nPrgNO - 1;
  3208.     gE2pData.gCurPrgInfo.prgType= nPrgType;
  3210.    
  3211.     if(KB_E2PWrite(KB_NVM_CUR_PGM_ADDR, (UINT8 *)&gE2pData.gCurPrgInfo, sizeof(KB_DBCurPrgInd), NULL) != RETOK)
  3212.     {
  3213.         return RET_FAIL;
  3214.     }
  3215.     
  3216.     return RET_OK;
  3218.  
  3219. }*/
  3221. void KB_ReadBannerDispTime(char *bannerDispTime)
  3222. {
  3224. if (KB_E2PRead(KB_NVM_LAST_BANNER_DISPTIME_OFFSET, (UINT8 *)bannerDispTime, sizeof(char), NULL) != RETOK)
  3225. {
  3226. printf("===FAIL load_pos====n");
  3227. }
  3228. }
  3230. void KB_SaveBannerDispTime(char *bannerDispTime)
  3231. {
  3232. if (KB_E2PWrite(KB_NVM_LAST_BANNER_DISPTIME_OFFSET, (UINT8 *)bannerDispTime, sizeof(char), NULL) != RETOK)
  3233. {
  3234. printf("===FAIL save_pos====n");
  3235. }
  3236. }
  3237.  
  3238.  //added by yyj start 2007.6.14
  3239. KB_DBRET KB_DBSavePgmCurVol(UINT8 buff )
  3240. {
  3241.     gConfigAudioVol=buff;
  3243.     if(KB_E2PWrite(KB_NVM_CONFIG_AUDIO_VOLUME_OFFSET, &buff, sizeof(UINT8), NULL) != RETOK)
  3244.     {
  3245.         return RET_FAIL;
  3246.     }
  3247.     
  3248.     return RET_OK;
  3249. }
  3251.  KB_DBRET KB_DBGetPgmCurVol(UINT8 *buff )
  3252. {
  3253.     *buff=gConfigAudioVol;
  3255.      if(*buff>=KB_AV_MAX_VOLUME)
  3256.      {
  3257.           *buff=KB_AV_DEFAULT_VOLUME;
  3258.      }
  3259.     
  3260.     return RET_OK;
  3261. }
  3263. static KB_DBRET KD_InitPgmCurVol(void)
  3264. {
  3265.     if (KB_E2PRead(KB_NVM_CONFIG_AUDIO_VOLUME_OFFSET, (UINT8 *)&gConfigAudioVol, sizeof(UINT8), NULL) != RETOK)
  3266.     {
  3267.         return RET_FAIL;
  3268.     }
  3269.     
  3270.     return RET_OK;
  3271. }
  3273. static KB_DBRET KD_ResetPgmCurVol(void)
  3274. {
  3275.     gConfigAudioVol=KB_AV_DEFAULT_VOLUME;
  3276.     
  3277.     if (KB_E2PWrite(KB_NVM_CONFIG_AUDIO_VOLUME_OFFSET, (UINT8 *)&gConfigAudioVol, sizeof(UINT8), NULL) != RETOK)
  3278.     {
  3279.         return RET_FAIL;
  3280.     }
  3281.     
  3282.     return RET_OK;
  3283. }
  3287. ///////////序列号////////////
  3288. KB_DBRET KD_DBGetSerialNumInfo(UINT16 size, UINT8 *buff)
  3289. {
  3290.   
  3291.     if (KB_E2PRead(KB_NVM_UPDATE_IN_SERIAL_NUM_OFFSET, buff, size, NULL) != RETOK)
  3292.     {
  3293.         return RET_FAIL;
  3294.     }
  3295.     
  3296.     return RET_OK;
  3297. }
  3299. KB_DBRET KD_DBSaveSerialNumInfo(UINT16 size, UINT8 *buff)
  3300. {
  3301.   
  3302.     if (KB_E2PWrite(KB_NVM_UPDATE_IN_SERIAL_NUM_OFFSET, buff, size, NULL) != RETOK)
  3303.     {
  3304.         return RET_FAIL;
  3305.     }
  3306.     
  3307.     return RET_OK;
  3308. }
  3310. //////////////////////////////////
  3312. //added by yyj end 2007.6.14
  3314. //added by yyj start 2007.6.19
  3315. //机顶盒信息
  3316. KB_DBRET KB_DBSaveSTBInfo(KB_DBSTBInfo buff )
  3317. {
  3318.     gE2pData.gSTBInfo=buff;
  3320.     if(KB_E2PWrite(KB_NVM_STB_INFO_ADDR, (UINT8 *)&buff, sizeof(KB_DBSTBInfo), NULL) != RETOK)
  3321.     {
  3322.         return RET_FAIL;
  3323.     }
  3324.     
  3325.     return RET_OK;
  3326. }
  3328.  KB_DBRET KB_DBGetSTBInfo(KB_DBSTBInfo *buff )
  3329. {
  3330.     *buff=gE2pData.gSTBInfo;
  3331.   
  3332.     return RET_OK;
  3333. }
  3335. static KB_DBRET KD_InitSTBInfo(void)
  3336. {
  3337.     UINT8 str[]="------";
  3338.     UINT8 crc[] = "KBSTBINFO";
  3340.     if (KB_E2PRead(KB_NVM_STB_INFO_ADDR, (UINT8 *)&gE2pData.gSTBInfo, sizeof(KB_DBSTBInfo), NULL) != RETOK)
  3341.     {
  3342.         return RET_FAIL;
  3343.     }
  3344.     if (memcmp(gE2pData.gSTBInfo.CRC, crc, 10))
  3345.     {
  3346.     #if 1
  3347. memcpy(gE2pData.gSTBInfo.CRC, crc, 10);
  3348.        memcpy(gE2pData.gSTBInfo.STB_Model, str, 20);
  3349. memcpy(gE2pData.gSTBInfo.HW_Info, str, 20);
  3350. strcpy((char *)gE2pData.gSTBInfo.HW_Vervion,"1.0.0");
  3351. memcpy(gE2pData.gSTBInfo.SW_Info, str, 20);
  3352. strcpy((char *)gE2pData.gSTBInfo.SW_Vervion,"1.0.0");
  3353. memset(gE2pData.gSTBInfo.SW_Release_Time, 0xff, 20);
  3354. strcpy((char *)gE2pData.gSTBInfo.CA_Version,"1.0.0");
  3355. strcpy((char *)gE2pData.gSTBInfo.Manufacturer,"键桥通讯"); 
  3356. if(KB_E2PWrite(KB_NVM_STB_INFO_ADDR, (UINT8 *)&gE2pData.gSTBInfo, sizeof(KB_DBSTBInfo), NULL) != RETOK)
  3357. {
  3358.         return RET_FAIL;
  3359. }
  3360.     #else
  3361. return RET_FAIL;
  3362.     #endif
  3363.     }
  3364.     
  3365.     return RET_OK;
  3366. }
  3368. static KB_DBRET KD_ResetSTBInfo(void)
  3369. { 
  3370.        UINT8 str[]="------";
  3371.      UINT8 crc[] = "KBSTBINFO";
  3373. memcpy(gE2pData.gSTBInfo.CRC, crc, 10);
  3374.        memcpy(gE2pData.gSTBInfo.STB_Model, str, 20);
  3375. memcpy(gE2pData.gSTBInfo.HW_Info, str, 20);
  3376. strcpy((char *)gE2pData.gSTBInfo.HW_Vervion,"1.0.0");
  3377. memcpy(gE2pData.gSTBInfo.SW_Info, str, 20);
  3378. strcpy((char *)gE2pData.gSTBInfo.SW_Vervion,"1.0.0");
  3379. memset(gE2pData.gSTBInfo.SW_Release_Time, 0xff, 20);
  3380. strcpy((char *)gE2pData.gSTBInfo.CA_Version,"1.0.0");
  3381. strcpy((char *)gE2pData.gSTBInfo.Manufacturer,"键桥通讯"); 
  3382. if (KB_E2PWrite(KB_NVM_STB_INFO_ADDR, (UINT8 *)&gE2pData.gSTBInfo, sizeof(KB_DBSTBInfo), NULL) != RETOK)
  3383. {
  3384.     return RET_FAIL;
  3385. }
  3387. return RET_OK;
  3388. }
  3390. //added by yyj end 2007.6.19
  3392. //added by yyj 2007.6.27 start
  3393. KB_DBRET KB_DBSaveVideoDispMode(UINT8 buff )
  3394. {
  3395.     gVidDispMode=buff;
  3397.     if(KB_E2PWrite(KB_NVM_VIDEO_DISPLAY_MODE_OFFSET, &buff, sizeof(UINT8), NULL) != RETOK)
  3398.     {
  3399.         return RET_FAIL;
  3400.     }
  3401.     
  3402.     return RET_OK;
  3403. }
  3405.  KB_DBRET KB_DBGetVideoDispMode(UINT8 *buff )
  3406. {
  3407.     *buff=gVidDispMode;
  3408.      printf("n[KB_DBGetVideoDispMode]:gVidDispMode=%d",gVidDispMode);
  3409.      
  3410.      if(*buff>=KB_AV_VIDEO_DISPLAY_MAX_TYPE)
  3411.      {
  3412.           *buff=KB_AV_DEFAULT_DISP_MODE;
  3413.      }
  3414.     
  3415.     return RET_OK;
  3416. }
  3418. static KB_DBRET KD_InitVideoDispMode(void)
  3419. {
  3420.     if (KB_E2PRead(KB_NVM_VIDEO_DISPLAY_MODE_OFFSET, (UINT8 *)&gVidDispMode, sizeof(UINT8), NULL) != RETOK)
  3421.     {
  3422.         return RET_FAIL;
  3423.     }
  3424.     
  3425.     return RET_OK;
  3426. }
  3428. static KB_DBRET KD_ResetVideoDispMode(void)
  3429. {
  3430.     gVidDispMode=KB_AV_DEFAULT_DISP_MODE;
  3431.     
  3432.     if (KB_E2PWrite(KB_NVM_VIDEO_DISPLAY_MODE_OFFSET, (UINT8 *)&gVidDispMode, sizeof(UINT8), NULL) != RETOK)
  3433.     {
  3434.         return RET_FAIL;
  3435.     }
  3436.     
  3437.     return RET_OK;
  3438. }
  3440. KB_DBRET KB_DBSaveVideoAspectRatio(UINT8 buff )
  3441. {
  3442.     gVidAspectRatio=buff;
  3444.     if(KB_E2PWrite(KB_NVM_VIDEO_ASPECT_RATIO_OFFSET, &buff, sizeof(UINT8), NULL) != RETOK)
  3445.     {
  3446.         return RET_FAIL;
  3447.     }
  3448.     
  3449.     return RET_OK;
  3450. }
  3452.  KB_DBRET KB_DBGetVideoAspectRatio(UINT8 *buff )
  3453. {
  3454.     *buff=gVidAspectRatio;
  3456.      if(*buff>KB_AV_ASPECT_RATIO_16TO9)
  3457.      {
  3458.           *buff=KB_AV_DEFAULT_ASPECT_RATIO;
  3459.      }
  3460.     
  3461.     return RET_OK;
  3462. }
  3464. static KB_DBRET KD_InitVideoAspectRatio(void)
  3465. {
  3466.     if (KB_E2PRead(KB_NVM_VIDEO_ASPECT_RATIO_OFFSET, (UINT8 *)&gVidAspectRatio, sizeof(UINT8), NULL) != RETOK)
  3467.     {
  3468.         return RET_FAIL;
  3469.     }
  3470.     
  3471.     return RET_OK;
  3472. }
  3474. static KB_DBRET KD_ResetVideoAspectRatio(void)
  3475. {
  3476.     gVidAspectRatio=KB_AV_DEFAULT_ASPECT_RATIO;
  3477.     
  3478.     if (KB_E2PWrite(KB_NVM_VIDEO_ASPECT_RATIO_OFFSET, (UINT8 *)&gVidAspectRatio, sizeof(UINT8), NULL) != RETOK)
  3479.     {
  3480.         return RET_FAIL;
  3481.     }
  3482.     
  3483.     return RET_OK;
  3484. }
  3486. KB_DBRET KB_DBSavePgmCurTrack(UINT8 buff )
  3487. {
  3488.     gConfigAudioTrack=buff;
  3490.     if(KB_E2PWrite(KB_NVM_CONFIG_AUDIO_TRACK_OFFSET, &buff, sizeof(UINT8), NULL) != RETOK)
  3491.     {
  3492.         return RET_FAIL;
  3493.     }
  3494.     
  3495.     return RET_OK;
  3496. }
  3498.  KB_DBRET KB_DBGetPgmCurTrack(UINT8 *buff )
  3499. {
  3500.     *buff=gConfigAudioTrack;
  3502.      if(*buff>STEREO_TRACK)
  3503.      {
  3504.           *buff=KB_AV_DEFAULT_TRACK;
  3505.      }
  3506.     
  3507.     return RET_OK;
  3508. }
  3510. static KB_DBRET KD_InitPgmCurTrack(void)
  3511. {
  3512.     if (KB_E2PRead(KB_NVM_CONFIG_AUDIO_TRACK_OFFSET, (UINT8 *)&gConfigAudioTrack, sizeof(UINT8), NULL) != RETOK)
  3513.     {
  3514.         return RET_FAIL;
  3515.     }
  3516.     
  3517.     return RET_OK;
  3518. }
  3520. static KB_DBRET KD_ResetPgmCurTrack(void)
  3521. {
  3522.     gConfigAudioTrack=KB_AV_DEFAULT_TRACK;
  3523.     
  3524.     if (KB_E2PWrite(KB_NVM_CONFIG_AUDIO_TRACK_OFFSET, (UINT8 *)&gConfigAudioTrack, sizeof(UINT8), NULL) != RETOK)
  3525.     {
  3526.         return RET_FAIL;
  3527.     }
  3528.     
  3529.     return RET_OK;
  3530. }
  3532. KB_DBRET KB_DBSaveAdultRank(UINT8 buff )
  3533. {
  3534.     gConfigAdultRank=buff;
  3536.     if(KB_E2PWrite(KB_NVM_CONFIG_ADULT_RANK_OFFSET, &buff, sizeof(UINT8), NULL) != RETOK)
  3537.     {
  3538.         return RET_FAIL;
  3539.     }
  3540.     
  3541.     return RET_OK;
  3542. }
  3544.  KB_DBRET KB_DBGetAdultRank(UINT8 *buff )
  3545. {
  3546.     *buff=gConfigAdultRank;
  3548.      if(*buff>RANK_18)
  3549.      {
  3550.           *buff=KB_AV_DEFAULT_ADULT_RANK;
  3551.      }
  3552.     
  3553.     return RET_OK;
  3554. }
  3556. static KB_DBRET KD_InitAdultRank(void)
  3557. {
  3558.     if (KB_E2PRead(KB_NVM_CONFIG_ADULT_RANK_OFFSET, (UINT8 *)&gConfigAdultRank, sizeof(UINT8), NULL) != RETOK)
  3559.     {
  3560.         return RET_FAIL;
  3561.     }
  3562.     
  3563.     return RET_OK;
  3564. }
  3566. static KB_DBRET KD_ResetAdultRank(void)
  3567. {
  3568.     gConfigAdultRank=KB_AV_DEFAULT_ADULT_RANK;
  3569.     
  3570.     if (KB_E2PWrite(KB_NVM_CONFIG_ADULT_RANK_OFFSET, (UINT8 *)&gConfigAdultRank, sizeof(UINT8), NULL) != RETOK)
  3571.     {
  3572.         return RET_FAIL;
  3573.     }
  3574.     
  3575.     return RET_OK;
  3576. }
  3578. KB_DBRET KB_DBSaveMenuLan(UINT8 buff )
  3579. {
  3580.     gConfigMenuLan=buff;
  3582.     if(KB_E2PWrite(KB_NVM_CONFIG_MENU_LANG_OFFSET, &buff, sizeof(UINT8), NULL) != RETOK)
  3583.     {
  3584.         return RET_FAIL;
  3585.     }
  3586.     
  3587.     return RET_OK;
  3588. }
  3590.  KB_DBRET KB_DBGetMenuLan(UINT8 *buff )
  3591. {
  3592.     *buff=gConfigMenuLan;
  3594.      if(*buff>=ENGLISH)
  3595.      {
  3596.           *buff=KB_DB_DEFAULT_MENU_LAN;
  3597.      }
  3598.     
  3599.     return RET_OK;
  3600. }
  3602. static KB_DBRET KD_InitMenuLan(void)
  3603. {
  3604.     if (KB_E2PRead(KB_NVM_CONFIG_MENU_LANG_OFFSET, (UINT8 *)&gConfigMenuLan, sizeof(UINT8), NULL) != RETOK)
  3605.     {
  3606.         return RET_FAIL;
  3607.     }
  3608.     
  3609.     return RET_OK;
  3610. }
  3612. static KB_DBRET KD_ResetMenuLan(void)
  3613. {
  3614.     gConfigMenuLan=KB_DB_DEFAULT_MENU_LAN;
  3615.     
  3616.     if (KB_E2PWrite(KB_NVM_CONFIG_MENU_LANG_OFFSET, (UINT8 *)&gConfigMenuLan, sizeof(UINT8), NULL) != RETOK)
  3617.     {
  3618.         return RET_FAIL;
  3619.     }
  3620.     
  3621.     return RET_OK;
  3622. }
  3624. KB_DBRET KB_DBSaveMenuTran(UINT8 buff )
  3625. {
  3626.     gConfigMenuTran=buff;
  3628.     if(KB_E2PWrite(KB_NVM_CONFIG_MENU_TRAN_OFFSET, &buff, sizeof(UINT8), NULL) != RETOK)
  3629.     {
  3630.         return RET_FAIL;
  3631.     }
  3632.     
  3633.     return RET_OK;
  3634. }
  3636.  KB_DBRET KB_DBGetMenuTran(UINT8 *buff )
  3637. {
  3638.     *buff=gConfigMenuTran;
  3640.      if(*buff>=LEVEL_3)
  3641.      {
  3642.           *buff=KB_DB_DEFAULT_MENU_TRAN;
  3643.      }
  3644.     
  3645.     return RET_OK;
  3646. }
  3648. static KB_DBRET KD_InitMenuTran(void)
  3649. {
  3650.     if (KB_E2PRead(KB_NVM_CONFIG_MENU_TRAN_OFFSET, (UINT8 *)&gConfigMenuTran, sizeof(UINT8), NULL) != RETOK)
  3651.     {
  3652.         return RET_FAIL;
  3653.     }
  3654.     
  3655.     return RET_OK;
  3656. }
  3658. static KB_DBRET KD_ResetMenuTran(void)
  3659. {
  3660.     gConfigMenuTran=KB_DB_DEFAULT_MENU_TRAN;
  3661.     
  3662.     if (KB_E2PWrite(KB_NVM_CONFIG_MENU_TRAN_OFFSET, (UINT8 *)&gConfigMenuTran, sizeof(UINT8), NULL) != RETOK)
  3663.     {
  3664.         return RET_FAIL;
  3665.     }
  3666.     
  3667.     return RET_OK;
  3668. }
  3669. //added by yyj 2007.6.27 end 
  3671.  
  3672. //added by yyj 2007.7.3 start
  3673. KB_DBRET KD_ResetDemandInfo(void)
  3674. {
  3675. char head[9];
  3676. //int nSize;
  3677. KB_DBRET ret;
  3678. //int *pnde;
  3679. #if 0
  3680. //先读取信息的总长度
  3681.  memset(head,0x00,9);
  3682.  ret=KB_DBGetDemandInfo(8,(UINT8 *)head);
  3683.  if(ret==RET_FAIL)
  3684.     return RET_FAIL;
  3685.  if(strncmp(head,EDHF_OPER_FLAG,4)!=0)
  3686.     return RET_OK;
  3687. #endif
  3688.  KB_ClearAllDmdEnt();
  3689.  KB_ClearDataLink();
  3690.  
  3691. //pnde=(int*)head;
  3692. //nSize=*(pnde+1);
  3693. //分配信息内存
  3694. //debuf=(char*)KB_OSPMalloc(nSize);
  3695. //if(NULL == debuf)
  3696. //return RET_FAIL;
  3697. //memset(debuf,0xFF,nSize);
  3698. memset(head,0x00,9);
  3699. if (KB_E2PWrite(KB_NVM_DEMAND_INFO_ADDR, (UINT8 *)head, 8, NULL) != RETOK)
  3700. {
  3701.     return RET_FAIL;
  3702. }
  3703.  
  3704. return RET_OK;
  3705. }
  3706. //added by yyj 2007.7.3 end
  3708. //added by yyj 2007.7.11 start
  3709. KB_DBRET KB_DBSaveOtaPara(KB_DBOtaPara *buff)
  3710. {
  3711. UINT8 writeData[14];
  3712. UINT32 i;
  3714. for(i=0;i<14;i++)   writeData[i]=0xFF;
  3716. //printf("n[KB_DBSaveOtaPara]:freq=%ld, Symb=%ld, qam=%ld,  pid=%ld",buff->freq, buff->Symb, buff->Qam, buff->PID);
  3718. //频率的转换    
  3719. writeData[0]=(UINT8)((buff->freq>>24)&0x000000ff);
  3720. writeData[1]=(UINT8)((buff->freq>>16)&0x000000ff);
  3721. writeData[2]=(UINT8)((buff->freq>>8)&0x000000ff);
  3722. writeData[3]=(UINT8)(buff->freq&0x000000ff);
  3723. printf("nn--writeData[0]=%x",writeData[0]);
  3724. printf("n--writeData[1]=%x",writeData[1]);
  3725. printf("n--writeData[2]=%x",writeData[2]);
  3726. printf("n--writeData[3]=%x",writeData[3]);
  3727. //end
  3729. //符号率的转换    
  3730. writeData[4]=(UINT8)((buff->Symb>>24)&0x000000ff);
  3731. writeData[5]=(UINT8)((buff->Symb>>16)&0x000000ff);
  3732. writeData[6]=(UINT8)((buff->Symb>>8)&0x000000ff);
  3733. writeData[7]=(UINT8)(buff->Symb&0x000000ff);
  3734. printf("nn--writeData[4]=%x",writeData[4]);
  3735. printf("n--writeData[5]=%x",writeData[5]);
  3736. printf("n--writeData[6]=%x",writeData[6]);
  3737. printf("n--writeData[7]=%x",writeData[7]);
  3738. //end
  3740. writeData[8]=buff->Qam+3;
  3742. writeData[9]=(buff->PID>>8)&0x000000ff;
  3743. writeData[10]=buff->PID&0x000000ff;
  3745. writeData[12]=0x01;
  3746. writeData[13]=0x00;  
  3748.  if(KB_E2PWrite(KB_NVM_UPDATE_BASE_ADDR, writeData, 14, NULL)!=Ret_OK)
  3749. {
  3750.      printf("n Save OTA parameter error!");
  3751.      return RET_FAIL;
  3752. }  
  3754. KB_OSPTaskDelay(500);
  3757. #if 1
  3758. {
  3759. unsigned char flag[14];
  3760. KB_E2PRead((UINT32)KB_NVM_UPDATE_BASE_ADDR, (UINT8 *)flag, (UINT32)14, NULL);
  3761. printf("n 0x%x 0x%x 0x%x 0x%x  0x%x 0x%x 0x%x 0x%x",flag[0],flag[1],flag[2],flag[3],flag[4],flag[5],flag[6],flag[7]);
  3762. printf("n 0x%x  0x%x 0x%x  0x%x  0x%x 0x%x",flag[8],flag[9],flag[10],flag[11],flag[12],flag[13]);
  3763. }
  3764. #endif
  3766. return RET_OK;
  3767. }
  3769. unsigned short KB_DBGetPrgTsID(UINT8 type,int nPrgNO)
  3770. {
  3771. static KB_DBPrgInfo prgInfo;
  3772. KB_DBChnnlInfo chnnlInfo;
  3773. UINT8 bTrack;
  3774. UINT8 bVolume;
  3775. UINT8 bLockFlag;
  3776. KB_DBGetPrgInfo(nPrgNO - 1, type, &prgInfo, &chnnlInfo, &bTrack, &bVolume, &bLockFlag);
  3777. return prgInfo.TSID;
  3778. }
  3781. UINT16 KB_DBDelPrgInfoByTsidSrvid(UINT8      type,
  3782.                                      UINT16     Tsid,
  3783.                                      UINT16     SvcID)
  3784. {
  3785.     int        i = 0, j = 0;
  3786.     UINT16     total = 0;
  3787.     KB_DBPrgInfo *tmpPrgInfo = NULL;
  3789.     total = KB_DBGetPrgTotal(type);
  3791.     if (0 == total)
  3792.     {
  3793.         return KB_DB_DTV_FAILURE;
  3794.     }
  3796.     if (DTVPRG == type)
  3797.     {
  3798.         tmpPrgInfo = gPrgAllInfo.gDTVInfo.PgmList;
  3799.     }
  3800.     else if (RADIOPRG == type)
  3801.     {
  3802.         tmpPrgInfo = gPrgAllInfo.gRADInfo.PgmList;
  3803.     }
  3804.     else
  3805.     {
  3806.         printf("nKB_DBDelPrgInfo::input PrgType(%d) error!", type);
  3807.         return KB_DB_DTV_FAILURE;
  3808.     }
  3810.     for (j = 0; j < total; j++)
  3811.     {
  3812.         if (tmpPrgInfo[j].TSID == Tsid && tmpPrgInfo[j].SvcID == SvcID)
  3813.         {
  3814.             break;
  3815.         }
  3816.     }
  3818.     if (j >= total)
  3819.     {
  3820.         printf("nKB_DBDelPrgInfoByTsidSrvid::无匹配的srv");
  3821.         return KB_DB_DTV_FAILURE;
  3822.     }
  3824.     KB_DBDelFavPrg(type, Tsid, SvcID);
  3826.     for(i = j; i < total - 1; i++)
  3827.     {
  3828.         memcpy(&tmpPrgInfo[i], &tmpPrgInfo[i+1], sizeof(KB_DBPrgInfo));
  3829.     }
  3831.     if (DTVPRG == type)
  3832.     {
  3833.         gPrgAllInfo.gDTVInfo.nTotal--;
  3834.     }
  3835.     else if (RADIOPRG == type)
  3836.     {
  3837.         gPrgAllInfo.gRADInfo.nTotal--;
  3838.     }
  3840.     return KB_DB_DTV_SUCCESS;
  3841. }
  3843. UINT16 KD_GetPrgInxByTsidSvcID(UINT8      PrgType,
  3844.                                   UINT16     Tsid,   
  3845.                                   UINT16     ServiceID)
  3846. {
  3847.     UINT16 i = 0, sum = 0;
  3848.     
  3849.     sum = KB_DBGetPrgTotal(PrgType);
  3851.     if (0 == sum)
  3852.     {
  3853.         return KB_DB_INVALID_PROGRAMNO;
  3854.     }
  3856.     if (DTVPRG == PrgType)
  3857.     {
  3858.         for (i = 0; i < sum; ++i)
  3859.         {
  3860.             if (gPrgAllInfo.gDTVInfo.PgmList[i].SvcID == ServiceID
  3861.                  && gPrgAllInfo.gDTVInfo.PgmList[i].TSID == Tsid)
  3862.             {
  3863.                 return i;
  3864.             }
  3865.         }
  3866.     }
  3867.     else if (RADIOPRG== PrgType)
  3868.     {
  3869.         for (i = 0; i < sum; ++i)
  3870.         {
  3871.             if (gPrgAllInfo.gRADInfo.PgmList[i].SvcID == ServiceID
  3872.                  && gPrgAllInfo.gRADInfo.PgmList[i].TSID == Tsid)
  3873.             {
  3874.                 return i;
  3875.             }
  3876.         }
  3877.     }
  3878.     else if (DATAPRG== PrgType)
  3879.     {
  3880.         for (i = 0; i < sum; ++i)
  3881.         {
  3882.             if (gPrgAllInfo.gDATAInfo.PgmList[i].SvcID == ServiceID
  3883.                  && gPrgAllInfo.gDATAInfo.PgmList[i].TSID == Tsid)
  3884.             {
  3885.                 return i;
  3886.             }
  3887.         }
  3888.     }
  3889.     else
  3890.     {
  3891.      return KB_DB_INVALID_PROGRAMNO;
  3892.     }
  3894.     return KB_DB_INVALID_PROGRAMNO;
  3895.     
  3896. }
  3898. UINT8 KB_DBLockSrv(unsigned char type, UINT16 nPrgInx)
  3899. {
  3900.     UINT16  total = 0xff;
  3901.     UINT16  IndexOfConfigInfo = 0xff;
  3902.     
  3903.     total = KB_DBGetPrgTotal(type);
  3904.     
  3905.     if(nPrgInx >= total || nPrgInx < 0)
  3906.     {
  3907.         printf("nKB_DBLockSrv::input nPrgInx(%d){total(%d)} error!",
  3908.                 nPrgInx, total);
  3909.         return KB_DB_DTV_FAILURE;
  3910.     }
  3911.     
  3912.     if (DTVPRG == type)
  3913.     {
  3914.         IndexOfConfigInfo = gPrgAllInfo.gDTVInfo.PgmList[nPrgInx].IndexOfConfigInfo;
  3915.         gE2pData.gDTVPrgCfgInfo[IndexOfConfigInfo].Lock_Track_Vol |= 0x80; 
  3917.         if (KB_E2PWrite((UINT16)(KB_NVM_DTV_PGM_CFG_ADDR + IndexOfConfigInfo * sizeof(KB_DBPrgConfigNode)),
  3918.                 (UINT8 *)&gE2pData.gDTVPrgCfgInfo[IndexOfConfigInfo], 
  3919.                 sizeof(KB_DBPrgConfigNode), NULL) != RETOK)
  3920.         {
  3921.             printf("nKB_DBLockSrv::KB_E2PWrite gDTVPrgCfgInfo fail");
  3922.             return KB_DB_DTV_FAILURE;
  3923.         }
  3924.     }
  3925.     else if (RADIOPRG == type)
  3926.     {
  3927.         IndexOfConfigInfo = gPrgAllInfo.gRADInfo.PgmList[nPrgInx].IndexOfConfigInfo;
  3928.         gE2pData.gRADPrgCfgInfo[IndexOfConfigInfo].Lock_Track_Vol |= 0x80; 
  3930.         if (KB_E2PWrite((UINT16)(KB_NVM_RAD_PGM_CFG_ADDR + IndexOfConfigInfo * sizeof(KB_DBPrgConfigNode)),
  3931.                 (UINT8 *)&gE2pData.gRADPrgCfgInfo[IndexOfConfigInfo], 
  3932.                 sizeof(KB_DBPrgConfigNode), NULL) != RETOK)
  3933.         {
  3934.             printf("nKB_DBLockSrv::KB_E2PWrite gRADPrgCfgInfo fail");
  3935.             return KB_DB_DTV_FAILURE;
  3936.         }
  3937.     }
  3938.     else
  3939.     {
  3940.         printf("nKB_DBLockSrv::input PrgType(%d) error!", type);
  3941.         return KB_DB_DTV_FAILURE;
  3942.     }
  3943.     
  3944.     return KB_DB_DTV_SUCCESS;
  3945. }
  3947. UINT8 KB_DBUnlockSrv(unsigned char type, UINT16 nPrgInx)
  3948. {
  3949.     UINT16  total = 0xff;
  3950.     UINT16  IndexOfConfigInfo = 0xff;
  3951.     
  3952.     total = KB_DBGetPrgTotal(type);
  3953.     
  3954.     if (nPrgInx >= total || nPrgInx < 0)
  3955.     {
  3956.         printf("nKB_DBUnlockSrv::input nPrgInx(%d){total(%d)} error!", 
  3957.                nPrgInx, total);
  3958.         return KB_DB_DTV_FAILURE;
  3959.     }
  3960.     
  3961.     if (DTVPRG == type)
  3962.     {
  3963.         IndexOfConfigInfo = gPrgAllInfo.gDTVInfo.PgmList[nPrgInx].IndexOfConfigInfo;
  3964.         gE2pData.gDTVPrgCfgInfo[IndexOfConfigInfo].Lock_Track_Vol &= 0x7f; 
  3966.         if (KB_E2PWrite((UINT16)(KB_NVM_DTV_PGM_CFG_ADDR + IndexOfConfigInfo * sizeof(KB_DBPrgConfigNode)),
  3967.                 (UINT8 *)&gE2pData.gDTVPrgCfgInfo[IndexOfConfigInfo], 
  3968.                 sizeof(KB_DBPrgConfigNode), NULL) != RETOK)
  3969.         {
  3970.             printf("nKB_DBUnlockSrv::KB_E2PWrite gDTVPrgCfgInfo fail");
  3971.             return KB_DB_DTV_FAILURE;
  3972.         }
  3973.     }
  3974.     else if (RADIOPRG == type)
  3975.     {
  3976.         IndexOfConfigInfo = gPrgAllInfo.gRADInfo.PgmList[nPrgInx].IndexOfConfigInfo;
  3977.         gE2pData.gRADPrgCfgInfo[IndexOfConfigInfo].Lock_Track_Vol &= 0x7f; 
  3979.         if (KB_E2PWrite((UINT16)(KB_NVM_RAD_PGM_CFG_ADDR + IndexOfConfigInfo * sizeof(KB_DBPrgConfigNode)),
  3980.                 (UINT8 *)&gE2pData.gRADPrgCfgInfo[IndexOfConfigInfo], 
  3981.                 sizeof(KB_DBPrgConfigNode), NULL) != RETOK)
  3982.         {
  3983.             printf("nKB_DBUnlockSrv::KB_E2PWrite gRADPrgCfgInfo fail");
  3984.             return KB_DB_DTV_FAILURE;
  3985.         }
  3986.     }
  3987.     else
  3988.     {
  3989.         printf("nKB_DBUnlockSrv::input PrgType(%d) error!", type);
  3990.         return KB_DB_DTV_FAILURE;
  3991.     }
  3992.     
  3993.     return KB_DB_DTV_SUCCESS;
  3994. }
  3996. void KB_DBGetLockSrvInfo(UINT8 type,
  3997.                             UINT16 *pNum, 
  3998.                             UINT16 PrgIndex[])
  3999. {
  4000.     UINT8   LockFlag = 0xff;
  4001.     UINT16  loop = 0;
  4002.     UINT16  total = 0xffff;
  4003.     UINT16  IndexOfConfigInfo = 0xffff;
  4005.     if (NULL == pNum 
  4006.         || NULL == PrgIndex 
  4007.         || (DTVPRG != type && RADIOPRG != type))
  4008.     {
  4009.         printf("nKB_DBGetLockSrvInfo::input error. type(0x%x), pNum(0x%x), PrgIndex(0x%x)",
  4010.                 type, pNum, PrgIndex);
  4012.         if (NULL != pNum)
  4013.         {
  4014.             *pNum = 0;
  4015.         }
  4016.         
  4017.         return;
  4018.     }
  4020.     //先初始被锁定的节目个数为0
  4021.     *pNum = 0;
  4022.     
  4023.     if (DTVPRG == type)
  4024.     {
  4025.         total = KB_DBGetPrgTotal(type);
  4026.     
  4027.         if (0 == total || total > KB_DB_MAX_DTV)
  4028.         {
  4029.             return;
  4030.         }
  4032.         for (loop = 0; loop < total; loop++)
  4033.         {
  4034.             IndexOfConfigInfo = gPrgAllInfo.gDTVInfo.PgmList[loop].IndexOfConfigInfo;
  4035.             if (IndexOfConfigInfo >= KB_DB_MAX_DTV)
  4036.             {
  4037.                 printf("nKB_DBGetLockSrvInfo::Dtv IndexOfConfigInfo(0x%x) get error!",
  4038.                        IndexOfConfigInfo);
  4039.                 continue;
  4040.             }
  4041.             
  4042.             LockFlag = (gE2pData.gDTVPrgCfgInfo[IndexOfConfigInfo].Lock_Track_Vol & 0x80)>>7;
  4043.             //记录被锁定的节目个数和节目索引号
  4044.             if (1 == LockFlag)
  4045.             {
  4046.                 PrgIndex[(*pNum)] = loop;
  4047.                 (*pNum)++;
  4048.             }
  4049.         }
  4050.     }
  4051.     else if (RADIOPRG == type)
  4052.     {
  4053.         total = KB_DBGetPrgTotal(type);
  4054.     
  4055.         if (0 == total || total > KB_DB_MAX_RAD)
  4056.         {
  4057.             return;
  4058.         }
  4060.         for (loop = 0; loop < total; loop++)
  4061.         {
  4062.             IndexOfConfigInfo = gPrgAllInfo.gRADInfo.PgmList[loop].IndexOfConfigInfo;
  4063.             if (IndexOfConfigInfo >= KB_DB_MAX_RAD)
  4064.             {
  4065.                 printf("nKB_DBGetLockSrvInfo::Rad IndexOfConfigInfo(0x%x) get error!",
  4066.                        IndexOfConfigInfo);
  4067.                 continue;
  4068.             }
  4069.             
  4070.             LockFlag = (gE2pData.gRADPrgCfgInfo[IndexOfConfigInfo].Lock_Track_Vol & 0x80)>>7;
  4071.             //记录被锁定的节目个数和节目索引号
  4072.             if (1 == LockFlag)
  4073.             {
  4074.                 PrgIndex[(*pNum)] = loop;
  4075.                 (*pNum)++;
  4076.             }
  4077.         }
  4078.     }
  4079.     else
  4080.     {
  4081.         printf("nKB_DBGetLockSrvInfo::input type(%d) error", type);
  4082.         return;
  4083.     }
  4085.     return;
  4086. }
  4088. BOOL KB_DBIsSrvLocked(UINT8 type, UINT16 nPrgInx)
  4089. {
  4090.     UINT8   LockFlag = 0xff;
  4091.     UINT16  total = 0xffff;
  4092.     UINT16  IndexOfConfigInfo = 0xffff;
  4093.     
  4094.     if (DTVPRG == type)
  4095.     {
  4096.         total = KB_DBGetPrgTotal(type);
  4097.         if (nPrgInx >= total || nPrgInx >= KB_DB_MAX_DTV)
  4098.         {
  4099.             printf("nKB_DBIsSrvLocked::input Dtv nPrgInx(%d){total(%d)} error!", 
  4100.                     nPrgInx, total);
  4101.             return FALSE;
  4102.         }
  4103.         
  4104.         IndexOfConfigInfo = gPrgAllInfo.gDTVInfo.PgmList[nPrgInx].IndexOfConfigInfo;
  4105.         if (IndexOfConfigInfo >= KB_DB_MAX_DTV)
  4106.         {
  4107.             printf("nKB_DBIsSrvLocked::Dtv IndexOfConfigInfo(0x%x) get error!",
  4108.                    IndexOfConfigInfo);
  4109.             return FALSE;
  4110.         }
  4112.         LockFlag = (gE2pData.gDTVPrgCfgInfo[IndexOfConfigInfo].Lock_Track_Vol & 0x80)>>7;
  4113.         if (1 == LockFlag)
  4114.         {
  4115.             return TRUE;
  4116.         }
  4117.         else
  4118.         {
  4119.             return FALSE;
  4120.         }
  4121.     }
  4122.     else if (RADIOPRG == type)
  4123.     {
  4124.         total = KB_DBGetPrgTotal(type);
  4125.         if (nPrgInx >= total || nPrgInx >= KB_DB_MAX_RAD)
  4126.         {
  4127.             printf("nKB_DBIsSrvLocked::input Rad nPrgInx(%d){total(%d)} error!", 
  4128.                     nPrgInx, total);
  4129.             return FALSE;
  4130.         }
  4131.         
  4132.         IndexOfConfigInfo = gPrgAllInfo.gRADInfo.PgmList[nPrgInx].IndexOfConfigInfo;
  4133.         if (IndexOfConfigInfo >= KB_DB_MAX_RAD)
  4134.         {
  4135.             printf("nKB_DBIsSrvLocked::Dtv IndexOfConfigInfo(0x%x) get error!",
  4136.                    IndexOfConfigInfo);
  4137.             return FALSE;
  4138.         }
  4140.         LockFlag = (gE2pData.gRADPrgCfgInfo[IndexOfConfigInfo].Lock_Track_Vol & 0x80)>>7;
  4141.         if (1 == LockFlag)
  4142.         {
  4143.             return TRUE;
  4144.         }
  4145.         else
  4146.         {
  4147.             return FALSE;
  4148.         }
  4149.     }
  4150.     else
  4151.     {
  4152.         printf("nKB_DBIsSrvLocked::input type(%d) error", type);
  4153.         return FALSE;
  4154.     }
  4155. }
  4157. KB_DBRET KB_DBAddFavPrg(UINT8 type,
  4158.                             UINT16 TsId,
  4159.                             UINT16 SrvId)
  4160. {
  4161.     UINT16  loop = 0;
  4162.     UINT16  total = 0;
  4163.     
  4164.     if (type != DTVPRG && type != RADIOPRG)
  4165.     {
  4166.         printf("nKB_DBAddFavPrg::input type(%d) error", type);
  4167.         return RET_FAIL;
  4168.     }
  4170.     if (TRUE != KB_DBIsPrgExist(type, TsId, SrvId))
  4171.     {
  4172.         printf("nKB_DBAddFavPrg::Prg type(%d)-TsId(%d)-SrvId(%d) not exist",
  4173.                 type, TsId, SrvId);
  4174.         return RET_FAIL;
  4175.     }
  4177.     if (DTVPRG == type)
  4178.     {
  4179.         total = KB_DBGetFavPrgTotal(DTVPRG);
  4180.         if (total > KB_DB_MAX_FAV_DTV)
  4181.         {
  4182.             printf("nKB_DBAddFavPrg::dtv favor total(%d) exceeds max",
  4183.                     total);
  4184.             return RET_FAIL;
  4185.         }
  4187.         for (loop = 0; loop < gE2pData.gDTVFavInfo.nTotal; loop++)
  4188.         {
  4189.             if (gE2pData.gDTVFavInfo.FavList[loop].TsId == TsId
  4190.                 && gE2pData.gDTVFavInfo.FavList[loop].SrvId == SrvId)
  4191.             {
  4192.                 printf("nKB_DBAddFavPrg::dtv favor Tsid(%d), SrvId(%d) repeat add!",
  4193.                         TsId, SrvId);
  4194.                 return RET_OK;
  4195.             }
  4196.         }
  4197.         
  4198.         gE2pData.gDTVFavInfo.FavList[total].TsId = TsId;
  4199.         gE2pData.gDTVFavInfo.FavList[total].SrvId = SrvId;
  4200.         gE2pData.gDTVFavInfo.nTotal++;
  4201.         
  4202.         if (KB_E2PWrite(KB_NVM_FAV_DTV_ADDR, (UINT8 *)&gE2pData.gDTVFavInfo, sizeof(KB_DBFavDtvInfo), NULL) != RETOK)
  4203.         {
  4204.             printf("nKB_DBAddFavPrg::KB_E2PWrite dtv fail");
  4205.             return RET_FAIL;
  4206.         }
  4207.     }
  4208.     else if (RADIOPRG == type)
  4209.     {
  4210.         total = KB_DBGetFavPrgTotal(RADIOPRG);
  4211.         if (total > KB_DB_MAX_FAV_RAD)
  4212.         {
  4213.             printf("nKB_DBAddFavPrg::radio favor total(%d) exceeds max",
  4214.                     total);
  4215.             return RET_FAIL;
  4216.         }
  4218.         for (loop = 0; loop < gE2pData.gDTVFavInfo.nTotal; loop++)
  4219.         {
  4220.             if (gE2pData.gRADFavInfo.FavList[loop].TsId == TsId
  4221.                 && gE2pData.gRADFavInfo.FavList[loop].SrvId == SrvId)
  4222.             {
  4223.                 printf("nKB_DBAddFavPrg::radio favor Tsid(%d), SrvId(%d) repeat add!",
  4224.                         TsId, SrvId);
  4225.                 return RET_OK;
  4226.             }
  4227.         }
  4228.         
  4229.         gE2pData.gRADFavInfo.FavList[total].TsId = TsId;
  4230.         gE2pData.gRADFavInfo.FavList[total].SrvId = SrvId;
  4231.         gE2pData.gRADFavInfo.nTotal++;
  4232.         
  4233.         if (KB_E2PWrite(KB_NVM_FAV_RAD_ADDR, (UINT8 *)&gE2pData.gRADFavInfo, sizeof(KB_DBFavRadInfo), NULL) != RETOK)
  4234.         {
  4235.             printf("nKB_SystemSetUp::KB_E2PWrite radio fail");
  4236.             return RET_FAIL;
  4237.         }
  4238.     }
  4240.     return RET_OK;
  4241. }
  4243. void KB_DBFavPrgRefresh(void)
  4244. {
  4245.     UINT8 i = 0;
  4246.     UINT8 j = 0;
  4248.     if (gE2pData.gDTVFavInfo.nTotal > KB_DB_MAX_FAV_DTV)
  4249.     {
  4250.         printf("nKB_DBFavPrgRefresh::dtv favor total(%d) exceeds max",
  4251.                 gE2pData.gDTVFavInfo.nTotal);
  4252.         KD_ResetFavDtv();
  4253.     }
  4254.     else
  4255.     {
  4256.         for (i = 0; i < gE2pData.gDTVFavInfo.nTotal;)
  4257.         {
  4258.             if (TRUE != KB_DBIsPrgExist(DTVPRG, 
  4259.                                           gE2pData.gDTVFavInfo.FavList[i].TsId, 
  4260.                                           gE2pData.gDTVFavInfo.FavList[i].SrvId))
  4261.             {
  4262.                 for (j = i; j < gE2pData.gDTVFavInfo.nTotal - 1 ;j++)
  4263.                 {
  4264.                     memcpy(&gE2pData.gDTVFavInfo.FavList[j], 
  4265.                            &gE2pData.gDTVFavInfo.FavList[j+1], 
  4266.                            sizeof(KB_DBFavNode)); 
  4267.                 }
  4268.                 gE2pData.gDTVFavInfo.nTotal--;
  4269.             }
  4270.             else
  4271.             {
  4272.                 i++;
  4273.             }
  4274.         }
  4275.     }
  4277.     if (KB_E2PWrite(KB_NVM_FAV_DTV_ADDR, (UINT8 *)&gE2pData.gDTVFavInfo, sizeof(KB_DBFavDtvInfo), NULL) != RETOK)
  4278.     {
  4279.         printf("nKB_DBFavPrgRefresh::KB_E2PWrite dtv fail");
  4280.     }
  4282.     if (gE2pData.gRADFavInfo.nTotal > KB_DB_MAX_FAV_RAD)
  4283.     {
  4284.         printf("nKB_DBFavPrgRefresh::dtv favor total(%d) exceeds max",
  4285.                 gE2pData.gRADFavInfo.nTotal);
  4286.         KD_ResetFavRad();
  4287.     }
  4288.     else
  4289.     {
  4290.         for (i = 0; i < gE2pData.gRADFavInfo.nTotal;)
  4291.         {
  4292.             if (TRUE != KB_DBIsPrgExist(RADIOPRG, 
  4293.                                           gE2pData.gRADFavInfo.FavList[i].TsId, 
  4294.                                           gE2pData.gRADFavInfo.FavList[i].SrvId))
  4295.             {
  4296.                 for (j = i; j < gE2pData.gRADFavInfo.nTotal - 1 ;j++)
  4297.                 {
  4298.                     memcpy(&gE2pData.gRADFavInfo.FavList[j], 
  4299.                            &gE2pData.gRADFavInfo.FavList[j+1], 
  4300.                            sizeof(KB_DBFavNode)); 
  4301.                 }
  4302.                 gE2pData.gRADFavInfo.nTotal--;
  4303.             }
  4304.             else
  4305.             {
  4306.                 i++;
  4307.             }
  4308.         }
  4309.     }
  4311.     if (KB_E2PWrite(KB_NVM_FAV_RAD_ADDR, (UINT8 *)&gE2pData.gRADFavInfo, sizeof(KB_DBFavRadInfo), NULL) != RETOK)
  4312.     {
  4313.         printf("nKB_DBFavPrgRefresh::KB_E2PWrite radio fail");
  4314.     }
  4316.     return;
  4317. }
  4319. void KB_DBGetFavPrgInfo(UINT8 type,
  4320.                            UINT16 *pNum, 
  4321.                            UINT16 PrgIndex[])
  4322. {
  4323.     UINT8   find = 0;
  4324.     UINT16  i = 0;
  4325.     UINT16  j = 0;
  4327.     if (NULL == pNum 
  4328.         || NULL == PrgIndex 
  4329.         || (DTVPRG != type && RADIOPRG != type))
  4330.     {
  4331.         printf("nKB_DBGetFavPrgInfo::input error. type(0x%x), pNum(0x%x), PrgIndex(0x%x)",
  4332.                 type, pNum, PrgIndex);
  4333.         
  4334.         if (NULL != pNum)
  4335.         {
  4336.             *pNum = 0;
  4337.         }
  4338.         
  4339.         return;
  4340.     }
  4342.     //先初始喜爱的节目个数为0
  4343.     *pNum = 0;
  4345.     if (DTVPRG == type)
  4346.     {
  4347.         if (gE2pData.gDTVFavInfo.nTotal > KB_DB_MAX_FAV_DTV
  4348.             || 0 == gE2pData.gDTVFavInfo.nTotal)
  4349.         {
  4350.             printf("nKB_DBGetFavPrgInfo::gE2pData favor dtv total(%d) error.",
  4351.                     gE2pData.gDTVFavInfo.nTotal);
  4352.             return;
  4353.         }
  4355.         if (gPrgAllInfo.gDTVInfo.nTotal > KB_DB_MAX_DTV)
  4356.         {
  4357.             printf("nKB_DBGetFavPrgInfo::gPrgAllInfo favor dtv total(%d) error.",
  4358.                     gPrgAllInfo.gDTVInfo.nTotal);
  4359.             return;
  4360.         }
  4361.         
  4362.         for (i = 0; i < gE2pData.gDTVFavInfo.nTotal; )
  4363.         {
  4364.             find = 0;
  4365.             for (j = 0; j < gPrgAllInfo.gDTVInfo.nTotal; j++)
  4366.             {
  4367.                 if (gPrgAllInfo.gDTVInfo.PgmList[j].TSID == gE2pData.gDTVFavInfo.FavList[i].TsId
  4368.                     && gPrgAllInfo.gDTVInfo.PgmList[j].SvcID == gE2pData.gDTVFavInfo.FavList[i].SrvId)
  4369.                 {
  4370.                     PrgIndex[(*pNum)] = j;
  4371.                     (*pNum)++;
  4372.                     find = 1;
  4373.                     break;
  4374.                 }
  4375.             }
  4377.             //对gPrgAllInfo已经不存在的dtv fav的刷新处理
  4378.             if (0 == find)
  4379.             {
  4380.                 for (j = i; j < gE2pData.gDTVFavInfo.nTotal - 1 ;j++)
  4381.                 {
  4382.                     memcpy(&gE2pData.gDTVFavInfo.FavList[j], 
  4383.                            &gE2pData.gDTVFavInfo.FavList[j+1], 
  4384.                            sizeof(KB_DBFavNode)); 
  4385.                 }
  4386.                 gE2pData.gDTVFavInfo.nTotal--;
  4387.                 
  4388.                 if (KB_E2PWrite(KB_NVM_FAV_DTV_ADDR, (UINT8 *)&gE2pData.gDTVFavInfo, sizeof(KB_DBFavDtvInfo), NULL) != RETOK)
  4389.                 {
  4390.                     printf("nKB_DBGetFavPrgInfo::KB_E2PWrite dtv fail");
  4391.                 }
  4392.             }
  4393.             else
  4394.             {
  4395.                 i++;
  4396.             }
  4397.         }
  4398.     }
  4399.     else if (RADIOPRG == type)
  4400.     {
  4401.         if (gE2pData.gRADFavInfo.nTotal > KB_DB_MAX_FAV_RAD
  4402.             || 0 == gE2pData.gRADFavInfo.nTotal)
  4403.         {
  4404.             printf("nKB_DBGetFavPrgInfo::gE2pData favor radio total(%d) error.",
  4405.                     gE2pData.gRADFavInfo.nTotal);
  4406.             return;
  4407.         }
  4409.         if (gPrgAllInfo.gRADInfo.nTotal > KB_DB_MAX_RAD)
  4410.         {
  4411.             printf("nKB_DBGetFavPrgInfo::gPrgAllInfo favor radio total(%d) error.",
  4412.                     gPrgAllInfo.gRADInfo.nTotal);
  4413.             return;
  4414.         }
  4416.         for (i = 0; i < gE2pData.gRADFavInfo.nTotal; )
  4417.         {
  4418.             find = 0;
  4419.             for (j = 0; j < gPrgAllInfo.gRADInfo.nTotal; j++)
  4420.             {
  4421.                 if (gPrgAllInfo.gRADInfo.PgmList[j].TSID == gE2pData.gRADFavInfo.FavList[i].TsId
  4422.                     && gPrgAllInfo.gRADInfo.PgmList[j].SvcID == gE2pData.gRADFavInfo.FavList[i].SrvId)
  4423.                 {
  4424.                     PrgIndex[(*pNum)] = j;
  4425.                     (*pNum)++;
  4426.                     find = 1;
  4427.                     break;
  4428.                 }
  4429.             }
  4431.             //对gPrgAllInfo已经不存在的radio fav的刷新处理
  4432.             if (0 == find)
  4433.             {
  4434.                 for (j = i; j < gE2pData.gRADFavInfo.nTotal - 1 ;j++)
  4435.                 {
  4436.                     memcpy(&gE2pData.gRADFavInfo.FavList[j], 
  4437.                            &gE2pData.gRADFavInfo.FavList[j+1], 
  4438.                            sizeof(KB_DBFavNode)); 
  4439.                 }
  4440.                 gE2pData.gRADFavInfo.nTotal--;
  4442.                 if (KB_E2PWrite(KB_NVM_FAV_RAD_ADDR, (UINT8 *)&gE2pData.gRADFavInfo, sizeof(KB_DBFavRadInfo), NULL) != RETOK)
  4443.                 {
  4444.                     printf("nKB_DBGetFavPrgInfo::KB_E2PWrite radio fail");
  4445.                 }
  4446.             }
  4447.             else
  4448.             {
  4449.                 i++;
  4450.             }        
  4451.         }
  4452.     }
  4453.     else
  4454.     {
  4455.         printf("nKB_DBGetFavPrgInfo::input type(%d) error", type);
  4456.         return;
  4457.     }
  4458.  
  4459.     return;
  4460. }
  4462. void KB_DBGetFavPrgInfoInE2p(UINT8 type, void *pInfo)
  4463. {    
  4464.     if ((DTVPRG != type && RADIOPRG != type)
  4465.         || NULL == pInfo)
  4466.     {
  4467.         printf("nKB_DBGetFavPrgInfoInE2p::input error. type(%d), pInfo(0x%x)",
  4468.                 type, pInfo);
  4469.         return;
  4470.     }
  4472.     if (DTVPRG == type)
  4473.     {
  4474.         memcpy(pInfo, 
  4475.                &gE2pData.gDTVFavInfo, 
  4476.                sizeof(KB_DBFavDtvInfo));
  4477.     }
  4478.     else if (RADIOPRG == type)
  4479.     {
  4480.         memcpy(pInfo, 
  4481.                &gE2pData.gRADFavInfo, 
  4482.                sizeof(KB_DBFavRadInfo));
  4483.     }
  4484.     else
  4485.     {
  4486.         printf("nKB_DBGetFavPrgInfoInE2p::input error. type(%d)",
  4487.                 type);
  4488.     }
  4490.     return;
  4491. }
  4494. void KB_DBE2pCfgInfoRefresh(UINT8 nPrgType) 
  4495. {
  4496.     BOOL    find = FALSE;
  4497.     UINT16  i = 0;
  4498.     UINT16  j = 0;
  4500.     switch(nPrgType)
  4501.     {
  4502.         case DTVPRG: 
  4503.             {
  4504.                 for (i = 0; i < KB_DB_MAX_DTV; ++i)
  4505.                 {
  4506.                     if (CONFIG_USED == gE2pData.gDTVPrgCfgInfo[i].Flag
  4507.                         || (CONFIG_USED + 1) == gE2pData.gDTVPrgCfgInfo[i].Flag)
  4508.                     {
  4509.                         find = FALSE;
  4510.                         for (j = 0; j < gPrgAllInfo.gDTVInfo.nTotal; j++)
  4511.                         {
  4512.                             if (i == gPrgAllInfo.gDTVInfo.PgmList[j].IndexOfConfigInfo)
  4513.                             {
  4514.                                 find = TRUE;
  4515.                                 break;
  4516.                             }
  4517.                         }
  4519.                         if (FALSE == find)
  4520.                         {
  4521.                             gE2pData.gDTVPrgCfgInfo[i].Flag = CONFIG_NO_USED;
  4522.                         }
  4523.                     }
  4524.                 }
  4525.             }
  4526.             break;
  4527.             
  4528.         case RADIOPRG:
  4529.             {
  4530.                 for (i = 0; i < KB_DB_MAX_RAD; ++i)
  4531.                 {
  4532.                     if (CONFIG_USED == gE2pData.gRADPrgCfgInfo[i].Flag
  4533.                         || (CONFIG_USED + 1) == gE2pData.gRADPrgCfgInfo[i].Flag)
  4534.                     {
  4535.                         find = FALSE;
  4536.                         for (j = 0; j < gPrgAllInfo.gRADInfo.nTotal; j++)
  4537.                         {
  4538.                             if (i == gPrgAllInfo.gRADInfo.PgmList[j].IndexOfConfigInfo)
  4539.                             {
  4540.                                 find = TRUE;
  4541.                                 break;
  4542.                             }
  4543.                         }
  4545.                         if (FALSE == find)
  4546.                         {
  4547.                             gE2pData.gRADPrgCfgInfo[i].Flag = CONFIG_NO_USED;
  4548.                         }
  4549.                     }
  4550.                 }
  4551.             }
  4552.             break;
  4553.             
  4554.         case DATAPRG:
  4555.             {
  4556.                 for (i = 0; i < KB_DB_MAX_DATA; ++i)
  4557.                 {
  4558.                     if (CONFIG_USED == gE2pData.gDATAPrgCfgInfo[i].Flag
  4559.                         || (CONFIG_USED + 1) == gE2pData.gDATAPrgCfgInfo[i].Flag)
  4560.                     {
  4561.                         find = FALSE;
  4562.                         for (j = 0; j < gPrgAllInfo.gDATAInfo.nTotal; j++)
  4563.                         {
  4564.                             if (i == gPrgAllInfo.gDATAInfo.PgmList[j].IndexOfConfigInfo)
  4565.                             {
  4566.                                 find = TRUE;
  4567.                                 break;
  4568.                             }
  4569.                         }
  4571.                         if (FALSE == find)
  4572.                         {
  4573.                             gE2pData.gRADPrgCfgInfo[i].Flag = CONFIG_NO_USED;
  4574.                         }
  4575.                     }
  4576.                 }
  4577.             }
  4578.             break;
  4580.         default:
  4581.             printf("nKB_DBE2pCfgInfoRefresh::input PrgType(%d) error", nPrgType);
  4582.             break;
  4583.     }
  4585.     return;
  4586. }