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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

mbenc.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. Simon Winder (swinder@microsoft.com), Microsoft Corporation
  8. (date: June, 1997)
  9. and edited by
  10.         Wei Wu (weiwu@stallion.risc.rockwell.com) Rockwell Science Center
  12. and also edited by
  13. Yoshihiro Kikuchi (TOSHIBA CORPORATION)
  14. Takeshi Nagai (TOSHIBA CORPORATION)
  15. Toshiaki Watanabe (TOSHIBA CORPORATION)
  16. Noboru Yamaguchi (TOSHIBA CORPORATION)
  18. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  19. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  20. as specified by the MPEG-4 Video. 
  21. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  22. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  23. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
  24. The original developer of this software module and his/her company, 
  25. the subsequent editors and their companies, 
  26. and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
  27. Copyright is not released for non MPEG-4 Video conforming products. 
  28. Microsoft retains full right to use the code for his/her own purpose, 
  29. assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
  30. This copyright notice must be included in all copies or derivative works. 
  32. Copyright (c) 1996, 1997.
  34. Module Name:
  36. MBenc.cpp
  38. Abstract:
  40. MacroBlock encoder
  42. Revision History:
  44. This software module was edited by
  46. Hiroyuki Katata (katata@imgsl.mkhar.sharp.co.jp), Sharp Corporation
  47. Norio Ito (norio@imgsl.mkhar.sharp.co.jp), Sharp Corporation
  48. Shuichi Watanabe (watanabe@imgsl.mkhar.sharp.co.jp), Sharp Corporation
  49. (date: October, 1997)
  51. for object based temporal scalability.
  53. Dec 20, 1997: Interlaced tools added by NextLevel Systems X.Chen, B. Eifrig
  54.         May. 9   1998:  add boundary by Hyundai Electronics 
  55.                                   Cheol-Soo Park (cspark@super5.hyundai.co.kr) 
  56. May 9, 1999: tm5 rate control by DemoGraFX, duhoff@mediaone.net
  58. NOTE:
  60. m_pvopfCurrQ holds the original data until it is texture quantized
  62. *************************************************************************/
  64. #include <stdlib.h>
  65. #include <math.h>
  66. #include <iostream.h>
  67. #include "typeapi.h"
  68. #include "codehead.h"
  69. #include "mode.hpp"
  70. #include "global.hpp"
  71. #include "entropy/bitstrm.hpp"
  72. #include "entropy/entropy.hpp"
  73. #include "entropy/huffman.hpp"
  74. #include "vopses.hpp"
  75. #include "vopseenc.hpp"
  77. #ifdef __MFC_
  78. #ifdef _DEBUG
  79. #undef THIS_FILE
  80. static char BASED_CODE THIS_FILE[] = __FILE__;
  81. #endif
  83. #define new DEBUG_NEW    
  84. #endif // __MFC_
  86. /*Void CVideoObjectEncoder::encodePVOPMBWithShape (
  87. PixelC* ppxlcRefMBY, PixelC* ppxlcRefMBU, PixelC* ppxlcRefMBV,
  88. PixelC* ppxlcRefMBA, PixelC* ppxlcRefBY,
  89. CMBMode* pmbmd, const CMotionVector* pmv, CMotionVector* pmvBY,
  90. ShapeMode shpmdColocatedMB,
  91. Int imbX, Int imbY,
  92. CoordI x, CoordI y, Int& iQPPrev)
  93. {
  94. encodePVOPMBJustShape(ppxlcRefBY,pmbmd,shpmdColocatedMB,pmv,pmvBY,x,y,imbX,imbY);
  95. dumpCachedShapeBits();
  96. encodePVOPMBTextureWithShape(ppxlcRefMBY,ppxlcRefMBU,ppxlcRefMBV,ppxlcRefMBA,pmbmd,
  97. pmv,imbX,imbY,x,y,iQPPrev);
  98. }*/
  100. Void CVideoObjectEncoder::encodePVOPMBJustShape(
  101. PixelC* ppxlcRefBY, CMBMode* pmbmd, ShapeMode shpmdColocatedMB,
  102. const CMotionVector* pmv, CMotionVector* pmvBY,
  103. CoordI x, CoordI y, Int imbX, Int imbY)
  104. {
  105. m_statsMB.nBitsShape += codeInterShape (
  106. ppxlcRefBY, m_pvopcRefQ0, pmbmd, shpmdColocatedMB,
  107. pmv, pmvBY, x, y, imbX, imbY
  108. );
  110. // change pmbmd to inter if all transparent
  111. decideTransparencyStatus (pmbmd, m_ppxlcCurrMBBY);
  112. }
  114. Void CVideoObjectEncoder::dumpCachedShapeBits()
  115. {
  116. #ifdef __TRACE_AND_STATS_
  117. m_pbitstrmOut->trace("INSERTING PRE-ENCODED MB SHAPE STREAM HEREn");
  118. m_pbitstrmOut->trace(m_pbitstrmOut->getCounter(),"Location Before");
  119. #endif // __TRACE_AND_STATS_
  120. m_pbitstrmOut->putBitStream(*m_pbitstrmShapeMBOut);
  121. #ifdef __TRACE_AND_STATS_
  122. m_pbitstrmOut->trace(m_pbitstrmOut->getCounter(),"Location After");
  123. #endif // __TRACE_AND_STATS_
  124. m_pbitstrmShapeMBOut->flush();
  125. m_pbitstrmShapeMBOut->resetAll();
  126. }
  128. Void CVideoObjectEncoder::encodePVOPMBTextureWithShape(
  129. PixelC* ppxlcRefMBY, PixelC* ppxlcRefMBU, PixelC* ppxlcRefMBV,
  130. PixelC* ppxlcRefMBA, CMBMode* pmbmd, const CMotionVector* pmv,
  131. Int imbX, Int imbY, CoordI x, CoordI y, Int& iQPPrev,
  132. Int &iQPPrevAlpha, Bool &bUseNewQPForVlcThr)
  133. {
  134. // update quantiser
  135. pmbmd->m_stepSize = iQPPrev + pmbmd->m_intStepDelta;
  136. if(bUseNewQPForVlcThr)
  137. pmbmd->m_stepSizeDelayed = pmbmd->m_stepSize;
  138. else
  139. pmbmd->m_stepSizeDelayed = iQPPrev;
  140. iQPPrev = pmbmd->m_stepSize;
  142. if (pmbmd -> m_dctMd == INTRA || pmbmd -> m_dctMd == INTRAQ) {
  143. if(pmbmd -> m_rgTranspStatus [0] == PARTIAL)
  144. LPEPadding (pmbmd);
  146. if (m_volmd.fAUsage == EIGHT_BIT) {
  147. // update alpha quant
  148. if(!m_volmd.bNoGrayQuantUpdate)
  149. {
  150. iQPPrevAlpha = (iQPPrev * m_vopmd.intStepPAlpha) / m_vopmd.intStep;
  151. if(iQPPrevAlpha<1)
  152. iQPPrevAlpha=1;
  153. }
  154. pmbmd->m_stepSizeAlpha = iQPPrevAlpha;
  155. }
  157. assert (pmbmd -> m_rgTranspStatus [0] != ALL);
  158. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  159.                 if (m_vopmd.bInterlace && pmbmd -> m_rgTranspStatus [0] == PARTIAL)
  160.                         boundaryMacroBlockMerge (pmbmd);
  161. // End of Hyundai(1998-5-9)*/
  162. quantizeTextureIntraMB (imbX, imbY, pmbmd, ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA);
  163. codeMBTextureHeadOfPVOP (pmbmd);
  164. sendDCTCoefOfIntraMBTexture (pmbmd);
  165. if (m_volmd.fAUsage == EIGHT_BIT) {
  166. codeMBAlphaHeadOfPVOP (pmbmd);
  167. sendDCTCoefOfIntraMBAlpha (pmbmd);
  168. }
  169. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  170.                 if (m_vopmd.bInterlace && pmbmd -> m_bMerged[0])
  171.                         mergedMacroBlockSplit (pmbmd, ppxlcRefMBY, ppxlcRefMBA);
  172. // End of Hyundai(1998-5-9)*/
  174. bUseNewQPForVlcThr = FALSE;
  175. }
  176. else { // INTER or skipped
  177. if (m_volmd.fAUsage == EIGHT_BIT) {
  178. // update alpha quant
  179. if(!m_volmd.bNoGrayQuantUpdate)
  180. iQPPrevAlpha = (iQPPrev * m_vopmd.intStepPAlpha) / m_vopmd.intStep;
  181. pmbmd->m_stepSizeAlpha = iQPPrevAlpha;
  182. }
  183. if (pmbmd -> m_rgTranspStatus [0] == PARTIAL) {
  184. CoordI xRefUV, yRefUV;
  186. // INTERLACE
  187. // new changes 
  188. if(pmbmd->m_bFieldMV) {
  189. CoordI xRefUV1, yRefUV1;
  190. mvLookupUV (pmbmd, pmv, xRefUV, yRefUV, xRefUV1, yRefUV1);
  191. motionCompFieldUV(m_ppxlcPredMBU, m_ppxlcPredMBV,
  192. m_pvopcRefQ0, x, y, xRefUV, yRefUV, pmbmd->m_bForwardTop);
  193. motionCompFieldUV(m_ppxlcPredMBU + BLOCK_SIZE, m_ppxlcPredMBV + BLOCK_SIZE,
  194. m_pvopcRefQ0, x, y, xRefUV1, yRefUV1, pmbmd->m_bForwardBottom);
  195. }
  196. else {
  197. // ~INTERLACE
  198. mvLookupUVWithShape (pmbmd, pmv, xRefUV, yRefUV);
  199. motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, x, y,
  200. xRefUV, yRefUV, m_vopmd.iRoundingControl,&m_rctRefVOPY0);
  201. }
  202. motionCompMBYEnc (pmv, pmbmd, imbX, imbY, x, y, &m_rctRefVOPY0);
  203. computeTextureErrorWithShape ();
  204. }
  205. else {
  206. // not partial
  207. CoordI xRefUV, yRefUV, xRefUV1, yRefUV1;
  208. mvLookupUV (pmbmd, pmv, xRefUV, yRefUV, xRefUV1, yRefUV1);
  209. // INTERLACE
  210. // new changes 
  211. if(pmbmd->m_bFieldMV) {
  212. motionCompFieldUV(m_ppxlcPredMBU, m_ppxlcPredMBV,
  213. m_pvopcRefQ0, x, y, xRefUV, yRefUV, pmbmd->m_bForwardTop);
  214. motionCompFieldUV(m_ppxlcPredMBU + BLOCK_SIZE, m_ppxlcPredMBV + BLOCK_SIZE,
  215. m_pvopcRefQ0, x, y, xRefUV1, yRefUV1, pmbmd->m_bForwardBottom);
  216. }
  217. else {
  218. // ~INTERLACE
  219. motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, x, y,
  220. xRefUV, yRefUV, m_vopmd.iRoundingControl, &m_rctRefVOPY0);
  221. }
  222. motionCompMBYEnc (pmv, pmbmd, imbX, imbY, x, y, &m_rctRefVOPY0);
  223. computeTextureError ();
  224. }
  225. Bool bSkip = pmbmd->m_bhas4MVForward ? (pmv [1].isZero () && pmv [2].isZero () && pmv [3].isZero () && pmv [4].isZero ())
  226. : (!pmbmd->m_bFieldMV && pmv->isZero()) ;
  227. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  228. if (m_vopmd.bInterlace && pmbmd -> m_rgTranspStatus [0] == PARTIAL)
  229.                         boundaryMacroBlockMerge (pmbmd);
  230. // End of Hyundai(1998-5-9)*/
  232. if(!m_volmd.bAllowSkippedPMBs)
  233. bSkip = FALSE;
  234. quantizeTextureInterMB (pmbmd, pmv, ppxlcRefMBA, bSkip); // decide COD here
  235. codeMBTextureHeadOfPVOP (pmbmd);
  236. if (!pmbmd -> m_bSkip) {
  237. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  238.             if (m_vopmd.bInterlace && pmbmd -> m_bMerged[0])
  239.                     swapTransparentModes (pmbmd, BBS);
  240. // End of Hyundai(1998-5-9)*/
  241. m_statsMB.nBitsMV += encodeMVWithShape (pmv, pmbmd, imbX, imbY);
  242. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  243. if (m_vopmd.bInterlace && pmbmd -> m_bMerged[0])
  244. swapTransparentModes (pmbmd, BBM);
  245. // End of Hyundai(1998-5-9)*/
  246. sendDCTCoefOfInterMBTexture (pmbmd);
  247. // addErrorAndPredToCurrQ (ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV); // delete by Hyundai, ok swinder
  248. }
  249. else
  250. assignPredToCurrQ (ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV);
  251. if (m_volmd.fAUsage == EIGHT_BIT) {
  252. codeMBAlphaHeadOfPVOP (pmbmd);
  253. if (pmbmd -> m_CODAlpha == ALPHA_CODED) {
  254. sendDCTCoefOfInterMBAlpha (pmbmd);
  255. // addAlphaErrorAndPredToCurrQ (ppxlcRefMBA); // delete by Hyundai. ok swinder
  256. }
  257. else if(pmbmd -> m_CODAlpha == ALPHA_SKIPPED)
  258. assignAlphaPredToCurrQ (ppxlcRefMBA);
  259. }
  260. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  261.                 if (m_vopmd.bInterlace && pmbmd -> m_bMerged[0])
  262.                         mergedMacroBlockSplit (pmbmd);
  263. // End of Hyundai(1998-5-9)*/
  264.         if (!pmbmd -> m_bSkip)
  265. {
  266. bUseNewQPForVlcThr = FALSE;
  267.             addErrorAndPredToCurrQ (ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV);
  268. }
  269.         if (m_volmd.fAUsage == EIGHT_BIT && pmbmd -> m_CODAlpha == ALPHA_CODED)
  270.             addAlphaErrorAndPredToCurrQ (ppxlcRefMBA);
  271. }
  272. }
  274. Void CVideoObjectEncoder::encodePVOPMB (
  275. PixelC* ppxlcRefMBY, PixelC* ppxlcRefMBU, PixelC* ppxlcRefMBV,
  276. CMBMode* pmbmd, const CMotionVector* pmv,
  277. Int iMBX, Int iMBY,
  278. CoordI x, CoordI y
  279. )
  280. {
  281. // For Sprite update macroblock there is no motion compensation 
  282. if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP) {
  283. if ( m_bSptMB_NOT_HOLE ) {
  284. m_iNumSptMB++ ;      
  285. CopyCurrQToPred(ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV);
  286. computeTextureError ();
  287. Bool bSkip = pmbmd->m_bhas4MVForward ? (pmv [1].isZero () && pmv [2].isZero () && pmv [3].isZero () && pmv [4].isZero ())
  288.  : pmv->isZero ();
  289. quantizeTextureInterMB (pmbmd, pmv, NULL, bSkip); // decide COD here
  290. codeMBTextureHeadOfPVOP (pmbmd);
  291. if (!pmbmd -> m_bSkip) {
  292. sendDCTCoefOfInterMBTexture (pmbmd);
  293. addErrorAndPredToCurrQ (ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV);
  294. }
  295. }
  296. else {
  297. pmbmd -> m_bSkip = TRUE;
  298. codeMBTextureHeadOfPVOP (pmbmd);
  299. }
  300. return;
  301. }
  303. if (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ) {
  304. pmbmd->m_bSkip = FALSE; //in case use by direct mode in the future
  305. quantizeTextureIntraMB (iMBX, iMBY, pmbmd, ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, NULL);
  306. codeMBTextureHeadOfPVOP (pmbmd);
  307. sendDCTCoefOfIntraMBTexture (pmbmd);
  308. }
  309. else {
  310. CoordI xRefUV, yRefUV, xRefUV1, yRefUV1;
  311. mvLookupUV (pmbmd, pmv, xRefUV, yRefUV, xRefUV1, yRefUV1);
  312. // INTERLACE
  313. // pmbmd->m_rgTranspStatus[0] = NONE; // This a rectangular VOP 
  314. if(pmbmd->m_bFieldMV) {
  315. motionCompFieldUV(m_ppxlcPredMBU, m_ppxlcPredMBV,
  316. m_pvopcRefQ0, x, y, xRefUV, yRefUV, pmbmd->m_bForwardTop);
  317. motionCompFieldUV(m_ppxlcPredMBU + BLOCK_SIZE, m_ppxlcPredMBV + BLOCK_SIZE,
  318. m_pvopcRefQ0, x, y, xRefUV1, yRefUV1, pmbmd->m_bForwardBottom);
  319. }
  320. else 
  321. // ~INTERLACE
  322. motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, x, y,
  323. xRefUV, yRefUV, m_vopmd.iRoundingControl,&m_rctRefVOPY0);
  324. motionCompMBYEnc (pmv, pmbmd, iMBX, iMBY, x, y, &m_rctRefVOPY0);
  325. computeTextureError ();
  326. Bool bSkip = pmbmd->m_bhas4MVForward ? (pmv [1].isZero () && pmv [2].isZero () && pmv [3].isZero () && pmv [4].isZero ())
  327.             : (!pmbmd->m_bFieldMV && pmv->isZero());
  328. if(!m_volmd.bAllowSkippedPMBs)
  329. bSkip = FALSE;
  330. quantizeTextureInterMB (pmbmd, pmv, NULL, bSkip); // decide COD here
  331. codeMBTextureHeadOfPVOP (pmbmd);
  332. if (!pmbmd -> m_bSkip) {
  333. if(!(m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 3))
  334. m_statsMB.nBitsMV += encodeMVVP (pmv, pmbmd, iMBX, iMBY);
  335. sendDCTCoefOfInterMBTexture (pmbmd);
  336. addErrorAndPredToCurrQ (ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV);
  337. }
  338. else {
  339. assignPredToCurrQ (ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV);
  340. }
  341. }
  342. }
  345. Void CVideoObjectEncoder::encodeBVOPMB (
  346. PixelC* ppxlcCurrQMBY, PixelC* ppxlcCurrQMBU, PixelC* ppxlcCurrQMBV,
  347. CMBMode* pmbmd, const CMotionVector* pmv, const CMotionVector* pmvBackward,
  348. const CMBMode* pmbmdRef, const CMotionVector* pmvRef,
  349. Int iMBX, Int iMBY,
  350. CoordI x, CoordI y
  351. )
  352. {
  353. motionCompAndDiff_BVOP_MB (pmv, pmvBackward, pmbmd, x, y, &m_rctRefVOPY0, &m_rctRefVOPY1);
  354. Bool bSkip;
  355. if (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 0 &&
  356.     pmbmd->m_mbType == FORWARD)
  357. bSkip = (pmv->m_vctTrueHalfPel.x ==0 && pmv->m_vctTrueHalfPel.y == 0);
  358. else if (pmbmd->m_mbType == DIRECT)
  359. bSkip = (pmbmd->m_vctDirectDeltaMV.x ==0 && pmbmd->m_vctDirectDeltaMV.y == 0);
  360. else 
  361. bSkip = FALSE;
  362. quantizeTextureInterMB (pmbmd, pmv, NULL, bSkip); // decide COD here; skip not allowed in non-direct mode
  363. codeMBTextureHeadOfBVOP (pmbmd);
  364. if (!pmbmd->m_bSkip) {
  365. m_statsMB.nBitsMV += encodeMVofBVOP (pmv, pmvBackward, pmbmd, iMBX, iMBY, pmvRef, pmbmdRef);
  366. sendDCTCoefOfInterMBTexture (pmbmd);
  367. addErrorAndPredToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
  368. }
  369. else
  370. assignPredToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
  371. }
  373. Void CVideoObjectEncoder::encodeBVOPMB_WithShape (
  374. PixelC* ppxlcCurrQMBY, PixelC* ppxlcCurrQMBU, PixelC* ppxlcCurrQMBV, PixelC* ppxlcCurrQMBA, PixelC* ppxlcCurrQBY,
  375. CMBMode* pmbmd, const CMotionVector* pmv, const CMotionVector* pmvBackward, 
  376. CMotionVector* pmvBY, ShapeMode shpmdColocatedMB,
  377. const CMBMode* pmbmdRef, const CMotionVector* pmvRef,
  378. Int iMBX, Int iMBY,
  379. CoordI x, CoordI y, Int &iQPPrev, Int &iQPPrevAlpha
  380. )
  381. {
  382. pmbmd->m_stepSize = iQPPrev;
  384. if(!m_volmd.bNoGrayQuantUpdate)
  385. {
  386. iQPPrevAlpha = (iQPPrev * m_vopmd.intStepBAlpha) / m_vopmd.intStepB;
  387. if(iQPPrevAlpha<1)
  388. iQPPrevAlpha=1;
  389. }
  390. pmbmd->m_stepSizeAlpha = iQPPrevAlpha;
  392. m_statsMB.nBitsShape += codeInterShape (
  393. ppxlcCurrQBY, 
  394. m_vopmd.fShapeBPredDir==B_FORWARD ? m_pvopcRefQ0 : m_pvopcRefQ1,
  395. pmbmd, shpmdColocatedMB,
  396. NULL, pmvBY, 
  397. x, y, 
  398. iMBX, iMBY
  399. );
  400. downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV);
  401. decideTransparencyStatus (pmbmd, m_ppxlcCurrMBBY); // change pmbmd to inter if all transparent
  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 && pmbmd->m_rgTranspStatus [0] != ALL) {
  406. if (pmbmd->m_rgTranspStatus [0] == PARTIAL)
  407. motionCompAndDiff_BVOP_MB_WithShape (pmv, pmvBackward, pmbmd, x, y, &m_rctRefVOPY0, &m_rctRefVOPY1);
  408. else
  409. motionCompAndDiff_BVOP_MB (pmv, pmvBackward, pmbmd, x, y, &m_rctRefVOPY0, &m_rctRefVOPY1);
  410. Bool bSkip = FALSE;
  411. if (pmbmd->m_mbType == DIRECT) {
  412. if(pmvRef == NULL) //just to be safe
  413. pmbmd->m_vctDirectDeltaMV = pmv->m_vctTrueHalfPel;
  414. bSkip = (pmbmd->m_vctDirectDeltaMV.x == 0) && (pmbmd->m_vctDirectDeltaMV.y == 0);
  415. }
  416. if(m_volmd.fAUsage == EIGHT_BIT)
  417. motionCompAndDiffAlpha_BVOP_MB (
  418. pmv,
  419. pmvBackward, 
  420. pmbmd, 
  421. x, y,
  422. &m_rctRefVOPY0, &m_rctRefVOPY1
  423. );
  424. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  425. if (m_vopmd.bInterlace && pmbmd -> m_rgTranspStatus [0] == PARTIAL)
  426.                         boundaryMacroBlockMerge (pmbmd);
  427. // End of Hyundai(1998-5-9)*/
  428. quantizeTextureInterMB (pmbmd, pmv, ppxlcCurrQMBA, bSkip); // decide COD here; skip not allowed in non-direct mode
  429. codeMBTextureHeadOfBVOP (pmbmd);
  430. if (!pmbmd -> m_bSkip) {
  431. m_statsMB.nBitsMV += encodeMVofBVOP (pmv, pmvBackward, pmbmd,
  432. iMBX, iMBY, pmvRef, pmbmdRef); // need to see the MB type to decide what MV to be sent
  433. sendDCTCoefOfInterMBTexture (pmbmd);
  434. //addErrorAndPredToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV); // delete by Hyundai, ok swinder
  435. }
  436. else
  437. assignPredToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
  438. if (m_volmd.fAUsage == EIGHT_BIT) {
  439. codeMBAlphaHeadOfBVOP (pmbmd);
  440. if (pmbmd -> m_CODAlpha == ALPHA_CODED) {
  441. sendDCTCoefOfInterMBAlpha (pmbmd);
  442. //addAlphaErrorAndPredToCurrQ (ppxlcCurrQMBA); // delete by Hyundai, ok swinder
  443. }
  444. else if(pmbmd -> m_CODAlpha == ALPHA_SKIPPED)
  445. assignAlphaPredToCurrQ (ppxlcCurrQMBA);
  446. }
  447. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  448.                 if (m_vopmd.bInterlace && pmbmd -> m_bMerged[0])
  449.                         mergedMacroBlockSplit (pmbmd);
  450. // End of Hyundai(1998-5-9)*/
  451.         if (!pmbmd -> m_bSkip)
  452. addErrorAndPredToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
  453.         if (m_volmd.fAUsage == EIGHT_BIT && pmbmd -> m_CODAlpha == ALPHA_CODED)
  454.     addAlphaErrorAndPredToCurrQ (ppxlcCurrQMBA);
  455. }
  456. }
  458. Void CVideoObjectEncoder::codeMBTextureHeadOfIVOP (const CMBMode* pmbmd)
  459. {
  460. UInt CBPC = (pmbmd->getCodedBlockPattern (U_BLOCK) << 1)
  461. | pmbmd->getCodedBlockPattern (V_BLOCK);
  462. //per defintion of H.263's CBPC 
  463. assert (CBPC >= 0 && CBPC <= 3);
  464. Int CBPY = 0;
  465. UInt cNonTrnspBlk = 0, iBlk;
  466. for (iBlk = (UInt) Y_BLOCK1; iBlk <= (UInt) Y_BLOCK4; iBlk++) {
  467. if (pmbmd->m_rgTranspStatus [iBlk] != ALL)
  468. cNonTrnspBlk++;
  469. }
  470. UInt iBitPos = 1;
  471. for (iBlk = (UInt) Y_BLOCK1; iBlk <= (UInt) Y_BLOCK4; iBlk++) {
  472. if (pmbmd->m_rgTranspStatus [iBlk] != ALL) {
  473. CBPY |= pmbmd->getCodedBlockPattern ((BlockNum) iBlk) << (cNonTrnspBlk - iBitPos);
  474. iBitPos++;
  475. }
  476. }
  477. assert (CBPY >= 0 && CBPY <= 15); //per defintion of H.263's CBPY 
  479. Int iSymbol = 4 * pmbmd->m_dctMd + CBPC;
  480. assert (iSymbol >= 0 && iSymbol <= 7); //send MCBPC
  481. #ifdef __TRACE_AND_STATS_
  482. m_pbitstrmOut->trace (iSymbol, "MB_MCBPC");
  483. #endif // __TRACE_AND_STATS_
  484. m_statsMB.nBitsMCBPC += m_pentrencSet->m_pentrencMCBPCintra->encodeSymbol (iSymbol, "MB_MCBPC");
  485. //fprintf(stderr,"MCBPC = %dn",iSymbol);
  487. m_pbitstrmOut->putBits (pmbmd->m_bACPrediction, 1, "MB_ACPRED");
  488. m_statsMB.nBitsIntraPred++;
  489. //fprintf(stderr,"ACPred = %dn",pmbmd->m_bACPrediction);
  491. #ifdef __TRACE_AND_STATS_
  492. m_pbitstrmOut->trace (cNonTrnspBlk, "MB_NumNonTranspBlks");
  493. m_pbitstrmOut->trace (CBPY, "MB_CBPY (I-style)");
  494. #endif // __TRACE_AND_STATS_
  495. switch (cNonTrnspBlk) {
  496. case 1:
  497. m_statsMB.nBitsCBPY += m_pentrencSet->m_pentrencCBPY1->encodeSymbol (CBPY, "MB_CBPY");
  498. break;
  499. case 2:
  500. m_statsMB.nBitsCBPY += m_pentrencSet->m_pentrencCBPY2->encodeSymbol (CBPY, "MB_CBPY");
  501. break;
  502. case 3:
  503. m_statsMB.nBitsCBPY += m_pentrencSet->m_pentrencCBPY3->encodeSymbol (CBPY, "MB_CBPY");
  504. break;
  505. case 4:
  506. m_statsMB.nBitsCBPY += m_pentrencSet->m_pentrencCBPY->encodeSymbol (CBPY, "MB_CBPY");
  507. break;
  508. default:
  509. assert (FALSE);
  510. }
  511. //fprintf(stderr,"CBPY = %dn",CBPY);
  512. m_statsMB.nIntraMB++;
  513. if (pmbmd->m_dctMd == INTRAQ) {
  514. Int DQUANT = pmbmd->m_intStepDelta; //send DQUANT
  515. assert (DQUANT >= -2 && DQUANT <= 2);
  516. if (DQUANT != 0) {
  517. if (sign (DQUANT) == 1)
  518. m_pbitstrmOut->putBits (DQUANT + 1, 2, "MB_DQUANT");
  519. else
  520. m_pbitstrmOut->putBits (-1 - DQUANT, 2, "MB_DQUANT");
  521. m_statsMB.nBitsDQUANT += 2;
  522. }
  523. }
  524. // INTERLACE
  525. if(m_vopmd.bInterlace==TRUE) {
  526. m_pbitstrmOut->putBits (pmbmd->m_bFieldDCT, 1, "DCT_TYPE"); // send dct_type
  527. m_statsMB.nBitsInterlace += 1;
  528. }
  529. // ~INTERLACE
  530. }
  532. Void CVideoObjectEncoder::codeMBTextureHeadOfPVOP (const CMBMode* pmbmd)
  533. {
  534. UInt CBPC = (pmbmd->getCodedBlockPattern (U_BLOCK) << 1)
  535. | pmbmd->getCodedBlockPattern (V_BLOCK);
  536. //per defintion of H.263's CBPC 
  537. assert (CBPC >= 0 && CBPC <= 3);
  538. Int CBPY = 0;
  539. UInt cNonTrnspBlk = 0, iBlk;
  540. for (iBlk = (UInt) Y_BLOCK1; iBlk <= (UInt) Y_BLOCK4; iBlk++) {
  541. if (pmbmd->m_rgTranspStatus [iBlk] != ALL)
  542. cNonTrnspBlk++;
  543. }
  544. UInt iBitPos = 1;
  545. for (iBlk = (UInt) Y_BLOCK1; iBlk <= (UInt) Y_BLOCK4; iBlk++) {
  546. if (pmbmd->m_rgTranspStatus [iBlk] != ALL) {
  547. CBPY |= pmbmd->getCodedBlockPattern ((BlockNum) iBlk) << (cNonTrnspBlk - iBitPos);
  548. iBitPos++;
  549. }
  550. }
  551. assert (CBPY >= 0 && CBPY <= 15); //per defintion of H.263's CBPY 
  552. m_pbitstrmOut->putBits (pmbmd->m_bSkip, 1, "MB_Skip");
  553. m_statsMB.nBitsCOD++;
  554. if (pmbmd->m_bSkip)
  555. m_statsMB.nSkipMB++;
  556. else {
  557. Int iMBtype; //per H.263's MBtype
  558. if (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ)
  559. iMBtype = pmbmd->m_dctMd + 3;
  560. else
  561. iMBtype = (pmbmd -> m_dctMd - 2) | pmbmd -> m_bhas4MVForward << 1;
  562. assert (iMBtype >= 0 && iMBtype <= 4);
  563. #ifdef __TRACE_AND_STATS_
  564. m_pbitstrmOut->trace (iMBtype, "MB_MBtype");
  565. m_pbitstrmOut->trace (CBPC, "MB_CBPC");
  566. #endif // __TRACE_AND_STATS_
  567. m_statsMB.nBitsMCBPC += m_pentrencSet->m_pentrencMCBPCinter->encodeSymbol (iMBtype * 4 + CBPC, "MCBPC");
  568. if (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ) {
  569. m_pbitstrmOut->putBits (pmbmd->m_bACPrediction, 1, "MB_ACPRED");
  570. m_statsMB.nBitsIntraPred++;
  571. #ifdef __TRACE_AND_STATS_
  572. m_pbitstrmOut->trace (cNonTrnspBlk, "MB_NumNonTranspBlks");
  573. m_pbitstrmOut->trace (CBPY, "MB_CBPY (I-style)");
  574. #endif // __TRACE_AND_STATS_
  575. switch (cNonTrnspBlk) {
  576. case 1:
  577. m_statsMB.nBitsCBPY += m_pentrencSet->m_pentrencCBPY1->encodeSymbol (CBPY, "MB_CBPY");
  578. break;
  579. case 2:
  580. m_statsMB.nBitsCBPY += m_pentrencSet->m_pentrencCBPY2->encodeSymbol (CBPY, "MB_CBPY");
  581. break;
  582. case 3:
  583. m_statsMB.nBitsCBPY += m_pentrencSet->m_pentrencCBPY3->encodeSymbol (CBPY, "MB_CBPY");
  584. break;
  585. case 4:
  586. m_statsMB.nBitsCBPY += m_pentrencSet->m_pentrencCBPY->encodeSymbol (CBPY, "MB_CBPY");
  587. break;
  588. default:
  589. assert (FALSE);
  590. }
  591. m_statsMB.nIntraMB++;
  592. }
  593. else {
  594. #ifdef __TRACE_AND_STATS_
  595. m_pbitstrmOut->trace (cNonTrnspBlk, "MB_NumNonTranspBlks");
  596. m_pbitstrmOut->trace (CBPY, "MB_CBPY (P-style)");
  597. #endif // __TRACE_AND_STATS_
  598. switch (cNonTrnspBlk) {
  599. case 1:
  600. m_statsMB.nBitsCBPY += m_pentrencSet->m_pentrencCBPY1->encodeSymbol (1 - CBPY, "MB_CBPY");
  601. break;
  602. case 2:
  603. m_statsMB.nBitsCBPY += m_pentrencSet->m_pentrencCBPY2->encodeSymbol (3 - CBPY, "MB_CBPY");
  604. break;
  605. case 3:
  606. m_statsMB.nBitsCBPY += m_pentrencSet->m_pentrencCBPY3->encodeSymbol (7 - CBPY, "MB_CBPY");
  607. break;
  608. case 4:
  609. m_statsMB.nBitsCBPY += m_pentrencSet->m_pentrencCBPY->encodeSymbol (15 - CBPY, "MB_CBPY");
  610. break;
  611. default:
  612. assert (FALSE);
  613. }
  614. if(pmbmd ->m_bhas4MVForward)
  615. m_statsMB.nInter4VMB++;
  616. // INTERLACE
  617. else if (pmbmd-> m_bFieldMV)
  618. m_statsMB.nFieldForwardMB++;
  619. // ~INTERLACE
  620. else
  621. m_statsMB.nInterMB++;
  622. }
  623. if (pmbmd->m_dctMd == INTERQ || pmbmd->m_dctMd == INTRAQ) {
  624. Int DQUANT = pmbmd->m_intStepDelta; //send DQUANT
  625. assert (DQUANT >= -2 && DQUANT <= 2);
  626. if (DQUANT != 0) {
  627. if (sign (DQUANT) == 1)
  628. m_pbitstrmOut->putBits (DQUANT + 1, 2, "MB_DQUANT");
  629. else
  630. m_pbitstrmOut->putBits (-1 - DQUANT, 2, "MB_DQUANT");
  631. m_statsMB.nBitsDQUANT += 2;
  632. }
  633. }
  634. // INTERLACE
  635. if (m_vopmd.bInterlace == TRUE) {
  636. if((pmbmd->m_dctMd == INTRA) || (pmbmd->m_dctMd == INTRAQ) || (CBPC || CBPY)) {
  637. m_pbitstrmOut->putBits (pmbmd->m_bFieldDCT, 1, "DCT_Type");
  638. m_statsMB.nBitsInterlace += 1;
  639. }
  640. if((pmbmd->m_dctMd == INTER || pmbmd->m_dctMd == INTERQ )&&(pmbmd -> m_bhas4MVForward == FALSE)) {
  641. m_pbitstrmOut->putBits (pmbmd->m_bFieldMV, 1, "Field_Prediction");
  642. m_statsMB.nBitsInterlace += 1;
  643. if(pmbmd->m_bFieldMV) {
  644. m_pbitstrmOut->putBits (pmbmd->m_bForwardTop, 1, "Forward_Top_Field_Ref");
  645. m_pbitstrmOut->putBits (pmbmd->m_bForwardBottom, 1, "Forward_Bot_Field_Ref");
  646. m_statsMB.nBitsInterlace += 2;
  647. }
  648. }
  649. }
  650. // ~INTERLACE
  651. }
  652. }
  654. Void CVideoObjectEncoder::codeMBTextureHeadOfBVOP (const CMBMode* pmbmd)
  655. {
  656.   U8 uchCBPB = 0;
  657. if (pmbmd->m_bSkip) {
  658. if (m_volmd.volType == BASE_LAYER) {
  659. assert (pmbmd -> m_rgTranspStatus [0] != ALL);
  660. if (pmbmd->m_bColocatedMBSkip)
  661. return;
  662. }
  663. m_pbitstrmOut->putBits (1, 1, "MB_MODB");
  664. m_statsMB.nBitsMODB++;
  665. m_statsMB.nSkipMB++;
  666. if(m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 0)
  667. return;
  668. }
  669. else {
  670. Int iCBPC = (pmbmd->getCodedBlockPattern (U_BLOCK) << 1) | 
  671.  pmbmd->getCodedBlockPattern (V_BLOCK); //per defintion of H.263's CBPC 
  672. assert (iCBPC >= 0 && iCBPC <= 3);
  673. Int iCBPY = 0;
  674. Int iNumNonTrnspBlk = 0, iBlk;
  675. for (iBlk = Y_BLOCK1; iBlk <= Y_BLOCK4; iBlk++) 
  676. iNumNonTrnspBlk += (pmbmd->m_rgTranspStatus [iBlk] != ALL);
  677. Int iBitPos = 1;
  678. for (iBlk = Y_BLOCK1; iBlk <= Y_BLOCK4; iBlk++) {
  679. if (pmbmd->m_rgTranspStatus [iBlk] != ALL) {
  680. iCBPY |= pmbmd->getCodedBlockPattern ((BlockNum) iBlk) << (iNumNonTrnspBlk - iBitPos);
  681. iBitPos++;
  682. }
  683. }
  684. assert (iCBPY >= 0 && iCBPY <= 15); //per defintion of H.263's CBPY 
  685. uchCBPB = (iCBPY << 2 | iCBPC) & 0x3F;
  687. if (uchCBPB == 0) {
  688. m_pbitstrmOut->putBits (1, 2, "MB_MODB");
  689. m_statsMB.nBitsMODB += 2;
  690. if (m_volmd.volType == BASE_LAYER || (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode != 0))
  691. m_statsMB.nBitsMBTYPE += m_pentrencSet->m_pentrencMbTypeBVOP->encodeSymbol (pmbmd->m_mbType, "MB_TYPE");
  692. else {
  693. Int iMbtypeBits =0;
  694. if(pmbmd->m_mbType == FORWARD) iMbtypeBits = 1;
  695. else if(pmbmd->m_mbType == INTERPOLATE) iMbtypeBits = 2;
  696. else if(pmbmd->m_mbType == BACKWARD) iMbtypeBits = 3;
  697. Int iMbtypeValue = 1;
  698. m_statsMB.nBitsMBTYPE += iMbtypeBits;
  699. m_pbitstrmOut->putBits (iMbtypeValue, iMbtypeBits, "MB_TYPE");
  700. }
  701. }
  702. else {
  703. m_pbitstrmOut->putBits (0, 2,"MB_MODB");
  704. m_statsMB.nBitsMODB += 2;
  705. //m_stat.nBitsMBTYPE += m_pentrencMbTypeBVOP->encodeSymbol (pmbmd->m_mbType, "MB_TYPE");
  706. if (m_volmd.volType == BASE_LAYER || (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode != 0))
  707. m_statsMB.nBitsMBTYPE += m_pentrencSet->m_pentrencMbTypeBVOP->encodeSymbol (pmbmd->m_mbType, "MB_TYPE");
  708. else {
  709. Int iMbtypeBits =0;
  710. if(pmbmd->m_mbType == FORWARD) iMbtypeBits = 1;
  711. else if(pmbmd->m_mbType == INTERPOLATE) iMbtypeBits = 2;
  712. else if(pmbmd->m_mbType == BACKWARD) iMbtypeBits = 3;
  713. Int iMbtypeValue = 1;
  714. m_statsMB.nBitsMBTYPE += iMbtypeBits;
  715. m_pbitstrmOut->putBits (iMbtypeValue, iMbtypeBits, "MB_TYPE");
  716. }
  717. m_pbitstrmOut -> putBits (uchCBPB, iNumNonTrnspBlk + 2, "MB_CBPB");
  718. m_statsMB.nBitsCBPB += iNumNonTrnspBlk + 2;
  719. }
  720. switch (pmbmd->m_mbType) {
  721. case FORWARD:
  722. m_statsMB.nForwardMB++;
  723. break;
  724. case BACKWARD:
  725. m_statsMB.nBackwardMB++;
  726. break;
  727. case DIRECT:
  728. m_statsMB.nDirectMB++;
  729. break;
  730. case INTERPOLATE:
  731. m_statsMB.nInterpolateMB++;
  732. break;
  733. default:
  734. assert (FALSE);
  735. }
  736. }
  737. if (pmbmd->m_mbType != DIRECT) {
  738. if (uchCBPB != 0) { //no need to send when MODB = 10
  739. Int DQUANT = pmbmd->m_intStepDelta; //send DQUANT
  740. assert (DQUANT == -2 || DQUANT == 2 || DQUANT == 0);
  741. if (DQUANT == 0) {
  742. m_pbitstrmOut->putBits ((Int) 0, (UInt) 1, "MB_DQUANT");
  743. m_statsMB.nBitsDQUANT += 1;
  744. }
  745. else {
  746. if (DQUANT == 2)
  747. m_pbitstrmOut->putBits (3, 2, "MB_DQUANT");
  748. else 
  749. m_pbitstrmOut->putBits (2, 2, "MB_DQUANT");
  750. m_statsMB.nBitsDQUANT += 2;
  751. }
  752. }
  753. }
  754. // INTERLACE
  755. if (pmbmd->m_bSkip) {
  756. if (m_vopmd.bInterlace && (pmbmd->m_mbType == DIRECT) && pmbmd->m_bFieldMV)
  757. m_statsMB.nFieldDirectMB++;
  758. } else if (m_vopmd.bInterlace) {
  759. if (uchCBPB) {
  760. m_pbitstrmOut->putBits((Int) pmbmd->m_bFieldDCT, 1, "DCT_TYPE");
  761. m_statsMB.nBitsInterlace++;
  762. }
  763. if (pmbmd->m_bFieldMV) {
  764. switch (pmbmd->m_mbType) {
  766. case FORWARD:
  767. m_pbitstrmOut->putBits(1, 1, "FIELD_PREDICTION");
  768. m_pbitstrmOut->putBits((Int)pmbmd->m_bForwardTop,    1, "FORWARD_TOP_FIELD_REFERENCE");
  769. m_pbitstrmOut->putBits((Int)pmbmd->m_bForwardBottom, 1, "FORWARD_BOTTOM_FIELD_REFERENCE");
  770. m_statsMB.nFieldForwardMB++;
  771. m_statsMB.nBitsInterlace += 3;
  772. break;
  774. case BACKWARD:
  775. m_pbitstrmOut->putBits(1, 1, "FIELD_PREDICTION");
  776. m_pbitstrmOut->putBits((Int)pmbmd->m_bBackwardTop,    1, "BACKWARD_TOP_FIELD_REFERENCE");
  777. m_pbitstrmOut->putBits((Int)pmbmd->m_bBackwardBottom, 1, "BACKWARD_BOTTOM_FIELD_REFERENCE");
  778. m_statsMB.nFieldBackwardMB++;
  779. m_statsMB.nBitsInterlace += 3;
  780. break;
  782. case INTERPOLATE:
  783. m_pbitstrmOut->putBits(1, 1, "FIELD_PREDICTION");
  784. m_pbitstrmOut->putBits((Int)pmbmd->m_bForwardTop,     1, "FORWARD_TOP_FIELD_REFERENCE");
  785. m_pbitstrmOut->putBits((Int)pmbmd->m_bForwardBottom,  1, "FORWARD_BOTTOM_FIELD_REFERENCE");
  786. m_pbitstrmOut->putBits((Int)pmbmd->m_bBackwardTop,    1, "BACKWARD_TOP_FIELD_REFERENCE");
  787. m_pbitstrmOut->putBits((Int)pmbmd->m_bBackwardBottom, 1, "BACKWARD_BOTTOM_FIELD_REFERENCE");
  788. m_statsMB.nFieldInterpolateMB++;
  789. m_statsMB.nBitsInterlace += 5;
  790. break;
  792. case DIRECT:
  793. m_statsMB.nFieldDirectMB++;
  794. break;
  795. }
  796. } else if (pmbmd->m_mbType != DIRECT) {
  797. m_pbitstrmOut->putBits(0, 1, "FIELD_PREDICTION");
  798. m_statsMB.nBitsInterlace++;
  799. }
  800. }
  801. // ~INTERLACE
  802. }
  804. Void CVideoObjectEncoder::copyToCurrBuffWithShape (
  805. const PixelC* ppxlcCurrY, const PixelC* ppxlcCurrU, const PixelC* ppxlcCurrV,
  806. const PixelC* ppxlcCurrBY, const PixelC* ppxlcCurrA,
  807. Int iWidthY, Int iWidthUV
  808. )
  809. {
  810. PixelC* ppxlcCurrMBY = m_ppxlcCurrMBY;
  811. PixelC* ppxlcCurrMBU = m_ppxlcCurrMBU;
  812. PixelC* ppxlcCurrMBV = m_ppxlcCurrMBV;
  813. PixelC* ppxlcCurrMBBY = m_ppxlcCurrMBBY;
  814. Int ic;
  815. for (ic = 0; ic < BLOCK_SIZE; ic++) {
  816. memcpy (ppxlcCurrMBY, ppxlcCurrY, MB_SIZE*sizeof(PixelC)); 
  817. memcpy (ppxlcCurrMBU, ppxlcCurrU, BLOCK_SIZE*sizeof(PixelC));
  818. memcpy (ppxlcCurrMBV, ppxlcCurrV, BLOCK_SIZE*sizeof(PixelC));
  819. memcpy (ppxlcCurrMBBY, ppxlcCurrBY, MB_SIZE*sizeof(PixelC));
  820. ppxlcCurrMBY += MB_SIZE; ppxlcCurrY += iWidthY;
  821. ppxlcCurrMBU += BLOCK_SIZE; ppxlcCurrU += iWidthUV;
  822. ppxlcCurrMBV += BLOCK_SIZE; ppxlcCurrV += iWidthUV;
  823. ppxlcCurrMBBY += MB_SIZE; ppxlcCurrBY += iWidthY;
  825. memcpy (ppxlcCurrMBY, ppxlcCurrY, MB_SIZE*sizeof(PixelC)); // two rows for Y
  826. memcpy (ppxlcCurrMBBY, ppxlcCurrBY, MB_SIZE*sizeof(PixelC));
  827. ppxlcCurrMBY += MB_SIZE; ppxlcCurrY += iWidthY;
  828. ppxlcCurrMBBY += MB_SIZE; ppxlcCurrBY += iWidthY;
  829. }
  830. if (m_volmd.fAUsage == EIGHT_BIT) {
  831. PixelC* ppxlcCurrMBA = m_ppxlcCurrMBA;
  832. for (ic = 0; ic < MB_SIZE; ic++) {
  833. memcpy (ppxlcCurrMBA, ppxlcCurrA, MB_SIZE*sizeof(PixelC));
  834. ppxlcCurrMBA += MB_SIZE; 
  835. ppxlcCurrA += iWidthY;
  836. }
  837. }
  838. }
  840. Void CVideoObjectEncoder::copyToCurrBuffJustShape(const PixelC* ppxlcCurrBY,
  841.   Int iWidthY)
  842. {
  843. PixelC* ppxlcCurrMBBY = m_ppxlcCurrMBBY;
  844. Int ic;
  845. for (ic = 0; ic < BLOCK_SIZE; ic++) {
  846. memcpy (ppxlcCurrMBBY, ppxlcCurrBY, MB_SIZE*sizeof(PixelC));
  847. ppxlcCurrMBBY += MB_SIZE; ppxlcCurrBY += iWidthY;
  848. memcpy (ppxlcCurrMBBY, ppxlcCurrBY, MB_SIZE*sizeof(PixelC));
  849. ppxlcCurrMBBY += MB_SIZE; ppxlcCurrBY += iWidthY;
  850. }
  851. }
  853. Void CVideoObjectEncoder::copyToCurrBuff (
  854. const PixelC* ppxlcCurrY, const PixelC* ppxlcCurrU, const PixelC* ppxlcCurrV,
  855. Int iWidthY, Int iWidthUV
  856. )
  857. {
  858. PixelC* ppxlcCurrMBY = m_ppxlcCurrMBY;
  859. PixelC* ppxlcCurrMBU = m_ppxlcCurrMBU;
  860. PixelC* ppxlcCurrMBV = m_ppxlcCurrMBV;
  861. Int ic;
  862. for (ic = 0; ic < BLOCK_SIZE; ic++) {
  863. memcpy (ppxlcCurrMBY, ppxlcCurrY, MB_SIZE*sizeof(PixelC));
  864. memcpy (ppxlcCurrMBU, ppxlcCurrU, BLOCK_SIZE*sizeof(PixelC));
  865. memcpy (ppxlcCurrMBV, ppxlcCurrV, BLOCK_SIZE*sizeof(PixelC));
  866. ppxlcCurrMBY += MB_SIZE; ppxlcCurrY += iWidthY;
  867. ppxlcCurrMBU += BLOCK_SIZE; ppxlcCurrU += iWidthUV;
  868. ppxlcCurrMBV += BLOCK_SIZE; ppxlcCurrV += iWidthUV;
  870. memcpy (ppxlcCurrMBY, ppxlcCurrY, MB_SIZE*sizeof(PixelC)); // two rows for Y
  871. ppxlcCurrMBY += MB_SIZE; ppxlcCurrY += iWidthY;
  872. }
  873. }
  875. // compute error signal
  877. Void CVideoObjectEncoder::computeTextureError ()
  878. {
  879. CoordI ix;
  880. // Y
  881. for (ix = 0; ix < MB_SQUARE_SIZE; ix++)
  882. m_ppxliErrorMBY [ix] = m_ppxlcCurrMBY [ix] - m_ppxlcPredMBY [ix];
  884. // UV
  885. for (ix = 0; ix < BLOCK_SQUARE_SIZE; ix++) {
  886. m_ppxliErrorMBU [ix] = m_ppxlcCurrMBU [ix] - m_ppxlcPredMBU [ix];
  887. m_ppxliErrorMBV [ix] = m_ppxlcCurrMBV [ix] - m_ppxlcPredMBV [ix];
  888. }
  890. // Alpha
  891. if(m_volmd.fAUsage==EIGHT_BIT)
  892. for (ix = 0; ix < MB_SQUARE_SIZE; ix++)
  893. m_ppxliErrorMBA [ix] = m_ppxlcCurrMBA [ix] - m_ppxlcPredMBA [ix];
  894. }
  896. Void CVideoObjectEncoder::computeTextureErrorWithShape ()
  897. {
  898. CoordI ix;
  899. // Y
  900. for (ix = 0; ix < MB_SQUARE_SIZE; ix++) {
  901. if (m_ppxlcCurrMBBY [ix] == transpValue)
  902. m_ppxliErrorMBY [ix] = 0; // zero padding
  903. else
  904. m_ppxliErrorMBY [ix] = m_ppxlcCurrMBY [ix] - m_ppxlcPredMBY [ix];
  905. }
  907. // UV
  908. for (ix = 0; ix < BLOCK_SQUARE_SIZE; ix++) {
  909. if (m_ppxlcCurrMBBUV [ix] == transpValue)
  910. m_ppxliErrorMBU [ix] = m_ppxliErrorMBV [ix] = 0;
  911. else {
  912. m_ppxliErrorMBU [ix] = m_ppxlcCurrMBU [ix] - m_ppxlcPredMBU [ix];
  913. m_ppxliErrorMBV [ix] = m_ppxlcCurrMBV [ix] - m_ppxlcPredMBV [ix];
  914. }
  915. }
  917. if(m_volmd.fAUsage==EIGHT_BIT)
  918. for (ix = 0; ix < MB_SQUARE_SIZE; ix++) {
  919. if (m_ppxlcCurrMBBY [ix] == transpValue)
  920. m_ppxliErrorMBA [ix] = 0; // zero padding
  921. else
  922. m_ppxliErrorMBA [ix] = m_ppxlcCurrMBA [ix] - m_ppxlcPredMBA [ix];
  923. }
  924. }
  926. Void CVideoObjectEncoder::computeAlphaError ()
  927. {
  928. CoordI ix;
  930. for (ix = 0; ix < MB_SQUARE_SIZE; ix++) {
  931. if (m_ppxlcCurrMBBY [ix] == transpValue)
  932. m_ppxliErrorMBA [ix] = 0; // zero padding
  933. else
  934. m_ppxliErrorMBA [ix] = m_ppxlcCurrMBA [ix] - m_ppxlcPredMBA [ix];
  935. }
  936. }
  938. Void CVideoObjectEncoder::quantizeTextureIntraMB (
  939. Int imbX, Int imbY,
  940. CMBMode* pmbmd, 
  941. PixelC* ppxlcCurrQMBY, PixelC* ppxlcCurrQMBU, PixelC* ppxlcCurrQMBV,
  942. PixelC* ppxlcCurrQMBA
  943. )
  944. {
  945. assert (pmbmd != NULL);
  946. assert (pmbmd -> m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ);
  947. assert (pmbmd -> m_rgTranspStatus [0] != ALL);
  949. Int iQP = pmbmd->m_stepSize;
  950. #ifdef __TRACE_AND_STATS_
  951. m_statsMB.nQMB++;
  952. m_statsMB.nQp += iQP;
  953. #endif // __TRACE_AND_STATS_
  955. Int iDcScalerY, iDcScalerC, iDcScalerA = 0;
  956. if (iQP <= 4)
  957. {
  958. iDcScalerY = 8;
  959. iDcScalerC = 8;
  960. }
  961. else if (iQP >= 5 && iQP <= 8)
  962. {
  963. iDcScalerY = 2 * iQP;
  964. iDcScalerC = (iQP + 13) / 2;
  965. }
  966. else if (iQP >= 9 && iQP <= 24)
  967. {
  968. iDcScalerY = iQP + 8;
  969. iDcScalerC = (iQP + 13) / 2;
  970. }
  971. else
  972. {
  973. iDcScalerY = 2 * iQP - 16;
  974. iDcScalerC = iQP - 6;
  975. }
  977. Int iQPA = 0;
  978. pmbmd->m_CODAlpha = ALPHA_CODED;
  979. if(m_volmd.fAUsage == EIGHT_BIT)
  980. {
  981. if (pmbmd -> m_stepSizeAlpha < 1)
  982. pmbmd -> m_stepSizeAlpha = 1;
  983. iQPA = pmbmd->m_stepSizeAlpha;
  985. if (iQPA <= 4)
  986. iDcScalerA = 8;
  987. else if (iQPA >= 5 && iQPA <= 8)
  988. iDcScalerA = 2 * iQPA;
  989. else if (iQPA >= 9 && iQPA <= 24)
  990. iDcScalerA = iQPA + 8;
  991. else
  992. iDcScalerA = 2 * iQPA - 16;
  994. if(pmbmd->m_rgTranspStatus [0] == NONE)
  995. {
  996. // need to test gray alpha vals
  997. // CODA = 1 if all==255, can't use TranspStatus, has to be 255
  998. Int i;
  999. Int iThresh = 256 - iQPA;
  1000. pmbmd->m_CODAlpha = ALPHA_ALL255;
  1001. for(i = 0; i<MB_SQUARE_SIZE; i++)
  1002. if(m_ppxlcCurrMBA[i]<=iThresh)
  1003. {
  1004. pmbmd->m_CODAlpha = ALPHA_CODED;
  1005. break;
  1006. }
  1007. if(pmbmd->m_CODAlpha == ALPHA_ALL255)
  1008. {
  1009. pxlcmemset(m_ppxlcCurrMBA, 255, MB_SQUARE_SIZE);
  1010. PixelC *ppxlc = ppxlcCurrQMBA;
  1011. for(i = 0; i<MB_SIZE; i++, ppxlc += m_iFrameWidthY)
  1012. pxlcmemset(ppxlc, 255, MB_SIZE);
  1013. }
  1014. }
  1015. }
  1017. Int iCoefToStart;
  1018. assert (pmbmd -> m_stepSizeDelayed > 0);
  1019. if (pmbmd -> m_stepSizeDelayed >= grgiDCSwitchingThreshold [m_vopmd.iIntraDcSwitchThr])
  1020. {
  1021. pmbmd->m_bCodeDcAsAc = TRUE;
  1022. //pmbmd->m_bCodeDcAsAcAlpha = TRUE; // decision should really be based on alpha quantiser
  1023. iCoefToStart = 0;
  1024. }
  1025. else {
  1026. pmbmd->m_bCodeDcAsAc = FALSE;
  1027. //pmbmd->m_bCodeDcAsAcAlpha = FALSE;
  1028. iCoefToStart = 1;
  1029. }
  1030. pmbmd->m_bCodeDcAsAcAlpha = FALSE;
  1032. //for intra pred
  1033. MacroBlockMemory* pmbmLeft = NULL;
  1034. MacroBlockMemory* pmbmTop = NULL;
  1035. MacroBlockMemory* pmbmLeftTop = NULL;
  1036. CMBMode* pmbmdLeft = NULL;
  1037. CMBMode* pmbmdTop = NULL;
  1038. CMBMode* pmbmdLeftTop = NULL;  
  1039. Int iMBnum = imbY * m_iNumMBX + imbX;
  1040. if (!bVPNoTop(iMBnum)) {
  1041. pmbmTop  = m_rgpmbmAbove [imbX];
  1042. pmbmdTop = pmbmd - m_iNumMBX;
  1043. }
  1044. if (!bVPNoLeft(iMBnum, imbX)) {
  1045. pmbmLeft  = m_rgpmbmCurr [imbX - 1];
  1046. pmbmdLeft = pmbmd -  1;
  1047. }
  1048. if (!bVPNoLeftTop(iMBnum, imbX)) {
  1049. pmbmLeftTop  = m_rgpmbmAbove [imbX - 1];
  1050. pmbmdLeftTop = pmbmd - m_iNumMBX - 1;
  1051. }
  1053. // INTERLACE
  1054. if((pmbmd->m_rgTranspStatus [0] == NONE)&&(m_vopmd.bInterlace == TRUE) ) {
  1055. pmbmd->m_bFieldDCT = FrameFieldDCTDecideC(m_ppxlcCurrMBY);
  1056. m_statsMB.nFieldDCTMB += (Int) pmbmd->m_bFieldDCT;
  1057. }
  1058. else
  1059. pmbmd->m_bFieldDCT = 0;
  1061. pmbmd->m_bSkip = FALSE; // for direct mode reference 
  1062. // ~INTERLACE
  1064. PixelC* rgchBlkDst = NULL;
  1065. PixelC* rgchBlkSrc = NULL;
  1066. Int iWidthDst, iWidthSrc;
  1067. Int iDcScaler;
  1068. Int* rgiCoefQ;
  1069. Int iSumErr = 0; //sum of error to determine intra ac prediction
  1070. Int iBlk;
  1071. Int iBlkEnd;
  1072. if(m_volmd.fAUsage == EIGHT_BIT)
  1073. iBlkEnd = A_BLOCK4;
  1074. else
  1075. iBlkEnd = V_BLOCK;
  1077. for (iBlk = (Int) Y_BLOCK1; iBlk <= iBlkEnd; iBlk++) { // + 1 is because of the indexing
  1078. if (iBlk < (Int) U_BLOCK || iBlk > (Int) V_BLOCK) {
  1079. if(iBlk==A_BLOCK1)
  1080. iSumErr = 0; // start again for alpha
  1081. if (pmbmd -> m_rgTranspStatus [iBlk % 6] == ALL) // %6 hack!!
  1082. continue;
  1083. switch (iBlk) 
  1084. {
  1085. case (Y_BLOCK1): 
  1086. rgchBlkDst = ppxlcCurrQMBY;
  1087. rgchBlkSrc = m_ppxlcCurrMBY;
  1088. break;
  1089. case (Y_BLOCK2): 
  1090. rgchBlkDst = ppxlcCurrQMBY + BLOCK_SIZE;
  1091. rgchBlkSrc = m_ppxlcCurrMBY + BLOCK_SIZE;
  1092. break;
  1093. case (Y_BLOCK3): 
  1094. rgchBlkDst = ppxlcCurrQMBY + m_iFrameWidthYxBlkSize;
  1095. rgchBlkSrc = m_ppxlcCurrMBY + MB_SIZE * BLOCK_SIZE;
  1096. break;
  1097. case (Y_BLOCK4): 
  1098. rgchBlkDst = ppxlcCurrQMBY + m_iFrameWidthYxBlkSize + BLOCK_SIZE;
  1099. rgchBlkSrc = m_ppxlcCurrMBY + MB_SIZE * BLOCK_SIZE + BLOCK_SIZE;
  1100. break;
  1101. case (A_BLOCK1):
  1102. rgchBlkDst = ppxlcCurrQMBA;
  1103. rgchBlkSrc = m_ppxlcCurrMBA;
  1104. break;
  1105. case (A_BLOCK2):
  1106. rgchBlkDst = ppxlcCurrQMBA + BLOCK_SIZE;
  1107. rgchBlkSrc = m_ppxlcCurrMBA + BLOCK_SIZE;
  1108. break;
  1109. case (A_BLOCK3):
  1110. rgchBlkDst = ppxlcCurrQMBA + m_iFrameWidthYxBlkSize;
  1111. rgchBlkSrc = m_ppxlcCurrMBA + MB_SIZE * BLOCK_SIZE;
  1112. break;
  1113. case (A_BLOCK4):
  1114. rgchBlkDst = ppxlcCurrQMBA + m_iFrameWidthYxBlkSize + BLOCK_SIZE;
  1115. rgchBlkSrc = m_ppxlcCurrMBA + MB_SIZE * BLOCK_SIZE + BLOCK_SIZE;
  1116. break;
  1117. }
  1118. iWidthDst = m_iFrameWidthY;
  1119. iWidthSrc = MB_SIZE;
  1120. if(iBlk<=V_BLOCK)
  1121. iDcScaler = iDcScalerY; //m_rgiDcScalerY [iQP];
  1122. else
  1123. iDcScaler = iDcScalerA;
  1124. }
  1125. else {
  1126. iWidthDst = m_iFrameWidthUV;
  1127. iWidthSrc = BLOCK_SIZE;
  1128. rgchBlkDst = (iBlk == U_BLOCK) ? ppxlcCurrQMBU: ppxlcCurrQMBV;
  1129. rgchBlkSrc = (iBlk == U_BLOCK) ? m_ppxlcCurrMBU: m_ppxlcCurrMBV;
  1130. iDcScaler = iDcScalerC; //m_rgiDcScalerC [iQP];
  1131. }
  1133. if (m_volmd.nBits<=8) { // NBIT: not always valid when nBits>8
  1134. assert(iDcScaler > 0 && iDcScaler < 128);
  1135. }
  1137. rgiCoefQ = m_rgpiCoefQ [iBlk - 1];
  1138. iSumErr += quantizeIntraBlockTexture (
  1139. rgchBlkSrc,
  1140. iWidthSrc,
  1141. rgchBlkDst,
  1142. iWidthDst,
  1143. rgiCoefQ, 
  1144. (iBlk<=V_BLOCK ? iQP : iQPA), 
  1145. iDcScaler,
  1146. iBlk, //from here til last
  1147. pmbmLeft, 
  1148. pmbmTop, 
  1149. pmbmLeftTop, 
  1150. m_rgpmbmCurr [imbX],
  1151. pmbmdLeft, 
  1152. pmbmdTop, 
  1153. pmbmdLeftTop, 
  1154. pmbmd
  1155. ); //all for intra-pred
  1156. if(iBlk>=A_BLOCK1)
  1157. pmbmd->m_bACPredictionAlpha = (pmbmd->m_CODAlpha == ALPHA_CODED && iSumErr >= 0);
  1158. else
  1159. pmbmd->m_bACPrediction =(iSumErr >= 0);
  1160. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  1161.         if (m_vopmd.bInterlace && pmbmd->m_bMerged [0]) {
  1162.                 Int iDstBlk = 0;
  1163.                 switch (iBlk) {
  1164.                         case (Y_BLOCK1):
  1165.                                 if (pmbmd->m_bMerged [1])       iDstBlk = (Int) Y_BLOCK2;
  1166.                                 else if (pmbmd->m_bMerged [3])  iDstBlk = (Int) Y_BLOCK3;
  1167.                                 else if (pmbmd->m_bMerged [5])  iDstBlk = (Int) Y_BLOCK4;
  1168.                                 break;
  1169.                         case (Y_BLOCK2):
  1170.                                 if (pmbmd->m_bMerged [4])       iDstBlk = (Int) Y_BLOCK4;
  1171.                                 else if (pmbmd->m_bMerged [6])  iDstBlk = (Int) Y_BLOCK3;
  1172.                                 break;
  1173.                         case (Y_BLOCK3):
  1174.                                 if (pmbmd->m_bMerged [2])       iDstBlk = (Int) Y_BLOCK4;
  1175.                                 break;
  1176.                         case (A_BLOCK1):
  1177.                                 if (pmbmd->m_bMerged [1])       iDstBlk = (Int) A_BLOCK2;
  1178.                                 else if (pmbmd->m_bMerged [3])  iDstBlk = (Int) A_BLOCK3;
  1179.                                 else if (pmbmd->m_bMerged [5])  iDstBlk = (Int) A_BLOCK4;
  1180.                                 break;
  1181.                         case (A_BLOCK2):
  1182.                                 if (pmbmd->m_bMerged [4])       iDstBlk = (Int) A_BLOCK4;
  1183.                                 else if (pmbmd->m_bMerged [6])  iDstBlk = (Int) A_BLOCK3;
  1184.                                 break;
  1185.                         case (A_BLOCK3):
  1186.                                 if (pmbmd->m_bMerged [2])       iDstBlk = (Int) A_BLOCK4;
  1187.                                 break;
  1188.                 }
  1189.                 if (iDstBlk) {
  1190.                         MacroBlockMemory* pmbmCurr = m_rgpmbmCurr [imbX];
  1191.                         pmbmCurr->rgblkm [iDstBlk-1][0] = pmbmCurr->rgblkm [iBlk-1][0];
  1192.                         for (UInt x = 1; x < (BLOCK_SIZE<<1)-1; x++)
  1193.                                 pmbmCurr->rgblkm [iDstBlk-1][x] = 0;
  1194.                 }
  1195.         }
  1196. // End of Hyundai(1998-5-9)*/
  1197. }
  1199. // INTERLACE
  1200. if ((pmbmd->m_rgTranspStatus [0] == NONE) && (m_vopmd.bInterlace == TRUE) && (pmbmd->m_bFieldDCT == TRUE))
  1201. fieldDCTtoFrameC(ppxlcCurrQMBY);
  1202. // ~INTERLACE
  1204. for (iBlk = (UInt) Y_BLOCK1; iBlk <= iBlkEnd; iBlk++) { // + 1 is because of the indexing
  1205. if (pmbmd->m_rgTranspStatus [iBlk % 6] == ALL) { // hack %6 ok if [6]==[0]
  1206. pmbmd->setCodedBlockPattern ((BlockNum) iBlk, FALSE);
  1207. continue;
  1208. }
  1209. rgiCoefQ = m_rgpiCoefQ [iBlk - 1];
  1210. if (iBlk < (Int) U_BLOCK) 
  1211. iDcScaler = iDcScalerY; //m_rgiDcScalerY [iQP];
  1212. else if(iBlk < (Int) A_BLOCK1)
  1213. iDcScaler = iDcScalerC; //m_rgiDcScalerC [iQP];
  1214. else
  1215. iDcScaler = iDcScalerA;
  1217. intraPred ((BlockNum) iBlk, pmbmd, rgiCoefQ,
  1218. (iBlk<=V_BLOCK ? iQP : iQPA), iDcScaler, m_rgblkmCurrMB [iBlk - 1], m_rgiQPpred [iBlk - 1]);
  1219. Bool bCoded = FALSE;
  1220. UInt i;
  1221. if(iBlk >=(Int) A_BLOCK1)
  1222. iCoefToStart = pmbmd->m_bCodeDcAsAcAlpha==TRUE ? 0 : 1;
  1224. for (i = iCoefToStart; i < BLOCK_SQUARE_SIZE; i++) {
  1225. if (rgiCoefQ [i] != 0) {
  1226. bCoded = TRUE;
  1227. break;
  1228. }
  1229. }
  1230. pmbmd->setCodedBlockPattern ((BlockNum) iBlk, bCoded);
  1231. }
  1232. }
  1234. Void CVideoObjectEncoder::quantizeTextureInterMB (CMBMode* pmbmd, 
  1235.   const CMotionVector* pmv, 
  1236.   PixelC *ppxlcCurrQMBA,
  1237.   Bool bSkip) //bSkip: tested mv is zero
  1238. {
  1239. assert (pmbmd != NULL);
  1240. assert (pmbmd -> m_dctMd == INTER || pmbmd -> m_dctMd == INTERQ);
  1242. assert (pmbmd->m_rgTranspStatus [0] != ALL);
  1243. Int iQuantMax = (1<<m_volmd.uiQuantPrecision) - 1;
  1244. if (pmbmd -> m_stepSize < 1)
  1245. pmbmd -> m_stepSize = 1;
  1246. else if (pmbmd -> m_stepSize > iQuantMax)
  1247. pmbmd -> m_stepSize = iQuantMax;
  1248. Int iQP = pmbmd->m_stepSize;
  1249. #ifdef __TRACE_AND_STATS_
  1250. m_statsMB.nQMB++;
  1251. m_statsMB.nQp += iQP;
  1252. #endif // __TRACE_AND_STATS_
  1254. // INTERLACE
  1255. if ((pmbmd->m_rgTranspStatus [0] == NONE) && (m_vopmd.bInterlace == TRUE)) {
  1256. pmbmd->m_bFieldDCT = FrameFieldDCTDecideI(m_ppxliErrorMBY);
  1257. m_statsMB.nFieldDCTMB += (Int) pmbmd->m_bFieldDCT;
  1258. }
  1259. else
  1260. pmbmd->m_bFieldDCT = 0;
  1261. Bool bMBCoded = FALSE;
  1262. // ~INTERLACE
  1264. Int iQPA = 0;
  1265. pmbmd->m_CODAlpha = ALPHA_CODED;
  1266. Int iBlkEnd = V_BLOCK;
  1267. if(m_volmd.fAUsage == EIGHT_BIT)
  1268. {
  1269. iBlkEnd = A_BLOCK4;
  1270. if (pmbmd -> m_stepSizeAlpha < 1)
  1271. pmbmd -> m_stepSizeAlpha = 1;
  1272. iQPA = pmbmd->m_stepSizeAlpha;
  1274. Int i, iThresh = 256 - iQPA;
  1275. pmbmd->m_CODAlpha = ALPHA_ALL255;
  1276. for(i = 0; i<MB_SQUARE_SIZE; i++)
  1277. if(m_ppxlcCurrMBA[i] <= iThresh)
  1278. {
  1279. pmbmd->m_CODAlpha = ALPHA_CODED;
  1280. break;
  1281. }
  1282. }
  1284. // Bool bSkip = pmbmd->m_bhas4MVForward ? (bSkipAllowed && pmv [1].isZero () && pmv [2].isZero () && pmv [3].isZero () && pmv [4].isZero ())
  1285. //  : bSkipAllowed && pmv->isZero ();
  1286. Int* rgiBlkCurrQ = m_ppxliErrorMBY;
  1287. Int* rgiCoefQ;
  1288. Int iWidthCurrQ;
  1289. Bool bSkipAlpha = TRUE;
  1290. for (UInt iBlk = (UInt) Y_BLOCK1; iBlk <= (UInt)iBlkEnd; iBlk++) { 
  1291. if (iBlk < (UInt) U_BLOCK || iBlk> (UInt) V_BLOCK) {
  1292. if (pmbmd -> m_rgTranspStatus [iBlk % 6] == ALL) 
  1293. continue;
  1294. switch (iBlk) 
  1295. {
  1296. case (Y_BLOCK1): 
  1297. rgiBlkCurrQ = m_ppxliErrorMBY;
  1298. break;
  1299. case (Y_BLOCK2): 
  1300. rgiBlkCurrQ = m_ppxliErrorMBY + BLOCK_SIZE;
  1301. break;
  1302. case (Y_BLOCK3): 
  1303. rgiBlkCurrQ = m_ppxliErrorMBY + MB_SIZE * BLOCK_SIZE;
  1304. break;
  1305. case (Y_BLOCK4): 
  1306. rgiBlkCurrQ = m_ppxliErrorMBY + MB_SIZE * BLOCK_SIZE + BLOCK_SIZE;
  1307. break;
  1308. case (A_BLOCK1): 
  1309. rgiBlkCurrQ = m_ppxliErrorMBA;
  1310. break;
  1311. case (A_BLOCK2): 
  1312. rgiBlkCurrQ = m_ppxliErrorMBA + BLOCK_SIZE;
  1313. break;
  1314. case (A_BLOCK3): 
  1315. rgiBlkCurrQ = m_ppxliErrorMBA + MB_SIZE * BLOCK_SIZE;
  1316. break;
  1317. case (A_BLOCK4): 
  1318. rgiBlkCurrQ = m_ppxliErrorMBA + MB_SIZE * BLOCK_SIZE + BLOCK_SIZE;
  1319. break;
  1320. }
  1321. iWidthCurrQ = MB_SIZE;
  1322. }
  1323. else {
  1324. iWidthCurrQ = BLOCK_SIZE;
  1325. rgiBlkCurrQ = (iBlk == U_BLOCK) ? m_ppxliErrorMBU: m_ppxliErrorMBV;
  1326. }
  1328. rgiCoefQ = m_rgpiCoefQ [iBlk - 1];
  1329. if(iBlk>=A_BLOCK1)
  1330. quantizeTextureInterBlock (rgiBlkCurrQ, iWidthCurrQ, rgiCoefQ, iQPA, TRUE);
  1331. else
  1332. quantizeTextureInterBlock (rgiBlkCurrQ, iWidthCurrQ, rgiCoefQ, iQP, FALSE);
  1333. Bool bCoded = FALSE;
  1334. UInt i;
  1335. for (i = 0; i < BLOCK_SQUARE_SIZE; i++) {
  1336. if (rgiCoefQ [i] != 0) {
  1337. bCoded = TRUE;
  1338. bMBCoded = TRUE;
  1339. break;
  1340. }
  1341. }
  1342. if(iBlk<A_BLOCK1)
  1343. bSkip = bSkip & !bCoded;
  1344. else
  1345. bSkipAlpha = bSkipAlpha & !bCoded;
  1347. pmbmd->setCodedBlockPattern ((BlockNum) iBlk, bCoded);
  1348. }
  1350. pmbmd->m_bSkip = bSkip; 
  1352. if(m_volmd.fAUsage == EIGHT_BIT)
  1353. {
  1354. if(bSkipAlpha == TRUE)
  1355. pmbmd->m_CODAlpha = ALPHA_SKIPPED;
  1356. else if(pmbmd->m_CODAlpha == ALPHA_ALL255)
  1357. {
  1358. PixelC *ppxlc = ppxlcCurrQMBA;
  1359. Int i;
  1360. for(i = 0; i<MB_SIZE; i++, ppxlc += m_iFrameWidthY)
  1361. pxlcmemset(ppxlc, 255, MB_SIZE);
  1362. }
  1363. }
  1365. // INTERLACE
  1366. if ((pmbmd->m_rgTranspStatus [0] == NONE)
  1367. &&(m_vopmd.bInterlace == TRUE) && (pmbmd->m_bFieldDCT == TRUE) 
  1368. && (bMBCoded == TRUE))
  1369. fieldDCTtoFrameI(m_ppxliErrorMBY);
  1370. // ~INTERLACE
  1371. }
  1373. Void CVideoObjectEncoder::sendDCTCoefOfInterMBTexture (const CMBMode* pmbmd) 
  1374. {
  1375. assert (pmbmd != NULL);
  1376. assert (pmbmd -> m_dctMd == INTER || pmbmd -> m_dctMd == INTERQ);
  1377. assert (pmbmd -> m_rgTranspStatus [0] != ALL);
  1379. UInt nBits, iBlk = 0;
  1380. for (iBlk = Y_BLOCK1; iBlk <= V_BLOCK; iBlk++) {
  1381. #ifdef __TRACE_AND_STATS_
  1382. m_pbitstrmOut->trace (iBlk, "BLK_NO");
  1383. #endif // __TRACE_AND_STATS_
  1384. if (iBlk < U_BLOCK)
  1385. if (pmbmd -> m_rgTranspStatus [iBlk] == ALL) continue;
  1386. if (pmbmd->getCodedBlockPattern ((BlockNum) iBlk)) {
  1387. Int* rgiCoefQ = m_rgpiCoefQ [iBlk - 1];
  1388. #ifdef __TRACE_AND_STATS_
  1389. m_pbitstrmOut->trace (rgiCoefQ, BLOCK_SQUARE_SIZE, "BLK_QUANTIZED_COEF");
  1390. #endif // __TRACE_AND_STATS_
  1391. // Modified for data partitioning mode by Toshiba(1998-1-16)
  1392. if(m_volmd.bDataPartitioning && m_volmd.bReversibleVlc && m_vopmd.vopPredType != BVOP)
  1393. nBits = sendTCOEFInterRVLC (rgiCoefQ, 0, grgiStandardZigzag, TRUE);
  1394. else
  1395. nBits = sendTCOEFInter (rgiCoefQ, 0,
  1396.                 m_vopmd.bAlternateScan ? grgiVerticalZigzag : grgiStandardZigzag);
  1397. // End Toshiba(1998-1-16)
  1398. switch (iBlk) {
  1399. case U_BLOCK: 
  1400. m_statsMB.nBitsCr += nBits;
  1401. break;
  1402. case V_BLOCK: 
  1403. m_statsMB.nBitsCb += nBits;
  1404. break;
  1405. default:
  1406. m_statsMB.nBitsY += nBits;
  1407. }
  1408. }
  1409. }
  1410. }
  1412. Void CVideoObjectEncoder::sendDCTCoefOfIntraMBTexture (const CMBMode* pmbmd) 
  1413. {
  1414. assert (pmbmd != NULL);
  1415. assert (pmbmd -> m_dctMd == INTRA || pmbmd -> m_dctMd == INTRAQ);
  1416. assert (pmbmd->m_rgTranspStatus [0] != ALL);
  1418. UInt iBlk = 0;
  1419. for (iBlk = Y_BLOCK1; iBlk <= V_BLOCK; iBlk++) {
  1420. UInt nBits = 0;
  1421. #ifdef __TRACE_AND_STATS_
  1422. m_pbitstrmOut->trace (iBlk, "BLK_NO");
  1423. #endif // __TRACE_AND_STATS_
  1424. if (iBlk < U_BLOCK)
  1425. if (pmbmd -> m_rgTranspStatus [iBlk] == ALL) continue;
  1426. Int* rgiCoefQ = m_rgpiCoefQ [iBlk - 1];
  1427. #ifdef __TRACE_AND_STATS_
  1428. m_pbitstrmOut->trace (rgiCoefQ, BLOCK_SQUARE_SIZE, "BLK_QUANTIZED_COEF");
  1429. #endif // __TRACE_AND_STATS_
  1430. Int iCoefStart = 0;
  1431. if (pmbmd->m_bCodeDcAsAc != TRUE) {
  1432. iCoefStart = 1;
  1433. nBits = sendIntraDC (rgiCoefQ, (BlockNum) iBlk);
  1434. }
  1435. if (pmbmd->getCodedBlockPattern ((BlockNum) iBlk)) {
  1436. Int* rgiZigzag = grgiStandardZigzag;
  1437.             if (m_vopmd.bAlternateScan)
  1438.                 rgiZigzag = grgiVerticalZigzag;
  1439.             else if (pmbmd->m_bACPrediction)
  1440. rgiZigzag = (pmbmd->m_preddir [iBlk - 1] == HORIZONTAL) ? grgiVerticalZigzag : grgiHorizontalZigzag;
  1441. // Modified for data partitioning mode by Toshiba(1998-1-16)
  1442. if(m_volmd.bDataPartitioning && m_volmd.bReversibleVlc && m_vopmd.vopPredType != BVOP)
  1443. nBits += sendTCOEFIntraRVLC (rgiCoefQ, iCoefStart, rgiZigzag, TRUE);
  1444. else
  1445. nBits += sendTCOEFIntra (rgiCoefQ, iCoefStart, rgiZigzag);
  1446. // End Toshiba(1998-1-16)
  1447. }
  1448. switch (iBlk) {
  1449. case U_BLOCK: 
  1450. m_statsMB.nBitsCr += nBits;
  1451. break;
  1452. case V_BLOCK: 
  1453. m_statsMB.nBitsCb += nBits;
  1454. break;
  1455. default:
  1456. m_statsMB.nBitsY += nBits;
  1457. }
  1458. }
  1459. }
  1461. UInt CVideoObjectEncoder::sumAbsCurrMB ()
  1462. {
  1463. PixelC* ppxlcCurrMBY = m_ppxlcCurrMBY;
  1464. UInt uisumAbs = 0;
  1465. Int ic;
  1466. for (ic = 0; ic < MB_SQUARE_SIZE; ic++) {
  1467. uisumAbs += ppxlcCurrMBY [ic];
  1468. }
  1469. return uisumAbs;
  1470. }
  1472. Void CVideoObjectEncoder::codeMBAlphaHeadOfIVOP (const CMBMode* pmbmd)
  1473. {
  1474. // get CBPA
  1475. Int CBPA = 0;
  1476. UInt cNonTrnspBlk = 0, iBlk;
  1477. for (iBlk = (UInt) A_BLOCK1; iBlk <= (UInt) A_BLOCK4; iBlk++) {
  1478. if (pmbmd->m_rgTranspStatus [iBlk - 6] != ALL)
  1479. cNonTrnspBlk++;
  1480. }
  1481. UInt iBitPos = 1;
  1482. for (iBlk = (UInt) A_BLOCK1; iBlk <= (UInt) A_BLOCK4; iBlk++) {
  1483. if (pmbmd->m_rgTranspStatus [iBlk - 6] != ALL) {
  1484. CBPA |= pmbmd->getCodedBlockPattern ((BlockNum) iBlk) << (cNonTrnspBlk - iBitPos);
  1485. iBitPos++;
  1486. }
  1487. }
  1488. assert (CBPA >= 0 && CBPA <= 15);
  1490. Int iCODA = 0;
  1492. if(pmbmd->m_CODAlpha==ALPHA_ALL255)
  1493. iCODA = 1;
  1495. m_pbitstrmOut->putBits(iCODA, 1, "MB_CODA");
  1496. m_statsMB.nBitsCODA++;
  1498. if(iCODA)
  1499. return;
  1501. m_pbitstrmOut->putBits (pmbmd->m_bACPredictionAlpha, 1, "MB_ACPRED_ALPHA");
  1502. m_statsMB.nBitsIntraPred++;
  1504. #ifdef __TRACE_AND_STATS_
  1505. m_pbitstrmOut->trace (CBPA, "MB_CBPA");
  1506. #endif // __TRACE_AND_STATS_
  1507. switch (cNonTrnspBlk) {
  1508. case 1:
  1509. m_statsMB.nBitsCBPA += m_pentrencSet->m_pentrencCBPY1->encodeSymbol (1 - CBPA, "MB_CBPA");
  1510. break;
  1511. case 2:
  1512. m_statsMB.nBitsCBPA += m_pentrencSet->m_pentrencCBPY2->encodeSymbol (3 - CBPA, "MB_CBPA");
  1513. break;
  1514. case 3:
  1515. m_statsMB.nBitsCBPA += m_pentrencSet->m_pentrencCBPY3->encodeSymbol (7 - CBPA, "MB_CBPA");
  1516. break;
  1517. case 4:
  1518. m_statsMB.nBitsCBPA += m_pentrencSet->m_pentrencCBPY->encodeSymbol (15 - CBPA, "MB_CBPA");
  1519. break;
  1520. default:
  1521. assert (FALSE);
  1522. }
  1523. }
  1525. Void CVideoObjectEncoder::codeMBAlphaHeadOfPVOP (const CMBMode* pmbmd)
  1526. {
  1527. if(pmbmd -> m_dctMd == INTRA || pmbmd -> m_dctMd == INTRAQ)
  1528. codeMBAlphaHeadOfIVOP(pmbmd);
  1529. else
  1530. {
  1531. // get CBPA
  1532. Int CBPA = 0;
  1533. UInt cNonTrnspBlk = 0, iBlk;
  1534. for (iBlk = (UInt) A_BLOCK1; iBlk <= (UInt) A_BLOCK4; iBlk++) {
  1535. if (pmbmd->m_rgTranspStatus [iBlk - 6] != ALL)
  1536. cNonTrnspBlk++;
  1537. }
  1538. UInt iBitPos = 1;
  1539. for (iBlk = (UInt) A_BLOCK1; iBlk <= (UInt) A_BLOCK4; iBlk++) {
  1540. if (pmbmd->m_rgTranspStatus [iBlk - 6] != ALL) {
  1541. CBPA |= pmbmd->getCodedBlockPattern ((BlockNum) iBlk) << (cNonTrnspBlk - iBitPos);
  1542. iBitPos++;
  1543. }
  1544. }
  1545. assert (CBPA >= 0 && CBPA <= 15);
  1547. if(pmbmd->m_CODAlpha==ALPHA_CODED)
  1548. {
  1549. m_pbitstrmOut->putBits(0, 2, "MB_CODA");
  1550. m_statsMB.nBitsCODA += 2;
  1551. }
  1552. else if(pmbmd->m_CODAlpha==ALPHA_ALL255)
  1553. {
  1554. m_pbitstrmOut->putBits(1, 2, "MB_CODA");
  1555. m_statsMB.nBitsCODA += 2;
  1556. return;
  1557. }
  1558. else // ALPHA_SKIPPED
  1559. {
  1560. m_pbitstrmOut->putBits(1, 1, "MB_CODA");
  1561. m_statsMB.nBitsCODA ++;
  1562. return;
  1563. }
  1565. #ifdef __TRACE_AND_STATS_
  1566. m_pbitstrmOut->trace (CBPA, "MB_CBPA");
  1567. #endif // __TRACE_AND_STATS_
  1568. switch (cNonTrnspBlk) {
  1569. case 1:
  1570. m_statsMB.nBitsCBPA += m_pentrencSet->m_pentrencCBPY1->encodeSymbol (1 - CBPA, "MB_CBPA");
  1571. break;
  1572. case 2:
  1573. m_statsMB.nBitsCBPA += m_pentrencSet->m_pentrencCBPY2->encodeSymbol (3 - CBPA, "MB_CBPA");
  1574. break;
  1575. case 3:
  1576. m_statsMB.nBitsCBPA += m_pentrencSet->m_pentrencCBPY3->encodeSymbol (7 - CBPA, "MB_CBPA");
  1577. break;
  1578. case 4:
  1579. m_statsMB.nBitsCBPA += m_pentrencSet->m_pentrencCBPY->encodeSymbol (15 - CBPA, "MB_CBPA");
  1580. break;
  1581. default:
  1582. assert (FALSE);
  1583. }
  1584. }
  1585. }
  1587. Void CVideoObjectEncoder::sendDCTCoefOfIntraMBAlpha (const CMBMode* pmbmd)
  1588. {
  1589. assert (pmbmd != NULL);
  1590. assert (pmbmd -> m_dctMd == INTRA || pmbmd -> m_dctMd == INTRAQ);
  1591. assert (pmbmd->m_rgTranspStatus [0] != ALL);
  1593. if(pmbmd->m_CODAlpha != ALPHA_CODED)
  1594. return;
  1596. UInt iBlk;
  1597. for (iBlk = A_BLOCK1; iBlk <= A_BLOCK4; iBlk++) {
  1598. UInt nBits = 0;
  1599. #ifdef __TRACE_AND_STATS_
  1600. m_pbitstrmOut->trace (iBlk, "ALPHA_BLK_NO");
  1601. #endif // __TRACE_AND_STATS_
  1602. if (pmbmd -> m_rgTranspStatus [iBlk - 6 ] == ALL)
  1603. continue;
  1604. Int* rgiCoefQ = m_rgpiCoefQ [iBlk - 1];
  1605. #ifdef __TRACE_AND_STATS_
  1606. m_pbitstrmOut->trace (rgiCoefQ, BLOCK_SQUARE_SIZE, "BLK_QUANTIZED_COEF");
  1607. #endif // __TRACE_AND_STATS_
  1609. Int iCoefStart = 0;
  1610. if (pmbmd->m_bCodeDcAsAcAlpha != TRUE) {
  1611. iCoefStart = 1;
  1612. nBits = sendIntraDC (rgiCoefQ, (BlockNum) iBlk);
  1613. }
  1615. if (pmbmd->getCodedBlockPattern ((BlockNum) iBlk)) {
  1616. Int* rgiZigzag = grgiStandardZigzag;
  1617. if (pmbmd->m_bACPredictionAlpha)
  1618. rgiZigzag = (pmbmd->m_preddir [iBlk - 1] == HORIZONTAL) ? grgiVerticalZigzag : grgiHorizontalZigzag;
  1619. nBits += sendTCOEFIntra (rgiCoefQ, iCoefStart, rgiZigzag);
  1620. }
  1621. m_statsMB.nBitsA += nBits;
  1622. }
  1623. }
  1625. Void CVideoObjectEncoder::sendDCTCoefOfInterMBAlpha (const CMBMode* pmbmd)
  1626. {
  1627. assert (pmbmd != NULL);
  1628. assert (pmbmd -> m_dctMd == INTER || pmbmd -> m_dctMd == INTERQ);
  1629. assert (pmbmd -> m_rgTranspStatus [0] != ALL);
  1630. assert (pmbmd -> m_CODAlpha == ALPHA_CODED);
  1632. UInt nBits, iBlk = 0;
  1633. for (iBlk = A_BLOCK1; iBlk <= A_BLOCK4; iBlk++) {
  1634. #ifdef __TRACE_AND_STATS_
  1635. m_pbitstrmOut->trace (iBlk, "BLK_NO");
  1636. #endif // __TRACE_AND_STATS_
  1637. if (pmbmd -> m_rgTranspStatus [iBlk - 6] == ALL) continue;
  1638. if (pmbmd->getCodedBlockPattern ((BlockNum) iBlk)) {
  1639. Int* rgiCoefQ = m_rgpiCoefQ [iBlk - 1];
  1640. #ifdef __TRACE_AND_STATS_
  1641. m_pbitstrmOut->trace (rgiCoefQ, BLOCK_SQUARE_SIZE, "BLK_QUANTIZED_COEF");
  1642. #endif // __TRACE_AND_STATS_
  1643. nBits = sendTCOEFInter (rgiCoefQ, 0, grgiStandardZigzag);
  1644. m_statsMB.nBitsA += nBits;
  1645. }
  1646. }
  1647. }
  1649. Void CVideoObjectEncoder::codeMBAlphaHeadOfBVOP (const CMBMode* pmbmd)
  1650. {
  1651. // get CBPA
  1652. Int CBPA = 0;
  1653. UInt cNonTrnspBlk = 0, iBlk;
  1654. for (iBlk = (UInt) A_BLOCK1; iBlk <= (UInt) A_BLOCK4; iBlk++) {
  1655. if (pmbmd->m_rgTranspStatus [iBlk - 6] != ALL)
  1656. cNonTrnspBlk++;
  1657. }
  1658. UInt iBitPos = 1;
  1659. for (iBlk = (UInt) A_BLOCK1; iBlk <= (UInt) A_BLOCK4; iBlk++) {
  1660. if (pmbmd->m_rgTranspStatus [iBlk - 6] != ALL) {
  1661. CBPA |= pmbmd->getCodedBlockPattern ((BlockNum) iBlk) << (cNonTrnspBlk - iBitPos);
  1662. iBitPos++;
  1663. }
  1664. }
  1665. assert (CBPA >= 0 && CBPA <= 15);
  1667. if(pmbmd->m_CODAlpha==ALPHA_CODED)
  1668. {
  1669. m_pbitstrmOut->putBits(0, 2, "MB_CODBA");
  1670. m_statsMB.nBitsCODA += 2;
  1671. }
  1672. else if(pmbmd->m_CODAlpha==ALPHA_ALL255)
  1673. {
  1674. m_pbitstrmOut->putBits(1, 2, "MB_CODBA");
  1675. m_statsMB.nBitsCODA += 2;
  1676. return;
  1677. }
  1678. else // ALPHA_SKIPPED
  1679. {
  1680. m_pbitstrmOut->putBits(1, 1, "MB_CODBA");
  1681. m_statsMB.nBitsCODA ++;
  1682. return;
  1683. }
  1685. #ifdef __TRACE_AND_STATS_
  1686. m_pbitstrmOut->trace (CBPA, "MB_CBPBA");
  1687. #endif // __TRACE_AND_STATS_
  1688. switch (cNonTrnspBlk) {
  1689. case 1:
  1690. m_statsMB.nBitsCBPA += m_pentrencSet->m_pentrencCBPY1->encodeSymbol (1 - CBPA, "MB_CBPA");
  1691. break;
  1692. case 2:
  1693. m_statsMB.nBitsCBPA += m_pentrencSet->m_pentrencCBPY2->encodeSymbol (3 - CBPA, "MB_CBPA");
  1694. break;
  1695. case 3:
  1696. m_statsMB.nBitsCBPA += m_pentrencSet->m_pentrencCBPY3->encodeSymbol (7 - CBPA, "MB_CBPA");
  1697. break;
  1698. case 4:
  1699. m_statsMB.nBitsCBPA += m_pentrencSet->m_pentrencCBPY->encodeSymbol (15 - CBPA, "MB_CBPA");
  1700. break;
  1702. default:
  1704. assert (FALSE);
  1706. }
  1708. }