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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

vopmbenc.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. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  21. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  22. as specified by the MPEG-4 Video. 
  23. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  24. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  25. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
  26. The original developer of this software module and his/her company, 
  27. the subsequent editors and their companies, 
  28. and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
  29. Copyright is not released for non MPEG-4 Video conforming products. 
  30. Microsoft retains full right to use the code for his/her own purpose, 
  31. assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
  32. This copyright notice must be included in all copies or derivative works. 
  34. Copyright (c) 1996, 1997.
  37. Module Name:
  39. vopmbEnc.cpp
  41. Abstract:
  43. Encode MB's for each VOP (I-, P-, and B-VOP's)
  45. Revision History:
  46. Dec. 11, 1997: Interlaced tools added by NextLevel Systems (GI)
  47.                     B. Eifrig, (beifrig@nlvl.com) X. Chen, (xchen@nlvl.com)
  48.         May. 9   1998:  add boundary by Hyundai Electronics 
  49.                                   Cheol-Soo Park (cspark@super5.hyundai.co.kr) 
  50.         May. 9   1998:  add field based MC padding by Hyundai Electronics 
  51.                                   Cheol-Soo Park (cspark@super5.hyundai.co.kr) 
  52. May 9, 1999: tm5 rate control by DemoGraFX, duhoff@mediaone.net
  54. *************************************************************************/
  56. #include <stdio.h>
  57. #include <math.h>
  58. #include <stdlib.h>
  59. #include <iostream.h>
  61. #include "typeapi.h"
  62. #include "codehead.h"
  63. #include "entropy/bitstrm.hpp"
  64. #include "entropy/entropy.hpp"
  65. #include "entropy/huffman.hpp"
  66. #include "mode.hpp"
  67. #include "global.hpp"
  68. #include "vopses.hpp"
  69. #include "vopseenc.hpp"
  71. #ifdef __MFC_
  72. #ifdef _DEBUG
  73. #undef THIS_FILE
  74. static char BASED_CODE THIS_FILE[] = __FILE__;
  75. #endif
  77. #define new DEBUG_NEW    
  78. #endif // __MFC_
  81. Void CVideoObjectEncoder::encodeVOP ()
  82. {
  84. if (m_uiRateControl>=RC_TM5) {
  85. m_tm5rc.tm5rc_init_pict(m_vopmd.vopPredType,
  86. m_pvopcOrig->pixelsBoundY (),
  87. m_iFrameWidthY,
  88. m_iNumMBX,
  89. m_iNumMBY);
  90. }
  92. // Added for Data Partitioning mode by Toshiba(1998-1-16)
  93. if( m_volmd.bDataPartitioning ) {
  94. if (m_volmd.fAUsage == RECTANGLE) {
  95. switch( m_vopmd.vopPredType ) {
  96. case PVOP:
  97. encodeNSForPVOP_DP ();
  98. break;
  99. case IVOP:
  100. encodeNSForIVOP_DP ();
  101. break;
  102. case BVOP:
  103. encodeNSForBVOP ();
  104. break;
  105. default:
  106. assert(FALSE); // B-VOP and Sprite-VOP are not supported in DP-mode
  107. }
  108. } else {
  109. switch( m_vopmd.vopPredType ) {
  110. case PVOP:
  111. encodeNSForPVOP_WithShape_DP ();
  112. break;
  113. case IVOP:
  114. encodeNSForIVOP_WithShape_DP ();
  115. break;
  116. case BVOP:
  117. encodeNSForBVOP_WithShape ();
  118. break;
  119. default:
  120. assert(FALSE); // B-VOP and Sprite-VOP are not supported in DP-mode
  121. }
  122. }
  123. } else
  124. // End Toshiba(1998-1-16)
  125. if (m_volmd.fAUsage == RECTANGLE) {
  126. if (m_vopmd.vopPredType == PVOP)
  127. encodeNSForPVOP ();
  128. else if (m_vopmd.vopPredType == IVOP)
  129. encodeNSForIVOP ();
  130. else
  131. encodeNSForBVOP ();
  132. }
  133. else {
  134. if (m_vopmd.vopPredType == PVOP) {
  135. if (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE && m_vopmd.SpriteXmitMode != STOP)
  136. encodeNSForPVOP ();
  137. else
  138. encodeNSForPVOP_WithShape ();
  139. }
  140. else if (m_vopmd.vopPredType == IVOP)
  141. encodeNSForIVOP_WithShape ();
  142. else
  143. encodeNSForBVOP_WithShape ();
  144. }
  145. if (m_uiRateControl>=RC_TM5) {
  146. m_tm5rc.tm5rc_update_pict(m_vopmd.vopPredType, m_statsVOP.total());
  147. }
  148. }
  150. //
  151. // size:
  152. // m_pvopcCurr: original size (QCIF or CIF), same memory through out the session
  153. //  m_pvopfRef: expanded original size (QCIF or CIF expanded by 16), same memory through out the session
  154. // pmbmd and pmv: VOP.  need to reallocate every time
  155. //
  156. // things don't need to recompute:
  157. // m_iWidthY, m_iWidthUV, m_iWidthRefY, m_iWidthRefUV
  158. // need to recompute:
  159. // m_uintNumMBX, m_uintNumMBY, m_uintNumMB
  160. //
  162. Void CVideoObjectEncoder::encodeNSForIVOP ()
  163. {
  164. //in case the IVOP is used as an ref for direct mode
  165. memset (m_rgmv, 0, m_iNumMB * PVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
  167. CMBMode* pmbmd = m_rgmbmd;
  168. Int iQPPrev = m_vopmd.intStepI; //initialization
  169. PixelC* ppxlcRefY  = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
  170. PixelC* ppxlcRefU  = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
  171. PixelC* ppxlcRefV  = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
  173. PixelC* ppxlcOrigY = (PixelC*) m_pvopcOrig->pixelsBoundY ();
  174. PixelC* ppxlcOrigU = (PixelC*) m_pvopcOrig->pixelsBoundU ();
  175. PixelC* ppxlcOrigV = (PixelC*) m_pvopcOrig->pixelsBoundV ();
  177. // MB rate control
  178. //Int iIndexofQ = 0;
  179. //Int rgiQ [4] = {-1, -2, 1, 2};
  180. if (m_uiRateControl>=RC_TM5) iQPPrev = m_tm5rc.tm5rc_start_mb();
  181. // -----
  183. Bool bRestartDelayedQP = TRUE;
  185. Int iMBX, iMBY, iMB = 0;
  186. Int iMaxQP = (1<<m_volmd.uiQuantPrecision)-1; // NBIT
  187. for (iMBY = 0; iMBY < m_iNumMBY; iMBY++) {
  188. PixelC* ppxlcRefMBY  = ppxlcRefY;
  189. PixelC* ppxlcRefMBU  = ppxlcRefU;
  190. PixelC* ppxlcRefMBV  = ppxlcRefV;
  191. PixelC* ppxlcOrigMBY = ppxlcOrigY;
  192. PixelC* ppxlcOrigMBU = ppxlcOrigU;
  193. PixelC* ppxlcOrigMBV = ppxlcOrigV;
  195. // In a given Sprite object piece, identify whether current macroblock is not a hole and should be coded ?
  196. Bool  bSptMB_NOT_HOLE= TRUE;
  197. if (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE && m_vopmd.SpriteXmitMode != STOP) {
  198. bSptMB_NOT_HOLE = SptPieceMB_NOT_HOLE(0, iMBY, pmbmd);
  199. RestoreMBmCurrRow (iMBY, m_rgpmbmCurr);
  200. }
  202. for (iMBX = 0; iMBX < m_iNumMBX; iMBX++, iMB++) {
  204.             // code current macroblock only if it is not a hole 
  205. m_bSptMB_NOT_HOLE  =  bSptMB_NOT_HOLE;
  206. if (!m_bSptMB_NOT_HOLE) //low latency
  207. goto EOMB1;
  209. #ifdef __TRACE_AND_STATS_
  210. m_statsMB.reset ();
  211. m_pbitstrmOut->trace (CSite (iMBX, iMBY), "MB_X_Y");
  212. #endif // __TRACE_AND_STATS_
  214.             pmbmd->m_intStepDelta = 0;
  215. // MB rate control
  216. if (m_uiRateControl>=RC_TM5) {
  217. pmbmd->m_intStepDelta = m_tm5rc.tm5rc_calc_mquant(iMB,
  218.  m_statsVOP.total()) - iQPPrev;
  219. if (pmbmd->m_intStepDelta>2) pmbmd->m_intStepDelta = 2;
  220. else if (pmbmd->m_intStepDelta<-2) pmbmd->m_intStepDelta = -2;
  221. }
  222. #ifdef _MBQP_CHANGE_
  223. iIndexofQ = (iIndexofQ + 1) % 4;
  224. pmbmd->m_intStepDelta = rgiQ [iIndexofQ];
  225. #endif //_MBQP_CHANGE_
  226. pmbmd->m_bSkip = FALSE; //reset for direct mode
  227. pmbmd->m_stepSize = iQPPrev + pmbmd->m_intStepDelta;
  228. /* NBIT: change 31 to iMaxQP
  229. assert (pmbmd->m_stepSize <= 31 && pmbmd->m_stepSize > 0);
  230. */
  231. assert (pmbmd->m_stepSize <= iMaxQP && pmbmd->m_stepSize > 0);
  232. if ( m_volmd.bVPBitTh >= 0) { // modified by Sharp (98/4/13)
  233. Int iCounter = m_pbitstrmOut -> getCounter();
  234. if( iCounter - m_iVPCounter > m_volmd.bVPBitTh ) {
  235. pmbmd->m_intStepDelta = 0; // reset DQ to use QP in VP header
  236. codeVideoPacketHeader (iMBX, iMBY, pmbmd->m_stepSize); // video packet header
  237. m_iVPCounter = iCounter;
  238. bRestartDelayedQP = TRUE;
  239. }
  240. }
  241. // End Toshiba(1998-1-16)
  243. if(bRestartDelayedQP)
  244. {
  245. pmbmd->m_stepSizeDelayed = pmbmd->m_stepSize;
  246. bRestartDelayedQP = FALSE;
  247. }
  248. else
  249. pmbmd->m_stepSizeDelayed = iQPPrev;
  251. iQPPrev = pmbmd->m_stepSize;
  252. if (pmbmd->m_intStepDelta == 0)
  253. pmbmd->m_dctMd = INTRA;
  254. else
  255. pmbmd->m_dctMd = INTRAQ;
  256. pmbmd->m_bFieldMV = 0;
  258. copyToCurrBuff (ppxlcOrigMBY, ppxlcOrigMBU, ppxlcOrigMBV, m_iFrameWidthY, m_iFrameWidthUV); 
  259. quantizeTextureIntraMB (iMBX, iMBY, pmbmd, ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, NULL);
  260. codeMBTextureHeadOfIVOP (pmbmd);
  261. sendDCTCoefOfIntraMBTexture (pmbmd);
  263. EOMB1:
  264. pmbmd++;
  265. #ifdef __TRACE_AND_STATS_
  266. m_statsVOP   += m_statsMB;
  267. #endif // __TRACE_AND_STATS_
  268. ppxlcRefMBY  += MB_SIZE;
  269. ppxlcRefMBU  += BLOCK_SIZE;
  270. ppxlcRefMBV  += BLOCK_SIZE;
  271. ppxlcOrigMBY += MB_SIZE;
  272. ppxlcOrigMBU += BLOCK_SIZE;
  273. ppxlcOrigMBV += BLOCK_SIZE;
  275. if (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE) {
  276. bSptMB_NOT_HOLE = SptPieceMB_NOT_HOLE(iMBX+1, iMBY, pmbmd);
  277. m_iNumSptMB++ ;
  278. }
  279. }
  281. MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
  282. m_rgpmbmAbove = m_rgpmbmCurr;
  284. // dshu: begin of modification
  285.   if (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE)
  286. SaveMBmCurrRow (iMBY, m_rgpmbmCurr);  //   save current row pointed by *m_rgpmbmCurr 
  287. // dshu: end of modification
  289. m_rgpmbmCurr  = ppmbmTemp;
  290. ppxlcRefY  += m_iFrameWidthYxMBSize;
  291. ppxlcRefU  += m_iFrameWidthUVxBlkSize;
  292. ppxlcRefV  += m_iFrameWidthUVxBlkSize;
  293. ppxlcOrigY += m_iFrameWidthYxMBSize;
  294. ppxlcOrigU += m_iFrameWidthUVxBlkSize;
  295. ppxlcOrigV += m_iFrameWidthUVxBlkSize;
  296. }
  297. }
  299. Void CVideoObjectEncoder::encodeNSForIVOP_WithShape ()
  300. {
  301. //in case the IVOP is used as an ref for direct mode
  302. memset (m_rgmv, 0, m_iNumMB * PVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
  303. memset (m_rgmvBY, 0, m_iNumMB * sizeof (CMotionVector));
  305. Int iMBX, iMBY, iMB = 0;
  306. Int iMaxQP = (1<<m_volmd.uiQuantPrecision)-1; // NBIT
  307. CMBMode* pmbmd = m_rgmbmd;
  308. // Added for field based MC padding by Hyundai(1998-5-9)
  309.         CMBMode* field_pmbmd = m_rgmbmd;
  310. // End of Hyundai(1998-5-9)
  311. Int iQPPrev = m_vopmd.intStepI; //initialization
  312. Int iQPPrevAlpha = m_vopmd.intStepIAlpha;
  313. if (m_uiRateControl>=RC_TM5) iQPPrev = m_tm5rc.tm5rc_start_mb();
  315. PixelC* ppxlcRefY  = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
  316. PixelC* ppxlcRefU  = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
  317. PixelC* ppxlcRefV  = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
  318. PixelC* ppxlcRefBY = (PixelC*) m_pvopcRefQ1->pixelsBY () + m_iStartInRefToCurrRctY;
  319. PixelC* ppxlcRefBUV = (PixelC*) m_pvopcRefQ1->pixelsBUV () + m_iStartInRefToCurrRctUV;
  320. PixelC *ppxlcRefA = NULL, *ppxlcOrigA = NULL;
  322. PixelC* ppxlcOrigY = (PixelC*) m_pvopcOrig->pixelsBoundY ();
  323. PixelC* ppxlcOrigU = (PixelC*) m_pvopcOrig->pixelsBoundU ();
  324. PixelC* ppxlcOrigV = (PixelC*) m_pvopcOrig->pixelsBoundV ();
  325. PixelC* ppxlcOrigBY = (PixelC*) m_pvopcOrig->pixelsBoundBY ();
  327. if (m_volmd.fAUsage == EIGHT_BIT) {
  328. ppxlcRefA = (PixelC*) m_pvopcRefQ1->pixelsA () + m_iStartInRefToCurrRctY;
  329. ppxlcOrigA = (PixelC*) m_pvopcOrig->pixelsBoundA ();
  330. }
  332. Bool bRestartDelayedQP = TRUE;
  334. for (iMBY = 0; iMBY < m_iNumMBY; iMBY++) {
  335. PixelC* ppxlcRefMBY  = ppxlcRefY;
  336. PixelC* ppxlcRefMBU  = ppxlcRefU;
  337. PixelC* ppxlcRefMBV  = ppxlcRefV;
  338. PixelC* ppxlcRefMBBY = ppxlcRefBY;
  339. PixelC* ppxlcRefMBBUV = ppxlcRefBUV;
  340. PixelC* ppxlcRefMBA  = ppxlcRefA;
  341. PixelC* ppxlcOrigMBY = ppxlcOrigY;
  342. PixelC* ppxlcOrigMBU = ppxlcOrigU;
  343. PixelC* ppxlcOrigMBV = ppxlcOrigV;
  344. PixelC* ppxlcOrigMBBY = ppxlcOrigBY;
  345. PixelC* ppxlcOrigMBA = ppxlcOrigA;
  347.     // In a given Sprite object piece, identify whether current macroblock is not a hole and should be coded ?
  348. Bool  bSptMB_NOT_HOLE= TRUE;
  349. if (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE && m_vopmd.SpriteXmitMode != STOP) {
  350. bSptMB_NOT_HOLE = SptPieceMB_NOT_HOLE(0, iMBY, pmbmd);
  351. RestoreMBmCurrRow (iMBY, m_rgpmbmCurr);
  352. }
  354. for (iMBX = 0; iMBX < m_iNumMBX; iMBX++, iMB++) {
  355.   // code current macroblock only if it is not a hole 
  356. m_bSptMB_NOT_HOLE  =  bSptMB_NOT_HOLE;
  357. if (!m_bSptMB_NOT_HOLE) 
  358. goto EOMB2;
  360. // MB rate control
  361. if (m_uiRateControl>=RC_TM5) {
  362. pmbmd->m_intStepDelta = m_tm5rc.tm5rc_calc_mquant(iMB,
  363.  m_statsVOP.total()) - iQPPrev;
  364. if (pmbmd->m_intStepDelta>2) pmbmd->m_intStepDelta = 2;
  365. else if (pmbmd->m_intStepDelta<-2) pmbmd->m_intStepDelta = -2;
  366. }
  368.             // Added for error resilient mode by Toshiba(1997-11-14)
  369. pmbmd->m_stepSize = iQPPrev + pmbmd->m_intStepDelta;
  370. if ( m_volmd.bVPBitTh >= 0) {
  371. Int iCounter = m_pbitstrmOut -> getCounter();
  372. if( iCounter - m_iVPCounter > m_volmd.bVPBitTh ) {
  373. codeVideoPacketHeader (iMBX, iMBY, pmbmd->m_stepSize); // video packet header
  374. m_iVPCounter = iCounter;
  375. bRestartDelayedQP = TRUE;
  376. }
  377. }
  378.             // End Toshiba(1997-11-14)
  380. #ifdef __TRACE_AND_STATS_
  381. m_statsMB.reset ();
  382. m_pbitstrmOut->trace (CSite (iMBX, iMBY), "MB_X_Y");
  383. #endif // __TRACE_AND_STATS_
  385. pmbmd->m_bSkip = FALSE; //reset for direct mode 
  386. pmbmd->m_bPadded=FALSE;
  387. copyToCurrBuffWithShape (
  388. ppxlcOrigMBY, ppxlcOrigMBU, ppxlcOrigMBV, 
  389. ppxlcOrigMBBY, ppxlcOrigMBA,
  390. m_iFrameWidthY, m_iFrameWidthUV
  391. );
  392. downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV); // downsample original BY now for LPE padding (using original shape)
  393. decideTransparencyStatus (pmbmd, m_ppxlcCurrMBBY);
  394. if (pmbmd -> m_rgTranspStatus [0] == PARTIAL) {
  395. LPEPadding (pmbmd);
  396. m_statsMB.nBitsShape += codeIntraShape (ppxlcRefMBBY, pmbmd, iMBX, iMBY);
  397. downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV);
  398. decideTransparencyStatus (pmbmd, m_ppxlcCurrMBBY); // need to modify it a little (NONE block won't change)
  399. }
  400. else
  401. m_statsMB.nBitsShape += codeIntraShape (ppxlcRefMBBY, pmbmd, iMBX, iMBY);
  402. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  403. if (m_vopmd.bInterlace) initMergedMode (pmbmd);
  404. // End of Hyundai(1998-5-9)*/
  405. if(m_volmd.bShapeOnly == FALSE) {// shape only mode
  406. pmbmd->m_stepSizeDelayed = iQPPrev;
  408. if (pmbmd -> m_rgTranspStatus [0] != ALL) {
  409. pmbmd->m_stepSize = iQPPrev + pmbmd->m_intStepDelta;
  410. assert (pmbmd->m_stepSize <= iMaxQP && pmbmd->m_stepSize > 0);
  412. if(bRestartDelayedQP)
  413. {
  414. pmbmd->m_stepSizeDelayed = pmbmd->m_stepSize;
  415. bRestartDelayedQP = FALSE;
  416. }
  418. iQPPrev = pmbmd->m_stepSize;
  419. if (pmbmd->m_intStepDelta == 0)
  420. pmbmd->m_dctMd = INTRA;
  421. else
  422. pmbmd->m_dctMd = INTRAQ;
  423. if (m_volmd.fAUsage == EIGHT_BIT) {
  424. // update alpha quant
  425. if(!m_volmd.bNoGrayQuantUpdate)
  426. {
  427. iQPPrevAlpha = (iQPPrev * m_vopmd.intStepIAlpha) / m_vopmd.intStepI;
  428. if(iQPPrevAlpha<1)
  429. iQPPrevAlpha=1;
  430. }
  431. pmbmd->m_stepSizeAlpha = iQPPrevAlpha;
  432. }
  433. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  434. if (m_vopmd.bInterlace && pmbmd->m_rgTranspStatus[0] == PARTIAL)
  435. boundaryMacroBlockMerge (pmbmd);
  436. // End of Hyundai(1998-5-9)*/
  437. quantizeTextureIntraMB (iMBX, iMBY, pmbmd, ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA);
  438. codeMBTextureHeadOfIVOP (pmbmd);
  439. sendDCTCoefOfIntraMBTexture (pmbmd);
  440. if (m_volmd.fAUsage == EIGHT_BIT) {
  441. codeMBAlphaHeadOfIVOP (pmbmd);
  442. sendDCTCoefOfIntraMBAlpha (pmbmd);
  443. }
  444. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  445.                     if (m_vopmd.bInterlace && pmbmd->m_bMerged[0])
  446.                             mergedMacroBlockSplit (pmbmd, ppxlcRefMBY, ppxlcRefMBA);
  447. // End of Hyundai(1998-5-9)*/
  448. // MC padding
  449. // Added for field based MC padding by Hyundai(1998-5-9)
  450. if (!m_vopmd.bInterlace) {
  451. if (pmbmd -> m_rgTranspStatus [0] == PARTIAL)
  452. mcPadCurrMB (ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA);
  453. padNeighborTranspMBs (
  454. iMBX, iMBY,
  455. pmbmd,
  456. ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA
  457. );
  458. }
  459. // End of Hyundai(1998-5-9)
  460. }
  461. else {
  462. // Added for field based MC padding by Hyundai(1998-5-9)
  463. if (!m_vopmd.bInterlace) {
  464. padCurrAndTopTranspMBFromNeighbor (
  465. iMBX, iMBY,
  466. pmbmd,
  467. ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA
  468. );
  469. }
  470. // End of Hyundai(1998-5-9)
  471. }
  472. }
  474. EOMB2:
  475.      ppxlcRefMBA += MB_SIZE;
  476. ppxlcOrigMBBY += MB_SIZE;
  477. ppxlcOrigMBA += MB_SIZE;
  478. pmbmd++;
  479. #ifdef __TRACE_AND_STATS_
  480. m_statsVOP   += m_statsMB;
  481. #endif // __TRACE_AND_STATS_
  482. ppxlcRefMBY  += MB_SIZE;
  483. ppxlcRefMBU  += BLOCK_SIZE;
  484. ppxlcRefMBV  += BLOCK_SIZE;
  485. ppxlcRefMBBY += MB_SIZE;
  486. ppxlcRefMBBUV += BLOCK_SIZE;
  487. ppxlcOrigMBY += MB_SIZE;
  488. ppxlcOrigMBU += BLOCK_SIZE;
  489. ppxlcOrigMBV += BLOCK_SIZE;
  491. // Identify whether next Sprite object macroblock is not a hole and should be coded ?
  492. if (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE)
  493. bSptMB_NOT_HOLE = SptPieceMB_NOT_HOLE(iMBX+1, iMBY, pmbmd);
  494. }
  496. MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
  497. m_rgpmbmAbove = m_rgpmbmCurr;
  498. // dshu: begin of modification
  499.   if (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE)
  500. SaveMBmCurrRow (iMBY, m_rgpmbmCurr);  //   save current row pointed by *m_rgpmbmCurr 
  501. // dshu: end of modification
  502. m_rgpmbmCurr  = ppmbmTemp;
  503. ppxlcRefY  += m_iFrameWidthYxMBSize;
  504. ppxlcRefA  += m_iFrameWidthYxMBSize;
  505. ppxlcRefU  += m_iFrameWidthUVxBlkSize;
  506. ppxlcRefV  += m_iFrameWidthUVxBlkSize;
  507. ppxlcRefBY += m_iFrameWidthYxMBSize;
  508. ppxlcRefBUV += m_iFrameWidthUVxBlkSize;
  510. ppxlcOrigY += m_iFrameWidthYxMBSize;
  511. ppxlcOrigBY += m_iFrameWidthYxMBSize;
  512. ppxlcOrigA += m_iFrameWidthYxMBSize;
  513. ppxlcOrigU += m_iFrameWidthUVxBlkSize;
  514. ppxlcOrigV += m_iFrameWidthUVxBlkSize;
  515. }
  516. // Added for field based MC padding by Hyundai(1998-5-9)
  517.         if (m_vopmd.bInterlace && m_volmd.bShapeOnly == FALSE)
  518.                 fieldBasedMCPadding (field_pmbmd, m_pvopcRefQ1);
  519. // End of Hyundai(1998-5-9)
  520. }
  522. Void CVideoObjectEncoder::encodeNSForPVOP ()
  523. {
  524.     if (m_uiSprite == 0) //low latency: not motion esti
  525.     motionEstPVOP ();
  527. // Rate Control
  528. if (m_uiRateControl==RC_MPEG4) {
  529. Double Ec = m_iMAD / (Double) (m_iNumMBY * m_iNumMBX * 16 * 16);
  530. m_statRC.setMad (Ec);
  531. if (m_statRC.noCodedFrame () >= RC_START_RATE_CONTROL) {
  532. UInt newQStep = m_statRC.updateQuanStepsize ();
  533. m_vopmd.intStepDiff = newQStep - m_vopmd.intStep; // DQUANT
  534. m_vopmd.intStep = newQStep;
  535. }
  536. cout << "t" << "Q:" << "ttt" << m_vopmd.intStep << "n";
  537. m_statRC.setQc (m_vopmd.intStep);
  538. }
  540. // MB rate control
  541. //Int iIndexofQ = 0;
  542. //Int rgiQ [4] = {-1, -2, 1, 2};
  543. // -----
  545. Int iMBX, iMBY, iMB = 0;
  546. Int iMaxQP = (1<<m_volmd.uiQuantPrecision)-1; // NBIT
  547. CoordI y = 0; 
  548. CMBMode* pmbmd = m_rgmbmd;
  549. Int iQPPrev = m_vopmd.intStep;
  550. if (m_uiRateControl>=RC_TM5) iQPPrev = m_tm5rc.tm5rc_start_mb();
  551. CMotionVector* pmv = m_rgmv;
  552. PixelC* ppxlcRefY = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
  553. PixelC* ppxlcRefU = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
  554. PixelC* ppxlcRefV = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
  556. PixelC* ppxlcOrigY = (PixelC*) m_pvopcOrig->pixelsBoundY ();
  557. PixelC* ppxlcOrigU = (PixelC*) m_pvopcOrig->pixelsBoundU ();
  558. PixelC* ppxlcOrigV = (PixelC*) m_pvopcOrig->pixelsBoundV ();
  560. Bool bRestartDelayedQP = TRUE;
  562. for (iMBY = 0; iMBY < m_iNumMBY; iMBY++, y += MB_SIZE) {
  563. PixelC* ppxlcRefMBY = ppxlcRefY;
  564. PixelC* ppxlcRefMBU = ppxlcRefU;
  565. PixelC* ppxlcRefMBV = ppxlcRefV;
  566. PixelC* ppxlcOrigMBY = ppxlcOrigY;
  567. PixelC* ppxlcOrigMBU = ppxlcOrigU;
  568. PixelC* ppxlcOrigMBV = ppxlcOrigV;
  569. CoordI x = 0; 
  571. // In a given Sprite update piece, identify whether current macroblock is not a hole and should be coded ?
  572. Bool  bSptMB_NOT_HOLE= TRUE;
  573. if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP) {
  574. bSptMB_NOT_HOLE = SptUpdateMB_NOT_HOLE(0, iMBY, pmbmd);
  575. m_statsMB.nBitsShape = 0;  
  576. }
  578. for (iMBX = 0; iMBX < m_iNumMBX; iMBX++, x += MB_SIZE, iMB++) {
  580.             // skip current Sprite update macroblock if it is transparent
  581. if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP && pmbmd -> m_rgTranspStatus [0] == ALL)
  582. goto EOMB3;
  583. else if (m_uiSprite == 1) {
  584. m_bSptMB_NOT_HOLE = bSptMB_NOT_HOLE;
  585. pmv -> setToZero ();
  586. pmbmd->m_bhas4MVForward = FALSE ;
  587. pmbmd -> m_dctMd = INTER ;
  588. }
  590. #ifdef __TRACE_AND_STATS_
  591. m_pbitstrmOut->trace (CSite (iMBX, iMBY), "MB_X_Y");
  592. m_statsMB.reset ();
  593. #endif // __TRACE_AND_STATS_
  595. pmbmd->m_intStepDelta = 0;
  596. // MB rate control
  597. if (m_uiRateControl>=RC_TM5) {
  598. pmbmd->m_intStepDelta = m_tm5rc.tm5rc_calc_mquant(iMB,
  599.  m_statsVOP.total()) - iQPPrev;
  600. if (pmbmd->m_intStepDelta>2) pmbmd->m_intStepDelta = 2;
  601. else if (pmbmd->m_intStepDelta<-2) pmbmd->m_intStepDelta = -2;
  602. }
  603. #ifdef _MBQP_CHANGE_
  604. if (!pmbmd ->m_bhas4MVForward && !pmbmd ->m_bSkip) {
  605. iIndexofQ = (iIndexofQ + 1) % 4;
  606. pmbmd->m_intStepDelta = rgiQ [iIndexofQ];
  607. Int iQuantMax = (1<<m_volmd.uiQuantPrecision) - 1;
  608. if ((iQPPrev + pmbmd->m_intStepDelta) > iQuantMax) 
  609. pmbmd->m_intStepDelta = 0;
  610. if ((iQPPrev + pmbmd->m_intStepDelta) <= 0)
  611. pmbmd->m_intStepDelta = 0;
  612. if (pmbmd->m_intStepDelta != 0) {
  613. if (pmbmd->m_dctMd == INTRA)
  614. pmbmd->m_dctMd = INTRAQ;
  615. else if (pmbmd ->m_dctMd == INTER)
  616. pmbmd->m_dctMd = INTERQ;
  617. }
  618. }
  619. // -----
  620. #endif //_MBQP_CHANGE_
  621. pmbmd->m_stepSize = iQPPrev + pmbmd->m_intStepDelta;
  622. /* NBIT: change 31 to iMaxQP
  623. assert (pmbmd->m_stepSize <= 31 && pmbmd->m_stepSize > 0);
  624. */
  625. assert (pmbmd->m_stepSize <= iMaxQP && pmbmd->m_stepSize > 0);
  627. if ( m_volmd.bVPBitTh >= 0) {
  628. Int iCounter = m_pbitstrmOut -> getCounter();
  629. if( iCounter - m_iVPCounter > m_volmd.bVPBitTh ) {
  630. // reset DQ to use QP in VP header
  631. pmbmd->m_intStepDelta = 0;
  632. if (pmbmd->m_dctMd == INTRAQ)
  633. pmbmd->m_dctMd = INTRA;
  634. else if (pmbmd ->m_dctMd == INTERQ)
  635. pmbmd->m_dctMd = INTER;
  636. iQPPrev = pmbmd->m_stepSize;
  637. codeVideoPacketHeader (iMBX, iMBY, pmbmd->m_stepSize); // video packet header
  638. m_iVPCounter = iCounter;
  639. bRestartDelayedQP = TRUE;
  640. }
  641. }
  643. if(bRestartDelayedQP)
  644. pmbmd->m_stepSizeDelayed = pmbmd->m_stepSize;
  645. else
  646. pmbmd->m_stepSizeDelayed = iQPPrev;
  648. copyToCurrBuff (ppxlcOrigMBY, ppxlcOrigMBU, ppxlcOrigMBV, m_iFrameWidthY, m_iFrameWidthUV); 
  649. encodePVOPMB (
  650. ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV,
  651. pmbmd, pmv,
  652. iMBX, iMBY,
  653. x, y
  654. );
  655. if (!pmbmd->m_bSkip)
  656. {
  657. iQPPrev = pmbmd->m_stepSize;
  658. bRestartDelayedQP = FALSE;
  659. }
  661. EOMB3:
  662. pmbmd++;
  663. pmv += PVOP_MV_PER_REF_PER_MB;
  664. #ifdef __TRACE_AND_STATS_
  665. m_statsVOP += m_statsMB;
  666. #endif // __TRACE_AND_STATS_
  667. ppxlcRefMBY += MB_SIZE;
  668. ppxlcRefMBU += BLOCK_SIZE;
  669. ppxlcRefMBV += BLOCK_SIZE;
  670. ppxlcOrigMBY += MB_SIZE;
  671. ppxlcOrigMBU += BLOCK_SIZE;
  672. ppxlcOrigMBV += BLOCK_SIZE;
  673. // Identify whether next Sprite update macroblock is not a hole and should be coded ?
  674. if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP && iMBX < (m_iNumMBX-1))
  675. bSptMB_NOT_HOLE = SptUpdateMB_NOT_HOLE(iMBX+1, iMBY, pmbmd);   
  676. }
  677. MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
  678. m_rgpmbmAbove = m_rgpmbmCurr;
  679. m_rgpmbmCurr  = ppmbmTemp;
  681. ppxlcRefY += m_iFrameWidthYxMBSize;
  682. ppxlcRefU += m_iFrameWidthUVxBlkSize;
  683. ppxlcRefV += m_iFrameWidthUVxBlkSize;
  685. ppxlcOrigY += m_iFrameWidthYxMBSize;
  686. ppxlcOrigU += m_iFrameWidthUVxBlkSize;
  687. ppxlcOrigV += m_iFrameWidthUVxBlkSize;
  688. }
  689. }
  691. Void CVideoObjectEncoder::encodeNSForPVOP_WithShape ()
  692. {
  693. Int iMBX, iMBY, iMB = 0;
  695. motionEstPVOP_WithShape ();
  697. // shape bitstream is set to shape cache
  698. m_pbitstrmShapeMBOut = m_pbitstrmShape;
  700. // Rate Control
  701. if (m_uiRateControl==RC_MPEG4) {
  702. Double Ec = m_iMAD / (Double) (m_iNumMBY * m_iNumMBX * 16 * 16);
  703. m_statRC.setMad (Ec);
  704. if (m_statRC.noCodedFrame () >= RC_START_RATE_CONTROL) {
  705. UInt newQStep = m_statRC.updateQuanStepsize ();
  706. m_vopmd.intStepDiff = newQStep - m_vopmd.intStep; // DQUANT
  707. m_vopmd.intStep = newQStep;
  708. }
  709. cout << "t" << "Q:" << "ttt" << m_vopmd.intStep << "n";
  710. m_statRC.setQc (m_vopmd.intStep);
  711. }
  713. CoordI y = m_rctCurrVOPY.top; 
  714. CMBMode* pmbmd = m_rgmbmd;
  715. // Added for field based MC padding by Hyundai(1998-5-9)
  716. CMBMode* field_pmbmd = m_rgmbmd;
  717. // End of Hyundai(1998-5-9)
  719. Int iQPPrev = m_vopmd.intStep;
  720. Int iQPPrevAlpha = m_vopmd.intStepPAlpha;
  721. if (m_uiRateControl>=RC_TM5) iQPPrev = m_tm5rc.tm5rc_start_mb();
  723. CMotionVector* pmv = m_rgmv;
  724. CMotionVector* pmvBY = m_rgmvBY;
  725. PixelC* ppxlcRefY = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
  726. PixelC* ppxlcRefU = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
  727. PixelC* ppxlcRefV = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
  728. PixelC* ppxlcRefBY = (PixelC*) m_pvopcRefQ1->pixelsBY () + m_iStartInRefToCurrRctY;
  729. PixelC *ppxlcRefA = NULL, * ppxlcOrigA = NULL;
  731. PixelC* ppxlcOrigY = (PixelC*) m_pvopcOrig->pixelsBoundY ();
  732. PixelC* ppxlcOrigU = (PixelC*) m_pvopcOrig->pixelsBoundU ();
  733. PixelC* ppxlcOrigV = (PixelC*) m_pvopcOrig->pixelsBoundV ();
  734. PixelC* ppxlcOrigBY = (PixelC*) m_pvopcOrig->pixelsBoundBY ();
  736. if (m_volmd.fAUsage == EIGHT_BIT) {
  737. ppxlcRefA = (PixelC*) m_pvopcRefQ1->pixelsA () + m_iStartInRefToCurrRctY;
  738. ppxlcOrigA = (PixelC*) m_pvopcOrig->pixelsBoundA ();
  739. }
  741. Bool bRestartDelayedQP = TRUE;
  743. // Added for error resilient mode by Toshiba(1997-11-14)
  744. Bool bCodeVPHeaderNext = FALSE; // needed only for OBMC
  745. Int iTempVPMBnum = 0;
  746. // End Toshiba(1997-11-14)
  747. for (iMBY = 0; iMBY < m_iNumMBY; iMBY++, y += MB_SIZE) {
  748. PixelC* ppxlcRefMBY = ppxlcRefY;
  749. PixelC* ppxlcRefMBU = ppxlcRefU;
  750. PixelC* ppxlcRefMBV = ppxlcRefV;
  751. PixelC* ppxlcRefMBBY = ppxlcRefBY;
  752. PixelC* ppxlcRefMBA = ppxlcRefA;
  753. PixelC* ppxlcOrigMBY = ppxlcOrigY;
  754. PixelC* ppxlcOrigMBU = ppxlcOrigU;
  755. PixelC* ppxlcOrigMBV = ppxlcOrigV;
  756. PixelC* ppxlcOrigMBBY = ppxlcOrigBY;
  757. PixelC* ppxlcOrigMBA = ppxlcOrigA;
  758. CoordI x = m_rctCurrVOPY.left;
  760. #ifdef __TRACE_AND_STATS_
  761. m_statsMB.reset ();
  762. #endif // __TRACE_AND_STATS_
  764. // initiate advance shape coding
  765.         // Added for error resilient mode by Toshiba(1997-11-14)
  766. // The following operation is needed only for OBMC
  767. if ( m_volmd.bVPBitTh >= 0) {
  768. Int iCounter = m_pbitstrmOut -> getCounter();
  769. bCodeVPHeaderNext = iCounter - m_iVPCounter > m_volmd.bVPBitTh;
  770. if( bCodeVPHeaderNext ) {
  771. iTempVPMBnum  = m_iVPMBnum;
  772. m_iVPMBnum = VPMBnum(0, iMBY);
  773. m_iVPCounter = iCounter;
  774. }
  775. } else {
  776. bCodeVPHeaderNext = FALSE;
  777. }
  778. // End Toshiba(1997-11-14)
  779. copyToCurrBuffJustShape (ppxlcOrigMBBY, m_iFrameWidthY);
  780. // Modified for error resilient mode by Toshiba(1997-11-14)
  781. ShapeMode shpmdColocatedMB;
  782. if(m_vopmd.bShapeCodingType) {
  783. shpmdColocatedMB = m_rgmbmdRef [
  784. min (max (0, iMBY), m_iNumMBYRef - 1) * m_iNumMBXRef].m_shpmd;
  785. encodePVOPMBJustShape(ppxlcRefMBBY, pmbmd, shpmdColocatedMB, pmv, pmvBY, x, y, 0, iMBY);
  786. }
  787. else {
  788. m_statsMB.nBitsShape += codeIntraShape (ppxlcRefMBBY, pmbmd, 0, iMBY);
  789. decideTransparencyStatus (pmbmd, m_ppxlcCurrMBBY); 
  790. }
  791. // End Toshiba(1997-11-14)
  792.         // Added for error resilient mode by Toshiba(1997-11-14)
  793. // The following operation is needed only for OBMC
  794. if( bCodeVPHeaderNext )
  795. m_iVPMBnum = iTempVPMBnum;
  796.         // End Toshiba(1997-11-14)
  798. if(pmbmd->m_bhas4MVForward)
  799. padMotionVectors(pmbmd,pmv);
  801. for (iMBX = 0; iMBX < m_iNumMBX; iMBX++, x += MB_SIZE, iMB++) {
  802. // MB rate control
  803. if (m_uiRateControl>=RC_TM5) {
  804. pmbmd->m_intStepDelta = m_tm5rc.tm5rc_calc_mquant(iMB,
  805.  m_statsVOP.total()) - iQPPrev;
  806. if (pmbmd->m_intStepDelta>2) pmbmd->m_intStepDelta = 2;
  807. else if (pmbmd->m_intStepDelta<-2) pmbmd->m_intStepDelta = -2;
  808. }
  809.             // Added for error resilient mode by Toshiba(1997-11-14)
  810. pmbmd->m_stepSize = iQPPrev + pmbmd->m_intStepDelta;
  811. if ( m_volmd.bVPBitTh >= 0) {
  812. if( bCodeVPHeaderNext ) {
  813. codeVideoPacketHeader (iMBX, iMBY, pmbmd->m_stepSize); // video packet header
  814. bRestartDelayedQP = TRUE;
  815. }
  816. } else {
  817. bCodeVPHeaderNext = FALSE;
  818. }
  819.             // End Toshiba(1997-11-14)
  821. #ifdef __TRACE_AND_STATS_
  822. m_pbitstrmOut->trace (CSite (iMBX, iMBY), "MB_X_Y (Texture)");
  823. // shape quantization part
  824. m_statsMB.reset ();
  825. #endif // __TRACE_AND_STATS_
  827. pmbmd->m_bPadded=FALSE;
  829. dumpCachedShapeBits();
  831. if(iMBX<m_iNumMBX-1)
  832. {
  833.                 // Added for error resilient mode by Toshiba(1997-11-14)
  834. // The following operation is needed only for OBMC
  835. if ( m_volmd.bVPBitTh >= 0) {
  836. Int iCounter = m_pbitstrmOut -> getCounter();
  837. bCodeVPHeaderNext = iCounter - m_iVPCounter > m_volmd.bVPBitTh;
  838. if( bCodeVPHeaderNext ) {
  839. iTempVPMBnum  = m_iVPMBnum;
  840. m_iVPMBnum = VPMBnum(iMBX+1, iMBY);
  841. m_iVPCounter = iCounter;
  842. }
  843. } else {
  844. bCodeVPHeaderNext = FALSE;
  845. }
  846.                 // End Toshiba(1997-11-14)
  847. // code shape 1mb in advance
  848. copyToCurrBuffJustShape (ppxlcOrigMBBY+MB_SIZE,m_iFrameWidthY);
  849. // Modified for error resilient mode by Toshiba(1997-11-14)
  850. if(m_vopmd.bShapeCodingType) {
  851. shpmdColocatedMB = m_rgmbmdRef [
  852. min (max (0, iMBX+1), m_iNumMBXRef-1) + 
  853.   min (max (0, iMBY), m_iNumMBYRef-1) * m_iNumMBXRef
  854. ].m_shpmd;
  855. encodePVOPMBJustShape(
  856. ppxlcRefMBBY+MB_SIZE, pmbmd+1,
  857.  shpmdColocatedMB, pmv + PVOP_MV_PER_REF_PER_MB,
  858.  pmvBY+1, x+MB_SIZE, y,
  859.  iMBX+1, iMBY
  860. );
  861. }
  862. else {
  863. m_statsMB.nBitsShape
  864. += codeIntraShape (
  865. ppxlcRefMBBY+MB_SIZE,
  866. pmbmd+1, iMBX+1, iMBY
  867. );
  868. decideTransparencyStatus (pmbmd+1,
  869.  m_ppxlcCurrMBBY); 
  870. }
  871.     // End Toshiba(1997-11-14)
  873.                 // Added for error resilient mode by Toshiba(1997-11-14)
  874. // The following operation is needed only for OBMC
  875. if( bCodeVPHeaderNext )
  876. m_iVPMBnum = iTempVPMBnum;
  877.                 // End Toshiba(1997-11-14)
  878. // shape needs padded mvs ready for next mb
  879. if((pmbmd+1)->m_bhas4MVForward)
  880. padMotionVectors(pmbmd+1, pmv + PVOP_MV_PER_REF_PER_MB);
  881. }
  882. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  883. if (m_vopmd.bInterlace) initMergedMode (pmbmd);
  884. // End of Hyundai(1998-5-9)*/
  885. if(m_volmd.bShapeOnly==FALSE)
  886. {
  887. pmbmd->m_stepSizeDelayed = iQPPrev;
  889. if (pmbmd -> m_rgTranspStatus [0] != ALL) {
  890. // need to copy binary shape too since curr buff is future shape
  891. copyToCurrBuffWithShape(ppxlcOrigMBY, ppxlcOrigMBU, ppxlcOrigMBV,
  892. ppxlcRefMBBY, ppxlcOrigMBA, m_iFrameWidthY, m_iFrameWidthUV);
  893. downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV);
  894. encodePVOPMBTextureWithShape(ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV,
  895. ppxlcRefMBA, pmbmd, pmv, iMBX, iMBY, x, y, iQPPrev, iQPPrevAlpha,
  896. bRestartDelayedQP);
  897. // Added for field based MC padding by Hyundai(1998-5-9)
  898. if (!m_vopmd.bInterlace) { 
  899. if (pmbmd -> m_rgTranspStatus [0] == PARTIAL)
  900. mcPadCurrMB (ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA);
  901. padNeighborTranspMBs (
  902. iMBX, iMBY,
  903. pmbmd,
  904. ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA
  905. );
  906. }
  907. // End of Hyundai(1998-5-9)
  908. }
  909. else {
  910. // Added for field based MC padding by Hyundai(1998-5-9)
  911. if (!m_vopmd.bInterlace) { 
  912. padCurrAndTopTranspMBFromNeighbor (
  913. iMBX, iMBY,
  914. pmbmd,
  915. ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA
  916. );
  917. }
  918. // End of Hyundai(1998-5-9)
  919. }
  920. }
  922. pmbmd++;
  923. pmv += PVOP_MV_PER_REF_PER_MB;
  924. pmvBY++;
  925. ppxlcRefMBBY += MB_SIZE;
  926. ppxlcRefMBA += MB_SIZE;
  927. ppxlcOrigMBBY += MB_SIZE;
  928. ppxlcOrigMBA += MB_SIZE;
  929. #ifdef __TRACE_AND_STATS_
  930. m_statsVOP += m_statsMB;
  931. #endif // __TRACE_AND_STATS_
  932. ppxlcRefMBY += MB_SIZE;
  933. ppxlcRefMBU += BLOCK_SIZE;
  934. ppxlcRefMBV += BLOCK_SIZE;
  935. ppxlcOrigMBY += MB_SIZE;
  936. ppxlcOrigMBU += BLOCK_SIZE;
  937. ppxlcOrigMBV += BLOCK_SIZE;
  938. }
  939. MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
  940. m_rgpmbmAbove = m_rgpmbmCurr;
  941. m_rgpmbmCurr  = ppmbmTemp;
  943. ppxlcRefY += m_iFrameWidthYxMBSize;
  944. ppxlcRefU += m_iFrameWidthUVxBlkSize;
  945. ppxlcRefV += m_iFrameWidthUVxBlkSize;
  946. ppxlcRefBY += m_iFrameWidthYxMBSize;
  947. ppxlcRefA += m_iFrameWidthYxMBSize;
  949. ppxlcOrigY += m_iFrameWidthYxMBSize;
  950. ppxlcOrigBY += m_iFrameWidthYxMBSize;
  951. ppxlcOrigA += m_iFrameWidthYxMBSize;
  952. ppxlcOrigU += m_iFrameWidthUVxBlkSize;
  953. ppxlcOrigV += m_iFrameWidthUVxBlkSize;
  954. }
  956. // Added for field based MC padding by Hyundai(1998-5-9)
  957.         if (m_vopmd.bInterlace && m_volmd.bShapeOnly == FALSE)
  958.                 fieldBasedMCPadding (field_pmbmd, m_pvopcRefQ1);
  959. // End of Hyundai(1998-5-9)
  961. // restore normal output stream
  962. m_pbitstrmShapeMBOut = m_pbitstrmOut;
  963. }
  965. Void CVideoObjectEncoder::encodeNSForBVOP ()
  966. {
  967. motionEstBVOP ();
  969. CoordI y = 0; 
  970. CMBMode* pmbmd = m_rgmbmd;
  971. CMotionVector* pmv = m_rgmv;
  972. CMotionVector* pmvBackward = m_rgmvBackward;
  973. const CMBMode* pmbmdRef = m_rgmbmdRef; //MB mode in ref frame for direct mode
  974. const CMotionVector* pmvRef = m_rgmvRef; //MV in ref frame for direct mode
  975. PixelC* ppxlcCurrQY = (PixelC*) m_pvopcCurrQ->pixelsY () + m_iStartInRefToCurrRctY;
  976. PixelC* ppxlcCurrQU = (PixelC*) m_pvopcCurrQ->pixelsU () + m_iStartInRefToCurrRctUV;
  977. PixelC* ppxlcCurrQV = (PixelC*) m_pvopcCurrQ->pixelsV () + m_iStartInRefToCurrRctUV;
  979. PixelC* ppxlcOrigY = (PixelC*) m_pvopcOrig->pixelsBoundY ();
  980. PixelC* ppxlcOrigU = (PixelC*) m_pvopcOrig->pixelsBoundU ();
  981. PixelC* ppxlcOrigV = (PixelC*) m_pvopcOrig->pixelsBoundV ();
  983. // MB rate control
  984. //Int iIndexofQ = 0;
  985. //Int rgiQ [4] = {-2, 0, 0, 2};
  986. // -----
  988. Int iQPPrev = m_vopmd.intStepB;
  989. Int iMBX, iMBY, iMB = 0;
  990. Int iMaxQP = (1<<m_volmd.uiQuantPrecision)-1; // NBIT
  991. for (iMBY = 0; iMBY < m_iNumMBY; iMBY++, y += MB_SIZE) {
  992. PixelC* ppxlcCurrQMBY = ppxlcCurrQY;
  993. PixelC* ppxlcCurrQMBU = ppxlcCurrQU;
  994. PixelC* ppxlcCurrQMBV = ppxlcCurrQV;
  995. PixelC* ppxlcOrigMBY = ppxlcOrigY;
  996. PixelC* ppxlcOrigMBU = ppxlcOrigU;
  997. PixelC* ppxlcOrigMBV = ppxlcOrigV;
  998. CoordI x = 0;
  999. m_vctForwardMvPredBVOP[0].x  = m_vctForwardMvPredBVOP[0].y  = 0;
  1000. m_vctBackwardMvPredBVOP[0].x = m_vctBackwardMvPredBVOP[0].y = 0;
  1001. m_vctForwardMvPredBVOP[1].x  = m_vctForwardMvPredBVOP[1].y  = 0;
  1002. m_vctBackwardMvPredBVOP[1].x = m_vctBackwardMvPredBVOP[1].y = 0;
  1003. for (iMBX = 0; iMBX < m_iNumMBX; iMBX++, x += MB_SIZE, iMB++) {
  1004. #ifdef __TRACE_AND_STATS_
  1005. m_pbitstrmOut->trace (CSite (iMBX, iMBY), "MB_X_Y");
  1006. // shape quantization part
  1007. m_statsMB.reset ();
  1008. #endif // __TRACE_AND_STATS_
  1010. pmbmd->m_intStepDelta = 0;
  1011. // MB rate control
  1012. if (m_uiRateControl>=RC_TM5) {
  1013. int k = m_tm5rc.tm5rc_calc_mquant(iMB, m_statsVOP.total());
  1014. // special case for BVOP copied from MoMuSys
  1015. if (k > iQPPrev) {
  1016. if (iQPPrev+2 <= iMaxQP) pmbmd->m_intStepDelta = 2;
  1017. } else if (k < iQPPrev) {
  1018. if (iQPPrev-2 > 0) pmbmd->m_intStepDelta = -2;
  1019. }
  1020. }
  1021. #ifdef _MBQP_CHANGE_
  1022. if (!pmbmd->m_bColocatedMBSkip && pmbmd->m_mbType != DIRECT) {
  1023. iIndexofQ = (iIndexofQ + 1) % 4;
  1024. pmbmd->m_dctMd = INTERQ;
  1025. pmbmd->m_intStepDelta = rgiQ [iIndexofQ];
  1026. Int iQuantMax = (1<<m_volmd.uiQuantPrecision) - 1;
  1027. if ((iQPPrev + pmbmd->m_intStepDelta) > iQuantMax)
  1028. pmbmd->m_intStepDelta = 0;
  1029. if ((iQPPrev + pmbmd->m_intStepDelta) <= 0)
  1030. pmbmd->m_intStepDelta = 0;
  1031. }
  1032. // -----
  1033. #endif //_MBQP_CHANGE_
  1035. pmbmd->m_stepSize = iQPPrev + pmbmd->m_intStepDelta;
  1036. /* NBIT: change 31 to iMaxQP
  1037. assert (pmbmd->m_stepSize <= 31 && pmbmd->m_stepSize > 0);
  1038. */
  1039. assert (pmbmd->m_stepSize <= iMaxQP && pmbmd->m_stepSize > 0);
  1041. if ( m_volmd.bVPBitTh >= 0) {
  1042. Int iCounter = m_pbitstrmOut -> getCounter();
  1043. if( iCounter - m_iVPCounter > m_volmd.bVPBitTh ) {
  1044. // reset DQ to use QP in VP header
  1045. pmbmd->m_intStepDelta = 0;
  1046. if (pmbmd ->m_dctMd == INTERQ)
  1047. pmbmd->m_dctMd = INTER;
  1048. iQPPrev = pmbmd->m_stepSize;
  1050. codeVideoPacketHeader (iMBX, iMBY, pmbmd->m_stepSize); // video packet header
  1051. m_iVPCounter = iCounter;
  1052. //reset MV predictor
  1053. m_vctForwardMvPredBVOP[0].x  = m_vctForwardMvPredBVOP[0].y  = 0;
  1054. m_vctBackwardMvPredBVOP[0].x = m_vctBackwardMvPredBVOP[0].y = 0;
  1055. m_vctForwardMvPredBVOP[1].x  = m_vctForwardMvPredBVOP[1].y  = 0;
  1056. m_vctBackwardMvPredBVOP[1].x = m_vctBackwardMvPredBVOP[1].y = 0;
  1058. }
  1059. }
  1061. if (pmbmd->m_bColocatedMBSkip &&
  1062. (m_volmd.volType == BASE_LAYER || (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 3 && m_volmd.iEnhnType == 0)))
  1063. { // don't need to send any bit for this mode
  1064. copyFromRefToCurrQ (
  1065. m_pvopcRefQ0,
  1066. x, y, 
  1067. ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, NULL
  1068. );
  1069. }
  1070. else {
  1071. copyToCurrBuff (ppxlcOrigMBY, ppxlcOrigMBU, ppxlcOrigMBV, m_iFrameWidthY, m_iFrameWidthUV); 
  1072. encodeBVOPMB (
  1073. ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV,
  1074. pmbmd, pmv, pmvBackward,
  1075. pmbmdRef, pmvRef,
  1076. iMBX, iMBY,
  1077. x, y
  1078. );
  1079. if (pmbmd->getCodedBlockPattern (U_BLOCK) ||
  1080. pmbmd->getCodedBlockPattern (V_BLOCK) ||
  1081. pmbmd->getCodedBlockPattern (Y_BLOCK1) ||
  1082. pmbmd->getCodedBlockPattern (Y_BLOCK2) ||
  1083. pmbmd->getCodedBlockPattern (Y_BLOCK3) ||
  1084. pmbmd->getCodedBlockPattern (Y_BLOCK4))
  1085. iQPPrev = pmbmd->m_stepSize;
  1086. }
  1088. pmbmd++;
  1089. pmv         += BVOP_MV_PER_REF_PER_MB;
  1090. pmvBackward += BVOP_MV_PER_REF_PER_MB;
  1091. pmvRef      += PVOP_MV_PER_REF_PER_MB;
  1092. pmbmdRef++;
  1093. m_statsVOP += m_statsMB;
  1094. ppxlcCurrQMBY += MB_SIZE;
  1095. ppxlcCurrQMBU += BLOCK_SIZE;
  1096. ppxlcCurrQMBV += BLOCK_SIZE;
  1097. ppxlcOrigMBY += MB_SIZE;
  1098. ppxlcOrigMBU += BLOCK_SIZE;
  1099. ppxlcOrigMBV += BLOCK_SIZE;
  1100. }
  1101. ppxlcCurrQY += m_iFrameWidthYxMBSize;
  1102. ppxlcCurrQU += m_iFrameWidthUVxBlkSize;
  1103. ppxlcCurrQV += m_iFrameWidthUVxBlkSize;
  1105. ppxlcOrigY += m_iFrameWidthYxMBSize;
  1106. ppxlcOrigU += m_iFrameWidthUVxBlkSize;
  1107. ppxlcOrigV += m_iFrameWidthUVxBlkSize;
  1108. }
  1109. }
  1111. Void CVideoObjectEncoder::encodeNSForBVOP_WithShape ()
  1112. {
  1113. motionEstBVOP_WithShape ();
  1115. // decide prediction direction for shape
  1116. if(m_bCodedFutureRef==FALSE)
  1117. m_vopmd.fShapeBPredDir = B_FORWARD;
  1118. else
  1119. {
  1120. if(m_tFutureRef - m_t >= m_t - m_tPastRef)
  1121. m_vopmd.fShapeBPredDir = B_FORWARD;
  1122. else
  1123. m_vopmd.fShapeBPredDir = B_BACKWARD;
  1124. }
  1126. Int iQPPrev = m_vopmd.intStepB;
  1127. Int iQPPrevAlpha = m_vopmd.intStepBAlpha;
  1128. if (m_uiRateControl>=RC_TM5) iQPPrev = m_tm5rc.tm5rc_start_mb();
  1130. CoordI y = m_rctCurrVOPY.top; 
  1131. CMBMode*    pmbmd = m_rgmbmd;
  1132. // Added for field based MC padding by Hyundai(1998-5-9)
  1133. CMBMode* field_pmbmd = m_rgmbmd;
  1134. // End of Hyundai(1998-5-9)
  1136. CMotionVector* pmv = m_rgmv;
  1137. CMotionVector* pmvBackward = m_rgmvBackward;
  1138. CMotionVector* pmvBY = m_rgmvBY;
  1139. PixelC* ppxlcCurrQY = (PixelC*) m_pvopcCurrQ->pixelsY () + m_iStartInRefToCurrRctY;
  1140. PixelC* ppxlcCurrQU = (PixelC*) m_pvopcCurrQ->pixelsU () + m_iStartInRefToCurrRctUV;
  1141. PixelC* ppxlcCurrQV = (PixelC*) m_pvopcCurrQ->pixelsV () + m_iStartInRefToCurrRctUV;
  1142. PixelC* ppxlcCurrQBY = (PixelC*) m_pvopcCurrQ->pixelsBY () + m_iStartInRefToCurrRctY;
  1143. PixelC *ppxlcCurrQA = NULL, * ppxlcOrigA = NULL;
  1145. PixelC* ppxlcOrigY = (PixelC*) m_pvopcOrig->pixelsBoundY ();
  1146. PixelC* ppxlcOrigU = (PixelC*) m_pvopcOrig->pixelsBoundU ();
  1147. PixelC* ppxlcOrigV = (PixelC*) m_pvopcOrig->pixelsBoundV ();
  1148. PixelC* ppxlcOrigBY = (PixelC*) m_pvopcOrig->pixelsBoundBY ();
  1150. if (m_volmd.fAUsage == EIGHT_BIT) {
  1151. ppxlcCurrQA = (PixelC*) m_pvopcCurrQ->pixelsA () + m_iStartInRefToCurrRctY;
  1152. ppxlcOrigA = (PixelC*) m_pvopcOrig->pixelsBoundA ();
  1153. }
  1154. Int iMBX, iMBY, iMB = 0;
  1155. const CMBMode* pmbmdRef;
  1156. const CMotionVector* pmvRef;
  1157. for (iMBY = 0; iMBY < m_iNumMBY; iMBY++, y += MB_SIZE) {
  1158. PixelC* ppxlcCurrQMBY = ppxlcCurrQY;
  1159. PixelC* ppxlcCurrQMBU = ppxlcCurrQU;
  1160. PixelC* ppxlcCurrQMBV = ppxlcCurrQV;
  1161. PixelC* ppxlcCurrQMBBY = ppxlcCurrQBY;
  1162. PixelC* ppxlcCurrQMBA = ppxlcCurrQA;
  1163. PixelC* ppxlcOrigMBY = ppxlcOrigY;
  1164. PixelC* ppxlcOrigMBU = ppxlcOrigU;
  1165. PixelC* ppxlcOrigMBV = ppxlcOrigV;
  1166. PixelC* ppxlcOrigMBBY = ppxlcOrigBY;
  1167. PixelC* ppxlcOrigMBA = ppxlcOrigA;
  1168. CoordI x = m_rctCurrVOPY.left;
  1169. m_vctForwardMvPredBVOP[0].x  = m_vctForwardMvPredBVOP[0].y  = 0;
  1170. m_vctBackwardMvPredBVOP[0].x = m_vctBackwardMvPredBVOP[0].y = 0;
  1171. m_vctForwardMvPredBVOP[1].x  = m_vctForwardMvPredBVOP[1].y  = 0;
  1172. m_vctBackwardMvPredBVOP[1].x = m_vctBackwardMvPredBVOP[1].y = 0;
  1173. Int iMaxQP = (1<<m_volmd.uiQuantPrecision)-1; // NBIT
  1174. for (iMBX = 0; iMBX < m_iNumMBX; iMBX++, x += MB_SIZE, iMB++) {
  1175. pmbmd->m_intStepDelta = 0; //sharp added this
  1176. pmbmd->m_bPadded=FALSE;
  1177. // shape quantization part
  1178. m_statsMB.reset ();
  1180. // Modified for error resilience mode by Toshiba(1998-1-16)
  1181. pmbmd->m_stepSize = m_vopmd.intStepB;
  1182. // MB rate control  -- should this be here??????
  1183. if (m_uiRateControl>=RC_TM5) {
  1184. int k = m_tm5rc.tm5rc_calc_mquant(iMB, m_statsVOP.total());
  1185. // special case for BVOP copied from MoMuSys
  1186. if (k > iQPPrev) {
  1187. if (iQPPrev+2 <= iMaxQP) pmbmd->m_intStepDelta = 2;
  1188. } else if (k < iQPPrev) {
  1189. if (iQPPrev-2 > 0) pmbmd->m_intStepDelta = -2;
  1190. }
  1191. }
  1192. if ( m_volmd.bVPBitTh >= 0) {
  1193. Int iCounter = m_pbitstrmOut -> getCounter();
  1194. if( iCounter - m_iVPCounter > m_volmd.bVPBitTh ) {
  1195. // // reset DQ to use QP in VP header
  1196. // pmbmd->m_intStepDelta = 0;
  1197. // if (pmbmd ->m_dctMd == INTERQ)
  1198. // pmbmd->m_dctMd = INTER;
  1199. // iQPPrev = pmbmd->m_stepSize;
  1201. codeVideoPacketHeader (iMBX, iMBY, pmbmd->m_stepSize); // video packet header
  1202. m_iVPCounter = iCounter;
  1203. //reset MV predictor
  1204. m_vctForwardMvPredBVOP[0].x  = m_vctForwardMvPredBVOP[0].y  = 0;
  1205. m_vctBackwardMvPredBVOP[0].x = m_vctBackwardMvPredBVOP[0].y = 0;
  1206. m_vctForwardMvPredBVOP[1].x  = m_vctForwardMvPredBVOP[1].y  = 0;
  1207. m_vctBackwardMvPredBVOP[1].x = m_vctBackwardMvPredBVOP[1].y = 0;
  1208. }
  1209. }
  1210. // End Toshiba(1998-1-16)
  1212. findColocatedMB (iMBX, iMBY,  pmbmdRef, pmvRef);
  1214. ShapeMode shpmdColocatedMB;
  1215. if(m_vopmd.fShapeBPredDir==B_FORWARD)
  1216. shpmdColocatedMB = m_rgshpmd [min (max (0, iMBX), m_iRefShpNumMBX - 1) 
  1217. + min (max (0, iMBY), m_iRefShpNumMBY - 1) * m_iRefShpNumMBX];
  1218. else
  1219. shpmdColocatedMB = m_rgmbmdRef [min (max (0, iMBX), m_iNumMBXRef - 1)
  1220. + min (max (0, iMBY), m_iNumMBYRef - 1) * m_iNumMBXRef].m_shpmd;
  1222. if (pmbmd->m_bColocatedMBSkip &&
  1223. (m_volmd.volType == BASE_LAYER || (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 3 && m_volmd.iEnhnType == 0)))
  1224. { // don't need to send any bit for this mode
  1225. copyToCurrBuffJustShape( ppxlcOrigMBBY, m_iFrameWidthY );
  1226. m_statsMB.nBitsShape += codeInterShape (
  1227. ppxlcCurrQMBBY,
  1228. m_vopmd.fShapeBPredDir==B_FORWARD ? m_pvopcRefQ0 : m_pvopcRefQ1,
  1229. pmbmd, shpmdColocatedMB,
  1230. NULL, pmvBY,
  1231. x, y, 
  1232. iMBX, iMBY
  1233. );
  1234. downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV);
  1235. decideTransparencyStatus (pmbmd, m_ppxlcCurrMBBY); // change pmbmd to inter if all transparent
  1236. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  1237. if (m_vopmd.bInterlace) initMergedMode (pmbmd);
  1238. // End of Hyundai(1998-5-9)*/
  1239. // reset motion vectors to zero because of skip
  1240. memset (pmv, 0, BVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
  1241. memset (pmvBackward, 0, BVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
  1242. if (m_volmd.fAUsage == EIGHT_BIT)
  1243. copyAlphaFromRefToCurrQ(m_pvopcRefQ0, x, y, ppxlcCurrQMBA, &m_rctRefVOPY0);
  1244. copyFromRefToCurrQ(
  1245. m_pvopcRefQ0,
  1246. x, y, 
  1247. ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, &m_rctRefVOPY0
  1248. );
  1249. }
  1250. else {
  1251. copyToCurrBuffWithShape (
  1252. ppxlcOrigMBY, ppxlcOrigMBU, ppxlcOrigMBV, 
  1253. ppxlcOrigMBBY, ppxlcOrigMBA,
  1254. m_iFrameWidthY, m_iFrameWidthUV
  1255. );
  1256. encodeBVOPMB_WithShape (
  1257. ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, ppxlcCurrQMBA, ppxlcCurrQMBBY,
  1258. pmbmd, pmv, pmvBackward,
  1259. pmvBY, shpmdColocatedMB,
  1260. pmbmdRef, pmvRef,
  1261. iMBX, iMBY,
  1262. x, y, iQPPrev, iQPPrevAlpha
  1263. );
  1264. }
  1265. //padding of bvop is necessary for temporal scalability: bvop in base layer is used for prediction in enhancement layer
  1266. if(m_volmd.bShapeOnly == FALSE) {
  1267. // Added for field based MC padding by Hyundai(1998-5-9)
  1268. if (!m_vopmd.bInterlace) {
  1269. if (pmbmd -> m_rgTranspStatus [0] != ALL) {
  1270. if (pmbmd -> m_rgTranspStatus [0] == PARTIAL)
  1271. mcPadCurrMB (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, ppxlcCurrQMBA);
  1272. padNeighborTranspMBs (
  1273. iMBX, iMBY,
  1274. pmbmd,
  1275. ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, ppxlcCurrQMBA
  1276. );
  1277. }
  1278. else {
  1279. padCurrAndTopTranspMBFromNeighbor (
  1280. iMBX, iMBY,
  1281. pmbmd,
  1282. ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, ppxlcCurrQMBA
  1283. ); 
  1284. }
  1285. }
  1286. // End of Hyundai(1998-5-9)
  1287. }
  1288. pmvBY++;
  1289. pmbmd++;
  1290. pmv         += BVOP_MV_PER_REF_PER_MB;
  1291. pmvBackward += BVOP_MV_PER_REF_PER_MB;
  1292. m_statsVOP += m_statsMB;
  1293. ppxlcCurrQMBY += MB_SIZE;
  1294. ppxlcCurrQMBU += BLOCK_SIZE;
  1295. ppxlcCurrQMBV += BLOCK_SIZE;
  1296. ppxlcCurrQMBBY += MB_SIZE;
  1297. ppxlcCurrQMBA += MB_SIZE;
  1298. ppxlcOrigMBY += MB_SIZE;
  1299. ppxlcOrigMBU += BLOCK_SIZE;
  1300. ppxlcOrigMBV += BLOCK_SIZE;
  1301. ppxlcOrigMBBY += MB_SIZE;
  1302. ppxlcOrigMBA += MB_SIZE;
  1303. }
  1304. ppxlcCurrQY += m_iFrameWidthYxMBSize;
  1305. ppxlcCurrQU += m_iFrameWidthUVxBlkSize;
  1306. ppxlcCurrQV += m_iFrameWidthUVxBlkSize;
  1307. ppxlcCurrQBY += m_iFrameWidthYxMBSize;
  1308. ppxlcCurrQA += m_iFrameWidthYxMBSize;
  1310. ppxlcOrigY += m_iFrameWidthYxMBSize;
  1311. ppxlcOrigU += m_iFrameWidthUVxBlkSize;
  1312. ppxlcOrigV += m_iFrameWidthUVxBlkSize;
  1313. ppxlcOrigBY += m_iFrameWidthYxMBSize;
  1314. ppxlcOrigA += m_iFrameWidthYxMBSize;
  1315. }
  1316. // Added for field based MC padding by Hyundai(1998-5-9)
  1317.         if (m_vopmd.bInterlace && m_volmd.bShapeOnly == FALSE)
  1318.                 fieldBasedMCPadding (field_pmbmd, m_pvopcCurrQ);
  1319. // End of Hyundai(1998-5-9)
  1321. }