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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

vopses.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. (date: March, 1996)
  10. and edited by
  11.         Wei Wu (weiwu@stallion.risc.rockwell.com) Rockwell Science Center
  13. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  14. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  15. as specified by the MPEG-4 Video. 
  16. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  17. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  18. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
  19. The original developer of this software module and his/her company, 
  20. the subsequent editors and their companies, 
  21. and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
  22. Copyright is not released for non MPEG-4 Video conforming products. 
  23. Microsoft retains full right to use the code for his/her own purpose, 
  24. assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
  25. This copyright notice must be included in all copies or derivative works. 
  27. Copyright (c) 1996, 1997.
  29. Module Name:
  31. vopSes.cpp
  33. Abstract:
  35. Base class for the encoder for one VOP session.
  37. Revision History:
  38. December 20, 1997: Interlaced tools added by NextLevel Systems (GI)
  39.                         X.Chen (xchen@nlvl.com), B. Eifrig (beifrig@nlvl.com)
  40.         May. 9   1998:  add boundary by Hyundai Electronics 
  41.                                   Cheol-Soo Park (cspark@super5.hyundai.co.kr) 
  42.         May. 9   1998:  add field based unrestricted MC padding by Hyundai Electronics 
  43.                                   Cheol-Soo Park (cspark@super5.hyundai.co.kr) 
  44. *************************************************************************/
  46. #include <stdio.h>
  48. #include "typeapi.h"
  49. #include "basic.hpp"
  50. #include "header.h"
  51. #include "codehead.h"
  52. #include "mode.hpp"
  53. #include "dct.hpp"
  54. #include "cae.h"
  55. #include "vopses.hpp"
  57. #ifdef __MFC_
  58. #ifdef _DEBUG
  59. #undef THIS_FILE
  60. static char BASED_CODE THIS_FILE[] = __FILE__;
  61. #endif
  63. #define new DEBUG_NEW    
  64. #endif // __MFC_
  66. CVideoObject::~CVideoObject ()
  67. {
  68. delete m_pvopcCurrQ;
  69. delete m_pvopcRefQ0;
  70. delete m_pvopcRefQ1;       // modified by Shu 12/12/97
  71.    // wchen: unmodified 12/16/97
  73. delete m_pvopcCurrMB;
  74. delete m_pvopcPredMB;
  75. delete m_pvopiErrorMB;
  76. delete [] m_rgmbmd;
  77. delete [] m_rgmv;
  78. delete [] m_rgmvBY;
  79.     delete [] m_rgmvRef;
  80. delete m_pidct;
  82. Int nBlk = (m_volmd.fAUsage == EIGHT_BIT) ? 10 : 6;
  83. Int iBlk;
  84. for (iBlk = 0; iBlk < nBlk; iBlk++)
  85. delete [] m_rgpiCoefQ [iBlk];
  86. delete [] m_rgpiCoefQ;
  87. // delete m_pvopfCurrFilteredQ;
  88. // delete m_pdrtmdRef1;
  90. delete [] m_rgiQPpred;
  92. if (m_volmd.fAUsage == RECTANGLE) {
  93. Int nBlk = (m_volmd.fAUsage == EIGHT_BIT) ? 10 : 6;
  94. delete [] m_rgblkmCurrMB;
  95.         if (m_rgpmbmAbove != NULL)
  96.     for (Int iMB = 0; iMB < m_iNumMBX; iMB++) {
  97.     for (iBlk = 0; iBlk < nBlk; iBlk++) {
  98.     delete [] (m_rgpmbmAbove [iMB]->rgblkm) [iBlk];
  99.     delete [] (m_rgpmbmCurr  [iMB]->rgblkm) [iBlk];
  100.     }
  101.     delete [] m_rgpmbmAbove [iMB]->rgblkm;
  102.     delete m_rgpmbmAbove [iMB];
  103.     delete [] m_rgpmbmCurr [iMB]->rgblkm;
  104.     delete m_rgpmbmCurr [iMB];
  105.     }
  106. delete [] m_rgpmbmAbove;
  107. delete [] m_rgpmbmCurr;
  108. }
  110. // sprite
  111. if (m_uiSprite == 1) {
  112. delete [] m_rgstSrcQ;
  113. delete [] m_rgstDstQ;
  114. if (m_sptMode == BASIC_SPRITE)
  115. delete m_pvopcSptQ;
  116. }
  117. delete m_pbEmptyRowArray;
  119. /* NBIT: change
  120. m_rgiClipTab -= 400;
  121. */
  122. m_rgiClipTab -= m_iOffset;
  123. delete [] m_rgiClipTab;
  124. m_rgiClipTab = NULL;
  126. // shape
  127. if(m_rgshpmd!=NULL)
  128. delete m_rgshpmd;
  129. delete m_puciPredBAB;
  130. delete m_parcodec;
  131. delete [] m_ppxlcCurrMBBYDown4;
  132. delete [] m_ppxlcCurrMBBYDown2;
  133. delete [] m_ppxlcReconCurrBAB;
  134. delete [] m_ppxlcPredBABDown2;
  135. delete [] m_ppxlcPredBABDown4;
  136. }
  138. CVideoObject::CVideoObject ()
  139. {
  140. m_t = 0;
  141. m_iBCount = 0;
  142. m_tPastRef = 0;
  143. m_tFutureRef = 0;
  144. m_bCodedFutureRef = TRUE;
  145. m_rgmbmd = NULL;
  146. m_rgmv = NULL;
  147. m_rgmvBackward = NULL;
  148. m_rgmvBY = NULL;
  149. m_rgmbmdRef = NULL;
  150. m_rgmvRef = NULL;
  151. m_tModuloBaseDecd = 0;
  152. m_tModuloBaseDisp = 0;
  153. m_pvopcCurrQ = NULL;
  154. m_pvopcRefQ0 = NULL; 
  155. m_pvopcRefQ1 = NULL;
  156. m_puciPredBAB = NULL;
  157. m_ppxlcReconCurrBAB = NULL;
  158. m_parcodec = NULL;
  159. m_ppxlcCurrMBBYDown4 = NULL;
  160. m_ppxlcCurrMBBYDown2 = NULL;
  161. m_ppxlcPredBABDown4 = NULL;
  162. m_ppxlcPredBABDown2 = NULL;
  163. m_pvopcSptQ = NULL;
  164. m_uiSprite = 0;
  165. m_rgstSrcQ = NULL;
  166. m_rgstDstQ = NULL;
  167. m_iOffsetForPadY = 0;
  168. m_iOffsetForPadUV = 0;
  169. m_rgshpmd = NULL;
  170. m_pbEmptyRowArray = new Bool [MB_SIZE];
  172. /* NBIT: replaced by setClipTab() function
  173. m_rgiClipTab = new U8 [1024];
  174. m_rgiClipTab += 400;
  175. Int i;
  176. for (i = -400; i < 624; i++)
  177. m_rgiClipTab [i] = (i < 0) ? 0 : (i > 255) ? 255 : i;
  178. */
  180. }
  182. // NBIT: added function
  183. Void CVideoObject::setClipTab()
  184. {
  185. Int TabSize = 1<<(m_volmd.nBits+2);
  186. Int maxVal = (1<<m_volmd.nBits)-1;
  187. m_iOffset = TabSize/2;
  188. m_rgiClipTab = new PixelC [TabSize];
  189. m_rgiClipTab += m_iOffset;
  190. Int i;
  191. for (i = -m_iOffset; i < m_iOffset; i++)
  192. m_rgiClipTab [i] = (i < 0) ? 0 : (i > maxVal) ? maxVal : i;
  193. }
  195. Void CVideoObject::allocateVOLMembers (Int iSessionWidth, Int iSessionHeight)
  196. {
  197. m_pvopcCurrMB = new CVOPU8YUVBA (m_volmd.fAUsage, CRct (0, 0, MB_SIZE, MB_SIZE));
  198. m_ppxlcCurrMBY = (PixelC*) m_pvopcCurrMB->pixelsY ();
  199. m_ppxlcCurrMBU = (PixelC*) m_pvopcCurrMB->pixelsU ();
  200. m_ppxlcCurrMBV = (PixelC*) m_pvopcCurrMB->pixelsV ();
  201. m_ppxlcCurrMBBY = (PixelC*) m_pvopcCurrMB->pixelsBY ();
  202. m_ppxlcCurrMBBUV = (PixelC*) m_pvopcCurrMB->pixelsBUV ();
  203. m_ppxlcCurrMBA = (PixelC*) m_pvopcCurrMB->pixelsA ();
  205. m_pvopcPredMB = new CVOPU8YUVBA (m_volmd.fAUsage, CRct (0, 0, MB_SIZE, MB_SIZE));
  206. m_ppxlcPredMBY = (PixelC*) m_pvopcPredMB->pixelsY ();
  207. m_ppxlcPredMBU = (PixelC*) m_pvopcPredMB->pixelsU ();
  208. m_ppxlcPredMBV = (PixelC*) m_pvopcPredMB->pixelsV ();
  209. m_ppxlcPredMBA = (PixelC*) m_pvopcPredMB->pixelsA ();
  211. // B-VOP MB buffer data
  212. m_pvopcPredMBBack = new CVOPU8YUVBA (m_volmd.fAUsage, CRct (0, 0, MB_SIZE, MB_SIZE));
  213. m_ppxlcPredMBBackY = (PixelC*) m_pvopcPredMBBack->pixelsY ();
  214. m_ppxlcPredMBBackU = (PixelC*) m_pvopcPredMBBack->pixelsU ();
  215. m_ppxlcPredMBBackV = (PixelC*) m_pvopcPredMBBack->pixelsV ();
  216. m_ppxlcPredMBBackA = (PixelC*) m_pvopcPredMBBack->pixelsA ();
  218. m_pvopiErrorMB = new CVOPIntYUVBA (m_volmd.fAUsage, CRct (0, 0, MB_SIZE, MB_SIZE));
  219. m_ppxliErrorMBY = (PixelI*) m_pvopiErrorMB->getPlane (Y_PLANE)->pixels ();
  220. m_ppxliErrorMBU = (PixelI*) m_pvopiErrorMB->getPlane (U_PLANE)->pixels ();
  221. m_ppxliErrorMBV = (PixelI*) m_pvopiErrorMB->getPlane (V_PLANE)->pixels ();
  222. m_ppxliErrorMBA = (PixelI*) m_pvopiErrorMB->getPlane (A_PLANE)->pixels ();
  224. if (m_uiSprite == 0)
  225. m_pvopcCurrQ = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctRefFrameY);
  226. else //for sprite m_rctRefFrameY is for whole sprite, m_rctOrg is the display window 
  227. // dshu: begin of modification
  228. // m_pvopcCurrQ = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctDisplayWindow);
  229. {
  230. CRct rctCurrQ = CRct (
  231. -EXPANDY_REF_FRAME, -EXPANDY_REF_FRAME, 
  232. EXPANDY_REF_FRAME + m_rctDisplayWindow.width, EXPANDY_REF_FRAME + m_rctDisplayWindow.height()
  233. );
  235. m_pvopcCurrQ = new CVOPU8YUVBA (m_volmd.fAUsage, rctCurrQ);
  236. }
  237. // dshu: end of modification
  239.     assert (m_pvopcCurrQ != NULL);
  240. m_pvopcRefQ0 = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctRefFrameY);
  241. assert (m_pvopcRefQ0 != NULL);
  242. m_pvopcRefQ1 = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctRefFrameY);
  243. assert (m_pvopcRefQ1 != NULL);
  245. m_iFrameWidthY = m_pvopcRefQ0->whereY ().width;
  246. m_iFrameWidthUV = m_pvopcRefQ0->whereUV ().width;
  247. m_iFrameWidthYxMBSize = MB_SIZE * m_pvopcRefQ0->whereY ().width; 
  248. m_iFrameWidthYxBlkSize = BLOCK_SIZE * m_pvopcRefQ0->whereY ().width; 
  249. m_iFrameWidthUVxBlkSize = BLOCK_SIZE * m_pvopcRefQ0->whereUV ().width;
  251. // MB data
  252. Int nBlk = (m_volmd.fAUsage == EIGHT_BIT) ? 10 : 6;
  253. m_rgpiCoefQ = new Int* [nBlk];
  254. m_rgiQPpred = new Int [nBlk];
  255. Int iBlk;
  256. for (iBlk = 0; iBlk < nBlk; iBlk++)
  257. m_rgpiCoefQ [iBlk] = new Int [BLOCK_SQUARE_SIZE];
  258. /* NBIT: change
  259. m_pidct = new CInvBlockDCT;
  260. */
  261. m_pidct = new CInvBlockDCT(m_volmd.nBits);
  263. // motion vectors and MBMode
  264. Int iNumMBX = iSessionWidth / MB_SIZE; 
  265. if (iSessionWidth  % MB_SIZE != 0) //round up
  266. iNumMBX++;
  267. Int iNumMBY = iSessionHeight / MB_SIZE;
  268. if (iSessionHeight % MB_SIZE != 0) //deal with frational MB
  269. iNumMBY++;
  270. Int iNumMB = m_iSessNumMB = iNumMBX * iNumMBY;
  272. m_rgmbmd = new CMBMode [iNumMB];
  273. m_rgmv = new CMotionVector [max(PVOP_MV_PER_REF_PER_MB, 2*BVOP_MV_PER_REF_PER_MB) * iNumMB];
  274. m_rgmvBackward = m_rgmv + BVOP_MV_PER_REF_PER_MB * m_iSessNumMB;
  275. m_rgmvRef = new CMotionVector [max(PVOP_MV_PER_REF_PER_MB, 2*BVOP_MV_PER_REF_PER_MB) * iNumMB];
  276. m_rgmvBY = new CMotionVector [iNumMB]; // for shape
  277. m_rgmbmdRef = new CMBMode [iNumMB];
  279. if (m_volmd.volType == ENHN_LAYER)
  280. m_rgshpmd = new ShapeMode [iNumMB];
  282. // shape data
  283. if (m_volmd.fAUsage != RECTANGLE) {
  284. m_puciPredBAB = new CU8Image (CRct (0, 0, MC_BAB_SIZE, MC_BAB_SIZE));
  285. m_ppxlcReconCurrBAB = new PixelC [BAB_SIZE * BAB_SIZE];
  286. m_parcodec = new ArCodec;
  287. m_ppxlcCurrMBBYDown4 = new PixelC [8 * 8];
  288. m_ppxlcCurrMBBYDown2 = new PixelC [12 * 12];
  289. m_ppxlcPredBABDown4 = new PixelC [6*6];
  290. m_ppxlcPredBABDown2 = new PixelC [10*10];
  291. }
  292. }
  294. Void CVideoObject::computeVOLConstMembers ()
  295. {
  296. m_iOffsetForPadY = m_rctRefFrameY.offset (m_rctCurrVOPY.left, m_rctCurrVOPY.top);
  297. m_iOffsetForPadUV = m_rctRefFrameUV.offset (m_rctCurrVOPUV.left, m_rctCurrVOPUV.top);
  298. m_rctPrevNoExpandY = m_rctCurrVOPY;
  299. m_rctPrevNoExpandUV = m_rctCurrVOPUV;
  300. m_iVOPWidthY = m_rctCurrVOPY.width;
  301. m_iVOPWidthUV = m_rctCurrVOPUV.width;
  302. m_iNumMBX = m_iNumMBXRef = m_iVOPWidthY / MB_SIZE; 
  303. m_iNumMBY = m_iNumMBYRef = m_rctCurrVOPY.height () / MB_SIZE;
  304. m_iNumMB = m_iNumMBRef = m_iNumMBX * m_iNumMBY;
  305. m_iNumOfTotalMVPerRow = PVOP_MV_PER_REF_PER_MB * m_iNumMBX;
  306. setRefStartingPointers ();
  307. m_pvopcCurrQ->setBoundRct (m_rctCurrVOPY);
  308. m_pvopcRefQ0->setBoundRct (m_rctRefVOPY0);
  309. m_pvopcRefQ1->setBoundRct (m_rctRefVOPY1);
  311. Int iMB, iBlk;
  312. Int nBlk = (m_volmd.fAUsage == EIGHT_BIT) ? 10 : 6;
  313. m_rgblkmCurrMB = new BlockMemory [nBlk];
  315. m_rgpmbmAbove = new MacroBlockMemory* [m_iNumMBX];
  316. m_rgpmbmCurr  = new MacroBlockMemory* [m_iNumMBX];
  317. for (iMB = 0; iMB < m_iNumMBX; iMB++) {
  318. m_rgpmbmAbove [iMB] = new MacroBlockMemory;
  319. m_rgpmbmAbove [iMB]->rgblkm = new BlockMemory [nBlk];
  320. m_rgpmbmCurr  [iMB] = new MacroBlockMemory;
  321. m_rgpmbmCurr  [iMB]->rgblkm = new BlockMemory [nBlk];
  322. for (iBlk = 0; iBlk < nBlk; iBlk++) {
  323. (m_rgpmbmAbove [iMB]->rgblkm) [iBlk] = new Int [(BLOCK_SIZE << 1) - 1];
  324. (m_rgpmbmCurr  [iMB]->rgblkm) [iBlk] = new Int [(BLOCK_SIZE << 1) - 1];
  325. }
  326. }
  327. }
  329. Void CVideoObject::computeVOPMembers ()
  330. {
  331. m_iVOPWidthY = m_rctCurrVOPY.width;
  332. m_iVOPWidthUV = m_rctCurrVOPUV.width;
  333. m_iNumMBX = m_iVOPWidthY / MB_SIZE; 
  334. m_iNumMBY = m_rctCurrVOPY.height () / MB_SIZE;
  335. m_iNumMB = m_iNumMBX * m_iNumMBY;
  336. m_iNumOfTotalMVPerRow = PVOP_MV_PER_REF_PER_MB * m_iNumMBX;
  338. Int iMB, iBlk;
  339. Int nBlk = (m_volmd.fAUsage == EIGHT_BIT) ? 10 : 6;
  340. m_rgblkmCurrMB = new BlockMemory [nBlk];
  342. m_rgpmbmAbove = new MacroBlockMemory* [m_iNumMBX];
  343. m_rgpmbmCurr  = new MacroBlockMemory* [m_iNumMBX];
  344. for (iMB = 0; iMB < m_iNumMBX; iMB++) {
  345. m_rgpmbmAbove [iMB] = new MacroBlockMemory;
  346. m_rgpmbmAbove [iMB]->rgblkm = new BlockMemory [nBlk];
  347. m_rgpmbmCurr  [iMB] = new MacroBlockMemory;
  348. m_rgpmbmCurr  [iMB]->rgblkm = new BlockMemory [nBlk];
  349. for (iBlk = 0; iBlk < nBlk; iBlk++) {
  350. // BLOCK_SIZE*2-1 is 15 Ints for dc/ac prediction of coefficients
  351. (m_rgpmbmAbove [iMB]->rgblkm) [iBlk] = new Int [(BLOCK_SIZE << 1) - 1];
  352. (m_rgpmbmCurr  [iMB]->rgblkm) [iBlk] = new Int [(BLOCK_SIZE << 1) - 1];
  353. }
  354. }
  355. }
  357. Void CVideoObject::repeatPadYOrA (PixelC* ppxlcOldLeft, CVOPU8YUVBA* pvopcRef)
  358. {
  359. PixelC* ppxlcLeftTop = ppxlcOldLeft - EXPANDY_REFVOP * m_iFrameWidthY - EXPANDY_REFVOP;
  360. // point to the left top of the expanded bounding box (+- EXPANDY_REFVOP)
  361. const PixelC* ppxlcOldRight = ppxlcOldLeft + ((m_volmd.fAUsage == RECTANGLE)?m_ivolWidth:m_rctPrevNoExpandY.width) - 1; // modified by Sharp (99/1/14)
  362. // point to the right-top of the bounding box
  363. const PixelC* ppxlcOldTopLn = ppxlcOldLeft - EXPANDY_REFVOP;
  364. // point to the (left, top) - EXPANDY_REFVOP
  365. PixelC* ppxlcNewLeft = (PixelC*) ppxlcOldTopLn;
  366. PixelC* ppxlcNewRight = (PixelC*) ppxlcOldRight + 1;
  367. CoordI y;
  369. // begin:  modified by Sharp (99/1/14)
  370. Int PrevNoExpandY_height = (m_volmd.fAUsage == RECTANGLE)?m_ivolHeight:m_rctPrevNoExpandY.height ();
  371. for (y = 0; y < PrevNoExpandY_height; y++) { // x-direction interpolation
  372. // end: modified by Sharp
  373. for (Int i=0; i<EXPANDY_REFVOP; i++) {
  374. ppxlcNewLeft[i] = *ppxlcOldLeft;
  375. ppxlcNewRight[i] = *ppxlcOldRight;
  376. }
  377. ppxlcNewLeft += pvopcRef->whereY ().width;
  378. ppxlcNewRight += pvopcRef->whereY ().width;
  379. ppxlcOldLeft += pvopcRef->whereY ().width;
  380. ppxlcOldRight += pvopcRef->whereY ().width;
  381. }
  382. /* commented out due to fact of no field padding now
  383. // Added for field based unrestricted MC padding by Hyundai(1998-5-9)
  384.         if (m_vopmd.bInterlace) {      
  385. Int  iUnit = sizeof (PixelC); 
  386.                 Int     width = pvopcRef->whereY ().width;
  387.                 Int     iFieldSkip = 2*width;
  388.                 Int     iPadArea = (m_rctPrevNoExpandY.width + 2 * EXPANDY_REFVOP)*iUnit;
  389.                 const PixelC
  390.                         *ppxlcSrcTopFieldLn1 = ppxlcOldTopLn,
  391.                         *ppxlcSrcTopFieldLn2 = ppxlcNewLeft  - iFieldSkip,
  392.                         *ppxlcSrcBotFieldLn1 = ppxlcOldTopLn + width,
  393.                         *ppxlcSrcBotFieldLn2 = ppxlcNewLeft  - width;
  394.                 PixelC  *ppxlcDstTopFieldLn1 = ppxlcLeftTop,
  395.                         *ppxlcDstTopFieldLn2 = ppxlcNewLeft,
  396.                         *ppxlcDstBotFieldLn1 = ppxlcLeftTop + width,
  397.                         *ppxlcDstBotFieldLn2 = ppxlcNewLeft + width;
  398.                 for (y = 0; y < EXPANDY_REFVOP/2; y++) {
  399.                         memcpy (ppxlcDstTopFieldLn1, ppxlcSrcTopFieldLn1, iPadArea);
  400.                         memcpy (ppxlcDstTopFieldLn2, ppxlcSrcTopFieldLn2, iPadArea);
  401.                         memcpy (ppxlcDstBotFieldLn1, ppxlcSrcBotFieldLn1, iPadArea);
  402.                         memcpy (ppxlcDstBotFieldLn2, ppxlcSrcBotFieldLn2, iPadArea);
  403.                         ppxlcDstTopFieldLn1 += iFieldSkip;
  404.                         ppxlcDstTopFieldLn2 += iFieldSkip;
  405.                         ppxlcDstBotFieldLn1 += iFieldSkip;
  406.                         ppxlcDstBotFieldLn2 += iFieldSkip;
  407.                 }
  408.                 return;
  409.         }
  410. // End of Hyundai(1998-5-9)
  411. */
  413. const PixelC* ppxlcOldBotLn = ppxlcNewLeft - pvopcRef->whereY ().width;
  414. for (y = 0; y < EXPANDY_REFVOP; y++) {
  415. memcpy (ppxlcLeftTop, ppxlcOldTopLn, (m_rctPrevNoExpandY.width + 2 * EXPANDY_REFVOP)*sizeof(PixelC));
  416. memcpy (ppxlcNewLeft, ppxlcOldBotLn, (m_rctPrevNoExpandY.width + 2 * EXPANDY_REFVOP)*sizeof(PixelC));
  417. ppxlcNewLeft += pvopcRef->whereY ().width;
  418. ppxlcLeftTop += pvopcRef->whereY ().width;
  419. }
  420. }
  422. Void CVideoObject::repeatPadUV (CVOPU8YUVBA* pvopcRef)
  423. {
  424. const PixelC* ppxlcOldLeftU = pvopcRef->pixelsU () + m_iOffsetForPadUV; // point to the left-top of bounding box
  425. const PixelC* ppxlcOldLeftV = pvopcRef->pixelsV () + m_iOffsetForPadUV; // point to the left-top of bounding box
  426. PixelC* ppxlcLeftTopU = (PixelC*) ppxlcOldLeftU - EXPANDUV_REFVOP * m_iFrameWidthUV - EXPANDUV_REFVOP;
  427. PixelC* ppxlcLeftTopV = (PixelC*) ppxlcOldLeftV - EXPANDUV_REFVOP * m_iFrameWidthUV - EXPANDUV_REFVOP;
  428. // point to the left top of the expanded bounding box (+- EXPANDY_REFVOP)
  429. const PixelC* ppxlcOldRightU = ppxlcOldLeftU + ((m_volmd.fAUsage == RECTANGLE)?m_ivolWidth/2:m_rctPrevNoExpandUV.width) - 1; // modified by Sharp (99/1/14)
  430. const PixelC* ppxlcOldRightV = ppxlcOldLeftV + ((m_volmd.fAUsage == RECTANGLE)?m_ivolWidth/2:m_rctPrevNoExpandUV.width) - 1; // modified by Sharp (99/1/14)
  431. // point to the right-top of the bounding box
  432. const PixelC* ppxlcOldTopLnU = ppxlcOldLeftU - EXPANDUV_REFVOP;
  433. const PixelC* ppxlcOldTopLnV = ppxlcOldLeftV - EXPANDUV_REFVOP;
  434. // point to the (left, top) - EXPANDY_REFVOP
  435. PixelC* ppxlcNewLeftU = (PixelC*) ppxlcOldTopLnU;
  436. PixelC* ppxlcNewLeftV = (PixelC*) ppxlcOldTopLnV;
  437. PixelC* ppxlcNewRightU = (PixelC*) ppxlcOldRightU + 1;
  438. PixelC* ppxlcNewRightV = (PixelC*) ppxlcOldRightV + 1;
  440. CoordI y;
  441. // begin:  modified by Sharp (99/1/14)
  442. Int PrevNoExpandUV_height = (m_volmd.fAUsage == RECTANGLE)?m_ivolHeight/2:m_rctPrevNoExpandUV.height ();
  443. for (y = 0; y < PrevNoExpandUV_height; y++) { // x-direction interpolation
  444. // end:  modified by Sharp (99/1/14)
  445. for (Int i=0; i<EXPANDUV_REFVOP; i++) {
  446. ppxlcNewLeftU[i] = *ppxlcOldLeftU;
  447. ppxlcNewLeftV[i] = *ppxlcOldLeftV;
  448. ppxlcNewRightU[i] = *ppxlcOldRightU;
  449. ppxlcNewRightV[i] = *ppxlcOldRightV;
  450. }
  452. ppxlcNewLeftU += pvopcRef->whereUV ().width;
  453. ppxlcNewLeftV += pvopcRef->whereUV ().width;
  454. ppxlcNewRightU += pvopcRef->whereUV ().width;
  455. ppxlcNewRightV += pvopcRef->whereUV ().width;
  456. ppxlcOldLeftU += pvopcRef->whereUV ().width;
  457. ppxlcOldLeftV += pvopcRef->whereUV ().width;
  458. ppxlcOldRightU += pvopcRef->whereUV ().width;
  459. ppxlcOldRightV += pvopcRef->whereUV ().width;
  460. }
  461. /* no longer any field based padding
  462. // Added for field based unrestricted MC padding by Hyundai(1998-5-9)
  463.         if (m_vopmd.bInterlace) {
  464. Int iUnit = sizeof(PixelC);
  465.                 Int     width = pvopcRef->whereUV ().width;
  466.                 Int     iFieldSkip = 2*width;
  467.                 Int     iPadArea = (m_rctPrevNoExpandUV.width + 2 * EXPANDUV_REFVOP)*iUnit;
  468.                 const PixelC 
  469.                         *ppxlcSrcTopFieldLn1U = ppxlcOldTopLnU,
  470.                         *ppxlcSrcTopFieldLn2U = ppxlcNewLeftU  - iFieldSkip,
  471.                         *ppxlcSrcBotFieldLn1U = ppxlcOldTopLnU + width,
  472.                         *ppxlcSrcBotFieldLn2U = ppxlcNewLeftU  - width,
  473.                         *ppxlcSrcTopFieldLn1V = ppxlcOldTopLnV,
  474.                         *ppxlcSrcTopFieldLn2V = ppxlcNewLeftV  - iFieldSkip,
  475.                         *ppxlcSrcBotFieldLn1V = ppxlcOldTopLnV + width,
  476.                         *ppxlcSrcBotFieldLn2V = ppxlcNewLeftV  - width;
  477.                 PixelC  *ppxlcDstTopFieldLn1U = ppxlcLeftTopU,
  478.                         *ppxlcDstTopFieldLn2U = ppxlcNewLeftU,
  479.                         *ppxlcDstBotFieldLn1U = ppxlcLeftTopU + width,
  480.                         *ppxlcDstBotFieldLn2U = ppxlcNewLeftU + width,
  481.                         *ppxlcDstTopFieldLn1V = ppxlcLeftTopV,
  482.                         *ppxlcDstTopFieldLn2V = ppxlcNewLeftV,
  483.                         *ppxlcDstBotFieldLn1V = ppxlcLeftTopV + width,
  484.                         *ppxlcDstBotFieldLn2V = ppxlcNewLeftV + width;
  485.                 for (y = 0; y < EXPANDUV_REFVOP/2; y++) {
  486.                         memcpy (ppxlcDstTopFieldLn1U, ppxlcSrcTopFieldLn1U, iPadArea);
  487.                         memcpy (ppxlcDstTopFieldLn2U, ppxlcSrcTopFieldLn2U, iPadArea);
  488.                         memcpy (ppxlcDstBotFieldLn1U, ppxlcSrcBotFieldLn1U, iPadArea);
  489.                         memcpy (ppxlcDstBotFieldLn2U, ppxlcSrcBotFieldLn2U, iPadArea);
  490.                         memcpy (ppxlcDstTopFieldLn1V, ppxlcSrcTopFieldLn1V, iPadArea);
  491.                         memcpy (ppxlcDstTopFieldLn2V, ppxlcSrcTopFieldLn2V, iPadArea);
  492.                         memcpy (ppxlcDstBotFieldLn1V, ppxlcSrcBotFieldLn1V, iPadArea);
  493.                         memcpy (ppxlcDstBotFieldLn2V, ppxlcSrcBotFieldLn2V, iPadArea);
  494.                         ppxlcDstTopFieldLn1U += iFieldSkip;
  495.                         ppxlcDstTopFieldLn2U += iFieldSkip;
  496.                         ppxlcDstBotFieldLn1U += iFieldSkip;
  497.                         ppxlcDstBotFieldLn2U += iFieldSkip;
  498.                         ppxlcDstTopFieldLn1V += iFieldSkip;
  499.                         ppxlcDstTopFieldLn2V += iFieldSkip;
  500.                         ppxlcDstBotFieldLn1V += iFieldSkip;
  501.                         ppxlcDstBotFieldLn2V += iFieldSkip;
  502.                 }
  503.                 return;
  504.         }
  505. // End of Hyundai(1998-5-9)
  506. */
  508. const PixelC* ppxlcOldBotLnU = ppxlcNewLeftU - pvopcRef->whereUV ().width;
  509. const PixelC* ppxlcOldBotLnV = ppxlcNewLeftV - pvopcRef->whereUV ().width;
  510. for (y = 0; y < EXPANDUV_REFVOP; y++) {
  511. memcpy (ppxlcLeftTopU, ppxlcOldTopLnU, (m_rctPrevNoExpandUV.width + 2 * EXPANDUV_REFVOP)*sizeof(PixelC));
  512. memcpy (ppxlcLeftTopV, ppxlcOldTopLnV, (m_rctPrevNoExpandUV.width + 2 * EXPANDUV_REFVOP)*sizeof(PixelC));
  513. memcpy (ppxlcNewLeftU, ppxlcOldBotLnU, (m_rctPrevNoExpandUV.width + 2 * EXPANDUV_REFVOP)*sizeof(PixelC));
  514. memcpy (ppxlcNewLeftV, ppxlcOldBotLnV, (m_rctPrevNoExpandUV.width + 2 * EXPANDUV_REFVOP)*sizeof(PixelC));
  515. ppxlcNewLeftU += pvopcRef->whereUV ().width;
  516. ppxlcNewLeftV += pvopcRef->whereUV ().width;
  517. ppxlcLeftTopU += pvopcRef->whereUV ().width;
  518. ppxlcLeftTopV += pvopcRef->whereUV ().width;
  519. }
  520. }
  522. Void CVideoObject::saveShapeMode()
  523. {
  524. // called after reference frame encode/decode
  525. if(m_rgshpmd == NULL)
  526. {
  527. // first time
  528. m_iRefShpNumMBX = m_iNumMBX;
  529. m_iRefShpNumMBY = m_iNumMBY;
  530. m_rgshpmd = new ShapeMode [m_iNumMB];
  531. }
  532. else
  533. {
  534. // update if changed
  535. if(m_iRefShpNumMBX!=m_iNumMBXRef || m_iRefShpNumMBY != m_iNumMBYRef)
  536. {
  537. delete [] m_rgshpmd;
  538. m_rgshpmd = new ShapeMode [m_iNumMBRef];
  539. m_iRefShpNumMBX = m_iNumMBXRef;
  540. m_iRefShpNumMBY = m_iNumMBYRef;
  541. }
  542. // copy shape mode from previous ref to save
  543. Int i;
  544. for (i=0; i<m_iNumMBRef; i++ )
  545. m_rgshpmd[i] = m_rgmbmdRef[i].m_shpmd;
  546. }
  547. }
  549. Void CVideoObject::resetBYPlane ()
  550. {
  551. if (m_vopmd.vopPredType == PVOP || m_vopmd.vopPredType == IVOP) {
  552. PixelC* ppxlcBY = (PixelC*) m_pvopcRefQ1->pixelsBY ();
  553. memset (ppxlcBY, 0, m_pvopcRefQ1->whereY().area() * sizeof(PixelC));
  554. }
  555. else {
  556. PixelC* ppxlcBY = (PixelC*) m_pvopcCurrQ->pixelsBY ();
  557. memset (ppxlcBY, 0, m_pvopcCurrQ->whereY().area() * sizeof(PixelC));
  558. }
  559. }
  561. Void CVideoObject::updateAllRefVOPs ()
  562. // perform this after VOP prediction type decided and before encoding
  563. {
  564. if (m_vopmd.vopPredType != BVOP) {
  565. m_rctRefVOPY0 = m_rctRefVOPY1;
  566. swapVOPU8Pointers (m_pvopcRefQ0, m_pvopcRefQ1);
  567. }
  568. }
  570. // for spatial scalability
  571. Void CVideoObject::updateAllRefVOPs (const CVOPU8YUVBA* pvopcRefBaseLayer)
  572. {
  573. CVOPU8YUVBA *pvopcUpSampled = NULL;
  574. // Int fEnhancementLayer = 0;
  576. assert (m_volmd.volType == ENHN_LAYER);
  578. pvopcUpSampled = pvopcRefBaseLayer->upsampleForSpatialScalability (
  579. m_volmd.iver_sampling_factor_m,
  580. m_volmd.iver_sampling_factor_n,
  581. m_volmd.ihor_sampling_factor_m,
  582. m_volmd.ihor_sampling_factor_n,
  583. EXPANDY_REF_FRAME,
  584. EXPANDUV_REF_FRAME);
  585. if(m_vopmd.vopPredType == PVOP) {
  586. m_rctRefVOPY0 = m_rctRefVOPY1;
  587. swapVOPU8Pointers (m_pvopcRefQ0,pvopcUpSampled);
  588. m_pvopcRefQ0->setBoundRct(m_rctRefVOPY0);
  589. delete pvopcUpSampled;
  590. }
  591. else if(m_vopmd.vopPredType == BVOP){
  592. CRct tmp;
  593. tmp = m_rctRefVOPY0;
  594. m_rctRefVOPY0 = m_rctRefVOPY1;
  595. m_rctRefVOPY1 = tmp;
  596. swapVOPU8Pointers (m_pvopcRefQ0,m_pvopcRefQ1);
  597. swapVOPU8Pointers (m_pvopcRefQ1,pvopcUpSampled);
  598. m_pvopcRefQ0->setBoundRct(m_rctRefVOPY0);
  599. m_pvopcRefQ1->setBoundRct(m_rctRefVOPY1);
  600. delete pvopcUpSampled;
  601. }
  602. }
  604. Void CVideoObject::swapVOPU8Pointers (CVOPU8YUVBA*& pvopc0, CVOPU8YUVBA*& pvopc1)
  605. {
  606. CVOPU8YUVBA* pvopcTmp = pvopc0;
  607. pvopc0 = pvopc1;
  608. pvopc1 = pvopcTmp;
  609. }
  611. Void CVideoObject::swapVOPIntPointers (CVOPIntYUVBA*& pvopi0, CVOPIntYUVBA*& pvopi1)
  612. {
  613. CVOPIntYUVBA* pvopiTmp = pvopi0;
  614. pvopi0 = pvopi1;
  615. pvopi1 = pvopiTmp;
  616. }
  618. Void CVideoObject::setRefStartingPointers ()
  619. {
  620. m_iStartInRefToCurrRctY = m_rctRefFrameY.offset (m_rctCurrVOPY.left, m_rctCurrVOPY.top);
  621. m_iStartInRefToCurrRctUV = m_rctRefFrameUV.offset (m_rctCurrVOPUV.left, m_rctCurrVOPUV.top);
  622. }
  624. const CVOPU8YUVBA* CVideoObject::pvopcReconCurr () const
  625. {
  626. if (m_vopmd.vopPredType == SPRITE && m_iNumOfPnts > 0)
  627. return m_pvopcCurrQ;
  628. else if (m_vopmd.vopPredType == SPRITE && m_iNumOfPnts == 0) {
  629. if (m_sptMode != BASIC_SPRITE) 
  630. return m_pvopcSptQ;
  631. else 
  632. return m_pvopcRefQ1;
  633. }
  634. else if ((m_vopmd.vopPredType == BVOP && m_volmd.volType == BASE_LAYER) 
  635.  ||(m_vopmd.vopPredType == BVOP && m_vopmd.iRefSelectCode != 0))
  636. return m_pvopcCurrQ;
  637. else
  638. return m_pvopcRefQ1;
  639. }
  640. ////////// 97/12/22 start
  641. Void CVideoObject::compute_bfShapeMembers ()
  642. {
  643. m_iVOPWidthY = m_rctCurrVOPY.width;
  644. m_iVOPWidthUV = m_rctCurrVOPUV.width;
  645. m_iNumMBX = m_iVOPWidthY / MB_SIZE; 
  646. m_iNumMBY = m_rctCurrVOPY.height () / MB_SIZE;
  647. m_iNumMB = m_iNumMBX * m_iNumMBY;
  648. // m_iNumOfTotalMVPerRow = 5 * m_iNumMBX;
  649. //  wchen: changed to const as discussed with Bob.
  650. m_iNumOfTotalMVPerRow = PVOP_MV_PER_REF_PER_MB * m_iNumMBX;
  651. }
  653. Void CVideoObject::copyVOPU8YUVBA(CVOPU8YUVBA*& pvopc0, CVOPU8YUVBA*& pvopc1)
  654. {
  655. delete pvopc0;  pvopc0 = NULL;
  656. pvopc0 = new CVOPU8YUVBA (*pvopc1); /* i.e. pvopc0 = pvopc1; */
  657. }
  659. Void CVideoObject::copyVOPU8YUVBA(CVOPU8YUVBA*& pvopc0, CVOPU8YUVBA*& pvopc1, CVOPU8YUVBA*& pvopc2)
  660. {
  661. delete pvopc0;  pvopc0 = NULL;
  662. pvopc0 = (pvopc1 != NULL) ?
  663. new CVOPU8YUVBA (*pvopc1) : new CVOPU8YUVBA (*pvopc2);
  664. }
  665. ///// 97/12/22 end
  667. Void dumpNonCodedFrame(FILE* pfYUV, FILE* pfSeg, CRct& rct, UInt nBits)
  668. {
  669. Int iW = rct.width;
  670. Int iH = rct.height();
  671. Int i;
  672. PixelC pxlcVal = 1<<(nBits-1);
  674. PixelC *ppxlcPix = new PixelC [iW];
  676. pxlcmemset(ppxlcPix, pxlcVal, iW);
  677. for(i=0; i<iH; i++) // Y
  678. fwrite(ppxlcPix, sizeof(PixelC), iW, pfYUV);
  679. for(i=0; i<iH; i++) // UV
  680. fwrite(ppxlcPix, sizeof(PixelC), iW>>1, pfYUV);
  681. if(pfSeg!=NULL)
  682. {
  683. pxlcmemset(ppxlcPix, 0, iW);
  684. for(i=0; i<iH; i++) // A
  685. fwrite(ppxlcPix, sizeof(PixelC), iW, pfSeg);
  686. }
  688. delete ppxlcPix;
  689. }
  692. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  694. Void CVideoObject::boundaryMacroBlockMerge (CMBMode* pmbmd)
  695. {
  696.         if ((pmbmd->m_rgTranspStatus[1] & pmbmd->m_rgTranspStatus[2]) == PARTIAL) {
  697.                 pmbmd->m_bMerged[1] = checkMergedStatus (7, 8, 7, 0);
  698.                 if (pmbmd->m_bMerged[1]) {
  699.                         pmbmd->m_rgTranspStatusBBM[2] = ALL;
  700.                         overlayBlocks (7, 8, 7, 0, pmbmd->m_dctMd);
  701.                 }
  702.         }
  703.         if ((pmbmd->m_rgTranspStatus[3] & pmbmd->m_rgTranspStatus[4]) == PARTIAL) {
  704.                 pmbmd->m_bMerged[2] = checkMergedStatus (7, 8, 15, 8);
  705.                 if (pmbmd->m_bMerged[2]) {
  706.                         pmbmd->m_rgTranspStatusBBM[4] = ALL;
  707.                         overlayBlocks (7, 8, 15, 8, pmbmd->m_dctMd);
  708.                 }
  709.         }
  710.         if (pmbmd->m_bMerged[1] | pmbmd->m_bMerged[2]) goto MERGE;
  711.         else {
  712.                 if ((pmbmd->m_rgTranspStatus[1] & pmbmd->m_rgTranspStatus[3]) == PARTIAL) {
  713.                         pmbmd->m_bMerged[3] = checkMergedStatus (7, 0, 7, 8);
  714.                         if (pmbmd->m_bMerged[3]) {
  715.                                 pmbmd->m_rgTranspStatusBBM[3] = ALL;
  716.                                 overlayBlocks (7, 0, 7, 8, pmbmd->m_dctMd);
  717.                         }
  718.                 }
  719.                 if ((pmbmd->m_rgTranspStatus[2] & pmbmd->m_rgTranspStatus[4]) == PARTIAL) {
  720.                         pmbmd->m_bMerged[4] = checkMergedStatus (15, 8, 7, 8);
  721.                         if (pmbmd->m_bMerged[4]) {
  722.                                 pmbmd->m_rgTranspStatusBBM[4] = ALL;
  723.                                 overlayBlocks (15, 8, 7, 8, pmbmd->m_dctMd);
  724.                         }
  725.                 }
  726.                 if (pmbmd->m_bMerged[3] | pmbmd->m_bMerged[4]) goto MERGE;
  727.                 else {
  728.                         if ((pmbmd->m_rgTranspStatus[1] & pmbmd->m_rgTranspStatus[4]) == PARTIAL) {
  729.                                 pmbmd->m_bMerged[5] = checkMergedStatus (7, 8, 7, 8);
  730.                                 if (pmbmd->m_bMerged[5]) {
  731.                                         pmbmd->m_rgTranspStatusBBM[4] = ALL;
  732.                                         overlayBlocks (7, 8, 7, 8, pmbmd->m_dctMd);
  733.                                 }
  734.                         }
  735.                         if ((pmbmd->m_rgTranspStatus[2] & pmbmd->m_rgTranspStatus[3]) == PARTIAL) {
  736.                                 pmbmd->m_bMerged[6] = checkMergedStatus (15, 0, 7, 8);
  737.                                 if (pmbmd->m_bMerged[6]) {
  738.                                         pmbmd->m_rgTranspStatusBBM[3] = ALL;
  739.                                         overlayBlocks (15, 0, 7, 8, pmbmd->m_dctMd);
  740.                                 }
  741.                         }
  742.                 }
  743.         }
  744. MERGE:
  745.         for (UInt x=1; x<7; x++)
  746.                 pmbmd->m_bMerged[0] |= pmbmd->m_bMerged[x];
  747.         if (pmbmd->m_bMerged[0])
  748.                 swapTransparentModes (pmbmd, BBM);
  749. }
  751. Void CVideoObject::isBoundaryMacroBlockMerged (CMBMode* pmbmd)
  752. {
  753.         if ((pmbmd->m_rgTranspStatus[1] & pmbmd->m_rgTranspStatus[2]) == PARTIAL) {
  754.                 pmbmd->m_bMerged[1] = checkMergedStatus (7, 8, 7, 0);
  755.                 if (pmbmd->m_bMerged[1])
  756.                         pmbmd->m_rgTranspStatusBBM[2] = ALL;
  757.         }
  758.         if ((pmbmd->m_rgTranspStatus[3] & pmbmd->m_rgTranspStatus[4]) == PARTIAL) {
  759.                 pmbmd->m_bMerged[2] = checkMergedStatus (7, 8, 15, 8);
  760.                 if (pmbmd->m_bMerged[2])
  761.                         pmbmd->m_rgTranspStatusBBM[4] = ALL;
  762.         }
  763.         if (pmbmd->m_bMerged[1] | pmbmd->m_bMerged[2]) goto MERGE;
  764.         else {
  765.                 if ((pmbmd->m_rgTranspStatus[1] & pmbmd->m_rgTranspStatus[3]) == PARTIAL) {
  766.                         pmbmd->m_bMerged[3] = checkMergedStatus (7, 0, 7, 8);
  767.                         if (pmbmd->m_bMerged[3])
  768.                                 pmbmd->m_rgTranspStatusBBM[3] = ALL;
  769.                 }
  770.                 if ((pmbmd->m_rgTranspStatus[2] & pmbmd->m_rgTranspStatus[4]) == PARTIAL) {
  771.                         pmbmd->m_bMerged[4] = checkMergedStatus (15, 8, 7, 8);
  772.                         if (pmbmd->m_bMerged[4])
  773.                                 pmbmd->m_rgTranspStatusBBM[4] = ALL;
  774.                 }
  775.                 if (pmbmd->m_bMerged[3] | pmbmd->m_bMerged[4]) goto MERGE;
  776.                 else {
  777.                         if ((pmbmd->m_rgTranspStatus[1] & pmbmd->m_rgTranspStatus[4]) == PARTIAL) {
  778.                                 pmbmd->m_bMerged[5] = checkMergedStatus (7, 8, 7, 8);
  779.                                 if (pmbmd->m_bMerged[5])
  780.                                         pmbmd->m_rgTranspStatusBBM[4] = ALL;
  781.                         }
  782.                         if ((pmbmd->m_rgTranspStatus[2] & pmbmd->m_rgTranspStatus[3]) == PARTIAL) {
  783.                                 pmbmd->m_bMerged[6] = checkMergedStatus (15, 0, 7, 8);
  784.                                 if (pmbmd->m_bMerged[6])
  785.                                         pmbmd->m_rgTranspStatusBBM[3] = ALL;
  786.                         }
  787.                 }
  788.         }
  789. MERGE:
  790.         for (UInt x=1; x<7; x++)
  791.                 pmbmd->m_bMerged[0] |= pmbmd->m_bMerged[x];
  792.         if (pmbmd->m_bMerged[0])
  793.                 swapTransparentModes (pmbmd, BBM);
  794. }
  796. Void CVideoObject::isBoundaryMacroBlockMerged (CMBMode* pmbmd, PixelC* ppxlcBY)
  797. {
  798.         if ((pmbmd->m_rgTranspStatus[1] & pmbmd->m_rgTranspStatus[2]) == PARTIAL) {
  799.                 pmbmd->m_bMerged[1] = checkMergedStatus (7, 8, 7, 0, ppxlcBY);
  800.                 if (pmbmd->m_bMerged[1])
  801.                         pmbmd->m_rgTranspStatusBBM[2] = ALL;
  802.         }
  803.         if ((pmbmd->m_rgTranspStatus[3] & pmbmd->m_rgTranspStatus[4]) == PARTIAL) {
  804.                 pmbmd->m_bMerged[2] = checkMergedStatus (7, 8, 15, 8, ppxlcBY);
  805.                 if (pmbmd->m_bMerged[2])
  806.                         pmbmd->m_rgTranspStatusBBM[4] = ALL;
  807.         }
  808.         if (pmbmd->m_bMerged[1] | pmbmd->m_bMerged[2]) goto MERGE;
  809.         else {
  810.                 if ((pmbmd->m_rgTranspStatus[1] & pmbmd->m_rgTranspStatus[3]) == PARTIAL) {
  811.                         pmbmd->m_bMerged[3] = checkMergedStatus (7, 0, 7, 8, ppxlcBY);
  812.                         if (pmbmd->m_bMerged[3])
  813.                                 pmbmd->m_rgTranspStatusBBM[3] = ALL;
  814.                 }
  815.                 if ((pmbmd->m_rgTranspStatus[2] & pmbmd->m_rgTranspStatus[4]) == PARTIAL) {
  816.                         pmbmd->m_bMerged[4] = checkMergedStatus (15, 8, 7, 8, ppxlcBY);
  817.                         if (pmbmd->m_bMerged[4])
  818.                                 pmbmd->m_rgTranspStatusBBM[4] = ALL;
  819.                 }
  820.                 if (pmbmd->m_bMerged[3] | pmbmd->m_bMerged[4]) goto MERGE;
  821.                 else {
  822.                         if ((pmbmd->m_rgTranspStatus[1] & pmbmd->m_rgTranspStatus[4]) == PARTIAL) {
  823.                                 pmbmd->m_bMerged[5] = checkMergedStatus (7, 8, 7, 8, ppxlcBY);
  824.                                 if (pmbmd->m_bMerged[5])
  825.                                         pmbmd->m_rgTranspStatusBBM[4] = ALL;
  826.                         }
  827.                         if ((pmbmd->m_rgTranspStatus[2] & pmbmd->m_rgTranspStatus[3]) == PARTIAL) {
  828.                                 pmbmd->m_bMerged[6] = checkMergedStatus (15, 0, 7, 8, ppxlcBY);
  829.                                 if (pmbmd->m_bMerged[6])
  830.                                         pmbmd->m_rgTranspStatusBBM[3] = ALL;
  831.                         }
  832.                 }
  833.         }
  834. MERGE: 
  835.         for (UInt x=1; x<7; x++)
  836.                 pmbmd->m_bMerged[0] |= pmbmd->m_bMerged[x];
  837.         if (pmbmd->m_bMerged[0])
  838.                 swapTransparentModes (pmbmd, BBM);
  839. }
  841. Void CVideoObject::overlayBlocks (UInt x1, UInt x2, UInt y1, UInt y2, DCTMode dctMd)
  842. {
  843.         UInt    pos1 = y1*MB_SIZE+x1,
  844.                 pos2 = y2*MB_SIZE+x2;
  845.         PixelC  *SB1 = m_ppxlcCurrMBBY+pos1,
  846.                 *SB2 = m_ppxlcCurrMBBY+pos2;
  847.  
  848.         if (dctMd == INTRA || dctMd == INTRAQ) {
  849.                 overlayBlocks (SB1, SB2, m_ppxlcCurrMBY+pos1, m_ppxlcCurrMBY+pos2);
  850.                 if (m_volmd.fAUsage == EIGHT_BIT)
  851.                         overlayBlocks (SB1, SB2, m_ppxlcCurrMBA+pos1, m_ppxlcCurrMBA+pos2);
  852.         }
  853.         else {
  854.                 overlayBlocks (SB2, m_ppxliErrorMBY+pos1, m_ppxliErrorMBY+pos2);
  855.                 if (m_volmd.fAUsage == EIGHT_BIT)
  856.                         overlayBlocks (SB2, m_ppxliErrorMBA+pos1, m_ppxliErrorMBA+pos2);
  857.         }
  858. }
  860. Void CVideoObject::overlayBlocks (PixelC* SB1, PixelC* SB2, PixelC* ppxlcB1, PixelC* ppxlcB2)
  861. {
  862.         UInt    x, y;
  863.         PixelC  *ppxlcS1, *ppxlcS2;
  864.  
  865.         for (y = 0, ppxlcS1 = SB1, ppxlcS2 = SB2; y < BLOCK_SIZE; y++) {
  866.                 for (x = 0; x < BLOCK_SIZE; x++, ppxlcS1--, ppxlcS2++, ppxlcB1--, ppxlcB2++)
  867.                         if (*ppxlcS2)
  868.                                 *ppxlcB1 = *ppxlcB2;
  869.                         else if (!*ppxlcS1) {
  870.                                 *ppxlcB1 += *ppxlcB2;
  871.                                 *ppxlcB1 >>= 1;
  872.                         }
  873.                 ppxlcS1 -= BLOCK_SIZE;
  874.                 ppxlcS2 += BLOCK_SIZE;
  875.                 ppxlcB1 -= BLOCK_SIZE;
  876.                 ppxlcB2 += BLOCK_SIZE;
  877.         }
  878. }
  879.  
  880. Void CVideoObject::overlayBlocks (PixelC* SB2, PixelI* ppxlcB1, PixelI* ppxlcB2)
  881. {
  882.         UInt    x, y;
  883.         PixelC  *ppxlcS2;
  884.  
  885.         for (y = 0, ppxlcS2 = SB2; y < BLOCK_SIZE; y++) {
  886.                 for (x = 0; x < BLOCK_SIZE; x++, ppxlcS2++, ppxlcB1--, ppxlcB2++)
  887.                         if (*ppxlcS2)
  888.                                 *ppxlcB1 = *ppxlcB2;
  889.                 ppxlcS2 += BLOCK_SIZE;
  890.                 ppxlcB1 -= BLOCK_SIZE;
  891.                 ppxlcB2 += BLOCK_SIZE;
  892.         }
  893. }
  895. Bool CVideoObject::checkMergedStatus (UInt x1, UInt x2, UInt y1, UInt y2)
  896. {
  897.         PixelC  *ppxlcS1 = m_ppxlcCurrMBBY + y1 * MB_SIZE + x1,
  898.                 *ppxlcS2 = m_ppxlcCurrMBBY + y2 * MB_SIZE + x2;
  899.  
  900.         for (UInt y = 0; y < BLOCK_SIZE; y++) {
  901.                 for (UInt x = 0; x < BLOCK_SIZE; x++, ppxlcS1--, ppxlcS2++)
  902.                         if (*ppxlcS1 && *ppxlcS2)
  903.                                 return FALSE;
  904.                 ppxlcS1 -= BLOCK_SIZE;
  905.                 ppxlcS2 += BLOCK_SIZE;
  906.         }
  907.         return TRUE;
  908. }
  909.  
  910. Bool CVideoObject::checkMergedStatus (UInt x1, UInt x2, UInt y1, UInt y2, PixelC* ppxlcBY)
  911. {
  912.         PixelC  *ppxlcS1 = ppxlcBY + y1 * MB_SIZE + x1,
  913.                 *ppxlcS2 = ppxlcBY + y2 * MB_SIZE + x2;
  914.  
  915.         for (UInt y = 0; y < BLOCK_SIZE; y++) {
  916.                 for (UInt x = 0; x < BLOCK_SIZE; x++, ppxlcS1--, ppxlcS2++)
  917.                         if (*ppxlcS1 && *ppxlcS2)
  918.                                 return FALSE;
  919.                 ppxlcS1 -= BLOCK_SIZE;
  920.                 ppxlcS2 += BLOCK_SIZE;
  921.         }
  922.         return TRUE;
  923. }
  925. Void CVideoObject::mergedMacroBlockSplit (CMBMode* pmbmd, PixelC* ppxlcRefMBY, PixelC* ppxlcRefMBA)
  926. {
  927.         Bool    isIntra = (pmbmd->m_dctMd==INTRA || pmbmd->m_dctMd==INTRAQ) ? TRUE : FALSE;
  928.  
  929.         swapTransparentModes (pmbmd, BBS);
  930.         if (pmbmd->m_bMerged[1])
  931.                 if (isIntra)
  932.                         splitTwoMergedBlocks (7, 8, 7, 0, ppxlcRefMBY, ppxlcRefMBA);
  933.                 else    splitTwoMergedBlocks (7, 8, 7, 0, m_ppxliErrorMBY, m_ppxliErrorMBA);
  934.         if (pmbmd->m_bMerged[2])
  935.                 if (isIntra)
  936.                         splitTwoMergedBlocks (7, 8, 15, 8, ppxlcRefMBY, ppxlcRefMBA);
  937.                 else    splitTwoMergedBlocks (7, 8, 15, 8, m_ppxliErrorMBY, m_ppxliErrorMBA);
  938.         if (pmbmd->m_bMerged[1] || pmbmd->m_bMerged[2]) goto SPLIT;
  939.         else {
  940.                 if (pmbmd->m_bMerged[3])
  941.                         if (isIntra)
  942.                                 splitTwoMergedBlocks (7, 0, 7, 8, ppxlcRefMBY, ppxlcRefMBA);
  943.                         else    splitTwoMergedBlocks (7, 0, 7, 8, m_ppxliErrorMBY, m_ppxliErrorMBA);
  944.                 if (pmbmd->m_bMerged[4])
  945.                         if (isIntra)
  946.                                 splitTwoMergedBlocks (15, 8, 7, 8, ppxlcRefMBY, ppxlcRefMBA);
  947.                         else    splitTwoMergedBlocks (15, 8, 7, 8, m_ppxliErrorMBY, m_ppxliErrorMBA);
  948.                 if (pmbmd->m_bMerged[3] || pmbmd->m_bMerged[4]) goto SPLIT;
  949.                 else {
  950.                         if (pmbmd->m_bMerged[5])
  951.                                 if (isIntra)
  952.                                         splitTwoMergedBlocks (7, 8, 7, 8, ppxlcRefMBY, ppxlcRefMBA);
  953.                                 else    splitTwoMergedBlocks (7, 8, 7, 8, m_ppxliErrorMBY, m_ppxliErrorMBA);
  954.                         if (pmbmd->m_bMerged[6])
  955.                                 if (isIntra)
  956.                                         splitTwoMergedBlocks(15, 0, 7, 8, ppxlcRefMBY, ppxlcRefMBA);
  957.                                 else    splitTwoMergedBlocks (15, 0, 7, 8, m_ppxliErrorMBY, m_ppxliErrorMBA);
  958.                 }
  959.         }
  960. SPLIT:
  961.         return;
  962. }
  964. Void CVideoObject::splitTwoMergedBlocks (UInt x1, UInt x2, UInt y1, UInt y2, PixelC* ppxlcIn1, PixelC* ppxlcIn2)
  965. {
  966.         UInt    SKIP = m_iFrameWidthY - BLOCK_SIZE,
  967.                 pos1 = y1 * m_iFrameWidthY + x1,
  968.                 pos2 = y2 * m_iFrameWidthY + x2,
  969.                 pos3 = y2 * MB_SIZE + x2;
  970.         PixelC  *ppxlcS2, *ppxlcB1, *ppxlcB2;
  971.  
  972.         ppxlcB1 = ppxlcIn1 + pos1;
  973.         ppxlcB2 = ppxlcIn1 + pos2;
  974.         ppxlcS2 = m_ppxlcCurrMBBY + pos3;
  975.         for (UInt y = 0; y < BLOCK_SIZE; y++) {
  976.                 for (UInt x = 0; x < BLOCK_SIZE; x++, ppxlcS2++, ppxlcB1--, ppxlcB2++)
  977.                         if (*ppxlcS2)
  978.                                 *ppxlcB2 = *ppxlcB1;
  979.                 ppxlcS2 += BLOCK_SIZE;
  980.                 ppxlcB1 -= SKIP;
  981.                 ppxlcB2 += SKIP;
  982.         }
  983.         if (m_volmd.fAUsage == EIGHT_BIT) {
  984.                 ppxlcB1 = ppxlcIn2 + pos1;
  985.                 ppxlcB2 = ppxlcIn2 + pos2;
  986.                 ppxlcS2 = m_ppxlcCurrMBBY + pos3;
  987.                 for (UInt y = 0; y < BLOCK_SIZE; y++) {
  988.                         for (UInt x = 0; x < BLOCK_SIZE; x++, ppxlcS2++, ppxlcB1--, ppxlcB2++)
  989.                                 if (*ppxlcS2)
  990.                                         *ppxlcB2 = *ppxlcB1;
  991.                         ppxlcS2 += BLOCK_SIZE;
  992.                         ppxlcB1 -= SKIP;
  993.                         ppxlcB2 += SKIP;
  994.                 }
  995.         }
  996. }
  998. Void CVideoObject::splitTwoMergedBlocks (UInt x1, UInt x2, UInt y1, UInt y2, PixelI* ppxlcIn1, PixelI* ppxlcIn2)
  999. {
  1000.         UInt    pos1 = y1 * MB_SIZE + x1,
  1001.                 pos2 = y2 * MB_SIZE + x2;
  1002.         PixelC  *ppxlcS2;
  1003.         PixelI  *ppxlcB1, *ppxlcB2;
  1004.  
  1005.         ppxlcB1 = ppxlcIn1 + pos1;
  1006.         ppxlcB2 = ppxlcIn1 + pos2;
  1007.         ppxlcS2 = m_ppxlcCurrMBBY + pos2;
  1008.         for (UInt y = 0; y < BLOCK_SIZE; y++) {
  1009.                 for (UInt x = 0; x < BLOCK_SIZE; x++, ppxlcS2++, ppxlcB1--, ppxlcB2++)
  1010.                         if (*ppxlcS2)
  1011.                                 *ppxlcB2 = *ppxlcB1;
  1012.                 ppxlcS2 += BLOCK_SIZE;
  1013.                 ppxlcB1 -= BLOCK_SIZE;
  1014.                 ppxlcB2 += BLOCK_SIZE;
  1015.         }
  1016.         if (m_volmd.fAUsage == EIGHT_BIT) {
  1017.                 ppxlcB1 = ppxlcIn2 + pos1;
  1018.                 ppxlcB2 = ppxlcIn2 + pos2;
  1019.                 ppxlcS2 = m_ppxlcCurrMBBY + pos2;
  1020.                 for (UInt y = 0; y < BLOCK_SIZE; y++) {
  1021.                         for (UInt x = 0; x < BLOCK_SIZE; x++, ppxlcS2++, ppxlcB1--, ppxlcB2++)
  1022.                                 if (*ppxlcS2)
  1023.                                         *ppxlcB2 = *ppxlcB1;
  1024.                         ppxlcS2 += BLOCK_SIZE;
  1025.                         ppxlcB1 -= BLOCK_SIZE;
  1026.                         ppxlcB2 += BLOCK_SIZE;
  1027.                 }
  1028.         }
  1029. }
  1030.  
  1031. Void CVideoObject::swapTransparentModes (CMBMode* pmbmd, Bool mode) {
  1032.         TransparentStatus rgTranspStatusTmp[5];
  1033.         memcpy (rgTranspStatusTmp, pmbmd->m_rgTranspStatusBBM, 5*sizeof(TransparentStatus));
  1034.         memcpy (pmbmd->m_rgTranspStatusBBM, pmbmd->m_rgTranspStatus, 5*sizeof(TransparentStatus));
  1035.         memcpy (pmbmd->m_rgTranspStatus, rgTranspStatusTmp, 5*sizeof(TransparentStatus));
  1036. }
  1037.  
  1038. Void CVideoObject::setMergedTransparentModes (CMBMode* pmbmd) {
  1039.         memcpy (pmbmd->m_rgTranspStatusBBM, pmbmd->m_rgTranspStatus, 11*sizeof(TransparentStatus));
  1040. }
  1041.  
  1042. Void CVideoObject::initMergedMode (CMBMode* pmbmd) {
  1043.         setMergedTransparentModes (pmbmd);
  1044.         memset (pmbmd->m_bMerged, FALSE, 7*sizeof (Bool));
  1045. }
  1047. // End of Hyundai(1998-5-9)*/