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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

vopmbdec.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)
  12. and edited by
  13. Yoshihiro Kikuchi (TOSHIBA CORPORATION)
  14. Takeshi Nagai (TOSHIBA CORPORATION)
  15. Toshiaki Watanabe (TOSHIBA CORPORATION)
  16. Noboru Yamaguchi (TOSHIBA CORPORATION)
  18. and also edited by
  19. David B. Shu (dbshu@hrl.com), Hughes Electronics/HRL Laboratories
  21. and edited by
  22. Xuemin Chen (xchen@gi.com), General Instrument Corp.
  24. and also edited by
  25. Dick van Smirren (D.vanSmirren@research.kpn.com), KPN Research
  26. Cor Quist (C.P.Quist@research.kpn.com), KPN Research
  27. (date: July, 1998)
  29. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  30. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  31. as specified by the MPEG-4 Video. 
  32. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  33. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  34. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
  35. The original developer of this software module and his/her company, 
  36. the subsequent editors and their companies, 
  37. and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
  38. Copyright is not released for non MPEG-4 Video conforming products. 
  39. Microsoft retains full right to use the code for his/her own purpose, 
  40. assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
  41. This copyright notice must be included in all copies or derivative works. 
  43. Copyright (c) 1996, 1997.
  45. Module Name:
  47. vopmbDec.cpp
  49. Abstract:
  51. Decoder for VOP composed of MB's
  53. Revision History:
  55. Nov. 26 , 1997: modified for error resilient by Toshiba
  57. Nov. 30 , 1997: modified for Spatial Scalable by Takefumi Nagumo
  58. (nagumo@av.crl.sony.co.jp) SONY Corporation 
  59. Dec 20, 1997: Interlaced tools added by GI
  60.                         X. Chen (xchen@gi.com), B. Eifrig (beifrig@gi.com)
  61.         May. 9   1998:  add boundary by Hyundai Electronics 
  62.                                   Cheol-Soo Park (cspark@super5.hyundai.co.kr) 
  63.         May. 9   1998:  add field based MC padding by Hyundai Electronics 
  64.                                   Cheol-Soo Park (cspark@super5.hyundai.co.kr) 
  66. *************************************************************************/
  67. #include <stdio.h>
  68. #include <math.h>
  69. #include <stdlib.h>
  71. #include "typeapi.h"
  72. #include "mode.hpp"
  73. #include "codehead.h"
  74. #include "entropy/bitstrm.hpp"
  75. #include "entropy/entropy.hpp"
  76. #include "entropy/huffman.hpp"
  77. #include "global.hpp"
  78. #include "vopses.hpp"
  79. #include "vopsedec.hpp"
  81. #ifdef __MFC_
  82. #ifdef _DEBUG
  83. #undef THIS_FILE
  84. static char BASED_CODE THIS_FILE[] = __FILE__;
  85. #endif
  86. #define new DEBUG_NEW    
  87. #endif // __MFC_
  89. Void CVideoObjectDecoder::decodeVOP ()
  90. {
  91. if (m_volmd.fAUsage != RECTANGLE) {
  92. // Added for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)
  93. if(m_volmd.bDataPartitioning && !m_volmd.bShapeOnly){
  94. if (m_vopmd.vopPredType == PVOP)
  95. decodePVOP_WithShape_DataPartitioning ();
  96. else if (m_vopmd.vopPredType == IVOP)
  97. decodeIVOP_WithShape_DataPartitioning ();
  98. else
  99. decodeBVOP_WithShape ();
  100. }
  101. else {
  102. // End Toshiba(1998-1-16:DP+RVLC)
  103. if (m_vopmd.vopPredType == PVOP)
  104. { // Sprite update piece contains no shape information which has been included in the object piece
  105. if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP)
  106. decodePVOP ();
  107. else
  108. decodePVOP_WithShape ();
  109. }
  110. else if (m_vopmd.vopPredType == IVOP)
  111. decodeIVOP_WithShape ();
  112. else
  113. decodeBVOP_WithShape ();
  114. }
  115. }
  116. else {
  117. // Modified for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)
  118. if(m_volmd.bDataPartitioning){
  119. if (m_vopmd.vopPredType == PVOP)
  120. decodePVOP_DataPartitioning ();
  121. else if (m_vopmd.vopPredType == IVOP)
  122. decodeIVOP_DataPartitioning ();
  123. else
  124. decodeBVOP ();
  125. }
  126. else {
  127. if (m_vopmd.vopPredType == PVOP)
  128. decodePVOP ();
  129. else if (m_vopmd.vopPredType == IVOP)
  130. decodeIVOP ();
  131. else
  132. decodeBVOP ();
  133. }
  134. // End Toshiba(1998-1-16:DP+RVLC)
  135. }
  136. }
  138. Void CVideoObjectDecoder::decodeIVOP_WithShape ()
  139. {
  140. //in case the IVOP is used as an ref for direct mode
  141. memset (m_rgmv, 0, m_iNumMB * PVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
  143. Int iMBX, iMBY;
  144. CMBMode* pmbmd = m_rgmbmd;
  145. // Added for field based MC padding by Hyundai(1998-5-9)
  146.         CMBMode* field_pmbmd = m_rgmbmd;
  147. // End of Hyundai(1998-5-9)
  149. PixelC* ppxlcRefY  = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
  150. PixelC* ppxlcRefU  = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
  151. PixelC* ppxlcRefV  = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
  152. PixelC* ppxlcRefBY = (PixelC*) m_pvopcRefQ1->pixelsBY () + m_iStartInRefToCurrRctY;
  153. PixelC* ppxlcRefA  = (PixelC*) m_pvopcRefQ1->pixelsA () + m_iStartInRefToCurrRctY;
  154. PixelC* ppxlcRefBUV = (PixelC*) m_pvopcRefQ1->pixelsBUV () + m_iStartInRefToCurrRctUV;
  156. pmbmd->m_bFieldDCT=0; // new changes by X. Chen
  158. Int iCurrentQP  = m_vopmd.intStepI;
  159. Int iCurrentQPA = m_vopmd.intStepIAlpha;
  160. // Added for error resilient mode by Toshiba(1997-11-14)
  161. Int iVideoPacketNumber = 0;
  162. m_iVPMBnum = 0;
  163. Bool bRestartDelayedQP = TRUE;
  165. // End Toshiba(1997-11-14)
  166. for (iMBY = 0; iMBY < m_iNumMBY; iMBY++) {
  167. PixelC* ppxlcRefMBY  = ppxlcRefY;
  168. PixelC* ppxlcRefMBU  = ppxlcRefU;
  169. PixelC* ppxlcRefMBV  = ppxlcRefV;
  170. PixelC* ppxlcRefMBBY = ppxlcRefBY;
  171. PixelC* ppxlcRefMBBUV = ppxlcRefBUV;
  172. PixelC* ppxlcRefMBA  = ppxlcRefA;
  174. Bool  bSptMB_NOT_HOLE= TRUE;
  175. // Begin: modified by Hughes   4/9/98
  176. // if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP) {
  177. if (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE && m_vopmd.SpriteXmitMode != STOP) {
  178. // end:  modified by Hughes   4/9/98
  180. bSptMB_NOT_HOLE = SptPieceMB_NOT_HOLE(0, iMBY, pmbmd);  
  181. RestoreMBmCurrRow (iMBY, m_rgpmbmCurr);  // restore current row pointed by *m_rgpmbmCurr
  182. }
  184. for (iMBX = 0; iMBX < m_iNumMBX; iMBX++) {
  185. m_bSptMB_NOT_HOLE  =  bSptMB_NOT_HOLE;
  186. if (!m_bSptMB_NOT_HOLE ) // current Sprite macroblock is not a hole and should be decoded
  187. goto END_OF_DECODING1;
  189. // Added for error resilient mode by Toshiba(1997-11-14)
  190. if (checkResyncMarker()) {
  191. decodeVideoPacketHeader(iCurrentQP);
  192. iVideoPacketNumber++;
  193. bRestartDelayedQP = TRUE;
  194. }
  195. pmbmd->m_iVideoPacketNumber = iVideoPacketNumber;
  196. // End Toshiba(1997-11-14)
  197. decodeIntraShape (pmbmd, iMBX, iMBY, m_ppxlcCurrMBBY, ppxlcRefMBBY);
  198. downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV); // downsample original BY now for LPE padding (using original shape)
  199. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  200.                         if (m_vopmd.bInterlace) initMergedMode (pmbmd);
  201. // End of Hyundai(1998-5-9)*/
  202. if(m_volmd.bShapeOnly==FALSE)
  203. {
  204. pmbmd->m_bPadded=FALSE;
  205. if (pmbmd->m_rgTranspStatus [0] != ALL) {
  206. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  207.                     if (m_vopmd.bInterlace && pmbmd->m_rgTranspStatus [0] == PARTIAL)
  208.                             isBoundaryMacroBlockMerged (pmbmd);
  209. // End of Hyundai(1998-5-9)*/
  210. decodeMBTextureHeadOfIVOP (pmbmd, iCurrentQP, bRestartDelayedQP);
  211. decodeTextureIntraMB (pmbmd, iMBX, iMBY, ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV);
  212. // INTERLACE
  213. //new changes
  214. if ((pmbmd->m_rgTranspStatus [0] == NONE) && 
  215. (m_vopmd.bInterlace == TRUE) && (pmbmd->m_bFieldDCT == TRUE))
  216. fieldDCTtoFrameC(ppxlcRefMBY);
  217. //end of new changes
  218. // ~INTERLACE
  219. if (m_volmd.fAUsage == EIGHT_BIT) {
  220. decodeMBAlphaHeadOfIVOP (pmbmd, iCurrentQP, iCurrentQPA, m_vopmd.intStepI, m_vopmd.intStepIAlpha);
  221. decodeAlphaIntraMB (pmbmd, iMBX, iMBY, ppxlcRefMBA);
  222. }
  223. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  224.                         if (m_vopmd.bInterlace && pmbmd->m_bMerged[0])
  225.                                 mergedMacroBlockSplit (pmbmd, ppxlcRefMBY, ppxlcRefMBA);
  226. // End of Hyundai(1998-5-9)*/
  227. // Begin: modified by Hughes   4/9/98
  228. //   if (m_uiSprite == 0)  {  // added for sprite by dshu: [v071] to delay the padding until ready for warping
  229.   if (m_uiSprite == 0 || m_sptMode == BASIC_SPRITE)  {  //  delay the padding until ready for sprite warping
  230. // end:  modified by Hughes   4/9/98
  231. // MC padding
  232.                                         // Added for field based MC padding by Hyundai(1998-5-9)
  233.                                         if (!m_vopmd.bInterlace) {
  234. if (pmbmd -> m_rgTranspStatus [0] == PARTIAL)
  235. mcPadCurrMB (ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA);
  236. padNeighborTranspMBs (
  237. iMBX, iMBY,
  238. pmbmd,
  239. ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA
  240. );
  241. }
  242. // End of Hyundai(1998-5-9)
  243.   }   // added for sprite by dshu: [v071]
  244. }
  245. else {
  246. // Begin: modified by Hughes   4/9/98
  247. //   if (m_uiSprite == 0)    // added for sprite by dshu: [v071] to delay the padding until ready for warping
  248.   if (m_uiSprite == 0 || m_sptMode == BASIC_SPRITE) //  delay the padding until ready for sprite warping
  249. // end:  modified by Hughes   4/9/98
  250. // Added for field based MC padding by Hyundai(1998-5-9)
  251. if (!m_vopmd.bInterlace) {
  252. padCurrAndTopTranspMBFromNeighbor (
  253. iMBX, iMBY,
  254. pmbmd,
  255. ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA
  256. );
  257. }
  258. // End of Hyundai(1998-5-9)
  259. }
  260. }
  262. END_OF_DECODING1:
  263. ppxlcRefMBA += MB_SIZE;
  264. ppxlcRefMBBY += MB_SIZE;
  265. ppxlcRefMBBUV += BLOCK_SIZE;
  266. pmbmd++;
  267. ppxlcRefMBY += MB_SIZE;
  268. ppxlcRefMBU += BLOCK_SIZE;
  269. ppxlcRefMBV += BLOCK_SIZE;
  271. // Begin: modified by Hughes   4/9/98
  272. // if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP)
  273. if (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE && m_vopmd.SpriteXmitMode != STOP)
  274. // end:  modified by Hughes   4/9/98
  275. bSptMB_NOT_HOLE = SptPieceMB_NOT_HOLE(iMBX+1, iMBY, pmbmd);  
  276. else
  277. bSptMB_NOT_HOLE= TRUE;
  278. }
  279. MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
  280. m_rgpmbmAbove = m_rgpmbmCurr;
  282. // dshu: [v071] begin of modification   1/18/98
  283. // Begin: modified by Hughes   4/9/98
  284. //  if  (m_uiSprite == 1)
  285.   if  (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE)
  286. // end:  modified by Hughes   4/9/98
  287. SaveMBmCurrRow (iMBY, m_rgpmbmCurr);  //   save current row pointed by *m_rgpmbmCurr 
  288. // dshu: [v071] end of modification
  290. m_rgpmbmCurr  = ppmbmTemp;
  291. ppxlcRefY += m_iFrameWidthYxMBSize;
  292. ppxlcRefU += m_iFrameWidthUVxBlkSize;
  293. ppxlcRefV += m_iFrameWidthUVxBlkSize;
  294. ppxlcRefBY += m_iFrameWidthYxMBSize;
  295. ppxlcRefA += m_iFrameWidthYxMBSize;
  296. ppxlcRefBUV += m_iFrameWidthUVxBlkSize;
  297. }
  298. // Added for field based MC padding by Hyundai(1998-5-9)
  299.         if (m_vopmd.bInterlace && m_volmd.bShapeOnly == FALSE)
  300.                 fieldBasedMCPadding (field_pmbmd, m_pvopcRefQ1);
  301.         // End of Hyundai(1998-5-9)
  303. }
  305. Void CVideoObjectDecoder::decodeIVOP ()
  306. {
  307. //in case the IVOP is used as an ref for direct mode
  308. memset (m_rgmv, 0, m_iNumMB * PVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
  310. //Int macrotellertje=0;  // [FDS]
  313. Int iMBX, iMBY;
  314. Int iMBXstart, iMBXstop, iMBYstart, iMBYstop; // Added by KPN for short headers
  315. UInt uiNumberOfGobs; // Added by KPN
  316. UInt uiGobNumber; // Added by KPN
  317. CMBMode* pmbmd = m_rgmbmd;
  318. pmbmd->m_stepSize = m_vopmd.intStepI;
  319. PixelC* ppxlcRefY = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
  320. PixelC* ppxlcRefU = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
  321. PixelC* ppxlcRefV = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
  322. pmbmd->m_bFieldDCT = 0;
  324. Int iCurrentQP  = m_vopmd.intStepI;
  325. Int iVideoPacketNumber = 0;  // added for error resilience mode by Toshiba
  326. m_iVPMBnum = 0; // Added for error resilient mode by Toshiba(1997-11-14)
  328. if (!short_video_header) { 
  329. uiNumberOfGobs = 1;
  330. iMBXstart=0; 
  331. iMBXstop= m_iNumMBX;
  332. iMBYstart=0;
  333. iMBYstop= m_iNumMBY;
  334. }
  335. else { // short_header
  336. uiNumberOfGobs = uiNumGobsInVop;
  337. iMBXstart=0; 
  338. iMBXstop= 0;
  339. iMBYstart=0;
  340. iMBYstop= 0;
  341. //uiNumMacroblocksInGob=8;
  342. // dx_in_gob = ;
  343. // dy_in_gob = ;
  344. }
  346. Bool bRestartDelayedQP = TRUE; // decodeMBTextureHeadOfIVOP sets this to false
  348. uiGobNumber=0;
  349. while (uiGobNumber < uiNumberOfGobs) { 
  350. if (short_video_header) {
  351. uiGobHeaderEmpty=1;
  352. if (uiGobNumber != 0) {
  353. if (m_pbitstrmIn->peekBits(17)==1) {
  354. uiGobHeaderEmpty=0;
  355. /* UInt uiGobResyncMarker= wmay */m_pbitstrmIn -> getBits (17);
  356. uiGobNumber=m_pbitstrmIn -> getBits(5);
  357. /* UInt uiGobFrameId = wmay */ m_pbitstrmIn -> getBits(2);
  358. /* UInt uiVopQuant= wmay */m_pbitstrmIn -> getBits(5); 
  359. uiGobNumber++; 
  360. } else {
  361. uiGobNumber++;
  362. }
  363. } else {
  364. uiGobNumber++;
  365. }
  367. iMBXstart=0; 
  368. iMBXstop= m_ivolWidth/16;
  369. iMBYstart=(uiGobNumber*(m_ivolHeight/16)/uiNumberOfGobs)-1;
  370. iMBYstop= iMBYstart+(m_ivolHeight/16)/uiNumberOfGobs;
  371. } else {
  372. uiGobNumber++; 
  373. }
  375. for (iMBY = iMBYstart; iMBY < iMBYstop; iMBY++) { // [FDS]
  376. PixelC* ppxlcRefMBY = ppxlcRefY;
  377. PixelC* ppxlcRefMBU = ppxlcRefU;
  378. PixelC* ppxlcRefMBV = ppxlcRefV;
  380. Bool  bSptMB_NOT_HOLE= TRUE;
  381. // Begin: modified by Hughes   4/9/98
  382. // if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP) {
  383. if (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE && m_vopmd.SpriteXmitMode != STOP) {
  384. // end:  modified by Hughes   4/9/98
  385. bSptMB_NOT_HOLE = SptPieceMB_NOT_HOLE(0, iMBY, pmbmd);  
  386. RestoreMBmCurrRow (iMBY, m_rgpmbmCurr);  // restore current row pointed by *m_rgpmbmCurr
  387. }
  389. for (iMBX = iMBXstart; iMBX < iMBXstop; iMBX++) {
  390.             
  391.   m_bSptMB_NOT_HOLE  =  bSptMB_NOT_HOLE;
  392.   if (!m_bSptMB_NOT_HOLE )  // current Sprite macroblock is not a hole and should be decoded
  393.   goto END_OF_DECODING2;
  395. if (checkResyncMarker()) {
  396. decodeVideoPacketHeader(iCurrentQP);
  397. iVideoPacketNumber++;
  398. bRestartDelayedQP = TRUE;
  399. }
  400. pmbmd->m_iVideoPacketNumber = iVideoPacketNumber; //mv out of if by wchen to set even when errR is off; always used in mbdec 
  401. decodeMBTextureHeadOfIVOP (pmbmd, iCurrentQP, bRestartDelayedQP);
  402. decodeTextureIntraMB (pmbmd, iMBX, iMBY, ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV);
  403. // INTERLACE
  404. if ((m_vopmd.bInterlace == TRUE) && (pmbmd->m_bFieldDCT == TRUE))
  405. fieldDCTtoFrameC(ppxlcRefMBY);
  406. // ~INTERLACE
  408. END_OF_DECODING2:
  409. pmbmd++;
  410. ppxlcRefMBY += MB_SIZE;
  411. ppxlcRefMBU += BLOCK_SIZE;
  412. ppxlcRefMBV += BLOCK_SIZE;
  413. // Begin: modified by Hughes   4/9/98
  414. // if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP)
  415. if (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE && m_vopmd.SpriteXmitMode != STOP)  // get the hole status for the next MB
  416. // end:  modified by Hughes   4/9/98
  417. bSptMB_NOT_HOLE = SptPieceMB_NOT_HOLE(iMBX+1, iMBY, pmbmd);  
  418. else
  419. bSptMB_NOT_HOLE= TRUE;
  420. }
  421. MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
  422. m_rgpmbmAbove = m_rgpmbmCurr;
  424. // dshu: [v071] begin of modification    1/18/98
  425. // Begin: modified by Hughes   4/9/98
  426. //  if  (m_uiSprite == 1)
  427.   if  (m_uiSprite == 1 && m_sptMode != BASIC_SPRITE)
  428. // end:  modified by Hughes   4/9/98
  429. SaveMBmCurrRow (iMBY, m_rgpmbmCurr);  //   save current row pointed by *m_rgpmbmCurr 
  430. // dshu: [v071] end of modification
  432. m_rgpmbmCurr  = ppmbmTemp;
  433. ppxlcRefY += m_iFrameWidthYxMBSize;
  434. ppxlcRefU += m_iFrameWidthUVxBlkSize;
  435. ppxlcRefV += m_iFrameWidthUVxBlkSize;
  436. // dshu: [v071] begin of modification    1/18/98 move these statements up
  437. // if  (m_uiSprite == 1)
  438. // SaveMBmCurrRow (iMBY, m_rgpmbmCurr);  //   save current row pointed by *m_rgpmbmCurr 
  439. // dshu: [v071] end of modification
  440. }
  441. } // KPN Terminate while loop Gob layer [FDS]
  442. }
  444. Void CVideoObjectDecoder::decodePVOP_WithShape ()
  445. {
  446. Int iMBX, iMBY;
  447. CoordI y = m_rctCurrVOPY.top; 
  448. CMBMode* pmbmd = m_rgmbmd;
  449.         // Added for field based MC padding by Hyundai(1998-5-9)
  450.         CMBMode* field_pmbmd = m_rgmbmd;
  451.         // End of Hyundai(1998-5-9)
  452. CMotionVector* pmv = m_rgmv;
  453. CMotionVector* pmvBY = m_rgmvBY;
  455. PixelC* ppxlcCurrQY  = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
  456. PixelC* ppxlcCurrQU  = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
  457. PixelC* ppxlcCurrQV  = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
  458. PixelC* ppxlcCurrQBY = (PixelC*) m_pvopcRefQ1->pixelsBY () + m_iStartInRefToCurrRctY;
  459. PixelC* ppxlcCurrQA  = (PixelC*) m_pvopcRefQ1->pixelsA () + m_iStartInRefToCurrRctY;
  461. Int iCurrentQP  = m_vopmd.intStep;
  462. Int iCurrentQPA = m_vopmd.intStepPAlpha;
  463. // Added for error resilient mode by Toshiba(1997-11-14)
  464. Int iVideoPacketNumber = 0;  // added for error resilience mode by Toshiba
  465. m_iVPMBnum = 0;
  467. Bool bRestartDelayedQP = TRUE;
  469. // End Toshiba(1997-11-14)
  470. for (iMBY = 0; iMBY < m_iNumMBY; iMBY++, y += MB_SIZE) {
  471. PixelC* ppxlcCurrQMBY  = ppxlcCurrQY;
  472. PixelC* ppxlcCurrQMBU  = ppxlcCurrQU;
  473. PixelC* ppxlcCurrQMBV  = ppxlcCurrQV;
  474. PixelC* ppxlcCurrQMBBY = ppxlcCurrQBY;
  475. PixelC* ppxlcCurrQMBA  = ppxlcCurrQA;
  476. // Added for error resilient mode by Toshiba(1997-11-14)
  477. if (iMBY != 0) {
  478. if (checkResyncMarker()) {
  479. decodeVideoPacketHeader(iCurrentQP);
  480. iVideoPacketNumber++;
  481. bRestartDelayedQP = TRUE;
  482. }
  483. }
  484. pmbmd->m_iVideoPacketNumber = iVideoPacketNumber;
  485. // End Toshiba(1997-11-14)
  486. // Modified for error resilient mode by Toshiba(1997-11-14)
  487. ShapeMode shpmdColocatedMB;
  488. if(m_vopmd.bShapeCodingType) {
  489. shpmdColocatedMB = m_rgmbmdRef [
  490. MIN (iMBY, m_iNumMBYRef-1) * m_iNumMBXRef
  491. ].m_shpmd;
  492. decodeInterShape (m_pvopcRefQ0, pmbmd, 0, iMBY,
  493. m_rctCurrVOPY.left, y, pmv, pmvBY,
  494. m_ppxlcCurrMBBY, ppxlcCurrQMBBY,
  495. shpmdColocatedMB);
  496. }
  497. else {
  498. decodeIntraShape (pmbmd, 0, iMBY, m_ppxlcCurrMBBY,
  499. ppxlcCurrQMBBY);
  500. }
  501. // End Toshiba(1997-11-14)
  502. downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV);
  503. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  504. if (m_vopmd.bInterlace) initMergedMode (pmbmd);
  505. // End of Hyundai(1998-5-9)*/
  506. if (pmbmd->m_rgTranspStatus [0] != ALL && m_volmd.bShapeOnly==FALSE) {
  507. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  508.             if (m_vopmd.bInterlace && pmbmd->m_rgTranspStatus [0] == PARTIAL)
  509.                     isBoundaryMacroBlockMerged (pmbmd);
  510. // End of Hyundai(1998-5-9)*/
  511. decodeMBTextureHeadOfPVOP (pmbmd, iCurrentQP, bRestartDelayedQP);
  512. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  513.                         if (m_vopmd.bInterlace && pmbmd->m_bMerged[0])
  514.                                 swapTransparentModes (pmbmd, BBS);
  515. // End of Hyundai(1998-5-9)*/
  516. decodeMVWithShape (pmbmd, 0, iMBY, pmv);
  517. if(pmbmd->m_bhas4MVForward)
  518. padMotionVectors(pmbmd,pmv);
  519. }
  520. CoordI x = m_rctCurrVOPY.left;
  521. for (iMBX = 0; iMBX < m_iNumMBX; iMBX++, x += MB_SIZE) {
  522. pmbmd->m_bPadded = FALSE;
  523. if (pmbmd->m_rgTranspStatus [0] != ALL && m_volmd.bShapeOnly==FALSE) {
  524. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  525.                 if (m_vopmd.bInterlace && pmbmd->m_bMerged[0])
  526.                     swapTransparentModes (pmbmd, BBM);
  527. // End of Hyundai(1998-5-9)*/
  528. if ((pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ) && !pmbmd->m_bSkip) {
  529. decodeTextureIntraMB (pmbmd, iMBX, iMBY, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
  530. // INTERLACE
  531. //new changes
  532. if ((pmbmd->m_rgTranspStatus [0] == NONE) && 
  533. (m_vopmd.bInterlace == TRUE) && (pmbmd->m_bFieldDCT == TRUE))
  534. fieldDCTtoFrameC(ppxlcCurrQMBY);
  535. //end of new changes
  536. // ~INTERLACE
  537. if (m_volmd.fAUsage == EIGHT_BIT) {
  538. decodeMBAlphaHeadOfPVOP (pmbmd, iCurrentQP, iCurrentQPA);
  539. decodeAlphaIntraMB (pmbmd, iMBX, iMBY, ppxlcCurrQMBA);
  540. }
  541. }
  542. else {
  543. if (!pmbmd->m_bSkip) {
  544. decodeTextureInterMB (pmbmd);
  545. // INTERLACE
  546. //new changes
  547. if ((pmbmd->m_rgTranspStatus [0] == NONE) && 
  548. (m_vopmd.bInterlace == TRUE) && (pmbmd->m_bFieldDCT == TRUE))
  549. fieldDCTtoFrameI(m_ppxliErrorMBY);
  550. //end of new changes
  551. // ~INTERLACE
  552. }
  553. if (m_volmd.fAUsage == EIGHT_BIT) {
  554. decodeMBAlphaHeadOfPVOP (pmbmd, iCurrentQP, iCurrentQPA);
  555. decodeAlphaInterMB (pmbmd, ppxlcCurrQMBA);
  556. }
  557. }
  558. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  559.                 if (m_vopmd.bInterlace && pmbmd->m_bMerged[0])
  560.                         mergedMacroBlockSplit (pmbmd, ppxlcCurrQMBY, ppxlcCurrQMBA);
  561. // End of Hyundai(1998-5-9)*/
  562. }
  563. // decode shape, overhead, and MV for the right MB
  564. if (iMBX != m_iNumMBX - 1) {
  565. CMBMode* pmbmdRight = pmbmd + 1;
  566. // Added for error resilient mode by Toshiba(1997-11-14)
  567. if (checkResyncMarker()) {
  568. decodeVideoPacketHeader(iCurrentQP);
  569. iVideoPacketNumber++;
  570. bRestartDelayedQP = TRUE;
  571. }
  572. pmbmdRight->m_iVideoPacketNumber = iVideoPacketNumber;
  573. // End Toshiba(1997-11-14)
  574. // Modified for error resilient mode by Toshiba(1997-11-14)
  575. if(m_vopmd.bShapeCodingType) {
  576. shpmdColocatedMB = m_rgmbmdRef [
  577. MIN (MAX (0, iMBX+1), m_iNumMBXRef-1) + 
  578.   MIN (MAX (0, iMBY), m_iNumMBYRef-1) * m_iNumMBXRef
  579. ].m_shpmd;
  580. decodeInterShape (
  581. m_pvopcRefQ0,
  582. pmbmdRight, 
  583. iMBX + 1, iMBY, 
  584. x + MB_SIZE, y, 
  585. pmv + PVOP_MV_PER_REF_PER_MB, pmvBY + 1, 
  586. m_ppxlcRightMBBY,
  587. ppxlcCurrQMBBY + MB_SIZE, 
  588. shpmdColocatedMB
  589. );
  590. }
  591. else {
  592. decodeIntraShape (
  593. pmbmdRight, iMBX + 1, iMBY,
  594. m_ppxlcRightMBBY,
  595. ppxlcCurrQMBBY + MB_SIZE
  596. );
  597. }
  598. // End Toshiba(1997-11-14)
  599. downSampleBY (m_ppxlcRightMBBY, m_ppxlcRightMBBUV);
  600. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  601. if (m_vopmd.bInterlace) initMergedMode (pmbmdRight); 
  602. // End of Hyundai(1998-5-9)*/
  603. if (pmbmdRight->m_rgTranspStatus [0] != ALL && m_volmd.bShapeOnly==FALSE) {
  604. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  605.                     if (m_vopmd.bInterlace && pmbmdRight->m_rgTranspStatus [0] == PARTIAL)
  606.                             isBoundaryMacroBlockMerged (pmbmdRight, m_ppxlcRightMBBY);
  607. // End of Hyundai(1998-5-9)*/
  608. decodeMBTextureHeadOfPVOP (pmbmdRight, iCurrentQP, bRestartDelayedQP);
  609. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  610.                     if (m_vopmd.bInterlace && pmbmdRight->m_bMerged[0])
  611.                             swapTransparentModes (pmbmdRight, BBS);
  612. // End of Hyundai(1998-5-9)*/
  613. decodeMVWithShape (pmbmdRight, iMBX + 1, iMBY, pmv + PVOP_MV_PER_REF_PER_MB);
  614. if(pmbmdRight->m_bhas4MVForward)
  615. padMotionVectors (pmbmdRight,pmv + PVOP_MV_PER_REF_PER_MB);
  616. }
  617. }
  619. if(m_volmd.bShapeOnly==FALSE) {
  620. if (pmbmd->m_rgTranspStatus [0] != ALL) {
  621. if (pmbmd->m_dctMd == INTER || pmbmd->m_dctMd == INTERQ) {
  622.   motionCompMB (
  623. m_ppxlcPredMBY, m_pvopcRefQ0->pixelsY (),
  624. pmv, pmbmd, 
  625. iMBX, iMBY, 
  626. x, y,
  627. pmbmd->m_bSkip, FALSE,
  628. &m_rctRefVOPY0
  629. );
  630. if (!pmbmd->m_bSkip) {
  631. CoordI iXRefUV, iYRefUV;
  632. // INTERLACE //new changes
  633. if(pmbmd->m_bFieldMV) {
  634. CoordI iXRefUV1, iYRefUV1;
  635. mvLookupUV (pmbmd, pmv, iXRefUV, iYRefUV, iXRefUV1, iYRefUV1);
  636.     motionCompFieldUV(m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, x, y,
  637.     iXRefUV, iYRefUV, pmbmd->m_bForwardTop);
  638.     motionCompFieldUV(m_ppxlcPredMBU + BLOCK_SIZE, m_ppxlcPredMBV + BLOCK_SIZE,
  639.     m_pvopcRefQ0, x, y, iXRefUV1, iYRefUV1, pmbmd->m_bForwardBottom);
  640.     }
  641. else {
  642. // INTERALCE //end of new changes
  643. mvLookupUVWithShape (pmbmd, pmv, iXRefUV, iYRefUV);
  644. motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0,
  645. x, y, iXRefUV, iYRefUV, m_vopmd.iRoundingControl,&m_rctRefVOPY0);
  646. }
  647. addErrorAndPredToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
  648. }
  649. else {
  650. if (m_volmd.bAdvPredDisable)
  651. copyFromRefToCurrQ (m_pvopcRefQ0, x, y, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, &m_rctRefVOPY0);
  652. else
  653. copyFromPredForYAndRefForCToCurrQ (x, y, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, &m_rctRefVOPY0);
  654. }
  656. if (m_volmd.fAUsage == EIGHT_BIT
  657. && pmbmd->m_CODAlpha!=ALPHA_ALL255)
  658. {
  659.   motionCompMB (
  660. m_ppxlcPredMBA, m_pvopcRefQ0->pixelsA (),
  661. pmv, pmbmd, 
  662. iMBX, iMBY, 
  663. x, y,
  664. FALSE, TRUE,
  665. &m_rctRefVOPY0
  666. );
  668. if(pmbmd->m_CODAlpha==ALPHA_SKIPPED)
  669. assignAlphaPredToCurrQ (ppxlcCurrQMBA);
  670. else
  671. addAlphaErrorAndPredToCurrQ (ppxlcCurrQMBA);
  672. }
  674. }
  675. // Added for field based MC padding by Hyundai(1998-5-9)
  676.                                         if (!m_vopmd.bInterlace) {
  677. if (pmbmd->m_rgTranspStatus [0] == PARTIAL)
  678. mcPadCurrMB (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, ppxlcCurrQMBA);
  679. padNeighborTranspMBs (
  680. iMBX, iMBY,
  681. pmbmd,
  682. ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, ppxlcCurrQMBA
  683. );
  684. }
  685. // End of Hyundai(1998-5-9)
  686. }
  687. else {
  688. // Added for field based MC padding by Hyundai(1998-5-9) 
  689.                                         if (!m_vopmd.bInterlace) {
  690. padCurrAndTopTranspMBFromNeighbor (
  691. iMBX, iMBY,
  692. pmbmd,
  693. ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, ppxlcCurrQMBA
  694. );
  695. }
  696. // End of Hyundai(1998-5-9)
  697. }
  698. }
  699. if (iMBX != m_iNumMBX - 1)
  700. swapCurrAndRightMBForShape ();
  702. pmbmd++;
  703. pmv += PVOP_MV_PER_REF_PER_MB;
  704. pmvBY++;
  705. ppxlcCurrQMBY += MB_SIZE;
  706. ppxlcCurrQMBU += BLOCK_SIZE;
  707. ppxlcCurrQMBV += BLOCK_SIZE;
  708. ppxlcCurrQMBBY += MB_SIZE;
  709. ppxlcCurrQMBA += MB_SIZE;
  710. }
  711. MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
  712. m_rgpmbmAbove = m_rgpmbmCurr;
  713. m_rgpmbmCurr  = ppmbmTemp;
  715. ppxlcCurrQY  += m_iFrameWidthYxMBSize;
  716. ppxlcCurrQU  += m_iFrameWidthUVxBlkSize;
  717. ppxlcCurrQV  += m_iFrameWidthUVxBlkSize;
  718. ppxlcCurrQBY += m_iFrameWidthYxMBSize;
  719. ppxlcCurrQA  += m_iFrameWidthYxMBSize;
  720. }
  721.         // Added for field based MC padding by Hyundai(1998-5-9)
  722.         if (m_vopmd.bInterlace && m_volmd.bShapeOnly == FALSE)
  723.                 fieldBasedMCPadding (field_pmbmd, m_pvopcRefQ1);
  724.         // End of Hyundai(1998-5-9)
  725. }
  727. Void CVideoObjectDecoder::decodePVOP ()
  728. {
  729. Int iMBX, iMBY;
  730. CoordI y = 0; 
  731. Int iMBXstart, iMBXstop, iMBYstart, iMBYstop; // added by KPN [FDS]
  732. UInt uiNumberOfGobs;
  733. Bool bFirstGobRow;
  734. CMBMode* pmbmd = m_rgmbmd;
  735. CMotionVector* pmv = m_rgmv;
  736. PixelC* ppxlcCurrQY = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
  737. PixelC* ppxlcCurrQU = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
  738. PixelC* ppxlcCurrQV = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
  739. // sprite update piece uses binary mask of the object piece
  740. PixelC* ppxlcCurrQBY = (PixelC*) m_pvopcRefQ1->pixelsBY () + m_iStartInRefToCurrRctY; 
  742. Int iCurrentQP  = m_vopmd.intStep;
  743. Int iVideoPacketNumber = 0;
  744. // Added for error resilient mode by Toshiba(1997-11-14)
  745. m_iVPMBnum = 0;
  746. // End Toshiba(1997-11-14)
  747. Bool bLeftBndry;
  748. Bool bRightBndry;
  749. Bool bTopBndry;
  750. Bool bZeroMV = (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 3) ? TRUE : FALSE;
  752. bFirstGobRow=FALSE;
  754. Bool bRestartDelayedQP = TRUE;
  756. if (!short_video_header) { 
  757. uiNumberOfGobs = 1;
  758. iMBXstart=0; 
  759. iMBXstop= m_iNumMBX;
  760. iMBYstart=0;
  761. iMBYstop= m_iNumMBY;
  762. }
  763. else { // short_header
  764. uiNumberOfGobs = uiNumGobsInVop;
  765. iMBXstart=0; 
  766. iMBXstop= 0;
  767. iMBYstart=0;
  768. iMBYstop= 0;
  769. //uiNumMacroblocksInGob=8;
  770. // dx_in_gob = ;
  771. // dy_in_gob = ;
  772. }
  774. uiGobNumber=0;
  775. while (uiGobNumber < uiNumberOfGobs) { 
  776. if (short_video_header) {
  777. uiGobHeaderEmpty=1;
  778. if (uiGobNumber != 0) {
  779. if (m_pbitstrmIn->peekBits(17)==1) {
  780. uiGobHeaderEmpty=0;
  781. /* UInt uiGobResyncMarker= wmay */m_pbitstrmIn -> getBits (17);
  782. uiGobNumber=m_pbitstrmIn -> getBits(5);
  784. /* UInt uiGobFrameId = wmay */m_pbitstrmIn -> getBits(2);
  786. /* UInt uiVopQuant= wmay */ m_pbitstrmIn -> getBits(5); 
  788. bFirstGobRow=TRUE; 
  789. uiGobNumber++; 
  792. } else {
  793. uiGobNumber++;
  795. }
  797. } else {
  798. uiGobNumber++;
  799. } 
  801. iMBXstart=0; 
  802. iMBXstop= m_ivolWidth/16;
  803. iMBYstart=(uiGobNumber*(m_ivolHeight/16)/uiNumberOfGobs)-1;
  804. iMBYstop= iMBYstart+(m_ivolHeight/16)/uiNumberOfGobs;
  805. } else {
  806. uiGobNumber++; 
  807. }
  809. for (iMBY = iMBYstart; iMBY < iMBYstop; iMBY++, y += MB_SIZE) {
  810. PixelC* ppxlcCurrQMBY = ppxlcCurrQY;
  811. PixelC* ppxlcCurrQMBU = ppxlcCurrQU;
  812. PixelC* ppxlcCurrQMBV = ppxlcCurrQV;
  813. //   In a given Sprite update piece, Check whether current macroblock is not a hole and should be coded ?
  814. PixelC* ppxlcCurrQMBBY = ppxlcCurrQBY;
  815. Bool  bSptMB_NOT_HOLE= TRUE;
  816. if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP) 
  817. bSptMB_NOT_HOLE = SptUpdateMB_NOT_HOLE(0, iMBY, pmbmd); 
  819. // Added for error resilience mode By Toshiba
  820. if (iMBY != 0) {
  821. if (checkResyncMarker()) {
  822. decodeVideoPacketHeader(iCurrentQP);
  823. iVideoPacketNumber++;
  824. bRestartDelayedQP = TRUE;
  825. }
  826. }
  827. pmbmd->m_iVideoPacketNumber = iVideoPacketNumber;
  828. if (iMBY==0) {
  829. bRightBndry = TRUE;
  830. bTopBndry = TRUE;
  831. }
  832. else {
  833. bRightBndry = !((pmbmd - m_iNumMBX + 1) -> m_iVideoPacketNumber == pmbmd->m_iVideoPacketNumber);
  834. bTopBndry = !((pmbmd - m_iNumMBX) -> m_iVideoPacketNumber == pmbmd->m_iVideoPacketNumber);
  835. }
  836. if (bFirstGobRow) // Added by KPN
  837. {
  838. bTopBndry=TRUE;
  839. bRightBndry=TRUE;
  840. }
  842. // only RECTANGLE or non-transparent MB  will be decoded  for the update piece
  843. if (m_uiSprite == 0) {
  844. decodeMBTextureHeadOfPVOP (pmbmd, iCurrentQP, bRestartDelayedQP);
  845. decodeMV (pmbmd, pmv, TRUE, bRightBndry, bTopBndry, bZeroMV, 0, iMBY);
  846. } 
  847. else if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP) {
  848. if (m_volmd.fAUsage != RECTANGLE) {
  849. if (pmbmd -> m_rgTranspStatus [0] != ALL)
  850. decodeMBTextureHeadOfPVOP (pmbmd, iCurrentQP, bRestartDelayedQP);
  851. }
  852. else
  853. decodeMBTextureHeadOfPVOP (pmbmd, iCurrentQP, bRestartDelayedQP);
  854. } 
  856. CoordI x = 0;
  857. for (iMBX = iMBXstart; iMBX < iMBXstop; iMBX++, x += MB_SIZE) { // [FDS]
  859. if (m_uiSprite == 0) {
  860. if (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ) {
  861. decodeTextureIntraMB (pmbmd, iMBX, iMBY, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
  862. if ((m_vopmd.bInterlace == TRUE) && (pmbmd->m_bFieldDCT == TRUE))
  863. fieldDCTtoFrameC(ppxlcCurrQMBY);
  864. } else {
  865. if (!pmbmd->m_bSkip) {
  866. decodeTextureInterMB (pmbmd);
  867. if ((m_vopmd.bInterlace == TRUE) && (pmbmd->m_bFieldDCT == TRUE))
  868. fieldDCTtoFrameI(m_ppxliErrorMBY);
  869. }
  870. }
  871. }
  872. // only non-transparent MB and COD == 0 will be decoded
  873. else if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP)
  874. // sprite update piece use P_VOP syntax with no MV
  875. {
  876. pmv -> setToZero ();  
  877. pmbmd->m_bhas4MVForward = FALSE ;  
  878. pmbmd -> m_dctMd = INTER ;
  879. if ((pmbmd -> m_rgTranspStatus [0] != ALL) && (!pmbmd->m_bSkip))
  880. decodeTextureInterMB (pmbmd);
  881. }
  883. if (iMBX != m_iNumMBX - 1) {
  884. CMBMode* pmbmdRight = pmbmd + 1;
  885. if (checkResyncMarker()) {
  886. decodeVideoPacketHeader(iCurrentQP);
  887. iVideoPacketNumber++;
  888. bRestartDelayedQP = TRUE;
  889. }
  890. pmbmdRight->m_iVideoPacketNumber = iVideoPacketNumber;
  891. if (iMBY == 0 || bFirstGobRow==TRUE) {  // [FDS]
  892. bLeftBndry = !(pmbmd -> m_iVideoPacketNumber == pmbmdRight -> m_iVideoPacketNumber);
  893. bRightBndry = TRUE;
  894. bTopBndry = TRUE;
  895. }
  896. else {
  897. bLeftBndry =  !(pmbmd -> m_iVideoPacketNumber == pmbmdRight -> m_iVideoPacketNumber);
  898. if ((iMBX + 1) == m_iNumMBX - 1)
  899. bRightBndry = TRUE;
  900. else
  901. bRightBndry = !((pmbmdRight - m_iNumMBX + 1) -> m_iVideoPacketNumber == pmbmdRight->m_iVideoPacketNumber);
  902. bTopBndry = !((pmbmdRight - m_iNumMBX) -> m_iVideoPacketNumber == pmbmdRight->m_iVideoPacketNumber);
  903. }
  904. if (m_uiSprite == 0) {
  905. decodeMBTextureHeadOfPVOP (pmbmdRight, iCurrentQP, bRestartDelayedQP);
  906. decodeMV (pmbmdRight, pmv + PVOP_MV_PER_REF_PER_MB, bLeftBndry, bRightBndry, bTopBndry, bZeroMV, iMBX+1, iMBY);
  907. }
  908. // sprite update piece use P_VOP syntax with no MV
  909. else if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP) 
  910. {
  911. bSptMB_NOT_HOLE = SptUpdateMB_NOT_HOLE(iMBX+1, iMBY, pmbmdRight);
  912. ppxlcCurrQMBBY += MB_SIZE;
  913. if (pmbmdRight -> m_rgTranspStatus [0] != ALL)
  914. decodeMBTextureHeadOfPVOP (pmbmdRight, iCurrentQP, bRestartDelayedQP);
  915. }
  916. }
  917. if (pmbmd->m_dctMd == INTER || pmbmd->m_dctMd == INTERQ) {
  918. if (m_uiSprite == 0) {
  919. motionCompMB (
  920. m_ppxlcPredMBY, m_pvopcRefQ0->pixelsY (),
  921. pmv, pmbmd, 
  922. iMBX, iMBY, 
  923. x, y,
  924. pmbmd->m_bSkip,
  925. FALSE,
  926. &m_rctRefVOPY0
  927. );
  928. if (!pmbmd->m_bSkip) {
  929. CoordI iXRefUV, iYRefUV, iXRefUV1, iYRefUV1;
  930. mvLookupUV (pmbmd, pmv, iXRefUV, iYRefUV, iXRefUV1, iYRefUV1);
  931. // INTERLACE
  932. if(pmbmd->m_bFieldMV) {
  933. motionCompFieldUV(m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, x, y,
  934. iXRefUV, iYRefUV, pmbmd->m_bForwardTop);
  935. motionCompFieldUV(m_ppxlcPredMBU + BLOCK_SIZE, m_ppxlcPredMBV + BLOCK_SIZE,
  936. m_pvopcRefQ0, x, y, iXRefUV1, iYRefUV1, pmbmd->m_bForwardBottom);
  937. }
  938. else 
  939. // ~INTERLACE
  940. motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0,
  941. x, y, iXRefUV, iYRefUV, m_vopmd.iRoundingControl,&m_rctRefVOPY0);
  942. addErrorAndPredToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
  943. }
  944. else {
  945. if (m_volmd.bAdvPredDisable)
  946. copyFromRefToCurrQ (m_pvopcRefQ0, x, y, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, NULL);
  947. else
  948. copyFromPredForYAndRefForCToCurrQ (x, y, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, NULL);
  949. }
  950. } // end else from "if ( m_vopmd.SpriteXmitMode != STOP)" 
  951. // sprite update piece use P_VOP syntax with no motionCompMB
  952. else if (m_uiSprite == 1 && m_vopmd.SpriteXmitMode != STOP) 
  953. {
  954. CopyCurrQToPred(ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
  955. if ((!pmbmd->m_bSkip) && (pmbmd -> m_rgTranspStatus [0] != ALL)) {
  956. addErrorAndPredToCurrQ (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV);
  957. }
  958. }
  959. }
  960. pmbmd++;
  961. pmv += PVOP_MV_PER_REF_PER_MB;
  962. ppxlcCurrQMBY += MB_SIZE;
  963. ppxlcCurrQMBU += BLOCK_SIZE;
  964. ppxlcCurrQMBV += BLOCK_SIZE;
  965. }
  966. MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
  967. m_rgpmbmAbove = m_rgpmbmCurr;
  968. m_rgpmbmCurr  = ppmbmTemp;
  969. ppxlcCurrQY += m_iFrameWidthYxMBSize;
  970. ppxlcCurrQU += m_iFrameWidthUVxBlkSize;
  971. ppxlcCurrQV += m_iFrameWidthUVxBlkSize;
  972. ppxlcCurrQBY += m_iFrameWidthYxMBSize;
  973. bFirstGobRow=FALSE; // KPN
  974. }
  975. } // Terminate while loop
  976. }
  978. Void CVideoObjectDecoder::decodeBVOP ()
  979. {
  980. Int iMBX, iMBY;
  981. CoordI y = 0; 
  982. CMBMode* pmbmd = m_rgmbmd;
  983. CMBMode* pmbmdRef = m_rgmbmdRef;
  984. CMotionVector* pmv = m_rgmv;
  985. CMotionVector* pmvRef = m_rgmvRef;
  986. CMotionVector* pmvBackward = m_rgmvBackward;
  987. PixelC* ppxlcCurrQY = (PixelC*) m_pvopcCurrQ->pixelsY () + m_iStartInRefToCurrRctY;
  988. PixelC* ppxlcCurrQU = (PixelC*) m_pvopcCurrQ->pixelsU () + m_iStartInRefToCurrRctUV;
  989. PixelC* ppxlcCurrQV = (PixelC*) m_pvopcCurrQ->pixelsV () + m_iStartInRefToCurrRctUV;
  991. Int iCurrentQP  = m_vopmd.intStepB;
  992. // Added for error resilient mode by Toshiba(1998-1-16:B-VOP+Error)
  993. Int iVideoPacketNumber = 0;
  994. m_iVPMBnum = 0;
  996. if(m_bCodedFutureRef==FALSE)
  997. {
  998. pmbmdRef = NULL;
  999. pmvRef = NULL;
  1000. }
  1002. // End Toshiba(1998-1-16:B-VOP+Error)
  1003. for (iMBY = 0; iMBY < m_iNumMBY; iMBY++, y += MB_SIZE) {
  1004. PixelC* ppxlcCurrQMBY = ppxlcCurrQY;
  1005. PixelC* ppxlcCurrQMBU = ppxlcCurrQU;
  1006. PixelC* ppxlcCurrQMBV = ppxlcCurrQV;
  1007. CoordI x = 0;
  1008. m_vctForwardMvPredBVOP[0].x  = m_vctForwardMvPredBVOP[0].y  = 0;
  1009. m_vctBackwardMvPredBVOP[0].x = m_vctBackwardMvPredBVOP[0].y = 0;
  1010. m_vctForwardMvPredBVOP[1].x  = m_vctForwardMvPredBVOP[1].y  = 0;
  1011. m_vctBackwardMvPredBVOP[1].x = m_vctBackwardMvPredBVOP[1].y = 0;
  1012. for (iMBX = 0; iMBX < m_iNumMBX; iMBX++, x += MB_SIZE) {
  1013. if(!(m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 0))
  1014. pmbmd->m_bColocatedMBSkip = (pmbmdRef==NULL ? FALSE : pmbmdRef->m_bSkip);
  1015. else
  1016. pmbmd->m_bColocatedMBSkip = FALSE;
  1017. if (pmbmd->m_bColocatedMBSkip &&
  1018. (m_volmd.volType == BASE_LAYER || (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 3 && m_volmd.iEnhnType == 0)))
  1019. {
  1020. copyFromRefToCurrQ (
  1021. m_pvopcRefQ0,
  1022. x, y, 
  1023. ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, NULL
  1024. );
  1025. pmbmd->m_bSkip = TRUE;
  1026. memset (pmv, 0, BVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
  1027. memset (pmvBackward, 0, BVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
  1028. pmbmd->m_mbType = FORWARD; // can be set to FORWARD mode since the result is the same
  1029. }
  1030. else {
  1031. if (checkResyncMarker()) {
  1032. decodeVideoPacketHeader(iCurrentQP);
  1033. iVideoPacketNumber++;
  1034. m_vctForwardMvPredBVOP[0].x  = m_vctForwardMvPredBVOP[0].y  = 0;
  1035. m_vctBackwardMvPredBVOP[0].x = m_vctBackwardMvPredBVOP[0].y = 0;
  1036. m_vctForwardMvPredBVOP[1].x  = m_vctForwardMvPredBVOP[1].y  = 0;
  1037. m_vctBackwardMvPredBVOP[1].x = m_vctBackwardMvPredBVOP[1].y = 0;
  1038. }
  1039. pmbmd->m_iVideoPacketNumber = iVideoPacketNumber; //mv out of if by wchen to set even when errR is off; always used in mbdec 
  1040. // End Toshiba(1998-1-16:B-VOP+Error)
  1041. decodeMBTextureHeadOfBVOP (pmbmd, iCurrentQP);
  1042. decodeMVofBVOP (pmv, pmvBackward, pmbmd, iMBX, iMBY, pmvRef, pmbmdRef);
  1043. if (!pmbmd->m_bSkip) {
  1044. decodeTextureInterMB (pmbmd);
  1045. // INTERLACE
  1046. if (m_vopmd.bInterlace == TRUE && pmbmd->m_bFieldDCT == TRUE)
  1047. fieldDCTtoFrameI(m_ppxliErrorMBY);
  1048. // ~INTERLACE
  1049. motionCompAndAddErrorMB_BVOP (
  1050. pmv, pmvBackward,
  1051. pmbmd, 
  1052. iMBX, iMBY, 
  1053. x, y,
  1054. ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV,
  1055. &m_rctRefVOPY0,&m_rctRefVOPY1);
  1056. }
  1057. else {
  1058.                     if (m_vopmd.bInterlace) {                       // Need to remove this 'if' (Bob Eifrig)
  1059.     assert(pmbmd->m_mbType == DIRECT);
  1060.     pmbmd->m_vctDirectDeltaMV.x = 0; 
  1061. pmbmd->m_vctDirectDeltaMV.y = 0;
  1062.     memset (m_ppxliErrorMBY, 0, MB_SQUARE_SIZE * sizeof(Int));
  1063.     memset (m_ppxliErrorMBU, 0, BLOCK_SQUARE_SIZE * sizeof(Int));
  1064.     memset (m_ppxliErrorMBV, 0, BLOCK_SQUARE_SIZE * sizeof(Int));
  1065.     motionCompAndAddErrorMB_BVOP (
  1066.     pmv, pmvBackward,
  1067.     pmbmd, 
  1068.     iMBX, iMBY, 
  1069.     x, y,
  1070.     ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV,
  1071.     &m_rctRefVOPY0, &m_rctRefVOPY1);
  1072.                     } else {
  1073.     motionCompSkipMB_BVOP (pmbmd, pmv, pmvBackward,
  1074.     x, y, ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, &m_rctRefVOPY0, &m_rctRefVOPY1);
  1075.                     }
  1076. }
  1077. }
  1079. if(m_bCodedFutureRef!=FALSE)
  1080. {
  1081. pmbmdRef++;
  1082. pmvRef += PVOP_MV_PER_REF_PER_MB;
  1083. }
  1085. pmbmd++;
  1086. pmv         += BVOP_MV_PER_REF_PER_MB;
  1087. pmvBackward += BVOP_MV_PER_REF_PER_MB;
  1088. ppxlcCurrQMBY += MB_SIZE;
  1089. ppxlcCurrQMBU += BLOCK_SIZE;
  1090. ppxlcCurrQMBV += BLOCK_SIZE;
  1091. }
  1092. ppxlcCurrQY += m_iFrameWidthYxMBSize;
  1093. ppxlcCurrQU += m_iFrameWidthUVxBlkSize;
  1094. ppxlcCurrQV += m_iFrameWidthUVxBlkSize;
  1095. }
  1096. }
  1098. Void CVideoObjectDecoder::decodeBVOP_WithShape ()
  1099. {
  1100. Int iMBX, iMBY;
  1101. CoordI y = m_rctCurrVOPY.top; 
  1102. CMBMode* pmbmd = m_rgmbmd;
  1103.         // Added for field based MC padding by Hyundai(1998-5-9)
  1104.         CMBMode* field_pmbmd = m_rgmbmd;
  1105.         // End of Hyundai(1998-5-9)
  1106. CMotionVector* pmv = m_rgmv;
  1107. CMotionVector* pmvBackward = m_rgmvBackward;
  1108. CMotionVector* pmvBY = m_rgmvBY;
  1109. const CMotionVector* pmvRef;
  1110. const CMBMode* pmbmdRef;
  1112. PixelC* ppxlcCurrQY = (PixelC*) m_pvopcCurrQ->pixelsY () + m_iStartInRefToCurrRctY;
  1113. PixelC* ppxlcCurrQU = (PixelC*) m_pvopcCurrQ->pixelsU () + m_iStartInRefToCurrRctUV;
  1114. PixelC* ppxlcCurrQV = (PixelC*) m_pvopcCurrQ->pixelsV () + m_iStartInRefToCurrRctUV;
  1115. PixelC* ppxlcCurrQBY = (PixelC*) m_pvopcCurrQ->pixelsBY () + m_iStartInRefToCurrRctY;
  1116. PixelC* ppxlcCurrQA  = (PixelC*) m_pvopcCurrQ->pixelsA () + m_iStartInRefToCurrRctY;
  1118. // decide prediction direction for shape
  1119. if(m_bCodedFutureRef==FALSE)
  1120. m_vopmd.fShapeBPredDir = B_FORWARD;
  1121. else
  1122. {
  1123. if(m_tFutureRef - m_t >= m_t - m_tPastRef)
  1124. m_vopmd.fShapeBPredDir = B_FORWARD;
  1125. else
  1126. m_vopmd.fShapeBPredDir = B_BACKWARD;
  1127. }
  1129. Int iCurrentQP  = m_vopmd.intStepB;
  1130. Int iCurrentQPA = m_vopmd.intStepBAlpha;
  1131. // Added for error resilient mode by Toshiba(1998-1-16:B-VOP+Error)
  1132. Int iVideoPacketNumber = 0;
  1133. m_iVPMBnum = 0;
  1134. // End Toshiba(1998-1-16:B-VOP+Error)
  1135. for (iMBY = 0; iMBY < m_iNumMBY; iMBY++, y += MB_SIZE) {
  1136. PixelC* ppxlcCurrQMBY = ppxlcCurrQY;
  1137. PixelC* ppxlcCurrQMBU = ppxlcCurrQU;
  1138. PixelC* ppxlcCurrQMBV = ppxlcCurrQV;
  1139. PixelC* ppxlcCurrQMBBY = ppxlcCurrQBY;
  1140. PixelC* ppxlcCurrQMBA  = ppxlcCurrQA;
  1141. CoordI x = m_rctCurrVOPY.left; 
  1142. m_vctForwardMvPredBVOP[0].x  = m_vctForwardMvPredBVOP[0].y  = 0;
  1143. m_vctBackwardMvPredBVOP[0].x = m_vctBackwardMvPredBVOP[0].y = 0;
  1144. m_vctForwardMvPredBVOP[1].x  = m_vctForwardMvPredBVOP[1].y  = 0;
  1145. m_vctBackwardMvPredBVOP[1].x = m_vctBackwardMvPredBVOP[1].y = 0;
  1146. for (iMBX = 0; iMBX < m_iNumMBX; iMBX++, x += MB_SIZE) {
  1147. // Added for error resilient mode by Toshiba(1998-1-16:B-VOP+Error)
  1148. if (checkResyncMarker()) {
  1149. decodeVideoPacketHeader(iCurrentQP);
  1150. iVideoPacketNumber++;
  1151. m_vctForwardMvPredBVOP[0].x  = m_vctForwardMvPredBVOP[0].y  = 0;
  1152. m_vctBackwardMvPredBVOP[0].x = m_vctBackwardMvPredBVOP[0].y = 0;
  1153. m_vctForwardMvPredBVOP[1].x  = m_vctForwardMvPredBVOP[1].y  = 0;
  1154. m_vctBackwardMvPredBVOP[1].x = m_vctBackwardMvPredBVOP[1].y = 0;
  1155. }
  1156. pmbmd->m_iVideoPacketNumber = iVideoPacketNumber; //mv out of if by wchen to set even when errR is off; always used in mbdec 
  1157. // End Toshiba(1998-1-16:B-VOP+Error)
  1158. pmbmd->m_bPadded=FALSE;
  1159. findColocatedMB (iMBX, iMBY, pmbmdRef, pmvRef);
  1160. pmbmd->m_bColocatedMBSkip = (pmbmdRef!=NULL && pmbmdRef->m_bSkip);
  1161. if(m_vopmd.bShapeCodingType)
  1162. {
  1163. ShapeMode shpmdColocatedMB;
  1164. if(m_vopmd.fShapeBPredDir==B_FORWARD)
  1165. shpmdColocatedMB = m_rgshpmd [MIN (MAX (0, iMBX), m_iRefShpNumMBX - 1)
  1166. + MIN (MAX (0, iMBY), m_iRefShpNumMBY - 1) * m_iRefShpNumMBX];
  1167. else
  1168. shpmdColocatedMB = m_rgmbmdRef [MIN (MAX (0, iMBX), m_iNumMBXRef - 1)
  1169. + MIN (MAX (0, iMBY), m_iNumMBYRef - 1) * m_iNumMBXRef].m_shpmd;
  1171. decodeInterShape (
  1172. m_vopmd.fShapeBPredDir==B_FORWARD ? m_pvopcRefQ0 : m_pvopcRefQ1,
  1173. pmbmd, iMBX, iMBY, x, y,
  1174. NULL, pmvBY, m_ppxlcCurrMBBY, ppxlcCurrQMBBY, shpmdColocatedMB);
  1175. } else {
  1176. decodeIntraShape (pmbmd, iMBX, iMBY, m_ppxlcCurrMBBY, ppxlcCurrQMBBY);
  1177. }
  1179. if(m_volmd.bShapeOnly==FALSE)
  1180. {
  1181. downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV);
  1182. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  1183. if (m_vopmd.bInterlace) initMergedMode (pmbmd);
  1184. // End of Hyundai(1998-5-9)*/
  1185. if (pmbmd->m_bColocatedMBSkip &&
  1186. (m_volmd.volType == BASE_LAYER || (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 3 && m_volmd.iEnhnType == 0))) { 
  1187. // don't need to send any bit for this mode except enhn_layer
  1188. copyFromRefToCurrQ (
  1189. m_pvopcRefQ0,
  1190. x, y, 
  1191. ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV,
  1192. &m_rctRefVOPY0
  1193. );
  1194. if(m_volmd.fAUsage == EIGHT_BIT)
  1195. copyAlphaFromRefToCurrQ(m_pvopcRefQ0, x, y, ppxlcCurrQMBA, &m_rctRefVOPY0);
  1196. pmbmd->m_bSkip = TRUE;
  1197. memset (pmv, 0, BVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
  1198. memset (pmvBackward, 0, BVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
  1199. pmbmd->m_mbType = FORWARD; // can be set to FORWARD mode since the result is the same
  1200. }
  1201. else {
  1202. if (pmbmd->m_rgTranspStatus [0] != ALL) {
  1203. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  1204. if (m_vopmd.bInterlace && pmbmd->m_rgTranspStatus [0] == PARTIAL)
  1205. isBoundaryMacroBlockMerged (pmbmd);
  1206. // End of Hyundai(1998-5-9)*/
  1207. decodeMBTextureHeadOfBVOP (pmbmd, iCurrentQP);
  1208. decodeMVofBVOP (pmv, pmvBackward, pmbmd, iMBX, iMBY, pmvRef, pmbmdRef);
  1209. if (!pmbmd->m_bSkip) {
  1210. decodeTextureInterMB (pmbmd);
  1211. // INTERLACE
  1212. //new changes
  1213. if ((pmbmd->m_rgTranspStatus [0] == NONE) && 
  1214. (m_vopmd.bInterlace == TRUE) && (pmbmd->m_bFieldDCT == TRUE))
  1215. fieldDCTtoFrameI(m_ppxliErrorMBY);
  1216. //end of new changes
  1217. // ~INTERLACE
  1218. //motionCompAndAddErrorMB_BVOP ( // delete by Hyundai, ok swinder
  1219. // pmv, pmvBackward,
  1220. // pmbmd, 
  1221. // iMBX, iMBY, 
  1222. // x, y,
  1223. // ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV,
  1224. // &m_rctRefVOPY0, &m_rctRefVOPY1
  1225. //);
  1226. }
  1227. else {
  1228. // new changes 10/20/98
  1229. if (m_vopmd.bInterlace) {                       
  1230. assert(pmbmd->m_mbType == DIRECT);
  1231. pmbmd->m_vctDirectDeltaMV.x = 0; 
  1232. pmbmd->m_vctDirectDeltaMV.y = 0;
  1233. memset (m_ppxliErrorMBY, 0, MB_SQUARE_SIZE * sizeof(Int));
  1234. memset (m_ppxliErrorMBU, 0, BLOCK_SQUARE_SIZE * sizeof(Int));
  1235. memset (m_ppxliErrorMBV, 0, BLOCK_SQUARE_SIZE * sizeof(Int));
  1236. motionCompAndAddErrorMB_BVOP (
  1237. pmv, pmvBackward,
  1238. pmbmd, 
  1239.      iMBX, iMBY, 
  1240. x, y,
  1241. ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV,
  1242. &m_rctRefVOPY0, &m_rctRefVOPY1);
  1243. } else 
  1244. // end of new changes 10/20/98
  1245. {
  1246. //assert(pmbmdRef!=NULL);
  1247. motionCompSkipMB_BVOP (pmbmd, pmv, pmvBackward, x, y,
  1248. ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, &m_rctRefVOPY0, &m_rctRefVOPY1);
  1250. }
  1251. }
  1252. if(m_volmd.fAUsage == EIGHT_BIT)
  1253. {
  1254. decodeMBAlphaHeadOfBVOP(pmbmd, iCurrentQP, iCurrentQPA);
  1255. decodeAlphaInterMB(pmbmd, ppxlcCurrQMBA);
  1257. /* delete by Hyundai, ok swinder
  1258. if (pmbmd->m_CODAlpha!=ALPHA_ALL255)
  1259. {
  1260. motionCompAlphaMB_BVOP(
  1261. pmv, pmvBackward,
  1262. pmbmd, 
  1263. iMBX, iMBY, 
  1264. x, y,
  1265. ppxlcCurrQMBA,
  1266. &m_rctRefVOPY0, &m_rctRefVOPY1
  1267. );
  1269. if(pmbmd->m_CODAlpha==ALPHA_SKIPPED)
  1270. assignAlphaPredToCurrQ (ppxlcCurrQMBA);
  1271. else
  1272. addAlphaErrorAndPredToCurrQ (ppxlcCurrQMBA);
  1273. }
  1274. */
  1275. }
  1276. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  1277. if (m_vopmd.bInterlace && pmbmd->m_bMerged[0])
  1278. mergedMacroBlockSplit (pmbmd);
  1279. // End of Hyundai(1998-5-9)*/
  1280. if (!pmbmd->m_bSkip) {
  1281. motionCompAndAddErrorMB_BVOP (
  1282. pmv, pmvBackward,
  1283. pmbmd,
  1284. iMBX, iMBY,
  1285. x, y,
  1286. ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV,
  1287. &m_rctRefVOPY0, &m_rctRefVOPY1
  1288. );
  1289. }          
  1290. if (m_volmd.fAUsage == EIGHT_BIT) {
  1291. if (pmbmd->m_CODAlpha!=ALPHA_ALL255)
  1292. {  
  1293. motionCompAlphaMB_BVOP(
  1294. pmv, pmvBackward,
  1295. pmbmd,
  1296. iMBX, iMBY,
  1297. x, y,
  1298. ppxlcCurrQMBA,
  1299. &m_rctRefVOPY0, &m_rctRefVOPY1
  1300. );
  1302. if(pmbmd->m_CODAlpha==ALPHA_SKIPPED)
  1303. assignAlphaPredToCurrQ (ppxlcCurrQMBA);
  1304. else
  1305. addAlphaErrorAndPredToCurrQ (ppxlcCurrQMBA);
  1306. }
  1307. }
  1308. }
  1309. }
  1310. //padding of bvop is necessary for temporal scalability: bvop in base layer is used for prediction in enhancement layer
  1312. // Added for field based MC padding by Hyundai(1998-5-9)
  1313. if (!m_vopmd.bInterlace) {
  1314. if (pmbmd -> m_rgTranspStatus [0] != ALL) {
  1315. if (pmbmd -> m_rgTranspStatus [0] == PARTIAL)
  1316. mcPadCurrMB (ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, ppxlcCurrQMBA);
  1317. padNeighborTranspMBs (
  1318. iMBX, iMBY,
  1319. pmbmd,
  1320. ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, ppxlcCurrQMBA
  1321. );
  1322. }
  1323. else {
  1324. padCurrAndTopTranspMBFromNeighbor (
  1325. iMBX, iMBY,
  1326. pmbmd,
  1327. ppxlcCurrQMBY, ppxlcCurrQMBU, ppxlcCurrQMBV, ppxlcCurrQMBA
  1328. );
  1329. }
  1330. }
  1331. // End of Hyundai(1998-5-9)
  1332. }
  1333. pmbmd++;
  1334. pmv += BVOP_MV_PER_REF_PER_MB;
  1335. pmvBY++;
  1336. pmvBackward += BVOP_MV_PER_REF_PER_MB;
  1337. ppxlcCurrQMBY += MB_SIZE;
  1338. ppxlcCurrQMBU += BLOCK_SIZE;
  1339. ppxlcCurrQMBV += BLOCK_SIZE;
  1340. ppxlcCurrQMBBY += MB_SIZE;
  1341. ppxlcCurrQMBA += MB_SIZE;
  1342. }
  1343. ppxlcCurrQY += m_iFrameWidthYxMBSize;
  1344. ppxlcCurrQU += m_iFrameWidthUVxBlkSize;
  1345. ppxlcCurrQV += m_iFrameWidthUVxBlkSize;
  1346. ppxlcCurrQBY += m_iFrameWidthYxMBSize;
  1347. ppxlcCurrQA += m_iFrameWidthYxMBSize;
  1348. }
  1349.         // Added for field based MC padding by Hyundai(1998-5-9)
  1350.         if (m_vopmd.bInterlace && m_volmd.bShapeOnly == FALSE)
  1351.                 fieldBasedMCPadding (field_pmbmd, m_pvopcCurrQ);
  1352.         // End of Hyundai(1998-5-9)
  1353. }