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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

vopseenc.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)
  11. and edited by
  12.         Wei Wu (weiwu@stallion.risc.rockwell.com) Rockwell Science Center
  14. and also edited by
  15. Yoshihiro Kikuchi (TOSHIBA CORPORATION)
  16. Takeshi Nagai (TOSHIBA CORPORATION)
  17. Toshiaki Watanabe (TOSHIBA CORPORATION)
  18. Noboru Yamaguchi (TOSHIBA CORPORATION)
  20. and also edited by
  21. David B. Shu (dbshu@hrl.com), Hughes Electronics/HRL Laboratories
  23. Marc Mongenet (Marc.Mongenet@epfl.ch), Swiss Federal Institute of Technology, Lausanne (EPFL)
  25. and also edited by
  26. Yoshinori Suzuki (Hitachi, Ltd.)
  28. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  29. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  30. as specified by the MPEG-4 Video. 
  31. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  32. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  33. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
  34. The original developer of this software module and his/her company, 
  35. the subsequent editors and their companies, 
  36. and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
  37. Copyright is not released for non MPEG-4 Video conforming products. 
  38. Microsoft retains full right to use the code for his/her own purpose, 
  39. assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
  40. This copyright notice must be included in all copies or derivative works. 
  42. Copyright (c) 1996, 1997.
  44. Module Name:
  46. vopSeEnc.hpp
  48. Abstract:
  50. Encoder for one VO.
  52. Revision History:
  53. Sept. 30, 1997: Error resilient tools added by Toshiba
  54. Dec.  11, 1997: Interlaced tools added by NextLevel Systems
  55. X. Chen, xchen@nlvl.com B. Eifrig, beifrig@nlvl.com
  56. Jun.  16, 1998: add Complexity Estimation syntax support
  57. Marc Mongenet (Marc.Mongenet@epfl.ch) - EPFL
  58. Jan.  28, 1999: Rounding control parameters added by Hitachi, Ltd.
  59. May    9, 1999: tm5 rate control by DemoGraFX, duhoff@mediaone.net
  61. *************************************************************************/
  63. #include <stdio.h>
  64. #include <iostream.h>
  65. #include <fstream.h>
  66. #include <math.h>
  67. #include <stdlib.h>
  69. #include "typeapi.h"
  70. #include "codehead.h"
  71. #include "global.hpp"
  72. #include "entropy/bitstrm.hpp"
  73. #include "entropy/entropy.hpp"
  74. #include "entropy/huffman.hpp"
  75. #include "mode.hpp"
  76. #include "dct.hpp"
  77. #include "tps_enhcbuf.hpp" // added by Sharp (98/2/12)
  78. #include "vopses.hpp"
  79. #include "vopseenc.hpp"
  80. #include "enhcbufenc.hpp" // added by Sharp (98/2/12)
  81. #include "cae.h" // Added for error resilient mode by Toshiba(1997-11-14)
  83. #ifdef __MFC_
  84. #ifdef _DEBUG
  85. #undef THIS_FILE
  86. static char BASED_CODE THIS_FILE[] = __FILE__;
  87. #endif
  89. #define new DEBUG_NEW    
  90. #endif // __MFC_
  92. CVideoObjectEncoder::~CVideoObjectEncoder ()
  93. {
  94. delete m_pvopcOrig;
  95. delete m_pvopcRefOrig1;
  96. delete m_pvopcRefOrig0;
  98. delete m_puciRefQZoom0;
  99. delete m_puciRefQZoom1;
  100. delete m_pfdct;
  101. delete [] m_rgdSNR;
  103. // bitstream stuff
  104. delete [] m_pchBitsBuffer; 
  105. delete m_pbitstrmOut;
  106. delete m_pentrencSet;
  107. delete [] m_pchShapeBitsBuffer;
  108. delete m_pbitstrmShape;
  110. // Added for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)
  111. delete [] *m_pchShapeBitsBuffer_DP;
  112. delete [] *m_pbitstrmShape_DP;
  113. delete m_pchShapeBitsBuffer_DP;
  114. delete m_pbitstrmShape_DP;
  115. // End Toshiba(1998-1-16)
  117. // shape
  118. delete [] m_rgiSubBlkIndx16x16;
  119. delete [] m_rgiSSubBlkIndx16x16;
  120. delete [] m_rgiSubBlkIndx18x18;
  121. delete [] m_rgiSubBlkIndx20x20;
  122. delete [] m_rgiPxlIndx12x12;
  123. delete [] m_rgiPxlIndx8x8;
  125. // B-VOP MB buffer
  126. delete m_puciDirectPredMB;
  127. delete m_puciInterpPredMB;
  128. delete m_piiDirectErrorMB; 
  129. delete m_piiInterpErrorMB; 
  130. }
  132. CVideoObjectEncoder::CVideoObjectEncoder (
  133. UInt uiVOId, 
  134. VOLMode& volmd, 
  135. VOPMode& vopmd, 
  136. UInt nFirstFrame,
  137. UInt nLastFrame,
  138. Int iSessionWidth,
  139. Int iSessionHeight,
  140. UInt uiRateControl,
  141. UInt uiBudget,
  142. ostream* pstrmTrace, // trace outstream
  143. UInt uiWarpingAccuracy, // for sprite warping
  144. Int iNumOfPnts, // for sprite warping
  145. CSiteD** rgstDest, // for sprite warping destination
  146. SptMode SpriteMode, // sprite reconstruction mode
  147. CRct rctFrame, // sprite warping source
  148.     CRct rctSpt,      // rct sprite
  149. Int iMVFileUsage,
  150. Char* pchMVFileName
  151. ) :
  152. CVideoObject (),
  153. m_nFirstFrame (nFirstFrame), m_nLastFrame (nLastFrame), 
  154. m_iBufferSize (uiBudget), m_uiRateControl (uiRateControl),
  155. m_pvopcOrig (NULL),
  156. m_rgiSubBlkIndx16x16 (NULL),
  157. m_rgiSSubBlkIndx16x16 (NULL),
  158. m_rgiSubBlkIndx18x18 (NULL),
  159. m_rgiSubBlkIndx20x20 (NULL),
  160. m_rgiPxlIndx12x12 (NULL),
  161. m_rgiPxlIndx8x8 (NULL)
  162. {
  163. m_ivolWidth = iSessionWidth;
  164. m_ivolHeight = iSessionHeight;
  166. // sprite stuff
  167. if (iNumOfPnts >= 0) {
  168. m_uiSprite = 1;
  169. m_uiWarpingAccuracy = uiWarpingAccuracy;
  170. m_iNumOfPnts = iNumOfPnts;
  171. m_rgstSrcQ = new CSiteD [m_iNumOfPnts];
  172. m_rgstDstQ = new CSiteD [m_iNumOfPnts];
  173. m_rctSpt = rctSpt;
  174. //#ifdef __LOW_LATENCY_SPRITE_
  175. m_pprgstDest = rgstDest;
  176. m_sptMode = SpriteMode ;
  177. m_rctOrg =  rctFrame;
  178. m_rctDisplayWindow = m_rctOrg; //only used for sprite, will be combined with Org later
  179. }
  180. else 
  181. m_uiSprite = 0;
  183. m_pchBitsBuffer = new Char [iSessionWidth * iSessionHeight * 2]; //we think this is enof for 4:2:0; if crushes, increase the buffer
  184. m_pbitstrmOut = new COutBitStream (m_pchBitsBuffer, 0, pstrmTrace);
  185. m_pentrencSet = new CEntropyEncoderSet (*m_pbitstrmOut);
  187. // shape cache
  188. m_pchShapeBitsBuffer = new Char [MB_SIZE * MB_SIZE * 2]; // same as above
  189. m_pbitstrmShape = new COutBitStream (m_pchShapeBitsBuffer, 0, pstrmTrace);
  190. m_pbitstrmShapeMBOut = m_pbitstrmOut; // initially the output stream (only changes for inter)
  192. m_uiVOId = uiVOId;
  193. m_volmd = volmd;
  195. // NBIT: set right clip table
  196. setClipTab();
  198. Int iClockRate = m_volmd.iClockRate;
  199. assert (iClockRate >= 1 && iClockRate < 65536);
  200. for (m_iNumBitsTimeIncr = 1; m_iNumBitsTimeIncr < NUMBITS_TIME_RESOLUTION; m_iNumBitsTimeIncr++) {
  201. if (iClockRate == 1)
  202. break;
  203. iClockRate = (iClockRate >> 1);
  204. }
  206. m_vopmd = vopmd;
  207. // decideMVInfo ();                // MV search radius now varys with GOP
  208. m_vopmd.iRoundingControlEncSwitch = m_volmd.iInitialRoundingType;
  209. if(!m_volmd.bRoundingControlDisable)
  210. m_vopmd.iRoundingControlEncSwitch ^= 0x00000001;
  211. m_vopmd.iRoundingControl = m_vopmd.iRoundingControlEncSwitch;
  212. Int iMod = iSessionWidth % MB_SIZE;
  213. Int iSessionWidthRound = (iMod > 0) ? iSessionWidth + MB_SIZE - iMod : iSessionWidth;
  214. iMod = iSessionHeight % MB_SIZE;
  215. Int iSessionHeightRound = (iMod > 0) ? iSessionHeight + MB_SIZE - iMod : iSessionHeight;
  216. // Added for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)
  217. Int iMB;
  218. Int iMBN = (iSessionWidthRound/MB_SIZE)*(iSessionHeightRound/MB_SIZE);
  219. m_pchShapeBitsBuffer_DP = new Char* [iMBN];
  220. m_pbitstrmShape_DP = new COutBitStream* [iMBN];
  221. for (iMB = 0; iMB < iMBN; iMB++) {
  222. m_pchShapeBitsBuffer_DP[iMB] = new Char [MB_SIZE * MB_SIZE * 2]; // same as above
  223. m_pbitstrmShape_DP[iMB] = new COutBitStream (m_pchShapeBitsBuffer_DP[iMB], 0, pstrmTrace);
  224. }
  225. // End Toshiba(1998-1-16:DP+RVLC)
  226. m_rctRefFrameY = CRct (
  227. -EXPANDY_REF_FRAME, -EXPANDY_REF_FRAME, 
  228. EXPANDY_REF_FRAME + iSessionWidthRound, EXPANDY_REF_FRAME + iSessionHeightRound
  229. );
  230. m_rctRefFrameUV = m_rctRefFrameY.downSampleBy2 ();
  231. m_pvopcOrig = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctRefFrameY);
  232. m_pvopcRefOrig0 = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctRefFrameY);
  233. m_pvopcRefOrig1 = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctRefFrameY);
  234. allocateVOLMembers (iSessionWidthRound, iSessionHeightRound);
  236.     //#ifdef __LOW_LATENCY_SPRITE_
  237. // identify initial sprite piece
  238. if ((m_uiSprite == 1) && (m_sptMode != BASIC_SPRITE) ){
  239. initialSpritePiece (iSessionWidthRound, iSessionHeightRound);
  240. }
  242.     CRct rctFrameZoom = m_rctRefFrameY.upSampleBy2 ();
  243. m_puciRefQZoom0 = new CU8Image (rctFrameZoom);
  245. m_puciRefQZoom1 = new CU8Image (rctFrameZoom);
  247. m_pfdct = new CFwdBlockDCT(volmd.nBits);
  249. // B-VOP MB buffer
  250. m_puciDirectPredMB = new CU8Image (CRct (0, 0, MB_SIZE, MB_SIZE));
  251. m_puciInterpPredMB = new CU8Image (CRct (0, 0, MB_SIZE, MB_SIZE));
  252. m_ppxlcDirectPredMBY = (PixelC*) m_puciDirectPredMB->pixels (); 
  253. m_ppxlcInterpPredMBY = (PixelC*) m_puciInterpPredMB->pixels (); 
  255. m_piiDirectErrorMB = new CIntImage (CRct (0, 0, MB_SIZE, MB_SIZE)); 
  256. m_piiInterpErrorMB = new CIntImage (CRct (0, 0, MB_SIZE, MB_SIZE)); 
  257. m_ppxliDirectErrorMBY = (PixelI*) m_piiDirectErrorMB->pixels (); 
  258. m_ppxliInterpErrorMBY = (PixelI*) m_piiInterpErrorMB->pixels (); 
  260. // with shape
  261. if (m_volmd.fAUsage != RECTANGLE) {
  262. m_rgiSubBlkIndx16x16 = computeShapeSubBlkIndex (4, 16);
  263. m_rgiSSubBlkIndx16x16 = computeShapeSubBlkIndex (2, 16);
  264. m_rgiSubBlkIndx18x18 = computeShapeSubBlkIndex (4, 18);
  265. m_rgiSubBlkIndx20x20 = computeShapeSubBlkIndex (4, 20);
  266. m_rgiPxlIndx12x12 = new Int [8 * 8];
  267. Int* piPxl = m_rgiPxlIndx12x12;
  268. UInt i, j;
  269. for (i = 2; i < 10; i++)
  270. for (j = 2; j < 10; j++)
  271. *piPxl++ = i * 12 + j;
  272. m_rgiPxlIndx8x8 = new Int [4 * 4];
  273. piPxl = m_rgiPxlIndx8x8;
  274. for (i = 2; i < 6; i++)
  275. for (j = 2; j < 6; j++)
  276. *piPxl++ = i * 8 + j;
  277. }
  279. m_statsVOL.reset ();
  280. codeVOHead ();
  281. codeVOLHead (iSessionWidth, iSessionHeight);//, rctSprite);
  283. // Added for error resilient mode by Toshiba(1997-11-14): Moved (1998-1-16)
  284. g_iMaxHeading = MAXHEADING_ERR;
  285. g_iMaxMiddle = MAXMIDDLE_ERR;
  286. g_iMaxTrailing = MAXTRAILING_ERR;
  288. // End Toshiba(1997-11-14)
  290. m_statsVOL.nBitsStuffing += m_pbitstrmOut->flush ();
  291. m_statRC.resetSkipMode ();
  292. m_rgdSNR = (m_volmd.fAUsage == EIGHT_BIT) ? new Double [4] : new Double [3];
  294. // some fixed variables
  295. m_iFrameWidthZoomY = m_iFrameWidthY * 2;
  296. m_iFrameWidthZoomUV = m_iFrameWidthUV * 2;
  297. m_iFrameWidthZoomYx2Minus2MB = m_iFrameWidthY * 2 * 2 - 2 * MB_SIZE;
  298. m_iFrameWidthZoomYx2Minus2Blk = m_iFrameWidthY * 2 * 2 - 2 * BLOCK_SIZE;
  300. if (m_volmd.fAUsage == RECTANGLE) {
  301. m_rctCurrVOPY = CRct (0, 0, iSessionWidthRound, iSessionHeightRound);
  302. m_pvopcOrig->setBoundRct (m_rctCurrVOPY);
  303. m_rctCurrVOPUV = m_rctCurrVOPY.downSampleBy2 ();
  305. m_rctRefVOPY0 = m_rctCurrVOPY;
  306. m_rctRefVOPY0.expand (EXPANDY_REFVOP);
  307. m_rctRefVOPUV0 = m_rctRefVOPY0.downSampleBy2 ();
  309. m_rctRefVOPY1 = m_rctRefVOPY0;
  310. m_rctRefVOPUV1 = m_rctRefVOPUV0;
  312. m_rctRefVOPZoom0 = m_rctRefVOPY0.upSampleBy2 ();
  313. m_rctRefVOPZoom1 = m_rctRefVOPY1.upSampleBy2 ();
  314. m_pvopcRefOrig0->setBoundRct (m_rctRefVOPY0);
  315. m_pvopcRefOrig1->setBoundRct (m_rctRefVOPY1);
  317. // dshu: begin of modification
  318. if ((m_uiSprite == 0) || ((m_uiSprite == 1) && (m_sptMode == BASIC_SPRITE)) )
  319. // dshu: end of modification
  321. computeVOLConstMembers (); // these VOP members are the same for all frames
  322. }
  324. m_vopmd.SpriteXmitMode = STOP ;
  325.     // tentative solution for indicating the first Sprite VOP
  326.     tentativeFirstSpriteVop = 0;
  328. // Open motion vector file if used
  329. m_pchMVFileName = pchMVFileName;
  330. m_iMVFileUsage = iMVFileUsage;
  331. if (m_iMVFileUsage != 0) { // wmay - changed from =
  332. m_fMVFile = fopen(m_pchMVFileName, (m_iMVFileUsage == 1) ? "r" : "w");
  333. assert(m_fMVFile != NULL);
  334. m_iMVLineNo = 0;
  335. }
  336. }
  338. // for back/forward shape
  339. CVideoObjectEncoder::CVideoObjectEncoder (
  340. UInt uiVOId, 
  341. VOLMode& volmd, 
  342. VOPMode& vopmd,
  343. Int iSessionWidth,
  344. Int iSessionHeight
  345. ) :
  346. CVideoObject (),
  347. m_pvopcOrig (NULL),
  348. m_rgiSubBlkIndx16x16 (NULL),
  349. m_rgiSSubBlkIndx16x16 (NULL),
  350. m_rgiSubBlkIndx18x18 (NULL),
  351. m_rgiSubBlkIndx20x20 (NULL),
  352. m_rgiPxlIndx12x12 (NULL),
  353. m_rgiPxlIndx8x8 (NULL)
  354. {
  356. // sprite stuff
  357.      m_uiSprite = 0; // sprite off
  359. m_pchBitsBuffer = NULL;
  360. m_pbitstrmOut = NULL;
  361. m_pentrencSet = NULL;
  363.         // shape cache
  364. m_pchShapeBitsBuffer = NULL;
  365. m_pbitstrmShape = NULL;
  366. m_pbitstrmShapeMBOut = NULL;
  368. m_uiVOId = uiVOId;
  369. m_volmd = volmd;
  371. m_vopmd = vopmd;
  372. // decideMVInfo ();
  373. m_vopmd.iRoundingControl = 0;
  374. m_vopmd.iRoundingControlEncSwitch = 0;
  375. Int iMod = iSessionWidth % MB_SIZE;
  376. Int iSessionWidthRound = (iMod > 0) ? iSessionWidth + MB_SIZE - iMod : iSessionWidth;
  377. iMod = iSessionHeight % MB_SIZE;
  378. Int iSessionHeightRound = (iMod > 0) ? iSessionHeight + MB_SIZE - iMod : iSessionHeight;
  379. m_rctRefFrameY = CRct (
  380. -EXPANDY_REF_FRAME, -EXPANDY_REF_FRAME, 
  381. EXPANDY_REF_FRAME + iSessionWidthRound, EXPANDY_REF_FRAME + iSessionHeightRound
  382. );
  383. m_rctRefFrameUV = m_rctRefFrameY.downSampleBy2 ();
  384. m_pvopcOrig = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctRefFrameY);
  385. m_pvopcRefOrig0 = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctRefFrameY);
  386. m_pvopcRefOrig1 = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctRefFrameY);
  387. allocateVOLMembers (iSessionWidth, iSessionHeight);
  389. CRct rctFrameZoom = m_rctRefFrameY.upSampleBy2 ();
  390. m_puciRefQZoom0 = new CU8Image (rctFrameZoom);
  392. m_puciRefQZoom1 = new CU8Image (rctFrameZoom);
  394. m_pfdct = new CFwdBlockDCT;
  396. // B-VOP MB buffer
  397. m_puciDirectPredMB = new CU8Image (CRct (0, 0, MB_SIZE, MB_SIZE));
  398. m_puciInterpPredMB = new CU8Image (CRct (0, 0, MB_SIZE, MB_SIZE));
  399. m_ppxlcDirectPredMBY = (PixelC*) m_puciDirectPredMB->pixels (); 
  400. m_ppxlcInterpPredMBY = (PixelC*) m_puciInterpPredMB->pixels (); 
  402. m_piiDirectErrorMB = new CIntImage (CRct (0, 0, MB_SIZE, MB_SIZE)); 
  403. m_piiInterpErrorMB = new CIntImage (CRct (0, 0, MB_SIZE, MB_SIZE)); 
  404. m_ppxliDirectErrorMBY = (PixelI*) m_piiDirectErrorMB->pixels (); 
  405. m_ppxliInterpErrorMBY = (PixelI*) m_piiInterpErrorMB->pixels (); 
  407. // with shape
  408. if (m_volmd.fAUsage != RECTANGLE) {
  409. m_rgiSubBlkIndx16x16 = computeShapeSubBlkIndex (4, 16);
  410. m_rgiSSubBlkIndx16x16 = computeShapeSubBlkIndex (2, 16);
  411. m_rgiSubBlkIndx18x18 = computeShapeSubBlkIndex (4, 18);
  412. m_rgiSubBlkIndx20x20 = computeShapeSubBlkIndex (4, 20);
  413. m_rgiPxlIndx12x12 = new Int [8 * 8];
  414. Int* piPxl = m_rgiPxlIndx12x12;
  415. UInt i, j;
  416. for (i = 2; i < 10; i++)
  417. for (j = 2; j < 10; j++)
  418. *piPxl++ = i * 12 + j;
  419. m_rgiPxlIndx8x8 = new Int [4 * 4];
  420. piPxl = m_rgiPxlIndx8x8;
  421. for (i = 2; i < 6; i++)
  422. for (j = 2; j < 6; j++)
  423. *piPxl++ = i * 8 + j;
  424. }
  426. m_statRC.resetSkipMode ();
  427. m_rgdSNR = (m_volmd.fAUsage == EIGHT_BIT) ? new Double [4] : new Double [3];
  429. // some fixed variables
  430. m_iFrameWidthZoomY = m_iFrameWidthY * 2;
  431. m_iFrameWidthZoomUV = m_iFrameWidthUV * 2;
  432. m_iFrameWidthZoomYx2Minus2MB = m_iFrameWidthY * 2 * 2 - 2 * MB_SIZE;
  433. m_iFrameWidthZoomYx2Minus2Blk = m_iFrameWidthY * 2 * 2 - 2 * BLOCK_SIZE;
  435. if (m_volmd.fAUsage == RECTANGLE) {
  436. m_rctCurrVOPY = CRct (0, 0, iSessionWidthRound, iSessionHeightRound);
  437. m_pvopcOrig->setBoundRct (m_rctCurrVOPY);
  438. m_rctCurrVOPUV = m_rctCurrVOPY.downSampleBy2 ();
  440. m_rctRefVOPY0 = m_rctCurrVOPY;
  441. m_rctRefVOPY0.expand (EXPANDY_REFVOP);
  442. m_rctRefVOPUV0 = m_rctRefVOPY0.downSampleBy2 ();
  444. m_rctRefVOPY1 = m_rctRefVOPY0;
  445. m_rctRefVOPUV1 = m_rctRefVOPUV0;
  447. m_rctRefVOPZoom0 = m_rctRefVOPY0.upSampleBy2 ();
  448. m_pvopcRefOrig0->setBoundRct (m_rctRefVOPY0);
  449. m_pvopcRefOrig1->setBoundRct (m_rctRefVOPY1);
  450. computeVOLConstMembers (); // these VOP members are the same for all frames
  451. }
  452. }
  454. Bool CVideoObjectEncoder::skipTest(Time t,VOPpredType vopPredType)
  455. {
  456. if (m_uiRateControl==RC_MPEG4) {
  457. if (!m_statRC.firstFrame ()) {// test whether we should skip this frame
  458. if (m_statRC.skipThisFrame ())
  459. return TRUE;
  460. } 
  461. else
  462. m_statRC.resetFirstFrame ();
  463. }
  464. return FALSE;
  465. }
  467. Void CVideoObjectEncoder::encode (
  468. Bool bVOPVisible, 
  469. Time t,
  470. VOPpredType vopPredType,
  471. const CVOPU8YUVBA* pvopfRefBaseLayer)
  472. {
  473. m_t = t;
  474. m_vopmd.vopPredType = vopPredType;
  475.     m_statsVOP.reset ();
  477. Bool bTemporalScalability = m_volmd.bTemporalScalability; // added by Sharp (98/2/10)
  478. Bool bPrevRefVopWasCoded = m_bCodedFutureRef;
  480. //__LOW_LATENCY_SPRITE_
  481. if (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE && m_vopmd.SpriteXmitMode != STOP) {
  482. setRefStartingPointers (); // need to compute the starting pointers of the refVOP's (corresponding to the current Rct)
  483. computeVOPMembers ();
  484. m_iNumSptMB = 0;
  485. encodeVOP ();
  486. }
  487. else {
  488.     if (m_uiSprite == 1 && m_t>=0)
  489.     m_vopmd.vopPredType = SPRITE;
  491.     m_pbitstrmOut->reset ();
  492.     cout << "nVOP " << m_uiVOId << "n";
  493.     cout << "tVOL " << (int)m_volmd.volType << "n"; // added by Sharp (98/2/10)
  495. if(m_vopmd.vopPredType==IVOP || m_vopmd.vopPredType==PVOP)
  496. m_bCodedFutureRef = bVOPVisible; // flag used by bvop prediction
  498.     if(!bVOPVisible)
  499.     {
  500. #ifdef __TRACE_AND_STATS_
  501.     m_pbitstrmOut -> trace (m_t, "VOP_Time");
  502. #endif // __TRACE_AND_STATS_
  503.     codeNonCodedVOPHead ();
  504.     cout << "tTime..." << m_t << " (" << m_t/m_volmd.dFrameHz << " sec)" 
  505. << "ntNot coded.nn";
  506.     cout.flush ();
  507.     m_statsVOP.nBitsStuffing += m_pbitstrmOut->flush ();
  508. #ifdef __TRACE_AND_STATS_
  509.     m_statsVOP.dSNRY = m_statsVOP.dSNRU = m_statsVOP.dSNRV = 0;
  510.     m_statsVOP.print (TRUE);
  511.     m_statsVOL += m_statsVOP;
  512. #endif // __TRACE_AND_STATS_
  513.     }
  515. if(bPrevRefVopWasCoded) // only swap references if previous vop was coded
  516. {
  517. if (m_volmd.volType == BASE_LAYER)
  518. updateAllRefVOPs (); // update all reconstructed VOP's
  519. else if (!bTemporalScalability) { // modified by Sharp (98/2/10)
  520. if(m_volmd.volType == ENHN_LAYER && m_vopmd.vopPredType == PVOP)
  521. m_vopmd.iRefSelectCode = 3;
  522. else if(m_volmd.volType == ENHN_LAYER && m_vopmd.vopPredType == BVOP)
  523. m_vopmd.iRefSelectCode = 0;
  524. updateAllRefVOPs (pvopfRefBaseLayer); // for spatial scalability
  525. }
  527.      if (m_volmd.bOriginalForME) {
  528.      if (m_vopmd.vopPredType == PVOP || 
  529.      (m_volmd.volType == ENHN_LAYER && m_vopmd.vopPredType == BVOP && m_vopmd.iRefSelectCode == 0))
  530.      swapVOPU8Pointers (m_pvopcRefOrig0, m_pvopcRefOrig1);
  531.      }
  532. }
  534.     if (m_vopmd.vopPredType != BVOP) {
  535. if(bPrevRefVopWasCoded)
  536. {
  537. // swap zoomed ref images
  538. CU8Image *puciTmp = m_puciRefQZoom0;
  539. m_puciRefQZoom0 = m_puciRefQZoom1;
  540. m_puciRefQZoom1 = puciTmp;
  541. m_rctRefVOPZoom0 = m_rctRefVOPZoom1;
  542. }
  543.     m_vopmd.iSearchRangeBackward = 0;
  544. if(bPrevRefVopWasCoded)
  545. if ( !bTemporalScalability || m_volmd.volType == BASE_LAYER ) // added by Sharp (99/1/28)
  546. m_tPastRef = m_tFutureRef;
  547.     m_tDistanceBetwIPVOP = (m_t - m_tPastRef) / m_volmd.iTemporalRate;
  548.             m_tFutureRef = m_t;
  549.     m_iBCount = 0;
  550. if(m_vopmd.vopPredType == PVOP &&
  551. m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode ==3)
  552. m_tPastRef = m_t;
  553.     if (m_vopmd.vopPredType == PVOP) {
  554. // swap rounding control 0 <-> 1 every coded PVOP
  555. if( bPrevRefVopWasCoded && !m_volmd.bRoundingControlDisable)
  556. m_vopmd.iRoundingControlEncSwitch ^= 0x00000001;
  557. m_vopmd.iRoundingControl = m_vopmd.iRoundingControlEncSwitch;
  559. m_rctRefVOPZoom0 = m_rctRefVOPY0.upSampleBy2 ();
  560. biInterpolateY (m_pvopcRefQ0, m_rctRefVOPY0, m_puciRefQZoom0,
  561. m_rctRefVOPZoom0, m_vopmd.iRoundingControl);
  563.     m_vopmd.iSearchRangeForward = 
  564. checkrange (m_volmd.iMVRadiusPerFrameAwayFromRef * (m_t - m_tPastRef) / m_volmd.iTemporalRate, 1, 1024);
  565.     } else
  566.     m_vopmd.iSearchRangeForward = 0;
  567.     } else {
  568. // BVOP, set rounding control to zero
  569. m_vopmd.iRoundingControl = 0;
  570. if (m_volmd.volType==ENHN_LAYER && m_vopmd.iRefSelectCode==0){
  571. m_tPastRef = m_tFutureRef;
  572. m_tFutureRef = m_t;
  573. }
  574. m_iBCount++;
  575. if (m_iBCount == 1 || (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode==0))
  576. {
  577. if(bPrevRefVopWasCoded)
  578. {
  579. m_rctRefVOPZoom1 = m_rctRefVOPY1.upSampleBy2 ();
  580. biInterpolateY (m_pvopcRefQ1,m_rctRefVOPY1,
  581. m_puciRefQZoom1, m_rctRefVOPZoom1, 0);
  582. }
  583. if (m_vopmd.iRoundingControlEncSwitch==1 // modified by Sharp (98/2/10) && // Need to re-compute because iRoundingControl was 1
  584. || (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 0) || bTemporalScalability) 
  585. {
  586. m_rctRefVOPZoom0 = m_rctRefVOPY0.upSampleBy2 ();
  587. biInterpolateY (m_pvopcRefQ0, m_rctRefVOPY0, m_puciRefQZoom0, m_rctRefVOPZoom0, 0);
  588. }
  589. }
  590. //m_vopmd.iSearchRangeForward = 15;
  591. //m_vopmd.iSearchRangeBackward = 15;
  592. m_vopmd.iSearchRangeForward = 
  593. checkrange ((m_t - m_tPastRef) * m_volmd.iMVRadiusPerFrameAwayFromRef / m_volmd.iTemporalRate, 1, 1024);
  594. m_vopmd.iSearchRangeBackward = 
  595. checkrange ((m_tFutureRef - m_t) * m_volmd.iMVRadiusPerFrameAwayFromRef / m_volmd.iTemporalRate, 1, 1024);
  596.     }
  597.     decideMVInfo();
  598.     m_statsVOP.nVOPs = 1;
  599.      if (m_volmd.fAUsage != RECTANGLE)
  600.      resetBYPlane ();
  602. if(!bVOPVisible)
  603. {
  604. if (m_vopmd.vopPredType != BVOP
  605. && m_volmd.fAUsage != RECTANGLE && bPrevRefVopWasCoded)
  606. {
  607. // give the current object a dummy size
  608. m_iNumMBX = m_iNumMBY = m_iNumMB = 1;
  609. saveShapeMode(); // save the previous reference vop shape mode
  610. }
  611. return;   // return if not coded
  612. }
  614.      // prepare for the current original data
  615.      // extend the currVOP size to multiples of MBSize, will put zero on extended pixels
  616.      if (m_volmd.fAUsage != RECTANGLE) {
  617.      if (m_uiSprite != 1) { // add by cgu to deal with vop-mc-left-top 12/5
  618.      findTightBoundingBox ();
  619.      findBestBoundingBox ();
  620. } else if (m_sptMode == BASIC_SPRITE) {
  621. Int iSpriteWidth =  m_rctSpt.right - m_rctSpt.left;
  622. if(iSpriteWidth%16)
  623. iSpriteWidth += 16 - (iSpriteWidth%16);
  624. Int iSpriteHeight =  m_rctSpt.bottom - m_rctSpt.top;
  625. if(iSpriteHeight%16)
  626. iSpriteHeight += 16 - (iSpriteHeight%16);
  627. m_pvopcOrig->setBoundRct (CRct (0, 0, iSpriteWidth, iSpriteHeight));
  628. }
  629. m_rctCurrVOPY = m_pvopcOrig->whereBoundY ();
  630. m_rctCurrVOPUV = m_pvopcOrig->whereBoundUV ();
  631. setRefStartingPointers (); // need to compute the starting pointers of the refVOP's (corresponding to the current Rct)
  632. computeVOPMembers ();
  633. // Modified for error resilient mode by Toshiba(1998-1-16)
  634. if (m_volmd.bVPBitTh < 0 || m_volmd.bShapeOnly==TRUE) {
  635. m_vopmd.bShapeCodingType = (m_vopmd.vopPredType == IVOP) ? 0 : 1;
  636. } else {
  637. m_vopmd.bShapeCodingType = (m_volmd.iBinaryAlphaRR<0)?1:((m_t % m_volmd.iBinaryAlphaRR)==0) ? 0 : 1;
  638. }
  639. // printf("vop_shape_coding_type=%dn",m_vopmd.bShapeCodingType);
  640. // End Toshiba(1998-1-16)
  641. }
  643. #ifdef __TRACE_AND_STATS_
  644.     m_pbitstrmOut -> trace (m_t, "VOP_Time");
  645. #endif // __TRACE_AND_STATS_
  646.     codeVOPHead ();
  647.     cout << "t" << "Time..." << m_t << " (" << m_t/m_volmd.dFrameHz << " sec)";
  648.     switch(vopPredType)
  649.     {
  650.     case IVOP:
  651.     cout << "tIVOP";
  652.      break;
  653.     case PVOP:
  654.      cout << "tPVOP (reference: t=" << m_tPastRef <<")";
  655.      break;
  656.     case BVOP:
  657.      cout << "tBVOP (past ref: t=" << m_tPastRef
  658.      << ", future ref: t=" << m_tFutureRef <<")";
  659.      break;
  660.     default:
  661.      break;
  662.     }
  663.     cout << "n";
  664.     cout.flush ();
  666.     encodeVOP ();
  668.     m_statsVOP.nBitsStuffing += m_pbitstrmOut->flush ();
  669. }
  670. #ifdef __TRACE_AND_STATS_
  671. if (m_vopmd.vopPredType == BVOP)
  672. computeSNRs (m_pvopcCurrQ);
  673. else
  674. computeSNRs (m_pvopcRefQ1);
  675. m_statsVOP.dSNRY = m_rgdSNR [0];
  676. m_statsVOP.dSNRU = m_rgdSNR [1];
  677. m_statsVOP.dSNRV = m_rgdSNR [2];
  678. if (m_volmd.fAUsage == EIGHT_BIT)
  679. m_statsVOP.dSNRA = m_rgdSNR [3];
  680. m_statsVOP.print (TRUE);
  681. m_statsVOL += m_statsVOP;
  682. #endif // __TRACE_AND_STATS_
  684. // rate control
  685. if (m_uiRateControl==RC_MPEG4) {
  686. assert (m_volmd.volType == BASE_LAYER); //don't no know to do RC for scalability yet
  687. #ifndef __TRACE_AND_STATS_
  688. cerr << "Compile flag __TRACE_AND_STATS_ required for stats for rate control." << endl;
  689. exit(1);
  690. #endif // __TRACE_AND_STATS_
  691. if (m_vopmd.vopPredType == IVOP) { // !!!! check whether CRct has been expanded
  692. Double dMad = 
  693. (m_pvopcOrig->getPlane (Y_PLANE)->sumAbs (m_rctCurrVOPY)) / 
  694. (Double) (m_rctCurrVOPY.area ());
  695. m_statRC.reset (
  696. m_nFirstFrame, 
  697. m_nLastFrame, 
  698. m_volmd.iTemporalRate, 
  699. m_iBufferSize, 
  700. dMad, 
  701. m_statsVOL.nBitsTotal,
  702. m_volmd.dFrameHz
  703. );
  704. }
  705. else if (m_vopmd.vopPredType == PVOP)
  706. m_statRC.updateRCModel (m_statsVOP.total (), m_statsVOP.head ());
  707. }
  709. // store the direct mode data (by swaping pointers)
  710. if (m_vopmd.vopPredType != BVOP) {
  711. if(m_volmd.fAUsage != RECTANGLE && bPrevRefVopWasCoded)
  712. saveShapeMode();
  713. CMBMode* pmbmdTmp = m_rgmbmd;
  714. m_rgmbmd = m_rgmbmdRef;
  715. m_rgmbmdRef = pmbmdTmp;
  716. CMotionVector* pmvTmp = m_rgmv;
  717. m_rgmv = m_rgmvRef;
  718. m_rgmvRef = pmvTmp;
  719. //wchen: should not only for pvop
  720. //if (m_vopmd.vopPredType == PVOP) 
  721. m_rgmvBackward = m_rgmv + BVOP_MV_PER_REF_PER_MB * m_iSessNumMB;
  723. #if 0 // Debugging .. use the same anchor VOPs as reference implementation
  724. static FILE *pfRefPicInputFile = NULL;
  725. if (pfRefPicInputFile == NULL) {
  726. pfRefPicInputFile = fopen("ref.yuv", "rb");
  727. assert(pfRefPicInputFile != NULL);
  728. }
  729. Int iLeadingPixels = m_t * m_rctPrevNoExpandY.area ();
  730. fseek (pfRefPicInputFile, iLeadingPixels + iLeadingPixels / 2, SEEK_SET); //4:2:0
  731. static Int iYDataHeight = m_rctPrevNoExpandY.height ();
  732. static Int iUVDataHeight = m_rctPrevNoExpandY.height () / 2;
  733. static Int iYFrmWidth = m_pvopcRefQ1->whereY ().width;
  734. static Int iUvFrmWidth = m_pvopcRefQ1->whereUV ().width;
  735. static Int nSkipYPixel = iYFrmWidth * EXPANDY_REF_FRAME + EXPANDY_REF_FRAME;
  736. static Int nSkipUvPixel = iUvFrmWidth * EXPANDUV_REF_FRAME + EXPANDUV_REF_FRAME;
  737. PixelC* ppxlcY = (PixelC*) m_pvopcRefQ1->pixelsY () + nSkipYPixel;
  738. PixelC* ppxlcU = (PixelC*) m_pvopcRefQ1->pixelsU () + nSkipUvPixel;
  739. PixelC* ppxlcV = (PixelC*) m_pvopcRefQ1->pixelsV () + nSkipUvPixel;
  740. for (CoordI y = 0; y < iYDataHeight; y++) {
  741. Int size = (Int) fread (ppxlcY, sizeof (U8), m_rctPrevNoExpandY.width, pfRefPicInputFile);
  742. if (size == 0)
  743. fprintf (stderr, "Unexpected end of filen");
  744. ppxlcY += iYFrmWidth;
  745. }
  746. for (y = 0; y < iUVDataHeight; y++) {
  747. Int size = (Int) fread (ppxlcU, sizeof (U8), m_rctPrevNoExpandY.width / 2, pfRefPicInputFile);
  748. if (size == 0)
  749. fprintf (stderr, "Unexpected end of filen");
  750. ppxlcU += iUvFrmWidth;
  751. }
  753. for (y = 0; y < iUVDataHeight; y++) {
  754. Int size = (Int) fread (ppxlcV, sizeof (U8), m_rctPrevNoExpandY.width / 2, pfRefPicInputFile);
  755. if (size == 0)
  756. fprintf (stderr, "Unexpected end of filen");
  757. ppxlcV += iUvFrmWidth;
  758. }
  759. #endif
  760. }
  762. if (m_volmd.fAUsage != RECTANGLE) {
  763. if (m_vopmd.vopPredType != BVOP) {
  764. m_iNumMBRef = m_iNumMB;
  765. m_iNumMBXRef = m_iNumMBX;
  766. m_iNumMBYRef = m_iNumMBY;
  767. m_iOffsetForPadY = m_rctRefFrameY.offset (m_rctCurrVOPY.left, m_rctCurrVOPY.top);
  768. m_iOffsetForPadUV = m_rctRefFrameUV.offset (m_rctCurrVOPUV.left, m_rctCurrVOPUV.top);
  769. m_rctPrevNoExpandY = m_rctCurrVOPY;
  770. m_rctPrevNoExpandUV = m_rctCurrVOPUV;
  772. m_rctRefVOPY1 = m_rctCurrVOPY;
  773. m_rctRefVOPY1.expand (EXPANDY_REFVOP);
  774. m_rctRefVOPUV1 = m_rctCurrVOPUV;
  775. m_rctRefVOPUV1.expand (EXPANDUV_REFVOP);
  776. m_pvopcRefQ1->setBoundRct (m_rctRefVOPY1);
  777. }
  779. // begin:  added by by Sharp (98/2/10)
  780. if ( bTemporalScalability && m_vopmd.vopPredType == BVOP ) {
  781. m_iBVOPOffsetForPadY = m_rctRefFrameY.offset (m_rctCurrVOPY.left, m_rctCurrVOPY.top);
  782. m_iBVOPOffsetForPadUV = m_rctRefFrameUV.offset (m_rctCurrVOPUV.left, m_rctCurrVOPUV.top);
  783. m_rctBVOPPrevNoExpandY = m_rctCurrVOPY;
  784. m_rctBVOPPrevNoExpandUV = m_rctCurrVOPUV;
  786. m_rctBVOPRefVOPY1 = m_rctCurrVOPY;
  787. m_rctBVOPRefVOPY1.expand (EXPANDY_REFVOP);
  788. m_rctBVOPRefVOPUV1 = m_rctCurrVOPUV;
  789. m_rctBVOPRefVOPUV1.expand (EXPANDUV_REFVOP);
  790. }
  791. // end: added by Sharp (98/2/10)
  793. //this is ac/dc pred stuff; clean the memory
  794. Int nBlk = (m_volmd.fAUsage == EIGHT_BIT) ? 10 : 6;
  795. delete [] m_rgblkmCurrMB;
  796. for (Int iMB = 0; iMB < m_iNumMBX; iMB++) {
  797. for (Int iBlk = 0; iBlk < nBlk; iBlk++) {
  798. delete [] (m_rgpmbmAbove [iMB]->rgblkm) [iBlk];
  799. delete [] (m_rgpmbmCurr  [iMB]->rgblkm) [iBlk];
  800. }
  801. delete [] m_rgpmbmAbove [iMB]->rgblkm;
  802. delete m_rgpmbmAbove [iMB];
  803. delete [] m_rgpmbmCurr [iMB]->rgblkm;
  804. delete m_rgpmbmCurr [iMB];
  805. }
  806. delete [] m_rgpmbmAbove;
  807. delete [] m_rgpmbmCurr;
  808. }
  810. // begin: added by Sharp (98/2/10)
  811. if ( bTemporalScalability && m_volmd.fAUsage == RECTANGLE ) {
  812. m_iBVOPOffsetForPadY = m_iOffsetForPadY;
  813. m_iBVOPOffsetForPadUV = m_iOffsetForPadUV;
  814. m_rctBVOPPrevNoExpandY = m_rctPrevNoExpandY;
  815. m_rctBVOPPrevNoExpandUV = m_rctPrevNoExpandUV;
  817. m_rctBVOPRefVOPY1 = m_rctRefVOPY1;
  818. m_rctBVOPRefVOPUV1 = m_rctRefVOPUV1;
  819. }
  820. // end: added by Sharp (98/2/10)
  822. // __LOW_LATENCY_SPRITE_
  823. if (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE && m_vopmd.SpriteXmitMode != STOP)
  824. return;
  826.     if (m_vopmd.vopPredType != BVOP || m_volmd.volType == ENHN_LAYER) {
  827. repeatPadYOrA ((PixelC*) m_pvopcRefQ1->pixelsY () + m_iOffsetForPadY, m_pvopcRefQ1);
  828. repeatPadUV (m_pvopcRefQ1);
  829. if (m_volmd.fAUsage != RECTANGLE)       {
  830. if (m_volmd.fAUsage == EIGHT_BIT)
  831. repeatPadYOrA ((PixelC*) m_pvopcRefQ1->pixelsA () + m_iOffsetForPadY, m_pvopcRefQ1);
  832. }
  833. }
  835. if( m_volmd.volType == ENHN_LAYER && 
  836. m_vopmd.vopPredType == BVOP &&
  837. m_vopmd.iRefSelectCode == 0){
  838. repeatPadYOrA ((PixelC*) m_pvopcCurrQ->pixelsY () + m_iOffsetForPadY, m_pvopcCurrQ);
  839. repeatPadUV (m_pvopcCurrQ);
  840. }
  842. if (m_volmd.bOriginalForME) {
  843. if (m_vopmd.vopPredType == IVOP || m_vopmd.vopPredType == PVOP || 
  844.     (m_volmd.volType == ENHN_LAYER && m_vopmd.vopPredType == BVOP && m_vopmd.iRefSelectCode == 0))
  845. updateAllOrigRefVOPs (); // update all original reference (MotionEsti) VOP's
  846. }
  847. }
  849. Void CVideoObjectEncoder::codeVOHead ()
  850. {
  851. m_pbitstrmOut -> putBits (START_CODE_PREFIX, NUMBITS_START_CODE_PREFIX, "VOSH_Start_Code");
  852. m_pbitstrmOut -> putBits (SESSION_START_CODE, 8, "VOSH_Start_Code");
  853. // Just signal Advanced Simple Profile @ L2 for now
  854. m_pbitstrmOut -> putBits (0xF3, 8, "VOSH_Start_Code");
  856. m_pbitstrmOut -> putBits (START_CODE_PREFIX, NUMBITS_START_CODE_PREFIX, "VO_Start_Code");
  857. m_pbitstrmOut -> putBits (VISUAL_OBJ_START_CODE, 8, "Visual_Obj_Start_Code");
  858. m_pbitstrmOut -> putBits (0x09, 8, "Visual_Object_Id");
  860. m_pbitstrmOut -> putBits (START_CODE_PREFIX, NUMBITS_START_CODE_PREFIX, "VO_Start_Code");
  861. m_pbitstrmOut -> putBits (VO_START_CODE, NUMBITS_VO_START_CODE, "VO_Start_Code"); //plus 3 bits
  862. m_pbitstrmOut -> putBits (m_uiVOId, NUMBITS_VO_ID, "VO_Id");
  863. UInt uiNumBits = NUMBITS_START_CODE_PREFIX + NUMBITS_VO_START_CODE + NUMBITS_VO_ID;;
  864. m_statsVOL.nBitsHead += uiNumBits;
  865. cout << "VO Overhead" << "tt" << uiNumBits << "nn";
  866. cout.flush ();
  867. }
  869. Void CVideoObjectEncoder::codeVOLHead (Int iSessionWidth, Int iSessionHeight)
  870. {
  871. m_pbitstrmOut -> putBits (START_CODE_PREFIX, NUMBITS_START_CODE_PREFIX, "VOL_Start_Code");
  872. m_pbitstrmOut -> putBits (VOL_START_CODE, NUMBITS_VOL_START_CODE, "VOL_Start_Code"); //plus 4 bits
  873. m_pbitstrmOut -> putBits ((Int) (m_volmd.volType == ENHN_LAYER), NUMBITS_VOL_ID, "VOL_Id"); // by katata
  874. m_statsVOL.nBitsHead+=NUMBITS_START_CODE_PREFIX+NUMBITS_VOL_START_CODE+NUMBITS_VOL_ID;
  876. // Begin: modified by Hughes   4/9/98   per clause 2.1.7. in N2171 document
  877. m_pbitstrmOut -> putBits ((Int) 0, 1, "VOL_Random_Access"); //isn't this a system level flg?
  878. m_statsVOL.nBitsHead++;
  879. // End: modified by Hughes   4/9/98
  881. m_pbitstrmOut -> putBits ((Int) 4, 8, "VOL_Type_Indicator"); // Set to indicate MAIN profile.
  882. m_statsVOL.nBitsHead+=8;
  883. m_pbitstrmOut -> putBits ((Int) 0, 1, "VOL_Is_Object_Layer_Identifier"); //useless flag for now
  884. m_statsVOL.nBitsHead++;
  885. m_pbitstrmOut -> putBits ((Int) 1, 4, "aspect_ratio_info"); // square pix
  886. m_statsVOL.nBitsHead+=4;
  888. m_pbitstrmOut -> putBits (m_volmd.uiVolControlParameters, 1, "VOL_Control_Parameters"); //useless flag for now
  889. m_statsVOL.nBitsHead++;
  891. if(m_volmd.uiVolControlParameters)
  892. {
  893. m_pbitstrmOut -> putBits (m_volmd.uiChromaFormat, 2, "Chroma_Format");
  894. m_pbitstrmOut -> putBits (m_volmd.uiLowDelay, 1, "Low_Delay");
  895. m_pbitstrmOut -> putBits (m_volmd.uiVBVParams, 1, "VBV_Params");
  896. m_statsVOL.nBitsHead += 2 + 1 + 1;
  898. if(m_volmd.uiVBVParams)
  899. {
  900. UInt uiFirstHalfBitRate = (m_volmd.uiBitRate >> 15);
  901. UInt uiLatterHalfBitRate = (m_volmd.uiBitRate & 0x7fff);
  902. m_pbitstrmOut -> putBits (uiFirstHalfBitRate, 15, "FirstHalf_BitRate");
  903. m_pbitstrmOut -> putBits (1, 1, "Marker");
  904. m_pbitstrmOut -> putBits (uiLatterHalfBitRate, 15, "LatterHalf_BitRate");
  905. m_pbitstrmOut -> putBits (1, 1, "Marker");
  907. UInt uiFirstHalfVbvBufferSize = (m_volmd.uiVbvBufferSize >> 3);
  908. UInt uiLatterHalfVbvBufferSize = (m_volmd.uiVbvBufferSize & 7);
  909. m_pbitstrmOut -> putBits (uiFirstHalfVbvBufferSize, 15, "FirstHalf_VbvBufferSize");
  910. m_pbitstrmOut -> putBits (1, 1, "Marker");
  911. m_pbitstrmOut -> putBits (uiLatterHalfVbvBufferSize, 3, "LatterHalf_VbvBufferSize");
  913. UInt uiFirstHalfVbvBufferOccupany = (m_volmd.uiVbvBufferOccupany >> 15);
  914. UInt uiLatterHalfVbvBufferOccupany = (m_volmd.uiVbvBufferOccupany & 0x7fff);
  915. m_pbitstrmOut -> putBits (uiFirstHalfVbvBufferOccupany, 11, "FirstHalf_VbvBufferOccupany");
  916. m_pbitstrmOut -> putBits (1, 1, "Marker");
  917. m_pbitstrmOut -> putBits (uiLatterHalfVbvBufferOccupany, 15, "LatterHalf_VbvBufferOccupany");
  918. m_pbitstrmOut -> putBits (1, 1, "Marker");
  920. m_statsVOL.nBitsHead += 15 + 15 + 15 + 3 + 11 + 15;
  921. m_statsVOL.nBitsStuffing += 5;
  922. }
  924. }
  926. if(m_volmd.bShapeOnly==TRUE)
  927. {
  928. m_pbitstrmOut -> putBits ((Int) 2, NUMBITS_VOL_SHAPE, "VOL_Shape_Type");
  929. m_pbitstrmOut -> putBits (1, 1, "Marker");
  930. m_pbitstrmOut -> putBits (m_volmd.iClockRate, NUMBITS_TIME_RESOLUTION, "VOL_Time_Increment_Resolution"); 
  931. m_pbitstrmOut -> putBits (1, 1, "Marker");
  932. m_pbitstrmOut -> putBits (0, 1, "VOL_Fixed_Vop_Rate");
  933. m_pbitstrmOut -> putBits (0, 1, "VOL_resync_marker_disable");
  934. m_statsVOL.nBitsHead += NUMBITS_VOL_SHAPE + NUMBITS_TIME_RESOLUTION + 2;
  935. m_statsVOL.nBitsStuffing +=2;
  936. cout << "VOL Overhead" << "tt" << m_statsVOL.nBitsHead << "nn";
  937. cout.flush ();
  938. return;
  939. }
  940. else
  941. {
  942. Int iAUsage = (Int)m_volmd.fAUsage;
  943. if(iAUsage==2) // CD: 0 = rect, 1 = binary, 2 = shape only, 3 = grey alpha
  944. iAUsage = 3;
  945. m_pbitstrmOut -> putBits (iAUsage, NUMBITS_VOL_SHAPE, "VOL_Shape_Type");
  946. m_pbitstrmOut -> putBits (1, 1, "Marker");
  947. m_pbitstrmOut -> putBits (m_volmd.iClockRate, NUMBITS_TIME_RESOLUTION, "VOL_Time_Increment_Resolution"); 
  948. m_pbitstrmOut -> putBits (1, 1, "Marker");
  949. m_pbitstrmOut -> putBits (0, 1, "VOL_Fixed_Vop_Rate");
  950. m_statsVOL.nBitsHead += NUMBITS_VOL_SHAPE + NUMBITS_TIME_RESOLUTION + 1;
  951. if (m_volmd.fAUsage == RECTANGLE) {
  952. m_pbitstrmOut -> putBits (MARKER_BIT, 1, "Marker_Bit");
  953. m_statsVOL.nBitsStuffing ++;
  954. m_pbitstrmOut -> putBits (iSessionWidth, NUMBITS_VOP_WIDTH, "VOL_Width"); 
  955. m_pbitstrmOut -> putBits (MARKER_BIT, 1, "Marker_Bit");
  956. m_statsVOL.nBitsStuffing ++;
  957. m_pbitstrmOut -> putBits (iSessionHeight, NUMBITS_VOP_HEIGHT, "VOL_Height"); 
  958. m_pbitstrmOut -> putBits (MARKER_BIT, 1, "Marker_Bit");
  959. m_statsVOL.nBitsStuffing ++;
  960. m_statsVOL.nBitsHead += NUMBITS_VOP_WIDTH + NUMBITS_VOP_HEIGHT;
  961. }
  962. }
  963. m_pbitstrmOut -> putBits (m_vopmd.bInterlace, (UInt) 1, "VOL_interlace");
  964. m_statsVOL.nBitsHead++;
  965. m_pbitstrmOut -> putBits (m_volmd.bAdvPredDisable, (UInt) 1, "VOL_OBMC_Disable");
  966. m_statsVOL.nBitsHead++;
  968. // code sprite info
  969. m_pbitstrmOut -> putBits (m_uiSprite, NUMBITS_SPRITE_USAGE, "VOL_Sprite_Usage");
  970. m_statsVOL.nBitsHead += NUMBITS_SPRITE_USAGE;
  971. if (m_uiSprite == 1) {
  972. m_pbitstrmOut -> putBits (m_rctSpt.width, NUMBITS_SPRITE_HDIM, "SPRT_hdim");
  973. m_statsVOL.nBitsHead += NUMBITS_SPRITE_HDIM; 
  974. m_pbitstrmOut -> putBits (MARKER_BIT, 1, "Marker_Bit");
  975. m_statsVOL.nBitsStuffing ++;
  976. m_pbitstrmOut -> putBits (m_rctSpt.height (), NUMBITS_SPRITE_VDIM, "SPRT_vdim");
  977. m_statsVOL.nBitsHead += NUMBITS_SPRITE_VDIM;
  978. m_pbitstrmOut -> putBits (MARKER_BIT, 1, "Marker_Bit");
  979. m_statsVOL.nBitsStuffing ++;
  980. if (m_rctSpt.left >= 0) {
  981. m_pbitstrmOut -> putBits (m_rctSpt.left, NUMBITS_SPRITE_LEFT_EDGE, "SPRT_Left_Edge");
  982. } else {
  983. m_pbitstrmOut -> putBits (m_rctSpt.left & 0x00001FFFF, NUMBITS_SPRITE_LEFT_EDGE, "SPRT_Left_Edge");
  984. }
  985. m_statsVOL.nBitsHead += NUMBITS_SPRITE_LEFT_EDGE;
  986. m_pbitstrmOut -> putBits (MARKER_BIT, 1, "Marker_Bit");
  987. m_statsVOL.nBitsStuffing += 1;
  988. if (m_rctSpt.top >= 0) {
  989. m_pbitstrmOut -> putBits (m_rctSpt.top, NUMBITS_SPRITE_TOP_EDGE, "SPRT_Top_Edge");
  990. } else {
  991. m_pbitstrmOut -> putBits (m_rctSpt.top & 0x00001FFFF, NUMBITS_SPRITE_TOP_EDGE, "SPRT_Top_Edge");
  992. }
  993. m_statsVOL.nBitsHead += NUMBITS_SPRITE_TOP_EDGE; 
  994. m_pbitstrmOut -> putBits (MARKER_BIT, 1, "Marker_Bit");
  995. m_statsVOL.nBitsStuffing += 1;
  996. m_pbitstrmOut -> putBits (m_iNumOfPnts, NUMBITS_NUM_SPRITE_POINTS, "SPRT_Num_Pnt");
  997. m_statsVOL.nBitsHead += NUMBITS_NUM_SPRITE_POINTS;
  998. m_pbitstrmOut -> putBits (m_uiWarpingAccuracy, NUMBITS_WARPING_ACCURACY, "SPRT_Warping_Accuracy");
  999. m_statsVOL.nBitsHead += NUMBITS_WARPING_ACCURACY;
  1000. Bool bLightChange = 0;
  1001. m_pbitstrmOut -> putBits (bLightChange, 1, "SPRT_Brightness_Change");
  1002. m_statsVOL.nBitsHead++;
  1004. // Begin: modified by Hughes   4/9/98
  1005. if (m_sptMode == BASIC_SPRITE)
  1006. m_pbitstrmOut -> putBits (FALSE, 1, "Low_latency_sprite_enable");
  1007. else
  1008. m_pbitstrmOut -> putBits (TRUE, 1, "Low_latency_sprite_enable");
  1009. m_statsVOL.nBitsHead++;
  1010. // End: modified by Hughes   4/9/98
  1011. }
  1013. // NBIT
  1014. m_pbitstrmOut -> putBits ((Int) m_volmd.bNot8Bit, 1, "VOL_NOT_8_BIT_VIDEO");
  1015. m_statsVOL.nBitsHead++;
  1016. if (m_volmd.bNot8Bit) {
  1017. m_pbitstrmOut->putBits ((Int) m_volmd.uiQuantPrecision, 4, "QUANT_PRECISION");
  1018. m_pbitstrmOut->putBits ((Int) m_volmd.nBits, 4, "BITS_PER_PIXEL");
  1019. m_statsVOL.nBitsHead+=8;
  1020. }
  1022. if (m_volmd.fAUsage == EIGHT_BIT) {
  1023. m_pbitstrmOut -> putBits (m_volmd.bNoGrayQuantUpdate, 1, "VOL_Disable_Gray_Q_Update");
  1024. m_pbitstrmOut -> putBits (0, 1, "Composition_Method");
  1025. m_pbitstrmOut -> putBits (1, 1, "Linear_Composition");
  1026. m_statsVOL.nBitsHead+=3;
  1027. }
  1028. m_pbitstrmOut -> putBits ((Int) m_volmd.fQuantizer, 1, "VOL_Quant_Type"); 
  1029. m_statsVOL.nBitsHead++;
  1030. if (m_volmd.fQuantizer == Q_MPEG) {
  1031. m_pbitstrmOut -> putBits (m_volmd.bLoadIntraMatrix, 1, "VOL_Load_Q_Matrix (intra)");
  1032. m_statsVOL.nBitsHead++;
  1033. if (m_volmd.bLoadIntraMatrix) {
  1034. UInt i = 0;
  1035. do {
  1036. m_pbitstrmOut -> putBits (m_volmd.rgiIntraQuantizerMatrix [grgiStandardZigzag[i]], NUMBITS_QMATRIX, "VOL_Quant_Matrix(intra)");
  1037. m_statsVOL.nBitsHead += NUMBITS_QMATRIX;
  1038. } while (m_volmd.rgiIntraQuantizerMatrix [grgiStandardZigzag[i]] != 0 && ++i < BLOCK_SQUARE_SIZE);
  1039. for (UInt j = i; j < BLOCK_SQUARE_SIZE; j++) {
  1040. m_volmd.rgiIntraQuantizerMatrix [grgiStandardZigzag[j]] = m_volmd.rgiIntraQuantizerMatrix [grgiStandardZigzag[i - 1]];
  1041. }
  1042. }
  1043. m_pbitstrmOut -> putBits (m_volmd.bLoadInterMatrix, 1, "VOL_Load_Q_Matrix (inter)");
  1044. m_statsVOL.nBitsHead++;
  1045. if (m_volmd.bLoadInterMatrix) {
  1046. UInt i = 0;
  1047. do {
  1048. m_pbitstrmOut -> putBits (m_volmd.rgiInterQuantizerMatrix [grgiStandardZigzag[i]], NUMBITS_QMATRIX, "VOL_Quant_Matrix(intra)");
  1049. m_statsVOL.nBitsHead += NUMBITS_QMATRIX;
  1050. } while (m_volmd.rgiInterQuantizerMatrix [grgiStandardZigzag[i]] != 0 && ++i < BLOCK_SQUARE_SIZE);
  1051. for (UInt j = i; j < BLOCK_SQUARE_SIZE; j++) {
  1052. m_volmd.rgiInterQuantizerMatrix [grgiStandardZigzag[j]] = m_volmd.rgiInterQuantizerMatrix [grgiStandardZigzag[i - 1]];
  1053. }
  1054. }
  1055. if (m_volmd.fAUsage == EIGHT_BIT) {
  1056. m_pbitstrmOut -> putBits (m_volmd.bLoadIntraMatrixAlpha, 1, "VOL_Load_Alpha_Q_Matrix (intra)");
  1057. m_statsVOL.nBitsHead++;
  1058. if (m_volmd.bLoadIntraMatrixAlpha) {
  1059. for (UInt i = 0; i < BLOCK_SQUARE_SIZE; i++) {
  1060. m_pbitstrmOut -> putBits (m_volmd.rgiIntraQuantizerMatrixAlpha [grgiStandardZigzag[i]], NUMBITS_QMATRIX, "VOL_Alpha_Quant_Matrix(intra)");
  1061. m_statsVOL.nBitsHead += NUMBITS_QMATRIX;
  1062. }
  1063. }
  1064. m_pbitstrmOut -> putBits (m_volmd.bLoadInterMatrixAlpha, 1, "VOL_Load_Alpha_Q_Matrix (inter)");
  1065. m_statsVOL.nBitsHead++;
  1066. if (m_volmd.bLoadInterMatrixAlpha) {
  1067. for (UInt i = 0; i < BLOCK_SQUARE_SIZE; i++) {
  1068. m_pbitstrmOut -> putBits (m_volmd.rgiInterQuantizerMatrixAlpha [grgiStandardZigzag[i]], NUMBITS_QMATRIX, "VOL_Alpha_Quant_Matrix(inter)");
  1069. m_statsVOL.nBitsHead += NUMBITS_QMATRIX;
  1070. }
  1071. }
  1072. }
  1073. }
  1075. // START: Complexity Estimation syntax support - Marc Mongenet (EPFL) - 16 Jun 1998
  1076. m_pbitstrmOut -> putBits (m_volmd.bComplexityEstimationDisable,
  1077.   1, "complexity_estimation_disable");
  1078. m_statsVOL.nBitsHead += 1;
  1079. if (! m_volmd.bComplexityEstimationDisable) {
  1081. m_volmd.iEstimationMethod = 0; // only known estimation method at now (18 Jun 1998)
  1083. m_volmd.bShapeComplexityEstimationDisable =
  1084.   !(m_volmd.bOpaque ||
  1085. m_volmd.bTransparent ||
  1086. m_volmd.bIntraCAE ||
  1087. m_volmd.bInterCAE ||
  1088. m_volmd.bNoUpdate ||
  1089. m_volmd.bUpsampling);
  1091. m_volmd.bTextureComplexityEstimationSet1Disable =
  1092.   !(m_volmd.bIntraBlocks ||
  1093. m_volmd.bInterBlocks ||
  1094. m_volmd.bInter4vBlocks ||
  1095. m_volmd.bNotCodedBlocks);
  1097. m_volmd.bTextureComplexityEstimationSet2Disable =
  1098.   !(m_volmd.bDCTCoefs ||
  1099. m_volmd.bDCTLines ||
  1100. m_volmd.bVLCSymbols ||
  1101. m_volmd.bVLCBits);
  1103. m_volmd.bMotionCompensationComplexityDisable =
  1104.   !(m_volmd.bAPM ||
  1105. m_volmd.bNPM ||
  1106. m_volmd.bInterpolateMCQ ||
  1107. m_volmd.bForwBackMCQ ||
  1108. m_volmd.bHalfpel2 ||
  1109. m_volmd.bHalfpel4);
  1112. assert (m_volmd.iEstimationMethod == 0);
  1113. m_pbitstrmOut -> putBits (m_volmd.iEstimationMethod, 2, "estimation_method");
  1114. m_statsVOL.nBitsHead += 2;
  1116. m_pbitstrmOut -> putBits (m_volmd.bShapeComplexityEstimationDisable,
  1117.   1, "shape_complexity_estimation_disable");
  1118. m_statsVOL.nBitsHead += 1;
  1119. if (! m_volmd.bShapeComplexityEstimationDisable) {
  1120. m_pbitstrmOut -> putBits (m_volmd.bOpaque, 1, "opaque");
  1121. m_pbitstrmOut -> putBits (m_volmd.bTransparent, 1, "transparent");
  1122. m_pbitstrmOut -> putBits (m_volmd.bIntraCAE, 1, "intra_cae");
  1123. m_pbitstrmOut -> putBits (m_volmd.bInterCAE, 1, "inter_cae");
  1124. m_pbitstrmOut -> putBits (m_volmd.bNoUpdate, 1, "no_update");
  1125. m_pbitstrmOut -> putBits (m_volmd.bUpsampling, 1, "upsampling");
  1126. m_statsVOL.nBitsHead += 6;
  1127. }
  1129. m_pbitstrmOut -> putBits (m_volmd.bTextureComplexityEstimationSet1Disable,
  1130.   1, "texture_complexity_estimation_set_1_disable");
  1131. m_statsVOL.nBitsHead += 1;
  1132. if (! m_volmd.bTextureComplexityEstimationSet1Disable) {
  1133. m_pbitstrmOut -> putBits (m_volmd.bIntraBlocks, 1, "intra_blocks");
  1134. m_pbitstrmOut -> putBits (m_volmd.bInterBlocks, 1, "inter_blocks");
  1135. m_pbitstrmOut -> putBits (m_volmd.bInter4vBlocks, 1, "inter4v_blocks");
  1136. m_pbitstrmOut -> putBits (m_volmd.bNotCodedBlocks, 1, "not_coded_blocks");
  1137. m_statsVOL.nBitsHead += 4;
  1138. }
  1140. m_pbitstrmOut -> putBits (1, 1, "Marker_Bit");
  1141. m_statsVOL.nBitsStuffing ++;
  1143. m_pbitstrmOut -> putBits (m_volmd.bTextureComplexityEstimationSet2Disable,
  1144.   1, "texture_complexity_estimation_set_2_disable");
  1145. m_statsVOL.nBitsHead += 1;
  1146. if (! m_volmd.bTextureComplexityEstimationSet2Disable) {
  1147. m_pbitstrmOut -> putBits (m_volmd.bDCTCoefs, 1, "dct_coefs");
  1148. m_pbitstrmOut -> putBits (m_volmd.bDCTLines, 1, "dct_lines");
  1149. m_pbitstrmOut -> putBits (m_volmd.bVLCSymbols, 1, "vlc_symbols");
  1150. m_pbitstrmOut -> putBits (m_volmd.bVLCBits, 1, "vlc_bits");
  1151. m_statsVOL.nBitsHead += 4;
  1152. }
  1154. m_pbitstrmOut -> putBits (m_volmd.bMotionCompensationComplexityDisable,
  1155.   1, "motion_compensation_complexity_disable");
  1156. m_statsVOL.nBitsHead += 1;
  1157. if (! m_volmd.bMotionCompensationComplexityDisable) {
  1158. m_pbitstrmOut -> putBits (m_volmd.bAPM, 1, "apm");
  1159. m_pbitstrmOut -> putBits (m_volmd.bNPM, 1, "npm");
  1160. m_pbitstrmOut -> putBits (m_volmd.bInterpolateMCQ, 1, "interpolate_mc_q");
  1161. m_pbitstrmOut -> putBits (m_volmd.bForwBackMCQ, 1, "forw_back_mc_q");
  1162. m_pbitstrmOut -> putBits (m_volmd.bHalfpel2, 1, "halfpel2");
  1163. m_pbitstrmOut -> putBits (m_volmd.bHalfpel4, 1, "halfpel4");
  1164. m_statsVOL.nBitsHead += 6;
  1165. }
  1167. m_pbitstrmOut -> putBits (1, 1, "Marker_Bit");
  1168. m_statsVOL.nBitsStuffing ++;
  1169. }
  1170. // END: Complexity Estimation syntax support
  1172. m_pbitstrmOut -> putBits (0, 1, "VOL_resync_marker_disable");
  1173. m_statsVOL.nBitsHead ++;
  1175. // Modified by Toshiba(1998-4-7)
  1176. m_pbitstrmOut -> putBits (m_volmd.bDataPartitioning, 1, "VOL_data_partitioning");
  1177. m_statsVOL.nBitsHead ++;
  1178. if( m_volmd.bDataPartitioning )
  1179. {
  1180. m_pbitstrmOut -> putBits (m_volmd.bReversibleVlc, 1, "VOL_reversible_vlc");
  1181. m_statsVOL.nBitsHead ++;
  1182. }
  1183. // End Toshiba
  1185. m_pbitstrmOut -> putBits (m_volmd.volType == ENHN_LAYER, 1, "VOL_Scalability");
  1186. m_statsVOL.nBitsHead++;
  1187. if (m_volmd.volType == ENHN_LAYER) {
  1188. //#ifdef _Scalable_SONY_
  1189. m_pbitstrmOut -> putBits (m_volmd.iHierarchyType, 1, "VOL_Hierarchy_Type");
  1190. //#endif _Scalable_SONY_
  1191. m_pbitstrmOut -> putBits (0, 4, "VOL_Ref_Layer_Id");
  1192. m_pbitstrmOut -> putBits (0, 1, "VOL_Ref_Layer_Sampling_Dir");
  1193. /*Added*/
  1194. m_pbitstrmOut -> putBits (m_volmd.ihor_sampling_factor_n, 5, "VOL_Horizontal_Sampling_Factor"); //The vm is not very clear about this.
  1195. m_pbitstrmOut -> putBits (m_volmd.ihor_sampling_factor_m, 5, "VOL_Horizontal_Sampling_Factor_Ref"); //Always 1
  1197. m_pbitstrmOut -> putBits (m_volmd.iver_sampling_factor_n, 5, "VOL_Vertical_Sampling_Factor"); //The vm is not very clear about this.
  1198. m_pbitstrmOut -> putBits (m_volmd.iver_sampling_factor_m, 5, "VOL_Vertical_Sampling_Factor_Ref"); //Always 1
  1200. m_pbitstrmOut -> putBits (m_volmd.iEnhnType!=0?1:0, 1, "VOL_Ehnancement_Type"); // enhancement_type for scalability // modified by Sharp (98/3/24)
  1201. m_statsVOL.nBitsHead += 26;
  1202. }
  1203. // Begin: modified by Hughes   4/9/98   per clause 2.1.7. in N2171 document
  1204. // m_pbitstrmOut -> putBits ((Int) 0, 1, "VOL_Random_Access"); //isn't this a system level flg?
  1205. // m_statsVOL.nBitsHead++;
  1206. // End: modified by Hughes   4/9/98
  1208. cout << "VOL Overhead" << "tt" << m_statsVOL.nBitsHead << "nn";
  1209. cout.flush ();
  1210. }
  1212. //encode GOV header, modified by SONY 980212
  1213. Void CVideoObjectEncoder::codeGOVHead (Time t)
  1214. {
  1215. cout << "GOV Header (t=" << t << ")nn";
  1217. m_pbitstrmOut->reset ();
  1219. // Start code
  1220. m_pbitstrmOut -> putBits (START_CODE_PREFIX, NUMBITS_START_CODE_PREFIX, "GOV_Start_Code");
  1221. m_pbitstrmOut -> putBits (GOV_START_CODE, NUMBITS_GOV_START_CODE, "GOV_Start_Code");
  1222. m_statsVOL.nBitsHead += NUMBITS_START_CODE_PREFIX + NUMBITS_GOV_START_CODE;
  1224. // Time code
  1225. /*modified by SONY (98/03/30) */
  1226. /* Time tGOVCode = ((Int)(t * m_volmd.iClockRate / m_volmd.dFrameHz)) / m_volmd.iClockRate;*/
  1227. /*modified by SONY (98/03/30) End*/
  1228. /*              ORIGINAL
  1229. Time tGOVCode = ((Int)(t * m_volmd.iClockRate / m_volmd.dFrameHz) - m_volmd.iBbetweenP) / m_volmd.iClockRate;
  1230. */
  1232. // modified by swinder 980511
  1233. Time tGOVCode = (Time)(t / m_volmd.dFrameHz);
  1234. // this is because t is the source frame count and dFrameHz is the source frame rate,
  1235. // tGOVCode is therefore in seconds rounded down. I see no reason for clock rate to be
  1236. // used here - swinder
  1238. if(tGOVCode<0) tGOVCode=0;
  1239. Time tCodeHou = (tGOVCode / 3600)%24;
  1240. Time tCodeMin = (tGOVCode / 60) % 60;
  1241. Time tCodeSec = tGOVCode % 60;
  1243. m_pbitstrmOut -> putBits (tCodeHou, NUMBITS_GOV_TIMECODE_HOUR, "GOV_Time_Code_Hour");
  1244. m_statsVOL.nBitsHead += NUMBITS_GOV_TIMECODE_HOUR;
  1245. m_pbitstrmOut -> putBits (tCodeMin, NUMBITS_GOV_TIMECODE_MIN, "GOV_Time_Code_Min");
  1246. m_statsVOL.nBitsHead += NUMBITS_GOV_TIMECODE_MIN;
  1247. m_pbitstrmOut -> putBits (MARKER_BIT, 1, "Marker_Bit");
  1248. m_statsVOL.nBitsStuffing += 1;
  1249. m_pbitstrmOut -> putBits (tCodeSec, NUMBITS_GOV_TIMECODE_SEC, "GOV_Time_Code_Sec");
  1250. m_statsVOL.nBitsHead += NUMBITS_GOV_TIMECODE_SEC;
  1252. Int iClosedGOV;
  1253. if ((m_vopmd.vopPredType==IVOP)&&(m_volmd.iBbetweenP==0))
  1254. iClosedGOV=1;
  1255. else
  1256. iClosedGOV=0;
  1257. m_pbitstrmOut -> putBits (iClosedGOV, 1, "GOV_Closed");
  1258. m_statsVOL.nBitsHead += 1;
  1259. m_pbitstrmOut -> putBits (0, 1, "GOV_Broken_Link");
  1260. m_statsVOL.nBitsHead += 1;
  1262. m_statsVOL.nBitsStuffing += m_pbitstrmOut->flush ();
  1263. //m_pbitstrmOut -> putBits (15, 4, "byte_align");
  1264. //m_statsVOL.nBitsHead += 4;
  1266. m_tModuloBaseDisp = tGOVCode;
  1267. m_tModuloBaseDecd = tGOVCode;
  1268. }
  1269. //980212
  1271. Void CVideoObjectEncoder::codeVOPHeadInitial()
  1272. {
  1273. // Start code
  1274. m_pbitstrmOut -> putBits (START_CODE_PREFIX, NUMBITS_START_CODE_PREFIX, "VOP_Start_Code");
  1275. m_pbitstrmOut -> putBits (VOP_START_CODE, NUMBITS_VOP_START_CODE, "VOP_Start_Code");
  1276. m_statsVOP.nBitsHead += NUMBITS_START_CODE_PREFIX + NUMBITS_VOP_START_CODE;
  1278. // prediction type
  1279. m_pbitstrmOut -> putBits (m_vopmd.vopPredType, NUMBITS_VOP_PRED_TYPE, "VOP_Pred_Type");
  1280. m_statsVOP.nBitsHead += NUMBITS_VOP_PRED_TYPE;
  1282. // Time reference
  1283. Time tCurrSec = (Int)(m_t / m_volmd.dFrameHz); // current time in seconds
  1284. // Time tCurrSec = m_t / SOURCE_FRAME_RATE;     // current time in seconds
  1285. m_nBitsModuloBase = tCurrSec - (((m_vopmd.vopPredType != BVOP) ||
  1286. (m_vopmd.vopPredType == BVOP && m_volmd.volType == ENHN_LAYER )) ?
  1287. m_tModuloBaseDecd : m_tModuloBaseDisp);
  1288. assert(m_nBitsModuloBase<=31);
  1290. m_pbitstrmOut -> putBits ((Int) 0xFFFFFFFE, (UInt) m_nBitsModuloBase + 1, "VOP_Modulo_Time_Base");
  1291. m_statsVOP.nBitsHead += m_nBitsModuloBase + 1;
  1293. m_iVopTimeIncr = (Int)(m_t * m_volmd.iClockRate / m_volmd.dFrameHz - tCurrSec * m_volmd.iClockRate);
  1294. // m_iVopTimeIncr = m_t * m_volmd.iClockRate / SOURCE_FRAME_RATE - tCurrSec * m_volmd.iClockRate;
  1296. m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit Added for error resilient mode by Toshiba(1997-11-14)
  1297. m_statsVOP.nBitsStuffing ++;
  1299. m_pbitstrmOut -> putBits (m_iVopTimeIncr, m_iNumBitsTimeIncr, "VOP_Time_Incr");
  1300. m_statsVOP.nBitsHead += m_iNumBitsTimeIncr;// Modified for error resilient mode by Toshiba(1997-11-14)
  1302. m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
  1303. m_statsVOP.nBitsStuffing ++;
  1305. if ( m_vopmd.vopPredType != BVOP ||
  1306. (m_vopmd.vopPredType == BVOP && m_volmd.volType == ENHN_LAYER ))
  1307. { //update modulo time base
  1308. m_tModuloBaseDisp = m_tModuloBaseDecd; //of the most recently displayed I/Pvop
  1309. m_tModuloBaseDecd = tCurrSec; //of the most recently decoded I/Pvop
  1310. }
  1311. }
  1313. Void CVideoObjectEncoder::codeNonCodedVOPHead ()
  1314. {
  1315. codeVOPHeadInitial();
  1317. m_pbitstrmOut -> putBits (0, 1, "VOP_Coded");
  1318. m_statsVOP.nBitsHead++;
  1319. }
  1321. Void CVideoObjectEncoder::codeVOPHead ()
  1322. {
  1323. codeVOPHeadInitial();
  1325. m_pbitstrmOut -> putBits (1, 1, "VOP_Coded");
  1326. m_statsVOP.nBitsHead++;
  1328. if(m_volmd.bShapeOnly==FALSE)
  1329. {
  1330. if (m_vopmd.vopPredType == PVOP) {
  1331. m_pbitstrmOut -> putBits (m_vopmd.iRoundingControl, 1, "VOP_Rounding_Type");
  1332. m_statsVOP.nBitsHead++;
  1333. }
  1334. }
  1335. if (m_volmd.fAUsage != RECTANGLE) {
  1336. if (!(m_uiSprite == 1 && m_vopmd.vopPredType == IVOP)) {
  1337. m_pbitstrmOut->putBits (m_rctCurrVOPY.width, NUMBITS_VOP_WIDTH, "VOP_Width");
  1338. m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
  1339. m_pbitstrmOut->putBits (m_rctCurrVOPY.height (), NUMBITS_VOP_HEIGHT, "VOP_Height");
  1340. m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
  1341. m_statsVOP.nBitsHead += NUMBITS_VOP_WIDTH + NUMBITS_VOP_HEIGHT;
  1342. m_statsVOP.nBitsStuffing += 2;
  1344. if (m_rctCurrVOPY.left >= 0) {
  1345. m_pbitstrmOut -> putBits (m_rctCurrVOPY.left, NUMBITS_VOP_HORIZONTAL_SPA_REF, "VOP_Hori_Ref");
  1346. } else {
  1347. m_pbitstrmOut -> putBits (m_rctCurrVOPY.left & 0x00001FFFF, NUMBITS_VOP_HORIZONTAL_SPA_REF, "VOP_Hori_Ref");
  1348. }
  1349. m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
  1350. if (m_rctCurrVOPY.top >= 0) {
  1351. m_pbitstrmOut -> putBits (m_rctCurrVOPY.top, NUMBITS_VOP_VERTICAL_SPA_REF, "VOP_Vert_Ref");
  1352. } else {
  1353. m_pbitstrmOut -> putBits (m_rctCurrVOPY.top & 0x00001FFFF, NUMBITS_VOP_VERTICAL_SPA_REF, "VOP_Vert_Ref");
  1354. }
  1355. m_statsVOP.nBitsHead += NUMBITS_VOP_HORIZONTAL_SPA_REF + NUMBITS_VOP_VERTICAL_SPA_REF;
  1356. m_statsVOP.nBitsStuffing += 1;
  1357. }
  1359. if ( m_volmd.volType == ENHN_LAYER && m_volmd.iEnhnType == 1 ) {
  1360. m_pbitstrmOut->putBits (1, 1, "Background Composition");
  1361. m_statsVOP.nBitsHead++;
  1362. }
  1363. // begin: added by Sharp (98/3/24)
  1364. else if ( m_volmd.volType == ENHN_LAYER && m_volmd.iEnhnType == 2 ) {
  1365. m_pbitstrmOut->putBits (0, 1, "Background Composition");
  1366. m_statsVOP.nBitsHead++;
  1367. }
  1368. // end: added by Sharp (98/3/24)
  1370. m_pbitstrmOut->putBits (m_volmd.bNoCrChange, 1, "VOP_CR_Change_Disable");
  1371. m_statsVOP.nBitsHead++;
  1372.         // tentative solution for normal sprite bitstream exchange
  1373. m_pbitstrmOut->putBits (0, 1, "VOP_Constant_Alpha");
  1374. m_statsVOP.nBitsHead++;
  1375. }
  1377. // START: Complexity Estimation syntax support - Marc Mongenet (EPFL) - 15 Jun 1998
  1378. if (! m_volmd.bComplexityEstimationDisable) {
  1379. assert (m_volmd.iEstimationMethod == 0);
  1381. // In real life the following values should be estimated by the encoder,
  1382. // but this is only a syntax support so arbitrary complexity values are assigned.
  1383. m_vopmd.iOpaque = 77;
  1384. m_vopmd.iTransparent = 97;
  1385. m_vopmd.iIntraCAE = 114;
  1386. m_vopmd.iInterCAE = 99;
  1387. m_vopmd.iNoUpdate = 32;
  1388. m_vopmd.iUpsampling = 32;
  1389. m_vopmd.iIntraBlocks = 171;
  1390. m_vopmd.iNotCodedBlocks = 171;
  1391. m_vopmd.iDCTCoefs = 215;
  1392. m_vopmd.iDCTLines = 187;
  1393. m_vopmd.iVLCSymbols = 187;
  1394. m_vopmd.iVLCBits = 10;
  1395. m_vopmd.iInterBlocks = 77;
  1396. m_vopmd.iInter4vBlocks = 111;
  1397. m_vopmd.iAPM = 110;
  1398. m_vopmd.iNPM = 103;
  1399. m_vopmd.iForwBackMCQ = 101;
  1400. m_vopmd.iHalfpel2 = 110;
  1401. m_vopmd.iHalfpel4 = 101;
  1402. m_vopmd.iInterpolateMCQ = 116;
  1404. if (m_vopmd.vopPredType == IVOP ||
  1405. m_vopmd.vopPredType == PVOP ||
  1406. m_vopmd.vopPredType == BVOP)
  1407. {
  1408. if (m_volmd.bOpaque) {
  1409. m_pbitstrmOut -> putBits (codedDCECS (m_vopmd.iOpaque, 8), 8, "dcecs_opaque");
  1410. m_statsVOP.nBitsHead += 8;
  1411. }
  1412. if (m_volmd.bTransparent) {
  1413. m_pbitstrmOut -> putBits (codedDCECS (m_vopmd.iTransparent, 8), 8, "dcecs_transparent");
  1414. m_statsVOP.nBitsHead += 8;
  1415. }
  1416. if (m_volmd.bIntraCAE) {
  1417. m_pbitstrmOut -> putBits (codedDCECS (m_vopmd.iIntraCAE, 8), 8 , "dcecs_intra_cae");
  1418. m_statsVOP.nBitsHead += 8;
  1419. }
  1420. if (m_volmd.bInterCAE) {
  1421. m_pbitstrmOut -> putBits (codedDCECS (m_vopmd.iInterCAE, 8), 8 , "dcecs_inter_cae");
  1422. m_statsVOP.nBitsHead += 8;
  1423. }
  1424. if (m_volmd.bNoUpdate) {
  1425. m_pbitstrmOut -> putBits (codedDCECS (m_vopmd.iNoUpdate, 8), 8 , "dcecs_no_update");
  1426. m_statsVOP.nBitsHead += 8;
  1427. }
  1428. if (m_volmd.bUpsampling) {
  1429. m_pbitstrmOut -> putBits (codedDCECS (m_vopmd.iUpsampling, 8), 8 , "dcecs_upsampling");
  1430. m_statsVOP.nBitsHead += 8;
  1431. }
  1432. }
  1434. if (m_volmd.bIntraBlocks) {
  1435. m_pbitstrmOut -> putBits (codedDCECS (m_vopmd.iIntraBlocks, 8), 8 , "dcecs_intra_blocks");
  1436. m_statsVOP.nBitsHead += 8;
  1437. }
  1438. if (m_volmd.bNotCodedBlocks) {
  1439. m_pbitstrmOut -> putBits (codedDCECS (m_vopmd.iNotCodedBlocks, 8), 8 , "dcecs_not_coded_blocks");
  1440. m_statsVOP.nBitsHead += 8;
  1441. }
  1442. if (m_volmd.bDCTCoefs) {
  1443. m_pbitstrmOut -> putBits (codedDCECS (m_vopmd.iDCTCoefs, 8), 8 , "dcecs_dct_coefs");
  1444. m_statsVOP.nBitsHead += 8;
  1445. }
  1446. if (m_volmd.bDCTLines) {
  1447. m_pbitstrmOut -> putBits (codedDCECS (m_vopmd.iDCTLines, 8), 8 , "dcecs_dct_lines");
  1448. m_statsVOP.nBitsHead += 8;
  1449. }
  1450. if (m_volmd.bVLCSymbols) {
  1451. m_pbitstrmOut -> putBits (codedDCECS (m_vopmd.iVLCSymbols, 8), 8 , "dcecs_vlc_symbols");
  1452. m_statsVOP.nBitsHead += 8;
  1453. }
  1454. if (m_volmd.bVLCBits) {
  1455. m_pbitstrmOut -> putBits (codedDCECS (m_vopmd.iVLCBits, 4), 4, "dcecs_vlc_bits");
  1456. m_statsVOP.nBitsHead += 4;
  1457. }
  1459. if (m_vopmd.vopPredType == PVOP ||
  1460. m_vopmd.vopPredType == BVOP ||
  1461. m_vopmd.vopPredType == SPRITE)
  1462. {
  1463. if (m_volmd.bInterBlocks) {
  1464. m_pbitstrmOut -> putBits (codedDCECS (m_vopmd.iInterBlocks, 8), 8 , "dcecs_inter_blocks");
  1465. m_statsVOP.nBitsHead += 8;
  1466. }
  1467. if (m_volmd.bInter4vBlocks) {
  1468. m_pbitstrmOut -> putBits (codedDCECS (m_vopmd.iInter4vBlocks, 8), 8 , "dcecs_inter4v_blocks");
  1469. m_statsVOP.nBitsHead += 8;
  1470. }
  1471. if (m_volmd.bAPM) {
  1472. m_pbitstrmOut -> putBits (codedDCECS (m_vopmd.iAPM, 8), 8 , "dcecs_apm");
  1473. m_statsVOP.nBitsHead += 8;
  1474. }
  1475. if (m_volmd.bNPM) {
  1476. m_pbitstrmOut -> putBits (codedDCECS (m_vopmd.iNPM, 8), 8 , "dcecs_npm");
  1477. m_statsVOP.nBitsHead += 8;
  1478. }
  1479. if (m_volmd.bForwBackMCQ) {
  1480. m_pbitstrmOut -> putBits (codedDCECS (m_vopmd.iForwBackMCQ, 8), 8 , "dcecs_forw_back_mc_q");
  1481. m_statsVOP.nBitsHead += 8;
  1482. }
  1483. if (m_volmd.bHalfpel2) {
  1484. m_pbitstrmOut -> putBits (codedDCECS (m_vopmd.iHalfpel2, 8), 8 , "dcecs_halfpel2");
  1485. m_statsVOP.nBitsHead += 8;
  1486. }
  1487. if (m_volmd.bHalfpel4) {
  1488. m_pbitstrmOut -> putBits (codedDCECS (m_vopmd.iHalfpel4, 8), 8 , "dcecs_halfpel4");
  1489. m_statsVOP.nBitsHead += 8;
  1490. }
  1491. }
  1493. if (m_vopmd.vopPredType == BVOP ||
  1494. m_vopmd.vopPredType == SPRITE)
  1495. {
  1496. if (m_volmd.bInterpolateMCQ) {
  1497. m_pbitstrmOut -> putBits (codedDCECS (m_vopmd.iInterpolateMCQ, 8), 8 , "dcecs_interpolate_mc_q");
  1498. m_statsVOP.nBitsHead += 8;
  1499. }
  1500. }
  1501. }
  1502. // END: Complexity Estimation syntax support
  1504. // Modified for error resilient mode by Toshiba(1998-1-16)
  1505. if(m_volmd.bShapeOnly==TRUE) {
  1506. VideoPacketResetVOP();
  1507. return;
  1508. }
  1510. // End Toshiba(1998-1-16)
  1512. m_pbitstrmOut->putBits (m_vopmd.iIntraDcSwitchThr, 3, "IntraDCSwitchThr");
  1513. m_statsVOP.nBitsHead+=3;
  1515. // INTERLACE_
  1516. //m_pbitstrmOut->putBits (m_vopmd.bInterlace, 1, "InterlaceEnable");
  1517. //m_statsVOP.nBitsHead++; 
  1518. if (m_vopmd.bInterlace == TRUE) {
  1519. m_pbitstrmOut->putBits (m_vopmd.bTopFieldFirst, 1, "Top_Field_First");
  1520. m_pbitstrmOut->putBits (m_vopmd.bAlternateScan, 1, "Alternate_Scan");
  1521. m_statsVOP.nBitsHead += 2; 
  1522. } else
  1523.         m_vopmd.bAlternateScan = FALSE;
  1525. // INTERLACE
  1528. if (m_vopmd.vopPredType == IVOP) {
  1529. m_pbitstrmOut -> putBits (m_vopmd.intStepI, m_volmd.uiQuantPrecision, "VOP_QUANT");
  1530. m_statsVOP.nBitsHead += m_volmd.uiQuantPrecision;
  1531. if(m_volmd.fAUsage == EIGHT_BIT)
  1532. {
  1533. m_pbitstrmOut -> putBits (m_vopmd.intStepIAlpha, NUMBITS_VOP_ALPHA_QUANTIZER, "VOP_GREY_QUANT");
  1534. m_statsVOP.nBitsHead += NUMBITS_VOP_ALPHA_QUANTIZER;
  1535. }
  1536. }
  1537. else if (m_vopmd.vopPredType == PVOP) {
  1538. m_pbitstrmOut -> putBits (m_vopmd.intStep, m_volmd.uiQuantPrecision, "VOP_QUANT");
  1539. m_statsVOP.nBitsHead += m_volmd.uiQuantPrecision;
  1540. if(m_volmd.fAUsage == EIGHT_BIT)
  1541. {
  1542. m_pbitstrmOut -> putBits (m_vopmd.intStepPAlpha, NUMBITS_VOP_ALPHA_QUANTIZER, "VOP_GREY_QUANT");
  1543. m_statsVOP.nBitsHead += NUMBITS_VOP_ALPHA_QUANTIZER;
  1544. }
  1545. m_pbitstrmOut -> putBits (m_vopmd.mvInfoForward.uiFCode, NUMBITS_VOP_FCODE, "VOP_Fcode_Forward");
  1546. m_statsVOP.nBitsHead += NUMBITS_VOP_FCODE;
  1547. }
  1548. else if (m_vopmd.vopPredType == BVOP) {
  1549. m_pbitstrmOut -> putBits (m_vopmd.intStepB, m_volmd.uiQuantPrecision, "VOP_QUANT");
  1550. m_statsVOP.nBitsHead += m_volmd.uiQuantPrecision;
  1551. if(m_volmd.fAUsage == EIGHT_BIT)
  1552. {
  1553. m_pbitstrmOut -> putBits (m_vopmd.intStepBAlpha, NUMBITS_VOP_ALPHA_QUANTIZER, "VOP_GREY_QUANT");
  1554. m_statsVOP.nBitsHead += NUMBITS_VOP_ALPHA_QUANTIZER;
  1555. }
  1556. m_pbitstrmOut -> putBits (m_vopmd.mvInfoForward.uiFCode, NUMBITS_VOP_FCODE, "VOP_Fcode_Forward");
  1557. m_statsVOP.nBitsHead += NUMBITS_VOP_FCODE;
  1558. m_pbitstrmOut -> putBits (m_vopmd.mvInfoBackward.uiFCode, NUMBITS_VOP_FCODE, "VOP_Fcode_Backward");
  1559. m_statsVOP.nBitsHead += NUMBITS_VOP_FCODE;
  1560. }
  1561. // Added for error resilient mode by Toshiba(1997-11-14)
  1562. if(m_volmd.volType != ENHN_LAYER){
  1563. if (m_volmd.fAUsage != RECTANGLE && m_vopmd.vopPredType != IVOP
  1564. && m_uiSprite != 1)  
  1565. {  
  1566. m_pbitstrmOut -> putBits (m_vopmd.bShapeCodingType, 1, "VOP_shape_coding_type");
  1567. m_statsVOP.nBitsHead++;
  1568. }
  1569. VideoPacketResetVOP();
  1570. }
  1571. else
  1572. {
  1573. ///// 97/12/22 start
  1574. if( m_volmd.iEnhnType != 0 ){ // modified by Sharp (98/3/24)
  1575. m_pbitstrmOut->putBits (m_vopmd.iLoadBakShape, 1, "load_backward_shape");
  1576. m_statsVOP.nBitsHead ++;
  1577. if(m_vopmd.iLoadBakShape){
  1578. delete rgpbfShape [1]->m_pvopcRefQ1;
  1579. // previous backward shape is saved to current forward shape
  1580. rgpbfShape [1]->m_pvopcRefQ1 = new CVOPU8YUVBA (*(rgpbfShape [0]->pvopcReconCurr()));
  1581. rgpbfShape [1]->m_rctCurrVOPY.left   = rgpbfShape [0]->m_rctCurrVOPY.left;
  1582. rgpbfShape [1]->m_rctCurrVOPY.right  = rgpbfShape [0]->m_rctCurrVOPY.right;
  1583. rgpbfShape [1]->m_rctCurrVOPY.top    = rgpbfShape [0]->m_rctCurrVOPY.top;
  1584. rgpbfShape [1]->m_rctCurrVOPY.bottom = rgpbfShape [0]->m_rctCurrVOPY.bottom;
  1586. rgpbfShape [0]->findTightBoundingBox ();
  1587. rgpbfShape [0]->findBestBoundingBox ();
  1588. rgpbfShape [0]->m_rctCurrVOPY  = rgpbfShape [0]->m_pvopcOrig->whereBoundY();
  1589. rgpbfShape [0]->m_rctCurrVOPUV = rgpbfShape [0]->m_pvopcOrig->whereBoundUV ();
  1590. rgpbfShape [0]->setRefStartingPointers ();
  1591. rgpbfShape [0]->compute_bfShapeMembers ();
  1593. // backward shape width/height, hori/vert reference
  1594. m_pbitstrmOut->putBits (rgpbfShape [0]->m_rctCurrVOPY.width, NUMBITS_VOP_WIDTH, "back_Width");
  1596. m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
  1597. m_statsVOP.nBitsStuffing ++;
  1599. m_pbitstrmOut->putBits (rgpbfShape [0]->m_rctCurrVOPY.height (), NUMBITS_VOP_HEIGHT, "back_Height");
  1601. m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
  1602. m_statsVOP.nBitsStuffing ++;
  1604. Int iSign = (rgpbfShape [0]->m_rctCurrVOPY.left < 0) ? 1 : 0;
  1605. m_pbitstrmOut->putBits (iSign, 1, "back_Hori_Ref_Sgn");
  1606. m_pbitstrmOut->putBits (abs (rgpbfShape [0]->m_rctCurrVOPY.left), NUMBITS_VOP_HORIZONTAL_SPA_REF - 1, "back_Hori_Ref");
  1608. m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
  1609. m_statsVOP.nBitsStuffing++;
  1611. iSign = (rgpbfShape [0]->m_rctCurrVOPY.top < 0) ? 1 : 0;
  1612. m_pbitstrmOut->putBits (iSign, 1, "back_Vert_Ref_Sgn");
  1613. m_pbitstrmOut->putBits (abs (rgpbfShape [0]->m_rctCurrVOPY.top), NUMBITS_VOP_VERTICAL_SPA_REF - 1, "back_Vert_Ref");
  1614. m_statsVOP.nBitsHead += NUMBITS_VOP_WIDTH + NUMBITS_VOP_HEIGHT 
  1615. + NUMBITS_VOP_HORIZONTAL_SPA_REF + NUMBITS_VOP_VERTICAL_SPA_REF;
  1617. rgpbfShape [0]->resetBYPlane ();
  1619. printf("================ backward shape codingn");
  1620. rgpbfShape [0]->m_volmd.bShapeOnly = TRUE;
  1621. rgpbfShape [0]->encodeNSForIVOP_WithShape ();
  1623. // backward shape coding
  1625. m_pbitstrmOut->putBits (m_vopmd.iLoadForShape, 1, "load_forward_shape");
  1626. m_statsVOP.nBitsHead++;
  1627. if(m_vopmd.iLoadForShape){
  1628. rgpbfShape [1]->findTightBoundingBox ();
  1629. rgpbfShape [1]->findBestBoundingBox ();
  1630. rgpbfShape [1]->m_rctCurrVOPY  = rgpbfShape [1]->m_pvopcOrig->whereBoundY ();
  1631. rgpbfShape [1]->m_rctCurrVOPUV = rgpbfShape [1]->m_pvopcOrig->whereBoundUV ();
  1632. rgpbfShape [1]->setRefStartingPointers ();
  1633. rgpbfShape [1]->compute_bfShapeMembers ();
  1635. // forward shape width/height, hori/vert reference
  1636. m_pbitstrmOut->putBits (rgpbfShape [1]->m_rctCurrVOPY.width, NUMBITS_VOP_WIDTH, "for_Width"); 
  1638. m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
  1639. m_statsVOP.nBitsStuffing ++;
  1641. m_pbitstrmOut->putBits (rgpbfShape [1]->m_rctCurrVOPY.height (), NUMBITS_VOP_HEIGHT, "for_Height");
  1643. m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
  1644. m_statsVOP.nBitsStuffing ++;
  1646. Int iSign = (rgpbfShape [1]->m_rctCurrVOPY.left < 0) ? 1 : 0;
  1647. m_pbitstrmOut->putBits (iSign, 1, "for_Hori_Ref_Sgn");
  1648. m_pbitstrmOut->putBits (abs (rgpbfShape [1]->m_rctCurrVOPY.left), NUMBITS_VOP_HORIZONTAL_SPA_REF - 1, "for_Hori_Ref");
  1650. m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
  1651. m_statsVOP.nBitsStuffing++;
  1653. iSign = (rgpbfShape [1]->m_rctCurrVOPY.top < 0) ? 1 : 0;
  1654. m_pbitstrmOut->putBits (iSign, 1, "for_Vert_Ref_Sgn");
  1655. m_pbitstrmOut->putBits (abs (rgpbfShape [1]->m_rctCurrVOPY.top), NUMBITS_VOP_VERTICAL_SPA_REF - 1, "for_Vert_Ref");
  1656. m_statsVOP.nBitsHead += NUMBITS_VOP_WIDTH + NUMBITS_VOP_HEIGHT 
  1657. + NUMBITS_VOP_HORIZONTAL_SPA_REF + NUMBITS_VOP_VERTICAL_SPA_REF;
  1659. rgpbfShape [1]->resetBYPlane ();
  1661. printf("================ forward shape codingn");
  1662. rgpbfShape [1]->m_volmd.bShapeOnly = TRUE;
  1663. rgpbfShape [1]->encodeNSForIVOP_WithShape ();
  1664. // forward shape coding
  1665. }
  1666. } // end of "if (m_vopmd.iLoadBakShape)"
  1667. } // end of "if (iEnhnType == 1)"
  1668. ///// 97/12/22 end
  1669. m_pbitstrmOut->putBits(m_vopmd.iRefSelectCode, 2, "RefSelectCode");
  1670. m_statsVOP.nBitsHead +=2;
  1671. }
  1672. // End Toshiba(1997-11-14)
  1673. }
  1675. Void CVideoObjectEncoder::decideMVInfo ()
  1676. {
  1677. assert (m_vopmd.iSearchRangeForward <= 1024); //seems a reasonable constraint
  1678. assert (m_vopmd.iSearchRangeBackward <= 1024); //seems a reasonable constraint
  1680. if(m_vopmd.iSearchRangeForward <= 16)
  1681. m_vopmd.mvInfoForward.uiFCode = 1;
  1682. else if(m_vopmd.iSearchRangeForward <= 32)
  1683. m_vopmd.mvInfoForward.uiFCode = 2;
  1684. else if(m_vopmd.iSearchRangeForward <= 64)
  1685. m_vopmd.mvInfoForward.uiFCode = 3;
  1686. else if(m_vopmd.iSearchRangeForward <= 128)
  1687. m_vopmd.mvInfoForward.uiFCode = 4;
  1688. else if(m_vopmd.iSearchRangeForward <= 256)
  1689. m_vopmd.mvInfoForward.uiFCode = 5;
  1690. else if(m_vopmd.iSearchRangeForward <= 512)
  1691. m_vopmd.mvInfoForward.uiFCode = 6;
  1692. else // 1024
  1693. m_vopmd.mvInfoForward.uiFCode = 7;
  1695. m_vopmd.mvInfoForward.uiRange = 1 << (m_vopmd.mvInfoForward.uiFCode + 4);
  1696. m_vopmd.mvInfoForward.uiScaleFactor = 1 << (m_vopmd.mvInfoForward.uiFCode - 1);
  1698. if ((UInt)m_vopmd.iSearchRangeForward == (m_vopmd.mvInfoForward.uiRange >> 1))
  1699. m_vopmd.iSearchRangeForward--; // avoid out of range half pel
  1701. if(m_vopmd.iSearchRangeBackward <= 16)
  1702. m_vopmd.mvInfoBackward.uiFCode = 1;
  1703. else if(m_vopmd.iSearchRangeBackward <= 32)
  1704. m_vopmd.mvInfoBackward.uiFCode = 2;
  1705. else if(m_vopmd.iSearchRangeBackward <= 64)
  1706. m_vopmd.mvInfoBackward.uiFCode = 3;
  1707. else if(m_vopmd.iSearchRangeBackward <= 128)
  1708. m_vopmd.mvInfoBackward.uiFCode = 4;
  1709. else if(m_vopmd.iSearchRangeBackward <= 256)
  1710. m_vopmd.mvInfoBackward.uiFCode = 5;
  1711. else if(m_vopmd.iSearchRangeBackward <= 512)
  1712. m_vopmd.mvInfoBackward.uiFCode = 6;
  1713. else // 1024
  1714. m_vopmd.mvInfoBackward.uiFCode = 7;
  1716. m_vopmd.mvInfoBackward.uiRange = 1 << (m_vopmd.mvInfoBackward.uiFCode + 4);
  1717. m_vopmd.mvInfoBackward.uiScaleFactor = 1 << (m_vopmd.mvInfoBackward.uiFCode - 1);
  1719. if ((UInt)m_vopmd.iSearchRangeBackward == (m_vopmd.mvInfoBackward.uiRange >> 1))
  1720. m_vopmd.iSearchRangeBackward--; // avoid out of range half pel
  1721. }
  1723. // START: Complexity Estimation syntax support - Marc Mongenet (EPFL) - 19 Jun 1998
  1724. Int CVideoObjectEncoder::codedDCECS (Int ioriginal, UInt uinb_bits)
  1725. {
  1726. ioriginal &= (1 << uinb_bits) - 1; // mask raw data
  1727. return ioriginal != 0 ? ioriginal : 1;
  1728. }
  1729. // END: Complexity Estimation syntax support
  1731. Void CVideoObjectEncoder::updateAllOrigRefVOPs ()
  1732. {
  1733. assert (m_vopmd.vopPredType != BVOP||(
  1734. m_vopmd.vopPredType == BVOP && m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 0));
  1735. swapVOPU8Pointers (m_pvopcOrig, m_pvopcRefOrig1);
  1736. m_pvopcRefOrig1->setBoundRct (m_rctRefVOPY1);
  1737. m_pvopcOrig->setBoundRct (m_rctCurrVOPY);
  1738. repeatPadYOrA ((PixelC*) m_pvopcRefOrig1->pixelsY () + m_iOffsetForPadY, m_pvopcRefOrig1);
  1739. }
  1741. Void CVideoObjectEncoder::copyCurrToRefOrig1Y ()
  1742. {
  1743. m_pvopcRefOrig0->setAndExpandBoundRctOnly (m_pvopcOrig->whereBoundY (), EXPANDY_REFVOP); // will adjust the starting pixel pointer too
  1744. const PixelC* ppxlcOrigY = m_pvopcOrig->pixelsBoundY ();
  1745. PixelC* ppxlcRefOrig0Y = (PixelC*) m_pvopcRefOrig0->pixelsBoundY ();
  1746. for (CoordI y = 0; y < m_pvopcOrig->whereBoundY ().height (); y++) {
  1747. memcpy (ppxlcRefOrig0Y, ppxlcOrigY, m_pvopcOrig->whereBoundY ().width*sizeof(PixelC)); // NBIT: add sizeof(PixelC)
  1748. ppxlcOrigY += m_pvopcOrig->whereBoundY ().width;
  1749. ppxlcRefOrig0Y += m_pvopcRefOrig0->whereBoundY ().width;
  1750. }
  1751. }
  1753. Void CVideoObjectEncoder::findTightBoundingBox ()
  1754. {
  1755. const CRct& rctOrig = m_pvopcOrig->whereY ();
  1756. CoordI left = rctOrig.right - 1;
  1757. CoordI top = rctOrig.bottom - 1;
  1758. CoordI right = rctOrig.left;
  1759. CoordI bottom = rctOrig.top;
  1760. const PixelC* ppxlcBY = m_pvopcOrig->pixelsBY ();
  1761. for (CoordI y = rctOrig.top; y < rctOrig.bottom; y++) {
  1762. for (CoordI x = rctOrig.left; x < rctOrig.right; x++) {
  1763. if (*ppxlcBY != transpValue) {
  1764. left = min (left, x);
  1765. top = min (top, y);
  1766. right = max (right, x);
  1767. bottom = max (bottom, y);
  1768. }
  1769. ppxlcBY++;
  1770. }
  1771. }
  1772. right++;
  1773. bottom++;
  1774. if (left % 2 != 0)
  1775. left--;
  1776. if (top % 2 != 0)
  1777. top--;
  1778. m_pvopcOrig->setBoundRct (CRct (left, top, right, bottom));
  1779. }
  1781. Void CVideoObjectEncoder::findBestBoundingBox ()
  1782. {
  1783. CoordI iLeftCurr   = m_pvopcOrig->whereBoundY ().left;
  1784. CoordI iTopCurr    = m_pvopcOrig->whereBoundY ().top;
  1785. // Added for Chroma Subsampling by Hyundai(1998-5-9)
  1786.         if (m_vopmd.bInterlace) iTopCurr -= iTopCurr%4;
  1787. // End of Hyundai(1998-5-9)
  1788. CoordI iRightCurr  = m_pvopcOrig->whereBoundY ().right;
  1789. CoordI iBottomCurr = m_pvopcOrig->whereBoundY ().bottom;
  1790. CoordI iLeftMost   = max (iLeftCurr - MB_SIZE + 2, 0);
  1791. // Added for Chroma Subsampling by Hyundai(1998-5-9)
  1792.         Int iTopSkip = (m_vopmd.bInterlace) ? 4 : 2;
  1793. CoordI iTopMost = max (iTopCurr - MB_SIZE + iTopSkip, 0);
  1794. // End of Hyundai(1998-5-9)
  1795. // CoordI iTopMost = max (iTopCurr  - MB_SIZE + 2, 0); // delete by Hyundai //can't be negative
  1797. Int nNonTransparentMBMin = m_pvopcOrig->whereBoundY ().area (); //abitrary large number
  1798. Int iLeftOfBBox, iTopOfBBox; //control postions
  1799. Int iLeftBest = iLeftMost;
  1800. Int iTopBest  = iTopMost;
  1801. for (iLeftOfBBox = iLeftMost; iLeftOfBBox <= iLeftCurr; iLeftOfBBox += 2) {
  1802. // for (iTopOfBBox = iTopMost; iTopOfBBox <= iTopCurr; iTopOfBBox += 2) { // delete by Hyundai
  1803. // Added for Chroma Subsampling by Hyundai(1998-5-9)
  1804. for (iTopOfBBox = iTopMost; iTopOfBBox <= iTopCurr; iTopOfBBox += iTopSkip) {
  1805. // End of Hyundai(1998-5-9)
  1806. // counting for each control position
  1807. const PixelC* ppxlcBYMBRow = m_pvopcOrig->getPlane(BY_PLANE)->pixels (iLeftOfBBox, iTopOfBBox);
  1808. Int nNonTransparentMB = 0;
  1809. Bool bKeepCounting = TRUE;
  1810. Int iLeftOfMB, iTopOfMB;
  1811. for (iTopOfMB = iTopOfBBox; iTopOfMB < iBottomCurr; iTopOfMB += MB_SIZE) {
  1812. const PixelC* ppxlcBYMB = ppxlcBYMBRow;
  1813. for (iLeftOfMB = iLeftOfBBox; iLeftOfMB < iRightCurr; iLeftOfMB += MB_SIZE) {
  1814. const PixelC* ppxlcBY = ppxlcBYMB;
  1815. UInt nOpaquePixel = 0;
  1816. for (UInt iY = 0; iY < MB_SIZE; iY++) {
  1817. for (UInt iX = 0; iX < MB_SIZE; iX++) {
  1818. nOpaquePixel += *ppxlcBY++;
  1819. }
  1820. ppxlcBY += m_iFrameWidthY - MB_SIZE;
  1821. }
  1822. if (nOpaquePixel != 0)
  1823. nNonTransparentMB++;
  1824. if (nNonTransparentMB > nNonTransparentMBMin) {
  1825. bKeepCounting = FALSE;
  1826. break;
  1827. }
  1828. ppxlcBYMB += MB_SIZE;
  1829. }
  1830. if (!bKeepCounting)
  1831. break;
  1832. ppxlcBYMBRow += m_iFrameWidthYxMBSize;
  1833. }
  1834. if (nNonTransparentMB <= nNonTransparentMBMin) {
  1835. nNonTransparentMBMin = nNonTransparentMB;
  1836. iLeftBest = iLeftOfBBox;
  1837. iTopBest = iTopOfBBox;
  1838. }
  1839. }
  1840. }
  1841. m_pvopcOrig->setBoundRct (CRct (
  1842. iLeftBest, 
  1843. iTopBest, 
  1844. iLeftBest + ((iRightCurr - iLeftBest - 1) / MB_SIZE + 1) * MB_SIZE, 
  1845. iTopBest  + ((iBottomCurr - iTopBest - 1) / MB_SIZE + 1) * MB_SIZE
  1846. ));
  1847. }
  1849. Void CVideoObjectEncoder::computeSNRs (const CVOPU8YUVBA* pvopcCurrQ)
  1850. {
  1851. if (m_volmd.fAUsage == RECTANGLE) {
  1852. SNRYorA (m_pvopcOrig->pixelsBoundY (), pvopcCurrQ->pixelsY () + m_iStartInRefToCurrRctY, m_rgdSNR [0]);
  1853. SNRUV (pvopcCurrQ);
  1854. }
  1855. else {
  1856. SNRYorAWithShape (m_pvopcOrig->pixelsBoundY (), pvopcCurrQ->pixelsY () + m_iStartInRefToCurrRctY, m_rgdSNR [0]);
  1857. SNRUVWithShape (pvopcCurrQ);
  1858. if (m_volmd.fAUsage == EIGHT_BIT)
  1859. SNRYorAWithShape (m_pvopcOrig->pixelsBoundA (), pvopcCurrQ->pixelsA () + m_iStartInRefToCurrRctY, m_rgdSNR [3]);
  1860. }
  1861. }
  1863. Void CVideoObjectEncoder::SNRYorA (
  1864. const PixelC* ppxlcOrig, const PixelC* ppxlcRef1, // these two should point to the left-top of the rctOrig's bounding box 
  1865. Double& dSNR
  1866. )
  1867. {
  1868. CoordI x, y;
  1869. Int iSqrDiff = 0;
  1870. Double dMaxVal = (Double) ((1<<m_volmd.nBits)-1); // NBIT
  1871. for (y = 0; y < m_pvopcOrig->whereBoundY ().height (); y++) {
  1872. for (x = 0; x < m_pvopcOrig->whereBoundY ().width; x++) {
  1873. Int iDiff = ppxlcOrig [x] - ppxlcRef1 [x];
  1874. iSqrDiff += iDiff * iDiff;
  1875. }
  1876. ppxlcOrig += m_pvopcOrig->whereY ().width;
  1877. ppxlcRef1 += m_pvopcRefQ1->whereY ().width;
  1878. }
  1879. if (iSqrDiff == 0) 
  1880. dSNR = 1000000.0;
  1881. else
  1882. /* NBIT: change 255.0 to dMaxVal
  1883. dSNR = (log10 ((255.0 * 255.0 * m_pvopcOrig->whereBoundY ().area ()) / (Double) iSqrDiff) * 10.0);
  1884. */
  1885. dSNR = (log10 ((dMaxVal * dMaxVal * m_pvopcOrig->whereBoundY ().area ()) / (Double) iSqrDiff) * 10.0);
  1886. }
  1888. Void CVideoObjectEncoder::SNRUV (const CVOPU8YUVBA* pvopcCurrQ)
  1889. {
  1890. CoordI x, y;
  1891. Int iSqrDiffU = 0, iSqrDiffV = 0, iDiff;
  1892. Double dMaxVal = (Double) ((1<<m_volmd.nBits)-1); // NBIT
  1893. const PixelC* ppxlcOrigU = m_pvopcOrig->pixelsBoundU (); 
  1894. const PixelC* ppxlcOrigV = m_pvopcOrig->pixelsBoundV (); 
  1895. const PixelC* ppxlcRef1U = pvopcCurrQ->pixelsU () + m_iStartInRefToCurrRctUV;
  1896. const PixelC* ppxlcRef1V = pvopcCurrQ->pixelsV () + m_iStartInRefToCurrRctUV;
  1897. for (y = 0; y < m_pvopcOrig->whereBoundUV ().height (); y++) {
  1898. for (x = 0; x < m_pvopcOrig->whereBoundUV ().width; x++) {
  1899. iDiff = ppxlcOrigU [x] - ppxlcRef1U [x];
  1900. iSqrDiffU += iDiff * iDiff;
  1901. iDiff = ppxlcOrigV [x] - ppxlcRef1V [x];
  1902. iSqrDiffV += iDiff * iDiff;
  1903. }
  1904. ppxlcOrigU += m_pvopcOrig->whereUV ().width;
  1905. ppxlcRef1U += m_pvopcRefQ1->whereUV ().width;
  1907. ppxlcOrigV += m_pvopcOrig->whereUV ().width;
  1908. ppxlcRef1V += m_pvopcRefQ1->whereUV ().width;
  1909. }
  1910. if (iSqrDiffU == 0) 
  1911. m_rgdSNR [1] = 1000000.0;
  1912. else
  1913. /* NBIT: change 255.0 to dMaxVal
  1914. m_rgdSNR [1] = (log10 ((Double) (255.0 * 255.0 * m_pvopcOrig->whereBoundUV ().area ()) / (Double) iSqrDiffU) * 10.0);
  1915. */
  1916. m_rgdSNR [1] = (log10 ((Double) (dMaxVal * dMaxVal * m_pvopcOrig->whereBoundUV ().area ()) / (Double) iSqrDiffU) * 10.0);
  1918. if (iSqrDiffV == 0) 
  1919. m_rgdSNR [2] = 1000000.0;
  1920. else
  1921. /* NBIT: change 255.0 to dMaxVal
  1922. m_rgdSNR [2] = (log10 ((Double) (255.0 * 255.0 * m_pvopcOrig->whereBoundUV ().area ()) / (Double) iSqrDiffV) * 10.0);
  1923. */
  1924. m_rgdSNR [2] = (log10 ((Double) (dMaxVal * dMaxVal * m_pvopcOrig->whereBoundUV ().area ()) / (Double) iSqrDiffV) * 10.0);
  1925. }
  1927. Void CVideoObjectEncoder::SNRYorAWithShape (
  1928. const PixelC* ppxlcOrig, const PixelC* ppxlcRef1, // these two should point to the left-top of the rctOrig's bounding box 
  1929. Double& dSNR
  1930. )
  1931. {
  1932. CoordI x, y;
  1933. Int iSqrDiff = 0, iNumNonTransp = 0;
  1934. Double dMaxVal = (Double) ((1<<m_volmd.nBits)-1); // NBIT
  1935. const PixelC* ppxlcOrigBY = m_pvopcOrig->pixelsBoundBY ();
  1936. for (y = 0; y < m_pvopcOrig->whereBoundY ().height (); y++) {
  1937. for (x = 0; x < m_pvopcOrig->whereBoundY ().width; x++) {
  1938. if (ppxlcOrigBY [x] != transpValue) {
  1939. Int iDiff = ppxlcOrig [x] - ppxlcRef1 [x];
  1940. iSqrDiff += iDiff * iDiff;
  1941. iNumNonTransp++;
  1942. }
  1943. }
  1944. ppxlcOrig += m_pvopcOrig->whereY ().width;
  1945. ppxlcOrigBY += m_pvopcOrig->whereY ().width;
  1946. ppxlcRef1 += m_pvopcRefQ1->whereY ().width;
  1947. }
  1948. if (iSqrDiff == 0) 
  1949. dSNR = 1000000.0;
  1950. else
  1951. /* NBIT: change 255.0 to dMaxVal
  1952. dSNR = (log10 ((Double) (255.0 * 255.0 * iNumNonTransp) / (Double) iSqrDiff) * 10.0);
  1953. */
  1954. dSNR = (log10 ((Double) (dMaxVal * dMaxVal * iNumNonTransp) / (Double) iSqrDiff) * 10.0);
  1955. }
  1957. Void CVideoObjectEncoder::SNRUVWithShape (const CVOPU8YUVBA* pvopcCurrQ)
  1958. {
  1959. CoordI x, y;
  1960. Int iSqrDiffU = 0, iSqrDiffV = 0, iNumNonTransp = 0, iDiff;
  1961. Double dMaxVal = (Double) ((1<<m_volmd.nBits)-1); // NBIT
  1962. const PixelC* ppxlcOrigU = m_pvopcOrig->pixelsBoundU (); 
  1963. const PixelC* ppxlcOrigV = m_pvopcOrig->pixelsBoundV (); 
  1964. const PixelC* ppxlcRef1U = pvopcCurrQ->pixelsU () + m_iStartInRefToCurrRctUV;
  1965. const PixelC* ppxlcRef1V = pvopcCurrQ->pixelsV () + m_iStartInRefToCurrRctUV;
  1966. const PixelC* ppxlcOrigBUV = m_pvopcOrig->pixelsBoundBUV ();
  1967. for (y = 0; y < m_pvopcOrig->whereBoundUV ().height (); y++) {
  1968. for (x = 0; x < m_pvopcOrig->whereBoundUV ().width; x++) {
  1969. if (ppxlcOrigBUV [x] != transpValue) {
  1970. iDiff = ppxlcOrigU [x] - ppxlcRef1U [x];
  1971. iSqrDiffU += iDiff * iDiff;
  1972. iDiff = ppxlcOrigV [x] - ppxlcRef1V [x];
  1973. iSqrDiffV += iDiff * iDiff;
  1974. iNumNonTransp++;
  1975. }
  1976. }
  1977. ppxlcOrigBUV += m_pvopcOrig->whereUV ().width;
  1978. ppxlcOrigU += m_pvopcOrig->whereUV ().width;
  1979. ppxlcRef1U += m_pvopcRefQ1->whereUV ().width;
  1981. ppxlcOrigV += m_pvopcOrig->whereUV ().width;
  1982. ppxlcRef1V += m_pvopcRefQ1->whereUV ().width;
  1983. }
  1984. if (iSqrDiffU == 0) 
  1985. m_rgdSNR [1] = 1000000.0;
  1986. else
  1987. /* NBIT: change 255.0 to dMaxVal
  1988. m_rgdSNR [1] = (log10 ((Double) (255.0 * 255.0 * iNumNonTransp) / (Double) iSqrDiffU) * 10.0);
  1989. */
  1990. m_rgdSNR [1] = (log10 ((Double) (dMaxVal * dMaxVal * iNumNonTransp) / (Double) iSqrDiffU) * 10.0);
  1992. if (iSqrDiffV == 0) 
  1993. m_rgdSNR [2] = 1000000.0;
  1994. else
  1995. /* NBIT: change 255.0 to dMaxVal
  1996. m_rgdSNR [2] = (log10 ((Double) (255.0 * 255.0 * iNumNonTransp) / (Double) iSqrDiffV) * 10.0);
  1997. */
  1998. m_rgdSNR [2] = (log10 ((Double) (dMaxVal * dMaxVal * iNumNonTransp) / (Double) iSqrDiffV) * 10.0);
  1999. }
  2001. Void CVideoObjectEncoder::biInterpolateY (
  2002. const CVOPU8YUVBA* pvopcRefQ, const CRct& rctRefVOP,
  2003. CU8Image* puciRefQZoom, const CRct& rctRefVOPZoom, Int iRoundingControl
  2004. )
  2005. {
  2006. const PixelC* ppxliOrg = pvopcRefQ->pixelsBoundY ();
  2007. const PixelC* ppxliOrgBot;
  2008. PixelC* ppxliZoom = (PixelC*) puciRefQZoom->pixels (rctRefVOPZoom.left, rctRefVOPZoom.top);
  2009. PixelC* ppxliZoomBot;
  2010. ppxliOrgBot = ppxliOrg + m_iFrameWidthY;
  2011. ppxliZoomBot = ppxliZoom + m_iFrameWidthZoomY;
  2012. Int iHeightPrevMinus1 = rctRefVOP.height () - 1;
  2013. Int iWidthPrevMinus1 = rctRefVOP.width - 1;
  2014. CoordI x, y;
  2015. for (y = 0; y < iHeightPrevMinus1; y++) {
  2016. const PixelC* ppxliOrgRow = ppxliOrg;
  2017. const PixelC* ppxliOrgBotRow = ppxliOrgBot;
  2018. PixelC* ppxliZoomRow = ppxliZoom;
  2019. PixelC* ppxliZoomBotRow = ppxliZoomBot;
  2020. for (x = 0; x < iWidthPrevMinus1; x++, ppxliZoomRow += 2, ppxliZoomBotRow += 2) {
  2021. *ppxliZoomRow = *ppxliOrgRow;
  2022. *(ppxliZoomRow + 1) = (*ppxliOrgRow + *(ppxliOrgRow + 1) + 1 - iRoundingControl) >> 1;
  2023. *ppxliZoomBotRow = (*ppxliOrgRow + *ppxliOrgBotRow + 1 - iRoundingControl) >> 1;
  2024. *(ppxliZoomBotRow + 1) = 
  2025. (*ppxliOrgRow + *ppxliOrgBotRow + 
  2026. *(ppxliOrgRow++ + 1) + *(ppxliOrgBotRow++ + 1) + 2 - iRoundingControl
  2027. ) >> 2;
  2029. }
  2030. *ppxliZoomRow = *(ppxliZoomRow + 1) = *ppxliOrgRow;
  2031. *ppxliZoomBotRow = *(ppxliZoomBotRow + 1) = (*ppxliOrgRow++ + *ppxliOrgBotRow++ + 1 - iRoundingControl) / 2; // the last pixels of every row do not need average
  2033. ppxliOrg += m_iFrameWidthY;
  2034. ppxliOrgBot += m_iFrameWidthY;
  2035. ppxliZoom += m_iFrameWidthZoomY * 2;
  2036. ppxliZoomBot += m_iFrameWidthZoomY * 2;
  2037. }
  2038. PixelC* ppxliZoomLastLnToSec = ppxliZoom;
  2039. for (x = 0; x < iWidthPrevMinus1; x++, ppxliZoomLastLnToSec += 2) {
  2040. *ppxliZoomLastLnToSec = *ppxliOrg;
  2041. *(ppxliZoomLastLnToSec + 1) = (*ppxliOrg + *(ppxliOrg++ + 1) + 1 - iRoundingControl) >> 1;
  2042. }
  2043. *ppxliZoomLastLnToSec = *(ppxliZoomLastLnToSec + 1) = *ppxliOrg;
  2044. // NBIT: add sizeof(PixelC)
  2045. memcpy (ppxliZoomBot, ppxliZoom, rctRefVOPZoom.width*sizeof(PixelC));
  2046. }
  2048. Void CVideoObjectEncoder::swapSpatialScalabilityBVOP () //for Rectangular shape only
  2049. {
  2050. if (m_volmd.volType == BASE_LAYER ||
  2051.     !(m_volmd.volType == ENHN_LAYER && m_vopmd.vopPredType == BVOP && m_vopmd.iRefSelectCode == 0))
  2052. return;
  2053. swapVOPU8Pointers(m_pvopcCurrQ,m_pvopcRefQ1);
  2054. repeatPadYOrA ((PixelC*) m_pvopcRefQ1->pixelsY () + m_iOffsetForPadY, m_pvopcRefQ1);
  2055. repeatPadUV (m_pvopcRefQ1);
  2056. }
  2058. // begin: added by Sharp (98/2/10)
  2059. Void CVideoObjectEncoder::setPredType(VOPpredType vopPredType)
  2060. {
  2061. m_vopmd.vopPredType = vopPredType;
  2062. }
  2064. Void CVideoObjectEncoder::setRefSelectCode(Int refSelectCode)
  2065. {
  2066. m_vopmd.iRefSelectCode = refSelectCode;
  2067. }
  2069. /******************************************
  2070. *** class CEnhcBufferEncoder ***
  2071. ******************************************/
  2072. CEnhcBufferEncoder::CEnhcBufferEncoder (Int iSessionWidth, Int iSessionHeight)
  2073. : CEnhcBuffer (iSessionWidth, iSessionHeight)
  2074. {
  2075. }
  2077. Void CEnhcBufferEncoder::copyBuf (const CEnhcBufferEncoder& srcBuf)
  2078. {
  2079. m_iNumMBRef = srcBuf.m_iNumMBRef;
  2080. m_iNumMBXRef = srcBuf.m_iNumMBXRef;
  2081. m_iNumMBYRef = srcBuf.m_iNumMBYRef;
  2082. m_iOffsetForPadY = srcBuf.m_iOffsetForPadY;
  2083. m_iOffsetForPadUV = srcBuf.m_iOffsetForPadUV;
  2084. m_rctPrevNoExpandY = srcBuf.m_rctPrevNoExpandY;
  2085. m_rctPrevNoExpandUV = srcBuf.m_rctPrevNoExpandUV;
  2087. m_rctRefVOPY0 = srcBuf.m_rctRefVOPY0;
  2088. m_rctRefVOPUV0 = srcBuf.m_rctRefVOPUV0;
  2089. m_rctRefVOPY1 = srcBuf.m_rctRefVOPY1;
  2090. m_rctRefVOPUV1 = srcBuf.m_rctRefVOPUV1;
  2091. m_rctRefVOPZoom = srcBuf.m_rctRefVOPZoom; // 9/26 by Norio
  2092. m_bCodedFutureRef = srcBuf.m_bCodedFutureRef; // added by Sharp (99/1/26)
  2094. CMBMode* pmbmdRefSrc = srcBuf.m_rgmbmdRef;
  2095. CMBMode* pmbmdRef    = m_rgmbmdRef;
  2096. CMotionVector* pmvRefSrc = srcBuf.m_rgmvRef;
  2097. CMotionVector* pmvRef = m_rgmvRef;
  2099. // TPS FIX
  2100. Int iMaxIndex = max(PVOP_MV_PER_REF_PER_MB, 2*BVOP_MV_PER_REF_PER_MB);
  2102. for (Int iMB=0; iMB<m_iNumMBRef; iMB++){
  2103. *pmbmdRef = *pmbmdRefSrc;
  2104. pmbmdRef++;
  2105. pmbmdRefSrc++;
  2107. // TPS FIX
  2108. for (Int iVecIndex=0; iVecIndex<iMaxIndex; iVecIndex++ ){
  2109. *pmvRef = *pmvRefSrc;
  2110. pmvRef++;
  2111. pmvRefSrc++;
  2112. }
  2113. }
  2115. CVOPU8YUVBA* pvop = srcBuf.m_pvopcBuf;
  2116. delete m_pvopcBuf;
  2117. m_pvopcBuf = NULL;
  2118. m_pvopcBuf = new CVOPU8YUVBA( *pvop );
  2120. m_t = srcBuf.m_t;
  2121. }
  2123. Void CEnhcBufferEncoder::getBuf(const CVideoObjectEncoder* pvopc)  // get params from Base layer
  2124. {
  2125. // assert(pvopc->m_volmd.volType == BASE_LAYER);
  2126. CMBMode* pmbmdRef;
  2127. CMBMode* pmbmdRefSrc;
  2128. CMotionVector* pmvRef;
  2129. CMotionVector* pmvRefSrc;
  2131. m_bCodedFutureRef = pvopc->m_bCodedFutureRef; // added by Sharp (99/1/26)
  2132. if ( pvopc->m_vopmd.vopPredType != BVOP ){
  2133. pmbmdRef = m_rgmbmdRef;
  2134. pmbmdRefSrc = pvopc->m_rgmbmdRef;
  2135. pmvRef = m_rgmvRef;
  2136. pmvRefSrc = pvopc->m_rgmvRef;
  2137. // This part is stored in CVideoObjectEncoder::encode()
  2138. m_iNumMBRef = pvopc->m_iNumMBRef;
  2139. m_iNumMBXRef = pvopc->m_iNumMBXRef;
  2140. m_iNumMBYRef = pvopc->m_iNumMBYRef;
  2141. } else {
  2142. pmbmdRef = m_rgmbmdRef;
  2143. pmbmdRefSrc = pvopc->m_rgmbmd;
  2144. pmvRef = m_rgmvRef;
  2145. pmvRefSrc = pvopc->m_rgmv;
  2146. m_iNumMBRef = pvopc->m_iNumMB;
  2147. m_iNumMBXRef = pvopc->m_iNumMBX;
  2148. m_iNumMBYRef = pvopc->m_iNumMBY;
  2149. }
  2151. // TPS FIX
  2152. Int iMaxIndex = max(PVOP_MV_PER_REF_PER_MB, 2*BVOP_MV_PER_REF_PER_MB);
  2154. for (Int iMB=0; iMB<m_iNumMBRef; iMB++ ) {
  2155. *pmbmdRef = *pmbmdRefSrc;
  2156. pmbmdRef++;
  2157. pmbmdRefSrc++;
  2159. // TPS FIX
  2160. for (Int iVecIndex=0; iVecIndex<iMaxIndex; iVecIndex++ ){
  2161. *pmvRef = *pmvRefSrc;
  2162. pmvRef++;
  2163. pmvRefSrc++;
  2164. }
  2165. }
  2167. m_t = pvopc->m_t;
  2168. delete m_pvopcBuf;
  2169. m_pvopcBuf = NULL;
  2170. m_pvopcBuf = new CVOPU8YUVBA( *(pvopc->pvopcReconCurr()) );
  2171. if ( pvopc->m_vopmd.vopPredType != BVOP ) {
  2172. m_iOffsetForPadY = pvopc->m_iOffsetForPadY;
  2173. m_iOffsetForPadUV = pvopc->m_iOffsetForPadUV;
  2174. m_rctPrevNoExpandY = pvopc->m_rctPrevNoExpandY;
  2175. m_rctPrevNoExpandUV = pvopc->m_rctPrevNoExpandUV;
  2176. m_rctRefVOPY1 = pvopc->m_rctRefVOPY1;
  2177. m_rctRefVOPUV1 = pvopc->m_rctRefVOPUV1;
  2178. }
  2179. else {
  2180. m_iOffsetForPadY = pvopc->m_iBVOPOffsetForPadY;
  2181. m_iOffsetForPadUV = pvopc->m_iBVOPOffsetForPadUV;
  2182. m_rctPrevNoExpandY = pvopc->m_rctBVOPPrevNoExpandY;
  2183. m_rctPrevNoExpandUV = pvopc->m_rctBVOPPrevNoExpandUV;
  2184. m_rctRefVOPY1 = pvopc->m_rctBVOPRefVOPY1;
  2185. m_rctRefVOPUV1 = pvopc->m_rctBVOPRefVOPUV1;
  2186. }
  2187. }
  2189. Void CEnhcBufferEncoder::putBufToQ0(CVideoObjectEncoder* pvopc)  // store params to Enhancement layer pvopcRefQ0
  2190. {
  2191. assert(pvopc->m_volmd.volType == ENHN_LAYER);
  2193. delete pvopc->m_pvopcRefQ0;
  2194. pvopc->m_pvopcRefQ0 = NULL;
  2195. pvopc->m_pvopcRefQ0 = new CVOPU8YUVBA ( *m_pvopcBuf );
  2196. pvopc->m_tPastRef = m_t;
  2198. pvopc->m_bCodedFutureRef = m_bCodedFutureRef; // added by Sharp (99/1/26)
  2199. if ( pvopc->m_volmd.iEnhnType != 0  && //modified by Sharp (98/3/24)
  2200. (((pvopc->m_vopmd.iRefSelectCode == 1 || pvopc->m_vopmd.iRefSelectCode == 2) && pvopc->m_vopmd.vopPredType == PVOP) ||
  2201.  (pvopc->m_vopmd.iRefSelectCode == 3 && pvopc->m_vopmd.vopPredType == BVOP))
  2202. )
  2203. // if ( pvopc->m_volmd.iEnhnType == 1 )
  2204. {
  2205. CRct rctRefFrameYTemp = pvopc->m_rctRefFrameY;
  2206. CRct rctRefFrameUVTemp = pvopc->m_rctRefFrameUV;
  2207. rctRefFrameYTemp.expand(-EXPANDY_REF_FRAME);
  2208. rctRefFrameUVTemp.expand(-EXPANDY_REF_FRAME/2);
  2209. pvopc->m_pvopcRefQ0->addBYPlain(rctRefFrameYTemp, rctRefFrameUVTemp);
  2210. }
  2212. CMBMode* pmbmdRefSrc = m_rgmbmdRef;
  2213. CMBMode* pmbmdRef = pvopc->m_rgmbmdRef;
  2214. CMotionVector* pmvRefSrc = m_rgmvRef;
  2215. CMotionVector* pmvRef = pvopc->m_rgmvRef;
  2217. // This part is stored in CVideoObjectEncoder::encode()
  2218. pvopc->m_iNumMBRef = m_iNumMBRef;
  2219. pvopc->m_iNumMBXRef = m_iNumMBXRef;
  2220. pvopc->m_iNumMBYRef = m_iNumMBYRef;
  2222. // TPS FIX
  2223. Int iMaxIndex = max(PVOP_MV_PER_REF_PER_MB, 2*BVOP_MV_PER_REF_PER_MB);
  2225. for (Int iMB=0; iMB<m_iNumMBRef; iMB++ ) {
  2226. *pmbmdRef = *pmbmdRefSrc;
  2228. if ( pvopc->m_volmd.iEnhnType != 0  && // modified by Sharp (98/3/24)
  2229. (((pvopc->m_vopmd.iRefSelectCode == 1 || pvopc->m_vopmd.iRefSelectCode == 2) && pvopc->m_vopmd.vopPredType == PVOP) ||
  2230.  (pvopc->m_vopmd.iRefSelectCode == 3 && pvopc->m_vopmd.vopPredType == BVOP))
  2231. ) {
  2232. pmbmdRef->m_shpmd = ALL_OPAQUE;
  2233. }
  2234. pmbmdRef++;
  2235. pmbmdRefSrc++;
  2237. // TPS FIX
  2238. for (Int iVecIndex=0; iVecIndex<iMaxIndex; iVecIndex++ ){
  2239. *pmvRef = *pmvRefSrc;
  2240. pmvRef ++;
  2241. pmvRefSrc ++;
  2242. }
  2243. }
  2244. pvopc->saveShapeMode ();
  2246. // for padding operation
  2247. pvopc->m_iOffsetForPadY = m_iOffsetForPadY;
  2248. pvopc->m_iOffsetForPadUV = m_iOffsetForPadUV;
  2249. pvopc->m_rctPrevNoExpandY = m_rctPrevNoExpandY;
  2250. pvopc->m_rctPrevNoExpandUV = m_rctPrevNoExpandUV;
  2252. // This part is needed for storing RefQ0
  2253. pvopc->m_rctRefVOPY0 = m_rctRefVOPY1;
  2254. pvopc->m_rctRefVOPUV0 = m_rctRefVOPUV1;
  2256. pvopc->m_pvopcRefQ0->setBoundRct(m_rctRefVOPY1);
  2258. pvopc->repeatPadYOrA ((PixelC*) pvopc->m_pvopcRefQ0->pixelsY () + m_iOffsetForPadY, pvopc->m_pvopcRefQ0);
  2259. pvopc->repeatPadUV(pvopc->m_pvopcRefQ0);
  2260. if ( pvopc->m_volmd.fAUsage != RECTANGLE ){
  2261. if ( pvopc->m_volmd.fAUsage == EIGHT_BIT )
  2262. pvopc->repeatPadYOrA ((PixelC*) pvopc->m_pvopcRefQ0->pixelsA () + m_iOffsetForPadY, pvopc->m_pvopcRefQ0);
  2263. }
  2264. }
  2266. Void CEnhcBufferEncoder::putBufToQ1(CVideoObjectEncoder* pvopc)  // store params to Enhancement layer pvopcRefQ1
  2267. {
  2268. assert(pvopc->m_volmd.volType == ENHN_LAYER);
  2270. delete pvopc->m_pvopcRefQ1;
  2271. pvopc->m_pvopcRefQ1 = NULL;
  2272. pvopc->m_pvopcRefQ1 = new CVOPU8YUVBA ( *m_pvopcBuf );
  2273. pvopc->m_tFutureRef = m_t;
  2274. pvopc->m_bCodedFutureRef = m_bCodedFutureRef; // added by Sharp (99/1/26)
  2275. if ( pvopc->m_volmd.iEnhnType != 0  && // modified by Sharp (98/3/24)
  2276. (((pvopc->m_vopmd.iRefSelectCode == 1 || pvopc->m_vopmd.iRefSelectCode == 2) && pvopc->m_vopmd.vopPredType == PVOP) ||
  2277. ((pvopc->m_vopmd.iRefSelectCode == 1 || pvopc->m_vopmd.iRefSelectCode == 3) && pvopc->m_vopmd.vopPredType == BVOP)) // modified by Sharp (98/5/25)
  2278. )
  2279. // if ( pvopc->m_volmd.iEnhnType == 1 )
  2280. {
  2281. CRct rctRefFrameYTemp = pvopc->m_rctRefFrameY;
  2282. CRct rctRefFrameUVTemp = pvopc->m_rctRefFrameUV;
  2283. rctRefFrameYTemp.expand(-EXPANDY_REF_FRAME);
  2284. rctRefFrameUVTemp.expand(-EXPANDY_REF_FRAME/2);
  2285. pvopc->m_pvopcRefQ1->addBYPlain(rctRefFrameYTemp, rctRefFrameUVTemp);
  2286. }
  2288. // if ( pvopc->m_volmd.fAUsage != RECTANGLE ){
  2289. CMBMode* pmbmdRefSrc = m_rgmbmdRef;
  2290. CMBMode* pmbmdRef = pvopc->m_rgmbmdRef;
  2291. CMotionVector* pmvRefSrc = m_rgmvRef;
  2292. CMotionVector* pmvRef = pvopc->m_rgmvRef;
  2294. // This part is stored in CVideoObjectEncoder::encode()
  2295. pvopc->m_iNumMBRef = m_iNumMBRef;
  2296. pvopc->m_iNumMBXRef = m_iNumMBXRef;
  2297. pvopc->m_iNumMBYRef = m_iNumMBYRef;
  2299. // TPS FIX
  2300. Int iMaxIndex = max(PVOP_MV_PER_REF_PER_MB, 2*BVOP_MV_PER_REF_PER_MB);
  2302. for (Int iMB=0; iMB<m_iNumMBRef; iMB++ ) {
  2303. *pmbmdRef = *pmbmdRefSrc;
  2304. if ( pvopc->m_volmd.iEnhnType != 0 ) { // modified by Sharp (98/3/24)
  2305. pmbmdRef->m_shpmd = ALL_OPAQUE;
  2306. }
  2307. pmbmdRef++;
  2308. pmbmdRefSrc++;
  2309. // TPS FIX
  2310. for (Int iVecIndex=0; iVecIndex<iMaxIndex; iVecIndex++ ){
  2311. *pmvRef = *pmvRefSrc;
  2312. pmvRef ++;
  2313. pmvRefSrc++;
  2314. }
  2315. }
  2317. // for padding operation
  2318. pvopc->m_iOffsetForPadY = m_iOffsetForPadY;
  2319. pvopc->m_iOffsetForPadUV = m_iOffsetForPadUV;
  2320. pvopc->m_rctPrevNoExpandY = m_rctPrevNoExpandY;
  2321. pvopc->m_rctPrevNoExpandUV = m_rctPrevNoExpandUV;
  2323. // This part is needed for storing RefQ0
  2324. pvopc->m_rctRefVOPY1 = m_rctRefVOPY1;
  2325. pvopc->m_rctRefVOPUV1 = m_rctRefVOPUV1;
  2327. pvopc->m_pvopcRefQ1->setBoundRct(m_rctRefVOPY1);
  2328. // }
  2330. pvopc->repeatPadYOrA ((PixelC*) pvopc->m_pvopcRefQ1->pixelsY () + m_iOffsetForPadY, pvopc->m_pvopcRefQ1);
  2331. pvopc->repeatPadUV(pvopc->m_pvopcRefQ1);
  2332. if ( pvopc->m_volmd.fAUsage != RECTANGLE ){
  2333. if ( pvopc->m_volmd.fAUsage == EIGHT_BIT )
  2334. pvopc->repeatPadYOrA ((PixelC*) pvopc->m_pvopcRefQ1->pixelsA () + m_iOffsetForPadY, pvopc->m_pvopcRefQ1);
  2335. }
  2336. }
  2338. Void CVideoObjectEncoder::set_LoadShape(
  2339.     Int* ieFramebShape, Int* ieFramefShape, // frame number for back/forward shape
  2340.     const Int iRate,       // rate of base layer
  2341.     const Int ieFrame,       // current frame number
  2342.     const Int iFirstFrame,    // first frame number of sequence
  2343.     const Int iFirstFrameLoop // first frame number of the enhancement loop
  2344. )
  2345. {
  2346.   if(m_volmd.iEnhnType==0){
  2347.       m_vopmd.iLoadBakShape = 0;
  2348.       m_vopmd.iLoadForShape = 0; // do not care
  2349.       return;
  2350.   }
  2352.   if(ieFrame == iFirstFrameLoop){
  2353.     *ieFramefShape = ((ieFrame-iFirstFrame)/iRate)*iRate + iFirstFrame;
  2354.     *ieFramebShape = *ieFramefShape + iRate;
  2356. //    if(*ieFramefShape != iFirstFrame){
  2357.       m_vopmd.iLoadBakShape = 1;
  2358.       m_vopmd.iLoadForShape = 0;
  2359. // } else {
  2360. //      m_vopmd.iLoadBakShape = 1;
  2361. //      m_vopmd.iLoadForShape = 1;
  2362. // }
  2363.   }
  2364.   else{
  2365.       m_vopmd.iLoadBakShape = 0;
  2366.       m_vopmd.iLoadForShape = 0; // do not care
  2367.   }
  2368. }
  2370. Void CVideoObjectEncoder::BackgroundComposition(
  2371.     const Int width, Int height,
  2372.     const Int iFrame,   // current frame number
  2373.     const Int iPrev,   // previous base frame 
  2374.     const Int iNext,      // next     base frame 
  2375.     const CVOPU8YUVBA* pvopcBuffP1,
  2376.     const CVOPU8YUVBA* pvopcBuffP2,
  2377.     const CVOPU8YUVBA* pvopcBuffB1,
  2378.     const CVOPU8YUVBA* pvopcBuffB2,
  2379. const Char* pchReconYUVDir, Int iobj, const Char* pchPrefix, // for output file name // modified by Sharp (98/10/26)
  2380. FILE *pchfYUV  // added by Sharp (98/10/26)
  2381. )
  2382. {
  2383.     Void convertYuv(const CVOPU8YUVBA* pvopcSrc, PixelC* destY, PixelC* destU, PixelC* destV, Int width, Int height);
  2384.     Void convertSeg(const CVOPU8YUVBA* pvopcSrc, PixelC* destBY,PixelC* destBUV,              Int width, Int height,
  2385.     Int left, Int right, Int top, Int bottom
  2386.     );
  2387.     Void bg_comp_each(PixelC* curr, PixelC* prev, PixelC* next, PixelC* mask_curr, PixelC* mask_prev, PixelC* mask_next, 
  2388.       Int curr_t, Int prev_t, Int next_t, Int width, Int height, Int CoreMode); // modified by Sharp (98/3/24)
  2389.     Void inv_convertYuv(const CVOPU8YUVBA* pvopcSrc, PixelC* destY, PixelC* destU, PixelC* destV, Int width, Int height);
  2390.     Void write420_sep(Int num, char *name, PixelC* destY, PixelC* destU, PixelC* destV, Int width, Int height); // modified by Sharp (98/10/26)
  2391.     Void write420_jnt(FILE *pchfYUV, PixelC* destY, PixelC* destU, PixelC* destV, Int width, Int height); // added by Sharp (98/10/26)
  2392.     Void write_seg_test(Int num, char *name, PixelC* destY, Int width, Int height);
  2394.     PixelC* currY = new PixelC [width*height];
  2395.     PixelC* currU = new PixelC [width*height/4];
  2396.     PixelC* currV = new PixelC [width*height/4];
  2397.     PixelC* currBY  = new PixelC [width*height];
  2398.     PixelC* currBUV = new PixelC [width*height/4];
  2400.     PixelC* prevY = new PixelC [width*height];
  2401.     PixelC* prevU = new PixelC [width*height/4];
  2402.     PixelC* prevV = new PixelC [width*height/4];
  2403.     PixelC* prevBY  = new PixelC [width*height];
  2404.     PixelC* prevBUV = new PixelC [width*height/4];
  2406.     PixelC* nextY = new PixelC [width*height];
  2407.     PixelC* nextU = new PixelC [width*height/4];
  2408.     PixelC* nextV = new PixelC [width*height/4];
  2409.     PixelC* nextBY  = new PixelC [width*height];
  2410.     PixelC* nextBUV = new PixelC [width*height/4];
  2412.     // current frame
  2413.     convertYuv(pvopcReconCurr(), currY, currU, currV, width, height);
  2414.     if(pvopcReconCurr ()->pixelsBY () != NULL)
  2415.       convertSeg(pvopcReconCurr(), currBY, currBUV, width, height,
  2416.        m_rctCurrVOPY.left,
  2417.        m_rctCurrVOPY.right,
  2418.        m_rctCurrVOPY.top,
  2419.        m_rctCurrVOPY.bottom); /* forward shape */
  2421.     // previouse frame
  2422.     if(pvopcBuffB1 != NULL)
  2423.       convertYuv(pvopcBuffB1, prevY, prevU, prevV, width, height);
  2424.     else
  2425.       convertYuv(pvopcBuffP1, prevY, prevU, prevV, width, height);
  2426.     convertSeg(rgpbfShape [1]->pvopcReconCurr (), prevBY, prevBUV, width, height,
  2427.        rgpbfShape [1]->m_rctCurrVOPY.left,
  2428.        rgpbfShape [1]->m_rctCurrVOPY.right,
  2429.        rgpbfShape [1]->m_rctCurrVOPY.top,
  2430.        rgpbfShape [1]->m_rctCurrVOPY.bottom); /* forward shape */
  2432.  //   write_test(iPrev, "aaa", prevY, prevU, prevV, width, height);
  2433.  //   write_seg_test(iPrev, "aaa", prevBY, width, height);
  2435.     // next frame
  2436.     if(pvopcBuffB2 != NULL)
  2437.       convertYuv(pvopcBuffB2, nextY, nextU, nextV, width, height);
  2438.     else
  2439.       convertYuv(pvopcBuffP2, nextY, nextU, nextV, width, height);
  2440.     convertSeg(rgpbfShape [0]->pvopcReconCurr (), nextBY, nextBUV, width, height,
  2441.        rgpbfShape [0]->m_rctCurrVOPY.left,
  2442.        rgpbfShape [0]->m_rctCurrVOPY.right,
  2443.        rgpbfShape [0]->m_rctCurrVOPY.top,
  2444.        rgpbfShape [0]->m_rctCurrVOPY.bottom); /* backward shape */
  2446. //    write_test(iNext, "aaa", nextY, nextU, nextV, width, height);
  2447. //    write_seg_test(iNext, "aaa", nextBY, width, height);
  2449. // begin: modified by Sharp (98/3/24)
  2450.     bg_comp_each(currY, prevY, nextY, currBY,  prevBY,  nextBY,  iFrame, iPrev, iNext, width,   height, m_volmd.iEnhnType == 2);
  2451.     bg_comp_each(currU, prevU, nextU, currBUV, prevBUV, nextBUV, iFrame, iPrev, iNext, width/2, height/2, m_volmd.iEnhnType == 2);
  2452.     bg_comp_each(currV, prevV, nextV, currBUV, prevBUV, nextBUV, iFrame, iPrev, iNext, width/2, height/2, m_volmd.iEnhnType == 2);
  2453. // end: modified by Sharp (98/3/24)
  2455. //    inv_convertYuv(pvopcReconCurr(), currY, currU, currV, width, height);
  2457. #ifdef __OUT_ONE_FRAME_ // added by Sharp (98/10/26)
  2458. // write background compsition image
  2459. static Char pchYUV [100];
  2460. sprintf (pchYUV, "%s/%2.2d/%s.yuv", pchReconYUVDir, iobj, pchPrefix); // modified by Sharp (98/10/26)
  2461.     write420_sep(iFrame, pchYUV, currY, currU, currV, width, height); // modified by Sharp (98/10/26)
  2462. // begin: added by Sharp (98/9/27)
  2463. #else
  2464.     write420_jnt(pchfYUV, currY, currU, currV, width, height);
  2465. #endif
  2466. // end: added by Sharp (98/9/27)
  2468.     delete currY;
  2469.     delete currU;
  2470.     delete currV;
  2471.     delete currBY;
  2472.     delete currBUV;
  2474.     delete prevY;
  2475.     delete prevU;
  2476.     delete prevV;
  2477.     delete prevBY;
  2478.     delete prevBUV;
  2480.     delete nextY;
  2481.     delete nextU;
  2482.     delete nextV;
  2483.     delete nextBY;
  2484.     delete nextBUV;
  2485. }
  2486. // end: added by Sharp (98/2/10)