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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

convertpar.cpp：源码内容
  1. /*************************************************************************
  3. This software module was originally developed by 
  5. Simon Winder (swinder@microsoft.com), Microsoft Corporation
  8. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  9. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  10. as specified by the MPEG-4 Video. 
  11. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  12. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  13. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
  14. The original developer of this software module and his/her company, 
  15. the subsequent editors and their companies, 
  16. and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
  17. Copyright is not released for non MPEG-4 Video conforming products. 
  18. Sharp retains full right to use the code for his/her own purpose, 
  19. assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
  20. This copyright notice must be included in all copies or derivative works. 
  22. Copyright (c) 1997.
  25. *************************************************************************/
  28. #include <stdio.h>
  29. #include <stdlib.h>
  30. #include <string.h>
  32. typedef unsigned int UInt;
  33. typedef int Int;
  34. typedef void Void;
  35. typedef int Bool;
  36. typedef double Double;
  37. typedef enum {Q_H263, Q_MPEG} Quantizer; 
  38. typedef enum AlphaUsage {RECTANGLE, ONE_BIT, EIGHT_BIT} AlphaUsage;
  39. typedef enum ChromType {FOUR_FOUR_FOUR, FOUR_TWO_TWO, FOUR_TWO_ZERO} ChromType;
  40. typedef enum {BASIC_SPRITE, LOW_LATENCY, PIECE_OBJECT, PIECE_UPDATE} SptMode;
  41. typedef char Char;
  43. Void nextValidLine (FILE *pfPara, UInt* pnLine);
  44. Void readBoolVOLFlag (Bool * rgbTable [2], UInt nVO, FILE * pfCfg, UInt * pnLine, Bool bAnyScalability);
  45. Void readItem(UInt *rguiTable [2], UInt nVO, FILE * pfCfg, UInt * pnLine, Bool bAnyScalability);
  47. #define BASE_LAYER 0
  48. #define ENHN_LAYER 1
  49. #define NO_SCALABILITY  0
  50. #define TEMPORAL_SCALABILITY 1
  51. #define SPATIAL_SCALABILITY  2
  52. #define FALSE 0
  53. #define TRUE 1
  54. #define BLOCK_SQUARE_SIZE    64
  55. #define RC_MPEG4 1
  56. #define RC_TM5 3
  58. Void fatal_error(char *pchError, Bool bFlag = FALSE);
  60. void my_assert(int iFlag)
  61. {
  62. if(!iFlag)
  63. fatal_error("Some assert failed! Check original par file format.n");
  64. }
  66. int main (Int argc, Char* argv[])
  67. {
  68. UInt nLine = 1;
  69. UInt* pnLine = &nLine;
  70. FILE *pfPara;
  71. FILE *pfOut = stdout;
  73. if (argc != 2 && argc !=3)
  74. {
  75. fprintf (stderr,"Usage: %s old_par_file [new_par_file]n", argv[0]);
  76. fatal_error("Conversion aborted");
  77. }
  79. if ((pfPara = fopen (argv[1], "r")) == NULL )
  80. {
  81. fprintf (stderr,"Source parameter file not foundn");
  82. fatal_error("Conversion aborted");
  83. }
  85. if(argc==3)
  86. {
  87. if ((pfOut = fopen (argv[2], "w")) == NULL )
  88. {
  89. fprintf (stderr,"Could not open %s for writing.n", argv[2]);
  90. fatal_error("Conversion aborted");
  91. }
  92. }
  94. // all the parameters to the encoder
  95. Int iVersion;
  96. Int iVTCFlag;
  97. UInt uiFrmWidth, uiFrmHeight;
  98. UInt firstFrm, lastFrm;
  99. Bool bNot8Bit;
  100. UInt uiQuantPrecision;
  101. UInt nBits;
  102. UInt firstVO, lastVO;
  103. UInt nVO;
  104. UInt uiFrmWidth_SS,uiFrmHeight_SS;
  105. UInt uiHor_sampling_m,uiHor_sampling_n;
  106. UInt uiVer_sampling_m,uiVer_sampling_n;
  107. Bool bAnyScalability;
  108. Int iSpatialOption;
  109. char *pchPrefix;
  110. char *pchBmpDir;
  111. char *pchOutBmpDir;
  112. char *pchOutStrFile;
  113. char *pchSptDir;
  114. char *pchSptPntDir;
  116. Int *rgiTemporalScalabilityType;
  117. Bool *rgbSpatialScalability;
  118. Bool *rgbScalability;
  119. Int *rgiEnhancementType;
  120. AlphaUsage *rgfAlphaUsage;
  121. Bool *rgbShapeOnly;
  122. Int *rgiBinaryAlphaTH;
  123. Int *rgbNoCrChange;
  124. Int *rgiBinaryAlphaRR;
  125. Bool *rgbRoundingControlDisable;
  126. Int *rgiInitialRoundingType;
  127. Int *rgiNumPbetweenIVOP;
  128. Int *rgiNumBbetweenPVOP;
  129. Int *rgiGOVperiod;
  130. Bool *rgbDeblockFilterDisable;
  131. Int *rgiTSRate;
  132. Int *rgiEnhcTSRate;
  133. ChromType *rgfChrType;
  134. Bool *rgbAllowSkippedPMBs;
  135. SptMode *rgSpriteMode;
  136. Bool *rgbDumpMB;
  137. Bool *rgbTrace;
  138. UInt *rguiSpriteUsage; 
  139. UInt *rguiWarpingAccuracy; 
  140. Int *rgiNumPnts;
  142. UInt *rguiRateControl [2];
  143. UInt *rguiBitsBudget [2];
  144. Bool *rgbAdvPredDisable [2];
  145. Bool *rgbErrorResilientDisable [2];
  146. Bool *rgbDataPartitioning [2];
  147. Bool *rgbReversibleVlc [2];
  148. Int *rgiVPBitTh [2];
  149. Bool *rgbInterlacedCoding [2];
  150. Quantizer* rgfQuant [2];
  151. Bool *rgbLoadIntraMatrix [2];
  152. Int **rgppiIntraQuantizerMatrix [2];
  153. Bool *rgbLoadInterMatrix [2];
  154. Int **rgppiInterQuantizerMatrix [2];
  155. Bool *rgiIntraDCSwitchingThr [2];
  156. Int *rgiIStep [2];
  157. Int *rgiPStep [2];
  158. Int *rgiStepBCode [2];
  159. Bool *rgbLoadIntraMatrixAlpha [2];
  160. Int **rgppiIntraQuantizerMatrixAlpha [2];
  161. Bool *rgbLoadInterMatrixAlpha [2];
  162. Int **rgppiInterQuantizerMatrixAlpha [2];
  163. Int *rgiIStepAlpha [2];
  164. Int *rgiPStepAlpha [2];
  165. Int *rgiBStepAlpha [2];
  166. Bool *rgbNoGrayQuantUpdate [2];
  167. UInt *rguiSearchRange [2];
  168. Bool *rgbOriginalME [2];
  169. Bool *rgbComplexityEstimationDisable [2];
  170. Bool *rgbOpaque [2];
  171. Bool *rgbTransparent [2];
  172. Bool *rgbIntraCAE [2];
  173. Bool *rgbInterCAE [2];
  174. Bool *rgbNoUpdate [2];
  175. Bool *rgbUpsampling [2];
  176. Bool *rgbIntraBlocks [2];
  177. Bool *rgbInterBlocks [2];
  178. Bool *rgbInter4vBlocks [2];
  179. Bool *rgbNotCodedBlocks [2];
  180. Bool *rgbDCTCoefs [2];
  181. Bool *rgbDCTLines [2];
  182. Bool *rgbVLCSymbols [2];
  183. Bool *rgbVLCBits [2];
  184. Bool *rgbAPM [2];
  185. Bool *rgbNPM [2];
  186. Bool *rgbInterpolateMCQ [2];
  187. Bool *rgbForwBackMCQ [2];
  188. Bool *rgbHalfpel2 [2];
  189. Bool *rgbHalfpel4 [2];
  190. UInt *rguiVolControlParameters[2];
  191. UInt *rguiChromaFormat[2];
  192. UInt *rguiLowDelay[2];
  193. UInt *rguiVBVParams[2];
  194. UInt *rguiBitRate[2];
  195. UInt *rguiVbvBufferSize[2];
  196. UInt *rguiVbvBufferOccupany[2];
  197. Double *rgdFrameFrequency[2];
  198. Bool *rgbTopFieldFirst [2];
  199. Bool *rgbAlternateScan [2];
  200. Int *rgiDirectModeRadius [2];
  201. Int *rgiMVFileUsage[2];
  202. char **pchMVFileName[2];
  204. UInt iObj;
  206. // verify version number
  207. nextValidLine (pfPara, pnLine);
  208. if ( fscanf (pfPara, "%u", &iVersion) != 1 ) {
  209. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  210. fatal_error("Conversion aborted");
  211. }
  213. if (iVersion != 813 && iVersion != 812 && iVersion != 814 && iVersion != 815) {
  214. // version 812 does not have rounding control flags
  215. // version 813 does not have VOL control parameters
  216. // version 814 does not have skipped mb enable
  217. fprintf(stderr, "unknown parameter file versionn");
  218. fatal_error("Conversion aborted");
  219. }
  221. /*************/
  222. fprintf(pfOut,"!!!MS!!!nn// This is the new parameter file format.  The parameters in this file can ben// specified in any order.n");
  223. fprintf(pfOut,"nVersion = 901nn");
  224. /*************/
  226. ///// WAVELET VTC: begin ///////////////////////////////
  227. // sarnoff: wavelet visual texture coding 
  228. nextValidLine (pfPara, pnLine);
  229. if ( fscanf (pfPara, "%d", &iVTCFlag) != 1) {
  230. fprintf(stderr, "wrong parameter VTC flag on line %dn", *pnLine);
  231. fatal_error("Conversion aborted");
  232. }
  233. fatal_error("iVTCFlag must be 0 or 1", iVTCFlag==0 || iVTCFlag==1);
  235. // read VTC control file
  237. char VTCCtlFile[80];
  238. nextValidLine (pfPara, pnLine);
  239. if ( fscanf (pfPara, "%s", VTCCtlFile) != 1) {
  240. fprintf(stderr, "wrong parameter VTC flag on line %dn", *pnLine);
  241. fatal_error("Conversion aborted");
  242. }
  244. /*************/
  245. fprintf(pfOut, "VTC.Enable = %dnVTC.Filename = "%s"n", iVTCFlag, VTCCtlFile);
  246. /*************/
  248. if (iVTCFlag==1) {
  249. fclose(pfPara);
  250. if(argc==3)
  251. fclose(pfOut);
  253. return 0;
  254. }
  256. ///// WAVELET VTC: end ///////////////////////////////
  260. // frame size code
  262. nextValidLine (pfPara, pnLine);
  263. if (fscanf (pfPara, "%u", &uiFrmWidth) != 1) {
  264. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  265. fatal_error("Conversion aborted");
  266. }
  267. nextValidLine (pfPara, pnLine);
  268. if (fscanf (pfPara, "%u", &uiFrmHeight) != 1) {
  269. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  270. fatal_error("Conversion aborted");
  271. }
  273. // first and last frame number
  274. nextValidLine (pfPara, pnLine);
  275. if ( fscanf (pfPara, "%u", &firstFrm) != 1) {
  276. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  277. fatal_error("Conversion aborted");
  278. }
  279. nextValidLine (pfPara, pnLine);
  280. if ( fscanf (pfPara, "%u", &lastFrm) != 1) {
  281. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  282. fatal_error("Conversion aborted");
  283. }
  284. my_assert (lastFrm >= firstFrm);
  286. /*************/
  287. fprintf(pfOut, "nSource.Width = %dnSource.Height = %dnSource.FirstFrame = %dnSource.LastFrame = %dn",
  288. uiFrmWidth, uiFrmHeight, firstFrm, lastFrm);
  289. /*************/
  291. // NBIT: not 8-bit flag
  292. nextValidLine (pfPara, pnLine);
  293. if ( fscanf (pfPara, "%d", &bNot8Bit) != 1) {
  294. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  295. fatal_error("Conversion aborted");
  296. }
  297. my_assert (bNot8Bit==0 || bNot8Bit==1);
  299. // NBIT: quant precision
  300. nextValidLine (pfPara, pnLine);
  301. if ( fscanf (pfPara, "%d", &uiQuantPrecision) != 1) {
  302. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  303. fatal_error("Conversion aborted");
  304. }
  305. if (bNot8Bit==0) {
  306. uiQuantPrecision = 5;
  307. }
  309. // NBIT: number of bits per pixel
  310. nextValidLine (pfPara, pnLine);
  311. if ( fscanf (pfPara, "%d", &nBits) != 1) {
  312. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  313. fatal_error("Conversion aborted");
  314. }
  315. my_assert (nBits>=4 && nBits<=12);
  316. if (bNot8Bit==0) {
  317. nBits = 8;
  318. }
  320. /*************/
  321. fprintf(pfOut, "Source.BitsPerPel = %dnNot8Bit.QuantPrecision = %dnNot8Bit.Enable = %dn",
  322. nBits, uiQuantPrecision, bNot8Bit);
  323. /*************/
  325. // object indexes
  326. nextValidLine (pfPara, pnLine);
  327. if ( fscanf (pfPara, "%u", &firstVO) != 1) {
  328. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  329. fatal_error("Conversion aborted");
  330. }
  331. nextValidLine (pfPara, pnLine);
  332. if ( fscanf (pfPara, "%u", &lastVO) != 1) {
  333. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  334. fatal_error("Conversion aborted");
  335. }
  336. my_assert (lastVO >= firstVO);
  337. nVO = lastVO - firstVO + 1;
  339. /*************/
  340. fprintf(pfOut, "Source.ObjectIndex.First = %dnSource.ObjectIndex.Last = %dn",
  341. firstVO, lastVO);
  342. /*************/
  344. // allocate per-vo parameters
  345. rgiTemporalScalabilityType = new Int [nVO];
  346. rgbSpatialScalability = new Bool [nVO];
  347. rgbScalability = new Bool [nVO];
  348. rgiEnhancementType = new Int [nVO];
  349. rgfAlphaUsage = new AlphaUsage [nVO];
  350. rgbShapeOnly = new Bool [nVO];
  351. rgiBinaryAlphaTH = new Int [nVO];
  352. rgbNoCrChange = new Bool [nVO];
  353. rgiBinaryAlphaRR = new Int [nVO];
  354. rgbRoundingControlDisable = new Bool [nVO];
  355. rgiInitialRoundingType = new Int [nVO];
  356. rgiNumPbetweenIVOP = new Int [nVO];
  357. rgiNumBbetweenPVOP = new Int [nVO];
  358. rgiGOVperiod = new Int [nVO];
  359. rgbDeblockFilterDisable = new Bool [nVO];
  360. rgiTSRate = new Int [nVO];
  361. rgiEnhcTSRate = new Int [nVO];
  362. rgfChrType = new ChromType [nVO];
  363. rgbAllowSkippedPMBs = new Bool [nVO];
  364. rgSpriteMode = new SptMode [nVO];
  365. rgbDumpMB = new Bool [nVO];
  366. rgbTrace = new Bool [nVO];
  367. rguiSpriteUsage = new UInt [nVO]; 
  368. rguiWarpingAccuracy = new UInt [nVO]; 
  369. rgiNumPnts = new Int [nVO]; 
  372. Int iL;
  373. for(iL = BASE_LAYER; iL<=ENHN_LAYER; iL++)
  374. {
  375. // allocate per-layer parameters
  376. rguiRateControl [iL] = new UInt [nVO];
  377. rguiBitsBudget [iL] = new UInt [nVO];
  378. rgbAdvPredDisable [iL] = new Bool [nVO];
  379. rgbErrorResilientDisable [iL] = new Bool [nVO];
  380. rgbDataPartitioning [iL] = new Bool [nVO];
  381. rgbReversibleVlc [iL] = new Bool [nVO];
  382. rgiVPBitTh [iL] = new Int [nVO];
  383. rgbInterlacedCoding [iL] = new Bool [nVO];
  384. rgfQuant [iL] = new Quantizer [nVO]; 
  385. rgbLoadIntraMatrix [iL] = new Bool [nVO];
  386. rgppiIntraQuantizerMatrix [iL] = new Int * [nVO];
  387. rgbLoadInterMatrix [iL] = new Bool [nVO];
  388. rgppiInterQuantizerMatrix [iL] = new Int * [nVO];
  389. rgiIntraDCSwitchingThr [iL] = new Int [nVO]; 
  390. rgiIStep [iL] = new Int [nVO]; 
  391. rgiPStep [iL] = new Int [nVO]; 
  392. rgiStepBCode [iL] = new Int [nVO]; 
  393. rgbLoadIntraMatrixAlpha [iL] = new Bool [nVO]; 
  394. rgppiIntraQuantizerMatrixAlpha [iL] = new Int * [nVO];
  395. rgbLoadInterMatrixAlpha [iL] = new Bool [nVO]; 
  396. rgppiInterQuantizerMatrixAlpha [iL] = new Int * [nVO];
  397. rgiIStepAlpha [iL] = new Int [nVO]; 
  398. rgiPStepAlpha [iL] = new Int [nVO]; 
  399. rgiBStepAlpha [iL] = new Int [nVO]; 
  400. rgbNoGrayQuantUpdate [iL] = new Bool [nVO];
  401. rguiSearchRange [iL] = new UInt [nVO];
  402. rgbOriginalME [iL] = new Bool [nVO];
  403. rgbComplexityEstimationDisable [iL] = new Bool [nVO];
  404. rgbOpaque [iL] = new Bool [nVO];
  405. rgbTransparent [iL] = new Bool [nVO];
  406. rgbIntraCAE [iL] = new Bool [nVO];
  407. rgbInterCAE [iL] = new Bool [nVO];
  408. rgbNoUpdate [iL] = new Bool [nVO];
  409. rgbUpsampling [iL] = new Bool [nVO];
  410. rgbIntraBlocks [iL] = new Bool [nVO];
  411. rgbInterBlocks [iL] = new Bool [nVO];
  412. rgbInter4vBlocks [iL] = new Bool [nVO];
  413. rgbNotCodedBlocks [iL] = new Bool [nVO];
  414. rgbDCTCoefs [iL] = new Bool [nVO];
  415. rgbDCTLines [iL] = new Bool [nVO];
  416. rgbVLCSymbols [iL] = new Bool [nVO];
  417. rgbVLCBits [iL] = new Bool [nVO];
  418. rgbAPM [iL] = new Bool [nVO];
  419. rgbNPM [iL] = new Bool [nVO];
  420. rgbInterpolateMCQ [iL] = new Bool [nVO];
  421. rgbForwBackMCQ [iL] = new Bool [nVO];
  422. rgbHalfpel2 [iL] = new Bool [nVO];
  423. rgbHalfpel4 [iL] = new Bool [nVO];
  424. rguiVolControlParameters [iL] = new UInt [nVO];
  425. rguiChromaFormat [iL] = new UInt [nVO];
  426. rguiLowDelay [iL] = new UInt [nVO];
  427. rguiVBVParams [iL] = new UInt [nVO];
  428. rguiBitRate [iL] = new UInt [nVO];
  429. rguiVbvBufferSize [iL] = new UInt [nVO];
  430. rguiVbvBufferOccupany [iL] = new UInt [nVO];
  431. rgdFrameFrequency [iL] = new Double [nVO];
  432. rgbTopFieldFirst [iL] = new Bool [nVO]; 
  433. rgbAlternateScan [iL] = new Bool [nVO]; 
  434. rgiDirectModeRadius [iL] = new Bool [nVO]; 
  435. rgiMVFileUsage[iL] = new Int [nVO];
  436. pchMVFileName[iL] = new char * [nVO];
  437. }
  439. for (iObj = 0; iObj < nVO; iObj++)
  440. {
  441. // per object alloc
  442. rgppiIntraQuantizerMatrix [BASE_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  443. rgppiIntraQuantizerMatrix [ENHN_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  444. rgppiInterQuantizerMatrix [BASE_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  445. rgppiInterQuantizerMatrix [ENHN_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  446. rgppiIntraQuantizerMatrixAlpha [BASE_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  447. rgppiIntraQuantizerMatrixAlpha [ENHN_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  448. rgppiInterQuantizerMatrixAlpha [BASE_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  449. rgppiInterQuantizerMatrixAlpha [ENHN_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  450. }
  453. //scalability indicators: 1 = temporal, 2 = spatial scalability
  456. nextValidLine (pfPara, pnLine);
  457. bAnyScalability = FALSE;
  458. for (iObj = 0; iObj < nVO; iObj++) {
  459. if (fscanf (pfPara, "%d", &rgbScalability [iObj]) != 1) {
  460. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  461. fatal_error("Conversion aborted");
  462. }
  463. if (rgbScalability[iObj] == TEMPORAL_SCALABILITY || 
  464. rgbScalability[iObj] == SPATIAL_SCALABILITY)
  465. bAnyScalability = TRUE;
  466. else
  467. my_assert (rgbScalability[iObj] == NO_SCALABILITY);
  468. if(rgbScalability[iObj] == SPATIAL_SCALABILITY || rgbScalability[iObj] == TEMPORAL_SCALABILITY) // modifiedy by Sharp(98/2/12)
  469. rgbSpatialScalability[iObj] = TRUE; 
  470. else 
  471. rgbSpatialScalability[iObj] = FALSE;
  473. /*************/
  474. fprintf(pfOut, "Scalability [%d] = "%s"n", iObj,
  475. rgbScalability[iObj] == TEMPORAL_SCALABILITY ? "Temporal" : (rgbScalability[iObj] == SPATIAL_SCALABILITY ? "Spatial" : "None"));
  476. /*************/
  477. }
  479. //coded added by Sony, only deals with ONE VO.
  480. //Type option of Spatial Scalable Coding
  481. //This parameter is used for dicision VOP prediction types of Enhancement layer in Spatial Scalable Coding
  482. //If this option is set to 0, Enhancement layer is coded as "PPPPPP......",
  483. //else if set to 1 ,It's coded as "PBBBB......."
  484. nextValidLine(pfPara,pnLine);
  485. my_assert (nVO == 1);
  486. fscanf(pfPara,"%d",&iSpatialOption);
  487. if(rgbScalability[0] == SPATIAL_SCALABILITY)
  488. if (iSpatialOption == 1)
  489. fprintf(stdout,"Enhancement layer is coded as "PPPPP....."n");
  490. else if (iSpatialOption == 0)
  491. fprintf(stdout,"Enhancement layer is coded as "PBBBB....."n");
  492. else {
  493. fprintf(stderr,"The parameter "SpatialOption" is not set correctlyn");
  494. fatal_error("Conversion aborted");
  495. }
  497. /*************/
  498. fprintf(pfOut, "Scalability.Spatial.PredictionType [0] = "%s"n", iSpatialOption==0 ? "PBB" : "PPP");
  499. /*************/
  501. //Load enhancement layer (Spatial Scalable) size
  502. nextValidLine(pfPara,pnLine);
  503. fscanf(pfPara,"%d",&uiFrmWidth_SS);
  504. fscanf(pfPara,"%d",&uiFrmHeight_SS);
  506. //load upsampling factor 
  507. nextValidLine(pfPara,pnLine);
  508. fscanf(pfPara,"%d",&uiHor_sampling_n);
  509. fscanf(pfPara,"%d",&uiHor_sampling_m);
  511. nextValidLine(pfPara,pnLine);
  512. fscanf(pfPara,"%d",&uiVer_sampling_n);
  513. fscanf(pfPara,"%d",&uiVer_sampling_m);
  515. /*************/
  516. fprintf(pfOut, "Scalability.Spatial.Width [0] = %dn", uiFrmWidth_SS);
  517. fprintf(pfOut, "Scalability.Spatial.Height [0] = %dn", uiFrmHeight_SS);
  518. fprintf(pfOut, "Scalability.Spatial.HorizFactor.N [0] = %dn", uiHor_sampling_n);
  519. fprintf(pfOut, "Scalability.Spatial.HorizFactor.M [0] = %dn", uiHor_sampling_m);
  520. fprintf(pfOut, "Scalability.Spatial.VertFactor.N [0] = %dn", uiVer_sampling_n);
  521. fprintf(pfOut, "Scalability.Spatial.VertFactor.M [0] = %dn", uiVer_sampling_m);
  522. /*************/
  524. // form of temporal scalability indicators
  525. // case 0  Enhn    P   P   ....
  526. //         Base  I   P   P ....
  527. // case 1  Enhn    B B   B B   ....
  528. //         Base  I     P     P ....
  529. // case 2  Enhn    P   B   B   ....
  530. //         Base  I   B   P   B ....
  531. nextValidLine (pfPara, pnLine);
  532. for (iObj = 0; iObj < nVO; iObj++) {
  533. if (fscanf (pfPara, "%d", &rgiTemporalScalabilityType [iObj]) != 1) {
  534. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  535. fatal_error("Conversion aborted");
  536. }
  537. my_assert (rgiTemporalScalabilityType [iObj] == 0 || 
  538. rgiTemporalScalabilityType [iObj] == 1 || 
  539. rgiTemporalScalabilityType [iObj] == 2 ||
  540. rgiTemporalScalabilityType [iObj] == 3 ||
  541. rgiTemporalScalabilityType [iObj] == 4);
  542. /*************/
  543. fprintf(pfOut, "Scalability.Temporal.PredictionType [%d] = %dn", iObj, rgiTemporalScalabilityType [iObj]);
  544. /*************/
  545. }
  547. // enhancement_type for scalability
  548. nextValidLine (pfPara, pnLine);
  549. for (iObj = 0; iObj < nVO; iObj++) {
  550. if (fscanf (pfPara, "%d", &rgiEnhancementType [iObj]) != 1) {
  551. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  552. fatal_error("Conversion aborted");
  553. }
  554. my_assert (rgiEnhancementType [iObj] == 0 || //  entire region of the base layer is enhanced
  555. // begin: modified by Sharp (98/3/24)
  556. rgiEnhancementType [iObj] == 1 ||  // partial region of the base layer is enhanced (with background composition)
  557. rgiEnhancementType [iObj] == 2);  // partial region of the base layer is enhanced (without background composition)
  558. // end: modified by Sharp (98/3/24)
  559. /*************/
  560. fprintf(pfOut, "Scalability.Temporal.EnhancementType [%d] = "%s"n", iObj,
  561. rgiEnhancementType [iObj] == 0 ? "Full" : (rgiEnhancementType [iObj] == 1 ? "PartC" : "PartNC"));
  562. /*************/
  563. }
  565. // rate control flag
  566. nextValidLine (pfPara, pnLine);
  567. for (iObj = 0; iObj < nVO; iObj++) {
  568. if (fscanf (pfPara, "%u", &rguiRateControl [BASE_LAYER] [iObj] ) != 1) {
  569. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  570. fatal_error("Conversion aborted");
  571. }
  572. my_assert (rguiRateControl [BASE_LAYER] [iObj]  == RC_MPEG4 || 
  573. rguiRateControl [BASE_LAYER] [iObj]  == RC_TM5 ||
  574. rguiRateControl [BASE_LAYER] [iObj]  == 0);
  576. /*************/
  577. fprintf(pfOut, "RateControl.Type [%d] = "%s"n", iObj,
  578. rguiRateControl [BASE_LAYER] [iObj] == 0 ? "None" : (rguiRateControl [BASE_LAYER] [iObj] == RC_MPEG4 ? "MP4" : "TM5"));
  579. /*************/
  580. }
  581. if (bAnyScalability) {
  582. for (iObj = 0; iObj < nVO; iObj++) {
  583. if (fscanf (pfPara, "%u", &rguiRateControl [ENHN_LAYER] [iObj]) != 1) {
  584. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  585. fatal_error("Conversion aborted");
  586. }
  587. my_assert (rguiRateControl [ENHN_LAYER] [iObj]  == 0 || 
  588. rguiRateControl [ENHN_LAYER] [iObj]  == RC_MPEG4 ||
  589. rguiRateControl [ENHN_LAYER] [iObj]  == RC_TM5);
  590. /*************/
  591. fprintf(pfOut, "RateControl.Type [%d] = "%s"n", iObj + nVO,
  592. rguiRateControl [ENHN_LAYER] [iObj] == 0 ? "None" : (rguiRateControl [ENHN_LAYER] [iObj] == RC_MPEG4 ? "MP4" : "TM5"));
  593. /*************/
  594. }
  595. }
  597. // bit budget for each object.
  598. nextValidLine (pfPara, pnLine);
  599. for (iObj = 0; iObj < nVO; iObj++) {
  600. if (fscanf (pfPara, "%d", &rguiBitsBudget [BASE_LAYER] [iObj]) != 1) {
  601. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  602. fatal_error("Conversion aborted");
  603. }
  604. /*************/
  605. fprintf(pfOut, "RateControl.BitsPerVOP [%d] = %dn", iObj, rguiBitsBudget [BASE_LAYER] [iObj]);
  606. /*************/
  607. }
  608. if (bAnyScalability) {
  609. for (iObj = 0; iObj < nVO; iObj++) {
  610. if (fscanf (pfPara, "%d", &rguiBitsBudget [ENHN_LAYER] [iObj]) != 1) {
  611. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  612. fatal_error("Conversion aborted");
  613. }
  614. my_assert (rguiBitsBudget [ENHN_LAYER] [iObj]  > 0);
  615. /*************/
  616. fprintf(pfOut, "RateControl.BitsPerVOP [%d] = %dn", iObj + nVO, rguiBitsBudget [ENHN_LAYER] [iObj]);
  617. /*************/
  618. }
  619. }
  622. // alpha usage for each object.  0: rectangle, 1: binary, 2: 8-bit, 3: shape only
  623. nextValidLine (pfPara, pnLine);
  624. for (iObj = 0; iObj < nVO; iObj++) {
  625. UInt uiAlpha;
  626. if (fscanf (pfPara, "%d", &uiAlpha) != 1) {
  627. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  628. fatal_error("Conversion aborted");
  629. }
  630. else {
  631. my_assert (uiAlpha == 0 || uiAlpha == 1 || uiAlpha == 2 || uiAlpha == 3);
  632. if(uiAlpha<3)
  633. {
  634. rgfAlphaUsage [iObj] = (AlphaUsage) uiAlpha;
  635. rgbShapeOnly [iObj] = FALSE;
  636. }
  637. else
  638. {
  639. rgfAlphaUsage [iObj] = ONE_BIT;
  640. rgbShapeOnly [iObj] = TRUE;
  641. }
  642. }
  643. /*************/
  644. fprintf(pfOut, "Alpha.Type [%d] = "%s"n", iObj,
  645. uiAlpha==0 ? "None" : (uiAlpha==1 ? "Binary" : (uiAlpha==2 ? "Gray" : "ShapeOnly")));
  646. /*************/
  647. }
  649. // binary shape rounding para
  650. nextValidLine (pfPara, pnLine);
  651. for (iObj = 0; iObj < nVO; iObj++) {
  652. if (fscanf (pfPara, "%d", &rgiBinaryAlphaTH [iObj]) != 1) {
  653. fprintf (stderr, "wrong parameter file format on line %dn", *pnLine);
  654. fatal_error("Conversion aborted");
  655. }
  656. my_assert (rgiBinaryAlphaTH [iObj] >= 0);
  657. /*************/
  658. fprintf(pfOut, "Alpha.Binary.RoundingThreshold [%d] = %dn", iObj, rgiBinaryAlphaTH [iObj]);
  659. /*************/
  660. }
  662. // binary shape size conversion flag
  663. nextValidLine (pfPara, pnLine);
  664. for (iObj = 0; iObj < nVO; iObj++) {
  665. if (fscanf (pfPara, "%d", &rgbNoCrChange [iObj]) != 1) {
  666. fprintf (stderr, "wrong parameter file format on line %dn", *pnLine);
  667. fatal_error("Conversion aborted");
  668. }
  669. my_assert (rgbNoCrChange [iObj] == TRUE || rgbNoCrChange [iObj] == FALSE); //boolean value
  670. if (rgiBinaryAlphaTH [iObj] == 0)
  671. my_assert (rgbNoCrChange [iObj] == TRUE); //MB-level size conversion of shape is off in lossless moden");
  672. /*************/
  673. fprintf(pfOut, "Alpha.Binary.SizeConversion.Enable [%d] = %dn", iObj, !rgbNoCrChange [iObj]);
  674. /*************/
  675. }
  677. // Added for error resilient mode by Toshiba(1997-11-14)
  678. nextValidLine (pfPara, pnLine);
  679. for (iObj = 0; iObj < nVO; iObj++) {
  680. if (fscanf (pfPara, "%d", &rgiBinaryAlphaRR [iObj]) != 1) {
  681. fprintf (stderr, "wrong parameter file format on line %dn", *pnLine);
  682. fatal_error("Conversion aborted");
  683. }
  684. my_assert (rgiBinaryAlphaRR [iObj] >= 0);
  685. /*************/
  686. fprintf(pfOut, "ErrorResil.AlphaRefreshRate [%d] = %dn", iObj, rgiBinaryAlphaRR [iObj]);
  687. /*************/
  688. }
  689. // End Toshiba(1997-11-14)
  691. // rounding control disable
  692. if(iVersion > 812)
  693. nextValidLine (pfPara, pnLine);
  694. for (iObj = 0; iObj < nVO; iObj++) {
  695. if(iVersion > 812)
  696. {
  697. if (fscanf (pfPara, "%d", &rgbRoundingControlDisable [iObj]) != 1) {
  698. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  699. fatal_error("Conversion aborted");
  700. }
  701. }
  702. else
  703. rgbRoundingControlDisable [iObj] = 0;
  704. my_assert (rgbRoundingControlDisable [iObj]  == 0 || rgbRoundingControlDisable [iObj] == 1);
  705. /*************/
  706. fprintf(pfOut, "Motion.RoundingControl.Enable [%d] = %dn", iObj, !rgbRoundingControlDisable [iObj]);
  707. /*************/
  708. }
  709. if(iVersion > 812)
  710. nextValidLine (pfPara, pnLine);
  711. for (iObj = 0; iObj < nVO; iObj++) {
  712. if(iVersion > 812)
  713. {
  714. if (fscanf (pfPara, "%d", &rgiInitialRoundingType [iObj]) != 1) {
  715. fprintf (stderr, "wrong parameter file format on line %dn", *pnLine);
  716. fatal_error("Conversion aborted");
  717. }
  718. }
  719. else
  720. rgiInitialRoundingType [iObj] = 0;
  721. my_assert (rgiInitialRoundingType [iObj] == 0 || rgiInitialRoundingType [iObj] == 1);
  722. /*************/
  723. fprintf(pfOut, "Motion.RoundingControl.StartValue [%d] = %dn", iObj, rgiInitialRoundingType [iObj]);
  724. /*************/
  725. }
  727. // error resilient coding disable
  728. nextValidLine (pfPara, pnLine);
  729. Int iErrorResilientFlags;
  730. for (iObj = 0; iObj < nVO; iObj++) {
  731. if (fscanf (pfPara, "%d", &iErrorResilientFlags) != 1) {
  732. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  733. fatal_error("Conversion aborted");
  734. }
  735. rgbErrorResilientDisable [BASE_LAYER] [iObj] = iErrorResilientFlags & 0x1;
  736. // Modified for error resilient mode by Toshiba(1998-1-16)
  737. rgbDataPartitioning [BASE_LAYER] [iObj]  = (iErrorResilientFlags & 0x2) ? TRUE : FALSE;
  738. rgbReversibleVlc [BASE_LAYER] [iObj]  = (iErrorResilientFlags & 0x4) ? TRUE : FALSE;
  739. // End Toshiba(1998-1-16)
  740. if( rgbErrorResilientDisable [BASE_LAYER] [iObj])
  741. rgiBinaryAlphaRR [iObj] = -1;
  743. /*************/
  744. fprintf(pfOut, "ErrorResil.RVLC.Enable [%d] = %dn", iObj, rgbReversibleVlc [BASE_LAYER] [iObj]);
  745. fprintf(pfOut, "ErrorResil.DataPartition.Enable [%d] = %dn", iObj, rgbDataPartitioning [BASE_LAYER] [iObj]);
  746. fprintf(pfOut, "ErrorResil.VideoPacket.Enable [%d] = %dn", iObj, !rgbErrorResilientDisable [BASE_LAYER] [iObj]);
  747. /*************/
  748. }
  749. if (bAnyScalability) {
  750. for (iObj = 0; iObj < nVO; iObj++) {
  751. if (fscanf (pfPara, "%d", &rgbErrorResilientDisable [ENHN_LAYER] [iObj]) != 1) {
  752. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  753. fatal_error("Conversion aborted");
  754. }
  755. my_assert (rgbErrorResilientDisable [ENHN_LAYER] [iObj] == TRUE); //error resilient coding not supported as for now
  756. rgbErrorResilientDisable [ENHN_LAYER] [iObj] = TRUE;
  757. rgbDataPartitioning [ENHN_LAYER] [iObj] = FALSE;
  758. rgbReversibleVlc [ENHN_LAYER] [iObj] = FALSE;
  759. /*************/
  760. fprintf(pfOut, "ErrorResil.RVLC.Enable [%d] = %dn", iObj + nVO, rgbReversibleVlc [ENHN_LAYER] [iObj]);
  761. fprintf(pfOut, "ErrorResil.DataPartition.Enable [%d] = %dn", iObj + nVO, rgbDataPartitioning [ENHN_LAYER] [iObj]);
  762. fprintf(pfOut, "ErrorResil.VideoPacket.Enable [%d] = %dn", iObj + nVO, !rgbErrorResilientDisable [ENHN_LAYER] [iObj]);
  763. /*************/
  764. }
  765. }
  767. // Bit threshold for video packet spacing control
  768. nextValidLine (pfPara, pnLine);
  769. for (iObj = 0; iObj < nVO; iObj++) {
  770. if (fscanf (pfPara, "%d", &rgiVPBitTh [BASE_LAYER] [iObj]) != 1) {
  771. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  772. fatal_error("Conversion aborted");
  773. }
  774. if (rgbErrorResilientDisable [BASE_LAYER] [iObj])
  775. rgiVPBitTh [BASE_LAYER] [iObj] = -1; // set VPBitTh to negative value
  776. /*************/
  777. fprintf(pfOut, "ErrorResil.VideoPacket.Length [%d] = %dn", iObj, rgiVPBitTh [BASE_LAYER] [iObj]);
  778. /*************/
  779. }
  780. if (bAnyScalability) {
  781. for (iObj = 0; iObj < nVO; iObj++) {
  782. if (fscanf (pfPara, "%d", &rgiVPBitTh [ENHN_LAYER] [iObj]) != 1) {
  783. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  784. fatal_error("Conversion aborted");
  785. }
  786. rgiVPBitTh [ENHN_LAYER] [iObj] = -1;
  787. /*************/
  788. fprintf(pfOut, "ErrorResil.VideoPacket.Length [%d] = %dn", iObj + nVO, rgiVPBitTh [ENHN_LAYER] [iObj]);
  789. /*************/
  790. }
  791. }
  793. // Interlaced coding
  794. nextValidLine (pfPara, pnLine);
  795. for (iObj = 0; iObj < nVO; iObj++) {
  796. if (fscanf (pfPara, "%d", &rgbInterlacedCoding [BASE_LAYER] [iObj]) != 1) {
  797. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  798. fatal_error("Conversion aborted");
  799. }
  800. my_assert (rgbInterlacedCoding [BASE_LAYER] [iObj] == 0 || rgbInterlacedCoding [BASE_LAYER] [iObj] == 1);
  801. /*************/
  802. fprintf(pfOut, "Motion.Interlaced.Enable [%d] = %dn", iObj, rgbInterlacedCoding [BASE_LAYER] [iObj]);
  803. /*************/
  804. }
  805. if (bAnyScalability) {
  806. for (iObj = 0; iObj < nVO; iObj++) {
  807. if (fscanf (pfPara, "%d", &rgbInterlacedCoding [ENHN_LAYER] [iObj]) != 1) {
  808. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  809. fatal_error("Conversion aborted");
  810. }
  811. my_assert (rgbInterlacedCoding [ENHN_LAYER] [iObj] == 0 || rgbInterlacedCoding [ENHN_LAYER] [iObj] == 1);
  812. /*************/
  813. fprintf(pfOut, "Motion.Interlaced.Enable [%d] = %dn", iObj + nVO, rgbInterlacedCoding [ENHN_LAYER] [iObj]);
  814. /*************/
  815. }
  816. }
  818. // quantizer selection: 0 -- H.263, 1 -- MPEG
  819. nextValidLine (pfPara, pnLine);
  820. for (iObj = 0; iObj < nVO; iObj++) {
  821.   int read;
  822. if (fscanf (pfPara, "%d", &read) != 1) {
  823. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  824. fatal_error("Conversion aborted");
  825. }
  826. rgfQuant [BASE_LAYER] [iObj] = (Quantizer)read;
  827. my_assert (rgfQuant [BASE_LAYER] [iObj] ==0 || rgfQuant [BASE_LAYER] [iObj] == 1);
  828. /*************/
  829. fprintf(pfOut, "Quant.Type [%d] = "%s"n", iObj, rgfQuant [BASE_LAYER] [iObj]==0 ? "H263" : "MPEG");
  830. /*************/
  831. }
  832. if (bAnyScalability) {
  833. for (iObj = 0; iObj < nVO; iObj++) {
  834.   int read;
  835. if (fscanf (pfPara, "%d", &read) != 1) {
  836. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  837. fatal_error("Conversion aborted");
  838. }
  839. rgfQuant [ENHN_LAYER] [iObj] = (Quantizer)read;
  840. my_assert (rgfQuant [ENHN_LAYER] [iObj] ==0 || rgfQuant [ENHN_LAYER] [iObj] == 1);
  841. /*************/
  842. fprintf(pfOut, "Quant.Type [%d] = "%s"n", iObj + nVO, rgfQuant [ENHN_LAYER] [iObj]==0 ? "H263" : "MPEG");
  843. /*************/
  844. }
  845. }
  847. // load non-default intra Q-Matrix, 0 -- FALSE, 1 -- TRUE
  848. nextValidLine (pfPara, pnLine);
  849. for (iObj = 0; iObj < nVO; iObj++) {
  850. if (fscanf (pfPara, "%d", &rgbLoadIntraMatrix [BASE_LAYER] [iObj]) != 1) {
  851. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  852. fatal_error("Conversion aborted");
  853. }
  854. my_assert (rgbLoadIntraMatrix [BASE_LAYER] [iObj] ==0 || 
  855. rgbLoadIntraMatrix [BASE_LAYER] [iObj] == 1);
  856. /*************/
  857. fprintf(pfOut, "Texture.QuantMatrix.Intra.Enable [%d] = %dn", iObj, rgbLoadIntraMatrix [BASE_LAYER] [iObj]);
  858. /*************/
  859. if (rgbLoadIntraMatrix [BASE_LAYER] [iObj]) {
  860. /*************/
  861. fprintf(pfOut, "Texture.QuantMatrix.Intra [%d] = {", iObj);
  862. /*************/
  863. UInt i = 0;
  864. do {
  865. if(i>0)
  866. /*************/
  867. fprintf(pfOut, ", ");
  868. /*************/
  869. if (fscanf (pfPara, "%d", &rgppiIntraQuantizerMatrix [BASE_LAYER] [iObj] [i]) != 1) {
  870. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  871. fatal_error("Conversion aborted");
  872. }
  873. /*************/
  874. fprintf(pfOut, "%d", rgppiIntraQuantizerMatrix [BASE_LAYER] [iObj] [i]);
  875. /*************/
  876. } while (rgppiIntraQuantizerMatrix [BASE_LAYER] [iObj] [i] != 0 && ++i < BLOCK_SQUARE_SIZE);
  877. /*************/
  878. fprintf(pfOut, "}n");
  879. /*************/
  880. }
  881. }
  882. if (bAnyScalability) {
  883. for (iObj = 0; iObj < nVO; iObj++) {
  884. if (fscanf (pfPara, "%d", &rgbLoadIntraMatrix [ENHN_LAYER] [iObj]) != 1) {
  885. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  886. fatal_error("Conversion aborted");
  887. }
  888. my_assert (rgbLoadIntraMatrix [ENHN_LAYER] [iObj] ==0 || 
  889. rgbLoadIntraMatrix [ENHN_LAYER] [iObj] == 1);
  890. /*************/
  891. fprintf(pfOut, "Texture.QuantMatrix.Intra.Enable [%d] = %dn", iObj + nVO, rgbLoadIntraMatrix [ENHN_LAYER] [iObj]);
  892. /*************/
  893. if (rgbLoadIntraMatrix [ENHN_LAYER] [iObj]) {
  894. /*************/
  895. fprintf(pfOut, "Texture.QuantMatrix.Intra [%d] = {", iObj + nVO);
  896. /*************/
  897. UInt i = 0;
  898. do {
  899. if(i>0)
  900. /*************/
  901. fprintf(pfOut, ", ");
  902. /*************/
  903. if (fscanf (pfPara, "%d", &rgppiIntraQuantizerMatrix [ENHN_LAYER] [iObj] [i]) != 1) {
  904. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  905. fatal_error("Conversion aborted");
  906. }
  907. /*************/
  908. fprintf(pfOut, "%d", rgppiIntraQuantizerMatrix [ENHN_LAYER] [iObj] [i]);
  909. /*************/
  910. } while (rgppiIntraQuantizerMatrix [ENHN_LAYER] [iObj] [i] != 0 && ++i < BLOCK_SQUARE_SIZE);
  911. /*************/
  912. fprintf(pfOut, "}n");
  913. /*************/
  914. }
  915. }
  916. }
  918. // load non-default inter Q-Matrix, 0 -- FALSE, 1 -- TRUE
  919. nextValidLine (pfPara, pnLine);
  920. for (iObj = 0; iObj < nVO; iObj++) {
  921. if (fscanf (pfPara, "%d", &rgbLoadInterMatrix [BASE_LAYER] [iObj]) != 1) {
  922. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  923. fatal_error("Conversion aborted");
  924. }
  925. my_assert (rgbLoadInterMatrix [BASE_LAYER] [iObj] ==0 || 
  926. rgbLoadInterMatrix [BASE_LAYER] [iObj] == 1);
  927. /*************/
  928. fprintf(pfOut, "Texture.QuantMatrix.Inter.Enable [%d] = %dn", iObj, rgbLoadInterMatrix [BASE_LAYER] [iObj]);
  929. /*************/
  930. if (rgbLoadInterMatrix [BASE_LAYER] [iObj]) {
  931. /*************/
  932. fprintf(pfOut, "Texture.QuantMatrix.Inter [%d] = {", iObj);
  933. /*************/
  934. UInt i = 0;
  935. do {
  936. if(i>0)
  937. /*************/
  938. fprintf(pfOut, ", ");
  939. /*************/
  940. if (fscanf (pfPara, "%d", &rgppiInterQuantizerMatrix [BASE_LAYER] [iObj] [i]) != 1) {
  941. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  942. fatal_error("Conversion aborted");
  943. }
  944. /*************/
  945. fprintf(pfOut, "%d", rgppiInterQuantizerMatrix [BASE_LAYER] [iObj] [i]);
  946. /*************/
  947. } while (rgppiInterQuantizerMatrix [BASE_LAYER] [iObj] [i] != 0 && ++i < BLOCK_SQUARE_SIZE);
  948. /*************/
  949. fprintf(pfOut, "}n");
  950. /*************/
  951. }
  952. }
  953. if (bAnyScalability) {
  954. for (iObj = 0; iObj < nVO; iObj++) {
  955. if (fscanf (pfPara, "%d", &rgbLoadInterMatrix [ENHN_LAYER] [iObj]) != 1) {
  956. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  957. fatal_error("Conversion aborted");
  958. }
  959. my_assert (rgbLoadInterMatrix [ENHN_LAYER] [iObj] ==0 || 
  960. rgbLoadInterMatrix [ENHN_LAYER] [iObj] == 1);
  961. /*************/
  962. fprintf(pfOut, "Texture.QuantMatrix.Inter.Enable [%d] = %dn", iObj + nVO, rgbLoadInterMatrix [ENHN_LAYER] [iObj]);
  963. /*************/
  964. if (rgbLoadInterMatrix [ENHN_LAYER] [iObj]) {
  965. /*************/
  966. fprintf(pfOut, "Texture.QuantMatrix.Inter [%d] = {", iObj + nVO);
  967. /*************/
  968. UInt i = 0;
  969. do {
  970. if(i>0)
  971. /*************/
  972. fprintf(pfOut, ", ");
  973. /*************/
  974. if (fscanf (pfPara, "%d", &rgppiInterQuantizerMatrix [ENHN_LAYER] [iObj] [i]) != 1) {
  975. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  976. fatal_error("Conversion aborted");
  977. }
  978. /*************/
  979. fprintf(pfOut, "%d", rgppiInterQuantizerMatrix [ENHN_LAYER] [iObj] [i]);
  980. /*************/
  981. } while (rgppiInterQuantizerMatrix [ENHN_LAYER] [iObj] [i] != 0 && ++i < BLOCK_SQUARE_SIZE);
  982. /*************/
  983. fprintf(pfOut, "}n");
  984. /*************/
  985. }
  986. }
  987. }
  989. // threhold to code Intra-DC as AC
  990. nextValidLine (pfPara, pnLine);
  991. for (iObj = 0; iObj < nVO; iObj++) {
  992. if (fscanf (pfPara, "%d", &(rgiIntraDCSwitchingThr [BASE_LAYER] [iObj])) != 1) {
  993. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  994. fatal_error("Conversion aborted");
  995. }
  996. my_assert (rgiIntraDCSwitchingThr [BASE_LAYER] [iObj] >= 0 && 
  997. rgiIntraDCSwitchingThr [BASE_LAYER] [iObj] <= 7);
  998. /*************/
  999. fprintf(pfOut, "Texture.IntraDCThreshold [%d] = %dn", iObj, rgiIntraDCSwitchingThr [BASE_LAYER] [iObj]);
  1000. /*************/
  1001. }
  1002. if (bAnyScalability) {
  1003. for (iObj = 0; iObj < nVO; iObj++) {
  1004. if (fscanf (pfPara, "%d", &(rgiIntraDCSwitchingThr [ENHN_LAYER] [iObj])) != 1) {
  1005. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1006. fatal_error("Conversion aborted");
  1007. }
  1008. my_assert (rgiIntraDCSwitchingThr [ENHN_LAYER] [iObj] >= 0 && 
  1009. rgiIntraDCSwitchingThr [ENHN_LAYER] [iObj] <= 7);
  1010. /*************/
  1011. fprintf(pfOut, "Texture.IntraDCThreshold [%d] = %dn", iObj + nVO, rgiIntraDCSwitchingThr [ENHN_LAYER] [iObj]);
  1012. /*************/
  1013. }
  1014. }
  1016. // I-VO quantization stepsize
  1017. nextValidLine (pfPara, pnLine);
  1018. for (iObj = 0; iObj < nVO; iObj++) {
  1019. if (fscanf (pfPara, "%d", &(rgiIStep [BASE_LAYER] [iObj])) != 1) {
  1020. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1021. fatal_error("Conversion aborted");
  1022. }
  1023. my_assert (rgiIStep [BASE_LAYER] [iObj] > 0 && rgiIStep [BASE_LAYER] [iObj] < (1<<uiQuantPrecision));
  1024. /*************/
  1025. fprintf(pfOut, "Texture.QuantStep.IVOP [%d] = %dn", iObj, rgiIStep [BASE_LAYER] [iObj]);
  1026. /*************/
  1027. }
  1028. if (bAnyScalability) {
  1029. for (iObj = 0; iObj < nVO; iObj++) {
  1030. if (fscanf (pfPara, "%d", &(rgiIStep [ENHN_LAYER] [iObj])) != 1) {
  1031. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1032. fatal_error("Conversion aborted");
  1033. }
  1034. my_assert (rgiIStep [ENHN_LAYER] [iObj] > 0 && rgiIStep [ENHN_LAYER] [iObj] < (1<<uiQuantPrecision));
  1035. /*************/
  1036. fprintf(pfOut, "Texture.QuantStep.IVOP [%d] = %dn", iObj + nVO, rgiIStep [ENHN_LAYER] [iObj]);
  1037. /*************/
  1038. }
  1039. }
  1041. // P-VO quantization stepsize
  1042. nextValidLine (pfPara, pnLine);
  1043. for (iObj = 0; iObj < nVO; iObj++) {
  1044. if (fscanf (pfPara, "%d", &(rgiPStep [BASE_LAYER] [iObj])) != 1) {
  1045. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1046. fatal_error("Conversion aborted");
  1047. }
  1048. my_assert (rgiPStep [BASE_LAYER] [iObj] > 0 && rgiPStep [BASE_LAYER] [iObj] < (1<<uiQuantPrecision));
  1049. /*************/
  1050. fprintf(pfOut, "Texture.QuantStep.PVOP [%d] = %dn", iObj, rgiPStep [BASE_LAYER] [iObj]);
  1051. /*************/
  1052. }
  1053. if (bAnyScalability) {
  1054. for (iObj = 0; iObj < nVO; iObj++) {
  1055. if (fscanf (pfPara, "%d", &(rgiPStep [ENHN_LAYER] [iObj])) != 1) {
  1056. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1057. fatal_error("Conversion aborted");
  1058. }
  1059. my_assert (rgiPStep [ENHN_LAYER] [iObj] > 0 && rgiPStep [ENHN_LAYER] [iObj] < (1<<uiQuantPrecision));
  1060. /*************/
  1061. fprintf(pfOut, "Texture.QuantStep.PVOP [%d] = %dn", iObj + nVO, rgiPStep [ENHN_LAYER] [iObj]);
  1062. /*************/
  1063. }
  1064. }
  1066. // quantization stepsize for B-VOP
  1067. nextValidLine (pfPara, pnLine);
  1068. for (iObj = 0; iObj < nVO; iObj++) {
  1069. if (fscanf (pfPara, "%d", &(rgiStepBCode [BASE_LAYER] [iObj])) != 1) {
  1070. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1071. fatal_error("Conversion aborted");
  1072. }
  1073. my_assert (rgiStepBCode [BASE_LAYER] [iObj] > 0 && rgiStepBCode [BASE_LAYER] [iObj] < (1<<uiQuantPrecision));
  1074. /*************/
  1075. fprintf(pfOut, "Texture.QuantStep.BVOP [%d] = %dn", iObj, rgiStepBCode [BASE_LAYER] [iObj]);
  1076. /*************/
  1077. }
  1078. if (bAnyScalability) {
  1079. for (iObj = 0; iObj < nVO; iObj++) {
  1080. if (fscanf (pfPara, "%d", &(rgiStepBCode [ENHN_LAYER] [iObj])) != 1) {
  1081. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1082. fatal_error("Conversion aborted");
  1083. }
  1084. my_assert (rgiStepBCode [ENHN_LAYER] [iObj] > 0 && rgiStepBCode [ENHN_LAYER] [iObj] < (1<<uiQuantPrecision));
  1085. /*************/
  1086. fprintf(pfOut, "Texture.QuantStep.BVOP [%d] = %dn", iObj + nVO, rgiStepBCode [ENHN_LAYER] [iObj]);
  1087. /*************/
  1088. }
  1089. }
  1091. // load non-default gray alpha intra Q-Matrix, 0 -- FALSE, 1 -- TRUE
  1092. nextValidLine (pfPara, pnLine);
  1093. for (iObj = 0; iObj < nVO; iObj++) {
  1094. if (fscanf (pfPara, "%d", &rgbLoadIntraMatrixAlpha [BASE_LAYER] [iObj]) != 1) {
  1095. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1096. fatal_error("Conversion aborted");
  1097. }
  1098. my_assert (rgbLoadIntraMatrixAlpha [BASE_LAYER] [iObj] ==0 || 
  1099. rgbLoadIntraMatrixAlpha [BASE_LAYER] [iObj] == 1);
  1100. /*************/
  1101. fprintf(pfOut, "Alpha.QuantMatrix.Intra.Enable [%d] = %dn", iObj, rgbLoadIntraMatrixAlpha [BASE_LAYER] [iObj]);
  1102. /*************/
  1103. if (rgbLoadIntraMatrixAlpha [BASE_LAYER] [iObj]) {
  1104. /*************/
  1105. fprintf(pfOut, "Alpha.QuantMatrix.Intra [%d] = {", iObj);
  1106. /*************/
  1107. for (UInt i = 0; i < BLOCK_SQUARE_SIZE; i++) {
  1108. if(i>0)
  1109. /*************/
  1110. fprintf(pfOut, ", ");
  1111. /*************/
  1112. if (fscanf (pfPara, "%d", &rgppiIntraQuantizerMatrixAlpha [BASE_LAYER] [iObj] [i]) != 1) {
  1113. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1114. fatal_error("Conversion aborted");
  1115. }
  1116. /*************/
  1117. fprintf(pfOut, "%d", rgppiIntraQuantizerMatrixAlpha [BASE_LAYER] [iObj] [i]);
  1118. /*************/
  1119. }
  1120. /*************/
  1121. fprintf(pfOut, "}n");
  1122. /*************/
  1123. }
  1124. }
  1125. if (bAnyScalability) {
  1126. for (iObj = 0; iObj < nVO; iObj++) {
  1127. if (fscanf (pfPara, "%d", &rgbLoadIntraMatrixAlpha [ENHN_LAYER] [iObj]) != 1) {
  1128. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1129. fatal_error("Conversion aborted");
  1130. }
  1131. my_assert (rgbLoadIntraMatrixAlpha [ENHN_LAYER] [iObj] ==0 || 
  1132. rgbLoadIntraMatrixAlpha [ENHN_LAYER] [iObj] == 1);
  1133. /*************/
  1134. fprintf(pfOut, "Alpha.QuantMatrix.Intra.Enable [%d] = %dn", iObj + nVO, rgbLoadIntraMatrixAlpha [ENHN_LAYER] [iObj]);
  1135. /*************/
  1136. if (rgbLoadIntraMatrixAlpha [ENHN_LAYER] [iObj]) {
  1137. /*************/
  1138. fprintf(pfOut, "Alpha.QuantMatrix.Intra [%d] = {", iObj + nVO);
  1139. /*************/
  1140. for (UInt i = 0; i < BLOCK_SQUARE_SIZE; i++) {
  1141. if(i>0)
  1142. /*************/
  1143. fprintf(pfOut, ", ");
  1144. /*************/
  1145. if (fscanf (pfPara, "%d", &rgppiIntraQuantizerMatrixAlpha [ENHN_LAYER] [iObj] [i]) != 1) {
  1146. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1147. fatal_error("Conversion aborted");
  1148. }
  1149. /*************/
  1150. fprintf(pfOut, "%d", rgppiIntraQuantizerMatrixAlpha [ENHN_LAYER] [iObj] [i]);
  1151. /*************/
  1152. }
  1153. /*************/
  1154. fprintf(pfOut, "}n");
  1155. /*************/
  1156. }
  1157. }
  1158. }
  1160. // load non-default  gray alpha inter Q-Matrix, 0 -- FALSE, 1 -- TRUE
  1161. nextValidLine (pfPara, pnLine);
  1162. for (iObj = 0; iObj < nVO; iObj++) {
  1163. if (fscanf (pfPara, "%d", &rgbLoadInterMatrixAlpha [BASE_LAYER] [iObj]) != 1) {
  1164. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1165. fatal_error("Conversion aborted");
  1166. }
  1167. my_assert (rgbLoadInterMatrixAlpha [BASE_LAYER] [iObj] ==0 || 
  1168. rgbLoadInterMatrixAlpha [BASE_LAYER] [iObj] == 1);
  1169. /*************/
  1170. fprintf(pfOut, "Alpha.QuantMatrix.Inter.Enable [%d] = %dn", iObj, rgbLoadInterMatrixAlpha [BASE_LAYER] [iObj]);
  1171. /*************/
  1172. if (rgbLoadInterMatrixAlpha [BASE_LAYER] [iObj]) {
  1173. /*************/
  1174. fprintf(pfOut, "Alpha.QuantMatrix.Inter [%d] = {", iObj);
  1175. /*************/
  1176. for (UInt i = 0; i < BLOCK_SQUARE_SIZE; i++) {
  1177. if(i>0)
  1178. /*************/
  1179. fprintf(pfOut, ", ");
  1180. /*************/
  1181. if (fscanf (pfPara, "%d", &rgppiInterQuantizerMatrixAlpha [BASE_LAYER] [iObj] [i]) != 1) {
  1182. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1183. fatal_error("Conversion aborted");
  1184. }
  1185. /*************/
  1186. fprintf(pfOut, "%d", rgppiInterQuantizerMatrixAlpha [BASE_LAYER] [iObj] [i]);
  1187. /*************/
  1188. }
  1189. /*************/
  1190. fprintf(pfOut, "}n");
  1191. /*************/
  1192. }
  1193. }
  1194. if (bAnyScalability) {
  1195. for (iObj = 0; iObj < nVO; iObj++) {
  1196. if (fscanf (pfPara, "%d", &rgbLoadInterMatrixAlpha [ENHN_LAYER] [iObj]) != 1) {
  1197. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1198. fatal_error("Conversion aborted");
  1199. }
  1200. my_assert (rgbLoadInterMatrixAlpha [ENHN_LAYER] [iObj] ==0 || 
  1201. rgbLoadInterMatrixAlpha [ENHN_LAYER] [iObj] == 1);
  1202. /*************/
  1203. fprintf(pfOut, "Alpha.QuantMatrix.Inter.Enable [%d] = %dn", iObj + nVO, rgbLoadInterMatrixAlpha [ENHN_LAYER] [iObj]);
  1204. /*************/
  1205. if (rgbLoadInterMatrixAlpha [ENHN_LAYER] [iObj]) {
  1206. /*************/
  1207. fprintf(pfOut, "Alpha.QuantMatrix.Inter [%d] = {", iObj + nVO);
  1208. /*************/
  1209. for (UInt i = 0; i < BLOCK_SQUARE_SIZE; i++) {
  1210. if(i>0)
  1211. /*************/
  1212. fprintf(pfOut, ", ");
  1213. /*************/
  1214. if (fscanf (pfPara, "%d", &rgppiInterQuantizerMatrixAlpha [ENHN_LAYER] [iObj] [i]) != 1) {
  1215. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1216. fatal_error("Conversion aborted");
  1217. }
  1218. /*************/
  1219. fprintf(pfOut, "%d", rgppiInterQuantizerMatrixAlpha [ENHN_LAYER] [iObj] [i]);
  1220. /*************/
  1221. }
  1222. /*************/
  1223. fprintf(pfOut, "}n");
  1224. /*************/
  1225. }
  1226. }
  1227. }
  1229. // I-VO quantization stepsize for Alpha
  1230. nextValidLine (pfPara, pnLine);
  1231. for (iObj = 0; iObj < nVO; iObj++) {
  1232. if (fscanf (pfPara, "%d", &(rgiIStepAlpha [BASE_LAYER] [iObj])) != 1) {
  1233. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1234. fatal_error("Conversion aborted");
  1235. }
  1236. my_assert (rgiIStepAlpha [BASE_LAYER] [iObj] > 0 && rgiIStepAlpha [BASE_LAYER] [iObj] < 32);
  1237. /*************/
  1238. fprintf(pfOut, "Alpha.QuantStep.IVOP [%d] = %dn", iObj, rgiIStepAlpha [BASE_LAYER] [iObj]);
  1239. /*************/
  1240. }
  1241. if (bAnyScalability) {
  1242. for (iObj = 0; iObj < nVO; iObj++) {
  1243. if (fscanf (pfPara, "%d", &(rgiIStepAlpha [ENHN_LAYER] [iObj])) != 1) {
  1244. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1245. fatal_error("Conversion aborted");
  1246. }
  1247. my_assert (rgiIStepAlpha [ENHN_LAYER] [iObj] > 0 && rgiIStepAlpha [ENHN_LAYER] [iObj] < 32);
  1248. /*************/
  1249. fprintf(pfOut, "Alpha.QuantStep.IVOP [%d] = %dn", iObj + nVO, rgiIStepAlpha [ENHN_LAYER] [iObj]);
  1250. /*************/
  1251. }
  1252. }
  1254. // P-VO quantization stepsize for Alpha
  1255. nextValidLine (pfPara, pnLine);
  1256. for (iObj = 0; iObj < nVO; iObj++) {
  1257. if (fscanf (pfPara, "%d", &(rgiPStepAlpha [BASE_LAYER] [iObj])) != 1) {
  1258. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1259. fatal_error("Conversion aborted");
  1260. }
  1261. my_assert (rgiPStepAlpha [BASE_LAYER] [iObj] > 0 && rgiPStepAlpha [BASE_LAYER] [iObj] < 64);
  1262. /*************/
  1263. fprintf(pfOut, "Alpha.QuantStep.PVOP [%d] = %dn", iObj, rgiPStepAlpha [BASE_LAYER] [iObj]);
  1264. /*************/
  1265. }
  1266. if (bAnyScalability) {
  1267. for (iObj = 0; iObj < nVO; iObj++) {
  1268. if (fscanf (pfPara, "%d", &(rgiPStepAlpha [ENHN_LAYER] [iObj])) != 1) {
  1269. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1270. fatal_error("Conversion aborted");
  1271. }
  1272. my_assert (rgiPStepAlpha [ENHN_LAYER] [iObj] > 0 && rgiPStepAlpha [ENHN_LAYER] [iObj] < 64);
  1273. /*************/
  1274. fprintf(pfOut, "Alpha.QuantStep.PVOP [%d] = %dn", iObj + nVO, rgiPStepAlpha [ENHN_LAYER] [iObj]);
  1275. /*************/
  1276. }
  1277. }
  1279. // B-VO quantization stepsize for Alpha
  1280. nextValidLine (pfPara, pnLine);
  1281. for (iObj = 0; iObj < nVO; iObj++) {
  1282. if (fscanf (pfPara, "%d", &(rgiBStepAlpha [BASE_LAYER] [iObj])) != 1) {
  1283. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1284. fatal_error("Conversion aborted");
  1285. }
  1286. my_assert (rgiBStepAlpha [BASE_LAYER] [iObj] > 0 && rgiBStepAlpha [BASE_LAYER] [iObj] < 64);
  1287. /*************/
  1288. fprintf(pfOut, "Alpha.QuantStep.BVOP [%d] = %dn", iObj, rgiBStepAlpha [BASE_LAYER] [iObj]);
  1289. /*************/
  1290. }
  1291. if (bAnyScalability) {
  1292. for (iObj = 0; iObj < nVO; iObj++) {
  1293. if (fscanf (pfPara, "%d", &(rgiBStepAlpha [ENHN_LAYER] [iObj])) != 1) {
  1294. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1295. fatal_error("Conversion aborted");
  1296. }
  1297. my_assert (rgiBStepAlpha [ENHN_LAYER] [iObj] > 0 && rgiBStepAlpha [ENHN_LAYER] [iObj] < 64);
  1298. /*************/
  1299. fprintf(pfOut, "Alpha.QuantStep.BVOP [%d] = %dn", iObj + nVO, rgiBStepAlpha [ENHN_LAYER] [iObj]);
  1300. /*************/
  1301. }
  1302. }
  1304. // disable_gray_quant_update
  1305. nextValidLine (pfPara, pnLine);
  1306. for (iObj = 0; iObj < nVO; iObj++) {
  1307. if (fscanf (pfPara, "%d", &(rgbNoGrayQuantUpdate [BASE_LAYER] [iObj])) != 1) {
  1308. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1309. fatal_error("Conversion aborted");
  1310. }
  1311. /*************/
  1312. fprintf(pfOut, "Alpha.QuantDecouple.Enable [%d] = %dn", iObj, rgbNoGrayQuantUpdate [BASE_LAYER] [iObj]);
  1313. /*************/
  1314. }
  1315. if (bAnyScalability) {
  1316. for (iObj = 0; iObj < nVO; iObj++) {
  1317. if (fscanf (pfPara, "%d", &(rgbNoGrayQuantUpdate [ENHN_LAYER] [iObj])) != 1) {
  1318. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1319. fatal_error("Conversion aborted");
  1320. }
  1321. /*************/
  1322. fprintf(pfOut, "Alpha.QuantDecouple.Enable [%d] = %dn", iObj + nVO, rgbNoGrayQuantUpdate [ENHN_LAYER] [iObj]);
  1323. /*************/
  1324. }
  1325. }
  1327. // number of P-VOP's between 2 I-VOP's; if there are B-VOPs, the no. of encode frames will multiply
  1328. nextValidLine (pfPara, pnLine);
  1329. for (iObj = 0; iObj < nVO; iObj++) {
  1330. if (fscanf (pfPara, "%d", &rgiNumPbetweenIVOP [iObj]) != 1) {
  1331. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1332. fatal_error("Conversion aborted");
  1333. }
  1334. /*************/
  1335. fprintf(pfOut, "Motion.PBetweenICount [%d] = %dn", iObj, rgiNumPbetweenIVOP [iObj]);
  1336. /*************/
  1337. }
  1339. // number of B-VOP's between 2 P-VOP's
  1340. nextValidLine (pfPara, pnLine);
  1341. for (iObj = 0; iObj < nVO; iObj++) {
  1342. if (fscanf (pfPara, "%d", &rgiNumBbetweenPVOP [iObj]) != 1) {
  1343. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1344. fatal_error("Conversion aborted");
  1345. }
  1346. my_assert (rgiNumBbetweenPVOP [iObj] >= 0);
  1347. /*************/
  1348. fprintf(pfOut, "Motion.BBetweenPCount [%d] = %dn", iObj, rgiNumBbetweenPVOP [iObj]);
  1349. /*************/
  1350. }
  1352. if(iVersion>814)
  1353. {
  1354. // rgbAllowSkippedPMBs
  1355. nextValidLine (pfPara, pnLine);
  1356. for (iObj = 0; iObj < nVO; iObj++) {
  1357. if (fscanf (pfPara, "%d", &rgbAllowSkippedPMBs [iObj]) != 1) {
  1358. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1359. fatal_error("Conversion aborted");
  1360. }
  1361. my_assert (rgbAllowSkippedPMBs [iObj] == 0 || rgbAllowSkippedPMBs[iObj]==1);
  1362. }
  1363. }
  1364. else
  1365. for (iObj = 0; iObj < nVO; iObj++)
  1366. rgbAllowSkippedPMBs [iObj] = 1;
  1368. for (iObj = 0; iObj < nVO; iObj++)
  1369. /*************/
  1370. fprintf(pfOut, "Motion.SkippedMB.Enable [%d] = %dn", iObj, rgbAllowSkippedPMBs [iObj]);
  1371. /*************/
  1373. //added to encode GOV header by SONY 980212
  1374. //number of VOP between GOV header
  1375. //CAUTION:GOV period is not used in spatial scalable coding
  1376. nextValidLine (pfPara, pnLine);
  1377. for (iObj = 0; iObj < nVO; iObj++) {
  1378. if (fscanf (pfPara, "%d", &rgiGOVperiod [iObj]) != 1) {
  1379. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1380. fatal_error("Conversion aborted");
  1381. }
  1382. my_assert (rgiGOVperiod [iObj] >= 0);
  1383. /*************/
  1384. fprintf(pfOut, "GOV.Enable [%d] = %dn", iObj, rgiGOVperiod [iObj] > 0);
  1385. fprintf(pfOut, "GOV.Period [%d] = %dn", iObj, rgiGOVperiod [iObj]);
  1386. /*************/
  1387. }
  1388. //980212
  1390. // deblocking filter disable
  1391. nextValidLine (pfPara, pnLine);
  1392. for (iObj = 0; iObj < nVO; iObj++) {
  1393. if (fscanf (pfPara, "%d", &rgbDeblockFilterDisable [iObj]) != 1) {
  1394. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1395. fatal_error("Conversion aborted");
  1396. }
  1397. /*************/
  1398. fprintf(pfOut, "Motion.DeblockingFilter.Enable [%d] = %dn", iObj, !rgbDeblockFilterDisable [iObj]);
  1399. /*************/
  1400. }
  1402. // Temporal sampling rate
  1403. nextValidLine (pfPara, pnLine);
  1404. for (iObj = 0; iObj < nVO; iObj++) {
  1405. if (fscanf (pfPara, "%d", &rgiTSRate [iObj]) != 1) {
  1406. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1407. fatal_error("Conversion aborted");
  1408. }
  1409. my_assert (rgiTSRate [iObj] >= 1);
  1410. /*************/
  1411. fprintf(pfOut, "Source.SamplingRate [%d] = %dn", iObj, rgiTSRate [iObj]);
  1412. /*************/
  1413. }
  1414. if ( bAnyScalability ){ // This part is added by Norio Ito
  1415. for (iObj = 0; iObj < nVO; iObj++) {
  1416. if (fscanf (pfPara, "%d", &rgiEnhcTSRate [iObj]) != 1) {
  1417. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1418. fatal_error("Conversion aborted");
  1419. }
  1420. my_assert (rgiEnhcTSRate [iObj] >= 1);
  1421. /*************/
  1422. fprintf(pfOut, "Source.SamplingRate [%d] = %dn", iObj + nVO, rgiEnhcTSRate [iObj]);
  1423. /*************/
  1424. }
  1425. }
  1427. // maximum displacement
  1428. nextValidLine (pfPara, pnLine);
  1429. for (iObj = 0; iObj < nVO; iObj++) {
  1430. if (fscanf (pfPara, "%d", &rguiSearchRange [BASE_LAYER] [iObj]) != 1) {
  1431. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1432. fatal_error("Conversion aborted");
  1433. }
  1434. my_assert (rguiSearchRange [BASE_LAYER] [iObj] >= 1);
  1435. /*************/
  1436. fprintf(pfOut, "Motion.SearchRange [%d] = %dn", iObj, rguiSearchRange [BASE_LAYER] [iObj]);
  1437. /*************/
  1438. }
  1439. if (bAnyScalability) {
  1440. for (iObj = 0; iObj < nVO; iObj++) {
  1441. if (fscanf (pfPara, "%d", &rguiSearchRange [ENHN_LAYER] [iObj]) != 1) {
  1442. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1443. fatal_error("Conversion aborted");
  1444. }
  1445. my_assert (rguiSearchRange [ENHN_LAYER] [iObj] >= 1);
  1446. /*************/
  1447. fprintf(pfOut, "Motion.SearchRange [%d] = %dn", iObj + nVO, rguiSearchRange [ENHN_LAYER] [iObj]);
  1448. /*************/
  1449. }
  1450. }
  1452. // use original or reconstructed previous VO for ME
  1453. nextValidLine (pfPara, pnLine);
  1454. for (iObj = 0; iObj < nVO; iObj++) {
  1455. if (fscanf (pfPara, "%d", &rgbOriginalME [BASE_LAYER] [iObj]) != 1) {
  1456. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1457. fatal_error("Conversion aborted");
  1458. }
  1459. my_assert (rgbOriginalME [BASE_LAYER] [iObj] == 0 || rgbOriginalME [BASE_LAYER] [iObj] == 1);
  1460. /*************/
  1461. fprintf(pfOut, "Motion.UseSourceForME.Enable [%d] = %dn", iObj, rgbOriginalME [BASE_LAYER] [iObj]);
  1462. /*************/
  1463. }
  1464. if (bAnyScalability) {
  1465. for (iObj = 0; iObj < nVO; iObj++) {
  1466. if (fscanf (pfPara, "%d", &rgbOriginalME [ENHN_LAYER] [iObj]) != 1) {
  1467. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1468. fatal_error("Conversion aborted");
  1469. }
  1470. my_assert (rgbOriginalME [ENHN_LAYER] [iObj] == 0 || rgbOriginalME [ENHN_LAYER] [iObj] == 1);
  1471. /*************/
  1472. fprintf(pfOut, "Motion.UseSourceForME.Enable [%d] = %dn", iObj + nVO, rgbOriginalME [ENHN_LAYER] [iObj]);
  1473. /*************/
  1474. }
  1475. }
  1477. // disable advance prediction (obmc only)?
  1478. nextValidLine (pfPara, pnLine);
  1479. for (iObj = 0; iObj < nVO; iObj++) {
  1480. if (fscanf (pfPara, "%d", &rgbAdvPredDisable [BASE_LAYER] [iObj]) != 1) {
  1481. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1482. fatal_error("Conversion aborted");
  1483. }
  1484. my_assert (rgbAdvPredDisable [BASE_LAYER] [iObj] == 0 || rgbAdvPredDisable [BASE_LAYER] [iObj] == 1);
  1485. /*************/
  1486. fprintf(pfOut, "Motion.AdvancedPrediction.Enable [%d] = %dn", iObj, !rgbAdvPredDisable [BASE_LAYER] [iObj]);
  1487. /*************/
  1488. }
  1489. if (bAnyScalability) {
  1490. for (iObj = 0; iObj < nVO; iObj++) {
  1491. if (fscanf (pfPara, "%d", &rgbAdvPredDisable [ENHN_LAYER] [iObj]) != 1) {
  1492. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1493. fatal_error("Conversion aborted");
  1494. }
  1495. my_assert (rgbAdvPredDisable [ENHN_LAYER] [iObj] == 0 || rgbAdvPredDisable [ENHN_LAYER] [iObj] == 1);
  1496. /*************/
  1497. fprintf(pfOut, "Motion.AdvancedPrediction.Enable [%d] = %dn", iObj + nVO, !rgbAdvPredDisable [ENHN_LAYER] [iObj]);
  1498. /*************/
  1499. }
  1500. }
  1502. // START: Complexity Estimation syntax support - Marc Mongenet (EPFL) - 16 Jun 1998
  1503. readBoolVOLFlag (rgbComplexityEstimationDisable, nVO, pfPara, pnLine, bAnyScalability);
  1504. readBoolVOLFlag (rgbOpaque, nVO, pfPara, pnLine, bAnyScalability);
  1505. readBoolVOLFlag (rgbTransparent, nVO, pfPara, pnLine, bAnyScalability);
  1506. readBoolVOLFlag (rgbIntraCAE, nVO, pfPara, pnLine, bAnyScalability);
  1507. readBoolVOLFlag (rgbInterCAE, nVO, pfPara, pnLine, bAnyScalability);
  1508. readBoolVOLFlag (rgbNoUpdate, nVO, pfPara, pnLine, bAnyScalability);
  1509. readBoolVOLFlag (rgbUpsampling, nVO, pfPara, pnLine, bAnyScalability);
  1510. readBoolVOLFlag (rgbIntraBlocks, nVO, pfPara, pnLine, bAnyScalability);
  1511. readBoolVOLFlag (rgbInterBlocks, nVO, pfPara, pnLine, bAnyScalability);
  1512. readBoolVOLFlag (rgbInter4vBlocks, nVO, pfPara, pnLine, bAnyScalability);
  1513. readBoolVOLFlag (rgbNotCodedBlocks, nVO, pfPara, pnLine, bAnyScalability);
  1514. readBoolVOLFlag (rgbDCTCoefs, nVO, pfPara, pnLine, bAnyScalability);
  1515. readBoolVOLFlag (rgbDCTLines, nVO, pfPara, pnLine, bAnyScalability);
  1516. readBoolVOLFlag (rgbVLCSymbols, nVO, pfPara, pnLine, bAnyScalability);
  1517. readBoolVOLFlag (rgbVLCBits, nVO, pfPara, pnLine, bAnyScalability);
  1518. readBoolVOLFlag (rgbAPM, nVO, pfPara, pnLine, bAnyScalability);
  1519. readBoolVOLFlag (rgbNPM, nVO, pfPara, pnLine, bAnyScalability);
  1520. readBoolVOLFlag (rgbInterpolateMCQ, nVO, pfPara, pnLine, bAnyScalability);
  1521. readBoolVOLFlag (rgbForwBackMCQ, nVO, pfPara, pnLine, bAnyScalability);
  1522. readBoolVOLFlag (rgbHalfpel2, nVO, pfPara, pnLine, bAnyScalability);
  1523. readBoolVOLFlag (rgbHalfpel4, nVO, pfPara, pnLine, bAnyScalability);
  1524. // END: Complexity Estimation syntax support
  1526. /*************/
  1527. for(iObj = 0; iObj<nVO; iObj++)
  1528. {
  1529. fprintf(pfOut, "Complexity.Enable [%d] = %dn", iObj, !rgbComplexityEstimationDisable [BASE_LAYER] [iObj]);
  1530. if(!rgbComplexityEstimationDisable [BASE_LAYER] [iObj])
  1531. {
  1532. fprintf(pfOut, "Complexity.Opaque.Enable [%d] = %dn", iObj, rgbOpaque [BASE_LAYER] [iObj]);
  1533. fprintf(pfOut, "Complexity.Transparent.Enable [%d] = %dn", iObj, rgbTransparent [BASE_LAYER] [iObj]);
  1534. fprintf(pfOut, "Complexity.IntraCAE.Enable [%d] = %dn", iObj, rgbIntraCAE [BASE_LAYER] [iObj]);
  1535. fprintf(pfOut, "Complexity.InterCAE.Enable [%d] = %dn", iObj, rgbInterCAE [BASE_LAYER] [iObj]);
  1536. fprintf(pfOut, "Complexity.NoUpdate.Enable [%d] = %dn", iObj, rgbNoUpdate [BASE_LAYER] [iObj]);
  1537. fprintf(pfOut, "Complexity.UpSampling.Enable [%d] = %dn", iObj, rgbUpsampling [BASE_LAYER] [iObj]);
  1538. fprintf(pfOut, "Complexity.IntraBlocks.Enable [%d] = %dn", iObj, rgbIntraBlocks [BASE_LAYER] [iObj]);
  1539. fprintf(pfOut, "Complexity.InterBlocks.Enable [%d] = %dn", iObj, rgbInterBlocks [BASE_LAYER] [iObj]);
  1540. fprintf(pfOut, "Complexity.Inter4VBlocks.Enable [%d] = %dn", iObj, rgbInter4vBlocks [BASE_LAYER] [iObj]);
  1541. fprintf(pfOut, "Complexity.NotCodedBlocks.Enable [%d] = %dn", iObj, rgbNotCodedBlocks [BASE_LAYER] [iObj]);
  1542. fprintf(pfOut, "Complexity.DCTCoefs.Enable [%d] = %dn", iObj, rgbDCTCoefs [BASE_LAYER] [iObj]);
  1543. fprintf(pfOut, "Complexity.DCTLines.Enable [%d] = %dn", iObj, rgbDCTLines [BASE_LAYER] [iObj]);
  1544. fprintf(pfOut, "Complexity.VLCSymbols.Enable [%d] = %dn", iObj, rgbVLCSymbols [BASE_LAYER] [iObj]);
  1545. fprintf(pfOut, "Complexity.VLCBits.Enable [%d] = %dn", iObj, rgbVLCBits [BASE_LAYER] [iObj]);
  1546. fprintf(pfOut, "Complexity.APM.Enable [%d] = %dn", iObj, rgbAPM [BASE_LAYER] [iObj]);
  1547. fprintf(pfOut, "Complexity.NPM.Enable [%d] = %dn", iObj, rgbNPM [BASE_LAYER] [iObj]);
  1548. fprintf(pfOut, "Complexity.InterpMCQ.Enable [%d] = %dn", iObj, rgbInterpolateMCQ [BASE_LAYER] [iObj]);
  1549. fprintf(pfOut, "Complexity.ForwBackMCQ.Enable [%d] = %dn", iObj, rgbForwBackMCQ [BASE_LAYER] [iObj]);
  1550. fprintf(pfOut, "Complexity.HalfPel2.Enable [%d] = %dn", iObj, rgbHalfpel2 [BASE_LAYER] [iObj]);
  1551. fprintf(pfOut, "Complexity.HalfPel4.Enable [%d] = %dn", iObj, rgbHalfpel4 [BASE_LAYER] [iObj]);
  1552. }
  1553. if(bAnyScalability)
  1554. {
  1555. fprintf(pfOut, "Complexity.Enable [%d] = %dn", iObj + nVO, !rgbComplexityEstimationDisable [ENHN_LAYER] [iObj]);
  1556. if(!rgbComplexityEstimationDisable [BASE_LAYER] [iObj])
  1557. {
  1558. fprintf(pfOut, "Complexity.Opaque.Enable [%d] = %dn", iObj + nVO, rgbOpaque [ENHN_LAYER] [iObj]);
  1559. fprintf(pfOut, "Complexity.Transparent.Enable [%d] = %dn", iObj + nVO, rgbTransparent [ENHN_LAYER] [iObj]);
  1560. fprintf(pfOut, "Complexity.IntraCAE.Enable [%d] = %dn", iObj + nVO, rgbIntraCAE [ENHN_LAYER] [iObj]);
  1561. fprintf(pfOut, "Complexity.InterCAE.Enable [%d] = %dn", iObj + nVO, rgbInterCAE [ENHN_LAYER] [iObj]);
  1562. fprintf(pfOut, "Complexity.NoUpdate.Enable [%d] = %dn", iObj + nVO, rgbNoUpdate [ENHN_LAYER] [iObj]);
  1563. fprintf(pfOut, "Complexity.UpSampling.Enable [%d] = %dn", iObj + nVO, rgbUpsampling [ENHN_LAYER] [iObj]);
  1564. fprintf(pfOut, "Complexity.IntraBlocks.Enable [%d] = %dn", iObj + nVO, rgbIntraBlocks [ENHN_LAYER] [iObj]);
  1565. fprintf(pfOut, "Complexity.InterBlocks.Enable [%d] = %dn", iObj + nVO, rgbInterBlocks [ENHN_LAYER] [iObj]);
  1566. fprintf(pfOut, "Complexity.Inter4VBlocks.Enable [%d] = %dn", iObj + nVO, rgbInter4vBlocks [ENHN_LAYER] [iObj]);
  1567. fprintf(pfOut, "Complexity.NotCodedBlocks.Enable [%d] = %dn", iObj + nVO, rgbNotCodedBlocks [ENHN_LAYER] [iObj]);
  1568. fprintf(pfOut, "Complexity.DCTCoefs.Enable [%d] = %dn", iObj + nVO, rgbDCTCoefs [ENHN_LAYER] [iObj]);
  1569. fprintf(pfOut, "Complexity.DCTLines.Enable [%d] = %dn", iObj + nVO, rgbDCTLines [ENHN_LAYER] [iObj]);
  1570. fprintf(pfOut, "Complexity.VLCSymbols.Enable [%d] = %dn", iObj + nVO, rgbVLCSymbols [ENHN_LAYER] [iObj]);
  1571. fprintf(pfOut, "Complexity.VLCBits.Enable [%d] = %dn", iObj + nVO, rgbVLCBits [ENHN_LAYER] [iObj]);
  1572. fprintf(pfOut, "Complexity.APM.Enable [%d] = %dn", iObj + nVO, rgbAPM [ENHN_LAYER] [iObj]);
  1573. fprintf(pfOut, "Complexity.NPM.Enable [%d] = %dn", iObj + nVO, rgbNPM [ENHN_LAYER] [iObj]);
  1574. fprintf(pfOut, "Complexity.InterpMCQ.Enable [%d] = %dn", iObj + nVO, rgbInterpolateMCQ [ENHN_LAYER] [iObj]);
  1575. fprintf(pfOut, "Complexity.ForwBackMCQ.Enable [%d] = %dn", iObj + nVO, rgbForwBackMCQ [ENHN_LAYER] [iObj]);
  1576. fprintf(pfOut, "Complexity.HalfPel2.Enable [%d] = %dn", iObj + nVO, rgbHalfpel2 [ENHN_LAYER] [iObj]);
  1577. fprintf(pfOut, "Complexity.HalfPel4.Enable [%d] = %dn", iObj + nVO, rgbHalfpel4 [ENHN_LAYER] [iObj]);
  1578. }
  1579. }
  1580. }
  1581. /*************/
  1583. // START: VOL Control Parameters
  1584. if(iVersion>813)
  1585. {
  1586. readItem(rguiVolControlParameters, nVO, pfPara, pnLine, bAnyScalability);
  1587. readItem(rguiChromaFormat, nVO, pfPara, pnLine, bAnyScalability);
  1588. readItem(rguiLowDelay, nVO, pfPara, pnLine, bAnyScalability);
  1589. readItem(rguiVBVParams, nVO, pfPara, pnLine, bAnyScalability);
  1590. readItem(rguiBitRate, nVO, pfPara, pnLine, bAnyScalability);
  1591. readItem(rguiVbvBufferSize, nVO, pfPara, pnLine, bAnyScalability);
  1592. readItem(rguiVbvBufferOccupany, nVO, pfPara, pnLine, bAnyScalability);
  1593. }
  1594. else
  1595. {
  1596. for(iObj = 0; iObj<nVO; iObj++)
  1597. {
  1598. rguiVolControlParameters[BASE_LAYER][iObj] = 0;
  1599. rguiVolControlParameters[ENHN_LAYER][iObj] = 0;
  1600. rguiChromaFormat[BASE_LAYER][iObj] = 0;
  1601. rguiChromaFormat[ENHN_LAYER][iObj] = 0;
  1602. rguiLowDelay[BASE_LAYER][iObj] = 0;
  1603. rguiLowDelay[ENHN_LAYER][iObj] = 0;
  1604. rguiVBVParams[BASE_LAYER][iObj] = 0;
  1605. rguiVBVParams[ENHN_LAYER][iObj] = 0;
  1606. rguiBitRate[BASE_LAYER][iObj] = 0;
  1607. rguiBitRate[ENHN_LAYER][iObj] = 0;
  1608. rguiVbvBufferSize[BASE_LAYER][iObj] = 0;
  1609. rguiVbvBufferSize[ENHN_LAYER][iObj] = 0;
  1610. rguiVbvBufferOccupany[BASE_LAYER][iObj] = 0;
  1611. rguiVbvBufferOccupany[ENHN_LAYER][iObj] = 0;
  1612. }
  1614. }
  1616. for(iObj = 0; iObj<nVO; iObj++)
  1617. {
  1618. /*************/
  1619. fprintf(pfOut, "VOLControl.Enable [%d] = %dn", iObj, rguiVolControlParameters [BASE_LAYER] [iObj]);
  1620. fprintf(pfOut, "VOLControl.ChromaFormat [%d] = %dn", iObj, rguiChromaFormat [BASE_LAYER] [iObj]);
  1621. fprintf(pfOut, "VOLControl.LowDelay [%d] = %dn", iObj, rguiLowDelay [BASE_LAYER] [iObj]);
  1622. fprintf(pfOut, "VOLControl.VBVParams.Enable [%d] = %dn", iObj, rguiVBVParams [BASE_LAYER] [iObj]);
  1623. fprintf(pfOut, "VOLControl.Bitrate [%d] = %dn", iObj, rguiBitRate [BASE_LAYER] [iObj]);
  1624. fprintf(pfOut, "VOLControl.VBVBuffer.Size [%d] = %dn", iObj, rguiVbvBufferSize [BASE_LAYER] [iObj]);
  1625. fprintf(pfOut, "VOLControl.VBVBuffer.Occupancy [%d] = %dn", iObj, rguiVbvBufferOccupany [BASE_LAYER] [iObj]);
  1626. /*************/
  1627. if(bAnyScalability)
  1628. {
  1629. /*************/
  1630. fprintf(pfOut, "VOLControl.Enable [%d] = %dn", iObj + nVO, rguiVolControlParameters [ENHN_LAYER] [iObj]);
  1631. fprintf(pfOut, "VOLControl.ChromaFormat [%d] = %dn", iObj + nVO, rguiChromaFormat [ENHN_LAYER] [iObj]);
  1632. fprintf(pfOut, "VOLControl.LowDelay [%d] = %dn", iObj + nVO, rguiLowDelay [ENHN_LAYER] [iObj]);
  1633. fprintf(pfOut, "VOLControl.VBVParams.Enable [%d] = %dn", iObj + nVO, rguiVBVParams [ENHN_LAYER] [iObj]);
  1634. fprintf(pfOut, "VOLControl.Bitrate [%d] = %dn", iObj + nVO, rguiBitRate [ENHN_LAYER] [iObj]);
  1635. fprintf(pfOut, "VOLControl.VBVBuffer.Size [%d] = %dn", iObj + nVO, rguiVbvBufferSize [ENHN_LAYER] [iObj]);
  1636. fprintf(pfOut, "VOLControl.VBVBuffer.Occupancy [%d] = %dn", iObj + nVO, rguiVbvBufferOccupany [ENHN_LAYER] [iObj]);
  1637. /*************/
  1638. }
  1639. }
  1641. // END: VOL Control Parameters
  1643. // Interlaced CHANGE
  1644. // Sequence frame frequency (Hz).  Use double type because of 29.97Hz (etc)
  1645. nextValidLine (pfPara, pnLine);
  1646. for (iObj = 0; iObj < nVO; iObj++) {
  1647. if (fscanf (pfPara, "%lf", &(rgdFrameFrequency [BASE_LAYER] [iObj])) != 1) {
  1648. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1649. fatal_error("Conversion aborted");
  1650. }
  1651. my_assert(rgdFrameFrequency [BASE_LAYER] [iObj] > 0.0);
  1652. /*************/
  1653. fprintf(pfOut, "Source.FrameRate [%d] = %gn", iObj, rgdFrameFrequency [BASE_LAYER] [iObj]);
  1654. /*************/
  1655. }
  1656. if (bAnyScalability) {
  1657. for (iObj = 0; iObj < nVO; iObj++) {
  1658. if (fscanf (pfPara, "%lf", &(rgdFrameFrequency [ENHN_LAYER] [iObj])) != 1) {
  1659. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1660. fatal_error("Conversion aborted");
  1661. }
  1662. my_assert(rgdFrameFrequency [ENHN_LAYER] [iObj] > 0.0);
  1663. /*************/
  1664. fprintf(pfOut, "Source.FrameRate [%d] = %gn", iObj + nVO, rgdFrameFrequency [ENHN_LAYER] [iObj]);
  1665. /*************/
  1666. }
  1667. }
  1669. // top field first flag
  1670. nextValidLine (pfPara, pnLine);
  1671. for (iObj = 0; iObj < nVO; iObj++) {
  1672. if (fscanf (pfPara, "%d", &(rgbTopFieldFirst [BASE_LAYER] [iObj])) != 1) {
  1673. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1674. fatal_error("Conversion aborted");
  1675. }
  1676. my_assert (rgbTopFieldFirst [BASE_LAYER] [iObj] == 0 || 
  1677. rgbTopFieldFirst [BASE_LAYER] [iObj] == 1);
  1678. /*************/
  1679. fprintf(pfOut, "Motion.Interlaced.TopFieldFirst.Enable [%d] = %dn", iObj, rgbTopFieldFirst [BASE_LAYER] [iObj]);
  1680. /*************/
  1681. }
  1682. if (bAnyScalability) {
  1683. for (iObj = 0; iObj < nVO; iObj++) {
  1684. if (fscanf (pfPara, "%d", &(rgbTopFieldFirst [ENHN_LAYER] [iObj])) != 1) {
  1685. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1686. fatal_error("Conversion aborted");
  1687. }
  1688. my_assert (rgbTopFieldFirst [ENHN_LAYER] [iObj] == 0 || 
  1689. rgbTopFieldFirst [ENHN_LAYER] [iObj] == 1);
  1690. /*************/
  1691. fprintf(pfOut, "Motion.Interlaced.TopFieldFirst.Enable [%d] = %dn", iObj + nVO, rgbTopFieldFirst [ENHN_LAYER] [iObj]);
  1692. /*************/
  1693. }
  1694. }
  1696. // alternate scan flag
  1697. nextValidLine (pfPara, pnLine);
  1698. for (iObj = 0; iObj < nVO; iObj++) {
  1699. if (fscanf (pfPara, "%d", &(rgbAlternateScan [BASE_LAYER] [iObj])) != 1) {
  1700. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1701. fatal_error("Conversion aborted");
  1702. }
  1703. my_assert (rgbAlternateScan [BASE_LAYER] [iObj] == 0 || 
  1704. rgbAlternateScan [BASE_LAYER] [iObj] == 1);
  1705. /*************/
  1706. fprintf(pfOut, "Motion.Interlaced.AlternativeScan.Enable [%d] = %dn", iObj, rgbAlternateScan [BASE_LAYER] [iObj]);
  1707. /*************/
  1708. }
  1709. if (bAnyScalability) {
  1710. for (iObj = 0; iObj < nVO; iObj++) {
  1711. if (fscanf (pfPara, "%d", &(rgbAlternateScan [ENHN_LAYER] [iObj])) != 1) {
  1712. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1713. fatal_error("Conversion aborted");
  1714. }
  1715. my_assert (rgbAlternateScan [ENHN_LAYER] [iObj] == 0 || 
  1716. rgbAlternateScan [ENHN_LAYER] [iObj] == 1);
  1717. /*************/
  1718. fprintf(pfOut, "Motion.Interlaced.AlternativeScan.Enable [%d] = %dn", iObj + nVO, rgbAlternateScan [ENHN_LAYER] [iObj]);
  1719. /*************/
  1720. }
  1721. }
  1723. // Direct Mode search radius (half luma pixel units)
  1724. nextValidLine (pfPara, pnLine);
  1725. for (iObj = 0; iObj < nVO; iObj++) {
  1726. if (fscanf (pfPara, "%d", &(rgiDirectModeRadius [BASE_LAYER] [iObj])) != 1) {
  1727. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1728. fatal_error("Conversion aborted");
  1729. }
  1730. /*************/
  1731. fprintf(pfOut, "Motion.SearchRange.DirectMode [%d] = %dn", iObj, rgiDirectModeRadius [BASE_LAYER] [iObj]);
  1732. /*************/
  1733. }
  1734. if (bAnyScalability) {
  1735. for (iObj = 0; iObj < nVO; iObj++) {
  1736. if (fscanf (pfPara, "%d", &(rgiDirectModeRadius [ENHN_LAYER] [iObj])) != 1) {
  1737. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1738. fatal_error("Conversion aborted");
  1739. }
  1740. /*************/
  1741. fprintf(pfOut, "Motion.SearchRange.DirectMode [%d] = %dn", iObj + nVO, rgiDirectModeRadius [ENHN_LAYER] [iObj]);
  1742. /*************/
  1743. }
  1744. }
  1746. // motion vector file
  1747. nextValidLine(pfPara, pnLine);
  1748. for (iObj = 0; iObj < nVO; iObj++) {
  1749. if (fscanf (pfPara, "%d", &(rgiMVFileUsage [BASE_LAYER] [iObj])) != 1) {
  1750. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1751. fatal_error("Conversion aborted");
  1752. }
  1753. my_assert (rgiMVFileUsage [BASE_LAYER] [iObj] == 0 || // 0= not used
  1754. rgiMVFileUsage [BASE_LAYER] [iObj] == 1 || // 1= read motion vectors from file
  1755. rgiMVFileUsage [BASE_LAYER] [iObj] == 2 ); // 2= write motion vectors to file
  1756. /*************/
  1757. fprintf(pfOut, "Motion.ReadWriteMVs [%d] = "%s"n", iObj,
  1758. rgiMVFileUsage [BASE_LAYER] [iObj]==0 ? "Off" : (rgiMVFileUsage [BASE_LAYER] [iObj]==1 ? "Read" : "Write"));
  1759. /*************/
  1761. pchMVFileName [BASE_LAYER] [iObj] = NULL;
  1762. pchMVFileName [ENHN_LAYER] [iObj] = NULL;
  1764. char cFileName[256];
  1765. cFileName[0] = 0;
  1766. if ((rgiMVFileUsage [BASE_LAYER] [iObj] != 0) &&
  1767. (fscanf (pfPara, "%200s", cFileName) != 1)) {
  1768. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1769. fatal_error("Conversion aborted");
  1770. }
  1771. Int iLength = strlen(cFileName) + 1;
  1772. pchMVFileName [BASE_LAYER] [iObj] = new char [iLength];
  1773. memcpy(pchMVFileName [BASE_LAYER] [iObj], cFileName, iLength);
  1774. /*************/
  1775. fprintf(pfOut, "Motion.ReadWriteMVs.Filename [%d] = "%s"n", iObj, pchMVFileName [BASE_LAYER] [iObj]);
  1776. /*************/
  1777. }
  1778. if (bAnyScalability) {
  1779. for (iObj = 0; iObj < nVO; iObj++) {
  1780. if (fscanf (pfPara, "%d", &(rgiMVFileUsage [ENHN_LAYER] [iObj])) != 1) {
  1781. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1782. fatal_error("Conversion aborted");
  1783. }
  1784. my_assert (rgiMVFileUsage [ENHN_LAYER] [iObj] == 0 || 
  1785. rgiMVFileUsage [ENHN_LAYER] [iObj] == 1 ||
  1786. rgiMVFileUsage [ENHN_LAYER] [iObj] == 2 );
  1787. /*************/
  1788. fprintf(pfOut, "Motion.ReadWriteMVs [%d] = "%s"n", iObj + nVO,
  1789. rgiMVFileUsage [ENHN_LAYER] [iObj]==0 ? "Off" : (rgiMVFileUsage [ENHN_LAYER] [iObj]==1 ? "Read" : "Write"));
  1790. /*************/
  1792. char cFileName[256];
  1793. cFileName[0] = 0;
  1794. if ((rgiMVFileUsage [ENHN_LAYER] [iObj] != 0) &&
  1795. (fscanf (pfPara, "%s", cFileName) != 1)) {
  1796. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1797. fatal_error("Conversion aborted");
  1798. }
  1799. Int iLength = strlen(cFileName) + 1;
  1800. pchMVFileName [ENHN_LAYER] [iObj] = new char [iLength];
  1801. memcpy(pchMVFileName [ENHN_LAYER] [iObj], cFileName, iLength);
  1802. /*************/
  1803. fprintf(pfOut, "Motion.ReadWriteMVs.Filename [%d] = "%s"n", iObj + nVO, pchMVFileName [ENHN_LAYER] [iObj]);
  1804. /*************/
  1805. }
  1806. }
  1808. // file information
  1809. pchPrefix = new char [256];
  1810. nextValidLine (pfPara, pnLine);
  1811. fscanf (pfPara, "%s", pchPrefix);
  1813. // original file directory
  1814. pchBmpDir = new char [256];
  1815. nextValidLine (pfPara, pnLine);
  1816. fscanf (pfPara, "%100s", pchBmpDir);
  1818. /*************/
  1819. fprintf(pfOut, "Source.FilePrefix = "%s"n", pchPrefix);
  1820. fprintf(pfOut, "Source.Directory = "%s"n", pchBmpDir);
  1821. /*************/
  1823. // chrominance format
  1824. nextValidLine (pfPara, pnLine);
  1825. for (iObj = 0; iObj < nVO; iObj++) {
  1826. UInt uiChrType;
  1827. if (fscanf (pfPara, "%d", &uiChrType) != 1) {
  1828. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1829. fatal_error("Conversion aborted");
  1830. }
  1831. else {
  1832. my_assert (uiChrType == 0 || uiChrType == 1 || uiChrType == 2);
  1833. rgfChrType [iObj] = (ChromType) uiChrType;
  1834. }
  1835. /*************/
  1836. fprintf(pfOut, "Source.Format [%d] = "%s"n", iObj,
  1837. uiChrType==0 ? "444" : (uiChrType==1 ? "422" : "420"));
  1838. /*************/
  1839. }
  1841. // output file directory
  1842. pchOutBmpDir = new char [256];
  1843. nextValidLine (pfPara, pnLine);
  1844. fscanf (pfPara, "%100s", pchOutBmpDir);
  1846. // output bitstream file
  1847. pchOutStrFile = new char [256];
  1848. nextValidLine (pfPara, pnLine);
  1849. fscanf (pfPara, "%100s", pchOutStrFile);
  1851. /*************/
  1852. fprintf(pfOut, "Output.Directory.Bitstream = "%s"n", pchOutStrFile);
  1853. fprintf(pfOut, "Output.Directory.DecodedFrames = "%s"n", pchOutBmpDir);
  1854. /*************/
  1856. // statistics dumping options
  1857. nextValidLine (pfPara, pnLine);
  1858. for (iObj = 0; iObj < nVO; iObj++) {
  1859. if (fscanf (pfPara, "%d", &rgbDumpMB [iObj]) != 1) {
  1860. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1861. fatal_error("Conversion aborted");
  1862. }
  1863. my_assert (rgbDumpMB [iObj] == 0 || rgbDumpMB [iObj] == 1);
  1864. /*************/
  1865. fprintf(pfOut, "Trace.DetailedDump.Enable [%d] = %dn", iObj, rgbDumpMB [iObj]);
  1866. /*************/
  1867. }
  1869. // trace file options
  1870. nextValidLine (pfPara, pnLine);
  1871. for (iObj = 0; iObj < nVO; iObj++) {
  1872. if (fscanf (pfPara, "%d", &rgbTrace [iObj]) != 1) {
  1873. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1874. fatal_error("Conversion aborted");
  1875. }
  1876. my_assert (rgbTrace [iObj] == 0 || rgbTrace [iObj] == 1);
  1877. /*************/
  1878. fprintf(pfOut, "Trace.CreateFile.Enable [%d] = %dn", iObj, rgbTrace [iObj]);
  1879. /*************/
  1880. }
  1882. // sprite info
  1883. // sprite usage
  1884. nextValidLine (pfPara, pnLine);
  1885. for (iObj = 0; iObj < nVO; iObj++) {
  1886. if (fscanf (pfPara, "%d", &rguiSpriteUsage [iObj]) != 1) {
  1887. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1888. fatal_error("Conversion aborted");
  1889. }
  1890. my_assert ((rguiSpriteUsage [iObj] == 0) || (rguiSpriteUsage [iObj] == 1)); // only support static sprite at the moment
  1891. if (rgbScalability [iObj] == TRUE)
  1892. my_assert (rguiSpriteUsage [iObj] == 0);
  1893. /*************/
  1894. fprintf(pfOut, "Sprite.Type [%d] = "%s"n", iObj, rguiSpriteUsage [iObj]==0 ? "None" : "Static");
  1895. /*************/
  1896. }
  1898. // warping accuracy
  1899. nextValidLine (pfPara, pnLine);
  1900. for (iObj = 0; iObj < nVO; iObj++) {
  1901. if (fscanf (pfPara, "%d", &rguiWarpingAccuracy [iObj]) != 1) {
  1902. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1903. fatal_error("Conversion aborted");
  1904. }
  1905. if (rguiSpriteUsage [iObj] != 0)
  1906. my_assert (rguiWarpingAccuracy [iObj] == 0 || rguiWarpingAccuracy [iObj] == 1 || rguiWarpingAccuracy [iObj] == 2 || rguiWarpingAccuracy [iObj] == 3);
  1907. /*************/
  1908. fprintf(pfOut, "Sprite.WarpAccuracy [%d] = "1/%d"n", iObj, 1<<(rguiWarpingAccuracy [iObj]+1));
  1909. /*************/
  1910. }
  1912. // number of points
  1913. nextValidLine (pfPara, pnLine);
  1914. for (iObj = 0; iObj < nVO; iObj++) {
  1915. if (fscanf (pfPara, "%d", &rgiNumPnts [iObj]) != 1) {
  1916. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1917. fatal_error("Conversion aborted");
  1918. }
  1919. if (rgbScalability [iObj] == TRUE)
  1920. my_assert (rgiNumPnts [iObj] == -1);
  1921. if (rguiSpriteUsage [iObj] == 1) 
  1922. my_assert (rgiNumPnts [iObj] == 0 ||
  1923. rgiNumPnts [iObj] == 1 ||
  1924. rgiNumPnts [iObj] == 2 ||
  1925. rgiNumPnts [iObj] == 3 ||
  1926. rgiNumPnts [iObj] == 4);
  1927. /*************/
  1928. fprintf(pfOut, "Sprite.Points [%d] = %dn", iObj, rgiNumPnts [iObj]);
  1929. /*************/
  1930. }
  1932. // sprite directory
  1933. pchSptDir = new char [256];
  1934. nextValidLine (pfPara, pnLine);
  1935. fscanf (pfPara, "%100s", pchSptDir);
  1937. // point directory
  1938. pchSptPntDir = new char [256];
  1939. nextValidLine (pfPara, pnLine);
  1940. fscanf (pfPara, "%100s", pchSptPntDir);
  1942. /*************/
  1943. fprintf(pfOut, "Sprite.Directory = "%s"n", pchSptDir);
  1944. fprintf(pfOut, "Sprite.Points.Directory = "%s"n", pchSptPntDir);
  1945. /*************/
  1947. //  sprite reconstruction mode, i.e. Low-latency-sprite-enable
  1948. nextValidLine (pfPara, pnLine);
  1949. for (iObj = 0; iObj < nVO; iObj++)
  1950. {
  1951. UInt uiSptMode;
  1952. if (fscanf (pfPara, "%d", &uiSptMode) != 1) {
  1953. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1954. fatal_error("Conversion aborted");
  1955. }
  1956. else {
  1957. my_assert (uiSptMode == 0 || uiSptMode == 1 );
  1958. rgSpriteMode[iObj] = (SptMode) uiSptMode;
  1959. }
  1960. /*************/
  1961. fprintf(pfOut, "Sprite.Mode [%d] = "%s"n", iObj,
  1962. uiSptMode==0 ? "Basic" : (uiSptMode==1 ? "LowLatency" : (uiSptMode==2 ? "PieceObject" : "PieceUpdate")));
  1963. /*************/
  1964. }
  1966. fclose(pfPara);
  1967. if(argc==3)
  1968. fclose(pfOut);
  1970. for (Int iLayer = BASE_LAYER; iLayer <= ENHN_LAYER; iLayer++) {
  1971. delete [] rguiRateControl [iLayer];
  1972. delete [] rguiBitsBudget [iLayer];
  1973. delete [] rgbErrorResilientDisable [iLayer];
  1974. delete [] rgbDataPartitioning [iLayer];
  1975. delete [] rgbReversibleVlc [iLayer];
  1976. delete [] rgiVPBitTh [iLayer];
  1978. // for texture coding
  1979. delete [] rgfQuant [iLayer];
  1980. delete [] rgiIntraDCSwitchingThr [iLayer];
  1981. delete [] rgiIStep [iLayer]; // error signal quantization stepsize
  1982. delete [] rgiPStep [iLayer]; // error signal quantization stepsize
  1983. delete [] rgiIStepAlpha [iLayer]; // error signal quantization stepsize
  1984. delete [] rgiPStepAlpha [iLayer]; // error signal quantization stepsize
  1985. delete [] rgiBStepAlpha [iLayer];
  1986. delete [] rgbNoGrayQuantUpdate [iLayer]; //discouple change of gray quant with tex. quant
  1987. delete [] rgiStepBCode [iLayer]; // error signal quantization stepsize
  1988. delete [] rgbLoadIntraMatrix [iLayer];
  1989. delete [] rgbLoadInterMatrix [iLayer];
  1990. delete [] rgbLoadIntraMatrixAlpha [iLayer];
  1991. delete [] rgbLoadInterMatrixAlpha [iLayer];
  1992. for (iObj = 0; iObj < nVO; iObj++) {
  1993. delete [] rgppiIntraQuantizerMatrix  [iLayer] [iObj];
  1994. delete [] rgppiInterQuantizerMatrix  [iLayer] [iObj];
  1995. delete [] rgppiIntraQuantizerMatrixAlpha  [iLayer] [iObj];
  1996. delete [] rgppiInterQuantizerMatrixAlpha  [iLayer] [iObj];
  1997. if(pchMVFileName [iLayer] [iObj]!=NULL)
  1998. delete [] pchMVFileName [iLayer] [iObj];
  2000. }
  2001. delete [] rgppiIntraQuantizerMatrix [iLayer];
  2002. delete [] rgppiInterQuantizerMatrix [iLayer];
  2003. delete [] rgppiIntraQuantizerMatrixAlpha [iLayer];
  2004. delete [] rgppiInterQuantizerMatrixAlpha [iLayer];
  2005. delete [] pchMVFileName [iLayer];
  2007. // for motion esti.
  2008. delete [] rgbOriginalME [iLayer];
  2009. delete [] rgbAdvPredDisable [iLayer];
  2010. delete [] rguiSearchRange [iLayer];
  2012. // for interlace coding
  2013. delete [] rgbInterlacedCoding [iLayer];
  2014. delete [] rgbTopFieldFirst [iLayer];
  2015. delete [] rgiDirectModeRadius [iLayer];
  2016. delete [] rgiMVFileUsage [iLayer];
  2018. delete [] rgdFrameFrequency [iLayer];
  2019. delete [] rgbAlternateScan [iLayer];
  2022. delete [] rgbComplexityEstimationDisable [iLayer];
  2023. delete [] rgbOpaque [iLayer];
  2024. delete [] rgbTransparent [iLayer];
  2025. delete [] rgbIntraCAE [iLayer];
  2026. delete [] rgbInterCAE [iLayer];
  2027. delete [] rgbNoUpdate [iLayer];
  2028. delete [] rgbUpsampling [iLayer];
  2029. delete [] rgbIntraBlocks [iLayer];
  2030. delete [] rgbInterBlocks [iLayer];
  2031. delete [] rgbInter4vBlocks [iLayer];
  2032. delete [] rgbNotCodedBlocks [iLayer];
  2033. delete [] rgbDCTCoefs [iLayer];
  2034. delete [] rgbDCTLines [iLayer];
  2035. delete [] rgbVLCSymbols [iLayer];
  2036. delete [] rgbVLCBits [iLayer];
  2037. delete [] rgbAPM [iLayer];
  2038. delete [] rgbNPM [iLayer];
  2039. delete [] rgbInterpolateMCQ [iLayer];
  2040. delete [] rgbForwBackMCQ [iLayer];
  2041. delete [] rgbHalfpel2 [iLayer];
  2042. delete [] rgbHalfpel4 [iLayer];
  2044. delete [] rguiVolControlParameters [iLayer];
  2045. delete [] rguiChromaFormat [iLayer];
  2046. delete [] rguiLowDelay [iLayer];
  2047. delete [] rguiVBVParams [iLayer];
  2048. delete [] rguiBitRate [iLayer];
  2049. delete [] rguiVbvBufferSize [iLayer];
  2050. delete [] rguiVbvBufferOccupany [iLayer];
  2051. }
  2053. delete [] rgbScalability;
  2054.     delete [] rgbSpatialScalability;
  2055. delete [] rgiTemporalScalabilityType;
  2056. delete [] rgiEnhancementType;
  2058. // for mask coding, should fill in later on
  2059. delete [] rgfAlphaUsage; // alpha usage for each VO.  0: binary, 1: 8-bit
  2060. delete [] rgbShapeOnly;
  2061. delete [] rgiBinaryAlphaTH;
  2062. delete [] rgiBinaryAlphaRR; // Added for error resilient mode by Toshiba(1997-11-14)
  2063. delete [] rgbNoCrChange;
  2065. delete [] rgbDeblockFilterDisable;
  2066. delete [] rgfChrType;
  2067. delete [] rgiNumBbetweenPVOP; // no of B-VOPs between P-VOPs
  2068. delete [] rgiNumPbetweenIVOP; // no of P-VOPs between I-VOPs
  2069. //added to encode GOV header by SONY 980212
  2070. delete [] rgiGOVperiod;
  2071. //980212
  2072. delete [] rgiTSRate;
  2073. delete [] rgiEnhcTSRate; // added by Norio Ito
  2074. delete [] rgbAllowSkippedPMBs;
  2076. // rounding control
  2077. delete [] rgbRoundingControlDisable;
  2078. delete [] rgiInitialRoundingType;
  2080. // sprite
  2081. delete [] rguiSpriteUsage;
  2082. delete [] rguiWarpingAccuracy;
  2083. delete [] rgiNumPnts;
  2084. delete [] rgbDumpMB;
  2085. delete [] rgbTrace;
  2086. delete [] rgSpriteMode;
  2088. delete pchPrefix;
  2089. delete pchBmpDir;
  2090. delete pchOutBmpDir;
  2091. delete pchOutStrFile;
  2092. delete pchSptDir;
  2093. delete pchSptPntDir;
  2095. return 0;
  2096. }
  2099. Void nextValidLine (FILE *pfPara, UInt* pnLine) {
  2101. Int chBoL = 0;
  2102. Char pchPlaceHolder[200];
  2103. fgets (pchPlaceHolder, 200, pfPara); // get the next line 
  2104. (*pnLine)++;
  2105. while (feof (pfPara) == 0 && (chBoL = fgetc(pfPara)) == '%') {
  2106. // skip a line
  2107. fgets (pchPlaceHolder, 200, pfPara); // get the next line 
  2108. (*pnLine)++;
  2109. }
  2110. ungetc (chBoL, pfPara);
  2112. }
  2114. ///// WAVELET VTC: end ///////////////////////////////
  2116. Void readBoolVOLFlag (Bool * rgbTable [2], UInt nVO, FILE * pfCfg, UInt * pnLine, Bool bAnyScalability)
  2117. {
  2118. nextValidLine (pfCfg, pnLine);
  2119. for (UInt i = 0; i < nVO; ++i) {
  2120. if (fscanf (pfCfg, "%d", & rgbTable [BASE_LAYER] [i]) != 1) {
  2121. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  2122. fatal_error("Conversion aborted");
  2123. }
  2124. my_assert (rgbTable [BASE_LAYER] [i] == 0 || rgbTable [BASE_LAYER] [i] == 1);
  2125. }
  2126. if (bAnyScalability) {
  2127. for (UInt i = 0; i < nVO; ++i) {
  2128. if (fscanf (pfCfg, "%d", & rgbTable [ENHN_LAYER] [i]) != 1) {
  2129. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  2130. fatal_error("Conversion aborted");
  2131. }
  2132. my_assert (rgbTable [ENHN_LAYER] [i] == 0 || rgbTable [ENHN_LAYER] [i] == 1);
  2133. }
  2134. }
  2135. }
  2137. Void readItem(UInt *rguiTable [2], UInt nVO, FILE * pfCfg, UInt * pnLine, Bool bAnyScalability)
  2138. {
  2139. nextValidLine (pfCfg, pnLine);
  2140. for (UInt i = 0; i < nVO; ++i) {
  2141. if (fscanf (pfCfg, "%d", & rguiTable [BASE_LAYER] [i]) != 1) {
  2142. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  2143. fatal_error("Conversion aborted");
  2144. }
  2145. }
  2146. if (bAnyScalability) 
  2147. {
  2148. for (UInt i = 0; i < nVO; ++i) {
  2149. if (fscanf (pfCfg, "%d", & rguiTable [ENHN_LAYER] [i]) != 1) {
  2150. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  2151. fatal_error("Conversion aborted");
  2152. }
  2153. }
  2154. }
  2155. }
  2157. Void fatal_error(char *pchError, Bool bFlag)
  2158. {
  2159. if(bFlag)
  2160. return;
  2162. fprintf(stderr, "Error: %sn", pchError);
  2163. exit(1);
  2164. }