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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

encoder.cpp：源码内容
  1. /*************************************************************************
  3. This software module was originally developed by 
  5. Ming-Chieh Lee (mingcl@microsoft.com), Microsoft Corporation
  6. Wei-ge Chen (wchen@microsoft.com), Microsoft Corporation
  7. Bruce Lin (blin@microsoft.com), Microsoft Corporation
  8. Chuang Gu (chuanggu@microsoft.com), Microsoft Corporation
  9. Simon Winder (swinder@microsoft.com), Microsoft Corporation
  10. (date: March, 1996)
  12. and edited by
  14. Hiroyuki Katata (katata@imgsl.mkhar.sharp.co.jp), Sharp Corporation
  15. Norio Ito (norio@imgsl.mkhar.sharp.co.jp), Sharp Corporation
  16. Shuichi Watanabe (watanabe@imgsl.mkhar.sharp.co.jp), Sharp Corporation
  17. (date: October, 1997)
  19. and also edited by
  20. Xuemin Chen (xchen@nlvl.com). Next Level Systems, Inc.
  21. Bob Eifrig (beifrig@nlvl.com) Next Level Systems, Inc.
  23. and also edited by
  24. Wei Wu (weiwu@stallion.risc.rockwell.com) Rockwell Science Center
  26. and also edited by
  27. Yoshihiro Kikuchi (TOSHIBA CORPORATION)
  28. Takeshi Nagai (TOSHIBA CORPORATION)
  29. Toshiaki Watanabe (TOSHIBA CORPORATION)
  30. Noboru Yamaguchi (TOSHIBA CORPORATION)
  32.     Marc Mongenet (Marc.Mongenet@epfl.ch), Swiss Federal Institute of Technology, Lausanne (EPFL)
  34. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  35. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  36. as specified by the MPEG-4 Video. 
  37. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  38. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  39. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
  40. The original developer of this software module and his/her company, 
  41. the subsequent editors and their companies, 
  42. and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
  43. Copyright is not released for non MPEG-4 Video conforming products. 
  44. Sharp retains full right to use the code for his/her own purpose, 
  45. assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
  46. This copyright notice must be included in all copies or derivative works. 
  48. Copyright (c) 1997.
  50. Module Name:
  52. encoder.cpp
  54. Abstract:
  56. caller for encoder
  58. Revision History:
  60. May 9, 1999: tm5 rate control by DemoGraFX, duhoff@mediaone.net
  62. *************************************************************************/
  65. #include <stdio.h>
  66. #include <stdlib.h>
  68. #ifdef __PC_COMPILER_
  69. #include <windows.h>
  70. #include <mmsystem.h>
  71. #endif // __PC_COMPILER_
  73. #include "typeapi.h"
  74. #include "codehead.h"
  75. #include "paramset.h"
  77. #include "mode.hpp"
  78. #include "tm5rc.hpp"
  79. #include "fstream.h"
  80. #include "sesenc.hpp"
  81. // #include "encoder/tps_sesenc.hpp" // deleted by Sharp (98/2/12)
  83. ///// WAVELET VTC: begin ////////////////////////////////
  84. #include "dataStruct.hpp"     // hjlee 
  85. ///// WAVELET VTC: end ////////////////////////////////
  88. #ifndef __GLOBAL_VAR_
  89. #define __GLOBAL_VAR_
  90. #endif
  91. #include "global.hpp"
  93. #ifdef __MFC_
  94. #ifdef _DEBUG
  95. #undef THIS_FILE
  96. static char BASED_CODE THIS_FILE[] = __FILE__;
  97. #endif
  99. #define new DEBUG_NEW    
  100. #endif // __MFC_
  102. #define _FOR_GSSP_
  104. #ifdef _FOR_GSSP_
  105. Int rgiDefaultIntraQMatrixAlpha [BLOCK_SQUARE_SIZE] = {
  106. 8,  17, 18, 19, 21, 23, 25, 27,
  107. 17, 18, 19, 21, 23, 25, 27, 28,
  108. 20, 21, 22, 23, 24, 26, 28, 30,
  109. 21, 22, 23, 24, 26, 28, 30, 32,
  110. 22, 23, 24, 26, 28, 30, 32, 35,
  111. 23, 24, 26, 28, 30, 32, 35, 38,
  112. 25, 26, 28, 30, 32, 35, 38, 41,
  113. 27, 28, 30, 32, 35, 38, 41, 45
  114. };
  115. Int rgiDefaultInterQMatrixAlpha [BLOCK_SQUARE_SIZE] = {
  116. 16, 17, 18, 19, 20, 21, 22, 23,
  117. 17, 18, 19, 20, 21, 22, 23, 24,
  118. 18, 19, 20, 21, 22, 23, 24, 25,
  119. 19, 20, 21, 22, 23, 24, 26, 27,
  120. 20, 21, 22, 23, 25, 26, 27, 28,
  121. 21, 22, 23, 24, 26, 27, 28, 30,
  122. 22, 23, 24, 26, 27, 28, 30, 31,
  123. 23, 24, 25, 27, 28, 30, 31, 33
  124. };
  125. #else
  126. Int rgiDefaultIntraQMatrixAlpha [BLOCK_SQUARE_SIZE] = {
  127. 16, 16, 16, 16, 16, 16, 16, 16,
  128. 16, 16, 16, 16, 16, 16, 16, 16,
  129. 16, 16, 16, 16, 16, 16, 16, 16,
  130. 16, 16, 16, 16, 16, 16, 16, 16,
  131. 16, 16, 16, 16, 16, 16, 16, 16,
  132. 16, 16, 16, 16, 16, 16, 16, 16,
  133. 16, 16, 16, 16, 16, 16, 16, 16,
  134. 16, 16, 16, 16, 16, 16, 16, 16
  135. };
  136. Int rgiDefaultInterQMatrixAlpha [BLOCK_SQUARE_SIZE] = {
  137. 16, 16, 16, 16, 16, 16, 16, 16,
  138. 16, 16, 16, 16, 16, 16, 16, 16,
  139. 16, 16, 16, 16, 16, 16, 16, 16,
  140. 16, 16, 16, 16, 16, 16, 16, 16,
  141. 16, 16, 16, 16, 16, 16, 16, 16,
  142. 16, 16, 16, 16, 16, 16, 16, 16,
  143. 16, 16, 16, 16, 16, 16, 16, 16,
  144. 16, 16, 16, 16, 16, 16, 16, 16
  145. };
  146. #endif
  148. Void nextValidLine (FILE *pfPara, UInt* pnLine);
  149. ///// WAVELET VTC: begin ////////////////////////////////
  150. Void readVTCParam(CVTCEncoder *pvtcenc, FILE *pfPara, UInt* pnLine);
  151. ///// WAVELET VTC: end ////////////////////////////////
  152. Void readBoolVOLFlag (Bool * rgbTable [2], UInt nVO, FILE * pfCfg, UInt * pnLine, Bool bAnyScalability);
  153. Void readItem(UInt *rguiTable [2], UInt nVO, FILE * pfCfg, UInt * pnLine, Bool bAnyScalability);
  154. Void RunVTCCodec(char *VTCCtlFile);
  155. Void GetIVal(CxParamSet *pPar, char *pchName, Int iInd, Int *piRtn);
  156. Void GetDVal(CxParamSet *pPar, char *pchName, Int iInd, Double *pdRtn);
  157. Void GetSVal(CxParamSet *pPar, char *pchName, Int iInd, char **ppchRtn);
  158. Void GetAVal(CxParamSet *pPar, char *pchName, Int iInd, Double **ppdRtn, Int *piCount);
  159. Void readBoolParam(CxParamSet *pPar, char *pchName, Int iInd, Bool *pbVal);
  161. Int bPrint = 0;
  163. #define VERSION_STRING "FDIS 1.02 (990812)"
  164. // please update version number when you
  165. // make changes in the following
  167. #define BASE_LAYER 0
  168. #define ENHN_LAYER 1
  169. #define NO_SCALABILITY  0
  170. #define TEMPORAL_SCALABILITY 1
  171. #define SPATIAL_SCALABILITY  2
  173. int main (int argc, Char* argv[])
  174. {
  175. UInt nLine = 1;
  176. UInt* pnLine = &nLine;
  177. FILE *pfPara;
  179. if (argc != 2) {
  180. printf ("Usage: %s parameter_filen       %s -version", argv [0], argv[0]);
  181. exit (1);
  182. }
  183. if(argv[1][0]=='-' && argv[1][1]=='v')
  184. {
  185. printf("Microsoft MPEG-4 Visual CODEC %sn",VERSION_STRING);
  186. exit(0);
  187. }
  189. if ((pfPara = fopen (argv[1], "r")) == NULL ){
  190. printf ("Parameter File Not Foundn");
  191. exit (1);
  192. }
  195. // all the parameters to the encoder
  196. Int iVersion;
  197. Int iVTCFlag;
  198. UInt uiFrmWidth, uiFrmHeight;
  199. UInt firstFrm, lastFrm;
  200. Bool bNot8Bit;
  201. UInt uiQuantPrecision;
  202. UInt nBits;
  203. UInt firstVO, lastVO;
  204. UInt nVO = 0;
  205. UInt uiFrmWidth_SS,uiFrmHeight_SS;
  206. UInt uiHor_sampling_m,uiHor_sampling_n;
  207. UInt uiVer_sampling_m,uiVer_sampling_n;
  208. Bool bAnyScalability = FALSE;
  209. Int iSpatialOption;
  210. char *pchPrefix;
  211. char *pchBmpDir;
  212. char *pchOutBmpDir;
  213. char *pchOutStrFile;
  214. char *pchSptDir;
  215. char *pchSptPntDir;
  217. Int *rgiTemporalScalabilityType;
  218. Bool *rgbSpatialScalability;
  219. Bool *rgbScalability;
  220. Int *rgiEnhancementType;
  221. AlphaUsage *rgfAlphaUsage;
  222. Bool *rgbShapeOnly;
  223. Int *rgiBinaryAlphaTH;
  224. Int *rgbNoCrChange;
  225. Int *rgiBinaryAlphaRR;
  226. Bool *rgbRoundingControlDisable;
  227. Int *rgiInitialRoundingType;
  228. Int *rgiNumPbetweenIVOP;
  229. Int *rgiNumBbetweenPVOP;
  230. Int *rgiGOVperiod;
  231. Bool *rgbDeblockFilterDisable;
  232. Int *rgiTSRate;
  233. Int *rgiEnhcTSRate;
  234. ChromType *rgfChrType;
  235. Bool *rgbAllowSkippedPMBs;
  236. SptMode *rgSpriteMode;
  237. Bool *rgbDumpMB;
  238. Bool *rgbTrace;
  239. UInt *rguiSpriteUsage; 
  240. UInt *rguiWarpingAccuracy; 
  241. Int *rgiNumPnts;
  243. UInt *rguiRateControl [2];
  244. UInt *rguiBitsBudget [2];
  245. Bool *rgbAdvPredDisable [2];
  246. Bool *rgbErrorResilientDisable [2];
  247. Bool *rgbDataPartitioning [2];
  248. Bool *rgbReversibleVlc [2];
  249. Int *rgiVPBitTh [2];
  250. Bool *rgbInterlacedCoding [2];
  251. Quantizer* rgfQuant [2];
  252. Bool *rgbLoadIntraMatrix [2];
  253. Int **rgppiIntraQuantizerMatrix [2];
  254. Bool *rgbLoadInterMatrix [2];
  255. Int **rgppiInterQuantizerMatrix [2];
  256. Bool *rgiIntraDCSwitchingThr [2];
  257. Int *rgiIStep [2];
  258. Int *rgiPStep [2];
  259. Int *rgiStepBCode [2];
  260. Bool *rgbLoadIntraMatrixAlpha [2];
  261. Int **rgppiIntraQuantizerMatrixAlpha [2];
  262. Bool *rgbLoadInterMatrixAlpha [2];
  263. Int **rgppiInterQuantizerMatrixAlpha [2];
  264. Int *rgiIStepAlpha [2];
  265. Int *rgiPStepAlpha [2];
  266. Int *rgiBStepAlpha [2];
  267. Bool *rgbNoGrayQuantUpdate [2];
  268. UInt *rguiSearchRange [2];
  269. Bool *rgbOriginalME [2];
  270. Bool *rgbComplexityEstimationDisable [2];
  271. Bool *rgbOpaque [2];
  272. Bool *rgbTransparent [2];
  273. Bool *rgbIntraCAE [2];
  274. Bool *rgbInterCAE [2];
  275. Bool *rgbNoUpdate [2];
  276. Bool *rgbUpsampling [2];
  277. Bool *rgbIntraBlocks [2];
  278. Bool *rgbInterBlocks [2];
  279. Bool *rgbInter4vBlocks [2];
  280. Bool *rgbNotCodedBlocks [2];
  281. Bool *rgbDCTCoefs [2];
  282. Bool *rgbDCTLines [2];
  283. Bool *rgbVLCSymbols [2];
  284. Bool *rgbVLCBits [2];
  285. Bool *rgbAPM [2];
  286. Bool *rgbNPM [2];
  287. Bool *rgbInterpolateMCQ [2];
  288. Bool *rgbForwBackMCQ [2];
  289. Bool *rgbHalfpel2 [2];
  290. Bool *rgbHalfpel4 [2];
  291. UInt *rguiVolControlParameters[2];
  292. UInt *rguiChromaFormat[2];
  293. UInt *rguiLowDelay[2];
  294. UInt *rguiVBVParams[2];
  295. UInt *rguiBitRate[2];
  296. UInt *rguiVbvBufferSize[2];
  297. UInt *rguiVbvBufferOccupany[2];
  298. Double *rgdFrameFrequency[2];
  299. Bool *rgbTopFieldFirst [2];
  300. Bool *rgbAlternateScan [2];
  301. Int *rgiDirectModeRadius [2];
  302. Int *rgiMVFileUsage[2];
  303. char **pchMVFileName[2];
  305. UInt iObj;
  307. Int iCh = getc(pfPara);
  308. if(iCh=='!')
  309. {
  310. // NEW STYLE PARAMETER FILE
  311. printf("New style parameter file.n");
  312. CxParamSet par;
  314. char rgBuf[80];
  315. char *pch = fgets(rgBuf, 79, pfPara);
  316. if(pch==NULL)
  317. fatal_error("Can't read magic number in parameter file");
  318. //if(strcmp("!!MS!!!n", rgBuf)!=0)
  319. // fatal_error("Bad magic number at start of parameter file");
  321. int iLine;
  322. int er = par.Load(pfPara, &iLine);
  323. if(er!=ERES_OK)
  324. exit(printf("error %d at line %d of parameter filen",er, iLine));
  326. fclose(pfPara);
  328. // process the parameters
  329. GetIVal(&par, "Version", -1, &iVersion);
  330. if(iVersion!=901)
  331. fatal_error("Incorrect parameter file version number for this compilation");
  333. GetIVal(&par, "VTC.Enable", -1, &iVTCFlag);
  334. if(iVTCFlag)
  335. {
  336. char *VTCCtlFile;
  337. GetSVal(&par, "VTC.Filename", -1, &VTCCtlFile);
  338. RunVTCCodec(VTCCtlFile);
  339. return 0;
  340. }
  342. GetIVal(&par, "Source.Width", -1, (Int *)&uiFrmWidth);
  343. GetIVal(&par, "Source.Height", -1, (Int *)&uiFrmHeight);
  344. GetIVal(&par, "Source.FirstFrame", -1, (Int *)&firstFrm);
  345. GetIVal(&par, "Source.LastFrame", -1, (Int *)&lastFrm);
  347. fatal_error("Last frame number cannot be smaller than first frame number", lastFrm >= firstFrm);
  349. GetIVal(&par, "Source.BitsPerPel", -1, (Int *)&nBits);
  350. readBoolParam(&par, "Not8Bit.Enable", -1, &bNot8Bit);
  351. GetIVal(&par, "Not8Bit.QuantPrecision", -1, (Int *)&uiQuantPrecision);
  353. if(bNot8Bit)
  354. fatal_error("When Not8Bit is enabled, the __NBIT_ compile flag must be used.", sizeof(PixelC)!=sizeof(char));
  355. else
  356. fatal_error("When Not8Bit is disabled, the __NBIT_ compile flag must not be used.", sizeof(PixelC)==sizeof(char));
  358. if(bNot8Bit==0)
  359. {
  360. uiQuantPrecision = 5;
  361. nBits = 8;
  362. }
  364. fatal_error("Number of bits per pel is out of range", nBits>=4 && nBits<=12);
  366. Int iLen;
  368. char *pchTmp;
  369. GetSVal(&par, "Source.FilePrefix", -1, &pchTmp);
  370. iLen = strlen(pchTmp) + 1;
  371. pchPrefix = new char [iLen];
  372. memcpy(pchPrefix, pchTmp, iLen);
  374. GetSVal(&par, "Source.Directory", -1, &pchTmp);
  375. iLen = strlen(pchTmp) + 1;
  376. pchBmpDir = new char [iLen];
  377. memcpy(pchBmpDir, pchTmp, iLen);
  379. GetSVal(&par, "Output.Directory.DecodedFrames", -1, &pchTmp);
  380. iLen = strlen(pchTmp) + 1;
  381. pchOutBmpDir = new char [iLen];
  382. memcpy(pchOutBmpDir, pchTmp, iLen);
  384. GetSVal(&par, "Output.Directory.Bitstream", -1, &pchTmp);
  385. iLen = strlen(pchTmp) + 1;
  386. pchOutStrFile = new char [iLen];
  387. memcpy(pchOutStrFile, pchTmp, iLen);
  389. GetSVal(&par, "Sprite.Directory", -1, &pchTmp);
  390. iLen = strlen(pchTmp) + 1;
  391. pchSptDir = new char [iLen];
  392. memcpy(pchSptDir, pchTmp, iLen);
  394. GetSVal(&par, "Sprite.Points.Directory", -1, &pchTmp);
  395. iLen = strlen(pchTmp) + 1;
  396. pchSptPntDir = new char [iLen];
  397. memcpy(pchSptPntDir, pchTmp, iLen);
  399. GetIVal(&par, "Source.ObjectIndex.First", -1, (Int *)&firstVO);
  400. GetIVal(&par, "Source.ObjectIndex.Last", -1, (Int *)&lastVO);
  402. fatal_error("First and last object indices don't make sense", lastVO>=firstVO);
  403. nVO = lastVO - firstVO + 1;
  405. // allocate per-vo parameters
  406. rgiTemporalScalabilityType = new Int [nVO];
  407. rgbSpatialScalability = new Bool [nVO];
  408. rgbScalability = new Bool [nVO];
  409. rgiEnhancementType = new Int [nVO];
  410. rgfAlphaUsage = new AlphaUsage [nVO];
  411. rgbShapeOnly = new Bool [nVO];
  412. rgiBinaryAlphaTH = new Int [nVO];
  413. rgbNoCrChange = new Bool [nVO];
  414. rgiBinaryAlphaRR = new Int [nVO];
  415. rgbRoundingControlDisable = new Bool [nVO];
  416. rgiInitialRoundingType = new Int [nVO];
  417. rgiNumPbetweenIVOP = new Int [nVO];
  418. rgiNumBbetweenPVOP = new Int [nVO];
  419. rgiGOVperiod = new Int [nVO];
  420. rgbDeblockFilterDisable = new Bool [nVO];
  421. rgiTSRate = new Int [nVO];
  422. rgiEnhcTSRate = new Int [nVO];
  423. rgfChrType = new ChromType [nVO];
  424. rgbAllowSkippedPMBs = new Bool [nVO];
  425. rgSpriteMode = new SptMode [nVO];
  426. rgbDumpMB = new Bool [nVO];
  427. rgbTrace = new Bool [nVO];
  428. rguiSpriteUsage = new UInt [nVO]; 
  429. rguiWarpingAccuracy = new UInt [nVO]; 
  430. rgiNumPnts = new Int [nVO]; 
  433. Int iL;
  434. for(iL = BASE_LAYER; iL<=ENHN_LAYER; iL++)
  435. {
  436. // allocate per-layer parameters
  437. rguiRateControl [iL] = new UInt [nVO];
  438. rguiBitsBudget [iL] = new UInt [nVO];
  439. rgbAdvPredDisable [iL] = new Bool [nVO];
  440. rgbErrorResilientDisable [iL] = new Bool [nVO];
  441. rgbDataPartitioning [iL] = new Bool [nVO];
  442. rgbReversibleVlc [iL] = new Bool [nVO];
  443. rgiVPBitTh [iL] = new Int [nVO];
  444. rgbInterlacedCoding [iL] = new Bool [nVO];
  445. rgfQuant [iL] = new Quantizer [nVO]; 
  446. rgbLoadIntraMatrix [iL] = new Bool [nVO];
  447. rgppiIntraQuantizerMatrix [iL] = new Int * [nVO];
  448. rgbLoadInterMatrix [iL] = new Bool [nVO];
  449. rgppiInterQuantizerMatrix [iL] = new Int * [nVO];
  450. rgiIntraDCSwitchingThr [iL] = new Int [nVO]; 
  451. rgiIStep [iL] = new Int [nVO]; 
  452. rgiPStep [iL] = new Int [nVO]; 
  453. rgiStepBCode [iL] = new Int [nVO]; 
  454. rgbLoadIntraMatrixAlpha [iL] = new Bool [nVO]; 
  455. rgppiIntraQuantizerMatrixAlpha [iL] = new Int * [nVO];
  456. rgbLoadInterMatrixAlpha [iL] = new Bool [nVO]; 
  457. rgppiInterQuantizerMatrixAlpha [iL] = new Int * [nVO];
  458. rgiIStepAlpha [iL] = new Int [nVO]; 
  459. rgiPStepAlpha [iL] = new Int [nVO]; 
  460. rgiBStepAlpha [iL] = new Int [nVO]; 
  461. rgbNoGrayQuantUpdate [iL] = new Bool [nVO];
  462. rguiSearchRange [iL] = new UInt [nVO];
  463. rgbOriginalME [iL] = new Bool [nVO];
  464. rgbComplexityEstimationDisable [iL] = new Bool [nVO];
  465. rgbOpaque [iL] = new Bool [nVO];
  466. rgbTransparent [iL] = new Bool [nVO];
  467. rgbIntraCAE [iL] = new Bool [nVO];
  468. rgbInterCAE [iL] = new Bool [nVO];
  469. rgbNoUpdate [iL] = new Bool [nVO];
  470. rgbUpsampling [iL] = new Bool [nVO];
  471. rgbIntraBlocks [iL] = new Bool [nVO];
  472. rgbInterBlocks [iL] = new Bool [nVO];
  473. rgbInter4vBlocks [iL] = new Bool [nVO];
  474. rgbNotCodedBlocks [iL] = new Bool [nVO];
  475. rgbDCTCoefs [iL] = new Bool [nVO];
  476. rgbDCTLines [iL] = new Bool [nVO];
  477. rgbVLCSymbols [iL] = new Bool [nVO];
  478. rgbVLCBits [iL] = new Bool [nVO];
  479. rgbAPM [iL] = new Bool [nVO];
  480. rgbNPM [iL] = new Bool [nVO];
  481. rgbInterpolateMCQ [iL] = new Bool [nVO];
  482. rgbForwBackMCQ [iL] = new Bool [nVO];
  483. rgbHalfpel2 [iL] = new Bool [nVO];
  484. rgbHalfpel4 [iL] = new Bool [nVO];
  485. rguiVolControlParameters [iL] = new UInt [nVO];
  486. rguiChromaFormat [iL] = new UInt [nVO];
  487. rguiLowDelay [iL] = new UInt [nVO];
  488. rguiVBVParams [iL] = new UInt [nVO];
  489. rguiBitRate [iL] = new UInt [nVO];
  490. rguiVbvBufferSize [iL] = new UInt [nVO];
  491. rguiVbvBufferOccupany [iL] = new UInt [nVO];
  492. rgdFrameFrequency [iL] = new Double [nVO];
  493. rgbTopFieldFirst [iL] = new Bool [nVO]; 
  494. rgbAlternateScan [iL] = new Bool [nVO]; 
  495. rgiDirectModeRadius [iL] = new Bool [nVO]; 
  496. rgiMVFileUsage[iL] = new Int [nVO];
  497. pchMVFileName[iL] = new char * [nVO];
  498. }
  500. for (iObj = 0; iObj < nVO; iObj++)
  501. {
  502. // per object alloc
  503. rgppiIntraQuantizerMatrix [BASE_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  504. rgppiIntraQuantizerMatrix [ENHN_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  505. rgppiInterQuantizerMatrix [BASE_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  506. rgppiInterQuantizerMatrix [ENHN_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  507. rgppiIntraQuantizerMatrixAlpha [BASE_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  508. rgppiIntraQuantizerMatrixAlpha [ENHN_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  509. rgppiInterQuantizerMatrixAlpha [BASE_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  510. rgppiInterQuantizerMatrixAlpha [ENHN_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  511. pchMVFileName[BASE_LAYER] [iObj] = NULL;
  512. pchMVFileName[ENHN_LAYER] [iObj] = NULL;
  514. // per object parameters
  515. GetSVal(&par, "Scalability", iObj, &pchTmp);
  516. if(strcmp(pchTmp, "Temporal")==0)
  517. {
  518. bAnyScalability = TRUE;
  519. rgbScalability[iObj] = TEMPORAL_SCALABILITY;
  521. }
  522. else if(strcmp(pchTmp, "Spatial")==0)
  523. {
  524. bAnyScalability = TRUE;
  525. rgbScalability[iObj] = SPATIAL_SCALABILITY;
  526. }
  527. else if(strcmp(pchTmp, "None")==0)
  528. {
  529. bAnyScalability = FALSE;
  530. rgbScalability[iObj] = NO_SCALABILITY;
  531. }
  532. else
  533. fatal_error("Unknown scalability type");
  535. if(rgbScalability[iObj] == SPATIAL_SCALABILITY || rgbScalability[iObj] == TEMPORAL_SCALABILITY)
  536. rgbSpatialScalability[iObj] = TRUE; 
  537. else 
  538. rgbSpatialScalability[iObj] = FALSE; 
  539. }
  541. //coded added by Sony, only deals with ONE VO.
  542. //Type option of Spatial Scalable Coding
  543. //This parameter is used for dicision VOP prediction types of Enhancement layer in Spatial Scalable Coding
  544. //If this option is set to 0, Enhancement layer is coded as "PPPPPP......",
  545. //else if set to 1 ,It's coded as "PBBBB......."
  547. if(rgbScalability[0] == SPATIAL_SCALABILITY)
  548. {
  549. fatal_error("Spatial scalability currently only works with one VO", nVO==1);
  551. GetSVal(&par, "Scalability.Spatial.PredictionType", 0, &pchTmp);
  552. if(strcmp(pchTmp, "PPP")==0)
  553. iSpatialOption = 1;
  554. else if(strcmp(pchTmp, "PBB")==0)
  555. iSpatialOption = 0;
  556. else
  557. fatal_error("Unknown spatial scalability prediction type");
  559. if (iSpatialOption == 1)
  560. fprintf(stdout,"Enhancement layer is coded as "PPPPP....."n");
  561. else
  562. fprintf(stdout,"Enhancement layer is coded as "PBBBB....."n");
  563. }
  565. if(bAnyScalability)
  566. {
  567. //Load enhancement layer (Spatial Scalable) size
  568. // should really be inside above if-statement
  569. GetIVal(&par, "Scalability.Spatial.Width", 0, (Int *)&uiFrmWidth_SS);
  570. GetIVal(&par, "Scalability.Spatial.Height", 0, (Int *)&uiFrmHeight_SS);
  572. //load upsampling factor 
  573. GetIVal(&par, "Scalability.Spatial.HorizFactor.N", 0, (Int *)&uiHor_sampling_n);
  574. GetIVal(&par, "Scalability.Spatial.HorizFactor.M", 0, (Int *)&uiHor_sampling_m);
  575. GetIVal(&par, "Scalability.Spatial.VertFactor.N", 0, (Int *)&uiVer_sampling_n);
  576. GetIVal(&par, "Scalability.Spatial.VertFactor.M", 0, (Int *)&uiVer_sampling_m);
  577. }
  579. for (iObj = 0; iObj < nVO; iObj++)
  580. {
  581. if(bAnyScalability)
  582. {
  583. // temporal scalability
  584. // form of temporal scalability indicators
  585. // case 0  Enhn    P   P   ....
  586. //         Base  I   P   P ....
  587. // case 1  Enhn    B B   B B   ....
  588. //         Base  I     P     P ....
  589. // case 2  Enhn    P   B   B   ....
  590. //         Base  I   B   P   B ....
  591. GetIVal(&par, "Scalability.Temporal.PredictionType", iObj, &rgiTemporalScalabilityType [iObj]);
  592. fatal_error("Scalability.Temporal.PredictionType must range from 0 to 4",
  593. rgiTemporalScalabilityType [iObj]>=0 && rgiTemporalScalabilityType [iObj]<=4);
  595. GetSVal(&par, "Scalability.Temporal.EnhancementType", iObj, &pchTmp);
  596. if(strcmp(pchTmp, "Full")==0)
  597. rgiEnhancementType [iObj] = 0;
  598. else if(strcmp(pchTmp, "PartC")==0)
  599. rgiEnhancementType [iObj] = 1;
  600. else if(strcmp(pchTmp, "PartNC")==0)
  601. rgiEnhancementType [iObj] = 2;
  602. else
  603. fatal_error("Unknown temporal scalability enhancement type");
  604. }
  606. // alpha usage
  607. GetSVal(&par, "Alpha.Type", iObj, &pchTmp);
  608. rgbShapeOnly[iObj] = FALSE;
  609. if(strcmp(pchTmp, "None")==0)
  610. rgfAlphaUsage[iObj] = RECTANGLE;
  611. else if(strcmp(pchTmp, "Binary")==0)
  612. rgfAlphaUsage[iObj] = ONE_BIT;
  613. else if(strcmp(pchTmp, "Gray")==0)
  614. rgfAlphaUsage[iObj] = EIGHT_BIT;
  615. else if(strcmp(pchTmp, "ShapeOnly")==0)
  616. {
  617. rgbShapeOnly[iObj] = TRUE;
  618. rgfAlphaUsage[iObj] = ONE_BIT;
  619. }
  620. else
  621. fatal_error("Unknown alpha type");
  623. GetIVal(&par, "Alpha.Binary.RoundingThreshold", iObj, &rgiBinaryAlphaTH [iObj]);
  624. fatal_error("Binary rounding threshold must be >= 0", rgiBinaryAlphaTH [iObj] >= 0);
  627. Bool bSizeConvEnable;
  628. readBoolParam(&par, "Alpha.Binary.SizeConversion.Enable", iObj, &bSizeConvEnable);
  629. rgbNoCrChange [iObj] = !bSizeConvEnable;
  630. if (rgiBinaryAlphaTH [iObj] == 0 && rgbNoCrChange [iObj] == 0)
  631. {
  632. printf("Size conversion was disabled since binary rounding threshold is zero");
  633. rgbNoCrChange [iObj] = TRUE;
  634. }
  636. GetIVal(&par, "ErrorResil.AlphaRefreshRate", iObj, &rgiBinaryAlphaRR [iObj]);
  637. fatal_error("Alpha refresh rate must be >= 0", rgiBinaryAlphaRR [iObj] >= 0);
  639. Bool bRoundingControlEnable;
  640. readBoolParam(&par, "Motion.RoundingControl.Enable", iObj, &bRoundingControlEnable);
  641. rgbRoundingControlDisable [iObj] = !bRoundingControlEnable;
  643. GetIVal(&par, "Motion.RoundingControl.StartValue", iObj, &rgiInitialRoundingType [iObj]);
  644. fatal_error("Rounding control start value must be either 0 or 1",
  645. rgiInitialRoundingType [iObj]==0 || rgiInitialRoundingType [iObj]==1);
  647. GetIVal(&par, "Motion.PBetweenICount", iObj, &rgiNumPbetweenIVOP [iObj]);
  648. if(rgiNumPbetweenIVOP [iObj] < 0)
  649. rgiNumPbetweenIVOP [iObj] = lastFrm - firstFrm + 1; //only 1 I at the beginning
  651. GetIVal(&par, "Motion.BBetweenPCount", iObj, &rgiNumBbetweenPVOP [iObj]);
  652. fatal_error("Motion.BBetweenPCount must be >= 0", rgiNumBbetweenPVOP [iObj]>=0);
  654. //number of VOP between GOV header
  655. //CAUTION:GOV period is not used in spatial scalable coding
  656. Bool bGOVEnable;
  657. readBoolParam(&par, "GOV.Enable", iObj, &bGOVEnable);
  658. if(!bGOVEnable)
  659. rgiGOVperiod[iObj] = 0;
  660. else
  661. GetIVal(&par, "GOV.Period", iObj, &rgiGOVperiod[iObj]);
  663. Bool bDeblockingFilterEnable;
  664. readBoolParam(&par, "Motion.DeblockingFilter.Enable", iObj, &bDeblockingFilterEnable);
  665. rgbDeblockFilterDisable[iObj] = !bDeblockingFilterEnable;
  667. GetSVal(&par, "Source.Format", iObj, &pchTmp);
  668. if(strcmp(pchTmp, "444")==0)
  669. rgfChrType[iObj] = FOUR_FOUR_FOUR;
  670. else if(strcmp(pchTmp, "422")==0)
  671. rgfChrType[iObj] = FOUR_TWO_TWO;
  672. else if(strcmp(pchTmp, "420")==0)
  673. rgfChrType[iObj] = FOUR_TWO_ZERO;
  674. else
  675. fatal_error("Unrecognised source format");
  677. GetSVal(&par, "Sprite.Type", iObj, &pchTmp);
  678. if(strcmp(pchTmp, "None")==0)
  679. rguiSpriteUsage[iObj] = 0;
  680. else if(strcmp(pchTmp, "Static")==0)
  681. rguiSpriteUsage[iObj] = 1;
  682. else
  683. fatal_error("Unknown value for Sprite.Type");
  684. if (rgbScalability [iObj] == TRUE && rguiSpriteUsage[iObj]==1)
  685. fatal_error("Sprite and scalability modes cannot be combined");
  687. GetSVal(&par, "Sprite.WarpAccuracy", iObj, &pchTmp);
  688. if(strcmp(pchTmp, "1/2")==0)
  689. rguiWarpingAccuracy[iObj] = 0;
  690. else if(strcmp(pchTmp, "1/4")==0)
  691. rguiWarpingAccuracy[iObj] = 1;
  692. else if(strcmp(pchTmp, "1/8")==0)
  693. rguiWarpingAccuracy[iObj] = 2;
  694. else if(strcmp(pchTmp, "1/16")==0)
  695. rguiWarpingAccuracy[iObj] = 3;
  696. else
  697. fatal_error("Unknown value for Sprite.WarpAccuracy");
  699. GetIVal(&par, "Sprite.Points", iObj, &rgiNumPnts[iObj]);
  700. fatal_error("Sprite.Points must lie in the range -1 to 4", rgiNumPnts[iObj]>=-1 && rgiNumPnts[iObj]<5);
  702. GetSVal(&par, "Sprite.Mode", iObj, &pchTmp);
  703. if(strcmp(pchTmp, "Basic")==0)
  704. rgSpriteMode[iObj] = BASIC_SPRITE;
  705. else if(strcmp(pchTmp, "LowLatency")==0)
  706. rgSpriteMode[iObj] = LOW_LATENCY;
  707. else if(strcmp(pchTmp, "PieceObject")==0)
  708. rgSpriteMode[iObj] = PIECE_OBJECT;
  709. else if(strcmp(pchTmp, "PieceUpdate")==0)
  710. rgSpriteMode[iObj] = PIECE_UPDATE;
  711. else
  712. fatal_error("Unkown value for Sprite.Mode");
  714. if(rguiSpriteUsage[iObj]==0)
  715. {
  716. rgiNumPnts[iObj] = -1;
  717. //rgSpriteMode[iObj] = -1;
  718. }
  720. readBoolParam(&par, "Trace.CreateFile.Enable", iObj, &rgbTrace[iObj]);
  721. readBoolParam(&par, "Trace.DetailedDump.Enable", iObj, &rgbDumpMB[iObj]);
  723. #ifndef __TRACE_AND_STATS_
  724. if(rgbTrace[iObj])
  725. {
  726. printf("Warning: this encoder will not generate trace information.n");
  727. printf("If you want trace information, re-compile with __TRACE_AND_STATS_ defined.n");
  728. }
  729. #endif
  731. readBoolParam(&par, "Motion.SkippedMB.Enable", iObj, &rgbAllowSkippedPMBs[iObj]);
  733. // parameters that can be different for each scalability layer
  734. Int iLayer, iLayerCount;
  735. if(rgbScalability[iObj]!=NO_SCALABILITY)
  736. iLayerCount = 2;
  737. else
  738. iLayerCount = 1;
  740. for(iLayer = 0; iLayer<iLayerCount; iLayer++)
  741. {
  742. Int iLayerObj = iObj + iLayer * nVO;
  744. // rate control
  745. GetSVal(&par, "RateControl.Type", iLayerObj, &pchTmp);
  746. if(strcmp(pchTmp, "None")==0)
  747. rguiRateControl [iLayer][iObj] = 0;
  748. else if(strcmp(pchTmp, "MP4")==0)
  749. rguiRateControl [iLayer][iObj] = RC_MPEG4;
  750. else if(strcmp(pchTmp, "TM5")==0)
  751. rguiRateControl [iLayer][iObj] = RC_TM5;
  752. else
  753. fatal_error("Unknown rate control type");
  755. // bit budget
  756. GetIVal(&par, "RateControl.BitsPerVOP", iLayerObj, (Int *)&(rguiBitsBudget[iLayer][iObj]));
  758. Bool bRVLCEnable, bDPEnable, bVPEnable;
  759. readBoolParam(&par, "ErrorResil.RVLC.Enable", iLayerObj, &bRVLCEnable);
  760. readBoolParam(&par, "ErrorResil.DataPartition.Enable", iLayerObj, &bDPEnable);
  761. readBoolParam(&par, "ErrorResil.VideoPacket.Enable", iLayerObj, &bVPEnable);
  763. rgbErrorResilientDisable [iLayer][iObj] = bVPEnable ? (iLayer!=0) : TRUE;
  764. rgbReversibleVlc [iLayer] [iObj] = bRVLCEnable ? (iLayer==0) : FALSE;
  765. rgbDataPartitioning [iLayer][iObj] = bDPEnable ? (iLayer==0) : FALSE;
  767. if(rgbErrorResilientDisable [BASE_LAYER][iObj])
  768. rgiBinaryAlphaRR [iObj] = -1;
  770. GetIVal(&par, "ErrorResil.VideoPacket.Length", iLayerObj, &rgiVPBitTh[iLayer][iObj]);
  771. if(rgbErrorResilientDisable [iLayer][iObj])
  772. rgiVPBitTh [iLayer][iObj] = -1;
  774. readBoolParam(&par, "Motion.Interlaced.Enable", iLayerObj, &rgbInterlacedCoding [iLayer][iObj]);
  776. GetSVal(&par, "Quant.Type", iLayerObj, &pchTmp);
  777. if(strcmp(pchTmp, "H263")==0)
  778. rgfQuant[iLayer][iObj] = Q_H263;
  779. else if(strcmp(pchTmp, "MPEG")==0)
  780. rgfQuant[iLayer][iObj] = Q_MPEG;
  781. else
  782. fatal_error("Unknown quantizer type");
  784. readBoolParam(&par, "Texture.QuantMatrix.Intra.Enable", iLayerObj, &rgbLoadIntraMatrix [iLayer][iObj]);
  785. if(rgbLoadIntraMatrix [iLayer][iObj])
  786. {
  787. Double *pdTmp;
  788. Int iCount;
  789. GetAVal(&par, "Texture.QuantMatrix.Intra", iLayerObj, &pdTmp, &iCount);
  790. fatal_error("Wrong number of intra quant matrix values (should be 64)", iCount<=64);
  791. Int i;
  792. for(i=0; i<iCount; i++)
  793. rgppiIntraQuantizerMatrix[iLayer][iObj][i] = (Int)pdTmp[i];
  794. if(iCount<64)
  795. rgppiIntraQuantizerMatrix[iLayer][iObj][iCount] = 0;
  796. }
  797. else
  798. memcpy (rgppiIntraQuantizerMatrix [iLayer][iObj], rgiDefaultIntraQMatrix, BLOCK_SQUARE_SIZE * sizeof(Int));
  800. readBoolParam(&par, "Texture.QuantMatrix.Inter.Enable", iLayerObj, &rgbLoadInterMatrix [iLayer][iObj]);
  801. if(rgbLoadInterMatrix [iLayer][iObj])
  802. {
  803. Double *pdTmp;
  804. Int iCount;
  805. GetAVal(&par, "Texture.QuantMatrix.Inter", iLayerObj, &pdTmp, &iCount);
  806. fatal_error("Wrong number of inter quant matrix values (should be 64)", iCount<=64);
  807. Int i;
  808. for(i=0; i<iCount; i++)
  809. rgppiInterQuantizerMatrix[iLayer][iObj][i] = (Int)pdTmp[i];
  810. if(iCount<64)
  811. rgppiInterQuantizerMatrix[iLayer][iObj][iCount] = 0;
  812. }
  813. else
  814. memcpy (rgppiInterQuantizerMatrix [iLayer][iObj], rgiDefaultInterQMatrix, BLOCK_SQUARE_SIZE * sizeof(Int));
  816. GetIVal(&par, "Texture.IntraDCThreshold", iLayerObj, &rgiIntraDCSwitchingThr [iLayer] [iObj]);
  817. fatal_error("Intra DC Threshold must be in range 0 - 7",
  818. rgiIntraDCSwitchingThr [iLayer] [iObj] >= 0 && rgiIntraDCSwitchingThr [iLayer] [iObj] <= 7);
  820. GetIVal(&par, "Texture.QuantStep.IVOP", iLayerObj, &rgiIStep [iLayer] [iObj]);
  821. fatal_error("IVOP quantizer stepsize is out of range", 
  822. rgiIStep [iLayer] [iObj] > 0 && rgiIStep [iLayer] [iObj] < (1<<uiQuantPrecision));
  824. GetIVal(&par, "Texture.QuantStep.PVOP", iLayerObj, &rgiPStep [iLayer] [iObj]);
  825. fatal_error("PVOP quantizer stepsize is out of range", 
  826. rgiPStep [iLayer] [iObj] > 0 && rgiPStep [iLayer] [iObj] < (1<<uiQuantPrecision));
  828. GetIVal(&par, "Texture.QuantStep.BVOP", iLayerObj, &rgiStepBCode [iLayer] [iObj]);
  829. fatal_error("BVOP quantizer stepsize is out of range", 
  830. rgiStepBCode [iLayer] [iObj] > 0 && rgiStepBCode [iLayer] [iObj] < (1<<uiQuantPrecision));
  832. readBoolParam(&par, "Alpha.QuantMatrix.Intra.Enable", iLayerObj, &rgbLoadIntraMatrixAlpha [iLayer][iObj]);
  833. if(rgbLoadIntraMatrixAlpha [iLayer][iObj])
  834. {
  835. Double *pdTmp;
  836. Int iCount;
  837. GetAVal(&par, "Alpha.QuantMatrix.Intra", iLayerObj, &pdTmp, &iCount);
  838. fatal_error("Wrong number of alpha intra quant matrix values (should be 64)", iCount<=64);
  839. Int i;
  840. for(i=0; i<iCount; i++)
  841. rgppiIntraQuantizerMatrixAlpha[iLayer][iObj][i] = (Int)pdTmp[i];
  842. if(iCount<64)
  843. rgppiIntraQuantizerMatrixAlpha[iLayer][iObj][iCount] = 0;
  844. }
  845. else
  846. memcpy (rgppiIntraQuantizerMatrixAlpha [iLayer][iObj], rgiDefaultIntraQMatrixAlpha,
  847. BLOCK_SQUARE_SIZE * sizeof(Int));
  849. readBoolParam(&par, "Alpha.QuantMatrix.Inter.Enable", iLayerObj, &rgbLoadInterMatrixAlpha [iLayer][iObj]);
  850. if(rgbLoadInterMatrixAlpha [iLayer][iObj])
  851. {
  852. Double *pdTmp;
  853. Int iCount;
  854. GetAVal(&par, "Alpha.QuantMatrix.Inter", iLayerObj, &pdTmp, &iCount);
  855. fatal_error("Wrong number of alpha inter quant matrix values (should be 64)", iCount<=64);
  856. Int i;
  857. for(i=0; i<iCount; i++)
  858. rgppiInterQuantizerMatrixAlpha[iLayer][iObj][i] = (Int)pdTmp[i];
  859. if(iCount<64)
  860. rgppiInterQuantizerMatrixAlpha[iLayer][iObj][iCount] = 0;
  861. }
  862. else
  863. memcpy (rgppiInterQuantizerMatrixAlpha [iLayer][iObj], rgiDefaultInterQMatrixAlpha,
  864. BLOCK_SQUARE_SIZE * sizeof(Int));
  866. GetIVal(&par, "Alpha.QuantStep.IVOP", iLayerObj, &rgiIStepAlpha [iLayer] [iObj]);
  867. fatal_error("IVOP alpha quantizer stepsize is out of range", 
  868. rgiIStepAlpha [iLayer] [iObj] > 0 && rgiIStepAlpha [iLayer] [iObj] < 64);
  870. GetIVal(&par, "Alpha.QuantStep.PVOP", iLayerObj, &rgiPStepAlpha [iLayer] [iObj]);
  871. fatal_error("PVOP alpha quantizer stepsize is out of range", 
  872. rgiPStepAlpha [iLayer] [iObj] > 0 && rgiPStepAlpha [iLayer] [iObj] < 64);
  874. GetIVal(&par, "Alpha.QuantStep.BVOP", iLayerObj, &rgiBStepAlpha [iLayer] [iObj]);
  875. fatal_error("BVOP alpha quantizer stepsize is out of range", 
  876. rgiBStepAlpha [iLayer] [iObj] > 0 && rgiBStepAlpha [iLayer] [iObj] < 64);
  878. readBoolParam(&par, "Alpha.QuantDecouple.Enable", iLayerObj, &rgbNoGrayQuantUpdate [iLayer] [iObj]);
  880. Int iRate;
  881. GetIVal(&par, "Source.SamplingRate", iLayerObj, &iRate);
  882. fatal_error("Source sampling rate must be > 0", iRate>0);
  883. if(iLayer==BASE_LAYER)
  884. rgiTSRate[iObj] = iRate;
  885. else
  886. rgiEnhcTSRate[iObj] = iRate;
  888. GetIVal(&par, "Motion.SearchRange", iLayerObj, (Int *)&rguiSearchRange[iLayer][iObj]);
  889. fatal_error("Motion.SearchRange must be > 0", rguiSearchRange[iLayer][iObj]>0);
  891. readBoolParam(&par, "Motion.UseSourceForME.Enable", iLayerObj, &rgbOriginalME [iLayer] [iObj]);
  893. Bool bAdvPredEnable;
  894. readBoolParam(&par, "Motion.AdvancedPrediction.Enable", iLayerObj, &bAdvPredEnable);
  895. rgbAdvPredDisable [iLayer][iObj] = !bAdvPredEnable;
  897. Bool bComplexityEnable;
  898. readBoolParam(&par, "Complexity.Enable", iLayerObj, &bComplexityEnable);
  899. rgbComplexityEstimationDisable[iLayer][iObj] = !bComplexityEnable;
  901. if(bComplexityEnable)
  902. {
  903. readBoolParam(&par, "Complexity.Opaque.Enable", iLayerObj, &rgbOpaque[iLayer][iObj]);
  904. readBoolParam(&par, "Complexity.Transparent.Enable", iLayerObj, &rgbTransparent[iLayer][iObj]);
  905. readBoolParam(&par, "Complexity.IntraCAE.Enable", iLayerObj, &rgbIntraCAE[iLayer][iObj]);
  906. readBoolParam(&par, "Complexity.InterCAE.Enable", iLayerObj, &rgbInterCAE[iLayer][iObj]);
  907. readBoolParam(&par, "Complexity.NoUpdate.Enable", iLayerObj, &rgbNoUpdate[iLayer][iObj]);
  908. readBoolParam(&par, "Complexity.UpSampling.Enable", iLayerObj, &rgbUpsampling[iLayer][iObj]);
  909. readBoolParam(&par, "Complexity.IntraBlocks.Enable", iLayerObj, &rgbIntraBlocks[iLayer][iObj]);
  910. readBoolParam(&par, "Complexity.InterBlocks.Enable", iLayerObj, &rgbInterBlocks[iLayer][iObj]);
  911. readBoolParam(&par, "Complexity.Inter4VBlocks.Enable", iLayerObj, &rgbInter4vBlocks[iLayer][iObj]);
  912. readBoolParam(&par, "Complexity.NotCodedBlocks.Enable", iLayerObj, &rgbNotCodedBlocks[iLayer][iObj]);
  913. readBoolParam(&par, "Complexity.DCTCoefs.Enable", iLayerObj, &rgbDCTCoefs[iLayer][iObj]);
  914. readBoolParam(&par, "Complexity.DCTLines.Enable", iLayerObj, &rgbDCTLines[iLayer][iObj]);
  915. readBoolParam(&par, "Complexity.VLCSymbols.Enable", iLayerObj, &rgbVLCSymbols[iLayer][iObj]);
  916. readBoolParam(&par, "Complexity.VLCBits.Enable", iLayerObj, &rgbVLCBits[iLayer][iObj]);
  917. readBoolParam(&par, "Complexity.APM.Enable", iLayerObj, &rgbAPM[iLayer][iObj]);
  918. readBoolParam(&par, "Complexity.NPM.Enable", iLayerObj, &rgbNPM[iLayer][iObj]);
  919. readBoolParam(&par, "Complexity.InterpMCQ.Enable", iLayerObj, &rgbInterpolateMCQ[iLayer][iObj]);
  920. readBoolParam(&par, "Complexity.ForwBackMCQ.Enable", iLayerObj, &rgbForwBackMCQ[iLayer][iObj]);
  921. readBoolParam(&par, "Complexity.HalfPel2.Enable", iLayerObj, &rgbHalfpel2[iLayer][iObj]);
  922. readBoolParam(&par, "Complexity.HalfPel4.Enable", iLayerObj, &rgbHalfpel4[iLayer][iObj]);
  923. }
  924. else
  925. {
  926. rgbOpaque[iLayer][iObj] = 0;
  927. rgbTransparent[iLayer][iObj] = 0;
  928. rgbIntraCAE[iLayer][iObj] = 0;
  929. rgbInterCAE[iLayer][iObj] = 0;
  930. rgbNoUpdate[iLayer][iObj] = 0;
  931. rgbUpsampling[iLayer][iObj] = 0;
  932. rgbIntraBlocks[iLayer][iObj] = 0;
  933. rgbInterBlocks[iLayer][iObj] = 0;
  934. rgbInter4vBlocks[iLayer][iObj] = 0;
  935. rgbNotCodedBlocks[iLayer][iObj] = 0;
  936. rgbDCTCoefs[iLayer][iObj] = 0;
  937. rgbDCTLines[iLayer][iObj] = 0;
  938. rgbVLCSymbols[iLayer][iObj] = 0;
  939. rgbVLCBits[iLayer][iObj] = 0;
  940. rgbAPM[iLayer][iObj] = 0;
  941. rgbNPM[iLayer][iObj] = 0;
  942. rgbInterpolateMCQ[iLayer][iObj] = 0;
  943. rgbForwBackMCQ[iLayer][iObj] = 0;
  944. rgbHalfpel2[iLayer][iObj] = 0;
  945. rgbHalfpel4[iLayer][iObj] = 0;
  946. }
  948. GetDVal(&par, "Source.FrameRate", iLayerObj, &rgdFrameFrequency[iLayer][iObj]);
  949. fatal_error("Source.FrameRate is invalid", rgdFrameFrequency[iLayer][iObj] > 0.0);
  951. readBoolParam(&par, "Motion.Interlaced.TopFieldFirst.Enable", iLayerObj, &rgbTopFieldFirst [iLayer] [iObj]);
  953. readBoolParam(&par, "Motion.Interlaced.AlternativeScan.Enable", iLayerObj, &rgbAlternateScan[iLayer][iObj]);
  955. GetIVal(&par, "Motion.SearchRange.DirectMode", iLayerObj, &rgiDirectModeRadius[iLayer][iObj]);
  957. GetSVal(&par, "Motion.ReadWriteMVs", iLayerObj, &pchTmp);
  958. if(strcmp(pchTmp, "Off")==0)
  959. rgiMVFileUsage[iLayer][iObj] = 0;
  960. else if(strcmp(pchTmp, "Read")==0)
  961. rgiMVFileUsage[iLayer][iObj] = 1;
  962. else if(strcmp(pchTmp, "Write")==0)
  963. rgiMVFileUsage[iLayer][iObj] = 2;
  964. else
  965. fatal_error("Unknown mode for Motion.ReadWriteMVs");
  967. if(rgiMVFileUsage[iLayer][iObj]!=0)
  968. {
  969. GetSVal(&par, "Motion.ReadWriteMVs.Filename", iLayerObj, &pchTmp);
  970. iLen = strlen(pchTmp) + 1;
  971. pchMVFileName [iLayer] [iObj] = new char [iLen];
  972. memcpy(pchMVFileName [iLayer] [iObj], pchTmp, iLen);
  973. }
  975. Bool bVolControlEnable;
  976. readBoolParam(&par, "VOLControl.Enable", iLayerObj, &bVolControlEnable);
  977. rguiVolControlParameters[iLayer][iObj] = (UInt)bVolControlEnable;
  979. GetIVal(&par, "VOLControl.ChromaFormat", iLayerObj, (Int *)&rguiChromaFormat[iLayer][iObj]);
  980. GetIVal(&par, "VOLControl.LowDelay", iObj, (Int *)&rguiLowDelay[iLayer][iObj]);
  982. Bool bVBVParams;
  983. readBoolParam(&par, "VOLControl.VBVParams.Enable", iLayerObj, &bVBVParams);
  984. rguiVBVParams[iLayer][iObj] = (UInt)bVBVParams;
  986. GetIVal(&par, "VOLControl.Bitrate", iLayerObj, (Int *)&rguiBitRate[iLayer][iObj]);
  987. GetIVal(&par, "VOLControl.VBVBuffer.Size", iLayerObj, (Int *)&rguiVbvBufferSize[iLayer][iObj]);
  988. GetIVal(&par, "VOLControl.VBVBuffer.Occupancy", iLayerObj, (Int *)&rguiVbvBufferOccupany[iLayer][iObj]);
  989. }
  991. }
  992. }
  993. else
  994. {
  995. // OLD STYLE PARAMETER FILE
  996. ungetc(iCh, pfPara);
  997. printf("Old style parameter file.n");
  999. // verify version number
  1000. nextValidLine (pfPara, pnLine);
  1001. if ( fscanf (pfPara, "%u", &iVersion) != 1 ) {
  1002. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1003. exit(1);
  1004. }
  1006. if (iVersion != 813 && iVersion != 812 && iVersion != 814 && iVersion != 815) {
  1007. // version 812 does not have rounding control flags
  1008. // version 813 does not have VOL control parameters
  1009. // version 814 does not have skipped mb enable
  1010. fprintf(stderr, "wrong parameter file version for %sn",VERSION_STRING);
  1011. exit(1);
  1012. }
  1014. ///// WAVELET VTC: begin ///////////////////////////////
  1015. // sarnoff: wavelet visual texture coding 
  1016. nextValidLine (pfPara, pnLine);
  1017. if ( fscanf (pfPara, "%d", &iVTCFlag) != 1) {
  1018. fprintf(stderr, "wrong parameter VTC flag on line %dn", *pnLine);
  1019. assert (FALSE);
  1020. }
  1021. assert (iVTCFlag==0 || iVTCFlag==1);
  1023. // read VTC control file
  1025. char VTCCtlFile[80];
  1026. nextValidLine (pfPara, pnLine);
  1027. if ( fscanf (pfPara, "%s", VTCCtlFile) != 1) {
  1028. fprintf(stderr, "wrong parameter VTC flag on line %dn", *pnLine);
  1029. assert (FALSE);
  1030. }
  1032. if (iVTCFlag==1) {
  1033. fclose(pfPara);
  1035. RunVTCCodec(VTCCtlFile);
  1036. return 0;
  1037. }
  1039. ///// WAVELET VTC: end ///////////////////////////////
  1043. // frame size code
  1045. nextValidLine (pfPara, pnLine);
  1046. if (fscanf (pfPara, "%u", &uiFrmWidth) != 1) {
  1047. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1048. exit(1);
  1049. }
  1050. nextValidLine (pfPara, pnLine);
  1051. if (fscanf (pfPara, "%u", &uiFrmHeight) != 1) {
  1052. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1053. exit(1);
  1054. }
  1056. // first and last frame number
  1057. nextValidLine (pfPara, pnLine);
  1058. if ( fscanf (pfPara, "%u", &firstFrm) != 1) {
  1059. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1060. exit(1);
  1061. }
  1062. nextValidLine (pfPara, pnLine);
  1063. if ( fscanf (pfPara, "%u", &lastFrm) != 1) {
  1064. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1065. exit(1);
  1066. }
  1067. assert (lastFrm >= firstFrm);
  1069. // NBIT: not 8-bit flag
  1070. nextValidLine (pfPara, pnLine);
  1071. if ( fscanf (pfPara, "%d", &bNot8Bit) != 1) {
  1072. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1073. exit(1);
  1074. }
  1075. assert (bNot8Bit==0 || bNot8Bit==1);
  1076. if(bNot8Bit==1)
  1077. {
  1078. assert(sizeof(PixelC)!=sizeof(unsigned char));
  1079. }
  1080. else
  1081. {
  1082. assert(sizeof(PixelC)==sizeof(unsigned char));
  1083. }
  1085. // NBIT: quant precision
  1086. nextValidLine (pfPara, pnLine);
  1087. if ( fscanf (pfPara, "%d", &uiQuantPrecision) != 1) {
  1088. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1089. exit(1);
  1090. }
  1091. if (bNot8Bit==0) {
  1092. uiQuantPrecision = 5;
  1093. }
  1095. // NBIT: number of bits per pixel
  1096. nextValidLine (pfPara, pnLine);
  1097. if ( fscanf (pfPara, "%d", &nBits) != 1) {
  1098. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1099. exit(1);
  1100. }
  1101. assert (nBits>=4 && nBits<=12);
  1102. if (bNot8Bit==0) {
  1103. nBits = 8;
  1104. }
  1106. // object indexes
  1107. nextValidLine (pfPara, pnLine);
  1108. if ( fscanf (pfPara, "%u", &firstVO) != 1) {
  1109. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1110. exit(1);
  1111. }
  1112. nextValidLine (pfPara, pnLine);
  1113. if ( fscanf (pfPara, "%u", &lastVO) != 1) {
  1114. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1115. exit(1);
  1116. }
  1117. assert (lastVO >= firstVO);
  1118. UInt nVO = lastVO - firstVO + 1;
  1120. // allocate per-vo parameters
  1121. rgiTemporalScalabilityType = new Int [nVO];
  1122. rgbSpatialScalability = new Bool [nVO];
  1123. rgbScalability = new Bool [nVO];
  1124. rgiEnhancementType = new Int [nVO];
  1125. rgfAlphaUsage = new AlphaUsage [nVO];
  1126. rgbShapeOnly = new Bool [nVO];
  1127. rgiBinaryAlphaTH = new Int [nVO];
  1128. rgbNoCrChange = new Bool [nVO];
  1129. rgiBinaryAlphaRR = new Int [nVO];
  1130. rgbRoundingControlDisable = new Bool [nVO];
  1131. rgiInitialRoundingType = new Int [nVO];
  1132. rgiNumPbetweenIVOP = new Int [nVO];
  1133. rgiNumBbetweenPVOP = new Int [nVO];
  1134. rgiGOVperiod = new Int [nVO];
  1135. rgbDeblockFilterDisable = new Bool [nVO];
  1136. rgiTSRate = new Int [nVO];
  1137. rgiEnhcTSRate = new Int [nVO];
  1138. rgfChrType = new ChromType [nVO];
  1139. rgbAllowSkippedPMBs = new Bool [nVO];
  1140. rgSpriteMode = new SptMode [nVO];
  1141. rgbDumpMB = new Bool [nVO];
  1142. rgbTrace = new Bool [nVO];
  1143. rguiSpriteUsage = new UInt [nVO]; 
  1144. rguiWarpingAccuracy = new UInt [nVO]; 
  1145. rgiNumPnts = new Int [nVO]; 
  1148. Int iL;
  1149. for(iL = BASE_LAYER; iL<=ENHN_LAYER; iL++)
  1150. {
  1151. // allocate per-layer parameters
  1152. rguiRateControl [iL] = new UInt [nVO];
  1153. rguiBitsBudget [iL] = new UInt [nVO];
  1154. rgbAdvPredDisable [iL] = new Bool [nVO];
  1155. rgbErrorResilientDisable [iL] = new Bool [nVO];
  1156. rgbDataPartitioning [iL] = new Bool [nVO];
  1157. rgbReversibleVlc [iL] = new Bool [nVO];
  1158. rgiVPBitTh [iL] = new Int [nVO];
  1159. rgbInterlacedCoding [iL] = new Bool [nVO];
  1160. rgfQuant [iL] = new Quantizer [nVO]; 
  1161. rgbLoadIntraMatrix [iL] = new Bool [nVO];
  1162. rgppiIntraQuantizerMatrix [iL] = new Int * [nVO];
  1163. rgbLoadInterMatrix [iL] = new Bool [nVO];
  1164. rgppiInterQuantizerMatrix [iL] = new Int * [nVO];
  1165. rgiIntraDCSwitchingThr [iL] = new Int [nVO]; 
  1166. rgiIStep [iL] = new Int [nVO]; 
  1167. rgiPStep [iL] = new Int [nVO]; 
  1168. rgiStepBCode [iL] = new Int [nVO]; 
  1169. rgbLoadIntraMatrixAlpha [iL] = new Bool [nVO]; 
  1170. rgppiIntraQuantizerMatrixAlpha [iL] = new Int * [nVO];
  1171. rgbLoadInterMatrixAlpha [iL] = new Bool [nVO]; 
  1172. rgppiInterQuantizerMatrixAlpha [iL] = new Int * [nVO];
  1173. rgiIStepAlpha [iL] = new Int [nVO]; 
  1174. rgiPStepAlpha [iL] = new Int [nVO]; 
  1175. rgiBStepAlpha [iL] = new Int [nVO]; 
  1176. rgbNoGrayQuantUpdate [iL] = new Bool [nVO];
  1177. rguiSearchRange [iL] = new UInt [nVO];
  1178. rgbOriginalME [iL] = new Bool [nVO];
  1179. rgbComplexityEstimationDisable [iL] = new Bool [nVO];
  1180. rgbOpaque [iL] = new Bool [nVO];
  1181. rgbTransparent [iL] = new Bool [nVO];
  1182. rgbIntraCAE [iL] = new Bool [nVO];
  1183. rgbInterCAE [iL] = new Bool [nVO];
  1184. rgbNoUpdate [iL] = new Bool [nVO];
  1185. rgbUpsampling [iL] = new Bool [nVO];
  1186. rgbIntraBlocks [iL] = new Bool [nVO];
  1187. rgbInterBlocks [iL] = new Bool [nVO];
  1188. rgbInter4vBlocks [iL] = new Bool [nVO];
  1189. rgbNotCodedBlocks [iL] = new Bool [nVO];
  1190. rgbDCTCoefs [iL] = new Bool [nVO];
  1191. rgbDCTLines [iL] = new Bool [nVO];
  1192. rgbVLCSymbols [iL] = new Bool [nVO];
  1193. rgbVLCBits [iL] = new Bool [nVO];
  1194. rgbAPM [iL] = new Bool [nVO];
  1195. rgbNPM [iL] = new Bool [nVO];
  1196. rgbInterpolateMCQ [iL] = new Bool [nVO];
  1197. rgbForwBackMCQ [iL] = new Bool [nVO];
  1198. rgbHalfpel2 [iL] = new Bool [nVO];
  1199. rgbHalfpel4 [iL] = new Bool [nVO];
  1200. rguiVolControlParameters [iL] = new UInt [nVO];
  1201. rguiChromaFormat [iL] = new UInt [nVO];
  1202. rguiLowDelay [iL] = new UInt [nVO];
  1203. rguiVBVParams [iL] = new UInt [nVO];
  1204. rguiBitRate [iL] = new UInt [nVO];
  1205. rguiVbvBufferSize [iL] = new UInt [nVO];
  1206. rguiVbvBufferOccupany [iL] = new UInt [nVO];
  1207. rgdFrameFrequency [iL] = new Double [nVO];
  1208. rgbTopFieldFirst [iL] = new Bool [nVO]; 
  1209. rgbAlternateScan [iL] = new Bool [nVO]; 
  1210. rgiDirectModeRadius [iL] = new Bool [nVO]; 
  1211. rgiMVFileUsage[iL] = new Int [nVO];
  1212. pchMVFileName[iL] = new char * [nVO];
  1213. }
  1215. for (iObj = 0; iObj < nVO; iObj++)
  1216. {
  1217. // per object alloc
  1218. rgppiIntraQuantizerMatrix [BASE_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  1219. rgppiIntraQuantizerMatrix [ENHN_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  1220. rgppiInterQuantizerMatrix [BASE_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  1221. rgppiInterQuantizerMatrix [ENHN_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  1222. rgppiIntraQuantizerMatrixAlpha [BASE_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  1223. rgppiIntraQuantizerMatrixAlpha [ENHN_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  1224. rgppiInterQuantizerMatrixAlpha [BASE_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  1225. rgppiInterQuantizerMatrixAlpha [ENHN_LAYER] [iObj] = new Int [BLOCK_SQUARE_SIZE];
  1226. }
  1229. //scalability indicators: 1 = temporal, 2 = spatial scalability
  1232. nextValidLine (pfPara, pnLine);
  1233. bAnyScalability = FALSE;
  1234. for (iObj = 0; iObj < nVO; iObj++) {
  1235. if (fscanf (pfPara, "%d", &rgbScalability [iObj]) != 1) {
  1236. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1237. exit (1);
  1238. }
  1239. if (rgbScalability[iObj] == TEMPORAL_SCALABILITY || 
  1240. rgbScalability[iObj] == SPATIAL_SCALABILITY)
  1241. bAnyScalability = TRUE;
  1242. else
  1243. assert (rgbScalability[iObj] == NO_SCALABILITY);
  1244. if(rgbScalability[iObj] == SPATIAL_SCALABILITY || rgbScalability[iObj] == TEMPORAL_SCALABILITY) // modifiedy by Sharp(98/2/12)
  1245. rgbSpatialScalability[iObj] = TRUE; 
  1246. else 
  1247. rgbSpatialScalability[iObj] = FALSE; 
  1248. }
  1250. //coded added by Sony, only deals with ONE VO.
  1251. //Type option of Spatial Scalable Coding
  1252. //This parameter is used for dicision VOP prediction types of Enhancement layer in Spatial Scalable Coding
  1253. //If this option is set to 0, Enhancement layer is coded as "PPPPPP......",
  1254. //else if set to 1 ,It's coded as "PBBBB......."
  1255. nextValidLine(pfPara,pnLine);
  1256. assert (nVO == 1);
  1257. fscanf(pfPara,"%d",&iSpatialOption);
  1258. if(rgbScalability[0] == SPATIAL_SCALABILITY)
  1259. if (iSpatialOption == 1)
  1260. fprintf(stdout,"Enhancement layer is coded as "PPPPP....."n");
  1261. else if (iSpatialOption == 0)
  1262. fprintf(stdout,"Enhancement layer is coded as "PBBBB....."n");
  1263. else {
  1264. fprintf(stderr,"The parameter "SpatialOption" is not set correctlyn");
  1265. exit(1);
  1266. }
  1268. //Load enhancement layer (Spatial Scalable) size
  1269. nextValidLine(pfPara,pnLine);
  1270. fscanf(pfPara,"%d",&uiFrmWidth_SS);
  1271. fscanf(pfPara,"%d",&uiFrmHeight_SS);
  1273. //load upsampling factor 
  1274. nextValidLine(pfPara,pnLine);
  1275. fscanf(pfPara,"%d",&uiHor_sampling_n);
  1276. fscanf(pfPara,"%d",&uiHor_sampling_m);
  1278. nextValidLine(pfPara,pnLine);
  1279. fscanf(pfPara,"%d",&uiVer_sampling_n);
  1280. fscanf(pfPara,"%d",&uiVer_sampling_m);
  1282. // form of temporal scalability indicators
  1283. // case 0  Enhn    P   P   ....
  1284. //         Base  I   P   P ....
  1285. // case 1  Enhn    B B   B B   ....
  1286. //         Base  I     P     P ....
  1287. // case 2  Enhn    P   B   B   ....
  1288. //         Base  I   B   P   B ....
  1289. nextValidLine (pfPara, pnLine);
  1290. for (iObj = 0; iObj < nVO; iObj++) {
  1291. if (fscanf (pfPara, "%d", &rgiTemporalScalabilityType [iObj]) != 1) {
  1292. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1293. exit (1);
  1294. }
  1295. assert (rgiTemporalScalabilityType [iObj] == 0 || 
  1296. rgiTemporalScalabilityType [iObj] == 1 || 
  1297. rgiTemporalScalabilityType [iObj] == 2 ||
  1298. rgiTemporalScalabilityType [iObj] == 3 ||
  1299. rgiTemporalScalabilityType [iObj] == 4);
  1300. }
  1302. // enhancement_type for scalability
  1303. nextValidLine (pfPara, pnLine);
  1304. for (iObj = 0; iObj < nVO; iObj++) {
  1305. if (fscanf (pfPara, "%d", &rgiEnhancementType [iObj]) != 1) {
  1306. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1307. exit (1);
  1308. }
  1309. assert (rgiEnhancementType [iObj] == 0 || //  entire region of the base layer is enhanced
  1310. // begin: modified by Sharp (98/3/24)
  1311. rgiEnhancementType [iObj] == 1 ||  // partial region of the base layer is enhanced (with background composition)
  1312. rgiEnhancementType [iObj] == 2);  // partial region of the base layer is enhanced (without background composition)
  1313. // end: modified by Sharp (98/3/24)
  1314. }
  1316. // rate control flag
  1317. nextValidLine (pfPara, pnLine);
  1318. for (iObj = 0; iObj < nVO; iObj++) {
  1319. if (fscanf (pfPara, "%u", &rguiRateControl [BASE_LAYER] [iObj] ) != 1) {
  1320. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1321. exit (1);
  1322. }
  1323. assert (rguiRateControl [BASE_LAYER] [iObj]  == RC_MPEG4 || 
  1324. rguiRateControl [BASE_LAYER] [iObj]  == RC_TM5 ||
  1325. rguiRateControl [BASE_LAYER] [iObj]  == 0);
  1326. }
  1327. if (bAnyScalability) {
  1328. for (iObj = 0; iObj < nVO; iObj++) {
  1329. if (fscanf (pfPara, "%u", &rguiRateControl [ENHN_LAYER] [iObj]) != 1) {
  1330. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1331. exit (1);
  1332. }
  1333. assert (rguiRateControl [ENHN_LAYER] [iObj]  == 0 || 
  1334. rguiRateControl [ENHN_LAYER] [iObj]  == RC_MPEG4 ||
  1335. rguiRateControl [ENHN_LAYER] [iObj]  == RC_TM5);
  1336. }
  1337. }
  1339. // bit budget for each object.
  1340. nextValidLine (pfPara, pnLine);
  1341. for (iObj = 0; iObj < nVO; iObj++) {
  1342. if (fscanf (pfPara, "%d", &rguiBitsBudget [BASE_LAYER] [iObj]) != 1) {
  1343. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1344. exit (1);
  1345. }
  1346. }
  1347. if (bAnyScalability) {
  1348. for (iObj = 0; iObj < nVO; iObj++) {
  1349. if (fscanf (pfPara, "%d", &rguiBitsBudget [ENHN_LAYER] [iObj]) != 1) {
  1350. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1351. exit (1);
  1352. }
  1353. assert (rguiBitsBudget [ENHN_LAYER] [iObj]  > 0);
  1354. }
  1355. }
  1358. // alpha usage for each object.  0: rectangle, 1: binary, 2: 8-bit, 3: shape only
  1359. nextValidLine (pfPara, pnLine);
  1360. for (iObj = 0; iObj < nVO; iObj++) {
  1361. UInt uiAlpha;
  1362. if (fscanf (pfPara, "%d", &uiAlpha) != 1) {
  1363. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1364. exit (1);
  1365. }
  1366. else {
  1367. assert (uiAlpha == 0 || uiAlpha == 1 || uiAlpha == 2 || uiAlpha == 3);
  1368. if(uiAlpha<3)
  1369. {
  1370. rgfAlphaUsage [iObj] = (AlphaUsage) uiAlpha;
  1371. rgbShapeOnly [iObj] = FALSE;
  1372. }
  1373. else
  1374. {
  1375. rgfAlphaUsage [iObj] = ONE_BIT;
  1376. rgbShapeOnly [iObj] = TRUE;
  1377. }
  1378. }
  1379. }
  1381. // binary shape rounding para
  1382. nextValidLine (pfPara, pnLine);
  1383. for (iObj = 0; iObj < nVO; iObj++) {
  1384. if (fscanf (pfPara, "%d", &rgiBinaryAlphaTH [iObj]) != 1) {
  1385. fprintf (stderr, "wrong parameter file format on line %dn", *pnLine);
  1386. exit (1);
  1387. }
  1388. assert (rgiBinaryAlphaTH [iObj] >= 0);
  1389. }
  1391. // binary shape size conversion flag
  1392. nextValidLine (pfPara, pnLine);
  1393. for (iObj = 0; iObj < nVO; iObj++) {
  1394. if (fscanf (pfPara, "%d", &rgbNoCrChange [iObj]) != 1) {
  1395. fprintf (stderr, "wrong parameter file format on line %dn", *pnLine);
  1396. exit (1);
  1397. }
  1398. assert (rgbNoCrChange [iObj] == TRUE || rgbNoCrChange [iObj] == FALSE); //boolean value
  1399. if (rgiBinaryAlphaTH [iObj] == 0)
  1400. assert (rgbNoCrChange [iObj] == TRUE); //MB-level size conversion of shape is off in lossless moden");
  1401. }
  1403. // Added for error resilient mode by Toshiba(1997-11-14)
  1404. nextValidLine (pfPara, pnLine);
  1405. for (iObj = 0; iObj < nVO; iObj++) {
  1406. if (fscanf (pfPara, "%d", &rgiBinaryAlphaRR [iObj]) != 1) {
  1407. fprintf (stderr, "wrong parameter file format on line %dn", *pnLine);
  1408. exit (1);
  1409. }
  1410. assert (rgiBinaryAlphaRR [iObj] >= 0);
  1411. }
  1412. // End Toshiba(1997-11-14)
  1414. // rounding control disable
  1415. if(iVersion > 812)
  1416. nextValidLine (pfPara, pnLine);
  1417. for (iObj = 0; iObj < nVO; iObj++) {
  1418. if(iVersion > 812)
  1419. {
  1420. if (fscanf (pfPara, "%d", &rgbRoundingControlDisable [iObj]) != 1) {
  1421. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1422. exit (1);
  1423. }
  1424. }
  1425. else
  1426. rgbRoundingControlDisable [iObj] = 0;
  1427. assert (rgbRoundingControlDisable [iObj]  == 0 || rgbRoundingControlDisable [iObj] == 1);
  1428. }
  1429. if(iVersion > 812)
  1430. nextValidLine (pfPara, pnLine);
  1431. for (iObj = 0; iObj < nVO; iObj++) {
  1432. if(iVersion > 812)
  1433. {
  1434. if (fscanf (pfPara, "%d", &rgiInitialRoundingType [iObj]) != 1) {
  1435. fprintf (stderr, "wrong parameter file format on line %dn", *pnLine);
  1436. exit (1);
  1437. }
  1438. }
  1439. else
  1440. rgiInitialRoundingType [iObj] = 0;
  1441. assert (rgiInitialRoundingType [iObj] == 0 || rgiInitialRoundingType [iObj] == 1);
  1442. }
  1444. // error resilient coding disable
  1445. nextValidLine (pfPara, pnLine);
  1446. Int iErrorResilientFlags;
  1447. for (iObj = 0; iObj < nVO; iObj++) {
  1448. if (fscanf (pfPara, "%d", &iErrorResilientFlags) != 1) {
  1449. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1450. exit (1);
  1451. }
  1452. rgbErrorResilientDisable [BASE_LAYER] [iObj] = iErrorResilientFlags & 0x1;
  1453. // Modified for error resilient mode by Toshiba(1998-1-16)
  1454. rgbDataPartitioning [BASE_LAYER] [iObj]  = (iErrorResilientFlags & 0x2) ? TRUE : FALSE;
  1455. rgbReversibleVlc [BASE_LAYER] [iObj]  = (iErrorResilientFlags & 0x4) ? TRUE : FALSE;
  1456. // End Toshiba(1998-1-16)
  1457. if( rgbErrorResilientDisable [BASE_LAYER] [iObj])
  1458. rgiBinaryAlphaRR [iObj] = -1;
  1459. }
  1460. if (bAnyScalability) {
  1461. for (iObj = 0; iObj < nVO; iObj++) {
  1462. if (fscanf (pfPara, "%d", &rgbErrorResilientDisable [ENHN_LAYER] [iObj]) != 1) {
  1463. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1464. exit (1);
  1465. }
  1466. assert (rgbErrorResilientDisable [ENHN_LAYER] [iObj] == TRUE); //error resilient coding not supported as for now
  1467. rgbErrorResilientDisable [ENHN_LAYER] [iObj] = TRUE;
  1468. rgbDataPartitioning [ENHN_LAYER] [iObj] = FALSE;
  1469. rgbReversibleVlc [ENHN_LAYER] [iObj] = FALSE;
  1470. }
  1471. }
  1473. // Bit threshold for video packet spacing control
  1474. nextValidLine (pfPara, pnLine);
  1475. for (iObj = 0; iObj < nVO; iObj++) {
  1476. if (fscanf (pfPara, "%d", &rgiVPBitTh [BASE_LAYER] [iObj]) != 1) {
  1477. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1478. exit (1);
  1479. }
  1480. if (rgbErrorResilientDisable [BASE_LAYER] [iObj])
  1481. rgiVPBitTh [BASE_LAYER] [iObj] = -1; // set VPBitTh to negative value
  1482. }
  1483. if (bAnyScalability) {
  1484. for (iObj = 0; iObj < nVO; iObj++) {
  1485. if (fscanf (pfPara, "%d", &rgiVPBitTh [ENHN_LAYER] [iObj]) != 1) {
  1486. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1487. exit (1);
  1488. }
  1489. rgiVPBitTh [ENHN_LAYER] [iObj] = -1;
  1490. }
  1491. }
  1493. // Interlaced coding
  1494. nextValidLine (pfPara, pnLine);
  1495. for (iObj = 0; iObj < nVO; iObj++) {
  1496. if (fscanf (pfPara, "%d", &rgbInterlacedCoding [BASE_LAYER] [iObj]) != 1) {
  1497. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1498. exit (1);
  1499. }
  1500. assert (rgbInterlacedCoding [BASE_LAYER] [iObj] == 0 || rgbInterlacedCoding [BASE_LAYER] [iObj] == 1);
  1501. }
  1502. if (bAnyScalability) {
  1503. for (iObj = 0; iObj < nVO; iObj++) {
  1504. if (fscanf (pfPara, "%d", &rgbInterlacedCoding [ENHN_LAYER] [iObj]) != 1) {
  1505. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1506. exit (1);
  1507. }
  1508. assert (rgbInterlacedCoding [ENHN_LAYER] [iObj] == 0 || rgbInterlacedCoding [ENHN_LAYER] [iObj] == 1);
  1509. }
  1510. }
  1512. // quantizer selection: 0 -- H.263, 1 -- MPEG
  1513. nextValidLine (pfPara, pnLine);
  1514. for (iObj = 0; iObj < nVO; iObj++) {
  1515.   int read;
  1516.   if (fscanf (pfPara, "%d", &read) != 1) { 
  1518. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1519. exit (1);
  1520. }
  1521.   rgfQuant [BASE_LAYER] [iObj] = (Quantizer)read;
  1522.   assert (rgfQuant [BASE_LAYER] [iObj] ==0 || rgfQuant [BASE_LAYER] [iObj] == 1);
  1523. }
  1524. if (bAnyScalability) {
  1525. for (iObj = 0; iObj < nVO; iObj++) {
  1526.   int read;
  1527.   if (fscanf (pfPara, "%d", &read) != 1) {
  1528. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1529. exit (1);
  1530.   }
  1531.   rgfQuant [ENHN_LAYER] [iObj] = (Quantizer)read;
  1532. assert (rgfQuant [ENHN_LAYER] [iObj] ==0 || rgfQuant [ENHN_LAYER] [iObj] == 1);
  1533. }
  1534. }
  1536. // load non-default intra Q-Matrix, 0 -- FALSE, 1 -- TRUE
  1537. nextValidLine (pfPara, pnLine);
  1538. for (iObj = 0; iObj < nVO; iObj++) {
  1539. if (fscanf (pfPara, "%d", &rgbLoadIntraMatrix [BASE_LAYER] [iObj]) != 1) {
  1540. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1541. exit (1);
  1542. }
  1543. assert (rgbLoadIntraMatrix [BASE_LAYER] [iObj] ==0 || 
  1544. rgbLoadIntraMatrix [BASE_LAYER] [iObj] == 1);
  1545. if (rgbLoadIntraMatrix [BASE_LAYER] [iObj]) {
  1546. UInt i = 0;
  1547. do {
  1548. if (fscanf (pfPara, "%d", &rgppiIntraQuantizerMatrix [BASE_LAYER] [iObj] [i]) != 1) {
  1549. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1550. exit (1);
  1551. }
  1552. } while (rgppiIntraQuantizerMatrix [BASE_LAYER] [iObj] [i] != 0 && ++i < BLOCK_SQUARE_SIZE);
  1553. }
  1554. else
  1555. memcpy (rgppiIntraQuantizerMatrix [BASE_LAYER] [iObj], rgiDefaultIntraQMatrix, BLOCK_SQUARE_SIZE * sizeof (Int));
  1556. }
  1557. if (bAnyScalability) {
  1558. for (iObj = 0; iObj < nVO; iObj++) {
  1559. if (fscanf (pfPara, "%d", &rgbLoadIntraMatrix [ENHN_LAYER] [iObj]) != 1) {
  1560. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1561. exit (1);
  1562. }
  1563. assert (rgbLoadIntraMatrix [ENHN_LAYER] [iObj] ==0 || 
  1564. rgbLoadIntraMatrix [ENHN_LAYER] [iObj] == 1);
  1565. if (rgbLoadIntraMatrix [ENHN_LAYER] [iObj]) {
  1566. UInt i = 0;
  1567. do {
  1568. if (fscanf (pfPara, "%d", &rgppiIntraQuantizerMatrix [ENHN_LAYER] [iObj] [i]) != 1) {
  1569. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1570. exit (1);
  1571. }
  1572. } while (rgppiIntraQuantizerMatrix [ENHN_LAYER] [iObj] [i] != 0 && ++i < BLOCK_SQUARE_SIZE);
  1573. }
  1574. else
  1575. memcpy (rgppiIntraQuantizerMatrix [ENHN_LAYER] [iObj], rgiDefaultIntraQMatrix, BLOCK_SQUARE_SIZE * sizeof (Int));
  1576. }
  1577. }
  1579. // load non-default inter Q-Matrix, 0 -- FALSE, 1 -- TRUE
  1580. nextValidLine (pfPara, pnLine);
  1581. for (iObj = 0; iObj < nVO; iObj++) {
  1582. if (fscanf (pfPara, "%d", &rgbLoadInterMatrix [BASE_LAYER] [iObj]) != 1) {
  1583. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1584. exit (1);
  1585. }
  1586. assert (rgbLoadInterMatrix [BASE_LAYER] [iObj] ==0 || 
  1587. rgbLoadInterMatrix [BASE_LAYER] [iObj] == 1);
  1588. if (rgbLoadInterMatrix [BASE_LAYER] [iObj]) {
  1589. UInt i = 0;
  1590. do {
  1591. if (fscanf (pfPara, "%d", &rgppiInterQuantizerMatrix [BASE_LAYER] [iObj] [i]) != 1) {
  1592. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1593. exit (1);
  1594. }
  1595. } while (rgppiInterQuantizerMatrix [BASE_LAYER] [iObj] [i] != 0 && ++i < BLOCK_SQUARE_SIZE);
  1596. }
  1597. else
  1598. memcpy (rgppiInterQuantizerMatrix [BASE_LAYER] [iObj], rgiDefaultInterQMatrix, BLOCK_SQUARE_SIZE * sizeof (Int));
  1599. }
  1600. if (bAnyScalability) {
  1601. for (iObj = 0; iObj < nVO; iObj++) {
  1602. if (fscanf (pfPara, "%d", &rgbLoadInterMatrix [ENHN_LAYER] [iObj]) != 1) {
  1603. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1604. exit (1);
  1605. }
  1606. assert (rgbLoadInterMatrix [ENHN_LAYER] [iObj] ==0 || 
  1607. rgbLoadInterMatrix [ENHN_LAYER] [iObj] == 1);
  1608. if (rgbLoadInterMatrix [ENHN_LAYER] [iObj]) {
  1609. UInt i = 0;
  1610. do {
  1611. if (fscanf (pfPara, "%d", &rgppiInterQuantizerMatrix [ENHN_LAYER] [iObj] [i]) != 1) {
  1612. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1613. exit (1);
  1614. }
  1615. } while (rgppiInterQuantizerMatrix [ENHN_LAYER] [iObj] [i] != 0 && ++i < BLOCK_SQUARE_SIZE);
  1616. }
  1617. else
  1618. memcpy (rgppiInterQuantizerMatrix [ENHN_LAYER] [iObj], rgiDefaultInterQMatrix, BLOCK_SQUARE_SIZE * sizeof (Int));
  1619. }
  1620. }
  1622. // threhold to code Intra-DC as AC
  1623. nextValidLine (pfPara, pnLine);
  1624. for (iObj = 0; iObj < nVO; iObj++) {
  1625. if (fscanf (pfPara, "%d", &(rgiIntraDCSwitchingThr [BASE_LAYER] [iObj])) != 1) {
  1626. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1627. exit (1);
  1628. }
  1629. assert (rgiIntraDCSwitchingThr [BASE_LAYER] [iObj] >= 0 && 
  1630. rgiIntraDCSwitchingThr [BASE_LAYER] [iObj] <= 7);
  1631. }
  1632. if (bAnyScalability) {
  1633. for (iObj = 0; iObj < nVO; iObj++) {
  1634. if (fscanf (pfPara, "%d", &(rgiIntraDCSwitchingThr [ENHN_LAYER] [iObj])) != 1) {
  1635. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1636. exit (1);
  1637. }
  1638. assert (rgiIntraDCSwitchingThr [ENHN_LAYER] [iObj] >= 0 && 
  1639. rgiIntraDCSwitchingThr [ENHN_LAYER] [iObj] <= 7);
  1640. }
  1641. }
  1643. // I-VO quantization stepsize
  1644. nextValidLine (pfPara, pnLine);
  1645. for (iObj = 0; iObj < nVO; iObj++) {
  1646. if (fscanf (pfPara, "%d", &(rgiIStep [BASE_LAYER] [iObj])) != 1) {
  1647. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1648. exit (1);
  1649. }
  1650. assert (rgiIStep [BASE_LAYER] [iObj] > 0 && rgiIStep [BASE_LAYER] [iObj] < (1<<uiQuantPrecision));
  1651. }
  1652. if (bAnyScalability) {
  1653. for (iObj = 0; iObj < nVO; iObj++) {
  1654. if (fscanf (pfPara, "%d", &(rgiIStep [ENHN_LAYER] [iObj])) != 1) {
  1655. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1656. exit (1);
  1657. }
  1658. assert (rgiIStep [ENHN_LAYER] [iObj] > 0 && rgiIStep [ENHN_LAYER] [iObj] < (1<<uiQuantPrecision));
  1659. }
  1660. }
  1662. // P-VO quantization stepsize
  1663. nextValidLine (pfPara, pnLine);
  1664. for (iObj = 0; iObj < nVO; iObj++) {
  1665. if (fscanf (pfPara, "%d", &(rgiPStep [BASE_LAYER] [iObj])) != 1) {
  1666. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1667. exit (1);
  1668. }
  1669. assert (rgiPStep [BASE_LAYER] [iObj] > 0 && rgiPStep [BASE_LAYER] [iObj] < (1<<uiQuantPrecision));
  1670. }
  1671. if (bAnyScalability) {
  1672. for (iObj = 0; iObj < nVO; iObj++) {
  1673. if (fscanf (pfPara, "%d", &(rgiPStep [ENHN_LAYER] [iObj])) != 1) {
  1674. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1675. exit (1);
  1676. }
  1677. assert (rgiPStep [ENHN_LAYER] [iObj] > 0 && rgiPStep [ENHN_LAYER] [iObj] < (1<<uiQuantPrecision));
  1678. }
  1679. }
  1681. // quantization stepsize for B-VOP
  1682. nextValidLine (pfPara, pnLine);
  1683. for (iObj = 0; iObj < nVO; iObj++) {
  1684. if (fscanf (pfPara, "%d", &(rgiStepBCode [BASE_LAYER] [iObj])) != 1) {
  1685. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1686. exit (1);
  1687. }
  1688. assert (rgiStepBCode [BASE_LAYER] [iObj] > 0 && rgiStepBCode [BASE_LAYER] [iObj] < (1<<uiQuantPrecision));
  1689. }
  1690. if (bAnyScalability) {
  1691. for (iObj = 0; iObj < nVO; iObj++) {
  1692. if (fscanf (pfPara, "%d", &(rgiStepBCode [ENHN_LAYER] [iObj])) != 1) {
  1693. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1694. exit (1);
  1695. }
  1696. assert (rgiStepBCode [ENHN_LAYER] [iObj] > 0 && rgiStepBCode [ENHN_LAYER] [iObj] < (1<<uiQuantPrecision));
  1697. }
  1698. }
  1700. // load non-default gray alpha intra Q-Matrix, 0 -- FALSE, 1 -- TRUE
  1701. nextValidLine (pfPara, pnLine);
  1702. for (iObj = 0; iObj < nVO; iObj++) {
  1703. if (fscanf (pfPara, "%d", &rgbLoadIntraMatrixAlpha [BASE_LAYER] [iObj]) != 1) {
  1704. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1705. exit (1);
  1706. }
  1707. assert (rgbLoadIntraMatrixAlpha [BASE_LAYER] [iObj] ==0 || 
  1708. rgbLoadIntraMatrixAlpha [BASE_LAYER] [iObj] == 1);
  1709. if (rgbLoadIntraMatrixAlpha [BASE_LAYER] [iObj]) {
  1710. for (UInt i = 0; i < BLOCK_SQUARE_SIZE; i++) {
  1711. if (fscanf (pfPara, "%d", &rgppiIntraQuantizerMatrixAlpha [BASE_LAYER] [iObj] [i]) != 1) {
  1712. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1713. exit (1);
  1714. }
  1715. }
  1716. }
  1717. else
  1718. memcpy (rgppiIntraQuantizerMatrixAlpha [BASE_LAYER] [iObj], rgiDefaultIntraQMatrixAlpha, BLOCK_SQUARE_SIZE * sizeof (Int));
  1719. }
  1720. if (bAnyScalability) {
  1721. for (iObj = 0; iObj < nVO; iObj++) {
  1722. if (fscanf (pfPara, "%d", &rgbLoadIntraMatrixAlpha [ENHN_LAYER] [iObj]) != 1) {
  1723. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1724. exit (1);
  1725. }
  1726. assert (rgbLoadIntraMatrixAlpha [ENHN_LAYER] [iObj] ==0 || 
  1727. rgbLoadIntraMatrixAlpha [ENHN_LAYER] [iObj] == 1);
  1728. if (rgbLoadIntraMatrixAlpha [ENHN_LAYER] [iObj]) {
  1729. for (UInt i = 0; i < BLOCK_SQUARE_SIZE; i++) {
  1730. if (fscanf (pfPara, "%d", &rgppiIntraQuantizerMatrixAlpha [ENHN_LAYER] [iObj] [i]) != 1) {
  1731. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1732. exit (1);
  1733. }
  1734. }
  1735. }
  1736. else
  1737. memcpy (rgppiIntraQuantizerMatrixAlpha [ENHN_LAYER] [iObj], rgiDefaultIntraQMatrixAlpha, BLOCK_SQUARE_SIZE * sizeof (Int));
  1738. }
  1739. }
  1741. // load non-default  gray alpha inter Q-Matrix, 0 -- FALSE, 1 -- TRUE
  1742. nextValidLine (pfPara, pnLine);
  1743. for (iObj = 0; iObj < nVO; iObj++) {
  1744. if (fscanf (pfPara, "%d", &rgbLoadInterMatrixAlpha [BASE_LAYER] [iObj]) != 1) {
  1745. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1746. exit (1);
  1747. }
  1748. assert (rgbLoadInterMatrixAlpha [BASE_LAYER] [iObj] ==0 || 
  1749. rgbLoadInterMatrixAlpha [BASE_LAYER] [iObj] == 1);
  1750. if (rgbLoadInterMatrixAlpha [BASE_LAYER] [iObj]) {
  1751. for (UInt i = 0; i < BLOCK_SQUARE_SIZE; i++) {
  1752. if (fscanf (pfPara, "%d", &rgppiInterQuantizerMatrixAlpha [BASE_LAYER] [iObj] [i]) != 1) {
  1753. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1754. exit (1);
  1755. }
  1756. }
  1757. }
  1758. else
  1759. memcpy (rgppiInterQuantizerMatrixAlpha [BASE_LAYER] [iObj], rgiDefaultInterQMatrixAlpha, BLOCK_SQUARE_SIZE * sizeof (Int));
  1760. }
  1761. if (bAnyScalability) {
  1762. for (iObj = 0; iObj < nVO; iObj++) {
  1763. if (fscanf (pfPara, "%d", &rgbLoadInterMatrixAlpha [ENHN_LAYER] [iObj]) != 1) {
  1764. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1765. exit (1);
  1766. }
  1767. assert (rgbLoadInterMatrixAlpha [ENHN_LAYER] [iObj] ==0 || 
  1768. rgbLoadInterMatrixAlpha [ENHN_LAYER] [iObj] == 1);
  1769. if (rgbLoadInterMatrixAlpha [ENHN_LAYER] [iObj]) {
  1770. for (UInt i = 0; i < BLOCK_SQUARE_SIZE; i++) {
  1771. if (fscanf (pfPara, "%d", &rgppiInterQuantizerMatrixAlpha [ENHN_LAYER] [iObj] [i]) != 1) {
  1772. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1773. exit (1);
  1774. }
  1775. }
  1776. }
  1777. else
  1778. memcpy (rgppiInterQuantizerMatrixAlpha [ENHN_LAYER] [iObj], rgiDefaultInterQMatrixAlpha, BLOCK_SQUARE_SIZE * sizeof (Int));
  1779. }
  1780. }
  1782. // I-VO quantization stepsize for Alpha
  1783. nextValidLine (pfPara, pnLine);
  1784. for (iObj = 0; iObj < nVO; iObj++) {
  1785. if (fscanf (pfPara, "%d", &(rgiIStepAlpha [BASE_LAYER] [iObj])) != 1) {
  1786. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1787. exit (1);
  1788. }
  1789. assert (rgiIStepAlpha [BASE_LAYER] [iObj] > 0 && rgiIStepAlpha [BASE_LAYER] [iObj] < 32);
  1790. }
  1791. if (bAnyScalability) {
  1792. for (iObj = 0; iObj < nVO; iObj++) {
  1793. if (fscanf (pfPara, "%d", &(rgiIStepAlpha [ENHN_LAYER] [iObj])) != 1) {
  1794. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1795. exit (1);
  1796. }
  1797. assert (rgiIStepAlpha [ENHN_LAYER] [iObj] > 0 && rgiIStepAlpha [ENHN_LAYER] [iObj] < 32);
  1798. }
  1799. }
  1801. // P-VO quantization stepsize for Alpha
  1802. nextValidLine (pfPara, pnLine);
  1803. for (iObj = 0; iObj < nVO; iObj++) {
  1804. if (fscanf (pfPara, "%d", &(rgiPStepAlpha [BASE_LAYER] [iObj])) != 1) {
  1805. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1806. exit (1);
  1807. }
  1808. assert (rgiPStepAlpha [BASE_LAYER] [iObj] > 0 && rgiPStepAlpha [BASE_LAYER] [iObj] < 64);
  1809. }
  1810. if (bAnyScalability) {
  1811. for (iObj = 0; iObj < nVO; iObj++) {
  1812. if (fscanf (pfPara, "%d", &(rgiPStepAlpha [ENHN_LAYER] [iObj])) != 1) {
  1813. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1814. exit (1);
  1815. }
  1816. assert (rgiPStepAlpha [ENHN_LAYER] [iObj] > 0 && rgiPStepAlpha [ENHN_LAYER] [iObj] < 64);
  1817. }
  1818. }
  1820. // B-VO quantization stepsize for Alpha
  1821. nextValidLine (pfPara, pnLine);
  1822. for (iObj = 0; iObj < nVO; iObj++) {
  1823. if (fscanf (pfPara, "%d", &(rgiBStepAlpha [BASE_LAYER] [iObj])) != 1) {
  1824. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1825. exit (1);
  1826. }
  1827. assert (rgiBStepAlpha [BASE_LAYER] [iObj] > 0 && rgiBStepAlpha [BASE_LAYER] [iObj] < 64);
  1828. }
  1829. if (bAnyScalability) {
  1830. for (iObj = 0; iObj < nVO; iObj++) {
  1831. if (fscanf (pfPara, "%d", &(rgiBStepAlpha [ENHN_LAYER] [iObj])) != 1) {
  1832. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1833. exit (1);
  1834. }
  1835. assert (rgiBStepAlpha [ENHN_LAYER] [iObj] > 0 && rgiBStepAlpha [ENHN_LAYER] [iObj] < 64);
  1836. }
  1837. }
  1839. // disable_gray_quant_update
  1840. nextValidLine (pfPara, pnLine);
  1841. for (iObj = 0; iObj < nVO; iObj++) {
  1842. if (fscanf (pfPara, "%d", &(rgbNoGrayQuantUpdate [BASE_LAYER] [iObj])) != 1) {
  1843. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1844. exit (1);
  1845. }
  1846. }
  1847. if (bAnyScalability) {
  1848. for (iObj = 0; iObj < nVO; iObj++) {
  1849. if (fscanf (pfPara, "%d", &(rgbNoGrayQuantUpdate [ENHN_LAYER] [iObj])) != 1) {
  1850. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1851. exit (1);
  1852. }
  1853. }
  1854. }
  1856. // number of P-VOP's between 2 I-VOP's; if there are B-VOPs, the no. of encode frames will multiply
  1857. nextValidLine (pfPara, pnLine);
  1858. for (iObj = 0; iObj < nVO; iObj++) {
  1859. if (fscanf (pfPara, "%d", &rgiNumPbetweenIVOP [iObj]) != 1) {
  1860. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1861. exit (1);
  1862. }
  1863. if (rgiNumPbetweenIVOP [iObj] < 0)
  1864. rgiNumPbetweenIVOP [iObj] = lastFrm - firstFrm + 1; //only 1 I at the beginning
  1865. }
  1867. // number of B-VOP's between 2 P-VOP's
  1868. nextValidLine (pfPara, pnLine);
  1869. for (iObj = 0; iObj < nVO; iObj++) {
  1870. if (fscanf (pfPara, "%d", &rgiNumBbetweenPVOP [iObj]) != 1) {
  1871. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1872. exit (1);
  1873. }
  1874. assert (rgiNumBbetweenPVOP [iObj] >= 0);
  1875. }
  1877. if(iVersion>814)
  1878. {
  1879. // rgbAllowSkippedPMBs
  1880. nextValidLine (pfPara, pnLine);
  1881. for (iObj = 0; iObj < nVO; iObj++) {
  1882. if (fscanf (pfPara, "%d", &rgbAllowSkippedPMBs [iObj]) != 1) {
  1883. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1884. exit (1);
  1885. }
  1886. assert (rgbAllowSkippedPMBs [iObj] == 0 || rgbAllowSkippedPMBs[iObj]==1);
  1887. }
  1888. }
  1889. else
  1890. for (iObj = 0; iObj < nVO; iObj++)
  1891. rgbAllowSkippedPMBs [iObj] = 1;
  1893. //added to encode GOV header by SONY 980212
  1894. //number of VOP between GOV header
  1895. //CAUTION:GOV period is not used in spatial scalable coding
  1896. nextValidLine (pfPara, pnLine);
  1897. for (iObj = 0; iObj < nVO; iObj++) {
  1898. if (fscanf (pfPara, "%d", &rgiGOVperiod [iObj]) != 1) {
  1899. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1900. exit (1);
  1901. }
  1902. assert (rgiGOVperiod [iObj] >= 0);
  1903. }
  1904. //980212
  1906. // deblocking filter disable
  1907. nextValidLine (pfPara, pnLine);
  1908. for (iObj = 0; iObj < nVO; iObj++) {
  1909. if (fscanf (pfPara, "%d", &rgbDeblockFilterDisable [iObj]) != 1) {
  1910. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1911. exit (1);
  1912. }
  1913. if (rgbDeblockFilterDisable [iObj] != TRUE) {
  1914. fprintf(stderr, "Deblocking filter is not supported in this versionn");
  1915. exit (1);
  1916. }
  1917. }
  1919. // Temporal sampling rate
  1920. nextValidLine (pfPara, pnLine);
  1921. for (iObj = 0; iObj < nVO; iObj++) {
  1922. if (fscanf (pfPara, "%d", &rgiTSRate [iObj]) != 1) {
  1923. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1924. exit (1);
  1925. }
  1926. assert (rgiTSRate [iObj] >= 1);
  1927. }
  1928. if ( bAnyScalability ){ // This part is added by Norio Ito
  1929. for (iObj = 0; iObj < nVO; iObj++) {
  1930. if (fscanf (pfPara, "%d", &rgiEnhcTSRate [iObj]) != 1) {
  1931. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1932. exit (1);
  1933. }
  1934. assert (rgiEnhcTSRate [iObj] >= 1);
  1935. }
  1936. }
  1938. // maximum displacement
  1939. nextValidLine (pfPara, pnLine);
  1940. for (iObj = 0; iObj < nVO; iObj++) {
  1941. if (fscanf (pfPara, "%d", &rguiSearchRange [BASE_LAYER] [iObj]) != 1) {
  1942. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1943. exit (1);
  1944. }
  1945. assert (rguiSearchRange [BASE_LAYER] [iObj] >= 1);
  1946. }
  1947. if (bAnyScalability) {
  1948. for (iObj = 0; iObj < nVO; iObj++) {
  1949. if (fscanf (pfPara, "%d", &rguiSearchRange [ENHN_LAYER] [iObj]) != 1) {
  1950. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1951. exit (1);
  1952. }
  1953. assert (rguiSearchRange [ENHN_LAYER] [iObj] >= 1);
  1954. }
  1955. }
  1957. // use original or reconstructed previous VO for ME
  1958. nextValidLine (pfPara, pnLine);
  1959. for (iObj = 0; iObj < nVO; iObj++) {
  1960. if (fscanf (pfPara, "%d", &rgbOriginalME [BASE_LAYER] [iObj]) != 1) {
  1961. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1962. exit (1);
  1963. }
  1964. assert (rgbOriginalME [BASE_LAYER] [iObj] == 0 || rgbOriginalME [BASE_LAYER] [iObj] == 1);
  1965. }
  1966. if (bAnyScalability) {
  1967. for (iObj = 0; iObj < nVO; iObj++) {
  1968. if (fscanf (pfPara, "%d", &rgbOriginalME [ENHN_LAYER] [iObj]) != 1) {
  1969. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1970. exit (1);
  1971. }
  1972. assert (rgbOriginalME [ENHN_LAYER] [iObj] == 0 || rgbOriginalME [ENHN_LAYER] [iObj] == 1);
  1973. }
  1974. }
  1976. // disable advance prediction (obmc only)?
  1977. nextValidLine (pfPara, pnLine);
  1978. for (iObj = 0; iObj < nVO; iObj++) {
  1979. if (fscanf (pfPara, "%d", &rgbAdvPredDisable [BASE_LAYER] [iObj]) != 1) {
  1980. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1981. exit (1);
  1982. }
  1983. assert (rgbAdvPredDisable [BASE_LAYER] [iObj] == 0 || rgbAdvPredDisable [BASE_LAYER] [iObj] == 1);
  1984. }
  1985. if (bAnyScalability) {
  1986. for (iObj = 0; iObj < nVO; iObj++) {
  1987. if (fscanf (pfPara, "%d", &rgbAdvPredDisable [ENHN_LAYER] [iObj]) != 1) {
  1988. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  1989. exit (1);
  1990. }
  1991. assert (rgbAdvPredDisable [ENHN_LAYER] [iObj] == 0 || rgbAdvPredDisable [ENHN_LAYER] [iObj] == 1);
  1992. }
  1993. }
  1995. // START: Complexity Estimation syntax support - Marc Mongenet (EPFL) - 16 Jun 1998
  1996. readBoolVOLFlag (rgbComplexityEstimationDisable, nVO, pfPara, pnLine, bAnyScalability);
  1997. readBoolVOLFlag (rgbOpaque, nVO, pfPara, pnLine, bAnyScalability);
  1998. readBoolVOLFlag (rgbTransparent, nVO, pfPara, pnLine, bAnyScalability);
  1999. readBoolVOLFlag (rgbIntraCAE, nVO, pfPara, pnLine, bAnyScalability);
  2000. readBoolVOLFlag (rgbInterCAE, nVO, pfPara, pnLine, bAnyScalability);
  2001. readBoolVOLFlag (rgbNoUpdate, nVO, pfPara, pnLine, bAnyScalability);
  2002. readBoolVOLFlag (rgbUpsampling, nVO, pfPara, pnLine, bAnyScalability);
  2003. readBoolVOLFlag (rgbIntraBlocks, nVO, pfPara, pnLine, bAnyScalability);
  2004. readBoolVOLFlag (rgbInterBlocks, nVO, pfPara, pnLine, bAnyScalability);
  2005. readBoolVOLFlag (rgbInter4vBlocks, nVO, pfPara, pnLine, bAnyScalability);
  2006. readBoolVOLFlag (rgbNotCodedBlocks, nVO, pfPara, pnLine, bAnyScalability);
  2007. readBoolVOLFlag (rgbDCTCoefs, nVO, pfPara, pnLine, bAnyScalability);
  2008. readBoolVOLFlag (rgbDCTLines, nVO, pfPara, pnLine, bAnyScalability);
  2009. readBoolVOLFlag (rgbVLCSymbols, nVO, pfPara, pnLine, bAnyScalability);
  2010. readBoolVOLFlag (rgbVLCBits, nVO, pfPara, pnLine, bAnyScalability);
  2011. readBoolVOLFlag (rgbAPM, nVO, pfPara, pnLine, bAnyScalability);
  2012. readBoolVOLFlag (rgbNPM, nVO, pfPara, pnLine, bAnyScalability);
  2013. readBoolVOLFlag (rgbInterpolateMCQ, nVO, pfPara, pnLine, bAnyScalability);
  2014. readBoolVOLFlag (rgbForwBackMCQ, nVO, pfPara, pnLine, bAnyScalability);
  2015. readBoolVOLFlag (rgbHalfpel2, nVO, pfPara, pnLine, bAnyScalability);
  2016. readBoolVOLFlag (rgbHalfpel4, nVO, pfPara, pnLine, bAnyScalability);
  2017. // END: Complexity Estimation syntax support
  2019. // START: VOL Control Parameters
  2020. if(iVersion>813)
  2021. {
  2022. readItem(rguiVolControlParameters, nVO, pfPara, pnLine, bAnyScalability);
  2023. readItem(rguiChromaFormat, nVO, pfPara, pnLine, bAnyScalability);
  2024. readItem(rguiLowDelay, nVO, pfPara, pnLine, bAnyScalability);
  2025. readItem(rguiVBVParams, nVO, pfPara, pnLine, bAnyScalability);
  2026. readItem(rguiBitRate, nVO, pfPara, pnLine, bAnyScalability);
  2027. readItem(rguiVbvBufferSize, nVO, pfPara, pnLine, bAnyScalability);
  2028. readItem(rguiVbvBufferOccupany, nVO, pfPara, pnLine, bAnyScalability);
  2029. }
  2030. else
  2031. {
  2032. for(iObj = 0; iObj<nVO; iObj++)
  2033. {
  2034. rguiVolControlParameters[BASE_LAYER][iObj] = 0;
  2035. rguiVolControlParameters[ENHN_LAYER][iObj] = 0;
  2036. rguiVBVParams[BASE_LAYER][iObj] = 0;
  2037. rguiVBVParams[ENHN_LAYER][iObj] = 0;
  2038. }
  2040. }
  2042. // END: VOL Control Parameters
  2044. // Interlaced CHANGE
  2045. // Sequence frame frequency (Hz).  Use double type because of 29.97Hz (etc)
  2046. nextValidLine (pfPara, pnLine);
  2047. for (iObj = 0; iObj < nVO; iObj++) {
  2048. if (fscanf (pfPara, "%lf", &(rgdFrameFrequency [BASE_LAYER] [iObj])) != 1) {
  2049. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  2050. exit (1);
  2051. }
  2052. assert(rgdFrameFrequency [BASE_LAYER] [iObj] > 0.0);
  2053. }
  2054. if (bAnyScalability) {
  2055. for (iObj = 0; iObj < nVO; iObj++) {
  2056. if (fscanf (pfPara, "%lf", &(rgdFrameFrequency [ENHN_LAYER] [iObj])) != 1) {
  2057. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  2058. exit (1);
  2059. }
  2060. assert(rgdFrameFrequency [ENHN_LAYER] [iObj] > 0.0);
  2061. }
  2062. }
  2064. // top field first flag
  2065. nextValidLine (pfPara, pnLine);
  2066. for (iObj = 0; iObj < nVO; iObj++) {
  2067. if (fscanf (pfPara, "%d", &(rgbTopFieldFirst [BASE_LAYER] [iObj])) != 1) {
  2068. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  2069. exit (1);
  2070. }
  2071. assert (rgbTopFieldFirst [BASE_LAYER] [iObj] == 0 || 
  2072. rgbTopFieldFirst [BASE_LAYER] [iObj] == 1);
  2073. }
  2074. if (bAnyScalability) {
  2075. for (iObj = 0; iObj < nVO; iObj++) {
  2076. if (fscanf (pfPara, "%d", &(rgbTopFieldFirst [ENHN_LAYER] [iObj])) != 1) {
  2077. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  2078. exit (1);
  2079. }
  2080. assert (rgbTopFieldFirst [ENHN_LAYER] [iObj] == 0 || 
  2081. rgbTopFieldFirst [ENHN_LAYER] [iObj] == 1);
  2082. }
  2083. }
  2085. // alternate scan flag
  2086. nextValidLine (pfPara, pnLine);
  2087. for (iObj = 0; iObj < nVO; iObj++) {
  2088. if (fscanf (pfPara, "%d", &(rgbAlternateScan [BASE_LAYER] [iObj])) != 1) {
  2089. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  2090. exit (1);
  2091. }
  2092. assert (rgbAlternateScan [BASE_LAYER] [iObj] == 0 || 
  2093. rgbAlternateScan [BASE_LAYER] [iObj] == 1);
  2094. }
  2095. if (bAnyScalability) {
  2096. for (iObj = 0; iObj < nVO; iObj++) {
  2097. if (fscanf (pfPara, "%d", &(rgbAlternateScan [ENHN_LAYER] [iObj])) != 1) {
  2098. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  2099. exit (1);
  2100. }
  2101. assert (rgbAlternateScan [ENHN_LAYER] [iObj] == 0 || 
  2102. rgbAlternateScan [ENHN_LAYER] [iObj] == 1);
  2103. }
  2104. }
  2106. // Direct Mode search radius (half luma pixel units)
  2107. nextValidLine (pfPara, pnLine);
  2108. for (iObj = 0; iObj < nVO; iObj++) {
  2109. if (fscanf (pfPara, "%d", &(rgiDirectModeRadius [BASE_LAYER] [iObj])) != 1) {
  2110. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  2111. exit (1);
  2112. }
  2113. }
  2114. if (bAnyScalability) {
  2115. for (iObj = 0; iObj < nVO; iObj++) {
  2116. if (fscanf (pfPara, "%d", &(rgiDirectModeRadius [ENHN_LAYER] [iObj])) != 1) {
  2117. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  2118. exit (1);
  2119. }
  2120. }
  2121. }
  2123. // motion vector file
  2124. nextValidLine(pfPara, pnLine);
  2125. for (iObj = 0; iObj < nVO; iObj++) {
  2126. if (fscanf (pfPara, "%d", &(rgiMVFileUsage [BASE_LAYER] [iObj])) != 1) {
  2127. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  2128. exit (1);
  2129. }
  2130. assert (rgiMVFileUsage [BASE_LAYER] [iObj] == 0 || // 0= not used
  2131. rgiMVFileUsage [BASE_LAYER] [iObj] == 1 || // 1= read motion vectors from file
  2132. rgiMVFileUsage [BASE_LAYER] [iObj] == 2 ); // 2= write motion vectors to file
  2134. pchMVFileName [BASE_LAYER] [iObj] = NULL;
  2135. pchMVFileName [ENHN_LAYER] [iObj] = NULL;
  2137. char cFileName[256];
  2138. cFileName[0] = 0;
  2139. if ((rgiMVFileUsage [BASE_LAYER] [iObj] != 0) &&
  2140. (fscanf (pfPara, "%200s", cFileName) != 1)) {
  2141. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  2142. exit (1);
  2143. }
  2144. Int iLength = strlen(cFileName) + 1;
  2145. pchMVFileName [BASE_LAYER] [iObj] = new char [iLength];
  2146. memcpy(pchMVFileName [BASE_LAYER] [iObj], cFileName, iLength);
  2147. }
  2148. if (bAnyScalability) {
  2149. for (iObj = 0; iObj < nVO; iObj++) {
  2150. if (fscanf (pfPara, "%d", &(rgiMVFileUsage [ENHN_LAYER] [iObj])) != 1) {
  2151. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  2152. exit (1);
  2153. }
  2154. assert (rgiMVFileUsage [ENHN_LAYER] [iObj] == 0 || 
  2155. rgiMVFileUsage [ENHN_LAYER] [iObj] == 1 ||
  2156. rgiMVFileUsage [ENHN_LAYER] [iObj] == 2 );
  2158. char cFileName[256];
  2159. cFileName[0] = 0;
  2160. if ((rgiMVFileUsage [ENHN_LAYER] [iObj] != 0) &&
  2161. (fscanf (pfPara, "%s", cFileName) != 1)) {
  2162. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  2163. exit (1);
  2164. }
  2165. Int iLength = strlen(cFileName) + 1;
  2166. pchMVFileName [ENHN_LAYER] [iObj] = new char [iLength];
  2167. memcpy(pchMVFileName [ENHN_LAYER] [iObj], cFileName, iLength);
  2168. }
  2169. }
  2171. // file information
  2172. pchPrefix = new char [256];
  2173. nextValidLine (pfPara, pnLine);
  2174. fscanf (pfPara, "%s", pchPrefix);
  2176. // original file directory
  2177. pchBmpDir = new char [256];
  2178. nextValidLine (pfPara, pnLine);
  2179. fscanf (pfPara, "%100s", pchBmpDir);
  2181. // chrominance format
  2182. nextValidLine (pfPara, pnLine);
  2183. for (iObj = 0; iObj < nVO; iObj++) {
  2184. UInt uiChrType;
  2185. if (fscanf (pfPara, "%d", &uiChrType) != 1) {
  2186. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  2187. exit (1);
  2188. }
  2189. else {
  2190. assert (uiChrType == 0 || uiChrType == 1 || uiChrType == 2);
  2191. rgfChrType [iObj] = (ChromType) uiChrType;
  2192. }
  2193. }
  2195. // output file directory
  2196. pchOutBmpDir = new char [256];
  2197. nextValidLine (pfPara, pnLine);
  2198. fscanf (pfPara, "%100s", pchOutBmpDir);
  2200. // output bitstream file
  2201. pchOutStrFile = new char [256];
  2202. nextValidLine (pfPara, pnLine);
  2203. fscanf (pfPara, "%100s", pchOutStrFile);
  2205. // statistics dumping options
  2206. nextValidLine (pfPara, pnLine);
  2207. for (iObj = 0; iObj < nVO; iObj++) {
  2208. if (fscanf (pfPara, "%d", &rgbDumpMB [iObj]) != 1) {
  2209. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  2210. exit (1);
  2211. }
  2212. assert (rgbDumpMB [iObj] == 0 || rgbDumpMB [iObj] == 1);
  2213. }
  2215. // trace file options
  2216. nextValidLine (pfPara, pnLine);
  2217. for (iObj = 0; iObj < nVO; iObj++) {
  2218. if (fscanf (pfPara, "%d", &rgbTrace [iObj]) != 1) {
  2219. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  2220. exit (1);
  2221. }
  2222. assert (rgbTrace [iObj] == 0 || rgbTrace [iObj] == 1);
  2223. }
  2225. // sprite info
  2226. // sprite usage
  2227. nextValidLine (pfPara, pnLine);
  2228. for (iObj = 0; iObj < nVO; iObj++) {
  2229. if (fscanf (pfPara, "%d", &rguiSpriteUsage [iObj]) != 1) {
  2230. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  2231. exit (1);
  2232. }
  2233. assert ((rguiSpriteUsage [iObj] == 0) || (rguiSpriteUsage [iObj] == 1)); // only support static sprite at the moment
  2234. if (rgbScalability [iObj] == TRUE)
  2235. assert (rguiSpriteUsage [iObj] == 0);
  2236. }
  2238. // warping accuracy
  2239. nextValidLine (pfPara, pnLine);
  2240. for (iObj = 0; iObj < nVO; iObj++) {
  2241. if (fscanf (pfPara, "%d", &rguiWarpingAccuracy [iObj]) != 1) {
  2242. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  2243. exit (1);
  2244. }
  2245. if (rguiSpriteUsage [iObj] != 0)
  2246. assert (rguiWarpingAccuracy [iObj] == 0 || rguiWarpingAccuracy [iObj] == 1 || rguiWarpingAccuracy [iObj] == 2 || rguiWarpingAccuracy [iObj] == 3);
  2247. }
  2249. // number of points
  2250. nextValidLine (pfPara, pnLine);
  2251. for (iObj = 0; iObj < nVO; iObj++) {
  2252. if (fscanf (pfPara, "%d", &rgiNumPnts [iObj]) != 1) {
  2253. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  2254. exit (1);
  2255. }
  2256. if (rgbScalability [iObj] == TRUE)
  2257. assert (rgiNumPnts [iObj] == -1);
  2258. if (rguiSpriteUsage [iObj] == 1) 
  2259. assert (rgiNumPnts [iObj] == 0 ||
  2260. rgiNumPnts [iObj] == 1 ||
  2261. rgiNumPnts [iObj] == 2 ||
  2262. rgiNumPnts [iObj] == 3 ||
  2263. rgiNumPnts [iObj] == 4);
  2264. }
  2266. // sprite directory
  2267. pchSptDir = new char [256];
  2268. nextValidLine (pfPara, pnLine);
  2269. fscanf (pfPara, "%100s", pchSptDir);
  2271. // point directory
  2272. pchSptPntDir = new char [256];
  2273. nextValidLine (pfPara, pnLine);
  2274. fscanf (pfPara, "%100s", pchSptPntDir);
  2276. //  sprite reconstruction mode, i.e. Low-latency-sprite-enable
  2277. nextValidLine (pfPara, pnLine);
  2278. for (iObj = 0; iObj < nVO; iObj++)
  2279. {
  2280. UInt uiSptMode;
  2281. if (fscanf (pfPara, "%d", &uiSptMode) != 1) {
  2282. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  2283. exit (1);
  2284. }
  2285. else {
  2286. assert (uiSptMode == 0 || uiSptMode == 1 );
  2287. rgSpriteMode[iObj] = (SptMode) uiSptMode;
  2288. }
  2289. }
  2291. fclose(pfPara);
  2292. }
  2294. CSessionEncoderParams param;
  2295. param.uiFrmWidth = uiFrmWidth;
  2296. param.uiFrmHeight = uiFrmHeight;
  2297. param.iFirstFrm = firstFrm;
  2298. param.iLastFrm = lastFrm;
  2299. param.bNot8Bit = bNot8Bit;
  2300. param.uiQuantPrecision = uiQuantPrecision;
  2301. param.nBits = nBits;
  2302. param.uiFirstVO = firstVO;
  2303. param.iLastVO = lastVO;
  2304. param.rgbSpatialScalability =  rgbSpatialScalability;
  2305. param.rgiTemporalScalabilityType = rgiTemporalScalabilityType;
  2306. param.rgiEnhancementType = rgiEnhancementType;
  2307. param.rguiRateControl = rguiRateControl;
  2308. param.rguiBudget = rguiBitsBudget;
  2309. param.rgfAlphaUsage = rgfAlphaUsage;
  2310. param.rgbShapeOnly = rgbShapeOnly;
  2311. param.rgiBinaryAlphaTH =  rgiBinaryAlphaTH;
  2312. param.rgiBinaryAlphaRR = rgiBinaryAlphaRR;
  2313. param.rgbNoCrChange = rgbNoCrChange;
  2314. param.rguiSearchRange = rguiSearchRange;
  2315. param.rgbOriginalForME = rgbOriginalME;
  2316. param.rgbAdvPredDisable = rgbAdvPredDisable;
  2317. param.rgbComplexityEstimationDisable = rgbComplexityEstimationDisable;
  2318. param.rgbOpaque = rgbOpaque;
  2319. param.rgbTransparent = rgbTransparent;
  2320. param.rgbIntraCAE = rgbIntraCAE;
  2321. param.rgbInterCAE = rgbInterCAE;
  2322. param.rgbNoUpdate = rgbNoUpdate;
  2323. param.rgbUpsampling = rgbUpsampling;
  2324. param.rgbIntraBlocks = rgbIntraBlocks;
  2325. param.rgbInterBlocks = rgbInterBlocks;
  2326. param.rgbInter4vBlocks = rgbInter4vBlocks;
  2327. param.rgbNotCodedBlocks = rgbNotCodedBlocks;
  2328. param.rgbDCTCoefs = rgbDCTCoefs;
  2329. param.rgbDCTLines = rgbDCTLines;
  2330. param.rgbVLCSymbols = rgbVLCSymbols;
  2331. param.rgbVLCBits = rgbVLCBits;
  2332. param.rgbAPM = rgbAPM;
  2333. param.rgbNPM = rgbNPM;
  2334. param.rgbInterpolateMCQ = rgbInterpolateMCQ;
  2335. param.rgbForwBackMCQ = rgbForwBackMCQ;
  2336. param.rgbHalfpel2 = rgbHalfpel2;
  2337. param.rgbHalfpel4 = rgbHalfpel4;
  2338. param.rguiVolControlParameters = rguiVolControlParameters;
  2339. param.rguiChromaFormat = rguiChromaFormat;
  2340. param.rguiLowDelay = rguiLowDelay;
  2341. param.rguiVBVParams = rguiVBVParams;
  2342. param.rguiBitRate = rguiBitRate;
  2343. param.rguiVbvBufferSize = rguiVbvBufferSize;
  2344. param.rguiVbvBufferOccupany = rguiVbvBufferOccupany;
  2345. param.rgdFrameFrequency = rgdFrameFrequency;
  2346. param.rgbInterlacedCoding = rgbInterlacedCoding;
  2347. param.rgbTopFieldFirst = rgbTopFieldFirst;
  2348. param.rgbAlternateScan = rgbAlternateScan;
  2349. param.rgiDirectModeRadius = rgiDirectModeRadius;
  2350. param.rgiMVFileUsage = rgiMVFileUsage;
  2351. param.pchMVFileName = &pchMVFileName[0];
  2352. param.rgbVPBitTh = rgiVPBitTh;
  2353. param.rgbDataPartitioning = rgbDataPartitioning;
  2354. param.rgbReversibleVlc = rgbReversibleVlc;
  2355. param.rgfQuant = rgfQuant;
  2356. param.rgbLoadIntraMatrix = rgbLoadIntraMatrix;
  2357. param.rgppiIntraQuantizerMatrix = rgppiIntraQuantizerMatrix;
  2358. param.rgbLoadInterMatrix = rgbLoadInterMatrix;
  2359. param.rgppiInterQuantizerMatrix =  rgppiInterQuantizerMatrix;
  2360. param.rgiIntraDCSwitchingThr = rgiIntraDCSwitchingThr;
  2361. param.rgiStepI = rgiIStep;
  2362. param.rgiStepP = rgiPStep;
  2363. param.rgbLoadIntraMatrixAlpha = rgbLoadIntraMatrixAlpha;
  2364. param.rgppiIntraQuantizerMatrixAlpha = rgppiIntraQuantizerMatrixAlpha;
  2365. param.rgbLoadInterMatrixAlpha = rgbLoadIntraMatrixAlpha;
  2366. param.rgppiInterQuantizerMatrixAlpha = rgppiInterQuantizerMatrixAlpha;
  2367. param.rgiStepIAlpha = rgiIStepAlpha;
  2368. param.rgiStepPAlpha = rgiPStepAlpha;
  2369. param.rgiStepBAlpha = rgiBStepAlpha;
  2370. param.rgbNoAlphaQuantUpdate = rgbNoGrayQuantUpdate;
  2371. param.rgiStepB = rgiStepBCode;
  2372. param.rgiNumOfBbetweenPVOP = rgiNumBbetweenPVOP;
  2373. param.rgiNumOfPbetweenIVOP = rgiNumPbetweenIVOP;
  2374. param.rgiGOVperiod = rgiGOVperiod;
  2375. param.rgbDeblockFilterDisable = rgbDeblockFilterDisable;
  2376. param.rgbAllowSkippedPMBs = rgbAllowSkippedPMBs;
  2377. param.pchPrefix = pchPrefix;
  2378. param.pchBmpFiles = pchBmpDir;
  2379. param.rgfChrType = rgfChrType;
  2380. param.pchOutBmpFiles = pchOutBmpDir;
  2381. param.pchOutStrFiles = pchOutStrFile;
  2382. param.rgiTemporalRate = rgiTSRate;
  2383. param.rgiEnhnTemporalRate = rgiEnhcTSRate;
  2384. param.rgbDumpMB = rgbDumpMB;
  2385. param.rgbTrace = rgbTrace;
  2386. param.rgbRoundingControlDisable =  rgbRoundingControlDisable;
  2387. param.rgiInitialRoundingType =  rgiInitialRoundingType;
  2388. param.rguiSpriteUsage = rguiSpriteUsage;
  2389. param.rguiWarpingAccuracy = rguiWarpingAccuracy;
  2390. param.rgNumOfPnts = rgiNumPnts;
  2391. param.pchSptDir = pchSptDir;
  2392. param.pchSptPntDir = pchSptPntDir;
  2393. param.pSpriteMode = rgSpriteMode;
  2394. param.iSpatialOption = iSpatialOption;
  2395. param.uiFrmWidth_SS = uiFrmWidth_SS;
  2396. param.uiFrmHeight_SS = uiFrmHeight_SS;
  2397. param.uiHor_sampling_n = uiHor_sampling_n;
  2398. param.uiHor_sampling_m = uiHor_sampling_m;
  2399. param.uiVer_sampling_n = uiVer_sampling_n;
  2400. param.uiVer_sampling_m = uiVer_sampling_m;
  2401. CSessionEncoder *penc = new CSessionEncoder(&param);
  2402. #if 0
  2403.   CSessionEncoder* penc = new CSessionEncoder (
  2404. // general info
  2405. uiFrmWidth, // frame width
  2406. uiFrmHeight, // frame height
  2407. (Int)firstFrm, // first frame number
  2408. (Int)lastFrm, // last frame number
  2409. (Bool)bNot8Bit, // NBIT: not 8-bit flag
  2410. uiQuantPrecision, // NBIT: quant precision
  2411. (UInt)nBits, // NBIT: number of bits per pixel
  2412. (Int)firstVO, // first VO index
  2413. (Int)lastVO, // last VO index
  2414. rgbSpatialScalability, // spatial scalability indicator
  2415. rgiTemporalScalabilityType, // form of temporal scalability // added by Sharp (98/02/09)
  2416. rgiEnhancementType, // enhancement_type for scalability // added by Sharp (98/02/09)
  2418. rguiRateControl,
  2419. rguiBitsBudget,
  2420. rgfAlphaUsage, // alpha usage for each VO.
  2421. rgbShapeOnly,
  2422. rgiBinaryAlphaTH,
  2423. rgiBinaryAlphaRR, // Added for error resilient mode by Toshiba(1997-11-14)
  2424. rgbNoCrChange, 
  2426. // motion estimation part for each VO
  2427. rguiSearchRange,
  2428. rgbOriginalME, // flag indicating whether use the original previous VO for ME
  2429. rgbAdvPredDisable,
  2431.             // START: Complexity Estimation syntax support - Marc Mongenet (EPFL) - 17 Jun 1998
  2432. rgbComplexityEstimationDisable,
  2433. rgbOpaque,
  2434. rgbTransparent,
  2435. rgbIntraCAE,
  2436. rgbInterCAE,
  2437. rgbNoUpdate,
  2438. rgbUpsampling,
  2439. rgbIntraBlocks,
  2440. rgbInterBlocks,
  2441. rgbInter4vBlocks,
  2442. rgbNotCodedBlocks,
  2443. rgbDCTCoefs,
  2444. rgbDCTLines,
  2445. rgbVLCSymbols,
  2446. rgbVLCBits,
  2447. rgbAPM,
  2448. rgbNPM,
  2449. rgbInterpolateMCQ,
  2450. rgbForwBackMCQ,
  2451. rgbHalfpel2,
  2452. rgbHalfpel4,
  2453. // END: Complexity Estimation syntax support
  2455. // START: VOL Control Parameters
  2456. rguiVolControlParameters,
  2457. rguiChromaFormat,
  2458. rguiLowDelay,
  2459. rguiVBVParams,
  2460. rguiBitRate,
  2461. rguiVbvBufferSize,
  2462. rguiVbvBufferOccupany,
  2463. // END: VOL Control Parameters
  2465. rgdFrameFrequency,
  2467. // interlace coding flag
  2468. rgbInterlacedCoding,
  2469. rgbTopFieldFirst,
  2470.             rgbAlternateScan,
  2472. // direct mode search radius
  2473. rgiDirectModeRadius,
  2475. // motion vector file I/O
  2476. rgiMVFileUsage,
  2477. &pchMVFileName[0],
  2479. // systax mode
  2480. rgiVPBitTh, // Bit threshold for video packet spacing control
  2481. rgbDataPartitioning,  //data partitioning
  2482. rgbReversibleVlc, //reversible VLC
  2484. // for texture coding
  2485. rgfQuant,
  2486. rgbLoadIntraMatrix,
  2487. rgppiIntraQuantizerMatrix,
  2488. rgbLoadInterMatrix,
  2489. rgppiInterQuantizerMatrix,
  2490. rgiIntraDCSwitchingThr, //threshold to code dc as ac when pred. is on
  2491. rgiIStep, // I-VOP quantization stepsize
  2492. rgiPStep, // P-VOP quantization stepsize
  2493. rgbLoadIntraMatrixAlpha,
  2494. rgppiIntraQuantizerMatrixAlpha,
  2495. rgbLoadInterMatrixAlpha,
  2496. rgppiInterQuantizerMatrixAlpha,
  2497. rgiIStepAlpha, // I-VOP gray alpha quantization stepsize
  2498. rgiPStepAlpha, // P-VOP gray alpha quantization stepsize
  2499. rgiBStepAlpha, // B-VOP gray alpha quantization stepsize
  2500. rgbNoGrayQuantUpdate, //disable gray quant update within VOP
  2501. rgiStepBCode, // code for quantization stepsize for B-VOP
  2502. rgiNumBbetweenPVOP, // no of B-VOPs between P-VOPs
  2503. rgiNumPbetweenIVOP, // no of P-VOPs between I-VOPs
  2504. rgiGOVperiod,
  2505. rgbDeblockFilterDisable, //disable deblocing filter
  2506. rgbAllowSkippedPMBs,
  2508. // file information
  2509. pchPrefix, // prefix name of the movie
  2510. pchBmpDir, // bmp file directory location
  2511. rgfChrType,
  2512. pchOutBmpDir, // quantized frame file directory
  2513. pchOutStrFile, // output bitstream file
  2514. rgiTSRate,
  2515. rgiEnhcTSRate, // frame rate for enhancement layer // added by Sharp (98/02/09)
  2517. rgbDumpMB,
  2518. rgbTrace,
  2519. rgbRoundingControlDisable,
  2520. rgiInitialRoundingType,
  2521. rguiSpriteUsage,
  2522. rguiWarpingAccuracy,
  2523. rgiNumPnts,
  2524. pchSptDir,
  2525. pchSptPntDir,
  2526.             rgSpriteMode,
  2527. iSpatialOption,
  2528. uiFrmWidth_SS,
  2529. uiFrmHeight_SS,
  2530. uiHor_sampling_n,
  2531. uiHor_sampling_m,
  2532. uiVer_sampling_n,
  2533. uiVer_sampling_m
  2534. );
  2535. #endif
  2537. #ifdef __PC_COMPILER_
  2538. Int tickBegin = ::GetTickCount ();
  2539. #endif // __PC_COMPILER_
  2541. penc->encode();
  2543. #ifdef __PC_COMPILER_
  2544. Int tickAfter = ::GetTickCount ();
  2545. Int nFrames = 1 + (lastFrm - firstFrm) / rgiTSRate [0];
  2546. printf ("Total time: %dn", tickAfter - tickBegin);
  2547. Double dAverage = (Double) (tickAfter - tickBegin) / (Double) nFrames;
  2548. printf ("Total frame %dtAverage time: %.6lfn", nFrames, dAverage);
  2549. printf ("FPS %.6lfn", 1000.0 / dAverage);
  2550. #endif // __PC_COMPILER_
  2551. delete penc;
  2553. for (Int iLayer = BASE_LAYER; iLayer <= ENHN_LAYER; iLayer++) {
  2554. delete [] rguiRateControl [iLayer];
  2555. delete [] rguiBitsBudget [iLayer];
  2556. delete [] rgbErrorResilientDisable [iLayer];
  2557. delete [] rgbDataPartitioning [iLayer];
  2558. delete [] rgbReversibleVlc [iLayer];
  2559. delete [] rgiVPBitTh [iLayer];
  2561. // for texture coding
  2562. delete [] rgfQuant [iLayer];
  2563. delete [] rgiIntraDCSwitchingThr [iLayer];
  2564. delete [] rgiIStep [iLayer]; // error signal quantization stepsize
  2565. delete [] rgiPStep [iLayer]; // error signal quantization stepsize
  2566. delete [] rgiIStepAlpha [iLayer]; // error signal quantization stepsize
  2567. delete [] rgiPStepAlpha [iLayer]; // error signal quantization stepsize
  2568. delete [] rgiBStepAlpha [iLayer];
  2569. delete [] rgbNoGrayQuantUpdate [iLayer]; //discouple change of gray quant with tex. quant
  2570. delete [] rgiStepBCode [iLayer]; // error signal quantization stepsize
  2571. delete [] rgbLoadIntraMatrix [iLayer];
  2572. delete [] rgbLoadInterMatrix [iLayer];
  2573. delete [] rgbLoadIntraMatrixAlpha [iLayer];
  2574. delete [] rgbLoadInterMatrixAlpha [iLayer];
  2575. for (iObj = 0; iObj < nVO; iObj++) {
  2576. delete [] rgppiIntraQuantizerMatrix  [iLayer] [iObj];
  2577. delete [] rgppiInterQuantizerMatrix  [iLayer] [iObj];
  2578. delete [] rgppiIntraQuantizerMatrixAlpha  [iLayer] [iObj];
  2579. delete [] rgppiInterQuantizerMatrixAlpha  [iLayer] [iObj];
  2580. if(pchMVFileName [iLayer] [iObj]!=NULL)
  2581. delete [] pchMVFileName [iLayer] [iObj];
  2583. }
  2584. delete [] rgppiIntraQuantizerMatrix [iLayer];
  2585. delete [] rgppiInterQuantizerMatrix [iLayer];
  2586. delete [] rgppiIntraQuantizerMatrixAlpha [iLayer];
  2587. delete [] rgppiInterQuantizerMatrixAlpha [iLayer];
  2588. delete [] pchMVFileName [iLayer];
  2590. // for motion esti.
  2591. delete [] rgbOriginalME [iLayer];
  2592. delete [] rgbAdvPredDisable [iLayer];
  2593. delete [] rguiSearchRange [iLayer];
  2595. // for interlace coding
  2596. delete [] rgbInterlacedCoding [iLayer];
  2597. delete [] rgbTopFieldFirst [iLayer];
  2598. delete [] rgiDirectModeRadius [iLayer];
  2599. delete [] rgiMVFileUsage [iLayer];
  2601. delete [] rgdFrameFrequency [iLayer];
  2602. delete [] rgbAlternateScan [iLayer];
  2605. delete [] rgbComplexityEstimationDisable [iLayer];
  2606. delete [] rgbOpaque [iLayer];
  2607. delete [] rgbTransparent [iLayer];
  2608. delete [] rgbIntraCAE [iLayer];
  2609. delete [] rgbInterCAE [iLayer];
  2610. delete [] rgbNoUpdate [iLayer];
  2611. delete [] rgbUpsampling [iLayer];
  2612. delete [] rgbIntraBlocks [iLayer];
  2613. delete [] rgbInterBlocks [iLayer];
  2614. delete [] rgbInter4vBlocks [iLayer];
  2615. delete [] rgbNotCodedBlocks [iLayer];
  2616. delete [] rgbDCTCoefs [iLayer];
  2617. delete [] rgbDCTLines [iLayer];
  2618. delete [] rgbVLCSymbols [iLayer];
  2619. delete [] rgbVLCBits [iLayer];
  2620. delete [] rgbAPM [iLayer];
  2621. delete [] rgbNPM [iLayer];
  2622. delete [] rgbInterpolateMCQ [iLayer];
  2623. delete [] rgbForwBackMCQ [iLayer];
  2624. delete [] rgbHalfpel2 [iLayer];
  2625. delete [] rgbHalfpel4 [iLayer];
  2627. delete [] rguiVolControlParameters [iLayer];
  2628. delete [] rguiChromaFormat [iLayer];
  2629. delete [] rguiLowDelay [iLayer];
  2630. delete [] rguiVBVParams [iLayer];
  2631. delete [] rguiBitRate [iLayer];
  2632. delete [] rguiVbvBufferSize [iLayer];
  2633. delete [] rguiVbvBufferOccupany [iLayer];
  2634. }
  2636. delete [] rgbScalability;
  2637.     delete [] rgbSpatialScalability;
  2638. delete [] rgiTemporalScalabilityType;
  2639. delete [] rgiEnhancementType;
  2641. // for mask coding, should fill in later on
  2642. delete [] rgfAlphaUsage; // alpha usage for each VO.  0: binary, 1: 8-bit
  2643. delete [] rgbShapeOnly;
  2644. delete [] rgiBinaryAlphaTH;
  2645. delete [] rgiBinaryAlphaRR; // Added for error resilient mode by Toshiba(1997-11-14)
  2646. delete [] rgbNoCrChange;
  2648. delete [] rgbDeblockFilterDisable;
  2649. delete [] rgfChrType;
  2650. delete [] rgiNumBbetweenPVOP; // no of B-VOPs between P-VOPs
  2651. delete [] rgiNumPbetweenIVOP; // no of P-VOPs between I-VOPs
  2652. //added to encode GOV header by SONY 980212
  2653. delete [] rgiGOVperiod;
  2654. //980212
  2655. delete [] rgiTSRate;
  2656. delete [] rgiEnhcTSRate; // added by Norio Ito
  2657. delete [] rgbAllowSkippedPMBs;
  2659. // rounding control
  2660. delete [] rgbRoundingControlDisable;
  2661. delete [] rgiInitialRoundingType;
  2663. // sprite
  2664. delete [] rguiSpriteUsage;
  2665. delete [] rguiWarpingAccuracy;
  2666. delete [] rgiNumPnts;
  2667. delete [] rgbDumpMB;
  2668. delete [] rgbTrace;
  2669. delete [] rgSpriteMode;
  2671. delete pchPrefix;
  2672. delete pchBmpDir;
  2673. delete pchOutBmpDir;
  2674. delete pchOutStrFile;
  2675. delete pchSptDir;
  2676. delete pchSptPntDir;
  2678. return 0;
  2679. }
  2682. Void nextValidLine (FILE *pfPara, UInt* pnLine) {
  2684. U8 chBoL = 0;
  2685. Char pchPlaceHolder[200];
  2686. fgets (pchPlaceHolder, 200, pfPara); // get the next line 
  2687. (*pnLine)++;
  2688. while (feof (pfPara) == 0 && (chBoL = fgetc(pfPara)) == '%') {
  2689. // skip a line
  2690. fgets (pchPlaceHolder, 200, pfPara); // get the next line 
  2691. (*pnLine)++;
  2692. }
  2693. ungetc (chBoL, pfPara);
  2695. }
  2697. ///// WAVELET VTC: begin ///////////////////////////////
  2699. Void readVTCParam(CVTCEncoder *pvtcenc, FILE *pfVTCPara, UInt* pnLine) {
  2701. // source image path
  2702. Char *cImagePath;
  2703. cImagePath = new char[80];
  2704. nextValidLine (pfVTCPara, pnLine);
  2705. if ( fscanf (pfVTCPara, "%s", cImagePath) != 1) {
  2706. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2707. assert (FALSE);
  2708. }
  2710. // Alpha Channel 
  2711. UInt uiAlphaChannel;
  2712. nextValidLine (pfVTCPara, pnLine);
  2713. if ( fscanf (pfVTCPara, "%d", &uiAlphaChannel) != 1) {
  2714. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2715. assert (FALSE);
  2716. }
  2718. // segmentation map image path
  2719. Char *cSegImagePath;
  2720. cSegImagePath = new char[80];
  2721. nextValidLine (pfVTCPara, pnLine);
  2722. if ( fscanf (pfVTCPara, "%s", cSegImagePath) != 1) {
  2723. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2724. assert (FALSE);
  2725. }
  2727. // Alpha threshold
  2728. UInt uiAlphaTh;
  2729. nextValidLine (pfVTCPara, pnLine);
  2730. if ( fscanf (pfVTCPara, "%d", &uiAlphaTh) != 1) {
  2731. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2732. assert (FALSE);
  2733. }
  2735. // Alpha Change CR Disable 
  2736. UInt uiChangeCRDisable;
  2737. nextValidLine (pfVTCPara, pnLine);
  2738. if ( fscanf (pfVTCPara, "%d", &uiChangeCRDisable) != 1) {
  2739. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2740. assert (FALSE);
  2741. }
  2743. // output bitstream file 
  2744. Char *cOutBitsFile;
  2745. cOutBitsFile = new char[80];
  2746. nextValidLine (pfVTCPara, pnLine);
  2747. if ( fscanf (pfVTCPara, "%s", cOutBitsFile) != 1) {
  2748. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2749. assert (FALSE);
  2750. }
  2752. // color components
  2753. UInt uiColors;
  2754. nextValidLine (pfVTCPara, pnLine);
  2755. if ( fscanf (pfVTCPara, "%d", &uiColors) != 1) {
  2756. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2757. assert (FALSE);
  2758. }
  2760. // Frame width
  2761. UInt uiFrmWidth;
  2762. nextValidLine (pfVTCPara, pnLine);
  2763. if ( fscanf (pfVTCPara, "%d", &uiFrmWidth) != 1) {
  2764. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2765. assert (FALSE);
  2766. }
  2768. // Frame height
  2769. UInt uiFrmHeight; // frame height
  2770. nextValidLine (pfVTCPara, pnLine);
  2771. if ( fscanf (pfVTCPara, "%d", &uiFrmHeight) != 1) {
  2772. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2773. assert (FALSE);
  2774. }
  2776. // wavelet decomposition
  2777. UInt uiWvtDecmpLev;
  2778. nextValidLine (pfVTCPara, pnLine);
  2779. if ( fscanf (pfVTCPara, "%d", &uiWvtDecmpLev) != 1) {
  2780. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2781. assert (FALSE);
  2782. }
  2785. // wavelet type
  2786. UInt uiWvtType;
  2787. nextValidLine (pfVTCPara, pnLine);
  2788. if ( fscanf (pfVTCPara, "%d", &uiWvtType) != 1) {
  2789. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2790. assert (FALSE);
  2791. }
  2793. // hjlee 0901
  2794. // wavelet download ?
  2795. UInt uiWvtDownload;
  2796. nextValidLine (pfVTCPara, pnLine);
  2797. if ( fscanf (pfVTCPara, "%d", &uiWvtDownload) != 1) {
  2798. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2799. assert (FALSE);
  2800. }
  2802. // hjlee 0901
  2803. // wavelet uniform ?
  2804. UInt uiWvtUniform;
  2805. Int  *iWvtFilters;
  2806. nextValidLine (pfVTCPara, pnLine);
  2807. if ( fscanf (pfVTCPara, "%d", &uiWvtUniform) != 1) {
  2808. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2809. assert (FALSE);
  2810. }
  2813. /* default wavelet filters are uniform */
  2814.     if (!uiWvtDownload) 
  2815. uiWvtUniform=1;
  2816.     if (uiWvtUniform)
  2817. iWvtFilters = (Int *)malloc(sizeof(Int));
  2818.     else
  2819. iWvtFilters = (Int *)malloc(sizeof(Int)*uiWvtDecmpLev);
  2820.   
  2821.     if (iWvtFilters==NULL) 
  2822.       exit(printf("error allocating memory:  iWvtFiltersn"));
  2823.      /* read in filter numbers if applicable */
  2824.      /* for int type filter: 0, 2, 4 */
  2825.      /* for float type: 1, 3, 5-10 */
  2826.   
  2827.     if (!uiWvtDownload) {
  2828.        if (uiWvtType==0)
  2829.           iWvtFilters[0]=0;
  2830.        else
  2831.           iWvtFilters[0]=1;
  2833. }
  2834.     else if (uiWvtUniform) {
  2835. nextValidLine (pfVTCPara, pnLine);
  2836.        fscanf(pfVTCPara,"%d", iWvtFilters);
  2837.        /* check to see if the filters match its type */
  2838.        if (iWvtFilters[0] !=0 &&
  2839.            iWvtFilters[0] !=2 &&
  2840.            iWvtFilters[0] !=4) {
  2841.           if (uiWvtType==0)
  2842.          exit(printf("Filter %d is not integer filter.n", iWvtFilters[0]));
  2843.    }
  2844.        else {
  2845.           if (uiWvtType!=0)
  2846.          exit(printf("Filter %d is not float filter.n", iWvtFilters[0]));
  2847.    }
  2848. }
  2849.     else {
  2850. nextValidLine (pfVTCPara, pnLine);
  2851.        for (int spa_lev=0; spa_lev<(int)uiWvtDecmpLev; spa_lev++) {
  2852.           fscanf(pfVTCPara,"%d", iWvtFilters+spa_lev);
  2853.           /* check to see if the filters match its type */
  2854.           if (iWvtFilters[spa_lev] !=0  &&
  2855.           iWvtFilters[spa_lev] !=2 &&
  2856.   iWvtFilters[spa_lev] !=4) {
  2857.           if (uiWvtType==0)
  2858.              exit(printf("Filter %d is not integer filter.n", iWvtFilters[spa_lev]));
  2859.   }
  2860.           else {
  2861.         if (uiWvtType!=0)
  2862.            exit(printf("Filter %d is not float filter.n", iWvtFilters[spa_lev]));
  2863.   }
  2864.    }
  2865. }
  2867. // quantization type 
  2868. UInt uiQuantType;
  2869. nextValidLine (pfVTCPara, pnLine);
  2870. if ( fscanf (pfVTCPara, "%d", &uiQuantType) != 1) {
  2871. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2872. assert (FALSE);
  2873. }
  2875. // scan direction
  2876. UInt uiScanDirection;
  2877. nextValidLine (pfVTCPara, pnLine);
  2878. if ( fscanf (pfVTCPara, "%d", &uiScanDirection) != 1) {
  2879. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2880. assert (FALSE);
  2881. }
  2883. // Start Code Enable 
  2884. UInt bStartCodeEnable;
  2885. nextValidLine (pfVTCPara, pnLine);
  2886. if ( fscanf (pfVTCPara, "%d", &bStartCodeEnable) != 1) {
  2887. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2888. assert (FALSE);
  2889. }
  2891. // target spatial level 
  2892. UInt uiTargetSpatialLev;
  2893. nextValidLine (pfVTCPara, pnLine);
  2894. if ( fscanf (pfVTCPara, "%d", &uiTargetSpatialLev) != 1) {
  2895. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2896. assert (FALSE);
  2897. }
  2899. // target SNR level
  2900. UInt uiTargetSNRLev;
  2901. nextValidLine (pfVTCPara, pnLine);
  2902. if ( fscanf (pfVTCPara, "%d", &uiTargetSNRLev) != 1) {
  2903. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2904. assert (FALSE);
  2905. }
  2907. // DC-Y quantization
  2908. UInt uiQdcY;
  2909. nextValidLine (pfVTCPara, pnLine);
  2910. if ( fscanf (pfVTCPara, "%d", &uiQdcY) != 1) {
  2911. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2912. assert (FALSE);
  2913. }
  2915. // DC-UV quantization
  2916. UInt uiQdcUV;
  2917. nextValidLine (pfVTCPara, pnLine);
  2918. if ( fscanf (pfVTCPara, "%d", &uiQdcUV) != 1) {
  2919. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2920. assert (FALSE);
  2921. }
  2923. // number of spatial scalabilities
  2924. UInt uiSpatialLev;
  2925. nextValidLine (pfVTCPara, pnLine);
  2926. if ( fscanf (pfVTCPara, "%d", &uiSpatialLev) != 1) {
  2927. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2928. assert (FALSE);
  2929. }
  2931. // hjlee 0901
  2932.     /* spatial layer flexability  */
  2933. UInt defaultSpatialScale;
  2934. Int  lastWvtDecompInSpaLayer[MAXDECOMPLEV];
  2936.     if (uiQuantType == 2)
  2937. {
  2938.        if (uiSpatialLev != uiWvtDecmpLev)
  2939.        {
  2940.      /* read in usedefault */
  2941.      fscanf(pfVTCPara,"%d",&defaultSpatialScale);
  2942.      if (defaultSpatialScale==0)
  2943.  {
  2944.        /* read in spatial layer info */
  2945.        for (int spa_lev=0; spa_lev<(int)uiSpatialLev-1; ++spa_lev)   
  2946.            fscanf(pfVTCPara,"%d",&lastWvtDecompInSpaLayer[spa_lev]);
  2947.  }
  2948.        }
  2949. }
  2953. UInt uispa_lev;
  2954. UInt uisnr_lev;
  2955. SNR_PARAM *Qinfo[3];
  2956. UInt uiSNRLev;
  2957. UInt uiQuant;
  2958. Int i;
  2959. // hjlee 0901
  2961. /* SQ-BB scanning */
  2962. if (uiQuantType==1 && uiScanDirection==1) {
  2964. nextValidLine (pfVTCPara, pnLine);
  2965. if ( fscanf (pfVTCPara, "%d", &uiSNRLev) != 1) {
  2966. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2967. assert (FALSE);
  2968. }
  2970. uiSpatialLev = uiWvtDecmpLev;
  2971. for (int i=0; i<3; i++)
  2972. Qinfo[i] = new SNR_PARAM[uiSpatialLev];
  2973. for (uispa_lev=0; uispa_lev<uiSpatialLev; uispa_lev++) {
  2974. for (int col=0; col<3; col++) {
  2975. Qinfo[col][uispa_lev].SNR_scalability_levels = (int)1;
  2976. Qinfo[col][uispa_lev].Quant = new Int[uiSNRLev];
  2977. }
  2978. }
  2979. // read quant-Y
  2980. if ( fscanf (pfVTCPara, "%d", &uiQuant) != 1) {
  2981. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2982. assert (FALSE);
  2983. }
  2984. Qinfo[0][0].Quant[0] = uiQuant;
  2986. // read quant-UV
  2987. if (uiColors==3) {
  2988. if ( fscanf (pfVTCPara, "%d", &uiQuant) != 1) {
  2989. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  2990. assert (FALSE);
  2991. }
  2992. Qinfo[1][0].Quant[0] = uiQuant;
  2993. Qinfo[2][0].Quant[0] = uiQuant;
  2994. }
  2996. }
  2997. else {
  2999. for (i=0; i<3; i++)
  3000. Qinfo[i] = new SNR_PARAM[uiSpatialLev];
  3001. for (uispa_lev=0; uispa_lev<uiSpatialLev; uispa_lev++) {
  3002. // number of spatial scalabilities
  3003. nextValidLine (pfVTCPara, pnLine);
  3004. if ( fscanf (pfVTCPara, "%d", &uiSNRLev) != 1) {
  3005. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  3006. assert (FALSE);
  3007. }
  3009. for (int col=0; col<3; col++) {
  3010. Qinfo[col][uispa_lev].SNR_scalability_levels = (int)uiSNRLev;
  3011. Qinfo[col][uispa_lev].Quant = new Int[uiSNRLev];
  3012. }
  3014. for (uisnr_lev=0; uisnr_lev<uiSNRLev; uisnr_lev++) {
  3016. // read quant-Y
  3017. if ( fscanf (pfVTCPara, "%d", &uiQuant) != 1) {
  3018. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  3019. assert (FALSE);
  3020. }
  3021. Qinfo[0][uispa_lev].Quant[uisnr_lev] = uiQuant;
  3023. // read quant-UV
  3024. if (uiColors==3) {
  3025. if ( fscanf (pfVTCPara, "%d", &uiQuant) != 1) {
  3026. fprintf(stderr, "wrong parameter on line %dn", *pnLine);
  3027. assert (FALSE);
  3028. }
  3029. Qinfo[1][uispa_lev].Quant[uisnr_lev] = uiQuant;
  3030. Qinfo[2][uispa_lev].Quant[uisnr_lev] = uiQuant;
  3031. }
  3032. }
  3033. }
  3034. }
  3036. pvtcenc -> init(
  3037.  cImagePath,
  3038.  uiAlphaChannel,
  3039.  cSegImagePath,
  3040.  uiAlphaTh,
  3041.  uiChangeCRDisable,
  3042.  cOutBitsFile,
  3043.  uiColors,
  3044.  uiFrmWidth,
  3045.  uiFrmHeight,
  3046.  uiWvtType,
  3047.  uiWvtDownload, // hjlee 0901
  3048.      uiWvtDecmpLev,
  3049.      uiWvtUniform, // hjlee 0901
  3050.  iWvtFilters,  // hjlee 0901
  3051.  uiQuantType,
  3052.  uiScanDirection,
  3053.  bStartCodeEnable,
  3054.  uiTargetSpatialLev,
  3055.  uiTargetSNRLev,
  3056.  uiQdcY,
  3057.  uiQdcUV, 
  3058.  uiSpatialLev,
  3059.  defaultSpatialScale, // hjlee 0901
  3060.      lastWvtDecompInSpaLayer, // hjlee 0901
  3061.  Qinfo  
  3062. );
  3063. }
  3065. ///// WAVELET VTC: end ///////////////////////////////
  3067. Void readBoolVOLFlag (Bool * rgbTable [2], UInt nVO, FILE * pfCfg, UInt * pnLine, Bool bAnyScalability)
  3068. {
  3069. nextValidLine (pfCfg, pnLine);
  3070. for (UInt i = 0; i < nVO; ++i) {
  3071. if (fscanf (pfCfg, "%d", & rgbTable [BASE_LAYER] [i]) != 1) {
  3072. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  3073. exit (1);
  3074. }
  3075. assert (rgbTable [BASE_LAYER] [i] == 0 || rgbTable [BASE_LAYER] [i] == 1);
  3076. }
  3077. if (bAnyScalability) {
  3078. for (UInt i = 0; i < nVO; ++i) {
  3079. if (fscanf (pfCfg, "%d", & rgbTable [ENHN_LAYER] [i]) != 1) {
  3080. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  3081. exit (1);
  3082. }
  3083. assert (rgbTable [ENHN_LAYER] [i] == 0 || rgbTable [ENHN_LAYER] [i] == 1);
  3084. }
  3085. }
  3086. }
  3088. Void readItem(UInt *rguiTable [2], UInt nVO, FILE * pfCfg, UInt * pnLine, Bool bAnyScalability)
  3089. {
  3090. nextValidLine (pfCfg, pnLine);
  3091. for (UInt i = 0; i < nVO; ++i) {
  3092. if (fscanf (pfCfg, "%d", & rguiTable [BASE_LAYER] [i]) != 1) {
  3093. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  3094. exit (1);
  3095. }
  3096. }
  3097. if (bAnyScalability) 
  3098. {
  3099. for (UInt i = 0; i < nVO; ++i) {
  3100. if (fscanf (pfCfg, "%d", & rguiTable [ENHN_LAYER] [i]) != 1) {
  3101. fprintf(stderr, "wrong parameter file format on line %dn", *pnLine);
  3102. exit (1);
  3103. }
  3104. }
  3105. }
  3106. }
  3108. Void RunVTCCodec(char *VTCCtlFile)
  3109. {
  3110. UInt nLine = 1;
  3111. UInt* pnLine = &nLine;
  3112. FILE *pfVTCPara;
  3113. if ((pfVTCPara = fopen (VTCCtlFile, "r")) == NULL ){
  3114. printf (" vtc Parameter File Not Foundn");
  3115. exit (1);
  3116. }
  3118. CVTCEncoder vtcenc;
  3120. // read VTC control parameters
  3121. readVTCParam(&vtcenc, pfVTCPara, pnLine);
  3123. fclose(pfVTCPara);
  3125. // start VTC encoding
  3126. int targetSpatialLev = vtcenc.mzte_codec.m_iTargetSpatialLev;
  3127. int targetSNRLev = vtcenc.mzte_codec.m_iTargetSNRLev;
  3129. vtcenc.encode();
  3131. // start VTC decoding 
  3132. CVTCDecoder vtcdec;
  3133. vtcdec.decode(vtcenc.m_cOutBitsFile, "encRec.yuv", 
  3134. targetSpatialLev, targetSNRLev );
  3135. }
  3137. Void GetIVal(CxParamSet *pPar, char *pchName, Int iInd, Int *piRtn)
  3138. {
  3139. Double dVal;
  3140. Int er = pPar->GetDouble(pchName, iInd, &dVal);
  3141. if(er!=ERES_OK)
  3142. {
  3143. if(iInd<0)
  3144. printf("Error: can't find %s in parameter file.n", pchName);
  3145. else
  3146. printf("Error: can't find %s[%d] in parameter file.n", pchName, iInd);
  3147. exit(1);
  3148. }
  3149. *piRtn = (Int)dVal;
  3150. }
  3152. Void GetDVal(CxParamSet *pPar, char *pchName, Int iInd, Double *pdRtn)
  3153. {
  3154. Double dVal;
  3155. Int er = pPar->GetDouble(pchName, iInd, &dVal);
  3156. if(er!=ERES_OK)
  3157. {
  3158. if(iInd<0)
  3159. printf("Error: can't find %s in parameter file.n", pchName);
  3160. else
  3161. printf("Error: can't find %s[%d] in parameter file.n", pchName, iInd);
  3162. exit(1);
  3163. }
  3164. *pdRtn = dVal;
  3165. }
  3167. Void GetSVal(CxParamSet *pPar, char *pchName, Int iInd, char **ppchRtn)
  3168. {
  3169. char *pchVal;
  3170. Int er = pPar->GetString(pchName, iInd, &pchVal);
  3171. if(er!=ERES_OK)
  3172. {
  3173. if(iInd<0)
  3174. printf("Error: can't find %s in parameter file.n", pchName);
  3175. else
  3176. printf("Error: can't find %s[%d] in parameter file.n", pchName, iInd);
  3177. exit(1);
  3178. }
  3179. *ppchRtn = pchVal;
  3180. }
  3182. Void GetAVal(CxParamSet *pPar, char *pchName, Int iInd, Double **ppdRtn, Int *piCount)
  3183. {
  3184. Int er = pPar->GetArray(pchName, iInd, ppdRtn, piCount);
  3185. if(er!=ERES_OK)
  3186. {
  3187. if(iInd<0)
  3188. printf("Error: can't find %s in parameter file.n", pchName);
  3189. else
  3190. printf("Error: can't find %s[%d] in parameter file.n", pchName, iInd);
  3191. exit(1);
  3192. }
  3193. }
  3195. Void readBoolParam(CxParamSet *pPar, char *pchName, Int iInd, Bool *pbVal)
  3196. {
  3197. Int iVal;
  3198. GetIVal(pPar, pchName, iInd, &iVal);
  3199. if(iVal!=0 && iVal!=1)
  3200. {
  3201. char rgchErr[100];
  3202. sprintf(rgchErr, "%s must be 0 or 1", pchName);
  3203. fatal_error(rgchErr);
  3204. }
  3206. *pbVal = (Bool)iVal;
  3207. }