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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

errdec.cpp：源码内容
  1. /*************************************************************************
  3. This software module was originally developed by 
  5. Yoshihiro Kikuchi (TOSHIBA CORPORATION)
  6. Takeshi Nagai (TOSHIBA CORPORATION)
  8.     and edited by:
  10. Toshiaki Watanabe (TOSHIBA CORPORATION)
  11. Noboru Yamaguchi (TOSHIBA CORPORATION)
  13.   in the course of development of the <MPEG-4 Video(ISO/IEC 14496-2)>. This
  14.   software module is an implementation of a part of one or more <MPEG-4 Video
  15.   (ISO/IEC 14496-2)> tools as specified by the <MPEG-4 Video(ISO/IEC 14496-2)
  16.   >. ISO/IEC gives users of the <MPEG-4 Video(ISO/IEC 14496-2)> free license
  17.   to this software module or modifications thereof for use in hardware or
  18.   software products claiming conformance to the <MPEG-4 Video(ISO/IEC 14496-2
  19.   )>. Those intending to use this software module in hardware or software
  20.   products are advised that its use may infringe existing patents. The
  21.   original developer of this software module and his/her company, the
  22.   subsequent editors and their companies, and ISO/IEC have no liability for
  23.   use of this software module or modifications thereof in an implementation.
  24.   Copyright is not released for non <MPEG-4 Video(ISO/IEC 14496-2)>
  25.   conforming products. TOSHIBA CORPORATION retains full right to use the code
  26.   for his/her own purpose, assign or donate the code to a third party and to
  27.   inhibit third parties from using the code for non <MPEG-4 Video(ISO/IEC
  28.   14496-2)> conforming products. This copyright notice must be included in
  29.   all copies or derivative works.
  30.   Copyright (c)1997.
  32. *************************************************************************/
  34. // Added for error resilience mode By Toshiba
  35. #include <stdio.h>
  36. #include <math.h>
  37. #include <stdlib.h>
  39. #include "typeapi.h"
  40. #include "mode.hpp"
  41. #include "codehead.h"
  42. #include "entropy/bitstrm.hpp"
  43. #include "entropy/entropy.hpp"
  44. #include "entropy/huffman.hpp"
  45. #include "global.hpp"
  46. #include "vopses.hpp"
  47. #include "vopsedec.hpp"
  49. #include "dct.hpp"
  51. #ifdef __MFC_
  52. #ifdef _DEBUG
  53. #undef THIS_FILE
  54. static char BASED_CODE THIS_FILE[] = __FILE__;
  55. #endif
  56. #define new DEBUG_NEW    
  57. #endif // __MFC_
  59. Bool CVideoObjectDecoder::checkResyncMarker()
  60. {
  61. Int nBitsPeeked;
  62. Int iStuffedBits = m_pbitstrmIn->peekBitsTillByteAlign (nBitsPeeked);
  63. Int nBitsResyncMarker = NUMBITS_VP_RESYNC_MARKER;
  64. if(m_volmd.bShapeOnly==FALSE)
  65. {
  66. if(m_vopmd.vopPredType == PVOP)
  67. nBitsResyncMarker += (m_vopmd.mvInfoForward.uiFCode - 1);
  68. else if(m_vopmd.vopPredType == BVOP)
  69. nBitsResyncMarker += MAX(m_vopmd.mvInfoForward.uiFCode, m_vopmd.mvInfoBackward.uiFCode) - 1;
  70. }
  72. assert (nBitsPeeked > 0 && nBitsPeeked <= 8);
  73. if (iStuffedBits == ((1 << (nBitsPeeked - 1)) - 1))
  74. return (m_pbitstrmIn->peekBitsFromByteAlign (nBitsResyncMarker) == RESYNC_MARKER);
  75. return FALSE;
  76. }
  78. #if 0 // revised HEC for shape
  79. Int CVideoObjectDecoder::decodeVideoPacketHeader(Int& iCurrentQP)
  80. {
  81. m_pbitstrmIn -> flush(8);
  83. Int nBitsResyncMarker = NUMBITS_VP_RESYNC_MARKER;
  84. if(m_volmd.bShapeOnly==FALSE)
  85. {
  86. if(m_vopmd.vopPredType == PVOP)
  87. nBitsResyncMarker += (m_vopmd.mvInfoForward.uiFCode - 1);
  88. else if(m_vopmd.vopPredType == BVOP)
  89. nBitsResyncMarker += MAX(m_vopmd.mvInfoForward.uiFCode, m_vopmd.mvInfoBackward.uiFCode) - 1;
  90. }
  92. UInt uiResyncMarker = m_pbitstrmIn -> getBits (nBitsResyncMarker);
  94. Int NumOfMB = m_iNumMBX * m_iNumMBY;
  95. assert (NumOfMB>0);
  97. //Int LengthOfMBNumber = (Int)(log(NumOfMB-1)/log(2)) + 1;
  99. Int iVal = NumOfMB - 1;
  100. Int iLengthOfMBNumber = 0;
  101. for(; iVal; iLengthOfMBNumber++)
  102. iVal>>=1;
  104. UInt uiMBNumber = 0;
  106. if(NumOfMB>1)
  107. uiMBNumber = m_pbitstrmIn -> getBits (iLengthOfMBNumber);
  109. m_iVPMBnum = uiMBNumber;
  110. if(m_volmd.bShapeOnly==FALSE) {
  111. Int stepDecoded = m_pbitstrmIn -> getBits (NUMBITS_VP_QUANTIZER);
  112. iCurrentQP = stepDecoded; 
  113. }
  115. UInt uiHEC = m_pbitstrmIn -> getBits (NUMBITS_VP_HEC);
  116. if (uiHEC){
  118. // Time reference and VOP_pred_type
  119. Int iModuloInc = 0;
  120. while (m_pbitstrmIn -> getBits (1) != 0)
  121. iModuloInc++;
  122. Time tCurrSec = iModuloInc + (m_vopmd.vopPredType != BVOP ? m_tOldModuloBaseDecd : m_tOldModuloBaseDisp);
  123. UInt uiMarker = m_pbitstrmIn -> getBits (1);
  124. assert(uiMarker == 1);
  125. Time tVopIncr = m_pbitstrmIn -> getBits (m_iNumBitsTimeIncr);
  126. uiMarker = m_pbitstrmIn -> getBits (1);
  127. assert(uiMarker == 1);
  128. // this is bogus - swinder.
  129. //assert (m_t == tCurrSec * 60 + tVopIncr * 60 / m_volmd.iClockRate); //in terms of 60Hz clock ticks
  131. VOPpredType vopPredType = (VOPpredType) m_pbitstrmIn -> getBits (NUMBITS_VP_PRED_TYPE);
  132. assert(m_vopmd.vopPredType == vopPredType);
  134. if(m_volmd.bShapeOnly==FALSE) {
  135. Int iIntraDcSwitchThr = m_pbitstrmIn->getBits (NUMBITS_VP_INTRA_DC_SWITCH_THR);
  136. assert(m_vopmd.iIntraDcSwitchThr == iIntraDcSwitchThr);
  137. if (m_vopmd.vopPredType == PVOP) {
  138. UInt uiFCode = m_pbitstrmIn -> getBits (NUMBITS_VOP_FCODE);
  139. assert(uiFCode == m_vopmd.mvInfoForward.uiFCode);
  140. }
  141. else if (m_vopmd.vopPredType == BVOP) {
  142. UInt uiForwardFCode = m_pbitstrmIn -> getBits (NUMBITS_VOP_FCODE);
  143. UInt uiBackwardFCode = m_pbitstrmIn -> getBits (NUMBITS_VOP_FCODE);
  144. assert(uiForwardFCode == m_vopmd.mvInfoForward.uiFCode);
  145. assert(uiBackwardFCode == m_vopmd.mvInfoBackward.uiFCode);
  146. }
  147. }
  148. }
  149. return TRUE;
  150. }
  151. #else
  152. Int CVideoObjectDecoder::decodeVideoPacketHeader(Int& iCurrentQP)
  153. {
  154.   UInt uiHEC = 0;
  155. m_pbitstrmIn -> flush(8);
  157. Int nBitsResyncMarker = NUMBITS_VP_RESYNC_MARKER;
  158. if(m_volmd.bShapeOnly==FALSE)
  159. {
  160. if(m_vopmd.vopPredType == PVOP)
  161. nBitsResyncMarker += (m_vopmd.mvInfoForward.uiFCode - 1);
  162. else if(m_vopmd.vopPredType == BVOP)
  163. nBitsResyncMarker += MAX(m_vopmd.mvInfoForward.uiFCode, m_vopmd.mvInfoBackward.uiFCode) - 1;
  164. }
  166. /* UInt uiResyncMarker = wmay */ m_pbitstrmIn -> getBits (nBitsResyncMarker);
  168. Int NumOfMB = m_iNumMBX * m_iNumMBY;
  169. assert (NumOfMB>0);
  171. //Int LengthOfMBNumber = (Int)(log(NumOfMB-1)/log(2)) + 1;
  173. Int iVal = NumOfMB - 1;
  174. Int iLengthOfMBNumber = 0;
  175. for(; iVal; iLengthOfMBNumber++)
  176. iVal>>=1;
  178. UInt uiMBNumber = 0;
  180. if (m_volmd.fAUsage != RECTANGLE) {
  181. uiHEC = m_pbitstrmIn -> getBits (NUMBITS_VP_HEC);
  182.   if (uiHEC && !(m_uiSprite == 1 && m_vopmd.vopPredType == IVOP)) {
  183.     /* Int width = wmay */ m_pbitstrmIn -> getBits (NUMBITS_VOP_WIDTH);
  184. Int marker;
  185. marker = m_pbitstrmIn -> getBits (1); // marker bit
  186. assert(marker==1);
  187. /* Int height = wmay */ m_pbitstrmIn -> getBits (NUMBITS_VOP_HEIGHT);
  188. marker = m_pbitstrmIn -> getBits (1); // marker bit
  189. assert(marker==1);
  190. //wchen: cd changed to 2s complement
  191. Int left = (m_pbitstrmIn -> getBits (1) == 0) ?
  192. m_pbitstrmIn->getBits (NUMBITS_VOP_HORIZONTAL_SPA_REF - 1) : 
  193. ((Int)m_pbitstrmIn->getBits (NUMBITS_VOP_HORIZONTAL_SPA_REF - 1) - (1 << (NUMBITS_VOP_HORIZONTAL_SPA_REF - 1)));
  194. marker = m_pbitstrmIn -> getBits (1); // marker bit
  195. assert(marker==1);
  196. Int top = (m_pbitstrmIn -> getBits (1) == 0) ?
  197.    m_pbitstrmIn->getBits (NUMBITS_VOP_VERTICAL_SPA_REF - 1) : 
  198.    ((Int)m_pbitstrmIn->getBits (NUMBITS_VOP_VERTICAL_SPA_REF - 1) - (1 << (NUMBITS_VOP_VERTICAL_SPA_REF - 1)));
  199. marker = m_pbitstrmIn -> getBits (1); // marker bit
  200. assert(marker==1);
  201. assert(((left | top)&1)==0); // must be even pix unit
  202.   }
  203. }
  205. if(NumOfMB>1)
  206. uiMBNumber = m_pbitstrmIn -> getBits (iLengthOfMBNumber);
  208. m_iVPMBnum = uiMBNumber;
  209. if(m_volmd.bShapeOnly==FALSE) {
  210. Int stepDecoded = m_pbitstrmIn -> getBits (NUMBITS_VP_QUANTIZER);
  211. iCurrentQP = stepDecoded; 
  212. }
  214. if (m_volmd.fAUsage == RECTANGLE)
  215. uiHEC = m_pbitstrmIn -> getBits (NUMBITS_VP_HEC);
  217. if (uiHEC){
  219. // Time reference and VOP_pred_type
  220. Int iModuloInc = 0;
  221. while (m_pbitstrmIn -> getBits (1) != 0)
  222. iModuloInc++;
  223. //Time tCurrSec = iModuloInc + (m_vopmd.vopPredType != BVOP ? m_tOldModuloBaseDecd : m_tOldModuloBaseDisp);
  224. UInt uiMarker = m_pbitstrmIn -> getBits (1);
  225. assert(uiMarker == 1);
  226. /* Time tVopIncr = wmay */ m_pbitstrmIn -> getBits (m_iNumBitsTimeIncr);
  227. uiMarker = m_pbitstrmIn -> getBits (1);
  228. assert(uiMarker == 1);
  229. // this is bogus - swinder.
  230. //assert (m_t == tCurrSec * 60 + tVopIncr * 60 / m_volmd.iClockRate); //in terms of 60Hz clock ticks
  232. VOPpredType vopPredType = (VOPpredType) m_pbitstrmIn -> getBits (NUMBITS_VP_PRED_TYPE);
  233. assert(m_vopmd.vopPredType == vopPredType);
  235. if (m_volmd.fAUsage != RECTANGLE) {
  236. m_volmd.bNoCrChange = m_pbitstrmIn -> getBits (1); //VOP_CR_Change_Disable
  237.         if (m_volmd.bShapeOnly==FALSE && m_vopmd.vopPredType != IVOP)
  238. {
  239. m_vopmd.bShapeCodingType = m_pbitstrmIn -> getBits (1);
  240.          }
  241. }
  243. if(m_volmd.bShapeOnly==FALSE) {
  244. Int iIntraDcSwitchThr = m_pbitstrmIn->getBits (NUMBITS_VP_INTRA_DC_SWITCH_THR);
  245. assert(m_vopmd.iIntraDcSwitchThr == iIntraDcSwitchThr);
  246. if (m_vopmd.vopPredType == PVOP) {
  247. UInt uiFCode = m_pbitstrmIn -> getBits (NUMBITS_VOP_FCODE);
  248. assert(uiFCode == m_vopmd.mvInfoForward.uiFCode);
  249. }
  250. else if (m_vopmd.vopPredType == BVOP) {
  251. UInt uiForwardFCode = m_pbitstrmIn -> getBits (NUMBITS_VOP_FCODE);
  252. UInt uiBackwardFCode = m_pbitstrmIn -> getBits (NUMBITS_VOP_FCODE);
  253. assert(uiForwardFCode == m_vopmd.mvInfoForward.uiFCode);
  254. assert(uiBackwardFCode == m_vopmd.mvInfoBackward.uiFCode);
  255. }
  256. }
  257. }
  258. return TRUE;
  259. }
  260. #endif
  262. Int CVideoObjectDecoder::checkMotionMarker()
  263. {
  264. return (m_pbitstrmIn -> peekBits (NUMBITS_DP_MOTION_MARKER) == MOTION_MARKER);
  265. }
  266. Int CVideoObjectDecoder::checkDCMarker()
  267. {
  268. return (m_pbitstrmIn -> peekBits (NUMBITS_DP_DC_MARKER) == DC_MARKER);
  269. }
  271. Void CVideoObjectDecoder::decodeIVOP_DataPartitioning ()
  272. {
  273. // assert (m_volmd.nBits==8);
  274. //in case the IVOP is used as an ref for direct mode
  275. // bug fix by toshiba 98-9-24 start
  276. // memset (m_rgmv, 0, m_iNumMB * 5 * sizeof (CMotionVector));
  277. memset (m_rgmv, 0, m_iNumMB * PVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
  278. // bug fix by toshiba 98-9-24 end
  280. Int iMBX=0, iMBY=0;
  281. CMBMode* pmbmd = m_rgmbmd;
  282. pmbmd->m_stepSize = m_vopmd.intStepI;
  283. PixelC* ppxlcRefY = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
  284. PixelC* ppxlcRefU = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
  285. PixelC* ppxlcRefV = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
  287. Int iCurrentQP  = m_vopmd.intStepI;
  288. Int iVideoPacketNumber = 0;
  289. m_iVPMBnum = 0;
  291. m_piMCBPC = new Int[m_iNumMBX*m_iNumMBY];
  292. Int* piMCBPC = m_piMCBPC;
  293. m_piIntraDC = new Int[m_iNumMBX*m_iNumMBY*V_BLOCK];
  294. Int* piIntraDC = m_piIntraDC;
  296. Int i;
  297. Int mbn = 0, mbnFirst = 0;
  298. Bool bRestartDelayedQP = TRUE;
  300. do{
  301. if( checkResyncMarker() ){
  302. decodeVideoPacketHeader(iCurrentQP);
  303. iVideoPacketNumber++;
  304. bRestartDelayedQP = TRUE;
  305. }
  307. CMBMode* pmbmdFirst = pmbmd;
  308. Int* piMCBPCFirst = piMCBPC;
  309. Int* piIntraDCFirst = piIntraDC;
  310. mbnFirst = mbn;
  311. do{
  312. pmbmd->m_iVideoPacketNumber = iVideoPacketNumber;
  314. *piMCBPC = m_pentrdecSet->m_pentrdecMCBPCintra->decodeSymbol ();
  315. assert (*piMCBPC >= 0 && *piMCBPC <= 7);
  316. pmbmd->m_dctMd = INTRA;
  317. if (*piMCBPC > 3)
  318. pmbmd->m_dctMd = INTRAQ;
  319. decodeMBTextureDCOfIVOP_DataPartitioning (pmbmd, iCurrentQP, piIntraDC, bRestartDelayedQP);
  320. pmbmd++;
  321. mbn++;
  322. piMCBPC++;
  323. piIntraDC+=V_BLOCK;
  324. } while( !checkDCMarker() );
  325. m_pbitstrmIn -> getBits (NUMBITS_DP_DC_MARKER);
  327. pmbmd = pmbmdFirst;
  328. piMCBPC = piMCBPCFirst;
  329. for(i=mbnFirst;i<mbn;i++) {
  330. decodeMBTextureHeadOfIVOP_DataPartitioning (pmbmd, piMCBPC);
  331. pmbmd++;
  332. piMCBPC++;
  333. }
  335. pmbmd = pmbmdFirst;
  336. piIntraDC = piIntraDCFirst;
  337. ppxlcRefY = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY + (mbnFirst/m_iNumMBX)*m_iFrameWidthYxMBSize;
  338. ppxlcRefU = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV + (mbnFirst/m_iNumMBX)*m_iFrameWidthUVxBlkSize;
  339. ppxlcRefV = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV + (mbnFirst/m_iNumMBX)*m_iFrameWidthUVxBlkSize;
  340. PixelC* ppxlcRefMBY = ppxlcRefY + (mbnFirst%m_iNumMBX)*MB_SIZE;
  341. PixelC* ppxlcRefMBU = ppxlcRefU + (mbnFirst%m_iNumMBX)*BLOCK_SIZE;
  342. PixelC* ppxlcRefMBV = ppxlcRefV + (mbnFirst%m_iNumMBX)*BLOCK_SIZE;
  343. for(i=mbnFirst;i<mbn;i++) {
  344. iMBX = i % m_iNumMBX;
  345. iMBY = i / m_iNumMBX;
  346. if(iMBX == 0 ) {
  347. ppxlcRefMBY = ppxlcRefY;
  348. ppxlcRefMBU = ppxlcRefU;
  349. ppxlcRefMBV = ppxlcRefV;
  350. }
  352. decodeTextureIntraMB_DataPartitioning (pmbmd, iMBX, iMBY, ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, piIntraDC);
  354. pmbmd++;
  355. piIntraDC += V_BLOCK;
  356. ppxlcRefMBY += MB_SIZE;
  357. ppxlcRefMBU += BLOCK_SIZE;
  358. ppxlcRefMBV += BLOCK_SIZE;
  359. if(iMBX == m_iNumMBX - 1) {
  360. MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
  361. m_rgpmbmAbove = m_rgpmbmCurr;
  362. m_rgpmbmCurr  = ppmbmTemp;
  363. ppxlcRefY += m_iFrameWidthYxMBSize;
  364. ppxlcRefU += m_iFrameWidthUVxBlkSize;
  365. ppxlcRefV += m_iFrameWidthUVxBlkSize;
  366. }
  367. }
  368. } while( checkResyncMarker() );
  369. delete m_piMCBPC;
  370. }
  372. Void CVideoObjectDecoder::decodeMBTextureDCOfIVOP_DataPartitioning (CMBMode* pmbmd, Int& iCurrentQP,
  373. Int* piIntraDC, Bool &bUseNewQPForVlcThr)
  374. {
  375. Int iBlk = 0;
  376. pmbmd->m_stepSize = iCurrentQP;
  377. pmbmd->m_stepSizeDelayed = iCurrentQP;
  378. if (pmbmd->m_dctMd == INTRAQ) {
  379. Int iDQUANT = m_pbitstrmIn->getBits (2);
  380. switch (iDQUANT) {
  381. case 0:
  382. pmbmd->m_intStepDelta = -1;
  383. break;
  384. case 1:
  385. pmbmd->m_intStepDelta = -2;
  386. break;
  387. case 2:
  388. pmbmd->m_intStepDelta = 1;
  389. break;
  390. case 3:
  391. pmbmd->m_intStepDelta = 2;
  392. break;
  393. default:
  394. assert (FALSE);
  395. }
  396. pmbmd->m_stepSize += pmbmd->m_intStepDelta;
  397. if(bUseNewQPForVlcThr)
  398. pmbmd->m_stepSizeDelayed = pmbmd->m_stepSize;
  399. Int iQuantMax = (1<<m_volmd.uiQuantPrecision) - 1;
  400. checkrange (pmbmd->m_stepSize, 1, iQuantMax);
  401. iCurrentQP = pmbmd->m_stepSize;
  402. }
  404. assert (pmbmd != NULL);
  405. if (pmbmd -> m_rgTranspStatus [0] == ALL) 
  406. return;
  408. bUseNewQPForVlcThr = FALSE;
  410. assert (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ);
  411. Int iQP = pmbmd->m_stepSize;
  412. for (Int i = 0; i <= 31; i++) {
  413. if (iQP <= 4) {
  414. m_rgiDcScalerY [i] = 8;
  415. m_rgiDcScalerC [i] = 8;
  416. }
  417. else if (iQP >= 5 && iQP <= 8) {
  418. m_rgiDcScalerY [i] = 2 * iQP;
  419. m_rgiDcScalerC [i] = (iQP + 13) / 2;
  420. }
  421. else if (iQP >= 9 && iQP <= 24) {
  422. m_rgiDcScalerY [i] = iQP + 8;
  423. m_rgiDcScalerC [i] = (iQP + 13) / 2;
  424. }
  425. else {
  426. m_rgiDcScalerY [i] = 2 * iQP - 16;
  427. m_rgiDcScalerC [i] = iQP - 6;
  428. }
  429. }
  431. assert (iQP > 0);
  432. assert (pmbmd -> m_stepSizeDelayed > 0);
  433. if (pmbmd -> m_stepSizeDelayed >= grgiDCSwitchingThreshold [m_vopmd.iIntraDcSwitchThr])
  434. pmbmd->m_bCodeDcAsAc = TRUE;
  435. else
  436. pmbmd->m_bCodeDcAsAc = FALSE;
  438. for (iBlk = Y_BLOCK1; iBlk < U_BLOCK; iBlk++) {
  439. if (pmbmd->m_rgTranspStatus [iBlk] != ALL)
  440. decodeIntraBlockTexture_DataPartitioning (iBlk, pmbmd, piIntraDC);
  441. }
  442. for (iBlk = U_BLOCK; iBlk <= V_BLOCK; iBlk++) {
  443. decodeIntraBlockTexture_DataPartitioning (iBlk, pmbmd, piIntraDC);
  444. }
  445. }
  447. Void CVideoObjectDecoder::decodeMBTextureHeadOfIVOP_DataPartitioning (CMBMode* pmbmd, Int* piMCBPC)
  448. {
  449. assert (pmbmd->m_rgTranspStatus [0] != ALL);
  450. Int iBlk = 0, cNonTrnspBlk = 0;
  451. for (iBlk = (Int) Y_BLOCK1; iBlk <= (Int) Y_BLOCK4; iBlk++) {
  452. if (pmbmd->m_rgTranspStatus [iBlk] != ALL)
  453. cNonTrnspBlk++;
  454. }
  455. Int iCBPC = 0;
  456. Int iCBPY = 0;
  457. // bug fix by toshiba 98-9-24 start
  458. pmbmd->m_dctMd = INTRA;
  459. pmbmd->m_bSkip = FALSE; //reset for direct mode 
  460. if (*piMCBPC > 3)
  461. pmbmd->m_dctMd = INTRAQ;
  462. // bug fix by toshiba 98-9-24 end
  463. iCBPC = *piMCBPC % 4;
  464. pmbmd->m_bACPrediction = m_pbitstrmIn->getBits (1);
  465. switch (cNonTrnspBlk) {
  466. case 1:
  467. iCBPY = m_pentrdecSet->m_pentrdecCBPY1->decodeSymbol ();
  468. break;
  469. case 2:
  470. iCBPY = m_pentrdecSet->m_pentrdecCBPY2->decodeSymbol ();
  471. break;
  472. case 3:
  473. iCBPY = m_pentrdecSet->m_pentrdecCBPY3->decodeSymbol ();
  474. break;
  475. case 4:
  476. iCBPY = m_pentrdecSet->m_pentrdecCBPY->decodeSymbol ();
  477. break;
  478. default:
  479. assert (FALSE);
  480. }
  481. setCBPYandC (pmbmd, iCBPC, iCBPY, cNonTrnspBlk);
  482. }
  484. Void CVideoObjectDecoder::decodeTextureIntraMB_DataPartitioning (
  485. CMBMode* pmbmd, CoordI iMBX, CoordI iMBY, 
  486. PixelC* ppxlcCurrFrmQY, PixelC* ppxlcCurrFrmQU, PixelC* ppxlcCurrFrmQV, Int* piIntraDC)
  487. {
  488. assert (pmbmd != NULL);
  489. if (pmbmd -> m_rgTranspStatus [0] == ALL) 
  490. return;
  492. assert (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ);
  493. Int iQP = pmbmd->m_stepSize;
  494. for (Int i = 0; i <= 31; i++) {
  495. if (iQP <= 4) {
  496. m_rgiDcScalerY [i] = 8;
  497. m_rgiDcScalerC [i] = 8;
  498. }
  499. else if (iQP >= 5 && iQP <= 8) {
  500. m_rgiDcScalerY [i] = 2 * iQP;
  501. m_rgiDcScalerC [i] = (iQP + 13) / 2;
  502. }
  503. else if (iQP >= 9 && iQP <= 24) {
  504. m_rgiDcScalerY [i] = iQP + 8;
  505. m_rgiDcScalerC [i] = (iQP + 13) / 2;
  506. }
  507. else {
  508. m_rgiDcScalerY [i] = 2 * iQP - 16;
  509. m_rgiDcScalerC [i] = iQP - 6;
  510. }
  511. }
  513. assert (iQP > 0);
  514. assert (pmbmd -> m_stepSizeDelayed > 0);
  515. if (pmbmd -> m_stepSizeDelayed >= grgiDCSwitchingThreshold [m_vopmd.iIntraDcSwitchThr])
  516. pmbmd->m_bCodeDcAsAc = TRUE;
  517. else
  518. pmbmd->m_bCodeDcAsAc = FALSE;
  520. //for intra pred
  521. MacroBlockMemory* pmbmLeft = NULL;
  522. MacroBlockMemory* pmbmTop = NULL;
  523. MacroBlockMemory* pmbmLeftTop = NULL;
  524. CMBMode* pmbmdLeft = NULL;
  525. CMBMode* pmbmdTop = NULL;
  526. CMBMode* pmbmdLeftTop = NULL;
  527.  
  528. Int iMBTop = iMBY - 1;
  529. if (iMBTop >= 0) {
  530. if(pmbmd->m_iVideoPacketNumber==(pmbmd - m_iNumMBX)->m_iVideoPacketNumber) {
  531. pmbmTop  = m_rgpmbmAbove [iMBX];
  532. pmbmdTop = pmbmd - m_iNumMBX;
  533. }
  534. }
  536. if (iMBX > 0) {
  537. if(pmbmd->m_iVideoPacketNumber==(pmbmd - 1)->m_iVideoPacketNumber) {
  538. pmbmLeft  = m_rgpmbmCurr [iMBX - 1];
  539. pmbmdLeft = pmbmd -  1;
  540. }
  541. }
  543. if (iMBTop >= 0 && iMBX > 0) {
  544. if(pmbmd->m_iVideoPacketNumber==(pmbmd - m_iNumMBX - 1)->m_iVideoPacketNumber) {
  545. pmbmLeftTop  = m_rgpmbmAbove [iMBX - 1];
  546. pmbmdLeftTop = pmbmd - m_iNumMBX - 1;
  547. }
  548. }
  550. PixelC* rgchBlkDst = NULL;
  551. Int iWidthDst;
  552. Int iDcScaler;
  553. Int* rgiCoefQ;
  554. for (Int iBlk = Y_BLOCK1; iBlk <= V_BLOCK; iBlk++) {
  555. if (iBlk < U_BLOCK) {
  556. if (pmbmd -> m_rgTranspStatus [iBlk] == ALL) 
  557. continue;
  558. switch (iBlk) 
  559. {
  560. case (Y_BLOCK1): 
  561. rgchBlkDst = ppxlcCurrFrmQY;
  562. break;
  563. case (Y_BLOCK2): 
  564. rgchBlkDst = ppxlcCurrFrmQY + BLOCK_SIZE;
  565. break;
  566. case (Y_BLOCK3): 
  567. rgchBlkDst = ppxlcCurrFrmQY + m_iFrameWidthYxBlkSize;
  568. break;
  569. case (Y_BLOCK4): 
  570. rgchBlkDst = ppxlcCurrFrmQY + m_iFrameWidthYxBlkSize + BLOCK_SIZE;
  571. break;
  572. }
  573. iWidthDst = m_iFrameWidthY;
  574. iDcScaler = m_rgiDcScalerY [iQP];
  575. }
  576. else {
  577. iWidthDst = m_iFrameWidthUV;
  578. rgchBlkDst = (iBlk == U_BLOCK) ? ppxlcCurrFrmQU: ppxlcCurrFrmQV;
  579. iDcScaler = m_rgiDcScalerC [iQP];
  580. }
  581. rgiCoefQ = m_rgpiCoefQ [iBlk - 1];
  582. const BlockMemory blkmPred = NULL;
  583. Int iQpPred = iQP; //default to current if no pred (use 128 case)
  585. decideIntraPred (blkmPred, 
  586.  pmbmd,
  587.  iQpPred,
  588.  (BlockNum) iBlk,
  589.  pmbmLeft, 
  590.     pmbmTop, 
  591.  pmbmLeftTop,
  592.  m_rgpmbmCurr[iMBX],
  593.  pmbmdLeft,
  594.  pmbmdTop,
  595.  pmbmdLeftTop);
  596. decodeIntraBlockTextureTcoef_DataPartitioning (rgchBlkDst,
  597.  iWidthDst,
  598.  iQP, 
  599.  iDcScaler,
  600.  iBlk,
  601.  *(m_rgpmbmCurr + iMBX),
  602.  pmbmd,
  603.    blkmPred, //for intra-pred
  604.  iQpPred,
  605.  piIntraDC);
  606. }
  607. }
  609. Void CVideoObjectDecoder::decodeIntraBlockTexture_DataPartitioning (Int iBlk, CMBMode* pmbmd, Int* piIntraDC)
  610. {
  611. if (!pmbmd->m_bCodeDcAsAc)
  612. piIntraDC[iBlk - 1] = decodeIntraDCmpeg (iBlk <= Y_BLOCK4 || iBlk >=A_BLOCK1);
  613. }
  615. Void CVideoObjectDecoder::decodeIntraBlockTextureTcoef_DataPartitioning (PixelC* rgpxlcBlkDst,
  616.  Int iWidthDst,
  617.  Int iQP,
  618.  Int iDcScaler,
  619.  Int iBlk,
  620.  MacroBlockMemory* pmbmCurr,
  621.  CMBMode* pmbmd,
  622.    const BlockMemory blkmPred,
  623.  Int iQpPred,
  624.  Int* piIntraDC)
  626. {
  627. Int iCoefStart = 0;
  628. if (!pmbmd->m_bCodeDcAsAc) {
  629. iCoefStart++;
  630. }
  632. Int* rgiCoefQ = m_rgpiCoefQ [iBlk - 1];
  633. rgiCoefQ[0] = piIntraDC [iBlk - 1];
  634. if (pmbmd->getCodedBlockPattern ((BlockNum) iBlk)) {
  635. Int* rgiZigzag = grgiStandardZigzag;
  636. if (pmbmd->m_bACPrediction)
  637. rgiZigzag = (pmbmd->m_preddir [iBlk - 1] == HORIZONTAL) ? grgiVerticalZigzag : grgiHorizontalZigzag;
  638.   if(m_volmd.bReversibleVlc)
  639.   decodeIntraRVLCTCOEF (rgiCoefQ, iCoefStart, rgiZigzag);
  640.   else
  641. decodeIntraTCOEF (rgiCoefQ, iCoefStart, rgiZigzag);
  642. }
  643. else
  644. memset (rgiCoefQ + iCoefStart, 0, sizeof (Int) * (BLOCK_SQUARE_SIZE - iCoefStart));
  645. inverseDCACPred (pmbmd, iBlk - 1, rgiCoefQ, iQP, iDcScaler, blkmPred, iQpPred);
  646. inverseQuantizeIntraDc (rgiCoefQ, iDcScaler);
  647. if (m_volmd.fQuantizer == Q_H263)
  648. inverseQuantizeDCTcoefH263 (rgiCoefQ, 1, iQP);
  649. else
  650. inverseQuantizeIntraDCTcoefMPEG (rgiCoefQ, 1, iQP, iBlk>=A_BLOCK1);
  652. Int i, j; //save coefQ (ac) for intra pred
  653. pmbmCurr->rgblkm [iBlk - 1] [0] = m_rgiDCTcoef [0]; //save recon value of DC for intra pred //save Qcoef in memory
  654. for (i = 1, j = 8; i < BLOCK_SIZE; i++, j += BLOCK_SIZE) {
  655. pmbmCurr->rgblkm [iBlk - 1] [i] = rgiCoefQ [i];
  656. pmbmCurr->rgblkm [iBlk - 1] [i + BLOCK_SIZE - 1] = rgiCoefQ [j];
  657. }
  660. m_pidct->apply (m_rgiDCTcoef, BLOCK_SIZE, rgpxlcBlkDst, iWidthDst);
  661. }
  663. Void CVideoObjectDecoder::decodePVOP_DataPartitioning ()
  664. {
  665. // assert (m_volmd.nBits==8);
  666. Int iMBX, iMBY;
  667. //CoordI y = 0; 
  668. CMBMode* pmbmd = m_rgmbmd;
  669. CMotionVector* pmv = m_rgmv;
  670. PixelC* ppxlcCurrQY = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
  671. PixelC* ppxlcCurrQU = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
  672. PixelC* ppxlcCurrQV = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
  674. Int iCurrentQP  = m_vopmd.intStep;
  675. Int iVideoPacketNumber = 0;
  676. m_iVPMBnum = 0;
  677. Bool bLeftBndry;
  678. Bool bRightBndry;
  679. Bool bTopBndry;
  681. m_piMCBPC = new Int[m_iNumMBX*m_iNumMBY];
  682. Int* piMCBPC = m_piMCBPC;
  683. m_piIntraDC = new Int[m_iNumMBX*m_iNumMBY*V_BLOCK];
  684. Int* piIntraDC = m_piIntraDC;
  685. // End Toshiba
  687. Int i;
  688. Int mbn = 0, mbnFirst = 0;
  690. CoordI x = 0;
  691. CoordI y = 0;
  692. PixelC* ppxlcCurrQMBY = NULL;
  693. PixelC* ppxlcCurrQMBU = NULL;
  694. PixelC* ppxlcCurrQMBV = NULL;
  696. Bool bMBBackup = FALSE;
  697. CMBMode* pmbmdBackup = NULL;
  698. Int iMBXBackup = 0, iMBYBackup = 0;
  699. CMotionVector* pmvBackup = 0;
  700. PixelC* ppxlcCurrQMBYBackup = NULL;
  701. PixelC* ppxlcCurrQMBUBackup = NULL;
  702. PixelC* ppxlcCurrQMBVBackup = NULL;
  704. Bool bRestartDelayedQP = TRUE;
  706. do{
  707. CMBMode* pmbmdFirst = pmbmd;
  708. CMotionVector* pmvFirst = pmv;
  709. Int* piMCBPCFirst = piMCBPC;
  710. Int* piIntraDCFirst = piIntraDC;
  711. mbnFirst = mbn;
  713. if( checkResyncMarker() ){
  714. decodeVideoPacketHeader(iCurrentQP);
  715. iVideoPacketNumber++;
  716. bRestartDelayedQP = TRUE;
  717. }
  719. do{
  720. pmbmd->m_iVideoPacketNumber = iVideoPacketNumber;
  721. iMBX = mbn % m_iNumMBX;
  722. iMBY = mbn / m_iNumMBX;
  724. pmbmd->m_bSkip = m_pbitstrmIn->getBits (1);
  725. if (!pmbmd->m_bSkip) {
  726. *piMCBPC = m_pentrdecSet->m_pentrdecMCBPCinter->decodeSymbol ();
  727. assert (*piMCBPC >= 0 && *piMCBPC <= 20);
  728. Int iMBtype = *piMCBPC / 4; //per H.263's MBtype
  729. switch (iMBtype) {
  730. case 0:
  731. pmbmd->m_dctMd = INTER;
  732. pmbmd -> m_bhas4MVForward = FALSE;
  733. break;
  734. case 1:
  735. pmbmd->m_dctMd = INTERQ;
  736. pmbmd -> m_bhas4MVForward = FALSE;
  737. break;
  738. case 2:
  739. pmbmd -> m_dctMd = INTER;
  740. pmbmd -> m_bhas4MVForward = TRUE;
  741. break;
  742. case 3:
  743. pmbmd->m_dctMd = INTRA;
  744. break;
  745. case 4:
  746. pmbmd->m_dctMd = INTRAQ;
  747. break;
  748. default:
  749. assert (FALSE);
  750. }
  751. } else { //skipped
  752. pmbmd->m_dctMd = INTER;
  753. pmbmd -> m_bhas4MVForward = FALSE;
  754. }
  755. if(iMBX == 0) {
  756. bLeftBndry = TRUE;
  757. } else {
  758. bLeftBndry = !((pmbmd - 1) -> m_iVideoPacketNumber == pmbmd -> m_iVideoPacketNumber);
  759. }
  760. if(iMBY == 0) {
  761. bTopBndry = TRUE;
  762. } else {
  763. bTopBndry = !((pmbmd - m_iNumMBX) -> m_iVideoPacketNumber == pmbmd -> m_iVideoPacketNumber);
  764. }
  765. if((iMBX == m_iNumMBX - 1) || (iMBY == 0)) {
  766. bRightBndry = TRUE;
  767. } else {
  768. bRightBndry = !((pmbmd - m_iNumMBX + 1) -> m_iVideoPacketNumber == pmbmd -> m_iVideoPacketNumber);
  769. }
  770. decodeMV (pmbmd, pmv, bLeftBndry, bRightBndry, bTopBndry, FALSE, iMBX, iMBY);
  772. if(bMBBackup){
  773. if (pmbmdBackup->m_dctMd == INTER || pmbmdBackup->m_dctMd == INTERQ) {
  774. motionCompMB (
  775. m_ppxlcPredMBY, m_pvopcRefQ0->pixelsY (),
  776. pmvBackup, pmbmdBackup, 
  777. iMBXBackup, iMBYBackup, 
  778. x, y,
  779. pmbmdBackup->m_bSkip, FALSE,
  780. &m_rctRefVOPY0
  781. );
  782. if (!pmbmdBackup->m_bSkip) {
  783. CoordI iXRefUV, iYRefUV, iXRefUV1, iYRefUV1;
  784. mvLookupUV (pmbmdBackup, pmvBackup, iXRefUV, iYRefUV, iXRefUV1, iYRefUV1);
  785. motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, x, y, iXRefUV, iYRefUV, m_vopmd.iRoundingControl, &m_rctRefVOPY0);
  786. addErrorAndPredToCurrQ (ppxlcCurrQMBYBackup, ppxlcCurrQMBUBackup, ppxlcCurrQMBVBackup);
  787. }
  788. else {
  789. if (m_volmd.bAdvPredDisable)
  791. copyFromRefToCurrQ (m_pvopcRefQ0, x, y, ppxlcCurrQMBYBackup, ppxlcCurrQMBUBackup, ppxlcCurrQMBVBackup, NULL);
  792. else
  793. copyFromPredForYAndRefForCToCurrQ (x, y, ppxlcCurrQMBYBackup, ppxlcCurrQMBUBackup, ppxlcCurrQMBVBackup, NULL);
  794. }
  795. }
  796. bMBBackup = FALSE;
  797. }
  799. pmbmd++;
  800. pmv += PVOP_MV_PER_REF_PER_MB;
  801. mbn++;
  802. piMCBPC++;
  803. assert(mbn<=(m_iNumMBX*m_iNumMBY));
  804. } while( !checkMotionMarker() );
  805. m_pbitstrmIn -> getBits (NUMBITS_DP_MOTION_MARKER);
  807. pmbmd = pmbmdFirst;
  808. piMCBPC = piMCBPCFirst;
  809. piIntraDC = piIntraDCFirst;
  810. for(i=mbnFirst;i<mbn;i++) {
  811. decodeMBTextureHeadOfPVOP_DataPartitioning (pmbmd, iCurrentQP, piMCBPC, piIntraDC, bRestartDelayedQP);
  812. pmbmd++;
  813. piMCBPC++;
  814. piIntraDC += V_BLOCK;
  815. }
  817. pmbmd = pmbmdFirst;
  818. pmv = pmvFirst;
  819. piIntraDC = piIntraDCFirst;
  821. for(i=mbnFirst;i<mbn;i++) {
  822. iMBX = i % m_iNumMBX;
  823. iMBY = i / m_iNumMBX;
  824. if(iMBX == 0 ) {
  825. ppxlcCurrQMBY = ppxlcCurrQY;
  826. ppxlcCurrQMBU = ppxlcCurrQU;
  827. ppxlcCurrQMBV = ppxlcCurrQV;
  828. x = 0;
  829. if(iMBY != 0) y += MB_SIZE;
  830. } else {
  831. x += MB_SIZE;
  832. }
  834. if (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ)
  835. decodeTextureIntraMB_DataPartitioning (pmbmd, iMBX, iMBY, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, piIntraDC);
  836. else {
  837. if (!pmbmd->m_bSkip)
  838. decodeTextureInterMB (pmbmd);
  839. }
  841. if(i==mbn-1){
  842. bMBBackup = TRUE;
  843. pmbmdBackup = pmbmd;
  844. pmvBackup = pmv;
  845. iMBXBackup = iMBX;
  846. iMBYBackup = iMBY;
  847. ppxlcCurrQMBYBackup = ppxlcCurrQMBY;
  848. ppxlcCurrQMBUBackup = ppxlcCurrQMBU;
  849. ppxlcCurrQMBVBackup = ppxlcCurrQMBV;
  850. }
  852. if (pmbmd->m_dctMd == INTER || pmbmd->m_dctMd == INTERQ) {
  853. motionCompMB (
  854. m_ppxlcPredMBY, m_pvopcRefQ0->pixelsY (),
  855. pmv, pmbmd, 
  856. iMBX, iMBY, 
  857. x, y,
  858. pmbmd->m_bSkip, FALSE,
  859. &m_rctRefVOPY0
  860. );
  861. if (!pmbmd->m_bSkip) {
  862. CoordI iXRefUV, iYRefUV, iXRefUV1, iYRefUV1;
  863. mvLookupUV (pmbmd, pmv, iXRefUV, iYRefUV, iXRefUV1, iYRefUV1);
  864. motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, x, y, iXRefUV, iYRefUV, m_vopmd.iRoundingControl, &m_rctRefVOPY0);
  865. addErrorAndPredToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
  866. }
  867. else {
  868. if (m_volmd.bAdvPredDisable)
  870. copyFromRefToCurrQ (m_pvopcRefQ0, x, y, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, NULL);
  871. else
  872. copyFromPredForYAndRefForCToCurrQ (x, y, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, NULL);
  873. }
  874. }
  876. pmbmd++;
  877. pmv += PVOP_MV_PER_REF_PER_MB;
  878. piIntraDC += V_BLOCK;
  879. ppxlcCurrQMBY += MB_SIZE;
  880. ppxlcCurrQMBU += BLOCK_SIZE;
  881. ppxlcCurrQMBV += BLOCK_SIZE;
  883. if(iMBX == m_iNumMBX - 1) {
  884. MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
  885. m_rgpmbmAbove = m_rgpmbmCurr;
  886. m_rgpmbmCurr  = ppmbmTemp;
  887. ppxlcCurrQY += m_iFrameWidthYxMBSize;
  888. ppxlcCurrQU += m_iFrameWidthUVxBlkSize;
  889. ppxlcCurrQV += m_iFrameWidthUVxBlkSize;
  890. }
  891. }
  892. } while( checkResyncMarker() );
  893. delete m_piIntraDC;
  894. delete m_piMCBPC;
  895. }
  897. Void CVideoObjectDecoder::decodeMBTextureHeadOfPVOP_DataPartitioning (CMBMode* pmbmd, Int& iCurrentQP, Int* piMCBPC,
  898.   Int* piIntraDC, Bool &bUseNewQPForVlcThr)
  899. {
  900. assert (pmbmd->m_rgTranspStatus [0] != ALL);
  901. Int iBlk = 0, cNonTrnspBlk = 0;
  902. for (iBlk = (Int) Y_BLOCK1; iBlk <= (Int) Y_BLOCK4; iBlk++) {
  903. if (pmbmd->m_rgTranspStatus [iBlk] != ALL)
  904. cNonTrnspBlk++;
  905. }
  906. Int iCBPC = 0;
  907. Int iCBPY = 0;
  908. if (!pmbmd->m_bSkip) {
  909.   //Int iMBtype = *piMCBPC / 4; //per H.263's MBtype
  910. iCBPC = *piMCBPC % 4;
  911. if (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ) {
  912. pmbmd->m_bACPrediction = m_pbitstrmIn->getBits (1);
  913. switch (cNonTrnspBlk) {
  914. case 1:
  915. iCBPY = m_pentrdecSet->m_pentrdecCBPY1->decodeSymbol ();
  916. break;
  917. case 2:
  918. iCBPY = m_pentrdecSet->m_pentrdecCBPY2->decodeSymbol ();
  919. break;
  920. case 3:
  921. iCBPY = m_pentrdecSet->m_pentrdecCBPY3->decodeSymbol ();
  922. break;
  923. case 4:
  924. iCBPY = m_pentrdecSet->m_pentrdecCBPY->decodeSymbol ();
  925. break;
  926. default:
  927. assert (FALSE);
  928. }
  929. }
  930. else {
  931. switch (cNonTrnspBlk) {
  932. case 1:
  933. iCBPY = 1 - m_pentrdecSet->m_pentrdecCBPY1->decodeSymbol ();
  934. break;
  935. case 2:
  936. iCBPY = 3 - m_pentrdecSet->m_pentrdecCBPY2->decodeSymbol ();
  937. break;
  938. case 3:
  939. iCBPY = 7 - m_pentrdecSet->m_pentrdecCBPY3->decodeSymbol ();
  940. break;
  941. case 4:
  942. iCBPY = 15 - m_pentrdecSet->m_pentrdecCBPY->decodeSymbol ();
  943. break;
  944. default:
  945. assert (FALSE);
  946. }
  947. }
  949. assert (iCBPY >= 0 && iCBPY <= 15);
  950. }
  951. else { //skipped
  952. pmbmd->m_dctMd = INTER;
  953. pmbmd -> m_bhas4MVForward = FALSE;
  954. }
  955. setCBPYandC (pmbmd, iCBPC, iCBPY, cNonTrnspBlk);
  956. pmbmd->m_stepSize = iCurrentQP;
  957. pmbmd->m_stepSizeDelayed = iCurrentQP;
  958. if (pmbmd->m_dctMd == INTERQ || pmbmd->m_dctMd == INTRAQ) {
  959. assert (!pmbmd->m_bSkip);
  960. Int iDQUANT = m_pbitstrmIn->getBits (2);
  961. switch (iDQUANT) {
  962. case 0:
  963. pmbmd->m_intStepDelta = -1;
  964. break;
  965. case 1:
  966. pmbmd->m_intStepDelta = -2;
  967. break;
  968. case 2:
  969. pmbmd->m_intStepDelta = 1;
  970. break;
  971. case 3:
  972. pmbmd->m_intStepDelta = 2;
  973. break;
  974. default:
  975. assert (FALSE);
  976. }
  977. pmbmd->m_stepSize += pmbmd->m_intStepDelta;
  978. if(bUseNewQPForVlcThr)
  979. pmbmd->m_stepSizeDelayed = pmbmd->m_stepSize;
  980. Int iQuantMax = (1<<m_volmd.uiQuantPrecision) - 1;
  981. if (pmbmd->m_stepSize < 1)
  982. pmbmd->m_stepSize = 1;
  983. else if (pmbmd->m_stepSize > iQuantMax)
  984. pmbmd->m_stepSize = iQuantMax;
  985. iCurrentQP = pmbmd->m_stepSize;
  986. }
  988. if (!pmbmd->m_bSkip)
  989. bUseNewQPForVlcThr = FALSE;
  991. if(pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ) {
  992. Int iQP = pmbmd->m_stepSize;
  993. for (Int i = 0; i <= 31; i++) {
  994. if (iQP <= 4) {
  995. m_rgiDcScalerY [i] = 8;
  996. m_rgiDcScalerC [i] = 8;
  997. }
  998. else if (iQP >= 5 && iQP <= 8) {
  999. m_rgiDcScalerY [i] = 2 * iQP;
  1000. m_rgiDcScalerC [i] = (iQP + 13) / 2;
  1001. }
  1002. else if (iQP >= 9 && iQP <= 24) {
  1003. m_rgiDcScalerY [i] = iQP + 8;
  1004. m_rgiDcScalerC [i] = (iQP + 13) / 2;
  1005. }
  1006. else {
  1007. m_rgiDcScalerY [i] = 2 * iQP - 16;
  1008. m_rgiDcScalerC [i] = iQP - 6;
  1009. }
  1010. }
  1012. assert (iQP > 0);
  1013. assert (pmbmd -> m_stepSizeDelayed > 0);
  1014. if (pmbmd -> m_stepSizeDelayed >= grgiDCSwitchingThreshold [m_vopmd.iIntraDcSwitchThr])
  1015. pmbmd->m_bCodeDcAsAc = TRUE;
  1016. else
  1017. pmbmd->m_bCodeDcAsAc = FALSE;
  1019. for (iBlk = Y_BLOCK1; iBlk < U_BLOCK; iBlk++) {
  1020. if (pmbmd->m_rgTranspStatus [iBlk] != ALL)
  1021. decodeIntraBlockTexture_DataPartitioning (iBlk, pmbmd, piIntraDC);
  1022. }
  1023. for (iBlk = U_BLOCK; iBlk <= V_BLOCK; iBlk++) {
  1024. decodeIntraBlockTexture_DataPartitioning (iBlk, pmbmd, piIntraDC);
  1025. }
  1026. }
  1027. }
  1029. Void CVideoObjectDecoder::decodeIVOP_WithShape_DataPartitioning ()
  1030. {
  1031. //assert (m_volmd.nBits==8);
  1032. assert (m_volmd.fAUsage!=EIGHT_BIT);
  1033. //in case the IVOP is used as an ref for direct mode
  1034. memset (m_rgmv, 0, m_iNumMB * PVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
  1036. Int iMBX, iMBY;
  1037. CMBMode* pmbmd = m_rgmbmd;
  1039. PixelC* ppxlcRefY  = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
  1040. PixelC* ppxlcRefU  = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
  1041. PixelC* ppxlcRefV  = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
  1042. PixelC* ppxlcRefBY = (PixelC*) m_pvopcRefQ1->pixelsBY () + m_iStartInRefToCurrRctY;
  1043. PixelC* ppxlcRefA  = (PixelC*) m_pvopcRefQ1->pixelsA () + m_iStartInRefToCurrRctY;
  1044. PixelC* ppxlcRefBUV = (PixelC*) m_pvopcRefQ1->pixelsBUV () + m_iStartInRefToCurrRctUV;
  1046. Int iCurrentQP  = m_vopmd.intStepI;
  1047. Int iVideoPacketNumber = 0;
  1048. m_iVPMBnum = 0;
  1049. m_piMCBPC = new Int[m_iNumMBX*m_iNumMBY];
  1050. Int* piMCBPC = m_piMCBPC;
  1051. m_piIntraDC = new Int[m_iNumMBX*m_iNumMBY*V_BLOCK];
  1052. Int* piIntraDC = m_piIntraDC;
  1054. Bool bRestartDelayedQP = TRUE;
  1055. Int i;
  1056. Int mbn = 0, mbnFirst = 0;
  1058. PixelC* ppxlcRefMBBY = NULL;
  1059. PixelC* ppxlcRefMBBUV;
  1060. PixelC* ppxlcRefMBY = NULL;
  1061. PixelC* ppxlcRefMBU = NULL;
  1062. PixelC* ppxlcRefMBV = NULL;
  1063. PixelC* ppxlcRefMBA = NULL;
  1064. do {
  1065. if( checkResyncMarker() ) {
  1066. decodeVideoPacketHeader(iCurrentQP);
  1067. iVideoPacketNumber++;
  1068. bRestartDelayedQP = TRUE;
  1069. }
  1071. CMBMode* pmbmdFirst = pmbmd;
  1072. Int* piMCBPCFirst = piMCBPC;
  1073. Int* piIntraDCFirst = piIntraDC;
  1074. mbnFirst = mbn;
  1076. do{
  1077. iMBX = mbn % m_iNumMBX;
  1078. iMBY = mbn / m_iNumMBX;
  1079. if(iMBX == 0 ) {
  1080. ppxlcRefMBBY = ppxlcRefBY;
  1081. ppxlcRefMBBUV = ppxlcRefBUV;
  1082. }
  1084. pmbmd->m_iVideoPacketNumber = iVideoPacketNumber;
  1086. decodeIntraShape (pmbmd, iMBX, iMBY, m_ppxlcCurrMBBY, ppxlcRefMBBY);
  1087. downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV); // downsample original BY now for LPE padding (using original shape)
  1088. if(m_volmd.bShapeOnly==FALSE)
  1089. {
  1090. pmbmd->m_bPadded=FALSE;
  1091. if (pmbmd->m_rgTranspStatus [0] != ALL) {
  1092. *piMCBPC = m_pentrdecSet->m_pentrdecMCBPCintra->decodeSymbol ();
  1093. assert (*piMCBPC >= 0 && *piMCBPC <= 7);
  1094. pmbmd->m_dctMd = INTRA;
  1095. if (*piMCBPC > 3)
  1096. pmbmd->m_dctMd = INTRAQ;
  1097. decodeMBTextureDCOfIVOP_DataPartitioning (pmbmd, iCurrentQP,
  1098. piIntraDC, bRestartDelayedQP);
  1099. }
  1100. }
  1101. else {
  1102. assert(FALSE);
  1103. }
  1104. pmbmd++;
  1105. mbn++;
  1106. piMCBPC++;
  1107. piIntraDC+=V_BLOCK;
  1108. ppxlcRefMBBY += MB_SIZE;
  1109. ppxlcRefMBBUV += BLOCK_SIZE;
  1110. if(iMBX == m_iNumMBX - 1) {
  1111. ppxlcRefBY += m_iFrameWidthYxMBSize;
  1112. ppxlcRefBUV += m_iFrameWidthUVxBlkSize;
  1113. }
  1114. } while( !checkDCMarker() );
  1115. m_pbitstrmIn -> getBits (NUMBITS_DP_DC_MARKER);
  1117. pmbmd = pmbmdFirst;
  1118. piMCBPC = piMCBPCFirst;
  1119. for(i=mbnFirst;i<mbn;i++) {
  1120. if (pmbmd->m_rgTranspStatus [0] != ALL)
  1121. decodeMBTextureHeadOfIVOP_DataPartitioning (pmbmd, piMCBPC);
  1122. pmbmd++;
  1123. piMCBPC++;
  1124. }
  1126. pmbmd = pmbmdFirst;
  1127. piIntraDC = piIntraDCFirst;
  1128. ppxlcRefBY = (PixelC*) m_pvopcRefQ1->pixelsBY () + m_iStartInRefToCurrRctY + (mbnFirst/m_iNumMBX)*m_iFrameWidthYxMBSize;
  1129. ppxlcRefBUV = (PixelC*) m_pvopcRefQ1->pixelsBUV () + m_iStartInRefToCurrRctUV + (mbnFirst/m_iNumMBX)*m_iFrameWidthUVxBlkSize;
  1130. ppxlcRefMBBY = ppxlcRefBY + (mbnFirst%m_iNumMBX)*MB_SIZE;
  1131. ppxlcRefMBBUV = ppxlcRefBUV + (mbnFirst%m_iNumMBX)*BLOCK_SIZE;
  1132. for(i=mbnFirst;i<mbn;i++) {
  1133. pmbmd->m_bPadded = FALSE;
  1134. iMBX = i % m_iNumMBX;
  1135. iMBY = i / m_iNumMBX;
  1136. if(iMBX == 0 ) {
  1137. ppxlcRefMBY = ppxlcRefY;
  1138. ppxlcRefMBU = ppxlcRefU;
  1139. ppxlcRefMBV = ppxlcRefV;
  1140. ppxlcRefMBA  = ppxlcRefA;
  1141. ppxlcRefMBBY = ppxlcRefBY;
  1142. ppxlcRefMBBUV = ppxlcRefBUV;
  1143. }
  1145. copyRefShapeToMb(m_ppxlcCurrMBBY, ppxlcRefMBBY);
  1146. downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV); // downsample original BY now for LPE padding (using original shape)
  1148. if (pmbmd->m_rgTranspStatus [0] != ALL) {
  1149. decodeTextureIntraMB_DataPartitioning (pmbmd, iMBX, iMBY, ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, piIntraDC);
  1151. // MC padding
  1152. if (pmbmd -> m_rgTranspStatus [0] == PARTIAL)
  1153. mcPadCurrMB (ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA);
  1154. padNeighborTranspMBs (
  1155. iMBX, iMBY,
  1156. pmbmd,
  1157. ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA
  1158. );
  1159. }
  1160. else {
  1161. padCurrAndTopTranspMBFromNeighbor (
  1162. iMBX, iMBY,
  1163. pmbmd,
  1164. ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA
  1165. );
  1166. }
  1168. ppxlcRefMBA += MB_SIZE;
  1169. ppxlcRefMBBY += MB_SIZE;
  1170. ppxlcRefMBBUV += BLOCK_SIZE;
  1171. pmbmd++;
  1172. piIntraDC += V_BLOCK;
  1173. ppxlcRefMBY += MB_SIZE;
  1174. ppxlcRefMBU += BLOCK_SIZE;
  1175. ppxlcRefMBV += BLOCK_SIZE;
  1176. if(iMBX == m_iNumMBX - 1) {
  1177. MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
  1178. m_rgpmbmAbove = m_rgpmbmCurr;
  1179. m_rgpmbmCurr  = ppmbmTemp;
  1180. ppxlcRefY += m_iFrameWidthYxMBSize;
  1181. ppxlcRefU += m_iFrameWidthUVxBlkSize;
  1182. ppxlcRefV += m_iFrameWidthUVxBlkSize;
  1183. ppxlcRefA += m_iFrameWidthYxMBSize;
  1184. ppxlcRefBY += m_iFrameWidthYxMBSize;
  1185. ppxlcRefBUV += m_iFrameWidthUVxBlkSize;
  1186. }
  1187. }
  1188. } while( checkResyncMarker() );
  1189. delete m_piMCBPC;
  1190. }
  1192. Void CVideoObjectDecoder::decodePVOP_WithShape_DataPartitioning ()
  1193. {
  1194. //assert (m_volmd.nBits==8);
  1195. assert (m_volmd.fAUsage!=EIGHT_BIT);
  1196. Int iMBX, iMBY;
  1197. CoordI y = m_rctCurrVOPY.top; 
  1198. CoordI x = m_rctCurrVOPY.left;
  1199. CoordI y_s = m_rctCurrVOPY.top; 
  1200. CoordI x_s = m_rctCurrVOPY.left;
  1201. CMBMode* pmbmd = m_rgmbmd;
  1202. CMotionVector* pmv = m_rgmv;
  1203. CMotionVector* pmvBY = m_rgmvBY;
  1204. PixelC* ppxlcCurrQY  = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
  1205. PixelC* ppxlcCurrQU  = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
  1206. PixelC* ppxlcCurrQV  = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
  1207. PixelC* ppxlcCurrQBY = (PixelC*) m_pvopcRefQ1->pixelsBY () + m_iStartInRefToCurrRctY;
  1208. PixelC* ppxlcCurrQA  = (PixelC*) m_pvopcRefQ1->pixelsA () + m_iStartInRefToCurrRctY;
  1209. PixelC* ppxlcCurrQBUV = (PixelC*) m_pvopcRefQ1->pixelsBUV () + m_iStartInRefToCurrRctUV;
  1211. Int iCurrentQP  = m_vopmd.intStep;
  1212. Int iVideoPacketNumber = 0;  // added for error resilience mode by Toshiba
  1213. m_iVPMBnum = 0;
  1215. m_piMCBPC = new Int[m_iNumMBX*m_iNumMBY];
  1216. Int* piMCBPC = m_piMCBPC;
  1217. m_piIntraDC = new Int[m_iNumMBX*m_iNumMBY*V_BLOCK];
  1218. Int* piIntraDC = m_piIntraDC;
  1220. Int i;
  1221. Int mbn = 0, mbnFirst = 0;
  1223. PixelC* ppxlcCurrQMBY = NULL;
  1224. PixelC* ppxlcCurrQMBU = NULL;
  1225. PixelC* ppxlcCurrQMBV = NULL;
  1226. PixelC* ppxlcCurrQMBBY = NULL;
  1227. PixelC* ppxlcCurrQMBBUV;
  1228. PixelC* ppxlcCurrQMBA = NULL;
  1230. Bool bMBBackup = FALSE;
  1231. CMBMode* pmbmdBackup = NULL;
  1232. Int iMBXBackup = 0, iMBYBackup = 0;
  1233. CMotionVector* pmvBackup = NULL;
  1234. PixelC* ppxlcCurrQMBYBackup = NULL;
  1235. PixelC* ppxlcCurrQMBUBackup = NULL;
  1236. PixelC* ppxlcCurrQMBVBackup = NULL;
  1237. PixelC* ppxlcCurrQMBBYBackup = NULL;
  1238. PixelC* ppxlcCurrQMBBUVBackup;
  1239. PixelC* ppxlcCurrQMBABackup = NULL;
  1240. Bool bPaddedLBackup = FALSE;
  1241. Bool bPaddedTBackup = FALSE;
  1243. Bool bRestartDelayedQP = TRUE;
  1245. do{
  1246. CMBMode* pmbmdFirst = pmbmd;
  1247. CMotionVector* pmvFirst = pmv;
  1248. Int* piMCBPCFirst = piMCBPC;
  1249. Int* piIntraDCFirst = piIntraDC;
  1250. mbnFirst = mbn;
  1252. if( checkResyncMarker() ){
  1253. decodeVideoPacketHeader(iCurrentQP);
  1254. iVideoPacketNumber++;
  1255. bRestartDelayedQP = TRUE;
  1256. }
  1258. do{
  1259. pmbmd->m_iVideoPacketNumber = iVideoPacketNumber;
  1260. iMBX = mbn % m_iNumMBX;
  1261. iMBY = mbn / m_iNumMBX;
  1262. if(iMBX == 0 ) {
  1263. ppxlcCurrQMBBY = ppxlcCurrQBY;
  1264. ppxlcCurrQMBBUV = ppxlcCurrQBUV;
  1265. x_s = m_rctCurrVOPY.left;
  1266. if(iMBY != 0) y_s += MB_SIZE;
  1267. } else {
  1268. x_s += MB_SIZE;
  1269. }
  1271. ShapeMode shpmdColocatedMB;
  1272. if(m_vopmd.bShapeCodingType) {
  1273. shpmdColocatedMB = m_rgmbmdRef [
  1274. MIN (MAX (0, iMBX), m_iNumMBXRef - 1) + 
  1275.   MIN (MAX (0, iMBY), m_iNumMBYRef - 1) * m_iNumMBXRef
  1276. ].m_shpmd;
  1277. decodeInterShape (
  1278. m_pvopcRefQ0,
  1279. pmbmd, 
  1280. iMBX, iMBY, 
  1281. x_s, y_s, 
  1282. pmv, pmvBY, 
  1283. m_ppxlcCurrMBBY, ppxlcCurrQMBBY,
  1284. shpmdColocatedMB
  1285. );
  1286. }
  1287. else {
  1288. decodeIntraShape (pmbmd, iMBX, iMBY, m_ppxlcCurrMBBY,
  1289. ppxlcCurrQMBBY);
  1290. }
  1291. downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV);
  1293. if (pmbmd->m_rgTranspStatus [0] != ALL && m_volmd.bShapeOnly==FALSE) {
  1294. pmbmd->m_bSkip = m_pbitstrmIn->getBits (1);
  1295. if (!pmbmd->m_bSkip) {
  1296. *piMCBPC = m_pentrdecSet->m_pentrdecMCBPCinter->decodeSymbol ();
  1297. assert (*piMCBPC >= 0 && *piMCBPC <= 20);
  1298. Int iMBtype = *piMCBPC / 4; //per H.263's MBtype
  1299. switch (iMBtype) {
  1300. case 0:
  1301. pmbmd->m_dctMd = INTER;
  1302. pmbmd -> m_bhas4MVForward = FALSE;
  1303. break;
  1304. case 1:
  1305. pmbmd->m_dctMd = INTERQ;
  1306. pmbmd -> m_bhas4MVForward = FALSE;
  1307. break;
  1308. case 2:
  1309. pmbmd -> m_dctMd = INTER;
  1310. pmbmd -> m_bhas4MVForward = TRUE;
  1311. break;
  1312. case 3:
  1313. pmbmd->m_dctMd = INTRA;
  1314. break;
  1315. case 4:
  1316. pmbmd->m_dctMd = INTRAQ;
  1317. break;
  1318. default:
  1319. assert (FALSE);
  1320. }
  1321. } else { //skipped
  1322. pmbmd->m_dctMd = INTER;
  1323. pmbmd -> m_bhas4MVForward = FALSE;
  1324. }
  1325. decodeMVWithShape (pmbmd, iMBX, iMBY, pmv);
  1326. if(pmbmd->m_bhas4MVForward)
  1327. padMotionVectors(pmbmd,pmv);
  1328. }
  1330. if(bMBBackup){
  1331. copyRefShapeToMb(m_ppxlcCurrMBBY, ppxlcCurrQMBBYBackup);
  1332. downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV); // downsample original BY now for LPE padding (using original shape)
  1333. pmbmdBackup->m_bPadded = FALSE;
  1334. if(iMBXBackup > 0) (pmbmdBackup-1)->m_bPadded = bPaddedLBackup;
  1335. if(iMBYBackup > 0) (pmbmdBackup-m_iNumMBX)->m_bPadded = bPaddedTBackup;
  1336. if (pmbmdBackup->m_rgTranspStatus [0] != ALL) {
  1337. if (pmbmdBackup->m_dctMd == INTER || pmbmdBackup->m_dctMd == INTERQ) {
  1338.   motionCompMB (
  1339. m_ppxlcPredMBY, m_pvopcRefQ0->pixelsY (),
  1340. pmvBackup, pmbmdBackup, 
  1341. iMBXBackup, iMBYBackup, 
  1342. x, y,
  1343. pmbmdBackup->m_bSkip, FALSE,
  1344. &m_rctRefVOPY0
  1345. );
  1346. if (!pmbmdBackup->m_bSkip) {
  1347. CoordI iXRefUV, iYRefUV;
  1348. mvLookupUVWithShape (pmbmdBackup, pmvBackup, iXRefUV, iYRefUV);
  1349. motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0,
  1350. x, y, iXRefUV, iYRefUV, m_vopmd.iRoundingControl,&m_rctRefVOPY0);
  1351. addErrorAndPredToCurrQ (ppxlcCurrQMBYBackup, ppxlcCurrQMBUBackup, ppxlcCurrQMBVBackup);
  1352. }
  1353. else {
  1354. if (m_volmd.bAdvPredDisable)
  1355. copyFromRefToCurrQ (m_pvopcRefQ0, x, y, ppxlcCurrQMBYBackup, ppxlcCurrQMBUBackup, ppxlcCurrQMBVBackup, &m_rctRefVOPY0);
  1356. else
  1357. copyFromPredForYAndRefForCToCurrQ (x, y, ppxlcCurrQMBYBackup, ppxlcCurrQMBUBackup, ppxlcCurrQMBVBackup, &m_rctRefVOPY0);
  1358. }
  1359. }
  1361. if (pmbmdBackup->m_rgTranspStatus [0] == PARTIAL)
  1362. mcPadCurrMB (ppxlcCurrQMBYBackup, ppxlcCurrQMBUBackup, ppxlcCurrQMBVBackup, ppxlcCurrQMBABackup);
  1363. padNeighborTranspMBs (
  1364. iMBXBackup, iMBYBackup,
  1365. pmbmdBackup,
  1366. ppxlcCurrQMBYBackup, ppxlcCurrQMBUBackup, ppxlcCurrQMBVBackup, ppxlcCurrQMBABackup
  1367. );
  1368. }
  1369. else {
  1370. padCurrAndTopTranspMBFromNeighbor (
  1371. iMBXBackup, iMBYBackup,
  1372. pmbmdBackup,
  1373. ppxlcCurrQMBYBackup, ppxlcCurrQMBUBackup, ppxlcCurrQMBVBackup, ppxlcCurrQMBABackup
  1374. );
  1375. }
  1377. bMBBackup = FALSE;
  1378. }
  1380. pmbmd++;
  1381. pmv += PVOP_MV_PER_REF_PER_MB;
  1382. pmvBY++;
  1383. mbn++;
  1384. piMCBPC++;
  1385. ppxlcCurrQMBBY += MB_SIZE;
  1386. ppxlcCurrQMBBUV += BLOCK_SIZE;
  1387. if(iMBX == m_iNumMBX - 1) {
  1388. ppxlcCurrQBY += m_iFrameWidthYxMBSize;
  1389. ppxlcCurrQBUV += m_iFrameWidthUVxBlkSize;
  1390. }
  1391. assert(mbn<=(m_iNumMBX*m_iNumMBY));
  1392. } while( !checkMotionMarker() );
  1393. m_pbitstrmIn -> getBits (NUMBITS_DP_MOTION_MARKER);
  1395. pmbmd = pmbmdFirst;
  1396. piMCBPC = piMCBPCFirst;
  1397. piIntraDC = piIntraDCFirst;
  1398. for(i=mbnFirst;i<mbn;i++) {
  1399. if (pmbmd->m_rgTranspStatus [0] != ALL && m_volmd.bShapeOnly==FALSE) {
  1400. decodeMBTextureHeadOfPVOP_DataPartitioning (pmbmd, iCurrentQP, piMCBPC, piIntraDC, bRestartDelayedQP);
  1401. }
  1402. pmbmd++;
  1403. piMCBPC++;
  1404. piIntraDC += V_BLOCK;
  1405. }
  1407. pmbmd = pmbmdFirst;
  1408. pmv = pmvFirst;
  1409. piIntraDC = piIntraDCFirst;
  1410. ppxlcCurrQBY = (PixelC*) m_pvopcRefQ1->pixelsBY () + m_iStartInRefToCurrRctY + (mbnFirst/m_iNumMBX)*m_iFrameWidthYxMBSize;
  1411. ppxlcCurrQBUV = (PixelC*) m_pvopcRefQ1->pixelsBUV () + m_iStartInRefToCurrRctUV + (mbnFirst/m_iNumMBX)*m_iFrameWidthUVxBlkSize;
  1412. ppxlcCurrQMBBY = ppxlcCurrQBY + (mbnFirst%m_iNumMBX)*MB_SIZE;
  1413. ppxlcCurrQMBBUV = ppxlcCurrQBUV + (mbnFirst%m_iNumMBX)*BLOCK_SIZE;
  1415. for(i=mbnFirst;i<mbn;i++) {
  1416. pmbmd->m_bPadded = FALSE;
  1417. iMBX = i % m_iNumMBX;
  1418. iMBY = i / m_iNumMBX;
  1419. if(iMBX == 0 ) {
  1420. ppxlcCurrQMBY = ppxlcCurrQY;
  1421. ppxlcCurrQMBU = ppxlcCurrQU;
  1422. ppxlcCurrQMBV = ppxlcCurrQV;
  1423. ppxlcCurrQMBBY = ppxlcCurrQBY;
  1424. ppxlcCurrQMBA  = ppxlcCurrQA;
  1425. ppxlcCurrQMBBUV = ppxlcCurrQBUV;
  1426. x = m_rctCurrVOPY.left;
  1427. if(iMBY != 0) y += MB_SIZE;
  1428. } else {
  1429. x += MB_SIZE;
  1430. }
  1432. copyRefShapeToMb(m_ppxlcCurrMBBY, ppxlcCurrQMBBY);
  1433. downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV); // downsample original BY now for LPE padding (using original shape)
  1435. if (pmbmd->m_rgTranspStatus [0] != ALL && m_volmd.bShapeOnly==FALSE) {
  1436. if (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ)
  1437. decodeTextureIntraMB_DataPartitioning (pmbmd, iMBX, iMBY, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, piIntraDC);
  1438. else {
  1439. if (!pmbmd->m_bSkip)
  1440. decodeTextureInterMB (pmbmd);
  1441. }
  1442. }
  1444. if(i==mbn-1){
  1445. bMBBackup = TRUE;
  1446. pmbmdBackup = pmbmd;
  1447. pmvBackup = pmv;
  1448. iMBXBackup = iMBX;
  1449. iMBYBackup = iMBY;
  1450. ppxlcCurrQMBYBackup = ppxlcCurrQMBY;
  1451. ppxlcCurrQMBUBackup = ppxlcCurrQMBU;
  1452. ppxlcCurrQMBVBackup = ppxlcCurrQMBV;
  1453. ppxlcCurrQMBBYBackup = ppxlcCurrQMBBY;
  1454. ppxlcCurrQMBBUVBackup = ppxlcCurrQMBBUV;
  1455. ppxlcCurrQMBABackup = ppxlcCurrQMBA;
  1456. bPaddedLBackup = (pmbmdBackup-1)->m_bPadded;
  1457. bPaddedTBackup = (pmbmdBackup-m_iNumMBX)->m_bPadded;
  1458. }
  1460. if (pmbmd->m_rgTranspStatus [0] != ALL) {
  1461. if (pmbmd->m_dctMd == INTER || pmbmd->m_dctMd == INTERQ) {
  1462. // Addded for data partitioning mode by Toshiba(1997-11-26:DP+RVLC)
  1463.   motionCompMB (
  1464. m_ppxlcPredMBY, m_pvopcRefQ0->pixelsY (),
  1465. pmv, pmbmd, 
  1466. iMBX, iMBY, 
  1467. x, y,
  1468. pmbmd->m_bSkip, FALSE,
  1469. &m_rctRefVOPY0
  1470. );
  1471. if (!pmbmd->m_bSkip) {
  1472. CoordI iXRefUV, iYRefUV;
  1473. mvLookupUVWithShape (pmbmd, pmv, iXRefUV, iYRefUV);
  1474. motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0,
  1475. x, y, iXRefUV, iYRefUV, m_vopmd.iRoundingControl,&m_rctRefVOPY0);
  1476. addErrorAndPredToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
  1477. }
  1478. else {
  1479. if (m_volmd.bAdvPredDisable)
  1480. copyFromRefToCurrQ (m_pvopcRefQ0, x, y, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, &m_rctRefVOPY0);
  1481. else
  1482. copyFromPredForYAndRefForCToCurrQ (x, y, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, &m_rctRefVOPY0);
  1483. }
  1484. }
  1485. if (pmbmd->m_rgTranspStatus [0] == PARTIAL)
  1486. mcPadCurrMB (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, ppxlcCurrQMBA);
  1487. padNeighborTranspMBs (
  1488. iMBX, iMBY,
  1489. pmbmd,
  1490. ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, ppxlcCurrQMBA
  1491. );
  1492. }
  1493. else {
  1494. padCurrAndTopTranspMBFromNeighbor (
  1495. iMBX, iMBY,
  1496. pmbmd,
  1497. ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, ppxlcCurrQMBA
  1498. );
  1499. }
  1501. pmbmd++;
  1502. pmv += PVOP_MV_PER_REF_PER_MB;
  1503. piIntraDC += V_BLOCK;
  1504. ppxlcCurrQMBY += MB_SIZE;
  1505. ppxlcCurrQMBU += BLOCK_SIZE;
  1506. ppxlcCurrQMBV += BLOCK_SIZE;
  1507. ppxlcCurrQMBBY += MB_SIZE;
  1508. ppxlcCurrQMBBUV += BLOCK_SIZE;
  1509. ppxlcCurrQMBA += MB_SIZE;
  1511. if(iMBX == m_iNumMBX - 1) {
  1512. MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
  1513. m_rgpmbmAbove = m_rgpmbmCurr;
  1514. m_rgpmbmCurr  = ppmbmTemp;
  1515. ppxlcCurrQY += m_iFrameWidthYxMBSize;
  1516. ppxlcCurrQU += m_iFrameWidthUVxBlkSize;
  1517. ppxlcCurrQV += m_iFrameWidthUVxBlkSize;
  1518. ppxlcCurrQBY += m_iFrameWidthYxMBSize;
  1519. ppxlcCurrQBUV += m_iFrameWidthYxBlkSize;
  1520. ppxlcCurrQA  += m_iFrameWidthYxMBSize;
  1521. }
  1522. }
  1523. } while( checkResyncMarker() );
  1524. delete m_piIntraDC;
  1525. delete m_piMCBPC;
  1526. }
  1528. // End Toshiba