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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
paramset.cpp
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：14k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

paramset.cpp：源码内容
  1. /*************************************************************************
  3. This software module was originally developed by 
  5. Simon Winder (swinder@microsoft.com), Microsoft Corporation
  7. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  8. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  9. as specified by the MPEG-4 Video. 
  10. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  11. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  12. Those intending to use this software module in hardware or software products are advised that
  13. its use may infringe existing patents. The original developer of this software module and his/her
  14. company, the subsequent editors and their companies, and ISO/IEC have no liability for use of
  15. this software module or modifications thereof in an implementation. Copyright is not released
  16. for non MPEG-4 Video conforming products. Microsoft retains full right to use the code for
  17. his/her own purpose, assign or donate the code to a third party and to inhibit third parties
  18. from using the code for non MPEG-4 Video conforming products. This copyright notice must be
  19. included in all copies or derivative works. 
  21. Copyright (c) 1996, 1997.
  24. *************************************************************************/
  27. #include <stdio.h>
  28. #include <stdlib.h>
  29. #include <string.h>
  30. #include <ctype.h>
  32. #include "paramset.h"
  35. #ifdef __MFC_
  36. #ifdef _DEBUG
  37. #undef THIS_FILE
  38. static char BASED_CODE THIS_FILE[] = __FILE__;
  39. #endif
  41. #define new DEBUG_NEW    
  42. #endif // __MFC_
  44. ////////////////////////////////////////////////////////////////////////
  45. // CxParamSet
  46. ////////////////////////////////////////////////////////////////////////
  48. CxParamSet::CxParamSet()
  49. : m_pCurrentEnum(NULL), m_pCreateListTail(NULL)
  50. {
  51. Int i;
  52. for(i=0; i<PAR_HASHSIZE; i++)
  53. m_rgpHashList[i] = NULL;
  54. }
  56. CxParamSet::~CxParamSet()
  57. {
  58. DeleteAll();
  59. }
  61. Int CxParamSet::GetParam(const char *pchName, Int iIndex, TxParamValue *ptValueRtn)
  62. {
  63. if(pchName==NULL)
  64. return ERES_PARAMS;
  65. if(iIndex<-1)
  66. iIndex = -1;
  68. Int iHash;
  69. TxParamEntry *pEntry = FindHashEntry(pchName, iIndex, &iHash);
  70. if(pEntry==NULL)
  71. return ERES_NOOBJ;
  73. if(ptValueRtn!=NULL)
  74. *ptValueRtn = pEntry->tValue;
  76. return ERES_OK;
  77. }
  79. Int CxParamSet::SetParam(const char *pchName, Int iIndex, const TxParamValue *ptValue)
  80. {
  81. if(pchName==NULL || ptValue==NULL)
  82. return ERES_PARAMS;
  83. if(ptValue->tType==PS_STRING && ptValue->pchData==NULL)
  84. return ERES_PARAMS;
  85. if(ptValue->tType==PS_ARRAY && ptValue->pdData==NULL)
  86. return ERES_PARAMS;
  87. if(iIndex<-1)
  88. iIndex = -1;
  90. Int iHash;
  91. TxParamEntry *pEntry = FindHashEntry(pchName, iIndex, &iHash);
  92. if(pEntry==NULL)
  93. {
  94. // validate new name
  95. Int i, iL;
  96. iL = strlen(pchName);
  97. for(i=0; i<iL; i++)
  98. if(isspace(pchName[i]) || pchName[i]=='/' || pchName[i]=='['
  99. || pchName[i]=='=')
  100. return ERES_PARAMS;
  102. // create new entry at iHash
  103. pEntry = new TxParamEntry;
  104. if(pEntry==NULL)
  105. return ERES_MEMORY;
  106. pEntry->pchName = new char [strlen(pchName) + 1];
  107. if(pEntry->pchName==NULL)
  108. {
  109. delete pEntry;
  110. return ERES_MEMORY;
  111. }
  112. strcpy(pEntry->pchName, pchName);
  113. pEntry->iIndex = iIndex;
  115. // copy data
  116. pEntry->tValue = *ptValue;
  117. if(pEntry->tValue.tType==PS_STRING)
  118. {
  119. pEntry->tValue.pchData = new char [strlen(ptValue->pchData) + 1];
  120. if(pEntry->tValue.pchData==NULL)
  121. {
  122. delete pEntry->pchName;
  123. delete pEntry;
  124. return ERES_MEMORY;
  125. }
  126. strcpy(pEntry->tValue.pchData, ptValue->pchData);
  127. }
  128. else if(pEntry->tValue.tType==PS_ARRAY)
  129. {
  130. pEntry->tValue.pdData = new Double [pEntry->tValue.iSize + 1]; // add one in case size is zero
  131. if(pEntry->tValue.pdData==NULL)
  132. {
  133. delete pEntry->pchName;
  134. delete pEntry;
  135. return ERES_MEMORY;
  136. }
  137. memcpy(pEntry->tValue.pdData, ptValue->pdData, pEntry->tValue.iSize * sizeof(Double));
  138. }
  140. // add to hash list at head
  141. pEntry->pNextHash = m_rgpHashList[iHash];
  142. pEntry->pPrevHash = NULL;
  143. m_rgpHashList[iHash] = pEntry;
  144. if(pEntry->pNextHash)
  145. pEntry->pNextHash->pPrevHash = pEntry;
  147. // add to create list at tail
  148. pEntry->pPrevCreate = m_pCreateListTail;
  149. pEntry->pNextCreate = NULL;
  150. m_pCreateListTail = pEntry;
  151. if(pEntry->pPrevCreate)
  152. pEntry->pPrevCreate->pNextCreate = pEntry;
  153. }
  154. else // already exists
  155. {
  156. // make copy of string or array if necessary
  157. char *pchTmp = NULL;
  158. Double *pdTmp = NULL;
  159. if(ptValue->tType==PS_STRING)
  160. {
  161. pchTmp = new char [strlen(ptValue->pchData) + 1];
  162. if(pchTmp==NULL)
  163. return ERES_MEMORY;
  164. strcpy(pchTmp, ptValue->pchData);
  165. }
  166. else if(pEntry->tValue.tType==PS_ARRAY)
  167. {
  168. pdTmp = new Double [ptValue->iSize + 1];
  169. if(pdTmp==NULL)
  170. return ERES_MEMORY;
  171. memcpy(pdTmp, ptValue->pdData, ptValue->iSize * sizeof(Double));
  172. }
  174. // delete old string or array if present
  175. if(pEntry->tValue.tType==PS_STRING)
  176. delete pEntry->tValue.pchData;
  177. else if(pEntry->tValue.tType==PS_ARRAY)
  178. delete pEntry->tValue.pdData;
  180. // copy data
  181. pEntry->tValue = *ptValue;
  183. // assign string or array pointer
  184. if(ptValue->tType==PS_STRING)
  185. pEntry->tValue.pchData = pchTmp;
  186. else if(ptValue->tType==PS_ARRAY)
  187. pEntry->tValue.pdData = pdTmp;
  188. }
  190. return ERES_OK;
  191. }
  193. Int CxParamSet::DeleteParam(const char *pchName, Int iIndex)
  194. {
  195. if(pchName==NULL)
  196. return ERES_PARAMS;
  197. if(iIndex<-1)
  198. iIndex = -1;
  200. Int iHash;
  201. TxParamEntry *pEntry = FindHashEntry(pchName, iIndex, &iHash);
  202. if(pEntry==NULL)
  203. return ERES_NOOBJ;
  205. if(pEntry==m_pCurrentEnum)
  206. m_pCurrentEnum = pEntry->pNextCreate;
  208. DeleteHashEntry(pEntry, iHash);
  210. return ERES_OK;
  211. }
  213. void CxParamSet::StartEnum()
  214. {
  215. // set current enum to head of create list
  216. if(m_pCreateListTail==NULL)
  217. return;
  218. m_pCurrentEnum = m_pCreateListTail;
  219. while(m_pCurrentEnum->pPrevCreate)
  220. m_pCurrentEnum = m_pCurrentEnum->pPrevCreate;
  221. }
  223. Bool CxParamSet::NextEnum(char **ppchNameRtn, Int *piIndexRtn, TxParamValue *ptValueRtn)
  224. {
  225. if(m_pCurrentEnum==NULL)
  226. return FALSE;
  228. if(ppchNameRtn)
  229. *ppchNameRtn = m_pCurrentEnum->pchName;
  230. if(piIndexRtn)
  231. *piIndexRtn = m_pCurrentEnum->iIndex;
  232. if(ptValueRtn)
  233. *ptValueRtn = m_pCurrentEnum->tValue;
  235. m_pCurrentEnum = m_pCurrentEnum->pNextCreate;
  236. return TRUE;
  237. }
  239. void CxParamSet::DeleteAll()
  240. {
  241. Int i;
  242. for(i=0; i<PAR_HASHSIZE; i++)
  243. {
  244. TxParamEntry *pEntry;
  245. while((pEntry = m_rgpHashList[i])!=NULL)
  246. DeleteHashEntry(pEntry, i);
  247. }
  248. m_pCurrentEnum = NULL;
  249. }
  251. void CxParamSet::DeleteHashEntry(TxParamEntry *pEntry, Int iHash)
  252. {
  253. // unlink from hash chain
  254. if(pEntry->pPrevHash)
  255. pEntry->pPrevHash->pNextHash = pEntry->pNextHash;
  256. else
  257. m_rgpHashList[iHash] = pEntry->pNextHash;
  258. if(pEntry->pNextHash)
  259. pEntry->pNextHash->pPrevHash = pEntry->pPrevHash;
  261. // unlink from create chain
  262. if(pEntry->pPrevCreate)
  263. pEntry->pPrevCreate->pNextCreate = pEntry->pNextCreate;
  264. if(pEntry->pNextCreate)
  265. pEntry->pNextCreate->pPrevCreate = pEntry->pPrevCreate;
  266. else
  267. m_pCreateListTail = pEntry->pPrevCreate;
  269. // delete
  270. if(pEntry->tValue.tType==PS_STRING)
  271. delete pEntry->tValue.pchData;
  272. else if(pEntry->tValue.tType==PS_ARRAY)
  273. delete pEntry->tValue.pdData;
  275. delete pEntry->pchName;
  276. delete pEntry;
  277. }
  279. TxParamEntry *CxParamSet::FindHashEntry(const char *pchName, Int iIndex, Int *piHashRtn)
  280. {
  281. const char *pchPtr;
  282. Int iHash = (iIndex + 2) % PAR_HASHSIZE;
  283. for(pchPtr = pchName; *pchPtr!=''; pchPtr++)
  284. iHash = (iHash * 17 + *pchPtr) % PAR_HASHSIZE;
  286. *piHashRtn = iHash;
  288. TxParamEntry *pEntry = m_rgpHashList[iHash];
  289. for(; pEntry!=NULL; pEntry = pEntry->pNextHash)
  290. if(iIndex==pEntry->iIndex && strcmp(pchName, pEntry->pchName)==0)
  291. break;
  293. return pEntry;
  294. }
  296. Int CxParamSet::GetC()
  297. {
  298. Int ch = getc(m_fp);
  299. if(ch=='n')
  300. (*m_piErrLine)++;
  301. return ch;
  302. }
  304. void CxParamSet::UnGetC(Int ch)
  305. {
  306. ungetc(ch, m_fp);
  307. if(ch=='n')
  308. (*m_piErrLine)--;
  309. }
  311. Int CxParamSet::GetToken(char *pchBuf)
  312. {
  313. SkipSpace();
  314. Int ch = GetC();
  315. if(ch==EOF)
  316. return ERES_EOF;
  317. if(ch=='/')
  318. {
  319. SkipComment();
  320. ch = GetC();
  321. if(ch==EOF)
  322. return ERES_EOF;
  323. }
  324. if(ch=='[' || ch==']' || ch=='=' || ch=='{' || ch=='}' || ch==','
  325. || ch=='"')
  326. {
  327. pchBuf[0] = (char)ch;
  328. pchBuf[1] = '';
  329. return ERES_OK;
  330. }
  331. pchBuf[0] = (char)ch;
  332. Int i;
  333. for(i=1;i<TOKEN_SIZE - 1;i++)
  334. {
  335. ch = GetC();
  336. if(ch==EOF)
  337. {
  338. pchBuf[i] = '';
  339. return ERES_EOF;
  340. }
  341. if(isspace(ch) || ch=='[' || ch==']' || ch=='=' || ch=='{'
  342. || ch=='}' || ch==',' || ch=='"')
  343. {
  344. pchBuf[i] = '';
  345. UnGetC(ch);
  346. return ERES_OK;
  347. }
  348. if(ch=='/' && SkipComment()!=ERES_NOOBJ)
  349. {
  350. pchBuf[i] = '';
  351. return ERES_OK;
  352. }
  353. pchBuf[i] = (char)ch;
  354. }
  355. pchBuf[i] = '';
  356. return ERES_OK;
  357. }
  359. Int CxParamSet::SkipSpace()
  360. {
  361. Int ch;
  363. do {
  364. ch = GetC();
  365. if(ch==EOF)
  366. return ERES_EOF;
  367. } while(isspace(ch));
  369. UnGetC(ch);
  370. return ERES_OK;
  371. }
  373. Int CxParamSet::SkipComment()
  374. {
  375. // assumes we already read a '/'
  376. // space is skipped at end
  377. Int ch;
  378. do {
  379. ch = GetC();
  380. if(ch==EOF)
  381. return ERES_EOF;
  382. if(ch!='/' && ch!='*')
  383. {
  384. UnGetC(ch);
  385. return ERES_NOOBJ;
  386. }
  387. if(ch=='/')
  388. {
  389. do {
  390. ch = GetC();
  391. if(ch==EOF)
  392. return ERES_EOF;
  393. } while(ch!='n');
  394. }
  395. else if(ch=='*')
  396. {
  397. Int iState = 0;
  398. do {
  399. ch = GetC();
  400. if(ch==EOF)
  401. return ERES_EOF;
  402. if(iState==0 && ch=='*')
  403. iState = 1;
  404. else if(iState==1)
  405. {
  406. if(ch=='/')
  407. iState = 2;
  408. else if(ch!='*')
  409. iState = 0;
  410. }
  411. } while(iState!=2);
  412. }
  413. if(SkipSpace()==ERES_EOF)
  414. return ERES_EOF;
  415. ch = GetC();
  416. if(ch==EOF)
  417. return ERES_EOF;
  418. } while(ch=='/');
  420. UnGetC(ch);
  421. return ERES_OK;
  422. }
  424. Int CxParamSet::ReadValue(char *pchBuf, TxParamValue *ptVal)
  425. {
  426. if(pchBuf[0]=='"')
  427. {
  428. // string value
  429. Int i, ch;
  430. for(i=0; i<TOKEN_SIZE - 2; i++)
  431. {
  432. ch = GetC();
  433. if(ch=='"')
  434. {
  435. pchBuf[i] = '';
  436. //printf(""%s"n", pchBuf);
  437. SetPVString(*ptVal, pchBuf);
  438. return ERES_OK;
  439. }
  440. if(ch==EOF)
  441. return ERES_FORMAT;
  442. pchBuf[i] = (char)ch;
  443. }
  444. return ERES_FORMAT;
  445. }
  446. else
  447. {
  448. char *pchEnd;
  449. Double dVal = strtod(pchBuf, &pchEnd);
  450. if(*pchEnd != '')
  451. return ERES_FORMAT;
  452. //printf("%gn", dVal);
  453. SetPVDouble(*ptVal, dVal);
  454. return ERES_OK;
  455. }
  456. }
  458. Int CxParamSet::Load(FILE *fp, Int *piErrLine)
  459. {
  460. char pchBuf[TOKEN_SIZE], pchName[TOKEN_SIZE];
  461. Int iInd;
  462. TxParamValue tVal;
  464. m_piErrLine = piErrLine;
  465. m_fp = fp;
  466. *m_piErrLine = 1;
  468. while(!(GetToken(pchBuf)==ERES_EOF))
  469. {
  470. strcpy(pchName, pchBuf);
  471. if(GetToken(pchBuf)==ERES_EOF)
  472. goto close_on_format;
  474. if(pchBuf[0]=='[')
  475. {
  476. if(GetToken(pchBuf)==ERES_EOF)
  477. goto close_on_format;
  478. char *pchEnd;
  479. iInd = strtol(pchBuf, &pchEnd, 10);
  480. if(*pchEnd != '')
  481. goto close_on_format;
  482. if(GetToken(pchBuf)==ERES_EOF)
  483. goto close_on_format;
  484. if(pchBuf[0]!=']')
  485. goto close_on_format;
  486. if(GetToken(pchBuf)==ERES_EOF)
  487. goto close_on_format;
  488. }
  489. else
  490. iInd = -1;
  491. if(pchBuf[0]!='=')
  492. goto close_on_format;
  494. if(GetToken(pchBuf)==ERES_EOF)
  495. goto close_on_format;
  496. if(pchBuf[0]=='{')
  497. {
  498. Int iCount = 0;
  499. Double rgdTemp[256];
  500. do {
  501. //printf("%s[%d] = (%d)", pchName, iInd, iCount);
  502. if(GetToken(pchBuf)==ERES_EOF)
  503. goto close_on_format;
  504. if(pchBuf[0]=='}')
  505. break;
  506. Int er = ReadValue(pchBuf, &tVal);
  507. if(er==ERES_OK)
  508. {
  509. if(tVal.tType==PS_DOUBLE)
  510. rgdTemp[iCount] = tVal.dData;
  511. else
  512. rgdTemp[iCount] = 0.0;
  513. }
  514. else
  515. return er;
  516. if(iCount<255)
  517. iCount++;
  519. if(GetToken(pchBuf)==ERES_EOF)
  520. goto close_on_format;
  521. } while(pchBuf[0]==',');
  523. if(pchBuf[0]!='}')
  524. goto close_on_format;
  526. SetPVArray(tVal, rgdTemp, iCount);
  527. Int er = SetParam(pchName, iInd, &tVal);
  528. if(er!=ERES_OK)
  529. return er;
  530. }
  531. else
  532. {
  533. //printf("%s[%d] = ", pchName, iInd);
  534. TxParamValue tVal;
  535. Int er = ReadValue(pchBuf, &tVal);
  536. if(er==ERES_OK)
  537. er = SetParam(pchName, iInd, &tVal);
  538. if(er!=ERES_OK)
  539. return er;
  540. }
  541. }
  543. return ERES_OK;
  545. close_on_format:
  546. return ERES_FORMAT;
  547. }
  550. Int CxParamSet::GetDouble(char *pchName, Int iIndex, Double *pdValue)
  551. {
  552. TxParamValue v;
  553. Int er = GetParam(pchName, iIndex, &v);
  554. if(er==ERES_OK)
  555. {
  556. if(v.tType==PS_DOUBLE)
  557. *pdValue = v.dData;
  558. else
  559. return ERES_PARAMS;
  560. }
  561. return er;
  562. }
  564. Int CxParamSet::GetString(char *pchName, Int iIndex, char **ppchVal)
  565. {
  566. TxParamValue v;
  567. Int er = GetParam(pchName, iIndex, &v);
  568. if(er==ERES_OK)
  569. {
  570. if(v.tType==PS_STRING)
  571. {
  572. char *pchBuf = new char [strlen(v.pchData)+1];
  573. if(pchBuf==NULL)
  574. return ERES_MEMORY;
  575. strcpy(pchBuf, v.pchData);
  576. *ppchVal = pchBuf;
  577. }
  578. else
  579. return ERES_PARAMS;
  580. }
  581. return er;
  582. }
  584. Int CxParamSet::GetArray(char *pchName, Int iIndex, Double **ppdVal, Int *piSize)
  585. {
  586. TxParamValue v;
  587. Int er = GetParam(pchName, iIndex, &v);
  588. if(er==ERES_OK)
  589. {
  590. if(v.tType==PS_ARRAY)
  591. {
  592. Double *pdBuf = NULL;
  593. if(v.iSize>0)
  594. {
  595. pdBuf = new Double [v.iSize];
  596. if(pdBuf==NULL)
  597. return ERES_MEMORY;
  598. memcpy(pdBuf, v.pdData, v.iSize * sizeof(Double));
  599. }
  600. *ppdVal = pdBuf;
  601. *piSize = v.iSize;
  602. }
  603. else
  604. return ERES_PARAMS;
  605. }
  606. return er;
  607. }
  609. void CxParamSet::Dump(FILE *fp)
  610. {
  611. StartEnum();
  613. char *pchName;
  614. int iInd, iCount;
  615. TxParamValue tVal;
  617. iCount = 0;
  618. while(NextEnum(&pchName, &iInd, &tVal))
  619. {
  620. iCount++;
  621. if(iInd<0)
  622. fprintf(fp, "%s = ", pchName);
  623. else
  624. fprintf(fp, "%s[%d] = ", pchName, iInd);
  625. if(tVal.tType==PS_DOUBLE)
  626. fprintf(fp, "%g", tVal.dData);
  627. else if(tVal.tType==PS_STRING)
  628. fprintf(fp, ""%s"", tVal.pchData);
  629. else
  630. {
  631. fprintf(fp, "{");
  632. int i;
  633. for(i = 0; i<tVal.iSize; i++)
  634. {
  635. fprintf(fp, "%g", tVal.pdData[i]);
  636. if(i+1<tVal.iSize)
  637. fprintf(fp, ", ");
  638. }
  639. fprintf(fp, "}");
  640. }
  641. fprintf(fp, "n");
  642. }
  644. fprintf(fp,"n// Total: %d parameters.nn", iCount);
  645. }