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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

sesenc.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. (date: March, 1996)
  10. and edited by
  11.         Wei Wu (weiwu@stallion.risc.rockwell.com) Rockwell Science Center
  13. and also edited by
  14. Yoshihiro Kikuchi (TOSHIBA CORPORATION)
  15. Takeshi Nagai (TOSHIBA CORPORATION)
  16. Toshiaki Watanabe (TOSHIBA CORPORATION)
  17. Noboru Yamaguchi (TOSHIBA CORPORATION)
  19. Marc Mongenet (Marc.Mongenet@epfl.ch), Swiss Federal Institute of Technology, Lausanne (EPFL)
  21. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  22. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  23. as specified by the MPEG-4 Video. 
  24. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  25. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  26. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
  27. The original developer of this software module and his/her company, 
  28. the subsequent editors and their companies, 
  29. and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
  30. Copyright is not released for non MPEG-4 Video conforming products. 
  31. Microsoft retains full right to use the code for his/her own purpose, 
  32. assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
  33. This copyright notice must be included in all copies or derivative works. 
  35. Copyright (c) 1996, 1997.
  38. Module Name:
  40. sesEnc.cpp
  42. Abstract:
  44. Encoder for one video session.
  46. Revision History:
  47. Sept. 30, 1997: Error resilient tools added by Toshiba
  48. Nov.  27, 1997: Spatial Scalable tools added, and modified for Spatial Scalable
  49. by Takefumi Nagumo(nagumo@av.crl.sony.co.jp) SONY
  50. Dec 11, 1997: Interlaced tools added by NextLevel Systems (GI)
  51. (B.Eifrig, beifrig@nlvl.com, X.Chen, xchen@nlvl.com)
  52. Jun 17, 1998: add Complexity Estimation syntax support
  53. Marc Mongenet (Marc.Mongenet@epfl) - EPFL
  54. May 9, 1999: tm5 rate control by DemoGraFX, duhoff@mediaone.net
  56. *************************************************************************/
  58. #include "stdlib.h"
  59. #include "stdio.h"
  60. #include "math.h"
  61. #include "fstream.h"
  62. #include "iostream.h"
  64. #include "typeapi.h"
  65. #include "codehead.h"
  66. #include "global.hpp"
  67. #include "entropy/bitstrm.hpp"
  68. #include "entropy/entropy.hpp"
  69. #include "entropy/huffman.hpp"
  71. #include "mode.hpp"
  72. #include "sesenc.hpp"
  74. #include "tps_enhcbuf.hpp" // added by Sharp (98/2/12)
  75. #include "vopses.hpp"
  76. #include "vopseenc.hpp"
  77. #include "enhcbufenc.hpp" // added by Sharp (98/2/12)
  79. #ifdef __MFC_
  80. #ifdef _DEBUG
  81. #undef THIS_FILE
  82. static char BASED_CODE THIS_FILE[] = __FILE__;
  83. #endif
  85. #define new DEBUG_NEW    
  86. #endif // __MFC_
  88. #ifdef __PC_COMPILER_ //OS specific stuff
  89. #define SUB_CMPFILE "%s\%2.2d\%s.cmp"
  90. #define SUB_TRCFILE "%s\%2.2d\%s.trc"
  91. #define SUB_YUVFILE "%s\%2.2d\%s.yuv"
  92. #define SUB_SEGFILE "%s\%2.2d\%s.seg"
  93. #define ENHN_SUB_CMPFILE "%s\%2.2d\%s_e.cmp"
  94. #define ENHN_SUB_TRCFILE "%s\%2.2d\%s_e.trc"
  95. #define ENHN_SUB_YUVFILE "%s\%2.2d\%s_e.yuv"
  96. #define ENHN_SUB_SEGFILE "%s\%2.2d\%s_e.seg"
  97. #define SUB_VDLFILE "%s\%2.2d\%s.spt" //for sprite i/o
  98. #define SUB_PNTFILE "%s\%2.2d\%s.pnt" //for sprite i/o
  99. #define ROOT_YUVFILE "%s\%s.yuv"
  100. #define ROOT_SEGFILE "%s\%s.seg"
  101. #define IOS_BINARY ios::binary
  102. #define MKDIR "mkdir %s\%2.2d"
  103. #else
  104. #define SUB_CMPFILE "%s/%2.2d/%s.cmp"
  105. #define SUB_TRCFILE "%s/%2.2d/%s.trc"
  106. #define SUB_YUVFILE "%s/%2.2d/%s.yuv"
  107. #define SUB_SEGFILE "%s/%2.2d/%s.seg"
  108. #define ENHN_SUB_CMPFILE "%s/%2.2d/%s_e.cmp"
  109. #define ENHN_SUB_TRCFILE "%s/%2.2d/%s_e.trc"
  110. #define ENHN_SUB_YUVFILE "%s/%2.2d/%s_e.yuv"
  111. #define ENHN_SUB_SEGFILE "%s/%2.2d/%s_e.seg"
  112. #define SUB_VDLFILE "%s/%2.2d/%s.vdl" //for sprite i/o
  113. #define SUB_PNTFILE "%s/%2.2d/%s.pnt" //for sprite i/o
  114. #define ROOT_YUVFILE "%s/%s.yuv"
  115. #define ROOT_SEGFILE "%s/%s.seg"
  116. #define IOS_BINARY ios::binary
  117. //#define IOS_BINARY 0
  118. #define MKDIR "mkdir %s/%2.2d"
  119. #endif
  121. #define BASE_LAYER 0
  122. #define ENHN_LAYER 1
  124. #define _FOR_GSSP_
  126. Bool fileExistence (const Char* pchFile) 
  127. {
  128. Bool ret = 1;
  129. FILE* pf = fopen (pchFile, "r");
  130. if (pf == NULL)
  131. ret = 0;
  132. else
  133. fclose (pf);
  134. return ret;
  135. }
  137. Void CSessionEncoder::createReconDir (UInt idx) const
  138. {
  139. Char pchTmp [100];
  140. sprintf (pchTmp, SUB_YUVFILE, m_pchReconYUVDir, idx, m_pchPrefix);
  141. FILE* pf = fopen (pchTmp, "wb");
  142. if (pf == NULL) {
  143. sprintf (pchTmp, MKDIR, m_pchReconYUVDir, idx);
  144. system (pchTmp);
  145. }
  146. else
  147. fclose (pf);
  148. }
  150. Void CSessionEncoder::createCmpDir (UInt idx) const
  151. {
  152. Char pchTmp [100];
  153. sprintf (pchTmp, SUB_CMPFILE, m_pchOutStrFiles, idx, m_pchPrefix);
  154. FILE* pf = fopen (pchTmp, "wb");
  155. if (pf == NULL) {
  156. sprintf (pchTmp, MKDIR, m_pchOutStrFiles, idx);
  157. system (pchTmp);
  158. }
  159. else
  160. fclose (pf);
  161. }
  163. CSessionEncoder::~CSessionEncoder ()
  164. {
  165. delete [] m_rgvolmd [BASE_LAYER];
  166. delete [] m_rgvolmd [ENHN_LAYER];
  167. delete [] m_rgvopmd [BASE_LAYER];
  168. delete [] m_rgvopmd [ENHN_LAYER];
  170. // sprite 
  171. for (Int iVO = 0; iVO < m_iNumVO; iVO++) {
  172. delete [] m_ppstSrc [iVO];
  173. for (Int ifr = 0; ifr < m_iNumFrame; ifr++)
  174. delete [] m_pppstDst [iVO] [ifr];
  175. delete [] m_pppstDst [iVO];
  176. }
  177. delete [] m_ppstSrc;
  178. delete [] m_pppstDst;
  179. }
  182. CSessionEncoder::CSessionEncoder (CSessionEncoderParams *param)
  183. {
  184. m_iFirstFrame = param->iFirstFrm;
  185. m_iLastFrame = param->iLastFrm;
  186. m_iFirstVO = param->uiFirstVO; 
  187. m_iLastVO = param->iLastVO;
  188. m_rgbSpatialScalability = param->rgbSpatialScalability;
  189. m_rguiRateControl = param->rguiRateControl; 
  190. m_rguiBudget = param->rguiBudget;
  191. m_pchPrefix = param->pchPrefix; 
  192. m_pchBmpFiles = param->pchBmpFiles;
  193. m_rgfChrType = param->rgfChrType; 
  194. m_pchReconYUVDir = param->pchOutBmpFiles; 
  195. m_pchOutStrFiles = param->pchOutStrFiles;
  196. m_pchSptDir = param->pchSptDir; 
  197. m_pchSptPntDir = param->pchSptPntDir;
  198. m_rguiSpriteUsage = param->rguiSpriteUsage; 
  199. m_rguiWarpingAccuracy = param->rguiWarpingAccuracy; 
  200. m_rgNumOfPnts = param->rgNumOfPnts; 
  201. m_rgiTemporalScalabilityType = param->rgiTemporalScalabilityType;
  202. #define PARAM(abc) abc = param->abc
  203.   UInt PARAM(uiFrmWidth);
  204. UInt PARAM(uiFrmHeight);
  205. Bool PARAM(bNot8Bit);
  206. UInt PARAM(uiQuantPrecision);
  207. UInt PARAM(nBits);
  208. const Int* PARAM(rgiEnhancementType);
  210. const AlphaUsage* PARAM(rgfAlphaUsage);
  211. const Bool* PARAM(rgbShapeOnly);
  212. const Int* PARAM(rgiBinaryAlphaTH);
  213. const Int* PARAM(rgiBinaryAlphaRR);
  214. const Bool* PARAM(rgbNoCrChange);
  215. UInt** PARAM(rguiSearchRange);
  216. Bool** PARAM(rgbOriginalForME);
  217. Bool** PARAM(rgbAdvPredDisable);
  218. Bool ** PARAM(rgbComplexityEstimationDisable);
  219. Bool ** PARAM(rgbOpaque);
  220. Bool ** PARAM(rgbTransparent);
  221. Bool ** PARAM(rgbIntraCAE);
  222. Bool ** PARAM(rgbInterCAE);
  223. Bool ** PARAM(rgbNoUpdate);
  224. Bool ** PARAM(rgbUpsampling);
  225. Bool ** PARAM(rgbIntraBlocks);
  226. Bool ** PARAM(rgbInterBlocks);
  227. Bool ** PARAM(rgbInter4vBlocks);
  228. Bool ** PARAM(rgbNotCodedBlocks);
  229. Bool ** PARAM(rgbDCTCoefs);
  230. Bool ** PARAM(rgbDCTLines);
  231. Bool ** PARAM(rgbVLCSymbols);
  232. Bool ** PARAM(rgbVLCBits);
  233. Bool ** PARAM(rgbAPM);
  234. Bool ** PARAM(rgbNPM);
  235. Bool ** PARAM(rgbInterpolateMCQ);
  236. Bool ** PARAM(rgbForwBackMCQ);
  237. Bool ** PARAM(rgbHalfpel2);
  238. Bool ** PARAM(rgbHalfpel4);
  239. UInt ** PARAM(rguiVolControlParameters);
  240. UInt ** PARAM(rguiChromaFormat);
  241. UInt ** PARAM(rguiLowDelay);
  242. UInt ** PARAM(rguiVBVParams);
  243. UInt ** PARAM(rguiBitRate);
  244. UInt ** PARAM(rguiVbvBufferSize);
  245. UInt ** PARAM(rguiVbvBufferOccupany);
  246. Double** PARAM(rgdFrameFrequency);
  247. Bool** PARAM(rgbInterlacedCoding);
  248. Bool** PARAM(rgbTopFieldFirst);
  249. Bool** PARAM(rgbAlternateScan);
  250. Int** PARAM(rgiDirectModeRadius);
  251. Int** PARAM(rgiMVFileUsage);
  252. Char*** PARAM(pchMVFileName);
  253. Int** PARAM(rgbVPBitTh);
  254. Bool** PARAM(rgbDataPartitioning);
  255. Bool** PARAM(rgbReversibleVlc);
  256. Quantizer** PARAM(rgfQuant);
  257. Bool** PARAM(rgbLoadIntraMatrix);
  258. Int*** PARAM(rgppiIntraQuantizerMatrix);
  259. Bool** PARAM(rgbLoadInterMatrix);
  260. Int*** PARAM(rgppiInterQuantizerMatrix);
  261. Int** PARAM(rgiIntraDCSwitchingThr);
  262. Int** PARAM(rgiStepI);
  263. Int** PARAM(rgiStepP);
  264. Bool** PARAM(rgbLoadIntraMatrixAlpha);
  265. Int*** PARAM(rgppiIntraQuantizerMatrixAlpha);
  266. Bool** PARAM(rgbLoadInterMatrixAlpha);
  267. Int*** PARAM(rgppiInterQuantizerMatrixAlpha);
  268. Int** PARAM(rgiStepIAlpha);
  269. Int** PARAM(rgiStepPAlpha);
  270. Int** PARAM(rgiStepBAlpha);
  271. Int** PARAM(rgbNoAlphaQuantUpdate);
  272. Int** PARAM(rgiStepB);
  273. const Int* PARAM(rgiNumOfBbetweenPVOP);
  274. const Int* PARAM(rgiNumOfPbetweenIVOP);
  275. const Int* PARAM(rgiGOVperiod);
  276. const Bool* PARAM(rgbDeblockFilterDisable);
  277. const Bool *PARAM(rgbAllowSkippedPMBs);
  278. const Int* PARAM(rgiTemporalRate);
  279. const Int* PARAM(rgiEnhnTemporalRate);
  280. const Bool* PARAM(rgbDumpMB);
  281. const Bool* PARAM(rgbTrace);
  282. const Bool* PARAM(rgbRoundingControlDisable); 
  283. const Int* PARAM(rgiInitialRoundingType); 
  284. SptMode *PARAM(pSpriteMode);
  285. Int PARAM(iSpatialOption);
  286. UInt PARAM(uiFrmWidth_SS);
  287. UInt PARAM(uiFrmHeight_SS);
  288. UInt PARAM(uiHor_sampling_n);
  289. UInt PARAM(uiHor_sampling_m);
  290. UInt PARAM(uiVer_sampling_n);
  291. UInt PARAM(uiVer_sampling_m);
  292. #undef PARAM
  293. // data preparation
  294. m_iNumFrame = m_iLastFrame - m_iFirstFrame + 1;
  295. assert (m_iNumFrame > 0);
  296. m_rctOrg = CRct (0, 0, uiFrmWidth, uiFrmHeight);
  297. if( uiFrmWidth_SS !=0 && uiFrmHeight_SS!=0)
  298. m_rctOrgSpatialEnhn = CRct(0, 0, uiFrmWidth_SS, uiFrmHeight_SS);
  299. assert (uiFrmWidth <= 8192 && uiFrmHeight <= 8192); //2^13 maximum size
  300. m_iNumVO = m_iLastVO - m_iFirstVO + 1;
  301. assert (m_iNumVO > 0);
  302. m_rgvolmd [BASE_LAYER] = new VOLMode [m_iNumVO];
  303. m_rgvolmd [ENHN_LAYER] = new VOLMode [m_iNumVO];
  304. m_rgvopmd [BASE_LAYER] = new VOPMode [m_iNumVO];
  305. m_rgvopmd [ENHN_LAYER] = new VOPMode [m_iNumVO];
  306. Int iVO;
  307. for (iVO = 0; iVO < m_iNumVO; iVO++) {
  308. // set VOL and VOP mode values
  309. for (Int iLayer = BASE_LAYER; iLayer <= m_rgbSpatialScalability [iVO] * ENHN_LAYER; iLayer++) {
  310. // NBIT
  311. m_rgvolmd [iLayer][iVO].bNot8Bit  = bNot8Bit;
  312. m_rgvolmd [iLayer][iVO].uiQuantPrecision  = uiQuantPrecision;
  313. m_rgvolmd [iLayer][iVO].nBits  = nBits;
  315. m_rgvolmd [iLayer][iVO].volType = (VOLtype) iLayer;
  316. m_rgvolmd [iLayer][iVO].fAUsage = rgfAlphaUsage [iVO];
  317. m_rgvolmd [iLayer][iVO].bShapeOnly = rgbShapeOnly [iVO];
  318. m_rgvolmd [iLayer][iVO].iBinaryAlphaTH = rgiBinaryAlphaTH [iVO] * 16;  //magic no. from the vm
  319. m_rgvolmd [iLayer][iVO].iBinaryAlphaRR = (rgiBinaryAlphaRR [iVO]<0)?-1:(rgiBinaryAlphaRR [iVO] +1)*(rgiNumOfBbetweenPVOP [iVO] +1)*rgiTemporalRate [iVO];  // Binary shape refresh rate: Added for error resilient mode by Toshiba(1997-11-14): Modified (1998-1-16)
  320. m_rgvolmd [iLayer][iVO].bNoCrChange = rgbNoCrChange [iVO];
  321. m_rgvolmd [iLayer][iVO].bOriginalForME = rgbOriginalForME [iLayer][iVO];
  322. m_rgvolmd [iLayer][iVO].bAdvPredDisable = rgbAdvPredDisable [iLayer][iVO];
  323. // START: Complexity Estimation syntax support - Marc Mongenet (EPFL) - 17 Jun 1998
  324. m_rgvolmd [iLayer][iVO].bComplexityEstimationDisable = rgbComplexityEstimationDisable [iLayer][iVO];
  325. m_rgvolmd [iLayer][iVO].bOpaque = rgbOpaque [iLayer][iVO];
  326. m_rgvolmd [iLayer][iVO].bTransparent = rgbTransparent [iLayer][iVO];
  327. m_rgvolmd [iLayer][iVO].bIntraCAE = rgbIntraCAE [iLayer][iVO];
  328. m_rgvolmd [iLayer][iVO].bInterCAE = rgbInterCAE [iLayer][iVO];
  329. m_rgvolmd [iLayer][iVO].bNoUpdate = rgbNoUpdate [iLayer][iVO];
  330. m_rgvolmd [iLayer][iVO].bUpsampling = rgbUpsampling [iLayer][iVO];
  331. m_rgvolmd [iLayer][iVO].bIntraBlocks = rgbIntraBlocks [iLayer][iVO];
  332. m_rgvolmd [iLayer][iVO].bInterBlocks = rgbInterBlocks [iLayer][iVO];
  333. m_rgvolmd [iLayer][iVO].bInter4vBlocks = rgbInter4vBlocks [iLayer][iVO];
  334. m_rgvolmd [iLayer][iVO].bNotCodedBlocks = rgbNotCodedBlocks [iLayer][iVO];
  335. m_rgvolmd [iLayer][iVO].bDCTCoefs = rgbDCTCoefs [iLayer][iVO];
  336. m_rgvolmd [iLayer][iVO].bDCTLines = rgbDCTLines [iLayer][iVO];
  337. m_rgvolmd [iLayer][iVO].bVLCSymbols = rgbVLCSymbols [iLayer][iVO];
  338. m_rgvolmd [iLayer][iVO].bVLCBits = rgbVLCBits [iLayer][iVO];
  339. m_rgvolmd [iLayer][iVO].bAPM = rgbAPM [iLayer][iVO];
  340. m_rgvolmd [iLayer][iVO].bNPM = rgbNPM [iLayer][iVO];
  341. m_rgvolmd [iLayer][iVO].bInterpolateMCQ = rgbInterpolateMCQ [iLayer][iVO];
  342. m_rgvolmd [iLayer][iVO].bForwBackMCQ = rgbForwBackMCQ [iLayer][iVO];
  343. m_rgvolmd [iLayer][iVO].bHalfpel2 = rgbHalfpel2 [iLayer][iVO];
  344. m_rgvolmd [iLayer][iVO].bHalfpel4 = rgbHalfpel4 [iLayer][iVO];
  345. m_rgvolmd [iLayer][iVO].bAllowSkippedPMBs = rgbAllowSkippedPMBs [iVO];
  347. // END: Complexity Estimation syntax support
  348. // START: Vol Control Parameters
  349. if(rguiVolControlParameters[0]!=NULL)
  350. {
  351. m_rgvolmd [iLayer][iVO].uiVolControlParameters = rguiVolControlParameters [iLayer][iVO];
  352. m_rgvolmd [iLayer][iVO].uiChromaFormat = rguiChromaFormat [iLayer][iVO];
  353. m_rgvolmd [iLayer][iVO].uiLowDelay = rguiLowDelay [iLayer][iVO];
  354. m_rgvolmd [iLayer][iVO].uiVBVParams = rguiVBVParams [iLayer][iVO];
  355. m_rgvolmd [iLayer][iVO].uiBitRate = rguiBitRate [iLayer][iVO];
  356. m_rgvolmd [iLayer][iVO].uiVbvBufferSize = rguiVbvBufferSize [iLayer][iVO];
  357. m_rgvolmd [iLayer][iVO].uiVbvBufferOccupany = rguiVbvBufferOccupany [iLayer][iVO];
  358. }
  359. else
  360. m_rgvolmd [iLayer][iVO].uiVolControlParameters = 0;
  361. // END: Vol Control Parameters
  362. m_rgvolmd [iLayer][iVO].bRoundingControlDisable = (iLayer== BASE_LAYER) ? rgbRoundingControlDisable[iVO] : 0;
  363. m_rgvolmd [iLayer][iVO].iInitialRoundingType = (iLayer== BASE_LAYER) ? rgiInitialRoundingType[iVO] : 0;
  364. m_rgvolmd [iLayer][iVO].bVPBitTh = rgbVPBitTh[iLayer][iVO];
  365. m_rgvolmd [iLayer][iVO].bDataPartitioning = rgbDataPartitioning [iLayer][iVO];
  366. m_rgvolmd [iLayer][iVO].bReversibleVlc  = rgbReversibleVlc [iLayer][iVO];
  367. m_rgvolmd [iLayer][iVO].fQuantizer = rgfQuant [iLayer][iVO];
  368. m_rgvolmd [iLayer][iVO].bNoGrayQuantUpdate 
  369. = rgbNoAlphaQuantUpdate [iLayer][iVO];
  370. m_rgvolmd [iLayer][iVO].dFrameHz = rgdFrameFrequency [iLayer][iVO];
  371. m_rgvolmd [iLayer][iVO].iMVRadiusPerFrameAwayFromRef = rguiSearchRange [iLayer][iVO];
  372. m_rgvopmd [iLayer][iVO].iSearchRangeForward = rguiSearchRange [iLayer][iVO];
  373. m_rgvopmd [iLayer][iVO].iSearchRangeBackward= rguiSearchRange [iLayer][iVO];
  374. m_rgvopmd [iLayer][iVO].intStepI = rgiStepI [iLayer][iVO];
  375. m_rgvopmd [iLayer][iVO].intStep = rgiStepP [iLayer][iVO];
  376. m_rgvopmd [iLayer][iVO].intStepB = rgiStepB [iLayer][iVO];
  377. m_rgvopmd [iLayer][iVO].intStepIAlpha = rgiStepIAlpha [iLayer][iVO];
  378. m_rgvopmd [iLayer][iVO].intStepPAlpha = rgiStepPAlpha [iLayer][iVO];
  379. m_rgvopmd [iLayer][iVO].intStepBAlpha = rgiStepBAlpha [iLayer][iVO];
  380. m_rgvopmd [iLayer][iVO].iIntraDcSwitchThr 
  381. = rgiIntraDCSwitchingThr [iLayer][iVO];
  382. m_rgvopmd [iLayer][iVO].bInterlace = rgbInterlacedCoding [iLayer][iVO];
  383. m_rgvopmd [iLayer][iVO].bTopFieldFirst = rgbTopFieldFirst [iLayer][iVO];
  384. m_rgvopmd [iLayer][iVO].bAlternateScan = rgbAlternateScan [iLayer][iVO];
  385. m_rgvopmd [iLayer][iVO].iDirectModeRadius = rgiDirectModeRadius [iLayer][iVO];
  386. m_rgvolmd [iLayer][iVO].bLoadIntraMatrix= rgbLoadIntraMatrix [iLayer][iVO];
  387. m_rgvolmd [iLayer][iVO].bLoadInterMatrix= rgbLoadInterMatrix [iLayer][iVO];
  388. m_rgvolmd [iLayer][iVO].bLoadIntraMatrixAlpha 
  389. = rgbLoadIntraMatrixAlpha [iLayer][iVO];
  390. m_rgvolmd [iLayer][iVO].bLoadInterMatrixAlpha 
  391. = rgbLoadInterMatrixAlpha [iLayer][iVO];
  392. memcpy (m_rgvolmd [iLayer][iVO].rgiIntraQuantizerMatrix, rgppiIntraQuantizerMatrix [iLayer][iVO], BLOCK_SQUARE_SIZE * sizeof (Int));
  393. memcpy (m_rgvolmd [iLayer][iVO].rgiInterQuantizerMatrix, rgppiInterQuantizerMatrix [iLayer][iVO], BLOCK_SQUARE_SIZE * sizeof (Int));
  394. memcpy (m_rgvolmd [iLayer][iVO].rgiIntraQuantizerMatrixAlpha, rgppiIntraQuantizerMatrixAlpha [iLayer][iVO], BLOCK_SQUARE_SIZE * sizeof (Int));
  395. memcpy (m_rgvolmd [iLayer][iVO].rgiInterQuantizerMatrixAlpha, rgppiInterQuantizerMatrixAlpha [iLayer][iVO], BLOCK_SQUARE_SIZE * sizeof (Int));
  397. m_rgvolmd [iLayer][iVO].bDeblockFilterDisable 
  398. = rgbDeblockFilterDisable [iVO];
  399. m_rgvolmd [iLayer][iVO].iBbetweenP = rgiNumOfBbetweenPVOP [iVO];
  400. m_rgvolmd [iLayer][iVO].iPbetweenI = rgiNumOfPbetweenIVOP [iVO];
  401. m_rgvolmd [iLayer][iVO].iGOVperiod = rgiGOVperiod [iVO]; // count of o/p frames between govs
  402. // set up temporal sampling rate and clock rate from source frame rate.
  403. m_rgvolmd [iLayer][iVO].iTemporalRate = rgiTemporalRate [iVO]; // frames to skip
  404. Double dFrameHz = m_rgvolmd [iLayer][iVO].dFrameHz;
  405. // this code copes with e.g. 12.5 fps and 29.97 fps by multiplying up the ticks per second
  406. // count appropriately
  407. Int iClockRate = (int)dFrameHz;
  408. if(dFrameHz != (double)iClockRate)
  409. {
  410. iClockRate = (int)(dFrameHz * 10.0);
  411. if(dFrameHz * 10.0 != (double)iClockRate)
  412. iClockRate = (int)(dFrameHz * 100.0);  // not much point going to 1000*
  413. }
  414. m_rgvolmd [iLayer][iVO].iClockRate = iClockRate;
  416. m_rgvolmd [iLayer][iVO].bDumpMB = rgbDumpMB [iVO];
  417. m_rgvolmd [iLayer][iVO].bTrace = rgbTrace [iVO];
  418. m_rgvolmd [iLayer][iVO].bTemporalScalability = FALSE;
  419. if(m_rgvolmd[iLayer][iVO].volType == ENHN_LAYER && m_rgbSpatialScalability [iVO] && rgiTemporalRate[iVO] == rgiEnhnTemporalRate[iVO]){
  420. // modified by Sharp (98/02/09)
  421. //#ifdef _Scalable_SONY_
  422. m_rgvolmd[iLayer][iVO].iHierarchyType = 0; //iHierarchyType 0 means spatial scalability
  423. //#endif _Scalable_SONY_
  424. m_rgvolmd[iLayer][iVO].iEnhnType = 0; // Spatial Scalable Enhancement layer shuold be set to Rectangular shape
  425. m_rgvolmd[iLayer][iVO].iSpatialOption = iSpatialOption; // This Option is for Spatial Scalable
  426. m_rgvolmd[iLayer][iVO].iver_sampling_factor_n = uiVer_sampling_n;
  427. m_rgvolmd[iLayer][iVO].iver_sampling_factor_m = uiVer_sampling_m;
  428. m_rgvolmd[iLayer][iVO].ihor_sampling_factor_n = uiHor_sampling_n;
  429. m_rgvolmd[iLayer][iVO].ihor_sampling_factor_m = uiHor_sampling_m;
  430. } 
  431. // begin: added by Sharp (98/2/12)
  432. else if (m_rgbSpatialScalability [iVO] && rgiTemporalRate[iVO] != rgiEnhnTemporalRate[iVO]){
  433. m_rgvolmd [iLayer][iVO].bTemporalScalability = TRUE;
  434. //#ifdef _Scalable_SONY_
  435. m_rgvolmd[iLayer][iVO].iHierarchyType = 1; //iHierarchyType 1 means temporal scalability
  436. //#endif _Scalable_SONY_
  437. m_rgvolmd [iLayer][iVO].iEnhnType = rgiEnhancementType [iVO];
  438. if ( rgiEnhancementType[iVO] != 0 ) // modified by Sharp (98/3/24)
  439. m_rgvolmd [BASE_LAYER][iVO].fAUsage = RECTANGLE;
  440. if ( iLayer == ENHN_LAYER ) {
  441. m_rgvolmd [ENHN_LAYER][iVO].iTemporalRate = rgiEnhnTemporalRate [iVO];
  442. Double dFrameHz = m_rgvolmd [ENHN_LAYER][iVO].dFrameHz;
  443. // this code copes with e.g. 12.5 fps and 29.97 fps by multiplying up the ticks per second
  444. // count appropriately
  445. Int iClockRate = (int)dFrameHz;
  446. if(dFrameHz != (double)iClockRate)
  447. {
  448. iClockRate = (int)(dFrameHz * 10.0);
  449. if(dFrameHz * 10.0 != (double)iClockRate)
  450. iClockRate = (int)(dFrameHz * 100.0);  // not much point going to 1000*
  451. }
  452. m_rgvolmd [ENHN_LAYER][iVO].iClockRate = iClockRate;
  453. }
  454. m_rgvolmd[iLayer][iVO].iver_sampling_factor_n = 1;
  455. m_rgvolmd[iLayer][iVO].iver_sampling_factor_m = 1;
  456. m_rgvolmd[iLayer][iVO].ihor_sampling_factor_n = 1;
  457. m_rgvolmd[iLayer][iVO].ihor_sampling_factor_m = 1;
  458. }
  459. // end: added by Sharp (98/2/12)
  460. else {
  461. m_rgvolmd[iLayer][iVO].iver_sampling_factor_n = 1;
  462. m_rgvolmd[iLayer][iVO].iver_sampling_factor_m = 1;
  463. m_rgvolmd[iLayer][iVO].ihor_sampling_factor_n = 1;
  464. m_rgvolmd[iLayer][iVO].ihor_sampling_factor_m = 1;
  465. }
  466. }
  467. }
  468. static Char pchYUV [100], pchSeg [100];
  469. // check whether there are data for separate layers
  470. sprintf (pchYUV, ROOT_YUVFILE, m_pchBmpFiles, m_pchPrefix);
  471. sprintf (pchSeg, ROOT_SEGFILE, m_pchBmpFiles, m_pchPrefix);
  472. m_bTexturePerVOP = !fileExistence (pchYUV);
  473. m_bAlphaPerVOP = !fileExistence (pchSeg);
  474. m_bPrevObjectExists = FALSE; // added by Sharp (98/2/13)
  476. // sprite info
  477. m_ppstSrc = new CSiteD* [m_iNumVO];
  478. m_pppstDst = new CSiteD** [m_iNumVO];
  479. for (iVO = 0; iVO < m_iNumVO; iVO++) {
  480. m_ppstSrc [iVO] = (m_rgNumOfPnts [iVO] > 0) ? new CSiteD [m_rgNumOfPnts [iVO]] : NULL;
  481. m_pppstDst [iVO] = new CSiteD* [m_iNumFrame];
  482. for (Int ifr = 0; ifr < m_iNumFrame; ifr++) {
  483. m_pppstDst [iVO] [ifr] = 
  484. (m_rgNumOfPnts [iVO] > 0) ? new CSiteD [m_rgNumOfPnts [iVO]] : 
  485. NULL;
  486. }
  487. }
  488. for (iVO = m_iFirstVO; iVO <= m_iLastVO; iVO++)
  489. if (m_rgNumOfPnts [iVO - m_iFirstVO] > 0)
  490. readPntFile (iVO);
  492.     m_SptMode = pSpriteMode[0];
  493. m_rgiMVFileUsage = rgiMVFileUsage;
  494. m_pchMVFileName  = pchMVFileName;
  495. }
  496. Void CSessionEncoder::encode ()
  497. {
  498. FILE* pfYuvSrc = NULL;
  499. FILE* pfYuvSrcSpatialEnhn = NULL;
  500. FILE* pfSegSrc = NULL;
  501. FILE* rgpfReconYUV [2];
  502. FILE* rgpfReconSeg [2];
  503. Int iVO;
  504. UInt iVOrelative = 0;
  506. // begin: added by Sharp (98/2/12)
  507. Bool bTemporalScalability = m_rgvolmd[BASE_LAYER][0].bTemporalScalability;
  508. // Bool bTemporalScalability = TRUE;
  510. // for a buffer management of temporal scalability
  511. CEnhcBufferEncoder* pBufP1 = NULL;
  512. CEnhcBufferEncoder* pBufP2 = NULL;
  513. CEnhcBufferEncoder* pBufB1 = NULL;
  514. CEnhcBufferEncoder* pBufB2 = NULL;
  515. CEnhcBufferEncoder* pBufE = NULL;
  517. // for backward/forward shape
  518. Void set_modes(VOLMode* volmd, VOPMode* vopmd);
  519. VOLMode* volmd_backShape = NULL;
  520. VOLMode* volmd_forwShape = NULL;
  521. VOPMode* vopmd_backShape = NULL;
  522. VOPMode* vopmd_forwShape = NULL;
  524. if ( bTemporalScalability ){
  525. pBufP1 = new CEnhcBufferEncoder(m_rctOrg.width, m_rctOrg.height());
  526. pBufP2 = new CEnhcBufferEncoder(m_rctOrg.width, m_rctOrg.height());
  527. pBufB1 = new CEnhcBufferEncoder(m_rctOrg.width, m_rctOrg.height());
  528. pBufB2 = new CEnhcBufferEncoder(m_rctOrg.width, m_rctOrg.height());
  529. pBufE  = new CEnhcBufferEncoder(m_rctOrg.width, m_rctOrg.height());
  531. volmd_backShape = new VOLMode;
  532. volmd_forwShape = new VOLMode;
  533. vopmd_backShape = new VOPMode;
  534. vopmd_forwShape = new VOPMode;
  535. set_modes(volmd_backShape, vopmd_backShape);
  536. set_modes(volmd_forwShape, vopmd_forwShape);
  537. }
  538. // end: added by Sharp (98/2/12)
  540. for (iVO = m_iFirstVO; iVO <= (Int) m_iLastVO; iVO++, iVOrelative++) {
  541. ofstream* rgpostrm [2];
  542. ofstream* rgpostrmTrace [2];
  543. PixelC pxlcObjColor;
  544. VOLMode volmd = m_rgvolmd [BASE_LAYER] [iVOrelative];
  545. VOLMode volmd_enhn = m_rgvolmd [ENHN_LAYER] [iVOrelative]; // added by Sharp (98/2/10)
  546. getInputFiles ( pfYuvSrc, pfSegSrc, pfYuvSrcSpatialEnhn,
  547. rgpfReconYUV, rgpfReconSeg, 
  548. rgpostrm, rgpostrmTrace, pxlcObjColor, iVO, volmd, volmd_enhn); // modified by Sharp(98/2/10)
  549. CRct rctOrg;
  550. CVideoObjectEncoder* rgpvoenc [2];
  551. if (m_rguiSpriteUsage [iVOrelative] == 1) {
  552. // change m_rctOrg to sprite size
  553. rctOrg = m_rctOrg;
  554. m_rctFrame = m_rctOrg;
  555. m_rctOrg = findSptRct (iVO);
  556. }
  558. initVOEncoder (rgpvoenc, iVO, rgpostrmTrace);
  559. #undef write
  560. rgpostrm [BASE_LAYER]->write (rgpvoenc [BASE_LAYER]->pOutStream ()->str (), //VO and VOL header
  561.   rgpvoenc [BASE_LAYER]->pOutStream ()->pcount ());
  563. if(m_rgbSpatialScalability[iVOrelative]){
  564. rgpostrm[ENHN_LAYER]->write(rgpvoenc [ENHN_LAYER]->pOutStream () ->str(),
  565. rgpvoenc [ENHN_LAYER]->pOutStream () ->pcount ());
  566. }
  567. // begin: added by Sharp (98/2/12)
  568. // for back/forward shape
  569. if ( bTemporalScalability ){
  570.   initVObfShape (rgpvoenc[ENHN_LAYER]->rgpbfShape, iVO, *volmd_backShape, *vopmd_backShape, *volmd_forwShape, *vopmd_forwShape);
  571.   // copy pointers
  572.   rgpvoenc[ENHN_LAYER]->rgpbfShape[0]->m_pchBitsBuffer = rgpvoenc[ENHN_LAYER]->m_pchBitsBuffer;
  573.   rgpvoenc[ENHN_LAYER]->rgpbfShape[0]->m_pbitstrmOut   = rgpvoenc[ENHN_LAYER]->m_pbitstrmOut;
  574.   rgpvoenc[ENHN_LAYER]->rgpbfShape[0]->m_pentrencSet   = rgpvoenc[ENHN_LAYER]->m_pentrencSet;
  576.   rgpvoenc[ENHN_LAYER]->rgpbfShape[0]->m_pchShapeBitsBuffer = rgpvoenc[ENHN_LAYER]->m_pchShapeBitsBuffer; // Oct 8
  577.   rgpvoenc[ENHN_LAYER]->rgpbfShape[0]->m_pbitstrmShape      = rgpvoenc[ENHN_LAYER]->m_pbitstrmShape; //
  578.   rgpvoenc[ENHN_LAYER]->rgpbfShape[0]->m_pbitstrmShapeMBOut = rgpvoenc[ENHN_LAYER]->m_pbitstrmShapeMBOut; //
  580.   rgpvoenc[ENHN_LAYER]->rgpbfShape[1]->m_pchBitsBuffer = rgpvoenc[ENHN_LAYER]->m_pchBitsBuffer;
  581.   rgpvoenc[ENHN_LAYER]->rgpbfShape[1]->m_pbitstrmOut   = rgpvoenc[ENHN_LAYER]->m_pbitstrmOut;
  582.   rgpvoenc[ENHN_LAYER]->rgpbfShape[1]->m_pentrencSet   = rgpvoenc[ENHN_LAYER]->m_pentrencSet;
  584.   rgpvoenc[ENHN_LAYER]->rgpbfShape[1]->m_pchShapeBitsBuffer = rgpvoenc[ENHN_LAYER]->m_pchShapeBitsBuffer; // Oct 8
  585.   rgpvoenc[ENHN_LAYER]->rgpbfShape[1]->m_pbitstrmShape     = rgpvoenc[ENHN_LAYER]->m_pbitstrmShape; //
  586.   rgpvoenc[ENHN_LAYER]->rgpbfShape[1]->m_pbitstrmShapeMBOut = rgpvoenc[ENHN_LAYER]->m_pbitstrmShapeMBOut; //
  587. }
  588. // end: added by Sharp (98/2/12)
  589. if (m_rguiSpriteUsage [iVO - m_iFirstVO] == 1) {
  590. // load sprite data into m_pvopcOrig
  591. loadSpt (iVO, rgpvoenc [BASE_LAYER] -> m_pvopcOrig);
  592. // encode the initial sprite
  593. if (m_SptMode == BASIC_SPRITE) 
  594. rgpvoenc [BASE_LAYER] -> encode (TRUE, -1, IVOP);
  595. else
  596. rgpvoenc [BASE_LAYER] -> encodeInitSprite (rctOrg);
  598. if (m_rgNumOfPnts [iVOrelative] > 0) {
  599. // change m_pvopcRefQ1 to m_pvopcSptQ for warping
  600. rgpvoenc [BASE_LAYER] -> swapRefQ1toSpt ();
  601. // restore m_pvopcCurrQ size to the normal one
  602. m_rctOrg = rctOrg;
  603. rgpvoenc [BASE_LAYER] -> changeSizeofCurrQ (rctOrg);
  604. }
  605. rgpostrm [BASE_LAYER]->write (rgpvoenc [BASE_LAYER]->pOutStream ()->str (), //write sprite unit
  606.   rgpvoenc [BASE_LAYER]->pOutStream ()->pcount ());
  607. }
  608. assert (!m_rctOrg.empty ());
  610. if (rgpvoenc [BASE_LAYER]->m_uiRateControl>=RC_TM5) {
  611. assert (!m_rgbSpatialScalability [iVOrelative]);
  612. assert (!bTemporalScalability);
  613. assert (volmd.iTemporalRate==1);
  614. #ifndef __TRACE_AND_STATS_
  615. cerr << "Compile flag __TRACE_AND_STATS_ required for stats for TM5 rate control." << endl;
  616. exit(1);
  617. #endif // __TRACE_AND_STATS_
  618. char pchQname[100];
  619. pchQname[0] = 0;
  620. //if( m_bRGBfiles ) {
  621. // if( m_pchOutStrFiles && m_pchOutStrFiles[0]) sprintf (pchQname, m_pchOutStrFiles, "q", iVO);
  622. //} else {
  623. if( m_pchOutStrFiles && m_pchOutStrFiles[0]) {
  624. sprintf (pchQname, SUB_CMPFILE, m_pchOutStrFiles, iVO, m_pchPrefix);
  625. }
  626. //}
  627. rgpvoenc [BASE_LAYER]->m_tm5rc.tm5rc_init_seq ( pchQname,
  628. rgpvoenc [BASE_LAYER]->m_uiRateControl,
  629. m_rgvolmd [BASE_LAYER] [iVOrelative].fAUsage,
  630. m_rctOrg.width,
  631. m_rctOrg.height(),
  632. (UInt)((m_rguiBudget [BASE_LAYER] [iVOrelative] * m_rgvolmd [BASE_LAYER][iVOrelative].dFrameHz)
  633.  / (m_iLastFrame - m_iFirstFrame + 1)),
  634. m_rgvolmd [BASE_LAYER][iVOrelative].dFrameHz
  635. );
  636. }
  638. // algorithm for generation of IPB sequences with arbitrary shape
  639.  //   (transparency allows for possible skipped frames) 
  640.  //   P prediction across skips is not allowed 
  642. #define DUMP_CURR 0
  643. #define DUMP_PREV 1
  644. #define DUMP_NONE 2
  646. Int iRefFrame;
  647. Int iDT = volmd.iTemporalRate;
  648. Int iDT_enhn = volmd_enhn.iTemporalRate; // added by Sharp (98/2/12)
  649. Int iRefInterval = volmd.iBbetweenP + 1;
  650. Int iPCount;
  651. Bool bObjectExists;
  652. const CVOPU8YUVBA* pvopcBaseQuant = NULL;
  653. Int iEcount = 0; // added by Sharp (98/2/12)
  654. Bool bCachedRefDump = FALSE;
  655. Bool bCachedRefCoded = TRUE;
  656. Bool bPrevObjectExists = FALSE; // added by Sharp (99/1/27)
  657. for(iRefFrame = m_iFirstFrame; iRefFrame <= m_iLastFrame; iRefFrame += iDT)
  658. {
  659. // encode initial I frame or non-coded sequence
  660. if(rgpvoenc [BASE_LAYER] -> skipTest(iRefFrame,IVOP)) // rate control
  661. continue;
  663. //encode GOV header added by SONY 980212
  664. // moved down slightly by swinder 980219
  665. //CAUTION:I don't know how GOV header is encoded in sprite mode
  666. // re-done by swinder 980511
  667. // gov header is output every n output frames, where n is iGOVperiod
  668. if (volmd.iGOVperiod != 0 
  669. && ((iRefFrame-m_iFirstFrame) % (volmd.iGOVperiod * volmd.iTemporalRate)) == 0)
  670. {
  671. rgpvoenc [BASE_LAYER] -> codeGOVHead (iRefFrame - m_iFirstFrame);
  672. rgpostrm [BASE_LAYER]->write (rgpvoenc [BASE_LAYER]->pOutStream ()->str (),
  673. rgpvoenc [BASE_LAYER]->pOutStream ()->pcount ());
  674. }
  675. //980211
  677. // first dump any cached frames, otherwise a non coded frame will be out of order
  678. if(bCachedRefDump && m_rguiSpriteUsage [iVOrelative] == 0)
  679. {
  680. bCachedRefDump = FALSE;
  681. // last ref frame needs to be output
  682. #ifndef __OUT_ONE_FRAME_
  684. if ( bCachedRefCoded )
  685. dumpData (rgpfReconYUV [BASE_LAYER], rgpfReconSeg [BASE_LAYER], rgpvoenc[BASE_LAYER] ->pvopcRefQLater(), m_rctOrg, volmd);
  686. else
  687. dumpNonCodedFrame(rgpfReconYUV [BASE_LAYER], rgpfReconSeg [BASE_LAYER], m_rctOrg, volmd.nBits);
  689. if (m_rgbSpatialScalability [iVOrelative] && !bTemporalScalability)
  690. dumpData (rgpfReconYUV [ENHN_LAYER], rgpfReconSeg [ENHN_LAYER], rgpvoenc[ENHN_LAYER] ->pvopcRefQLater(), m_rctOrgSpatialEnhn, volmd);
  691. // begin: deleted by Sharp (98/11/11)
  692. // #else
  693. //  dumpDataOneFrame (iFrame, iVO, rgpvoenc[BASE_LAYER] ->pvopcRefQLater(), volmd); // save one frame
  694. //  if (m_rgbSpatialScalability [iVOrelative] && !bTemporalScalability)
  695. //  dumpDataOneFrame (iFrame, iVO, rgpvoenc[BASE_LAYER] ->pvopcRefQLater(), volmd); // save one frame
  696. // end: deleted by Sharp (98/11/11)
  697. #endif
  698. }
  700. int iGOPperiod = (volmd.iPbetweenI + 1) * (volmd.iBbetweenP + 1);
  701. if (rgpvoenc [BASE_LAYER]->m_uiRateControl >= RC_TM5 && iGOPperiod != 0 
  702. && ((iRefFrame-m_iFirstFrame) % (iGOPperiod * volmd.iTemporalRate)) == 0)
  703. {
  704. Int nppic, npic = (m_iLastFrame - iRefFrame + 1) / volmd.iTemporalRate;
  705. if (iRefFrame == m_iFirstFrame) {
  706. if (npic > (iGOPperiod - volmd.iBbetweenP))
  707. npic = iGOPperiod - volmd.iBbetweenP;
  708. } else {
  709. npic += volmd.iBbetweenP;
  710. if (npic > iGOPperiod)
  711. npic = iGOPperiod;
  712. }
  713. nppic = (npic + volmd.iBbetweenP) / (volmd.iBbetweenP + 1) - 1;
  714. rgpvoenc [BASE_LAYER] -> m_tm5rc.tm5rc_init_GOP(nppic, npic - nppic - 1); //  np, nb remain
  715. }
  717. // encode non-coded frames or initial IVOPs
  718. // we always dump these out
  719. bObjectExists = loadDataSpriteCheck (iVOrelative,iRefFrame, pfYuvSrc, pfSegSrc, pxlcObjColor, rgpvoenc [BASE_LAYER]->m_pvopcOrig, volmd);
  720. encodeVideoObject(bObjectExists, bObjectExists, iRefFrame, IVOP, DUMP_CURR,
  721.   iVO, iVOrelative, BASE_LAYER, 
  722.   pfYuvSrc,pfSegSrc,rgpfReconYUV,rgpfReconSeg,
  723.   pxlcObjColor, rgpvoenc, volmd, rgpostrm);
  725. if (m_rgbSpatialScalability [iVOrelative] && !bTemporalScalability ) { // modified by Sharp (98/2/12)
  726. pvopcBaseQuant = rgpvoenc [BASE_LAYER]->pvopcReconCurr ();
  727. encodeVideoObject (bObjectExists, bObjectExists, iRefFrame, PVOP, DUMP_CURR,
  728.    iVO, iVOrelative, ENHN_LAYER,
  729.    pfYuvSrcSpatialEnhn, pfSegSrc, rgpfReconYUV, rgpfReconSeg,
  730.    pxlcObjColor, rgpvoenc, volmd, rgpostrm,
  731.    pvopcBaseQuant);
  732. }
  733. // begin: added by Sharp (98/2/12)
  734. else if (m_rgbSpatialScalability [iVOrelative] && bTemporalScalability)
  735. pBufP2->getBuf( rgpvoenc[BASE_LAYER] );
  736. // end: added by Sharp (98/2/12)
  738. // go to next frame if this was not coded or we are just coding sprites
  739. if(!bObjectExists)
  740. continue; 
  742. // we dumped first frame so rest must be delayed by one for re-order
  743. iPCount = volmd.iPbetweenI;
  744. Int iWaitInterval = 0;
  746. while (TRUE) {
  747. // search for next reference frame
  748. Int iSearchFrame;
  749. for(iSearchFrame = iRefFrame + iDT * iRefInterval + iWaitInterval;
  750. iSearchFrame > iRefFrame; iSearchFrame -= iDT)
  751. if(iSearchFrame <= m_iLastFrame)
  752. {
  753. bObjectExists = loadDataSpriteCheck(iVOrelative,iSearchFrame, pfYuvSrc, pfSegSrc, pxlcObjColor, rgpvoenc [BASE_LAYER]->m_pvopcOrig, volmd);
  754. break;  // found a suitable reference frame
  755. // may not be coded
  756. }
  758. if(iSearchFrame==iRefFrame)
  759. break;
  761. if (rgpvoenc [BASE_LAYER] -> skipTest(iSearchFrame,iPCount ? PVOP : IVOP)) // rate control
  762. {
  763. // too early! need to wait a frame
  764. iWaitInterval += iDT;
  765. continue;
  766. }
  767. iWaitInterval = 0;
  768. CVOPU8YUVBA* pvopcBasePVOPQuant = NULL;
  770. // begin: added by Sharp (98/2/12)
  771. if ( bTemporalScalability )
  772. if ( pBufP2 -> m_bCodedFutureRef == 1 ) // added by Sharp (99/1/28)
  773. pBufP1->copyBuf ( *pBufP2 );
  774. // end: added by Sharp (98/2/12)
  775. // encode the next reference frame
  776. //Bool bCachedRefDumpSaveForSpatialScalability = bCachedRefDump;
  777. if(iPCount==0)
  778. {
  779. //added to encode GOV header by SONY 980212
  780. // moved to here by swinder 980219
  781. //CAUTION:I don't know how GOV header is encoded in sprite mode - SONY
  782. // update by swinder 980511
  783. if (volmd.iGOVperiod != 0 
  784. && ((iSearchFrame-m_iFirstFrame) % (volmd.iGOVperiod * volmd.iTemporalRate)) == 0)
  785. {
  786. //modified by SONY (98/03/30)
  787. rgpvoenc [BASE_LAYER] -> codeGOVHead (iRefFrame - m_iFirstFrame + iDT);
  788. //modified by SONY (98/03/30) End
  789. /* rgpvoenc [BASE_LAYER] -> codeGOVHead (iSearchFrame - m_iFirstFrame);
  790. Original*/ // why was this changed? - swinder
  791. rgpostrm [BASE_LAYER]->write (rgpvoenc [BASE_LAYER]->pOutStream ()->str (),
  792. rgpvoenc [BASE_LAYER]->pOutStream ()->pcount ());
  793. }
  794. //980212
  796. int iGOPperiod = (volmd.iPbetweenI + 1) * (volmd.iBbetweenP + 1);
  797. if (rgpvoenc [BASE_LAYER]->m_uiRateControl >= RC_TM5 && iGOPperiod != 0 
  798. && ((iSearchFrame-m_iFirstFrame) % (iGOPperiod * volmd.iTemporalRate)) == 0)
  799. {
  800. Int nppic, npic = (m_iLastFrame - iSearchFrame + 1) / volmd.iTemporalRate;
  801. if (iRefFrame == m_iFirstFrame) {
  802. if (npic > (iGOPperiod - volmd.iBbetweenP))
  803. npic = iGOPperiod - volmd.iBbetweenP;
  804. } else {
  805. npic += volmd.iBbetweenP;
  806. if (npic > iGOPperiod)
  807. npic = iGOPperiod;
  808. }
  809. nppic = (npic + volmd.iBbetweenP) / (volmd.iBbetweenP + 1) - 1;
  810. rgpvoenc [BASE_LAYER] -> m_tm5rc.tm5rc_init_GOP(nppic, npic - nppic - 1); //  np, nb remain
  811. }
  813. // encode IVOP
  815. encodeVideoObject(bObjectExists, bPrevObjectExists, iSearchFrame, IVOP, bCachedRefDump ? DUMP_PREV : DUMP_NONE, // modified by Sharp (99/1/27)
  816.   iVO, iVOrelative, BASE_LAYER, 
  817.   pfYuvSrc, pfSegSrc, rgpfReconYUV, rgpfReconSeg,
  818.     pxlcObjColor, rgpvoenc, volmd, rgpostrm);
  820. bCachedRefDump = TRUE; // need to output this frame later
  821. bCachedRefCoded = bObjectExists;
  823. iPCount = volmd.iPbetweenI;
  824. if (m_rgbSpatialScalability [iVOrelative] && !bTemporalScalability )  // modified by Sharp
  825.                         pvopcBasePVOPQuant = new CVOPU8YUVBA (*(rgpvoenc [BASE_LAYER]->pvopcReconCurr ()),
  826.          rgpvoenc [BASE_LAYER]->pvopcReconCurr ()->whereY());
  827. // begin: added by Sharp (98/2/12)
  828. else if (m_rgbSpatialScalability [iVOrelative] && bTemporalScalability)
  829. pBufP2->getBuf( rgpvoenc[BASE_LAYER] );
  830. // end: added by Sharp (98/2/12)
  831. }
  832. else
  833. {
  834. // encoder PVOP
  835. encodeVideoObject(bObjectExists, bPrevObjectExists, iSearchFrame, PVOP, bCachedRefDump ? DUMP_PREV : DUMP_NONE, // modified by Sharp (99/1/27)
  836.   iVO, iVOrelative, BASE_LAYER, 
  837.   pfYuvSrcSpatialEnhn, pfSegSrc, rgpfReconYUV, rgpfReconSeg,
  838.   pxlcObjColor, rgpvoenc, volmd, rgpostrm);
  839. bCachedRefDump = TRUE; // need to output this frame later
  840. bCachedRefCoded = bObjectExists;
  842. if (m_rgbSpatialScalability [iVOrelative] && !bTemporalScalability )  // modified by Sharp (98/2/12)
  843. pvopcBasePVOPQuant = new CVOPU8YUVBA (*(rgpvoenc [BASE_LAYER]->pvopcReconCurr ()),
  844.          rgpvoenc [BASE_LAYER]->pvopcReconCurr ()->whereY());
  845. // begin: added by Sharp (98/2/12)
  846. else if (m_rgbSpatialScalability [iVOrelative] && bTemporalScalability)
  847. pBufP2->getBuf( rgpvoenc[BASE_LAYER] );
  848. // end: added by Sharp (98/2/12)
  850. if (iPCount>0)  // needed to handle iPCount = -1
  851. iPCount--;
  852. }
  853. bPrevObjectExists = bObjectExists;
  855. // encode B frames if needed
  856. Int iBFrame = iRefFrame + iDT; // added by Sharp (98/2/12)
  857. if(iRefInterval>1)
  858. {
  859. Bool bCachedBVOP = FALSE; // added by Sharp (98/11/11)
  860. // Int iBFrame;  // deleted by Sharp (98/2/12)
  861. for(iBFrame = iRefFrame + iDT; iBFrame < iSearchFrame; iBFrame += iDT)
  862. {
  863. if(rgpvoenc [BASE_LAYER] -> skipTest(iBFrame,BVOP))
  864. continue;
  865. bObjectExists = loadDataSpriteCheck(iVOrelative,iBFrame, pfYuvSrc, pfSegSrc, pxlcObjColor, rgpvoenc [BASE_LAYER]->m_pvopcOrig, volmd);
  866. encodeVideoObject (bObjectExists, bObjectExists, iBFrame, BVOP, bTemporalScalability ? DUMP_NONE: DUMP_CURR, // modified by Sharp (98/11/11)
  867.    iVO, iVOrelative, BASE_LAYER,
  868.    pfYuvSrc,pfSegSrc,rgpfReconYUV,rgpfReconSeg,
  869.    pxlcObjColor,rgpvoenc,volmd,rgpostrm);
  870. bCachedBVOP = bTemporalScalability ? TRUE : FALSE; // added by Sharp (98/11/11)
  871. if (m_rgbSpatialScalability [iVOrelative] && !bTemporalScalability) { // modified by Sharp (98/2/12)
  872. pvopcBaseQuant = rgpvoenc [BASE_LAYER]->pvopcReconCurr ();
  873. // Spatial Scalabe BVOP 
  874. encodeVideoObject (bObjectExists, bObjectExists, iBFrame, BVOP, DUMP_CURR, 
  875.    iVO, iVOrelative, ENHN_LAYER,
  876.    pfYuvSrcSpatialEnhn, pfSegSrc, rgpfReconYUV, rgpfReconSeg,
  877.    pxlcObjColor, rgpvoenc, volmd, rgpostrm,
  878.    pvopcBaseQuant);
  879. }
  880. // begin: added by Sharp (98/2/12)
  881. else if (m_rgbSpatialScalability [iVOrelative] && bTemporalScalability)
  882. pBufB2->getBuf( rgpvoenc[BASE_LAYER] );
  884. if ( m_rgbSpatialScalability [iVOrelative] && bTemporalScalability ) {  // for TPS enhancement layer
  885. rgpvoenc [ENHN_LAYER] -> m_iBCount = 0;
  886. for (Int iEFrame = iBFrame - iDT + iDT_enhn; iEFrame < iBFrame; iEFrame += iDT_enhn ) {
  888. updateRefForTPS( rgpvoenc[ENHN_LAYER], pBufP1, pBufP2, pBufB1, pBufB2, pBufE,
  889. 0, iVOrelative, iEcount, iBFrame-iDT+iDT_enhn, iEFrame, 0 );
  890. iEcount++;
  891. encodeEnhanceVideoObject(bObjectExists, iEFrame, rgpvoenc[ENHN_LAYER]->m_vopmd.vopPredType, DUMP_CURR,
  892. iVO,iVOrelative, pfYuvSrc,pfSegSrc,rgpfReconYUV,rgpfReconSeg,
  893. pxlcObjColor,rgpvoenc[ENHN_LAYER],volmd, volmd_enhn, iBFrame - iDT + iDT_enhn, rgpostrm,
  894. *pBufP1, *pBufP2, *pBufB1, *pBufB2, *pBufE
  895. );
  897. if ( !pBufB2->empty() ){
  898. if ( pBufB2 -> m_bCodedFutureRef == 1 ) // added by Sharp (99/1/28)
  899. pBufB1->copyBuf( *pBufB2 );
  900. pBufB2->dispose();
  901. }
  902. }
  903. }
  904. // end: added by Sharp (98/2/12)
  906. // begin: added by Sharp (98/11/11)
  907. if(bCachedBVOP && m_rguiSpriteUsage [iVOrelative] == 0)
  908. {
  909. // only for temporal scalability
  910. #ifndef __OUT_ONE_FRAME_
  911. // last ref frame needs to be output
  912. dumpData (rgpfReconYUV [BASE_LAYER], rgpfReconSeg [BASE_LAYER],
  913. rgpvoenc[BASE_LAYER] ->pvopcReconCurr(), m_rctOrg, volmd);
  914. if (m_rgbSpatialScalability [iVOrelative] && !bTemporalScalability)
  915. dumpData (rgpfReconYUV [BASE_LAYER], rgpfReconSeg [BASE_LAYER],
  916. rgpvoenc[BASE_LAYER] ->pvopcReconCurr(), m_rctOrgSpatialEnhn, volmd);
  917. #endif
  918. bCachedBVOP = FALSE;
  919. }
  920. // end: added by Sharp (98/11/11)
  922. }
  923. }
  925. if (m_rgbSpatialScalability [iVOrelative] && !bTemporalScalability) { // modified by Sharp (98/2/12)
  926. /* (98/3/30) modified by SONY*/
  927. if (iPCount == volmd.iPbetweenI)        {
  928. /* (98/3/20) modified by SONY(end)*/
  929. /*            ORIGINAL
  930. if (iPCount == 0)       {
  931. */
  932. encodeVideoObject(TRUE, TRUE, iSearchFrame, PVOP,
  933.   DUMP_CURR, // sony
  934.   iVO, iVOrelative, ENHN_LAYER, 
  935.   pfYuvSrcSpatialEnhn, pfSegSrc, rgpfReconYUV, rgpfReconSeg,
  936.   pxlcObjColor,rgpvoenc,volmd,rgpostrm,
  937.   pvopcBasePVOPQuant);
  938. }
  939. else {
  940. VOPpredType PrevType = (rgpvoenc[ENHN_LAYER]->m_volmd.iSpatialOption == 0 )? BVOP: PVOP;
  941. encodeVideoObject (bObjectExists, bObjectExists, iSearchFrame, PrevType,
  942.    DUMP_CURR, // sony
  943.    iVO, iVOrelative, ENHN_LAYER, 
  944.    pfYuvSrcSpatialEnhn, pfSegSrc, rgpfReconYUV, rgpfReconSeg,
  945.    pxlcObjColor, rgpvoenc, volmd, rgpostrm,
  946.    pvopcBasePVOPQuant);
  947. }
  948. delete pvopcBasePVOPQuant;
  949. }
  950. // begin: added by Sharp (98/2/12)
  951. else if ( m_rgbSpatialScalability [iVOrelative] && bTemporalScalability ){  // loop for TPS enhancement layer
  952. rgpvoenc [ENHN_LAYER] -> m_iBCount = 0;
  953. for (Int iEFrame = iSearchFrame - iDT + iDT_enhn; iEFrame < iSearchFrame; iEFrame += iDT_enhn ) {
  955. updateRefForTPS( rgpvoenc[ENHN_LAYER], pBufP1, pBufP2, pBufB1, pBufB2, pBufE,
  956. 0, iVOrelative, iEcount, iBFrame-iDT+iDT_enhn, iEFrame, 0 );
  958. iEcount++;
  959. encodeEnhanceVideoObject(bObjectExists, iEFrame, rgpvoenc[ENHN_LAYER]->m_vopmd.vopPredType, DUMP_CURR,
  960. iVO,iVOrelative,pfYuvSrc,pfSegSrc,rgpfReconYUV,rgpfReconSeg,
  961. pxlcObjColor,rgpvoenc[ENHN_LAYER],volmd, volmd_enhn, iSearchFrame - iDT + iDT_enhn, rgpostrm,
  962. *pBufP1, *pBufP2, *pBufB1, *pBufB2, *pBufE
  963. );
  964. }
  965. pBufB1->dispose();
  966. }
  967. // end: added by Sharp (98/2/12)
  968. // move onwards
  969. iRefFrame = iSearchFrame;
  970. }
  971. }
  973. if(bCachedRefDump && m_rguiSpriteUsage [iVOrelative] == 0)
  974. {
  975. // last ref frame needs to be output
  976. #ifndef __OUT_ONE_FRAME_
  977. if ( bCachedRefCoded )
  978. dumpData (rgpfReconYUV [BASE_LAYER], rgpfReconSeg [BASE_LAYER], rgpvoenc[BASE_LAYER] ->pvopcRefQLater(), m_rctOrg, volmd);
  979. else
  980. dumpNonCodedFrame(rgpfReconYUV [BASE_LAYER], rgpfReconSeg [BASE_LAYER], m_rctOrg, volmd.nBits);
  982. // begin deleted by sony
  983. // if (m_rgbSpatialScalability [iVOrelative] && !bTemporalScalability)
  984. // dumpData (rgpfReconYUV [BASE_LAYER], rgpfReconSeg [BASE_LAYER], rgpvoenc[BASE_LAYER] ->pvopcRefQLater(), m_rctOrgSpatialEnhn, volmd);
  985. // end deleted by sony
  986. bCachedRefDump = FALSE; // added by Sharp (98/11/11)
  987. // begin: deleted by Sharp (98/11/11)
  988. //#else
  989. // dumpDataOneFrame (iFrame, iVO, rgpvoenc[BASE_LAYER] ->pvopcRefQLater(), volmd); // save one frame
  990. // if (m_rgbSpatialScalability [iVOrelative] && !bTemporalScalability)
  991. // dumpDataOneFrame (iFrame, iVO, rgpvoenc[ENHN_LAYER] ->pvopcRefQLater(), volmd); // save one frame
  992. // end: deleted by Sharp (98/11/11)
  993. #endif
  994. }
  996. cout << "nBASE VOL " << iVO << "n";
  997. CStatistics sts = rgpvoenc [BASE_LAYER] -> statVOL ();
  998. #ifdef __TRACE_AND_STATS_
  999. sts.print (TRUE); // dumping statistics
  1000. #endif // __TRACE_AND_STATS_
  1001. delete rgpvoenc [BASE_LAYER];
  1002. fclose (rgpfReconYUV [BASE_LAYER]);
  1003. if (m_rgvolmd [BASE_LAYER] [iVOrelative].fAUsage != RECTANGLE) {
  1004. fclose (rgpfReconSeg [BASE_LAYER]);
  1005. }
  1006. delete rgpostrm [BASE_LAYER];
  1007. delete rgpostrmTrace [BASE_LAYER];
  1009. if (m_rgbSpatialScalability [iVOrelative] == TRUE) {
  1010. cout << "nEHNANCED VOL " << iVO << "n";
  1011. sts = rgpvoenc [ENHN_LAYER] -> statVOL ();
  1012. #ifdef __TRACE_AND_STATS_
  1013. sts.print (TRUE); // dumping statistics
  1014. #endif // __TRACE_AND_STATS_
  1015. delete rgpvoenc [ENHN_LAYER];
  1016. fclose (rgpfReconYUV [ENHN_LAYER]);
  1017. if (m_rgvolmd [BASE_LAYER] [iVOrelative].fAUsage != RECTANGLE) {
  1018. fclose (rgpfReconSeg [ENHN_LAYER]);
  1019. }
  1020. delete rgpostrm [ENHN_LAYER];
  1021. delete rgpostrmTrace [ENHN_LAYER];
  1022. }
  1023. }
  1024. }
  1026. Bool CSessionEncoder::loadDataSpriteCheck(UInt iVOrelative,UInt iFrame, FILE* pfYuvSrc, FILE* pfSegSrc, PixelC pxlcObjColor, CVOPU8YUVBA* pvopcDst, const VOLMode& volmd)
  1027. {
  1028. Bool bObjectExists = TRUE;
  1029. if(m_rguiSpriteUsage [iVOrelative] == 0)
  1030. bObjectExists = loadData (iFrame,pfYuvSrc,pfSegSrc, pxlcObjColor, pvopcDst, m_rctOrg, volmd);
  1031. return bObjectExists;
  1032. }
  1034. Void CSessionEncoder::encodeVideoObject(Bool bObjectExists,
  1035. Bool bPrevObjectExists,
  1036. Int iFrame,
  1037. VOPpredType predType,
  1038. Int iDumpMode,
  1039. Int iVO,
  1040. Int iVOrelative,
  1041. Int iLayer,
  1042. FILE* pfYuvSrc,
  1043. FILE* pfSegSrc,
  1044. FILE* rgpfReconYUV[],
  1045. FILE* rgpfReconSeg[],
  1046. PixelC pxlcObjColor,
  1047. CVideoObjectEncoder** rgpvoenc,
  1048. const VOLMode& volmd,
  1049. ofstream* rgpostrm[],
  1050. const CVOPU8YUVBA* pvopcBaseQuant)
  1051. {
  1052. CRct rctOrg;
  1053. if (m_rguiSpriteUsage [iVOrelative] == 0) {
  1054.         rctOrg = m_rctOrg;
  1055. if (iLayer == ENHN_LAYER) { 
  1056. rctOrg = m_rctOrgSpatialEnhn;
  1057. if((rgpvoenc [iLayer] -> skipTest((Time)iFrame,predType)))  // rate control
  1058. return;
  1059. bObjectExists = loadData(iFrame, pfYuvSrc, pfSegSrc, pxlcObjColor, rgpvoenc [iLayer]->m_pvopcOrig, rctOrg, volmd);
  1060. }
  1061. rgpvoenc [iLayer] -> encode (bObjectExists, (Time) (iFrame - m_iFirstFrame), predType, pvopcBaseQuant);
  1062. if (iLayer == ENHN_LAYER)
  1063. rgpvoenc [iLayer]-> swapSpatialScalabilityBVOP ();
  1064. }
  1065. else {
  1066.         rctOrg = m_rctFrame;
  1067. CRct rctWarp = (m_rgNumOfPnts [iVO - m_iFirstVO] > 0)? 
  1068.                         findBoundBoxInAlpha (iFrame, iVO) : m_rctOrg;
  1069. rgpvoenc [BASE_LAYER]->encodeSptTrajectory (iFrame, m_pppstDst [iVO - m_iFirstVO] [iFrame - m_iFirstFrame], rctWarp);
  1070. bObjectExists = TRUE;
  1071. }
  1072. //dump the output
  1074. // begin: added by Sharp (99/1/28)
  1075. #ifndef __OUT_ONE_FRAME_
  1076. if(iDumpMode==DUMP_CURR || m_rguiSpriteUsage [iVOrelative] != 0)
  1077. {
  1078. if (bObjectExists) 
  1079. dumpData (rgpfReconYUV [iLayer], rgpfReconSeg [iLayer], rgpvoenc[iLayer] ->pvopcReconCurr(), rctOrg, volmd);
  1080. else
  1081. dumpNonCodedFrame(rgpfReconYUV [iLayer], rgpfReconSeg [iLayer], rctOrg, volmd.nBits);
  1082. }
  1083. else if(iDumpMode==DUMP_PREV){ // dump previous reference frame
  1084. if ( bPrevObjectExists )
  1085. dumpData (rgpfReconYUV [iLayer], rgpfReconSeg [iLayer], rgpvoenc[iLayer] ->pvopcRefQPrev(), rctOrg, volmd);
  1086. else
  1087. dumpNonCodedFrame(rgpfReconYUV [iLayer], rgpfReconSeg [iLayer], rctOrg, volmd.nBits);
  1088. }
  1089. #else
  1090. if (bObjectExists) 
  1091. dumpDataOneFrame (iFrame, iVO, rgpvoenc[iLayer] ->pvopcReconCurr(), volmd); // save one frame
  1092. else
  1093. dumpNonCodedFrame(rgpfReconYUV [iLayer], rgpfReconSeg [iLayer], rctOrg, volmd.nBits);
  1094. #endif
  1095. // end: added by Sharp (99/1/28)
  1097. // begin: deleted by Sharp (99/1/28)
  1098. /*
  1099. if (bObjectExists) {
  1100. // begin: modified by Sharp (98/11/11)
  1101. // begin: modification by Sharp (98/2/12)
  1102. #ifndef __OUT_ONE_FRAME_
  1103. if(iDumpMode==DUMP_CURR || m_rguiSpriteUsage [iVOrelative] != 0)
  1104. {
  1105. // dump current reconstructed frame
  1106. dumpData (rgpfReconYUV [iLayer], rgpfReconSeg [iLayer], rgpvoenc[iLayer] ->pvopcReconCurr(), rctOrg, volmd);
  1107. }
  1108. else if(iDumpMode==DUMP_PREV) // dump previous reference frame
  1109. {
  1110. dumpData (rgpfReconYUV [iLayer], rgpfReconSeg [iLayer], rgpvoenc[iLayer] ->pvopcRefQPrev(), rctOrg, volmd);
  1111. }
  1112. // end: modification by Sharp (98/2/12)
  1113. #else
  1114. dumpDataOneFrame (iFrame, iVO, rgpvoenc[iLayer] ->pvopcReconCurr(), volmd); // save one frame
  1115. #endif
  1116. // end: modified by Sharp (98/11/11)
  1117. }
  1118. #ifndef __OUT_ONE_FRAME_ // added by Sharp (98/11/11)
  1119. else
  1120. dumpNonCodedFrame(rgpfReconYUV [iLayer], rgpfReconSeg [iLayer], rctOrg, volmd.nBits);
  1121. #endif // added by Sharp (98/11/11)
  1122. */
  1123. // end: deleted by Sharp (99/1/28)
  1124. rgpostrm [iLayer]->write (rgpvoenc [iLayer]->pOutStream ()->str (),
  1125. rgpvoenc [iLayer]->pOutStream ()->pcount ());
  1126. }
  1128. Void CSessionEncoder::readPntFile (UInt iobj)
  1129. {
  1130. Char pchtmp [100];
  1131. sprintf (pchtmp, SUB_PNTFILE, m_pchSptPntDir, iobj, m_pchPrefix);
  1132. FILE* pfPnt = fopen (pchtmp, "r");
  1133. if(pfPnt==NULL)
  1134. fatal_error("Can't open sprite point file");
  1136. Int numPnt;
  1137. Int iVOidx = iobj - m_iFirstVO;
  1138. fscanf (pfPnt, "%d", &numPnt);
  1139. assert (numPnt == m_rgNumOfPnts [iVOidx]);
  1140. Int ifrF;
  1141. Double dblX, dblY;
  1142. for (Int ip = 0; ip < numPnt; ip++)
  1143. fscanf (pfPnt, "%lf%lf", &m_ppstSrc [iVOidx] [ip].x, &m_ppstSrc [iVOidx] [ip].y); // not used
  1144. while (fscanf (pfPnt, "%d", &ifrF) != EOF) {
  1145. if ((ifrF >= m_iFirstFrame) && (ifrF <= m_iLastFrame)) {
  1146. for (Int ip = 0; ip < numPnt; ip++) {
  1147. fscanf (pfPnt, "%lf %lf", &dblX, &dblY);
  1148. Int iFrmIndex = ifrF - m_iFirstFrame;
  1149. if (iFrmIndex % (m_rgvolmd [BASE_LAYER] [iVOidx].iTemporalRate) == 0) {
  1150. m_pppstDst [iVOidx] [iFrmIndex] [ip].x = dblX;
  1151. m_pppstDst [iVOidx] [iFrmIndex] [ip].y = dblY;
  1152. }
  1153. }
  1154. } else {
  1155. for (Int ip = 0; ip < numPnt; ip++) {
  1156. fscanf (pfPnt, "%lf %lf", &dblX, &dblY);
  1157. }
  1158. }
  1159. }
  1160. }
  1162. Void CSessionEncoder::loadSpt (UInt iobj, CVOPU8YUVBA* pvopcDst)
  1163. {
  1164. Char pchSpt [100];
  1165. sprintf (pchSpt, SUB_VDLFILE, m_pchSptDir, iobj, m_pchPrefix);
  1167. FILE* pf = fopen (pchSpt, "rb");
  1168. // read overhead
  1169. Int c0 = getc (pf);
  1170. Int c1 = getc (pf);
  1171. Int c2 = getc (pf);
  1172. assert (c0 == 'S' && (c1 == 'P' || c2 == 'T') );
  1173. CRct rctSpt;
  1174. Bool bAUsage;
  1175. fread (&rctSpt.left, sizeof (CoordI), 1, pf);
  1176. fread (&rctSpt.top, sizeof (CoordI), 1, pf);
  1177. fread (&rctSpt.right, sizeof (CoordI), 1, pf);
  1178. fread (&rctSpt.bottom, sizeof (CoordI), 1, pf);
  1179. fread (&bAUsage, sizeof (Int), 1, pf);
  1180. #ifndef _FOR_GSSP_
  1181. assert (bAUsage != EIGHT_BIT); // sprite with Alpha channel is not supported at this moment
  1182. #endif
  1183. Int iYDataHeight = m_rctOrg.height ();
  1184. Int iUVDataHeight = m_rctOrg.height () / 2;
  1185. Int iYFrmWidth = pvopcDst->whereY ().width;
  1186. Int iUvFrmWidth = pvopcDst->whereUV ().width;
  1187. Int nSkipYPixel = iYFrmWidth * EXPANDY_REF_FRAME + EXPANDY_REF_FRAME;
  1188. Int nSkipUvPixel = iUvFrmWidth * EXPANDUV_REF_FRAME + EXPANDUV_REF_FRAME;
  1189. PixelC* ppxlcY = (PixelC*) pvopcDst->pixelsY () + nSkipYPixel;
  1190. PixelC* ppxlcU = (PixelC*) pvopcDst->pixelsU () + nSkipUvPixel;
  1191. PixelC* ppxlcV = (PixelC*) pvopcDst->pixelsV () + nSkipUvPixel;
  1193. CoordI y;
  1194. for (y = 0; y < iYDataHeight; y++) {
  1195. Int size = (Int) fread (ppxlcY, sizeof (U8), m_rctOrg.width, pf);
  1196. if (size == 0)
  1197. fprintf (stderr, "Unexpected end of filen");
  1198. ppxlcY += iYFrmWidth;
  1199. }
  1201. for (y = 0; y < iUVDataHeight; y++) {
  1202. Int size = (Int) fread (ppxlcU, sizeof (U8), m_rctOrg.width / 2, pf);
  1203. if (size == 0)
  1204. fprintf (stderr, "Unexpected end of filen");
  1205. ppxlcU += iUvFrmWidth;
  1206. }
  1208. for (y = 0; y < iUVDataHeight; y++) {
  1209. Int size = (Int) fread (ppxlcV, sizeof (U8), m_rctOrg.width / 2, pf);
  1210. if (size == 0)
  1211. fprintf (stderr, "Unexpected end of filen");
  1212. ppxlcV += iUvFrmWidth;
  1213. }
  1215. PixelC* ppxlcBY = (PixelC*) pvopcDst->pixelsBY () + nSkipYPixel;
  1216. //Int iObjectExist = 0;
  1217. if ((bAUsage == ONE_BIT) && (pvopcDst -> fAUsage () == ONE_BIT)) { // load Alpha
  1218. //binary
  1219. for (CoordI y = 0; y < iYDataHeight; y++) {
  1220. Int size = (Int) fread (ppxlcBY, sizeof (U8), m_rctOrg.width, pf);
  1221. if (size == 0)
  1222. fprintf (stderr, "Unexpected end of filen");
  1223. ppxlcBY += iYFrmWidth;
  1224. }
  1225. ((CU8Image*) pvopcDst->getPlane (BUV_PLANE))->decimateBinaryShapeFrom (*(pvopcDst->getPlane (BY_PLANE)));
  1226. }
  1227. #ifdef _FOR_GSSP_
  1228. else if ((bAUsage == EIGHT_BIT) && (pvopcDst -> fAUsage () == EIGHT_BIT)) { // load Alpha
  1229. //grayscale alpha
  1230. PixelC* ppxlcA = (PixelC*) pvopcDst->pixelsA () + nSkipYPixel;
  1231. for (CoordI y = 0; y < iYDataHeight; y++) {
  1232. for (CoordI x = 0; x < m_rctOrg.width; x++) {
  1233. PixelC pxlcCurr = getc (pf);
  1234. ppxlcA [x]  = (pxlcCurr >= GRAY_ALPHA_THRESHOLD) ? pxlcCurr : transpValue;
  1235. ppxlcBY [x] = (pxlcCurr >= GRAY_ALPHA_THRESHOLD) ? opaqueValue : transpValue;
  1236. }
  1237. ppxlcBY += iYFrmWidth;
  1238. ppxlcA  += iYFrmWidth;
  1239. }
  1240. ((CU8Image*) pvopcDst->getPlane (BUV_PLANE))->decimateBinaryShapeFrom (*(pvopcDst->getPlane (BY_PLANE)));
  1241. }
  1242. #endif
  1243. }
  1245. Void CSessionEncoder::getInputFiles (FILE*& pfYuvSrc, FILE*& pfAlpSrc, FILE*& pfYuvSrcSpatialEnhn,
  1246.  FILE* rgpfReconYUV [], FILE* rgpfReconSeg [], 
  1247.  ofstream* rgpostrm [], ofstream* rgpostrmTrace [],
  1248.  PixelC& pxlcObjColor, Int iobj, const VOLMode& volmd, const VOLMode& volmd_enhn)
  1249. {
  1250. static Char pchYUV [100], pchSeg [100], pchCmp [100], pchTrace [100];
  1252. //output files
  1253. createCmpDir (iobj);
  1254. sprintf (pchCmp, SUB_CMPFILE, m_pchOutStrFiles, iobj, m_pchPrefix);
  1255. sprintf (pchTrace, SUB_TRCFILE, m_pchOutStrFiles, iobj, m_pchPrefix);
  1256. rgpostrm [BASE_LAYER] = new ofstream (pchCmp, IOS_BINARY | ios::out);
  1257. rgpostrmTrace [BASE_LAYER] = NULL;
  1258. if (volmd.bTrace)
  1259. rgpostrmTrace [BASE_LAYER] = new ofstream (pchTrace);
  1261. // prepare for the reconstructed files
  1262. createReconDir (iobj); // create a directory for the reconstructed YUV in case it doesn't exist
  1263. sprintf (pchYUV, SUB_YUVFILE, m_pchReconYUVDir, iobj, m_pchPrefix);
  1264. sprintf (pchSeg, SUB_SEGFILE, m_pchReconYUVDir, iobj, m_pchPrefix);
  1266. rgpfReconSeg [BASE_LAYER] = NULL;
  1267. rgpfReconSeg [ENHN_LAYER] = NULL;
  1269. rgpfReconYUV [BASE_LAYER] = fopen (pchYUV, "wb"); // reconstructed YUV file
  1270. assert (rgpfReconYUV [BASE_LAYER] != NULL);
  1271. if (volmd.fAUsage != RECTANGLE) {
  1272. rgpfReconSeg [BASE_LAYER] = fopen (pchSeg, "wb"); // reconstructed seg file
  1273. assert (rgpfReconSeg [BASE_LAYER] != NULL);
  1274. }
  1275. /*
  1276. if (m_rgbSpatialScalability [iobj - m_iFirstVO] == TRUE) {
  1277. sprintf (pchCmp, ENHN_SUB_CMPFILE, m_pchOutStrFiles, iobj, m_pchPrefix);
  1278. sprintf (pchTrace, ENHN_SUB_TRCFILE, m_pchOutStrFiles, iobj, m_pchPrefix);
  1279. rgpostrm [ENHN_LAYER] = new ofstream (pchCmp, IOS_BINARY | ios::out);
  1280. rgpostrmTrace [ENHN_LAYER] = NULL;
  1281. if (volmd.bTrace)
  1282. rgpostrmTrace [ENHN_LAYER] = new ofstream (pchTrace);
  1284. sprintf (pchYUV, ENHN_SUB_YUVFILE, m_pchReconYUVDir, iobj, m_pchPrefix);
  1285. sprintf (pchSeg, ENHN_SUB_SEGFILE, m_pchReconYUVDir, iobj, m_pchPrefix);
  1286. rgpfReconYUV [ENHN_LAYER] = fopen (pchYUV, "wb"); // reconstructed YUV file
  1287. if (volmd.fAUsage != RECTANGLE) {
  1288. rgpfReconSeg [ENHN_LAYER] = fopen (pchSeg, "wb"); // reconstructed seg file
  1289. assert (FALSE); // no spatial scalability for shape
  1290. }
  1291. }
  1292. */ //wchen: moved down 
  1293. if (!m_bTexturePerVOP) 
  1294. sprintf (pchYUV, ROOT_YUVFILE, m_pchBmpFiles, m_pchPrefix);
  1295. else 
  1296. sprintf (pchYUV, SUB_YUVFILE, m_pchBmpFiles, iobj, m_pchPrefix);
  1297. pfYuvSrc = fopen (pchYUV, "rb");
  1298. if (pfYuvSrc == NULL) {
  1299. fprintf (stderr, "can't open %sn", pchYUV);
  1300. exit (1);
  1301. }
  1303. if (m_rgbSpatialScalability [iobj - m_iFirstVO] == TRUE) {
  1304. sprintf (pchCmp, ENHN_SUB_CMPFILE, m_pchOutStrFiles, iobj, m_pchPrefix);
  1305. sprintf (pchTrace, ENHN_SUB_TRCFILE, m_pchOutStrFiles, iobj, m_pchPrefix);
  1306. rgpostrm [ENHN_LAYER] = new ofstream (pchCmp, IOS_BINARY | ios::out);
  1307. rgpostrmTrace [ENHN_LAYER] = NULL;
  1308. if (volmd_enhn.bTrace) // modified by Sharp (98/2/12)
  1309. rgpostrmTrace [ENHN_LAYER] = new ofstream (pchTrace);
  1311. // begin: added by Sharp (98/10/26)
  1312. if ( volmd_enhn.bTemporalScalability == TRUE ){
  1313. rgpfReconYUV [ENHN_LAYER] = rgpfReconYUV[BASE_LAYER];
  1314. if (volmd_enhn.fAUsage != RECTANGLE) {
  1315. if ( volmd_enhn.iEnhnType == 0 )
  1316. rgpfReconSeg [ENHN_LAYER] = rgpfReconSeg[BASE_LAYER];
  1317. else{
  1318. sprintf (pchSeg, ENHN_SUB_SEGFILE, m_pchReconYUVDir, iobj, m_pchPrefix);
  1319. rgpfReconSeg [ENHN_LAYER] = fopen (pchSeg, "wb"); // reconstructed seg file
  1320. }
  1321. }
  1322. } else {
  1323. // end: added by Sharp (98/10/26)
  1324. sprintf (pchYUV, ENHN_SUB_YUVFILE, m_pchReconYUVDir, iobj, m_pchPrefix);
  1325. sprintf (pchSeg, ENHN_SUB_SEGFILE, m_pchReconYUVDir, iobj, m_pchPrefix);
  1326. rgpfReconYUV [ENHN_LAYER] = fopen (pchYUV, "wb"); // reconstructed YUV file
  1327. if (volmd_enhn.fAUsage != RECTANGLE) { // modified by Sharp (98/2/12)
  1328. rgpfReconSeg [ENHN_LAYER] = fopen (pchSeg, "wb"); // reconstructed seg file
  1329. // deleted by Sharp (98/10/26)
  1330. // begin: added by Sharp (98/2/10)
  1331. // if ( volmd.bTemporalScalability == TRUE )
  1332. // assert (rgpfReconSeg [ENHN_LAYER] != NULL);
  1333. // else
  1334. // end: added by Sharp (98/2/10)
  1335. // end: deleted by Sharp (98/10/26)
  1336. assert (FALSE); // no spatial scalability for shape
  1337. }
  1338. } // added by Sharp (98/10/26)
  1340. if ( volmd_enhn.bTemporalScalability == FALSE ){ // added by Sharp (98/2/10)
  1341. if (!m_bTexturePerVOP) { 
  1342. fprintf (stderr,"m_bTexturePerVOP != 0 is not applyed for spatial scalable codingn");
  1343. }
  1344. else 
  1345. sprintf (pchYUV, ENHN_SUB_YUVFILE, m_pchBmpFiles, iobj, m_pchPrefix);
  1346. pfYuvSrcSpatialEnhn = fopen (pchYUV, "rb");
  1347. if (pfYuvSrcSpatialEnhn == NULL){
  1348. fprintf (stderr,"can't open %sn", pchYUV);
  1349. exit(1);
  1350. }
  1351. } // added by Sharp (98/2/10)
  1352. }
  1354. if (volmd.fAUsage != RECTANGLE ||
  1355. m_rgbSpatialScalability [iobj - m_iFirstVO] == TRUE && volmd_enhn.fAUsage != RECTANGLE) { // load Alpha // modified by Sharp (98/2/12)
  1356. if (!m_bAlphaPerVOP) {
  1357. pxlcObjColor = iobj;
  1358. sprintf (pchSeg, ROOT_SEGFILE, m_pchBmpFiles, m_pchPrefix);
  1359. }
  1360. else {
  1361. pxlcObjColor = opaqueValue;   // out data notation
  1362. sprintf (pchSeg, SUB_SEGFILE, m_pchBmpFiles, iobj, m_pchPrefix);
  1363. }
  1364. pfAlpSrc = fopen (pchSeg, "rb");
  1365. if (pfAlpSrc == NULL) {
  1366. fprintf (stderr, "can't open %sn", pchSeg);
  1367. exit (1);
  1368. }
  1369. }
  1370. // begin: deleted by Sharp (98/10/26)
  1371. // begin: added by Sharp (98/2/10)
  1372. // #ifndef __OUT_ONE_FRAME_
  1373. //  if (m_rgbSpatialScalability [iobj - m_iFirstVO] == TRUE && volmd_enhn.bTemporalScalability == TRUE && volmd_enhn.iEnhnType != 0) { // modified by Sharp (98/3/24)
  1374. //  FILE *pfTemp;
  1375. //  sprintf (pchYUV, "%s/%2.2d/%s_bgc.yuv", m_pchReconYUVDir, iobj, m_pchPrefix);
  1376. //  pfTemp = fopen (pchYUV, "wb");  // clear file pointer for background composition
  1377. //  fclose(pfTemp);
  1378. //  }
  1379. // #endif
  1380. // end: added by Sharp (98/2/10)
  1381. // end: deleted by Sharp (98/10/26)
  1382. }
  1384. Void CSessionEncoder::initVOEncoder (CVideoObjectEncoder** rgpvoenc, Int iobj, ofstream* rgpostrmTrace [])
  1385. {
  1386. Int iVOidx = iobj - m_iFirstVO;
  1387. Bool bTemporalScalability = m_rgvolmd[BASE_LAYER][iVOidx].bTemporalScalability; // added by Sharp (98/2/10)
  1388. // Bool bTemporalScalability = TRUE; // added by Sharp (98/2/10)
  1389. if (m_rgbSpatialScalability [iVOidx] == TRUE) {
  1390. rgpvoenc [BASE_LAYER] = new CVideoObjectEncoder (
  1391. iobj, 
  1392. m_rgvolmd [BASE_LAYER] [iVOidx], 
  1393. m_rgvopmd [BASE_LAYER] [iVOidx], 
  1394. m_iFirstFrame,
  1395. m_iLastFrame,
  1396. m_rctOrg.width,
  1397. m_rctOrg.height(),
  1398. m_rguiRateControl [BASE_LAYER] [iVOidx],
  1399. m_rguiBudget [BASE_LAYER] [iVOidx],
  1400. rgpostrmTrace [BASE_LAYER],
  1401. m_rguiWarpingAccuracy [iVOidx],
  1402. m_rgNumOfPnts [iVOidx],
  1403. m_pppstDst [iVOidx],
  1404. m_SptMode,
  1405. m_rctFrame,
  1406.                                                         m_rctOrg,
  1407. m_rgiMVFileUsage [BASE_LAYER][iVOidx],
  1408. m_pchMVFileName  [BASE_LAYER][iVOidx]);
  1409. // begin: added by Sharp (98/2/10)
  1410. if ( bTemporalScalability )
  1411. rgpvoenc [ENHN_LAYER] = new CVideoObjectEncoder (
  1412. iobj, 
  1413. m_rgvolmd [ENHN_LAYER] [iVOidx],
  1414. m_rgvopmd [ENHN_LAYER] [iVOidx], 
  1415. m_iFirstFrame,
  1416. m_iLastFrame,
  1417. m_rctOrg.width,
  1418. m_rctOrg.height(),
  1419. m_rguiRateControl [ENHN_LAYER] [iVOidx],
  1420. m_rguiBudget [ENHN_LAYER] [iVOidx],
  1421. rgpostrmTrace [ENHN_LAYER],
  1422. 0,
  1423. -1,
  1424.                                                         m_pppstDst [iVOidx],
  1425. m_SptMode,
  1426. m_rctFrame,
  1427. m_rctOrgSpatialEnhn,
  1428. m_rgiMVFileUsage [ENHN_LAYER][iVOidx],
  1429. m_pchMVFileName  [ENHN_LAYER][iVOidx]);
  1430. else
  1431. // end: added by Sharp (98/2/10)
  1432. rgpvoenc [ENHN_LAYER] = new CVideoObjectEncoder (
  1433. iobj, 
  1434. m_rgvolmd [ENHN_LAYER] [iVOidx],
  1435. m_rgvopmd [ENHN_LAYER] [iVOidx], 
  1436. m_iFirstFrame,
  1437. m_iLastFrame,
  1438. m_rctOrgSpatialEnhn.width,
  1439. m_rctOrgSpatialEnhn.height (),
  1440. m_rguiRateControl [ENHN_LAYER] [iVOidx],
  1441. m_rguiBudget [ENHN_LAYER] [iVOidx],
  1442. rgpostrmTrace [ENHN_LAYER],
  1443. 0,
  1444. -1,
  1445.                                                         m_pppstDst [iVOidx],
  1446. m_SptMode,
  1447. m_rctFrame,
  1448. m_rctOrgSpatialEnhn,
  1449. m_rgiMVFileUsage [ENHN_LAYER][iVOidx],
  1450. m_pchMVFileName  [ENHN_LAYER][iVOidx]);
  1451. }
  1452. else {
  1453. rgpvoenc [BASE_LAYER] = new CVideoObjectEncoder (
  1454. iobj, 
  1455. m_rgvolmd [BASE_LAYER] [iVOidx], 
  1456. m_rgvopmd [BASE_LAYER] [iVOidx], 
  1457. m_iFirstFrame,
  1458. m_iLastFrame,
  1459. m_rctOrg.width,
  1460. m_rctOrg.height (),
  1461. m_rguiRateControl [BASE_LAYER] [iVOidx],
  1462. m_rguiBudget [BASE_LAYER] [iVOidx],
  1463. rgpostrmTrace [BASE_LAYER],
  1464. m_rguiWarpingAccuracy [iVOidx],
  1465. m_rgNumOfPnts [iVOidx],
  1466. m_pppstDst [iVOidx],
  1467. m_SptMode,
  1468. m_rctFrame,
  1469.                                                         m_rctOrg,
  1470. m_rgiMVFileUsage [BASE_LAYER][iVOidx],
  1471. m_pchMVFileName  [BASE_LAYER][iVOidx]);
  1472. }
  1473. }
  1475. Bool CSessionEncoder::loadData (UInt iFrame, FILE* pfYuvSrc, FILE* pfSegSrc, PixelC pxlcObjColor, CVOPU8YUVBA* pvopcDst, CRct& rctOrg, const VOLMode& volmd)
  1476. {
  1477. Int iLeadingPixels = iFrame * rctOrg.area ();
  1478. if (volmd.nBits<=8) {
  1479. fseek (pfYuvSrc, iLeadingPixels + iLeadingPixels / 2, SEEK_SET); //4:2:0
  1480. } else { // NBIT: 2 bytes per pixel, Y component plus UV
  1481. fseek (pfYuvSrc, iLeadingPixels * 3, SEEK_SET);
  1482. }
  1483. if (volmd.fAUsage != RECTANGLE)
  1484. fseek (pfSegSrc, iLeadingPixels, SEEK_SET);
  1486. Int iYDataHeight = rctOrg.height ();
  1487. Int iUVDataHeight = rctOrg.height () / 2;
  1488. Int iYFrmWidth = pvopcDst->whereY ().width;
  1489. Int iUvFrmWidth = pvopcDst->whereUV ().width;
  1490. Int nSkipYPixel = iYFrmWidth * EXPANDY_REF_FRAME + EXPANDY_REF_FRAME;
  1491. Int nSkipUvPixel = iUvFrmWidth * EXPANDUV_REF_FRAME + EXPANDUV_REF_FRAME;
  1492. PixelC* ppxlcY = (PixelC*) pvopcDst->pixelsY () + nSkipYPixel;
  1493. PixelC* ppxlcU = (PixelC*) pvopcDst->pixelsU () + nSkipUvPixel;
  1494. PixelC* ppxlcV = (PixelC*) pvopcDst->pixelsV () + nSkipUvPixel;
  1496. CoordI y,x;
  1497. for (y = 0; y < iYDataHeight; y++) {
  1498. Int size = (Int) fread (ppxlcY, sizeof (PixelC), rctOrg.width, pfYuvSrc);
  1499. if (size == 0)
  1500. fprintf (stderr, "Unexpected end of filen");
  1501. ppxlcY += iYFrmWidth;
  1502. }
  1504.  /* modified by Rockwell (98/05/08)
  1505. if (volmd.nBits<=8) {*/
  1506. for (y = 0; y < iUVDataHeight; y++) {
  1507. Int size = (Int) fread (ppxlcU, sizeof (PixelC), rctOrg.width / 2, pfYuvSrc);
  1508. if (size == 0)
  1509. fprintf (stderr, "Unexpected end of filen");
  1510. ppxlcU += iUvFrmWidth;
  1511. }
  1513. for (y = 0; y < iUVDataHeight; y++) {
  1514. Int size = (Int) fread (ppxlcV, sizeof (PixelC), rctOrg.width / 2, pfYuvSrc);
  1515. if (size == 0)
  1516. fprintf (stderr, "Unexpected end of filen");
  1517. ppxlcV += iUvFrmWidth;
  1518. }
  1519.   /* modified by Rockwell (98/05/08)
  1520.   } else { // NBIT: fill UV space with default pixel value
  1521. Int iDefval = 1<<(volmd.nBits-1);
  1522. Int iUVDataWidth = rctOrg.width / 2;
  1523. for (y = 0; y < iUVDataHeight; y++) {
  1524. for (x = 0; x < iUVDataWidth; x++) {
  1525. ppxlcU[x] = iDefval;
  1526. ppxlcV[x] = iDefval;
  1527. }
  1528. ppxlcU += iUvFrmWidth;
  1529. ppxlcV += iUvFrmWidth;
  1530. }
  1531.     }
  1532.   */
  1534. PixelC* ppxlcBY = (PixelC*) pvopcDst->pixelsBY () + nSkipYPixel;
  1535. Int iObjectExist = 0;
  1536. if (volmd.fAUsage == ONE_BIT) { // load Alpha
  1537. //binary
  1538. for (y = 0; y < iYDataHeight; y++) {
  1539. for (x = 0; x < rctOrg.width; x++) {
  1540. PixelC pxlcCurr = getc (pfSegSrc);
  1541. ppxlcBY [x] = (pxlcCurr == pxlcObjColor) ? opaqueValue : transpValue;
  1542. iObjectExist += ppxlcBY [x];
  1543. }
  1544. ppxlcBY += iYFrmWidth;
  1545. }
  1546. ((CU8Image*) pvopcDst->getPlane (BUV_PLANE))->decimateBinaryShapeFrom (*(pvopcDst->getPlane (BY_PLANE)));
  1547. }
  1548. else if (volmd.fAUsage == EIGHT_BIT) { // load Alpha
  1549. //gray
  1550. PixelC* ppxlcA = (PixelC*) pvopcDst->pixelsA () + nSkipYPixel;
  1551. for (y = 0; y < iYDataHeight; y++) {
  1552. for (x = 0; x < rctOrg.width; x++) {
  1553. PixelC pxlcCurr = getc (pfSegSrc);
  1554. ppxlcA [x]  = (pxlcCurr >= GRAY_ALPHA_THRESHOLD) ? pxlcCurr : transpValue;
  1555. ppxlcBY [x] = (pxlcCurr >= GRAY_ALPHA_THRESHOLD) ? opaqueValue : transpValue;
  1556. iObjectExist += ppxlcBY [x];
  1557. }
  1558. ppxlcBY += iYFrmWidth;
  1559. ppxlcA  += iYFrmWidth;
  1560. }
  1561. ((CU8Image*) pvopcDst->getPlane (BUV_PLANE))->decimateBinaryShapeFrom (*(pvopcDst->getPlane (BY_PLANE)));
  1562. }
  1563. else                                                                                                        //rectangle
  1564. iObjectExist = 1;
  1566. /* static int ini = 0;
  1567. if(ini = 0)
  1568. {
  1569. srand(123421);
  1570. ini = 1;
  1571. }
  1573. int k = rand();
  1574. if((k%4)==0)
  1575. iObjectExist = 0;*/
  1577. return (iObjectExist != 0);
  1578. }
  1580. CRct CSessionEncoder::findBoundBoxInAlpha (UInt ifr, UInt iobj)
  1581. {
  1582. CIntImage* pfiARet = NULL;
  1583. Char pchSeg [100];
  1584. if (m_rgvolmd [BASE_LAYER] [iobj].fAUsage != RECTANGLE) { // load Alpha
  1585. if (!m_bAlphaPerVOP) {
  1586. sprintf (pchSeg, ROOT_SEGFILE, m_pchBmpFiles, m_pchPrefix);
  1587. pfiARet = alphaFromCompFile (pchSeg, ifr, iobj, m_rctOrg);
  1588. }
  1589. else {
  1590. sprintf (pchSeg, SUB_SEGFILE, m_pchBmpFiles, iobj, m_pchPrefix);
  1591. pfiARet = new CIntImage (pchSeg, ifr, m_rctOrg);
  1592. pfiARet -> threshold (64);
  1593. }
  1594. CRct rctBoundingBox = pfiARet -> whereVisible ();
  1595. if (rctBoundingBox.left % 2 != 0)
  1596. rctBoundingBox.left--;
  1597. if (rctBoundingBox.top % 2 != 0)
  1598. rctBoundingBox.top--;
  1599. if (rctBoundingBox.right % 2 != 0)
  1600. rctBoundingBox.right++;
  1601. if (rctBoundingBox.bottom % 2 != 0)
  1602. rctBoundingBox.bottom++;
  1603. rctBoundingBox.width = rctBoundingBox.right - rctBoundingBox.left;
  1604. delete pfiARet;
  1605. return rctBoundingBox;
  1606. }
  1607. else
  1608. return m_rctOrg;
  1609. }
  1611. CRct CSessionEncoder::findSptRct (UInt iobj)
  1612. {
  1613. CRct rctSpt;
  1614. Char pchSpt [100];
  1615. sprintf (pchSpt, SUB_VDLFILE, m_pchSptDir, iobj, m_pchPrefix);
  1616. FILE* pf = fopen (pchSpt, "rb");
  1617. // read overhead
  1618. Int c0 = getc (pf);
  1619. Int c1 = getc (pf);
  1620. Int c2 = getc (pf);
  1621. assert (c0 == 'S' && (c1 == 'P' || c2 == 'T') );
  1622. fread (&rctSpt.left, sizeof (CoordI), 1, pf);
  1623. fread (&rctSpt.top, sizeof (CoordI), 1, pf);
  1624. fread (&rctSpt.right, sizeof (CoordI), 1, pf);
  1625. fread (&rctSpt.bottom, sizeof (CoordI), 1, pf);
  1626. assert (rctSpt.left % 2 == 0);
  1627. assert (rctSpt.top % 2 == 0);
  1628. rctSpt.width = rctSpt.right - rctSpt.left;
  1629. fclose (pf);
  1630. return rctSpt;
  1631. }
  1633. Void CSessionEncoder::dumpData (FILE* pfYuvDst, FILE* pfSegDst, 
  1634. const CVOPU8YUVBA* pvopcSrc, 
  1635. const CRct& rctOrg, const VOLMode& volmd)
  1636. {
  1637. Int iYDataHeight = rctOrg.height ();
  1638. Int iUVDataHeight = rctOrg.height () / 2;
  1639. Int iYFrmWidth = pvopcSrc->whereY ().width;
  1640. Int iUvFrmWidth = pvopcSrc->whereUV ().width;
  1641. Int nSkipYPixel = iYFrmWidth * EXPANDY_REF_FRAME + EXPANDY_REF_FRAME;
  1642. Int nSkipUvPixel = iUvFrmWidth * EXPANDUV_REF_FRAME + EXPANDUV_REF_FRAME;
  1643. const PixelC* ppxlcY = pvopcSrc->pixelsY () + nSkipYPixel;
  1644. const PixelC* ppxlcU = pvopcSrc->pixelsU () + nSkipUvPixel;
  1645. const PixelC* ppxlcV = pvopcSrc->pixelsV () + nSkipUvPixel;
  1647. if ( volmd.iEnhnType == 0 || volmd.volType == BASE_LAYER ){ // added by Sharp (99/1/20)
  1648. CoordI y;
  1649. for (y = 0; y < iYDataHeight; y++) {
  1650. Int size = (Int) fwrite (ppxlcY, sizeof (PixelC), rctOrg.width, pfYuvDst);
  1651. if (size == 0)
  1652. exit(fprintf (stderr, "Can't write to filen"));
  1653. ppxlcY += iYFrmWidth;
  1654. }
  1656.     // NBIT: now there is a UV component when nBits>8
  1657. for (y = 0; y < iUVDataHeight; y++) {
  1658. Int size = (Int) fwrite (ppxlcU, sizeof (PixelC), rctOrg.width / 2, pfYuvDst);
  1659. if (size == 0)
  1660. exit(fprintf (stderr, "Can't write to filen"));
  1661. ppxlcU += iUvFrmWidth;
  1662. }
  1664. for (y = 0; y < iUVDataHeight; y++) {
  1665. Int size = (Int) fwrite (ppxlcV, sizeof (PixelC), rctOrg.width / 2, pfYuvDst);
  1666. if (size == 0)
  1667. exit(fprintf (stderr, "Can't write to filen"));
  1668. ppxlcV += iUvFrmWidth;
  1669. }
  1670.   } // added by Sharp (99/1/20)
  1673. // if ( volmd.iEnhnType == 0) { // added by Sharp (98/10/26)
  1674. if (volmd.fAUsage == ONE_BIT) {
  1675. const PixelC* ppxlcBY = pvopcSrc->pixelsBY () + nSkipYPixel;
  1676. for (CoordI y = 0; y < iYDataHeight; y++) {
  1677.     if (volmd.bNot8Bit==0) {
  1678. /* Int size = (Int)*/ fwrite (ppxlcBY, sizeof (PixelC), m_rctOrg.width, pfSegDst);
  1679.     } else { // NBIT: here PixelC is unsigned short
  1680. const PixelC* ppxlcBYAux = ppxlcBY;
  1681. for (CoordI x = 0; x < m_rctOrg.width; x++, ppxlcBYAux++) {
  1682. fwrite(ppxlcBYAux, sizeof(PixelC), 1, pfSegDst);
  1683. }
  1684.     }
  1685. ppxlcBY += iYFrmWidth;
  1686. }
  1687. } else if (volmd.fAUsage == EIGHT_BIT) {
  1688. const PixelC* ppxlcBY = pvopcSrc->pixelsBY () + nSkipYPixel;
  1689. const PixelC* ppxlcA = pvopcSrc->pixelsA () + nSkipYPixel;
  1690. const PixelC pxlcZero = 0;
  1691. for (CoordI y = 0; y < iYDataHeight; y++) {
  1692. const PixelC* ppxlcBYAux = ppxlcBY;
  1693. const PixelC* ppxlcAAux = ppxlcA;
  1694. CoordI x;
  1695. for( x = 0; x < m_rctOrg.width; x++, ppxlcBYAux++, ppxlcAAux++)
  1696. if(*ppxlcBYAux)
  1697. fwrite(ppxlcAAux, sizeof(PixelC), 1, pfSegDst);
  1698. else
  1699. fwrite(&pxlcZero, sizeof(PixelC), 1, pfSegDst);
  1700. ppxlcA += iYFrmWidth;
  1701. ppxlcBY += iYFrmWidth;
  1702. }
  1703. }
  1704. // } // added by Sharp (98/10/26)
  1705. }
  1707. Void CSessionEncoder::updateRefForTPS (
  1708. CVideoObjectEncoder* pvopc,
  1709. CEnhcBufferEncoder* BufP1,
  1710. CEnhcBufferEncoder* BufP2,
  1711. CEnhcBufferEncoder* BufB1,
  1712. CEnhcBufferEncoder* BufB2,
  1713. CEnhcBufferEncoder* BufE,
  1714. Int bNoNextVOP,
  1715. Int iVOrelative,
  1716. Int iEcount,
  1717. Int ibFrameWithRate,
  1718. Int ieFrame,
  1719. Bool bupdateForLastLoop
  1720. )
  1721. {
  1722. if ( (m_rgiTemporalScalabilityType[iVOrelative] == 2 && iEcount == 0) ||
  1723. (m_rgiTemporalScalabilityType[iVOrelative] == 0 && ieFrame == ibFrameWithRate) ){
  1725. if ( BufP1 -> m_bCodedFutureRef == 1 ){ // added by Sharp (99/1/26)
  1726. pvopc -> setPredType(PVOP);
  1727. pvopc -> setRefSelectCode(1);
  1728. if ( BufB1 -> empty() )
  1729. BufP1 -> putBufToQ0 ( pvopc );
  1730. else
  1731. BufB1 -> putBufToQ0 ( pvopc );
  1732. } else // added by Sharp (99/1/26)
  1733. pvopc -> setPredType(IVOP); // added by Sharp (99/1/26)
  1735. } else if ( m_rgiTemporalScalabilityType[iVOrelative] == 2 ){
  1737. pvopc -> setPredType(BVOP);
  1738. pvopc -> setRefSelectCode(1);
  1739. BufE -> putBufToQ0 ( pvopc );
  1740. if ( BufB1 -> empty() )
  1741. BufP1 -> putBufToQ1( pvopc );
  1742. else
  1743. BufB1 -> putBufToQ1( pvopc );
  1745. } else if ( m_rgiTemporalScalabilityType[iVOrelative] == 1 ){
  1747. if ( bNoNextVOP && !bupdateForLastLoop ) {
  1748. pvopc -> setPredType(BVOP);
  1749. pvopc -> setRefSelectCode(3);
  1750. if ( BufB1 -> empty() )
  1751. BufP1 -> putBufToQ0( pvopc );
  1752. else
  1753. BufB1 -> putBufToQ0( pvopc );
  1754. if ( BufB2 -> empty() )
  1755. BufP2 -> putBufToQ1( pvopc );
  1756. else
  1757. BufB2 -> putBufToQ1( pvopc );
  1758. }
  1759. else if ( bNoNextVOP && bupdateForLastLoop ) {
  1760. if ( BufP1 -> m_bCodedFutureRef == 1 ){ // added by Sharp (99/1/26)
  1761. pvopc -> setPredType(PVOP);
  1762. pvopc -> setRefSelectCode(1);
  1764. if ( BufB1 -> empty() )
  1765. BufP1 -> putBufToQ0 ( pvopc );
  1766. else
  1767. BufB1 -> putBufToQ0 ( pvopc );
  1768. } else // added by Sharp (99/1/26)
  1769. pvopc -> setPredType(IVOP); // added by Sharp (99/1/26)
  1770. }
  1771. else {
  1772. Time prevTime;
  1773. Time nextTime;
  1775. pvopc -> setPredType(BVOP);
  1776. pvopc -> setRefSelectCode(3);
  1777. if ( BufB1 -> empty() ){
  1778. BufP1 -> putBufToQ0( pvopc );
  1779. // cout << "Time of Q0:" << BufP1 -> m_t << "n";
  1780. prevTime = BufP1 -> m_t;
  1781. }
  1782. else{
  1783. BufB1 -> putBufToQ0( pvopc );
  1784. // cout << "Time of Q0:" << BufB1 -> m_t << "n";
  1785. prevTime = BufB1 -> m_t;
  1786. }
  1787. if ( BufB2 -> empty() ){
  1788. BufP2 -> putBufToQ1( pvopc );
  1789. // cout << "Time of Q1:" << BufP2 -> m_t << "n";
  1790. nextTime = BufP2 -> m_t;
  1791. }
  1792. else{
  1793. BufB2 -> putBufToQ1( pvopc );
  1794. // cout << "Time of Q1:" << BufB2 -> m_t << "n";
  1795. nextTime = BufB2 -> m_t;
  1796. }
  1797. pvopc -> m_tPastRef = prevTime;
  1798. pvopc -> m_tFutureRef = nextTime;
  1799. }
  1801. } 
  1802. // begin: added by Sharp (99/1/25)
  1803.   else if ( m_rgiTemporalScalabilityType[iVOrelative] == 3 && iEcount == 0) {
  1804. if ( BufP1 -> m_bCodedFutureRef == 1 ){
  1805.         pvopc -> setPredType(PVOP);
  1806.         pvopc -> setRefSelectCode(2);
  1807.         if ( BufB2 -> empty() )
  1808.           BufP2 -> putBufToQ1 ( pvopc );
  1809.         else
  1810.           BufB2 -> putBufToQ1 ( pvopc );
  1811.     } else {
  1812.       pvopc -> setPredType(IVOP);
  1813.     }
  1814.   } else if ( m_rgiTemporalScalabilityType[iVOrelative] == 3 ){
  1815.     pvopc -> setPredType(BVOP);
  1816.     pvopc -> setRefSelectCode(2);
  1817.     BufE -> putBufToQ0 ( pvopc );
  1818.     if ( BufB2 -> empty() )
  1819.       BufP2 -> putBufToQ1( pvopc );
  1820.     else
  1821.       BufB2 -> putBufToQ1( pvopc );
  1822.   } else if (m_rgiTemporalScalabilityType[iVOrelative] == 4 ){
  1823.     pvopc -> setPredType(PVOP);
  1824.     pvopc -> setRefSelectCode(2);
  1825.     if ( BufB2 -> empty() )
  1826.       BufP2 -> putBufToQ1 ( pvopc );
  1827.     else
  1828.       BufB2 -> putBufToQ1 ( pvopc );
  1829.   }
  1830. // end: added by Sharp (99/1/25)
  1832. else {
  1834. if ( BufE -> m_bCodedFutureRef == 1 ){ // added by Sharp (99/1/26)
  1835. pvopc -> setPredType(PVOP);
  1836. pvopc -> setRefSelectCode(0);
  1837. BufE -> putBufToQ0 ( pvopc );
  1838. } else // added by Sharp (99/1/26)
  1839. pvopc -> setPredType(IVOP); // added by Sharp (99/1/26)
  1840. }
  1841. }
  1843. // for back/foward shape
  1844. Void CSessionEncoder::initVObfShape (CVideoObjectEncoder** rgpbfShape, 
  1845. Int iobj, // ofstream* rgpostrmTrace [],
  1846. VOLMode& volmd_back, 
  1847. VOPMode& vopmd_back,
  1848. VOLMode& volmd_forw, 
  1849. VOPMode& vopmd_forw
  1850. ) // made from initVOEncoder()
  1851. {
  1852. rgpbfShape [0] = new CVideoObjectEncoder ( iobj, 
  1853. volmd_back,
  1854. vopmd_back,
  1855. m_rctOrg.width,
  1856. m_rctOrg.height () //,
  1857.      );
  1858. rgpbfShape [1] = new CVideoObjectEncoder ( iobj, 
  1859. volmd_forw,
  1860. vopmd_forw,
  1861. m_rctOrg.width,
  1862. m_rctOrg.height () //,
  1863.      );
  1864. }
  1866. Void CSessionEncoder::dumpDataOneFrame (UInt iFrame, Int iobj, const CVOPU8YUVBA* pvopcSrc, const VOLMode& volmd)
  1867. {
  1868. static Int iYDataHeight = m_rctOrg.height ();
  1869. static Int iUVDataHeight = m_rctOrg.height () / 2;
  1870. static Int iYFrmWidth = pvopcSrc->whereY ().width;
  1871. static Int iUvFrmWidth = pvopcSrc->whereUV ().width;
  1872. static Int nSkipYPixel = iYFrmWidth * EXPANDY_REF_FRAME + EXPANDY_REF_FRAME;
  1873. static Int nSkipUvPixel = iUvFrmWidth * EXPANDUV_REF_FRAME + EXPANDUV_REF_FRAME;
  1874. const PixelC* ppxlcY = pvopcSrc->pixelsY () + nSkipYPixel;
  1875. const PixelC* ppxlcU = pvopcSrc->pixelsU () + nSkipUvPixel;
  1876. const PixelC* ppxlcV = pvopcSrc->pixelsV () + nSkipUvPixel;
  1878. // cout << "n=== write in separate format : frame no. =" << iFrame << "n";
  1880. static Char pchYUV [100], pchSeg [100];
  1881. CoordI y;
  1883. // if(volmd.volType == BASE_LAYER) { // deleted by Sharp (98/11/11)
  1884. sprintf (pchYUV, SUB_YUVFILE, m_pchReconYUVDir, iobj, m_pchPrefix);
  1885. sprintf (pchSeg, SUB_SEGFILE, m_pchReconYUVDir, iobj, m_pchPrefix);
  1886. // } // deleted by Sharp (98/11/11)
  1887. // begin: deleted by Sharp (98/11/11)
  1888. // else {
  1889. // sprintf (pchYUV, ENHN_SUB_YUVFILE, m_pchReconYUVDir, iobj, m_pchPrefix);
  1890. // sprintf (pchSeg, ENHN_SUB_SEGFILE, m_pchReconYUVDir, iobj, m_pchPrefix);
  1891. // }
  1892. // end: deleted by Sharp (98/11/11)
  1893. sprintf (pchYUV, "%s%d", pchYUV, iFrame);
  1894. sprintf (pchSeg, "%s%d", pchSeg, iFrame);
  1896. FILE* pfYuvDst = fopen(pchYUV, "wb");
  1898. for (y = 0; y < iYDataHeight; y++) {
  1899. Int size = (Int) fwrite (ppxlcY, sizeof (PixelC), m_rctOrg.width, pfYuvDst);
  1900. if (size == 0)
  1901. exit(fprintf (stderr, "Can't write to file(Y)n"));
  1902. ppxlcY += iYFrmWidth;
  1903. }
  1905. for (y = 0; y < iUVDataHeight; y++) {
  1906. Int size = (Int) fwrite (ppxlcU, sizeof (PixelC), m_rctOrg.width / 2, pfYuvDst);
  1907. if (size == 0)
  1908. exit(fprintf (stderr, "Can't write to file(U)n"));
  1909. ppxlcU += iUvFrmWidth;
  1910. }
  1912. for (y = 0; y < iUVDataHeight; y++) {
  1913. Int size = (Int) fwrite (ppxlcV, sizeof (PixelC), m_rctOrg.width / 2, pfYuvDst);
  1914. if (size == 0)
  1915. exit(fprintf (stderr, "Can't write to file(V)n"));
  1916. ppxlcV += iUvFrmWidth;
  1917. }
  1918. fclose(pfYuvDst);
  1920. if (volmd.fAUsage != RECTANGLE) {
  1921. FILE* pfSegDst = fopen(pchSeg, "wb");
  1922. const PixelC* ppxlcA = (volmd.fAUsage == ONE_BIT) ? pvopcSrc->pixelsBY () + nSkipYPixel
  1923.   : pvopcSrc->pixelsA () + nSkipYPixel;
  1924. for (y = 0; y < iYDataHeight; y++) {
  1925. Int size = (Int) fwrite (ppxlcA, sizeof (PixelC), m_rctOrg.width, pfSegDst);
  1926. if (size == 0)
  1927. exit(fprintf (stderr, "Can't write to file(B)n"));
  1928. ppxlcA += iYFrmWidth;
  1929. }
  1930. fclose(pfSegDst);
  1931. }
  1932. }
  1934. Void CSessionEncoder::encodeEnhanceVideoObject(Bool bObjectExists,
  1935. Int iFrame,
  1936. VOPpredType predType,
  1937. Int iDumpMode,
  1938. Int iVO,Int iVOrelative,
  1939. FILE* pfYuvSrc,
  1940. FILE* pfSegSrc,
  1941. FILE* rgpfReconYUV[],
  1942. FILE* rgpfReconSeg[],
  1943. PixelC pxlcObjColor,
  1944. CVideoObjectEncoder* rgpvoenc,
  1945. const VOLMode& volmd,
  1946. const VOLMode& volmd_enhn,
  1947. Int iEnhnFirstFrame,
  1948. ofstream* rgpostrm[],
  1949. CEnhcBufferEncoder& BufP1,
  1950. CEnhcBufferEncoder& BufP2,
  1951. CEnhcBufferEncoder& BufB1,
  1952. CEnhcBufferEncoder& BufB2,
  1953. CEnhcBufferEncoder& BufE
  1954. )
  1955. {
  1956. Int ieFramebShape; // for back/forward shape : frame number of backward shape
  1957. Int ieFramefShape; // for back/forward shape : frame number of forward shape
  1958. // m_bPrevObjectExists = FALSE; // added by Sharp (98/2/10)
  1960. Int iLayer = 1;
  1961. if (m_rguiSpriteUsage [iVOrelative] == 0) {
  1962. bObjectExists = loadData (iFrame, pfYuvSrc, pfSegSrc, pxlcObjColor, rgpvoenc ->m_pvopcOrig, m_rctOrg, volmd_enhn);
  1964. if ( rgpvoenc -> m_volmd.iEnhnType == 1) {
  1966. rgpvoenc -> set_LoadShape(&ieFramebShape, &ieFramefShape, volmd.iTemporalRate, 
  1967. iFrame, m_iFirstFrame, iEnhnFirstFrame );
  1968. if ( bObjectExists && !m_bPrevObjectExists && rgpvoenc -> m_volmd.iEnhnType == 1 )
  1969. { // bVOPVisible reflect a value of VOP_CODED
  1970. rgpvoenc -> m_vopmd.iLoadBakShape = 1;
  1971. rgpvoenc -> m_vopmd.iLoadForShape = 1;
  1972. }
  1973. m_bPrevObjectExists = bObjectExists;
  1975. // printf("FLAG: %d, %dn", rgpvoenc -> m_vopmd.iLoadBakShape, rgpvoenc -> m_vopmd.iLoadForShape );
  1977. if(rgpvoenc -> m_vopmd.iLoadBakShape) {
  1978. rgpvoenc  -> m_vopmd.iLoadBakShape = loadData (ieFramebShape, pfYuvSrc, pfSegSrc, pxlcObjColor, 
  1979. rgpvoenc ->rgpbfShape [0]->m_pvopcOrig, m_rctOrg, rgpvoenc ->rgpbfShape[0]->m_volmd);
  1980. if ( !rgpvoenc -> m_vopmd.iLoadBakShape )
  1981. cout << "Load_backward_shape was ON, but turned off because of no shapen";
  1982. }
  1983. if(rgpvoenc -> m_vopmd.iLoadForShape) {
  1984. rgpvoenc -> m_vopmd.iLoadForShape = loadData (ieFramefShape, pfYuvSrc, pfSegSrc, pxlcObjColor, 
  1985. rgpvoenc ->rgpbfShape [1]->m_pvopcOrig, m_rctOrg, rgpvoenc ->rgpbfShape[1]->m_volmd);
  1986. if ( !rgpvoenc -> m_vopmd.iLoadForShape )
  1987. cout << "Load_forward_shape was ON, but turned off because of no shapen";
  1988. }
  1989. }
  1990. // begin: added by Sharp (98/3/24)
  1991. else if ( rgpvoenc -> m_volmd.iEnhnType == 2 ) {
  1992. rgpvoenc -> m_vopmd.iLoadBakShape = 0;
  1993. rgpvoenc -> m_vopmd.iLoadForShape = 0;
  1994. }
  1995. // end: added by Sharp (98/3/24)
  1997. rgpvoenc -> encode (bObjectExists, (Time) (iFrame - m_iFirstFrame), predType); //, pvopcBaseQuant
  1999. // for background composition
  2000. if(rgpvoenc -> m_volmd.iEnhnType != 0) {
  2001. // should be changed to background_composition flag later. // modified by Sharp (98/3/24)
  2002. // printf("Performing B.C. ... Time = (%d, %d, %d)n", iFrame, ieFramefShape, ieFramebShape);
  2003. rgpvoenc -> BackgroundComposition(m_rctOrg.width, m_rctOrg.height (),
  2004. iFrame, ieFramefShape, ieFramebShape,
  2005. BufP1.m_pvopcBuf,
  2006. BufP2.m_pvopcBuf,
  2007. BufB1.m_pvopcBuf,
  2008. BufB2.m_pvopcBuf,
  2009. m_pchReconYUVDir, iVO, m_pchPrefix,
  2010. rgpfReconYUV[iLayer]); // modified by Sharp (98/10/26)
  2011. }
  2012. } // sprite
  2014. //dump the output
  2015. if (bObjectExists) {
  2016. // if ( rgpvoenc -> m_volmd.iEnhnType == 0 ){ // added by Sharp (98/10/26) // deleted by Sharp (99/1/25)
  2017. // begin: modified by Sharp (98/11/11)
  2018. #ifndef __OUT_ONE_FRAME_
  2019. if(iDumpMode==DUMP_CURR)
  2020. {
  2021. dumpData (rgpfReconYUV [iLayer], rgpfReconSeg [iLayer], rgpvoenc ->pvopcReconCurr (), m_rctOrg, volmd_enhn);
  2022. }
  2023. else if(iDumpMode==DUMP_PREV)
  2024. {
  2025. dumpData (rgpfReconYUV [iLayer], rgpfReconSeg [iLayer], rgpvoenc ->pvopcRefQPrev (), m_rctOrg, volmd_enhn);
  2026. }
  2027. #else
  2028. dumpDataOneFrame (iFrame, iVO, rgpvoenc ->pvopcReconCurr(), volmd_enhn); // save one frame
  2029. #endif
  2030. // end: modified by Sharp (98/11/11)
  2031. // } // added by Sharp (98/10/26) // deleted by Sharp (99/1/25)
  2032. }
  2033. #ifndef __OUT_ONE_FRAME_ // added by Sharp (98/11/11)
  2034. else
  2035. dumpNonCodedFrame(rgpfReconYUV [iLayer], rgpfReconSeg [iLayer], m_rctOrg, volmd_enhn.nBits);
  2036. #endif // added by Sharp (98/11/11)
  2038. rgpostrm[ENHN_LAYER] ->write (rgpvoenc ->pOutStream ()->str (), rgpvoenc ->pOutStream ()->pcount ());
  2039. if ( rgpvoenc -> m_bCodedFutureRef == 1 ) // added by Sharp (99/1/28)
  2040. BufE.getBuf( rgpvoenc );
  2041. }