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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

mbdec.cpp：源码内容
  1. /*************************************************************************
  3. This software module was originally developed by 
  5. Ming-Chieh Lee (mingcl@microsoft.com), Microsoft Corporation
  6. Wei-ge Chen (wchen@microsoft.com), Microsoft Corporation
  7. Bruce Lin (blin@microsoft.com), Microsoft Corporation
  8. Chuang Gu (chuanggu@microsoft.com), Microsoft Corporation
  9. Simon Winder (swinder@microsoft.com), Microsoft Corporation
  10. (date: March, 1996)
  11. and edited by
  12.         Wei Wu (weiwu@stallion.risc.rockwell.com) Rockwell Science Center
  14. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  15. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  16. as specified by the MPEG-4 Video. 
  17. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  18. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  19. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
  20. The original developer of this software module and his/her company, 
  21. the subsequent editors and their companies, 
  22. and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
  23. Copyright is not released for non MPEG-4 Video conforming products. 
  24. Microsoft retains full right to use the code for his/her own purpose, 
  25. assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
  26. This copyright notice must be included in all copies or derivative works. 
  28. Copyright (c) 1996, 1997.
  30. Module Name:
  32. MBDec.cpp
  34. Abstract:
  36. MacroBlock level decoder
  38. Revision History:
  39.         May. 9   1998:  add boundary by Hyundai Electronics 
  40.                                   Cheol-Soo Park (cspark@super5.hyundai.co.kr) 
  42. *************************************************************************/
  44. #include "typeapi.h"
  45. #include "codehead.h"
  46. #include "mode.hpp"
  47. #include "global.hpp"
  48. #include "entropy/bitstrm.hpp"
  49. #include "entropy/entropy.hpp"
  50. #include "entropy/huffman.hpp"
  51. #include "vopses.hpp"
  52. #include "vopsedec.hpp"
  54. #ifdef __MFC_
  55. #ifdef _DEBUG
  56. #undef THIS_FILE
  57. static char BASED_CODE THIS_FILE[] = __FILE__;
  58. #endif
  60. #define new DEBUG_NEW    
  61. #endif // __MFC_
  63. Void CVideoObjectDecoder::swapCurrAndRightMBForShape ()
  64. {
  65. CVOPU8YUVBA* pvopcTmp = m_pvopcCurrMB;
  66. m_pvopcCurrMB = m_pvopcRightMB;
  67. m_pvopcRightMB = pvopcTmp;
  69. m_ppxlcCurrMBBY = (PixelC*) m_pvopcCurrMB->pixelsBY ();
  70. m_ppxlcCurrMBBUV = (PixelC*) m_pvopcCurrMB->pixelsBUV ();
  72. m_ppxlcRightMBBY = (PixelC*) m_pvopcRightMB->pixelsBY ();
  73. m_ppxlcRightMBBUV = (PixelC*) m_pvopcRightMB->pixelsBUV ();
  75. }
  77. Void CVideoObjectDecoder::copyFromPredForYAndRefForCToCurrQ (
  78. CoordI x, CoordI y, 
  79. PixelC* ppxlcCurrQMBY, PixelC* ppxlcCurrQMBU, PixelC* ppxlcCurrQMBV,
  80. CRct *prctMVLimit
  81. )
  82. {
  83. Int iUnit = sizeof(PixelC); // NBIT: for memcpy
  84. // needs limiting to reference area bounding box
  85. limitMVRangeToExtendedBBFullPel(x,y,prctMVLimit,MB_SIZE);
  87. Int iOffsetUV = (y / 2 + EXPANDUV_REF_FRAME) * m_iFrameWidthUV + x / 2 + EXPANDUV_REF_FRAME;
  88. const PixelC* ppxlcPredMBY = m_ppxlcPredMBY;
  89. const PixelC* ppxlcRefMBU = m_pvopcRefQ0->pixelsU () + iOffsetUV;
  90. const PixelC* ppxlcRefMBV = m_pvopcRefQ0->pixelsV () + iOffsetUV;
  92. CoordI iY;
  93. for (iY = 0; iY < BLOCK_SIZE; iY++) {
  94. memcpy (ppxlcCurrQMBY, ppxlcPredMBY, MB_SIZE*iUnit);
  95. memcpy (ppxlcCurrQMBU, ppxlcRefMBU, BLOCK_SIZE*iUnit);
  96. memcpy (ppxlcCurrQMBV, ppxlcRefMBV, BLOCK_SIZE*iUnit);
  98. ppxlcCurrQMBY += m_iFrameWidthY; ppxlcPredMBY += MB_SIZE;
  99. ppxlcCurrQMBU += m_iFrameWidthUV; ppxlcRefMBU += m_iFrameWidthUV;
  100. ppxlcCurrQMBV += m_iFrameWidthUV; ppxlcRefMBV += m_iFrameWidthUV;
  102. memcpy (ppxlcCurrQMBY, ppxlcPredMBY, MB_SIZE*iUnit);
  103. ppxlcCurrQMBY += m_iFrameWidthY; ppxlcPredMBY += MB_SIZE;
  104. }
  105. }
  107. Void CVideoObjectDecoder::copyAlphaFromPredToCurrQ (
  108. CoordI x, CoordI y, 
  109. PixelC* ppxlcCurrQMBA
  110. )
  111. {
  112. const PixelC* ppxlcPredMBA = m_ppxlcPredMBA;
  114. CoordI iY;
  115. for (iY = 0; iY < MB_SIZE; iY++) {
  116. memcpy (ppxlcCurrQMBA, ppxlcPredMBA, MB_SIZE);
  117. ppxlcCurrQMBA += m_iFrameWidthY; 
  118. ppxlcPredMBA += MB_SIZE;
  119. }
  120. }
  122. // for Direct and Interpolate mode in B-VOP
  123. Void CVideoObjectDecoder::averagePredAndAddErrorToCurrQ (
  124. PixelC* ppxlcCurrQMBY, PixelC* ppxlcCurrQMBU, PixelC* ppxlcCurrQMBV
  125. )
  126. {
  127. CoordI ix, iy, ic = 0;
  128. for (iy = 0; iy < MB_SIZE; iy++) {
  129. for (ix = 0; ix < MB_SIZE; ix++, ic++) {
  130. ppxlcCurrQMBY [ix] = m_rgiClipTab [
  131. ((m_ppxlcPredMBY [ic] + m_ppxlcPredMBBackY [ic] + 1) >> 1) + 
  132. m_ppxliErrorMBY [ic]
  133. ];
  134. }
  135. ppxlcCurrQMBY += m_iFrameWidthY;
  136. }
  138. ic = 0;
  139. for (iy = 0; iy < BLOCK_SIZE; iy++) {
  140. for (ix = 0; ix < BLOCK_SIZE; ix++, ic++) {
  141. ppxlcCurrQMBU [ix] = m_rgiClipTab [
  142. ((m_ppxlcPredMBU [ic] + m_ppxlcPredMBBackU [ic] + 1) >> 1) + 
  143. m_ppxliErrorMBU [ic]
  144. ];
  145. ppxlcCurrQMBV [ix] = m_rgiClipTab [
  146. ((m_ppxlcPredMBV [ic] + m_ppxlcPredMBBackV [ic] + 1) >> 1) + 
  147. m_ppxliErrorMBV [ic]
  148. ];
  149. }
  150. ppxlcCurrQMBU += m_iFrameWidthUV;
  151. ppxlcCurrQMBV += m_iFrameWidthUV;
  152. }
  153. }
  155. Void CVideoObjectDecoder::averagePredAndAssignToCurrQ (
  156. PixelC* ppxlcCurrQMBY, PixelC* ppxlcCurrQMBU, PixelC* ppxlcCurrQMBV
  157. )
  158. {
  159. CoordI ix, iy, ic = 0;
  160. for (iy = 0; iy < MB_SIZE; iy++) {
  161. for (ix = 0; ix < MB_SIZE; ix++, ic++)
  162. ppxlcCurrQMBY [ix] = (m_ppxlcPredMBY [ic] + m_ppxlcPredMBBackY [ic] + 1) >> 1; // don't need to clip
  163. ppxlcCurrQMBY += m_iFrameWidthY;
  164. }
  166. ic = 0;
  167. for (iy = 0; iy < BLOCK_SIZE; iy++) {
  168. for (ix = 0; ix < BLOCK_SIZE; ix++, ic++) {
  169. ppxlcCurrQMBU [ix] = (m_ppxlcPredMBU [ic] + m_ppxlcPredMBBackU [ic] + 1) >> 1;
  170. ppxlcCurrQMBV [ix] = (m_ppxlcPredMBV [ic] + m_ppxlcPredMBBackV [ic] + 1) >> 1;
  171. }
  172. ppxlcCurrQMBU += m_iFrameWidthUV;
  173. ppxlcCurrQMBV += m_iFrameWidthUV;
  174. }
  175. }
  177. // texture and overhead
  178. // Intra
  179. Void CVideoObjectDecoder::decodeTextureIntraMB (
  180. CMBMode* pmbmd, CoordI iMBX, CoordI iMBY, 
  181. PixelC* ppxlcCurrFrmQY, PixelC* ppxlcCurrFrmQU, PixelC* ppxlcCurrFrmQV)
  182. {
  183. assert (pmbmd != NULL);
  184. if (pmbmd -> m_rgTranspStatus [0] == ALL) 
  185. return;
  187. assert (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ);
  188. Int iQP = pmbmd->m_stepSize;
  189. Int iDcScalerY, iDcScalerC;
  191. if (iQP <= 4) {
  192. iDcScalerY = 8;
  193. iDcScalerC = 8;
  194. }
  195. else if (iQP >= 5 && iQP <= 8) {
  196. iDcScalerY = 2 * iQP;
  197. iDcScalerC = (iQP + 13) / 2;
  198. }
  199. else if (iQP >= 9 && iQP <= 24) {
  200. iDcScalerY = iQP + 8;
  201. iDcScalerC = (iQP + 13) / 2;
  202. }
  203. else {
  204. iDcScalerY = 2 * iQP - 16;
  205. iDcScalerC = iQP - 6;
  206. }
  208. assert (iQP > 0);
  209. // more bogus technology
  210. assert (pmbmd -> m_stepSizeDelayed > 0);
  211. if (pmbmd -> m_stepSizeDelayed >= grgiDCSwitchingThreshold [m_vopmd.iIntraDcSwitchThr])
  212. pmbmd->m_bCodeDcAsAc = TRUE;
  213. else
  214. pmbmd->m_bCodeDcAsAc = FALSE;
  216. //for intra pred
  217. MacroBlockMemory* pmbmLeft = NULL;
  218. MacroBlockMemory* pmbmTop = NULL;
  219. MacroBlockMemory* pmbmLeftTop = NULL;
  220. CMBMode* pmbmdLeft = NULL;
  221. CMBMode* pmbmdTop = NULL;
  222. CMBMode* pmbmdLeftTop = NULL;
  223.  
  224. Int iMBTop = iMBY - 1;
  226. // dshu: begin of modification
  227. if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP) {
  228. assert (pmbmd->m_iVideoPacketNumber == 0);
  229. if (iMBTop >= 0)
  230. (pmbmd - m_iNumMBX)->m_iVideoPacketNumber = 0;
  231. if (iMBX > 0)
  232. (pmbmd - 1)->m_iVideoPacketNumber = 0;
  233. if (iMBTop >= 0 && iMBX > 0)
  234. (pmbmd - m_iNumMBX - 1)->m_iVideoPacketNumber = 0 ;
  235. }
  236. // dshu: end of modification
  237. if (iMBTop >= 0) {
  238. if (pmbmd->m_iVideoPacketNumber == (pmbmd - m_iNumMBX)->m_iVideoPacketNumber) {
  239. pmbmTop  = m_rgpmbmAbove [iMBX];
  240. pmbmdTop = pmbmd - m_iNumMBX; 
  241. }
  242. }
  244. if (iMBX > 0) {
  245. if (pmbmd->m_iVideoPacketNumber == (pmbmd - 1)->m_iVideoPacketNumber) {
  246. pmbmLeft  = m_rgpmbmCurr [iMBX - 1];
  247. pmbmdLeft = pmbmd -  1; 
  248. }
  249. }
  251. if (iMBTop >= 0 && iMBX > 0) {
  252. if (pmbmd->m_iVideoPacketNumber == (pmbmd - m_iNumMBX - 1)->m_iVideoPacketNumber) {
  253. pmbmLeftTop  = m_rgpmbmAbove [iMBX - 1];
  254. pmbmdLeftTop = pmbmd - m_iNumMBX - 1;
  255. }
  256. }
  258. PixelC* rgchBlkDst = NULL;
  259. Int iWidthDst;
  260. Int iDcScaler;
  261. Int* rgiCoefQ;
  262. for (Int iBlk = Y_BLOCK1; iBlk <= V_BLOCK; iBlk++) {
  263. if (iBlk < U_BLOCK) {
  264. if (pmbmd -> m_rgTranspStatus [iBlk] == ALL) 
  265. continue;
  266. switch (iBlk) 
  267. {
  268. case (Y_BLOCK1): 
  269. rgchBlkDst = ppxlcCurrFrmQY;
  270. break;
  271. case (Y_BLOCK2): 
  272. rgchBlkDst = ppxlcCurrFrmQY + BLOCK_SIZE;
  273. break;
  274. case (Y_BLOCK3): 
  275. rgchBlkDst = ppxlcCurrFrmQY + m_iFrameWidthYxBlkSize;
  276. break;
  277. case (Y_BLOCK4): 
  278. rgchBlkDst = ppxlcCurrFrmQY + m_iFrameWidthYxBlkSize + BLOCK_SIZE;
  279. break;
  280. }
  281. iWidthDst = m_iFrameWidthY;
  282. iDcScaler = iDcScalerY;
  283. }
  284. else {
  285. iWidthDst = m_iFrameWidthUV;
  286. rgchBlkDst = (iBlk == U_BLOCK) ? ppxlcCurrFrmQU: ppxlcCurrFrmQV;
  287. iDcScaler = iDcScalerC;
  288. }
  290. rgiCoefQ = m_rgpiCoefQ [iBlk - 1];
  291. const BlockMemory blkmPred = NULL;
  292. Int iQpPred = iQP; //default to current if no pred
  293. decideIntraPred (blkmPred, 
  294.  pmbmd,
  295.  iQpPred,
  296.  (BlockNum) iBlk,
  297.  pmbmLeft, 
  298.     pmbmTop, 
  299.  pmbmLeftTop,
  300.  m_rgpmbmCurr [iMBX],
  301.  pmbmdLeft,
  302.  pmbmdTop,
  303.  pmbmdLeftTop);
  304. decodeIntraBlockTexture (rgchBlkDst,
  305.  iWidthDst,
  306.  iQP, 
  307.  iDcScaler,
  308.  iBlk,
  309.  m_rgpmbmCurr [iMBX],
  310.  pmbmd,
  311.    blkmPred, //for intra-pred
  312.  iQpPred);
  314. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  315.                 if (m_vopmd.bInterlace && pmbmd->m_bMerged [0]) {
  316.                         Int iDstBlk = 0;
  317.                         switch (iBlk) {
  318.                                 case (Y_BLOCK1):
  319.                                         if (pmbmd->m_bMerged [1])       iDstBlk = (Int) Y_BLOCK2;
  320.                                         else if (pmbmd->m_bMerged [3])  iDstBlk = (Int) Y_BLOCK3;
  321.                                         else if (pmbmd->m_bMerged [5])  iDstBlk = (Int) Y_BLOCK4;
  322.                                         break;
  323.                                 case (Y_BLOCK2):
  324.                                         if (pmbmd->m_bMerged [4])       iDstBlk = (Int) Y_BLOCK4;
  325.                                         else if (pmbmd->m_bMerged [6])  iDstBlk = (Int) Y_BLOCK3;
  326.                                         break;
  327.                                 case (Y_BLOCK3):
  328.                                         if (pmbmd->m_bMerged [2])       iDstBlk = (Int) Y_BLOCK4;
  329.                                         break;
  330.                         }
  331.                         if (iDstBlk) {
  332.                                 MacroBlockMemory* pmbmCurr = m_rgpmbmCurr [iMBX];
  333.                                 pmbmCurr->rgblkm [iDstBlk-1][0] = pmbmCurr->rgblkm [iBlk-1][0];
  334.                                 for (UInt x = 1; x < (BLOCK_SIZE<<1)-1; x++)
  335.                                         pmbmCurr->rgblkm [iDstBlk-1][x] = 0;
  336.                         }
  337.                 }
  338. // End of Hyundai(1998-5-9)*/
  339. }
  340. }
  342. Void CVideoObjectDecoder::decodeAlphaIntraMB (CMBMode* pmbmd, Int iMBX, Int iMBY, PixelC* ppxlcRefMBA)
  343. {
  344. assert (pmbmd != NULL);
  345. if (pmbmd -> m_rgTranspStatus [0] == ALL) 
  346. return;
  348. assert (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ);
  349. Int iQP = pmbmd->m_stepSizeAlpha;
  350. Int iDcScalerA;
  352. if (pmbmd -> m_stepSizeAlpha < 1)
  353. pmbmd -> m_stepSizeAlpha = 1;
  354. if (iQP <= 4) {
  355. iDcScalerA = 8;
  356. }
  357. else if (iQP >= 5 && iQP <= 8) {
  358. iDcScalerA = 2 * iQP;
  359. }
  360. else if (iQP >= 9 && iQP <= 24) {
  361. iDcScalerA = iQP + 8;
  362. }
  363. else {
  364. iDcScalerA = 2 * iQP - 16;
  365. }
  367. assert (iQP > 0 && iQP < 64);
  369. // should be stepSizeAlpha and a different table
  370. //if (pmbmd -> m_stepSize >= grgiDCSwitchingThreshold [m_vopmd.iIntraDcSwitchThr])
  371. // pmbmd->m_bCodeDcAsAcAlpha = TRUE;
  372. //else
  373. pmbmd->m_bCodeDcAsAcAlpha = FALSE;
  375. if(pmbmd->m_CODAlpha==ALPHA_ALL255)
  376. {
  377. // fill curr macroblock with 255
  378. Int iY;
  379. PixelC *ppxlc = ppxlcRefMBA;
  380. for(iY = 0; iY<MB_SIZE; iY++, ppxlc += m_iFrameWidthY)
  381. pxlcmemset(ppxlc, 255, MB_SIZE);
  383. // fix intra prediction
  384. Int iBlk;
  385. MacroBlockMemory* pmbmCurr = m_rgpmbmCurr [iMBX];
  386. for(iBlk = A_BLOCK1; iBlk<=A_BLOCK4; iBlk++)
  387. {
  388. Int i;
  389. pmbmCurr->rgblkm [iBlk - 1] [0] = divroundnearest(255 * 8, iDcScalerA) * iDcScalerA;
  390. //save recon value of DC for intra pred //save Qcoef in memory
  391. for (i = 1; i < BLOCK_SIZE; i++) {
  392. pmbmCurr->rgblkm [iBlk - 1] [i] = 0;
  393. pmbmCurr->rgblkm [iBlk - 1] [i + BLOCK_SIZE - 1] = 0;
  394. }
  395. }
  397. return;
  398. }
  401. //for intra pred
  402. MacroBlockMemory* pmbmLeft = NULL;
  403. MacroBlockMemory* pmbmTop = NULL;
  404. MacroBlockMemory* pmbmLeftTop = NULL;
  405. CMBMode* pmbmdLeft = NULL;
  406. CMBMode* pmbmdTop = NULL;
  407. CMBMode* pmbmdLeftTop = NULL;
  408.  
  409. Int iMBTop = iMBY - 1;
  410. if (iMBTop >= 0) {
  411. if (pmbmd->m_iVideoPacketNumber == (pmbmd - m_iNumMBX)->m_iVideoPacketNumber) {
  412. pmbmTop  = m_rgpmbmAbove [iMBX];
  413. pmbmdTop = pmbmd - m_iNumMBX; 
  414. }
  415. }
  417. if (iMBX > 0) {
  418. if (pmbmd->m_iVideoPacketNumber == (pmbmd - 1)->m_iVideoPacketNumber) {
  419. pmbmLeft  = m_rgpmbmCurr [iMBX - 1];
  420. pmbmdLeft = pmbmd -  1; 
  421. }
  422. }
  424. if (iMBTop >= 0 && iMBX > 0) {
  425. if (pmbmd->m_iVideoPacketNumber == (pmbmd - m_iNumMBX - 1)->m_iVideoPacketNumber) {
  426. pmbmLeftTop  = m_rgpmbmAbove [iMBX - 1];
  427. pmbmdLeftTop = pmbmd - m_iNumMBX - 1;
  428. }
  429. }
  431. PixelC* rgchBlkDst = NULL;
  432. Int* rgiCoefQ;
  433. for (Int iBlk = A_BLOCK1; iBlk <= A_BLOCK4; iBlk++) {
  434. if (pmbmd -> m_rgTranspStatus [iBlk - 6] == ALL) 
  435. continue;
  436. switch (iBlk) 
  437. {
  438. case (A_BLOCK1): 
  439. rgchBlkDst = ppxlcRefMBA;
  440. break;
  441. case (A_BLOCK2): 
  442. rgchBlkDst = ppxlcRefMBA + BLOCK_SIZE;
  443. break;
  444. case (A_BLOCK3): 
  445. rgchBlkDst = ppxlcRefMBA + m_iFrameWidthYxBlkSize;
  446. break;
  447. case (A_BLOCK4): 
  448. rgchBlkDst = ppxlcRefMBA + m_iFrameWidthYxBlkSize + BLOCK_SIZE;
  449. break;
  450. }
  452. rgiCoefQ = m_rgpiCoefQ [iBlk - 1];
  453. const BlockMemory blkmPred = NULL;
  454. Int iQpPred = iQP;
  455. decideIntraPred (blkmPred, 
  456.  pmbmd,
  457.  iQpPred,
  458.  (BlockNum) iBlk,
  459.  pmbmLeft, 
  460.     pmbmTop, 
  461.  pmbmLeftTop,
  462.  m_rgpmbmCurr [iMBX], // save for curr coefs
  463.  pmbmdLeft,
  464.  pmbmdTop,
  465.  pmbmdLeftTop);
  466. decodeIntraBlockTexture (rgchBlkDst,
  467.  m_iFrameWidthY,
  468.  iQP, 
  469.  iDcScalerA,
  470.  iBlk,
  471.  m_rgpmbmCurr [iMBX],
  472.  pmbmd,
  473.    blkmPred, //for intra-pred
  474.  iQpPred);
  475. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  476.                 if (m_vopmd.bInterlace && pmbmd->m_bMerged [0]) {
  477.                         Int iDstBlk = 0;
  478.                         switch (iBlk) {
  479.                                 case (A_BLOCK1):
  480.                                         if (pmbmd->m_bMerged [1])       iDstBlk = (Int) A_BLOCK2;
  481.                                         else if (pmbmd->m_bMerged [3])  iDstBlk = (Int) A_BLOCK3;
  482.                                         else if (pmbmd->m_bMerged [5])  iDstBlk = (Int) A_BLOCK4;
  483.                                         break;
  484.                                 case (A_BLOCK2):
  485.                                         if (pmbmd->m_bMerged [4])       iDstBlk = (Int) A_BLOCK4;
  486.                                         else if (pmbmd->m_bMerged [6])  iDstBlk = (Int) A_BLOCK3;
  487.                                         break;
  488.                                 case (A_BLOCK3):
  489.                                         if (pmbmd->m_bMerged [2])       iDstBlk = (Int) A_BLOCK4;
  490.                                         break;
  491.                         }
  492.                         if (iDstBlk) {
  493.                                 MacroBlockMemory* pmbmCurr = m_rgpmbmCurr [iMBX];
  494.                                 pmbmCurr->rgblkm [iDstBlk-1][0] = pmbmCurr->rgblkm [iBlk-1][0];
  495.                                 for (UInt x = 1; x < (BLOCK_SIZE<<1)-1; x++)
  496.                                         pmbmCurr->rgblkm [iDstBlk-1][x] = 0;
  497.                         }
  498.                 }
  499. // End of Hyundai(1998-5-9)*/
  500. }
  501. }
  503. Void CVideoObjectDecoder::decodeTextureInterMB (CMBMode* pmbmd)
  504. {
  505. assert (pmbmd != NULL);
  506. if (pmbmd->m_rgTranspStatus [0] == ALL || pmbmd->m_bSkip) 
  507. return;
  509. assert (pmbmd->m_dctMd == INTER || pmbmd->m_dctMd == INTERQ);
  510. Int iQP = pmbmd->m_stepSize;
  511. Int* rgiBlkCurrQ = m_ppxliErrorMBY;
  512. Int iWidthCurrQ;
  513. for (Int iBlk = Y_BLOCK1; iBlk <= V_BLOCK; iBlk++) {
  514. if (iBlk < U_BLOCK) {
  515. if (pmbmd -> m_rgTranspStatus [iBlk] == ALL) 
  516. continue;
  517. switch (iBlk) 
  518. {
  519. case (Y_BLOCK1): 
  520. rgiBlkCurrQ = m_ppxliErrorMBY;
  521. break;
  522. case (Y_BLOCK2): 
  523. rgiBlkCurrQ = m_ppxliErrorMBY + BLOCK_SIZE;
  524. break;
  525. case (Y_BLOCK3): 
  526. rgiBlkCurrQ = m_ppxliErrorMBY + MB_SIZE * BLOCK_SIZE;
  527. break;
  528. case (Y_BLOCK4): 
  529. rgiBlkCurrQ = m_ppxliErrorMBY + MB_SIZE * BLOCK_SIZE + BLOCK_SIZE;
  530. break;
  531. }
  532. iWidthCurrQ = MB_SIZE;
  533. }
  534. else {
  535. iWidthCurrQ = BLOCK_SIZE;
  536. rgiBlkCurrQ = (iBlk == U_BLOCK) ? m_ppxliErrorMBU: m_ppxliErrorMBV;
  537. }
  538. if (pmbmd->getCodedBlockPattern ((BlockNum) iBlk))
  539. decodeTextureInterBlock (rgiBlkCurrQ, iWidthCurrQ, iQP, FALSE); //all for intra-pred
  540. else 
  541. for (Int i = 0; i < BLOCK_SIZE; i++) {
  542. memset (rgiBlkCurrQ, 0, sizeof (Int) * BLOCK_SIZE);
  543. rgiBlkCurrQ += iWidthCurrQ;
  544. }
  545. }
  546. }
  548. Void CVideoObjectDecoder::decodeAlphaInterMB (CMBMode* pmbmd, PixelC *ppxlcRefMBA)
  549. {
  550. assert (pmbmd != NULL);
  552. if (pmbmd->m_rgTranspStatus [0] == ALL)
  553. return;
  554. if(pmbmd->m_CODAlpha == ALPHA_ALL255) 
  555. {
  556. // fill curr macroblock with 255
  557. Int iY;
  558. PixelC *ppxlc = ppxlcRefMBA;
  559. for(iY = 0; iY<MB_SIZE; iY++, ppxlc += m_iFrameWidthY)
  560. pxlcmemset(ppxlc, 255, MB_SIZE);
  561. return;
  562. }
  563. if(pmbmd->m_CODAlpha != ALPHA_CODED)
  564. return;
  566. assert (pmbmd->m_dctMd == INTER || pmbmd->m_dctMd == INTERQ);
  568. Int iQP = pmbmd->m_stepSizeAlpha;
  569. Int* piBlkCurrQ = NULL;
  570. for (Int iBlk = A_BLOCK1; iBlk <= A_BLOCK4; iBlk++) {
  571. if (pmbmd -> m_rgTranspStatus [iBlk - 6] == ALL) 
  572. continue;
  573. switch (iBlk) 
  574. {
  575. case (A_BLOCK1): 
  576. piBlkCurrQ = m_ppxliErrorMBA;
  577. break;
  578. case (A_BLOCK2): 
  579. piBlkCurrQ = m_ppxliErrorMBA + BLOCK_SIZE;
  580. break;
  581. case (A_BLOCK3): 
  582. piBlkCurrQ = m_ppxliErrorMBA + MB_SIZE * BLOCK_SIZE;
  583. break;
  584. case (A_BLOCK4): 
  585. piBlkCurrQ = m_ppxliErrorMBA + MB_SIZE * BLOCK_SIZE + BLOCK_SIZE;
  586. break;
  587. }
  589. //Int *pix = piBlkCurrQ;
  590. Int i;
  591. if (pmbmd->getCodedBlockPattern ((BlockNum) iBlk))
  592. {
  593. decodeTextureInterBlock (piBlkCurrQ, MB_SIZE, iQP, TRUE);
  594. /*printf("nBlock %d DCT Coefs Quantn",iBlk);
  595. for(i=0;i<64;i++)
  596. printf("%d ",m_rgpiCoefQ [0][i]);
  597. printf("n");
  599. printf("Block %d DCT Coefs Inv Quantn",iBlk);
  600. for(i=0;i<64;i++)
  601. printf("%d ",m_rgiDCTcoef[i]);
  602. printf("n");*/
  603. }
  604. else 
  605. for (i = 0; i < BLOCK_SIZE; i++) {
  606. memset (piBlkCurrQ, 0, sizeof (Int) * BLOCK_SIZE);
  607. piBlkCurrQ += MB_SIZE;
  608. }
  609. /*Int j;
  610. printf("nblock %d updaten",iBlk);
  611. for(i=0;i<BLOCK_SIZE;i++,pix+=BLOCK_SIZE){
  612. for(j=0;j<BLOCK_SIZE;j++,pix++)
  613. printf("%3d ",*pix);
  614. printf("n");
  615. }*/
  616. }
  617. }
  619. Void CVideoObjectDecoder::setCBPYandC (CMBMode* pmbmd, Int iCBPC, Int iCBPY, Int cNonTrnspBlk)
  620. {
  621. pmbmd->setCodedBlockPattern (U_BLOCK, (iCBPC >> 1) & 1) ;
  622. pmbmd->setCodedBlockPattern (V_BLOCK, iCBPC & 1) ;
  623. Int iBitPos = 1, iBlk;
  624. for (iBlk = Y_BLOCK1; iBlk <= Y_BLOCK4; iBlk++) {
  625. if (pmbmd->m_rgTranspStatus [iBlk] != ALL) {
  626. pmbmd->setCodedBlockPattern (
  627. (BlockNum) iBlk, 
  628. (iCBPY >> (cNonTrnspBlk - iBitPos)) & 1
  629. );
  630. iBitPos++;
  631. }
  632. else
  633. pmbmd->setCodedBlockPattern ((BlockNum) iBlk, 0);
  634. }
  635. }