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

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

DVD

开发平台：

C/C++

kb_dc_fileproc.c：源码内容
  1. //-----------------------------------------------------------------------------
  2. // Project include files:
  3. //-----------------------------------------------------------------------------
  4. #include "kb_dc_pub.h"
  6. DCMODULEINFO moduleInfo={0,0};  
  7. static unsigned short curMovieCfgVer = 0x100;  /*影片配置文件版本号*/
  8. static unsigned short curServCfgVer = 0x100;    /*业务主配置文件版本号*/
  9. static unsigned char *curCfgName=NULL;
  11. //-----------------------------------------------------------------------------
  12. // FUNCTION:    Get_firstModID_ByName
  13. //
  14. // DESCRIPTION: 
  15. //
  16. // RETURN:      
  17. //
  18. // NOTES:       None
  19. //-----------------------------------------------------------------------------
  20. unsigned short Get_firstModID_ByName(char *name)
  21. {
  22. int i=0;
  23. unsigned short firstMId=0xffff;
  25. for(i=0;i<moduleInfo.modNum;i++)
  26. {
  27. if(strcmp((const char*)moduleInfo.modInf[i].fileName, (const char*)name)==0)
  28. return moduleInfo.modInf[i].modID;
  29. }
  31. return firstMId;
  32. }
  35. //get module number from a file
  36. int DCGetModNumByFile(DCFILE *file)   
  37. {
  39. int i=0;
  40. int count=0, blocksCnt=0;
  41. unsigned long fSize;
  43. if(file==NULL)
  44. {
  45. return -1;
  46. }
  48.        for(i=0;i<moduleInfo.modNum;i++)
  49.     {
  50. if(strcmp((const char*)file->fileName,  (const char*)moduleInfo.modInf[i].fileName)==0)
  51. count++;
  52.     }
  54. //if error, then choose another way to caculate the modulecount
  55. if(count==0)
  56. {
  57. fSize = file->fileLength;
  58. blocksCnt = (int)fSize/4066+(((int)fSize%4066==0)?0:1);
  59. count = blocksCnt/256+((blocksCnt%256==0)?0:1);
  60. }
  62. return count;
  63. }
  66. unsigned int DclsEof(DCFILE *file)
  67. {
  68. long position=file->position;
  69. long len=file->fileLength;
  70. if (position==(len))
  71. return 1;
  72. else
  73. return 0;
  75. }
  78. void DcCloseFile(DCFILE *file)
  79. {
  80. KBDcFree((void*)file->section);
  81. KBDcFree((void*)file);
  82. }
  85. void DcCloseDirectory(DCDIR *dir)
  86. {
  87. KBDcFree(dir->diiSection);
  88. KBDcFree(dir);
  89. }
  92. long DcReadFile(void *buf,int len,DCFILE *file)
  93. {
  94. long position=file->position;
  95. long fileLength=file->fileLength;
  96. unsigned long readBytes=0;
  98. if(DclsEof(file)==1)
  99. return readBytes;
  101. if((position+len)<fileLength)
  102. readBytes=len;
  103. else
  104. readBytes=fileLength-position;
  105. KBDcMemcpy((void*)buf,(const void*)(file->section+position),(size_t)readBytes);
  106. file->position+=readBytes;
  107. return readBytes;
  108. }
  110. //-----------------------------------------------------------------------------
  111. // FUNCTION:    FreeDCFILE
  112. //
  113. // DESCRIPTION: 释放分配的gDCFile
  114. //
  115. // RETURN:      
  116. //
  117. // NOTES:       None
  118. //-----------------------------------------------------------------------------
  119. void FreeDCFILE(void)
  120. {
  121. int i;
  123.        if(gDCFile!=NULL)
  124. {
  125. if(gDCFile->section!=NULL) 
  126. {
  127. DCDebug3("n ==free gDCFile->section");
  128. KBDcFree(gDCFile->section);
  129. gDCFile->section=NULL;
  130. }
  131. gDCFile->fileLength=0;
  133. //free BLOCK buffer status
  134. if(gDCFile->BufStatus.modcount>0&&gDCFile->BufStatus.modStat!=NULL)
  135. {
  136. for(i=0;i<gDCFile->BufStatus.modcount;i++)
  137. {
  138. if(gDCFile->BufStatus.modStat[i].blockCount>0)
  139. {
  140. if(gDCFile->BufStatus.modStat[i].blockStat!=NULL)
  141. {
  142. DCDebug3("n ==free blockStat of module %d", i);
  143. KBDcFree(gDCFile->BufStatus.modStat[i].blockStat);
  144. gDCFile->BufStatus.modStat[i].blockStat= NULL;
  145. gDCFile->BufStatus.modStat[i].blockCount = 0;
  146. }
  147. }
  148. }
  149. }
  150. //free module buffer status
  151. if(gDCFile->BufStatus.modStat!=NULL)
  152. {
  153. DCDebug3("n ==free modStat==");
  154. KBDcFree(gDCFile->BufStatus.modStat);
  155. gDCFile->BufStatus.modStat = NULL;
  156. gDCFile->BufStatus.modcount = 0;
  157. }
  159. }
  161. if(gDCFile!=NULL)
  162. KBDcFree(gDCFile);
  163. gDCFile=NULL;
  164. }
  167. //-----------------------------------------------------------------------------
  168. // FUNCTION:    FreeOneDCFILE
  169. //
  170. // DESCRIPTION: 根据参数释放分配的DCFILE内存
  171. //
  172. // RETURN:      
  173. //
  174. // NOTES:       None
  175. //-----------------------------------------------------------------------------
  176. void FreeOneDCFILE(DCFILE *pfile)
  177. {
  178. int i;
  180.        if(pfile!=NULL)
  181. {
  182. if(pfile->section!=NULL) 
  183. {
  184. DCDebug3("n ==free gDCFile->section_2");
  185. KBDcFree(pfile->section);
  186. pfile->section=NULL;
  187. }
  188. pfile->fileLength=0;
  190. //free BLOCK buffer status
  191. if(pfile->BufStatus.modcount>0&&pfile->BufStatus.modStat!=NULL)
  192. {
  193. for(i=0;i<pfile->BufStatus.modcount;i++)
  194. {
  195. if(pfile->BufStatus.modStat[i].blockCount>0)
  196. {
  197. if(pfile->BufStatus.modStat[i].blockStat!=NULL)
  198. {
  199. DCDebug3("n ==free blockStat of module %d_2", i);
  200. KBDcFree(pfile->BufStatus.modStat[i].blockStat);
  201. pfile->BufStatus.modStat[i].blockStat= NULL;
  202. pfile->BufStatus.modStat[i].blockCount = 0;
  203. }
  204. }
  205. }
  206. }
  207. //free module buffer status
  208. if(pfile->BufStatus.modStat!=NULL)
  209. {
  210. DCDebug3("n ==free modStat_2==");
  211. KBDcFree(pfile->BufStatus.modStat);
  212. pfile->BufStatus.modStat = NULL;
  213. pfile->BufStatus.modcount = 0;
  214. }
  216. }
  218. if(pfile!=NULL)
  219. {
  220. KBDcFree(pfile);
  221. pfile=NULL;
  222. }
  223. }
  225. //-----------------------------------------------------------------------------
  226. // FUNCTION:    FreeDCDIR
  227. //
  228. // DESCRIPTION: 释放分配的gDCFile
  229. //
  230. // RETURN:      
  231. //
  232. // NOTES:       None
  233. //-----------------------------------------------------------------------------
  234. void FreeDCDIR(void)
  235. {
  236.        if(gDCDir!=NULL)
  237. {
  238. if(gDCDir->diiSection!=NULL) 
  239. {
  240. KBDcFree(gDCDir->diiSection);
  241. gDCDir->diiSection=NULL;
  242. }
  243. }
  245. if(gDCDir!=NULL)
  246. KBDcFree(gDCDir);
  247. gDCDir=NULL;
  248. }
  252. //get file count int DII
  253. int DcGetFileCount()
  254. {
  255. int filecnt=0;
  256. return filecnt;
  257. }
  259. int InitFileModuleInfo(unsigned short modCount)
  260. {
  261. if((moduleInfo.modInf!=NULL)||(moduleInfo.modNum!=0))
  262. {
  263. if(moduleInfo.modNum != modCount)
  264. {
  265. FreeModuleInfo();  /*先释放moduleinfo结构内存*/
  266. }
  267. else
  268. {
  269. KBDcMemset(moduleInfo.modInf, 0x00, modCount*sizeof(DCModuleInfoArray));
  270. moduleInfo.modNum = 0;
  271. return 0;
  272. }
  273. }
  275. //init moduleinf struct
  276. moduleInfo.modInf = (DCModuleInfoArray *)KBDcMalloc(modCount*sizeof(DCModuleInfoArray));
  277. if(moduleInfo.modInf == NULL)
  278. {
  279. DCDebug1("n moduleInfo malloc error!");
  280. return -1;
  281. }
  283. KBDcMemset(moduleInfo.modInf, 0x00, modCount*sizeof(DCModuleInfoArray));
  284. moduleInfo.modNum = 0;
  285. return 0;
  286. }
  288. void FreeModuleInfo(void)
  289. {
  290.        if(moduleInfo.modInf!=NULL)
  291. {
  292. DCDebug4("n ==free moduleInfo.modInf");
  293. KBDcFree(moduleInfo.modInf);
  294. moduleInfo.modInf=NULL;
  295. moduleInfo.modNum = 0;
  296.        }
  297. }
  300. //初始化file结构
  301. void InitFileStruct(DCFILE *file)
  302. {
  303.    if(file==NULL)
  304.     return;
  306.    file->position =0;
  307.    file->fileLength =0;
  308.    KBDcMemset(file->fileName,0,KB_DCFILE_NAME_MAX_LEN);
  309.    file->section =NULL;
  310.    
  311.    //init bufstatus
  312.    file->BufStatus.modcount=0;
  313.    file->BufStatus.modStat = NULL;
  314.    
  315.    return;
  316. }
  318. //----------初始化buffer status----------
  319. int kb_dc_bufferStatusBuild(DCFILE *pfile, int blocksCnt)
  320. {
  321. int  i=0, modulesCnt=0;
  323. modulesCnt=blocksCnt/256+((blocksCnt%256==0)?0:1);
  324. if(pfile==NULL)
  325. {
  326. DCDebug1("n kb_dc_bufferStatusBuild: pfile is NULL");
  327. return 0;
  328. }
  330. //module buffer status
  331. pfile->BufStatus.modcount = modulesCnt;
  332. DCDebug3("n kb_dc_bufferStatusBuild:  modulesCnt=%d structSize=%d", modulesCnt, sizeof(DCBLOCKBUFSTATUS));
  333. pfile->BufStatus.modStat = (DCBLOCKBUFSTATUS *)KBDcMalloc(modulesCnt*sizeof(DCBLOCKBUFSTATUS));
  334. if(pfile->BufStatus.modStat == NULL) 
  335. {
  336. DCDebug1("n BufStatus malloc error");  
  337. return 0;
  338. }
  339. KBDcMemset(pfile->BufStatus.modStat, EMPTY, modulesCnt*sizeof(DCBLOCKBUFSTATUS));
  341. //block buffer status
  342. if(pfile->BufStatus.modcount==1)
  343. {
  344. DCDebug3("n ---in one module mode----");
  345. pfile->BufStatus.modStat[0].blockCount = blocksCnt;
  346. pfile->BufStatus.modStat[0].blockStat = (unsigned char *)KBDcMalloc(blocksCnt*sizeof(unsigned char));
  347. if(pfile->BufStatus.modStat[0].blockStat==NULL) 
  348. {
  349. DCDebug1("n blockStat malloc error 1");  
  350. return 0;
  351. }
  352. KBDcMemset(pfile->BufStatus.modStat[0].blockStat, EMPTY, blocksCnt*sizeof(unsigned char));
  353. }
  354. else if(pfile->BufStatus.modcount > 1)
  355. {
  356. int blockCntOfMod =0, blockCntOfLastMod =0;
  358. DCDebug3("n ---in multi-module mode----");
  359. blockCntOfMod = 256;
  360. for(i=0; i<pfile->BufStatus.modcount-1; i++)
  361. {
  362. pfile->BufStatus.modStat[i].blockCount = blockCntOfMod;
  363. pfile->BufStatus.modStat[i].blockStat  = (unsigned char *)KBDcMalloc(blockCntOfMod*sizeof(unsigned char));
  364. if(pfile->BufStatus.modStat[i].blockStat==NULL) 
  365. {
  366. DCDebug1("n blockStat of mod[%d] malloc error 2", i);  
  367. return 0;
  368. }
  369. KBDcMemset(pfile->BufStatus.modStat[i].blockStat, EMPTY, blockCntOfMod*sizeof(unsigned char));
  370. }
  372. //last module
  373. blockCntOfLastMod = blocksCnt - (pfile->BufStatus.modcount-1)*256;
  374. pfile->BufStatus.modStat[pfile->BufStatus.modcount-1].blockCount = blockCntOfLastMod;
  375. pfile->BufStatus.modStat[pfile->BufStatus.modcount-1].blockStat  = (unsigned char *)KBDcMalloc(blockCntOfLastMod*sizeof(unsigned char));
  376. if(pfile->BufStatus.modStat[pfile->BufStatus.modcount-1].blockStat==NULL) 
  377. {
  378. DCDebug1("n  blockStat  of last mod malloc error 3");  
  379. return 0;
  380. }
  381. KBDcMemset(pfile->BufStatus.modStat[pfile->BufStatus.modcount-1].blockStat,  EMPTY,  blockCntOfLastMod*sizeof(unsigned char));
  383. }
  385. return 1;
  386. }
  388. //根据moduleid从diiSection取得该module所承载的有效数据的大小
  389. unsigned int DCGetModSizeByIdSec(int index)
  390. {
  391.       DCDIR *dir;
  392.       ModuleInfo modInfo;
  393.   
  394.       // 获得dir 结构   
  395.       dir = GetDCDIR();
  396.       GetModuleInfo(dir->diiSection, index, &modInfo);
  397.       return modInfo.moduleSize;
  398. }
  403. //根据moduleid从DCFIle取得该module所承载的有效数据的大小
  404. unsigned int DCGetModSizeByModuleId(int modId)
  405. {
  406.      int i=0;
  408. for(i=0;i<moduleInfo.modNum;i++)
  409. {
  410. if(moduleInfo.modInf[i].modID == modId)
  411. return moduleInfo.modInf[i].moduleSize;
  412. }
  414. return 0xffff;
  415. }
  418. //Fuction:DcOpenFile
  419. //Description:malloc 
  420. DCFILE* DcOpenFile(DCDIR* dir,const char* fileName)
  421. {
  422. DIIHead diiHead;
  423. ModuleInfo modInfo;
  424. unsigned char name[255];
  425. int modCount=0;
  426. int blockSize=0;
  427. int blocksCnt=0;
  428. int i=0, nameLength;
  429. DCFILE *file;
  431. unsigned char *diiSection=dir->diiSection;
  432. GetDIIHead(diiSection,&diiHead);
  433. modCount=diiHead.numberOfModules;
  434. blockSize=diiHead.blockSize;
  436. file = (DCFILE*)KBDcMalloc(sizeof(DCFILE));
  437. if(file==NULL)
  438. {
  439. DCDebug1("nfile malloc error...n");
  440. return NULL;
  441. }
  443. InitFileStruct(file);
  444. if(InitFileModuleInfo(modCount)!=0)
  445. {
  446. DCDebug1("n InitFileModuleInfo error");
  447. return NULL;
  448. }
  450. DCDebug3("n modCount=%d...n",modCount);
  451. for(i=0;i<modCount;i++)
  452. {
  453. GetModuleInfo(diiSection,i,&modInfo);
  454. nameLength=GetModuleName(&modInfo,name);
  455. DCDebug3("[%s]VS[%s]...n", name, fileName);
  457. //初始化moduleInfo
  458. moduleInfo.modInf[moduleInfo.modNum].modID = modInfo.moduleId;
  459. moduleInfo.modInf[moduleInfo.modNum].moduleSize = modInfo.moduleSize;
  460. moduleInfo.modInf[moduleInfo.modNum].moduleVersion = modInfo.moduleVersion;
  461. strncpy((char*)moduleInfo.modInf[moduleInfo.modNum].fileName, (char*)name, strlen((char*)name));
  462. moduleInfo.modNum++;
  464. if(0==strcmp((const char*)name,(const char*)fileName))
  465. {
  466.        DCDebug3("open File[%d]=[%s]n",i,name);
  467. kb_dc_SaveCurCfgName(name);
  468. strcpy((char*)file->fileName,(char*)name);
  469. file->position=0;
  470. file->fileLength+=modInfo.moduleSize;
  471. }
  472. }
  474. //初始化一个配置文件收取 重复判断的结构,以避免解析中数组访问越界
  475. blocksCnt=(int)(file->fileLength)/4066+(((int)(file->fileLength)%4066==0)?0:1);
  476. if(kb_dc_bufferStatusBuild(file, blocksCnt)==0)
  477. {
  478. DCDebug1("n kb_dc_bufferStatusBuild failed");
  479. return NULL;
  480. }
  482. //初始化section buffer
  483. file->section = (unsigned char *)KBDcMalloc(file->fileLength);
  484.        if(file->section==NULL)
  485. {
  486. DCDebug1("Out of memory[%d]rn",file->fileLength);
  487. return NULL;
  488. }
  489. else
  490. {
  491.        //KBDcMemset(file->section, EMPTY, file->fileLength);
  492.        return file;
  493.         }
  494. }
  499. //--------------------------------------------------------------------------
  500. //description: 
  501. //--
  502. DCDIR* OpenDirectory(unsigned char *pData,int len)
  503. {
  504. DIIHead diiHead;
  505. DCDIR *dir;
  507. dir=(DCDIR*)KBDcMalloc(sizeof(DCDIR));
  508. KBDcMemset(dir, 0x00, sizeof(DCDIR));
  510. dir->diiSection=(unsigned char*)KBDcMalloc(4096);
  511. KBDcMemset(dir->diiSection, 0x00, 4096);
  513. KBDcMemcpy(dir->diiSection,pData,len);
  514. GetDIIHead(dir->diiSection,&diiHead);
  515. dir->blockSize=diiHead.blockSize;
  516. dir->numberOfModules = diiHead.numberOfModules;
  518. return dir;
  519. }
  521. //检查配置文件的版本号是否变更
  522. //TRUE: changed
  523. //FALSE: not changed
  524. BOOL kb_dc_CfgVerCheck(unsigned char *cfg_name, unsigned char type)
  525. {
  526. int i=0;
  528. if(cfg_name==NULL)
  529. {
  530. DCDebug1("n -kb_dc_CfgVerCheck-:  cfg_name is null");
  531. return FALSE;
  532. }
  534. //还没有取到module info数据的情况下，不去激活
  535. //配置文件搜索
  536. if(moduleInfo.modNum==0)
  537. {
  538. DCDebug1("n -kb_dc_CfgVerCheck-: moduleInfo.modNum==0! ");
  539. return FALSE;
  540. }
  542. //根据配置文件名匹配
  543. for(i=0;i<moduleInfo.modNum;i++)
  544. {
  545. if(strcmp((const char *)cfg_name, (const char *)moduleInfo.modInf[i].fileName)==0)
  546. {
  547. if(type==SERV_CFG_ADVERTISE)
  548. {
  549. DCDebug2("n -kb_dc_CfgVerCheck-: curCfgVer=%d   modInf[%d].moduleVersion=%d", curMovieCfgVer,i, moduleInfo.modInf[i].moduleVersion);
  550. if((unsigned short)moduleInfo.modInf[i].moduleVersion!=curMovieCfgVer)
  551. {
  552. curMovieCfgVer = (unsigned short)moduleInfo.modInf[i].moduleVersion;
  553. return TRUE;
  554. }
  555. }
  556. else if(type==SERV_CFG_MAIN)
  557. {
  558. DCDebug2("n -kb_dc_CfgVerCheck-: curServCfgVer=%d   modInf[%d].moduleVersion=%d", curServCfgVer,i, moduleInfo.modInf[i].moduleVersion);
  559. if((unsigned short)moduleInfo.modInf[i].moduleVersion!=curServCfgVer)
  560. {
  561. curServCfgVer = (unsigned short)moduleInfo.modInf[i].moduleVersion;
  562. return TRUE;
  563. }
  564. }
  565. } }
  568. //如果精确到文件, 此段代码应该屏蔽
  569. #if 0
  570. if(i>=moduleInfo.modNum)
  571. {
  572. int j=0;
  574. for(j=0;j<moduleInfo.modNum;j++)
  575. {
  576. if(moduleInfo.modInf[j].moduleVersion!=curMovieCfgVer)
  577. return TRUE;
  578. }
  579. }
  580. #endif
  582. return FALSE;
  583. }
  586. //-------
  587. unsigned char kb_dc_GetCurCfgVer()
  588. {
  589. return curMovieCfgVer;
  590. }
  592. int kb_dc_SaveServCfgVersion( char *cfg_name)
  593. {
  594. int i;
  596. for(i=0; i<moduleInfo.modNum; i++)
  597. {
  598. if(strcmp((const char *)cfg_name, (const char *)moduleInfo.modInf[i].fileName)==0)
  599. {
  600. curServCfgVer = (unsigned short)moduleInfo.modInf[i].moduleVersion;
  601. return true;
  602. }
  603. }
  606. return false;
  607. }
  609. void kb_dc_SaveCurCfgName(unsigned char *name)
  610. {
  611. if(curCfgName==NULL)
  612. {
  613. curCfgName=(unsigned char*)KBDcMalloc(KB_DCFILE_NAME_MAX_LEN*sizeof(unsigned char));
  614. if(curCfgName==NULL)
  615. {
  616. DCDebug1("n curCfgName malloc error!!!");
  617. return;
  618. }
  619. }
  621. strcpy((char*)curCfgName, (char*)name);
  622. return;
  623. }
  625. unsigned char * kb_dc_GetCurCfgName(void)
  626. {
  627. return curCfgName;
  628. }
  630. void kb_dc_moduleInfo_Test(void)
  631. {
  632. int i;
  634. for(i=0;i<moduleInfo.modNum;i++)
  635.     {
  636. DCDebug3("n mod[%d]: modid=%d,   fileName=%s,    moduleVersion=%d", i, moduleInfo.modInf[i].modID,  moduleInfo.modInf[i].fileName, moduleInfo.modInf[i].moduleVersion);
  637.     }
  638. }
  641. void kb_dc_CfgVerSaveTest(void)
  642. {
  643. DCDebug3("n ----kb_dc_CfgVerSaveTest-----");
  644. curMovieCfgVer++;
  645. }
  648. /*
  649. * 判断一个module是否已经收取完毕
  650. */
  651. unsigned char kb_dc_moduleIsEnd(DCFILE*pfile, unsigned short  index)
  652. {
  653. int k;
  655. if(index >(pfile->BufStatus.modcount-1))
  656. {
  657. DCDebug1("n index overflow error");
  658. index = pfile->BufStatus.modcount-1;
  659. }
  661. for(k=0; k<pfile->BufStatus.modStat[index].blockCount; k++)
  662. {
  663. if(pfile->BufStatus.modStat[index].blockStat[k] == EMPTY)
  664. break;
  665. }
  667. if(k>=pfile->BufStatus.modStat[index].blockCount)
  668. return 1;
  669. else
  670. return 0;
  672. }