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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

mcpad.cpp：源码内容
  1. /*************************************************************************
  3. This software module was originally developed by 
  5. Ming-Chieh Lee (mingcl@microsoft.com), Microsoft Corporation
  6. Simon Winder (swinder@microsoft.com), Microsoft Corporation
  7. (date: June, 1997)
  8. and edited by
  9.         Wei Wu (weiwu@stallion.risc.rockwell.com) Rockwell Science Center
  11. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  12. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  13. as specified by the MPEG-4 Video. 
  14. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  15. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  16. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
  17. The original developer of this software module and his/her company, 
  18. the subsequent editors and their companies, 
  19. and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
  20. Copyright is not released for non MPEG-4 Video conforming products. 
  21. Microsoft retains full right to use the code for his/her own purpose, 
  22. assign or donate the code to a third party and to inhibit third parties from using the code for non MPEG-4 Video conforming products. 
  23. This copyright notice must be included in all copies or derivative works. 
  25. Copyright (c) 1996, 1997.
  28. Module Name:
  30. mcPad.cpp
  32. Abstract:
  34. MB Padding (for motion estimation and compensation).
  36. Revision History:
  37.         May. 9   1998:  add field based MC padding  by Hyundai Electronics
  38.                                   Cheol-Soo Park (cspark@super5.hyundai.co.kr)
  40. *************************************************************************/
  42. #include "typeapi.h"
  43. #include "codehead.h"
  44. #include "mode.hpp"
  45. #include "vopses.hpp"
  47. // size of image for ppxlcAlphaBase is (uiBlkSize X uiBlkSize)
  50. #define invalidColour -1
  52. // Added for field based MC padding by Hyundai(1998-5-9)
  53. #define MB_FIELDY       1
  54. #define MB_FIELDC       3
  55. // End of Hyundai(1998-5-9)
  57. Void CVideoObject::mcPadCurrMB (
  58. PixelC* ppxlcRefMBY, 
  59. PixelC* ppxlcRefMBU, PixelC* ppxlcRefMBV,
  60. PixelC* ppxlcRefMBA 
  61. )
  62. {
  63. mcPadCurr (ppxlcRefMBY, m_ppxlcCurrMBBY, MB_SIZE, m_iFrameWidthY);
  64. mcPadCurr (ppxlcRefMBU, m_ppxlcCurrMBBUV, BLOCK_SIZE, m_iFrameWidthUV);
  65. mcPadCurr (ppxlcRefMBV, m_ppxlcCurrMBBUV, BLOCK_SIZE, m_iFrameWidthUV);
  66. if (m_volmd.fAUsage == EIGHT_BIT)
  67. mcPadCurr (ppxlcRefMBA, m_ppxlcCurrMBBY, MB_SIZE, m_iFrameWidthY);
  68. }
  70. Void CVideoObject::mcPadCurr (
  71. PixelC *ppxlcTextureBase, // (uiStride X ???)
  72. const PixelC *ppxlcAlphaBase, // uiBlkSize X uiBlkSize
  73. UInt uiBlkSize, UInt uiStride
  74. )
  75. {
  76. Int iUnit = sizeof(PixelC); // NBIT: memcpy
  77. CoordI iX,iY,iJ,iLeftX = 0;
  78. Bool bEmptyRow = FALSE;
  79. Bool bInVop;
  80. Int iLeftColour;
  82. PixelC *ppxlcTexture = ppxlcTextureBase;
  83. const PixelC *ppxlcAlpha = ppxlcAlphaBase;
  85. for (iY=0; iY < (CoordI) uiBlkSize; iY++, ppxlcTexture+=uiStride)
  86.     {
  87. bInVop = TRUE;
  88. iLeftColour = invalidColour;
  89. m_pbEmptyRowArray[iY]=0;
  91. for(iX=0;iX<(CoordI)uiBlkSize;iX++,ppxlcAlpha++)
  92. {
  93. if(bInVop==TRUE && *ppxlcAlpha==transpValue)
  94.     {
  95. // start of stripe or left border 
  96. bInVop=FALSE;
  97. iLeftX=iX;
  98. if(iX>0)
  99. iLeftColour=ppxlcTexture[iLeftX-1];
  100.     }
  101. else if(bInVop==FALSE && *ppxlcAlpha!=transpValue)
  102.     {
  103. // end of stripe not right border 
  104. bInVop=TRUE;
  105. if(iLeftColour==invalidColour)
  106. iLeftColour=ppxlcTexture[iX];
  107. else
  108. iLeftColour=(iLeftColour+ppxlcTexture[iX]+1)>>1;
  110. // fill stripe 
  111. for(iJ=iLeftX;iJ<iX;iJ++)
  112. ppxlcTexture[iJ]=(PixelC)iLeftColour;
  113.     }
  114. }
  116.         if(bInVop==FALSE)
  117. {
  118. // end of stripe at right border 
  119. if(iLeftX==0)
  120. {
  121. // blank stripe so mark
  122. m_pbEmptyRowArray[iY]=TRUE;
  123. bEmptyRow=TRUE;
  124. }
  125. else
  126.         {
  127. // fill trailing stripe 
  128.             for(iJ=iLeftX;iJ<iX;iJ++)
  129. ppxlcTexture[iJ]=(PixelC)iLeftColour;       
  130.         }
  131.       }
  132.     }
  134. // fill remaining holes 
  135. if(bEmptyRow)
  136. {
  137. ppxlcTexture=ppxlcTextureBase;
  138. PixelC *ppxlcUpperRow = NULL;
  139. for(iY=0;iY<(CoordI)uiBlkSize;iY++,ppxlcTexture+=uiStride)
  140. if(!m_pbEmptyRowArray[iY])
  141. ppxlcUpperRow = ppxlcTexture;
  142. else
  143. {
  144. // empty row, find lower row
  145. PixelC *ppxlcLowerRow = ppxlcTexture+uiStride;
  146. CoordI iYY;
  147. for(iYY=iY+1;iYY<(CoordI)uiBlkSize;iYY++,ppxlcLowerRow+=uiStride)
  148. if(!m_pbEmptyRowArray[iYY])
  149. break;
  150. if(iYY<(CoordI)uiBlkSize)
  151. {
  152. if(ppxlcUpperRow==NULL)
  153. {
  154. // just lower row
  155. for(;ppxlcTexture<ppxlcLowerRow;ppxlcTexture+=uiStride)
  156. memcpy(ppxlcTexture,ppxlcLowerRow,uiBlkSize*iUnit);
  157. }
  158. else
  159. {
  160. // lower row, upper row
  161. for(;ppxlcTexture<ppxlcLowerRow;ppxlcTexture+=uiStride)
  162. for(iX=0;iX<(CoordI)uiBlkSize;iX++)
  163. ppxlcTexture[iX]=
  164. (ppxlcUpperRow[iX]+ppxlcLowerRow[iX]+1)>>1;
  165. }
  166. }
  167. else
  168. {
  169. // just upper row
  170. assert(ppxlcUpperRow!=NULL);
  171. for(iYY=iY;iYY<(CoordI)uiBlkSize;iYY++,ppxlcTexture+=uiStride)
  172. memcpy(ppxlcTexture,ppxlcUpperRow,uiBlkSize*iUnit);
  173. }
  174. iY=iYY-1;
  175. ppxlcTexture -= uiStride;
  176. }
  177. }
  178. }
  180. Void CVideoObject::padNeighborTranspMBs (
  181. CoordI xb, CoordI yb,
  182. CMBMode* pmbmd,
  183. PixelC* ppxlcY, PixelC* ppxlcU, PixelC* ppxlcV, PixelC *ppxlcA
  184. )
  185. {
  186. if (xb > 0) {
  187. if ((pmbmd - 1)->m_rgTranspStatus [0] == ALL) {
  188. if (!((pmbmd - 1)->m_bPadded)) {
  189. mcPadLeftMB (ppxlcY, ppxlcU, ppxlcV, ppxlcA);
  190. (pmbmd - 1)->m_bPadded = TRUE;
  191. }
  192. }
  193. }
  194. if (yb > 0) {
  195. if ((pmbmd - m_iNumMBX)->m_rgTranspStatus [0] == ALL) {
  196. if (!((pmbmd - m_iNumMBX)->m_bPadded)) {
  197. mcPadTopMB (ppxlcY, ppxlcU, ppxlcV, ppxlcA);
  198. (pmbmd - m_iNumMBX)->m_bPadded = TRUE;
  199. }
  200. }
  201. }
  202. }
  204. Void CVideoObject::padCurrAndTopTranspMBFromNeighbor (
  205. CoordI xb, CoordI yb,
  206. CMBMode* pmbmd,
  207. PixelC* ppxlcY, PixelC* ppxlcU, PixelC* ppxlcV, PixelC* ppxlcA
  208. )
  209. {
  210. if (xb > 0) {
  211. if ((pmbmd - 1)->m_rgTranspStatus [0] != ALL) {
  212. mcPadCurrMBFromLeft (ppxlcY, ppxlcU, ppxlcV, ppxlcA);
  213. pmbmd->m_bPadded = TRUE;
  214. }
  215. }
  216. if (yb > 0) {
  217. if ((pmbmd - m_iNumMBX)->m_rgTranspStatus [0] != ALL) {
  218. if (!(pmbmd->m_bPadded)) {
  219. mcPadCurrMBFromTop (ppxlcY, ppxlcU, ppxlcV, ppxlcA);
  220. pmbmd->m_bPadded = TRUE;
  221. }
  222. }
  223. else
  224. if (!(pmbmd - m_iNumMBX)->m_bPadded)
  225. mcSetTopMBGray (ppxlcY, ppxlcU, ppxlcV, ppxlcA);
  226. }
  227. if(yb == m_iNumMBY-1)
  228. {
  229. if(xb > 0 && (pmbmd-1)->m_rgTranspStatus [0] == ALL && !((pmbmd-1)->m_bPadded))
  230. mcSetLeftMBGray(ppxlcY, ppxlcU, ppxlcV, ppxlcA);
  231. if(xb == m_iNumMBX-1 && !(pmbmd->m_bPadded))
  232. mcSetCurrMBGray(ppxlcY, ppxlcU, ppxlcV, ppxlcA);
  233. }
  234. }
  237. Void CVideoObject::mcPadLeftMB (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC* ppxlcMBA)
  238. {
  239. UInt iy;
  240. for (iy = 0; iy < BLOCK_SIZE; iy++) {
  241. pxlcmemset (ppxlcMBY - MB_SIZE, *ppxlcMBY, MB_SIZE);
  242. pxlcmemset (ppxlcMBU - BLOCK_SIZE, *ppxlcMBU, BLOCK_SIZE);
  243. pxlcmemset (ppxlcMBV - BLOCK_SIZE, *ppxlcMBV, BLOCK_SIZE);
  244. ppxlcMBY += m_iFrameWidthY;
  245. ppxlcMBU += m_iFrameWidthUV;
  246. ppxlcMBV += m_iFrameWidthUV;
  248. pxlcmemset (ppxlcMBY - MB_SIZE, *ppxlcMBY, MB_SIZE);
  249. ppxlcMBY += m_iFrameWidthY;
  250. }
  251. if(m_volmd.fAUsage == EIGHT_BIT)
  252. for (iy = 0; iy < BLOCK_SIZE; iy++) {
  253. pxlcmemset (ppxlcMBA - MB_SIZE, *ppxlcMBA, MB_SIZE);
  254. ppxlcMBA += m_iFrameWidthY;
  255. pxlcmemset (ppxlcMBA - MB_SIZE, *ppxlcMBA, MB_SIZE);
  256. ppxlcMBA += m_iFrameWidthY;
  257. }
  258. }
  260. Void CVideoObject::mcPadTopMB (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC* ppxlcMBA)
  261. {
  262. UInt ix, iy;
  263. for (ix = 0; ix < MB_SIZE; ix++) {
  264. PixelC* ppxlcYCol = ppxlcMBY;
  265. for (iy = 0; iy < MB_SIZE; iy++) {
  266. ppxlcYCol -= m_iFrameWidthY;
  267. *ppxlcYCol = *ppxlcMBY;
  268. }
  269. ppxlcMBY++;
  270. }
  272. for (ix = 0; ix < BLOCK_SIZE; ix++) {
  273. PixelC* ppxlcUCol = ppxlcMBU;
  274. PixelC* ppxlcVCol = ppxlcMBV;
  275. for (iy = 0; iy < BLOCK_SIZE; iy++) {
  276. ppxlcUCol -= m_iFrameWidthUV;
  277. ppxlcVCol -= m_iFrameWidthUV;
  278. *ppxlcUCol = *ppxlcMBU;
  279. *ppxlcVCol = *ppxlcMBV;
  280. }
  281. ppxlcMBU++;
  282. ppxlcMBV++;
  283. }
  284. if(m_volmd.fAUsage == EIGHT_BIT)
  285. for (ix = 0; ix < MB_SIZE; ix++) {
  286. PixelC* ppxlcACol = ppxlcMBA;
  287. for (iy = 0; iy < MB_SIZE; iy++) {
  288. ppxlcACol -= m_iFrameWidthY;
  289. *ppxlcACol = *ppxlcMBA;
  290. }
  291. ppxlcMBA++;
  292. }
  293. }
  295. Void CVideoObject::mcPadCurrMBFromLeft (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC* ppxlcMBA)
  296. {
  297. UInt iy;
  298. for (iy = 0; iy < BLOCK_SIZE; iy++) {
  299. pxlcmemset (ppxlcMBY, *(ppxlcMBY - 1), MB_SIZE);
  300. pxlcmemset (ppxlcMBU, *(ppxlcMBU - 1), BLOCK_SIZE);
  301. pxlcmemset (ppxlcMBV, *(ppxlcMBV - 1), BLOCK_SIZE);
  302. ppxlcMBY += m_iFrameWidthY;
  303. ppxlcMBU += m_iFrameWidthUV;
  304. ppxlcMBV += m_iFrameWidthUV;
  306. pxlcmemset (ppxlcMBY, *(ppxlcMBY - 1), MB_SIZE);
  307. ppxlcMBY += m_iFrameWidthY;
  308. }
  309. if(m_volmd.fAUsage == EIGHT_BIT)
  310. for (iy = 0; iy < BLOCK_SIZE; iy++) {
  311. pxlcmemset (ppxlcMBA, *(ppxlcMBA - 1), MB_SIZE);
  312. ppxlcMBA += m_iFrameWidthY;
  313. pxlcmemset (ppxlcMBA, *(ppxlcMBA - 1), MB_SIZE);
  314. ppxlcMBA += m_iFrameWidthY;
  315. }
  316. }
  318. Void CVideoObject::mcPadCurrMBFromTop (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC* ppxlcMBA)
  319. {
  320. UInt ix, iy;
  321. for (ix = 0; ix < MB_SIZE; ix++) {
  322. PixelC* ppxlcYCol = ppxlcMBY;
  323. PixelC pxlcY = *(ppxlcMBY - m_iFrameWidthY);
  324. for (iy = 0; iy < MB_SIZE; iy++) {
  325. *ppxlcYCol = pxlcY;
  326. ppxlcYCol += m_iFrameWidthY;
  327. }
  328. ppxlcMBY++;
  329. }
  331. for (ix = 0; ix < BLOCK_SIZE; ix++) {
  332. PixelC* ppxlcUCol = ppxlcMBU;
  333. PixelC* ppxlcVCol = ppxlcMBV;
  334. PixelC pxlcU = *(ppxlcMBU - m_iFrameWidthUV);
  335. PixelC pxlcV = *(ppxlcMBV - m_iFrameWidthUV);
  336. for (iy = 0; iy < BLOCK_SIZE; iy++) {
  337. *ppxlcUCol = pxlcU;
  338. *ppxlcVCol = pxlcV;
  339. ppxlcUCol += m_iFrameWidthUV;
  340. ppxlcVCol += m_iFrameWidthUV;
  341. }
  342. ppxlcMBU++;
  343. ppxlcMBV++;
  344. }
  345. if(m_volmd.fAUsage == EIGHT_BIT)
  346. for (ix = 0; ix < MB_SIZE; ix++) {
  347. PixelC* ppxlcACol = ppxlcMBA;
  348. PixelC pxlcA = *(ppxlcMBA - m_iFrameWidthY);
  349. for (iy = 0; iy < MB_SIZE; iy++) {
  350. *ppxlcACol = pxlcA;
  351. ppxlcACol += m_iFrameWidthY;
  352. }
  353. ppxlcMBA++;
  354. }
  355. }
  357. Void CVideoObject::mcSetTopMBGray (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC* ppxlcMBA)
  358. {
  359. PixelC pxlcGrayVal = 128;
  360. if(m_volmd.bNot8Bit)
  361. pxlcGrayVal = 1<<(m_volmd.nBits-1);
  363. UInt iy;
  364. for (iy = 0; iy < BLOCK_SIZE; iy++) {
  365. ppxlcMBY -= m_iFrameWidthY;
  366. ppxlcMBU -= m_iFrameWidthUV;
  367. ppxlcMBV -= m_iFrameWidthUV;
  368. pxlcmemset (ppxlcMBY, pxlcGrayVal, MB_SIZE);
  369. pxlcmemset (ppxlcMBU, pxlcGrayVal, BLOCK_SIZE);
  370. pxlcmemset (ppxlcMBV, pxlcGrayVal, BLOCK_SIZE);
  372. ppxlcMBY -= m_iFrameWidthY;
  373. pxlcmemset (ppxlcMBY, pxlcGrayVal, MB_SIZE);
  374. }
  375. if(m_volmd.fAUsage == EIGHT_BIT)
  376. for (iy = 0; iy < BLOCK_SIZE; iy++) {
  377. ppxlcMBA -= m_iFrameWidthY;
  378. pxlcmemset (ppxlcMBA, pxlcGrayVal, MB_SIZE);
  379. ppxlcMBA -= m_iFrameWidthY;
  380. pxlcmemset (ppxlcMBA, pxlcGrayVal, MB_SIZE);
  381. }
  382. }
  384. Void CVideoObject::mcSetLeftMBGray (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC* ppxlcMBA)
  385. {
  386. mcSetCurrMBGray(
  387. ppxlcMBY-MB_SIZE,
  388. ppxlcMBU-BLOCK_SIZE,
  389. ppxlcMBV-BLOCK_SIZE,
  390. (m_volmd.fAUsage == EIGHT_BIT) ? ppxlcMBA-MB_SIZE : (PixelC *)NULL
  391. );
  392. }
  394. Void CVideoObject::mcSetCurrMBGray (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC* ppxlcMBA)
  395. {
  396. PixelC pxlcGrayVal = 128;
  397. if(m_volmd.bNot8Bit)
  398. pxlcGrayVal = 1<<(m_volmd.nBits-1);
  399. UInt iy;
  400. for (iy = 0; iy < BLOCK_SIZE; iy++) {
  401. pxlcmemset (ppxlcMBY, pxlcGrayVal, MB_SIZE);
  402. pxlcmemset (ppxlcMBU, pxlcGrayVal, BLOCK_SIZE);
  403. pxlcmemset (ppxlcMBV, pxlcGrayVal, BLOCK_SIZE);
  404. ppxlcMBY += m_iFrameWidthY;
  405. ppxlcMBU += m_iFrameWidthUV;
  406. ppxlcMBV += m_iFrameWidthUV;
  408. pxlcmemset (ppxlcMBY, pxlcGrayVal, MB_SIZE);
  409. ppxlcMBY += m_iFrameWidthY;
  410. }
  411. if(m_volmd.fAUsage == EIGHT_BIT)
  412. for (iy = 0; iy < BLOCK_SIZE; iy++) {
  413. pxlcmemset (ppxlcMBA, pxlcGrayVal, MB_SIZE);
  414. ppxlcMBA += m_iFrameWidthY;
  415. pxlcmemset (ppxlcMBA, pxlcGrayVal, MB_SIZE);
  416. ppxlcMBA += m_iFrameWidthY;
  417. }
  418. }
  420. // Added for field based MC padding by Hyundai(1998-5-9)
  422. Void CVideoObject::fieldBasedMCPadding (CMBMode* pmbmd, CVOPU8YUVBA* pvopcCurrQ)
  423. {
  424.         Int     iMBX, iMBY;
  426.         PixelC* ppxlcCurrY  = (PixelC*) pvopcCurrQ->pixelsY () + m_iStartInRefToCurrRctY;
  427.         PixelC* ppxlcCurrU  = (PixelC*) pvopcCurrQ->pixelsU () + m_iStartInRefToCurrRctUV;
  428.         PixelC* ppxlcCurrV  = (PixelC*) pvopcCurrQ->pixelsV () + m_iStartInRefToCurrRctUV;
  429.         PixelC* ppxlcCurrBY = (PixelC*) pvopcCurrQ->pixelsBY () + m_iStartInRefToCurrRctY;
  430.         PixelC* ppxlcCurrBUV = (PixelC*) pvopcCurrQ->pixelsBUV () + m_iStartInRefToCurrRctUV;
  431. // 12.22.98 begin of changes
  432. PixelC* ppxlcCurrA = NULL;
  433. if (m_volmd.fAUsage == EIGHT_BIT) {
  434. ppxlcCurrA = (PixelC*) pvopcCurrQ->pixelsA () + m_iStartInRefToCurrRctY;
  435. } 
  436. // 12.22.98 end of changes
  437.         for (iMBY = 0; iMBY < m_iNumMBY; iMBY++) {
  438.                 PixelC* ppxlcCurrMBY  = ppxlcCurrY;
  439.                 PixelC* ppxlcCurrMBU  = ppxlcCurrU;
  440.                 PixelC* ppxlcCurrMBV  = ppxlcCurrV;
  441.                 PixelC* ppxlcCurrMBBY = ppxlcCurrBY;
  442.                 PixelC* ppxlcCurrMBBUV = ppxlcCurrBUV;
  443. PixelC* ppxlcCurrMBA = NULL;
  444. // 12.22.98 begin of changes
  445. if (m_volmd.fAUsage == EIGHT_BIT)
  446. ppxlcCurrMBA  = ppxlcCurrA; 
  447. // 12.22.98 end of changes
  448.                 for (iMBX = 0; iMBX < m_iNumMBX; iMBX++) {
  449. memset(pmbmd->m_rgbFieldPadded, 0, 5*sizeof(Bool));
  450.                     fieldBasedDownSampleBY (ppxlcCurrMBBY, ppxlcCurrMBBUV);
  451.                     decideFieldTransparencyStatus (pmbmd, ppxlcCurrMBBY, ppxlcCurrMBBUV);
  452.                     mcPadCurrAndNeighborsMBFields (iMBX, iMBY, pmbmd, ppxlcCurrMBY, ppxlcCurrMBU, ppxlcCurrMBV, ppxlcCurrMBBY, ppxlcCurrMBBUV,ppxlcCurrMBA);
  453.                     ppxlcCurrMBY += MB_SIZE;
  454.                     ppxlcCurrMBU += BLOCK_SIZE;
  455.                     ppxlcCurrMBV += BLOCK_SIZE;
  456.                     ppxlcCurrMBBY += MB_SIZE;
  457.                     ppxlcCurrMBBUV += BLOCK_SIZE;
  458. // 12.22.98 begin of changes
  459. if (m_volmd.fAUsage == EIGHT_BIT)
  460. ppxlcCurrMBA  += MB_SIZE; 
  461. // 12.22.98 end of changes
  462.                     pmbmd++;
  463.                 }
  464.                 ppxlcCurrY += m_iFrameWidthYxMBSize;
  465.                 ppxlcCurrU += m_iFrameWidthUVxBlkSize;
  466.                 ppxlcCurrV += m_iFrameWidthUVxBlkSize;
  467.                 ppxlcCurrBY += m_iFrameWidthYxMBSize;
  468.                 ppxlcCurrBUV += m_iFrameWidthUVxBlkSize;
  469. // 12.22.98 begin of changes
  470. if (m_volmd.fAUsage == EIGHT_BIT)
  471. ppxlcCurrA  += m_iFrameWidthYxMBSize; 
  472. // 12.22.98 end of changes
  473.         }
  474. }
  476. Void CVideoObject::mcPadCurrAndNeighborsMBFields (
  477.         Int     iMBX,
  478.         Int     iMBY,
  479.         CMBMode *pmbmd,
  480.         PixelC* ppxlcRefMBY,
  481.         PixelC* ppxlcRefMBU,
  482.         PixelC* ppxlcRefMBV,
  483.         PixelC* ppxlcRefMBBY,
  484.         PixelC* ppxlcRefMBBUV,
  485. PixelC* ppxlcRefMBA
  486. )
  487. {
  488. // 2.9.99 begin of changes.  X. Chen, 
  489. if (m_volmd.fAUsage == EIGHT_BIT) 
  490. mcPadFieldsCurr (iMBX, iMBY, pmbmd, MB_FIELDY, ppxlcRefMBY, ppxlcRefMBA, ppxlcRefMBBY, MB_SIZE, m_iFrameWidthY);
  491. else
  492. // 2.9.99 end of changes
  493.         mcPadFieldsCurr (iMBX, iMBY, pmbmd, MB_FIELDY, ppxlcRefMBY, NULL, ppxlcRefMBBY, MB_SIZE, m_iFrameWidthY);
  494.         mcPadFieldsCurr (iMBX, iMBY, pmbmd, MB_FIELDC, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBBUV, BLOCK_SIZE, m_iFrameWidthUV);
  495. }
  497. Void CVideoObject::mcPadFieldsCurr (
  498.         Int     iMBX,
  499.         Int     iMBY,
  500.         CMBMode *pmbmd,
  501.         Int     mode,
  502.         PixelC  *ppxlcCurrMB1,
  503.         PixelC  *ppxlcCurrMB2,
  504.         PixelC  *ppxlcCurrMBB,
  505.         Int     uiBlkXSize,
  506.         Int     uiStride
  507. )
  508. {
  509.         PixelC  *ppxlcCurrTopField1 = ppxlcCurrMB1,
  510.                 *ppxlcCurrBotField1 = ppxlcCurrMB1 + uiStride,
  511.                 *ppxlcCurrTopField2 = ((ppxlcCurrMB2) ? ppxlcCurrMB2 : NULL),
  512.                 *ppxlcCurrBotField2 = ((ppxlcCurrMB2) ? ppxlcCurrMB2 + uiStride : NULL),
  513.                 *ppxlcCurrTopFieldB = ppxlcCurrMBB,
  514.                 *ppxlcCurrBotFieldB = ppxlcCurrMBB + uiStride;
  515.  
  516.         if (pmbmd->m_rgFieldTranspStatus [mode] != ALL) {       // Top Field MC Padding
  517.                 if (pmbmd->m_rgFieldTranspStatus [mode] == PARTIAL) {
  518.                         mcPadOneField (ppxlcCurrTopField1, ppxlcCurrTopFieldB, uiBlkXSize, uiStride);
  519.                         if (ppxlcCurrTopField2)
  520.                                 mcPadOneField (ppxlcCurrTopField2, ppxlcCurrTopFieldB, uiBlkXSize, uiStride);
  521.                 }
  522.                 padNeighborTranspMBFields (iMBX, iMBY, pmbmd, mode, ppxlcCurrTopField1, ppxlcCurrTopField2, uiBlkXSize, uiStride);
  523.         } else  padCurrAndTopTranspMBFieldsFromNeighbor (iMBX, iMBY, pmbmd, mode, ppxlcCurrTopField1, ppxlcCurrTopField2, uiBlkXSize, uiStride);
  524.         if (pmbmd->m_rgFieldTranspStatus [mode+1] != ALL) {     // Bottom Field MC Padding
  525.                 if (pmbmd->m_rgFieldTranspStatus [mode+1] == PARTIAL) {
  526.                         mcPadOneField (ppxlcCurrBotField1, ppxlcCurrBotFieldB, uiBlkXSize, uiStride);
  527.                         if (ppxlcCurrBotField2)
  528.                                 mcPadOneField (ppxlcCurrBotField2, ppxlcCurrBotFieldB, uiBlkXSize, uiStride);
  529.                 }
  530.                 padNeighborTranspMBFields (iMBX, iMBY, pmbmd, mode+1, ppxlcCurrBotField1, ppxlcCurrBotField2, uiBlkXSize, uiStride);
  531.         } else  padCurrAndTopTranspMBFieldsFromNeighbor (iMBX, iMBY, pmbmd, mode+1, ppxlcCurrBotField1, ppxlcCurrBotField2, uiBlkXSize, uiStride);
  532. }
  534. Void CVideoObject::mcPadOneField (
  535.         PixelC          *ppxlcTextureBase,
  536.         const PixelC    *ppxlcAlphaBase,
  537.         Int             uiBlkXSize,
  538.         Int             uiStride
  539. )
  540. {
  541.         Int     iUnit = sizeof(PixelC);
  542.         Int     uiBlkYSize = uiBlkXSize/2;
  543.         Int     iFieldSkip = 2*uiStride;
  544.         CoordI  iX,iY,iJ,iLeftX = 0;
  545.         Bool    bEmptyRow = FALSE;
  546.         Bool    bInVop;
  547.         Int     iLeftColour;
  548.          
  549.  
  550.         PixelC  *ppxlcTexture = ppxlcTextureBase;
  551.         for (iY=0;iY<(CoordI)uiBlkYSize;iY++, ppxlcTexture+=iFieldSkip) {
  552.                 bInVop = TRUE;
  553.                 iLeftColour = invalidColour;
  554.                 m_pbEmptyRowArray[iY]=0;
  555.                 const PixelC *ppxlcAlpha = ppxlcAlphaBase;
  556.                 for(iX=0;iX<(CoordI)uiBlkXSize;iX++,ppxlcAlpha++) {
  557.                         if(bInVop==TRUE && *ppxlcAlpha==transpValue) {
  558.                                 bInVop=FALSE;
  559.                                 iLeftX=iX;
  560.                                 if(iX>0)
  561.                                         iLeftColour=ppxlcTexture[iLeftX-1];
  562.                         }
  563.                         else if(bInVop==FALSE && *ppxlcAlpha!=transpValue) {
  564.                                 bInVop=TRUE;
  565.                                 if(iLeftColour==invalidColour)
  566.                                         iLeftColour=ppxlcTexture[iX];
  567.                                 else    iLeftColour=(iLeftColour+ppxlcTexture[iX]+1)>>1;
  568.                                 for(iJ=iLeftX;iJ<iX;iJ++)
  569.                                         ppxlcTexture[iJ]=(PixelC)iLeftColour;
  570.                         }                 
  571.                 }
  572.                 ppxlcAlphaBase += iFieldSkip;
  573.                 if(bInVop==FALSE) {
  574.                         if(iLeftX==0) {
  575.                                 m_pbEmptyRowArray[iY]=TRUE;
  576.                                 bEmptyRow=TRUE;
  577.                         }
  578.                         else {
  579.                                 for(iJ=iLeftX;iJ<iX;iJ++)
  580.                                         ppxlcTexture[iJ]=(PixelC)iLeftColour;
  581.                         }                 
  582.                 }
  583.         }
  584.         if(bEmptyRow) {
  585.                 ppxlcTexture=ppxlcTextureBase;
  586.                 PixelC  *ppxlcUpperRow = NULL;
  587.                 for(iY=0;iY<(CoordI)uiBlkYSize;iY++,ppxlcTexture+=iFieldSkip)
  588.                         if(!m_pbEmptyRowArray[iY])
  589.                                 ppxlcUpperRow = ppxlcTexture;
  590.                         else {
  591.                                 PixelC *ppxlcLowerRow = ppxlcTexture+iFieldSkip;
  592.                                 CoordI iYY;
  593.                                 for(iYY=iY+1;iYY<(CoordI)uiBlkYSize;iYY++,ppxlcLowerRow+=iFieldSkip)
  594.                                         if(!m_pbEmptyRowArray[iYY])
  595.                                                 break;
  596.                                 if(iYY<(CoordI)uiBlkYSize) {
  597.                                         if(ppxlcUpperRow==NULL) {
  598.                                                 for(;ppxlcTexture<ppxlcLowerRow;ppxlcTexture+=iFieldSkip)
  599.                                                         memcpy(ppxlcTexture,ppxlcLowerRow,uiBlkXSize*iUnit);
  600.                                         }
  601.                                         else {
  602.                                                 for(;ppxlcTexture<ppxlcLowerRow;ppxlcTexture+=iFieldSkip)
  603.                                                         for(iX=0;iX<(CoordI)uiBlkXSize;iX++)
  604.                                                                 ppxlcTexture[iX]= (ppxlcUpperRow[iX]+ppxlcLowerRow[iX]+1)>>1;
  605.                                         }
  606.                                 }         
  607.                                 else {
  608.                                         assert(ppxlcUpperRow!=NULL);
  609.                                         for(iYY=iY;iYY<(CoordI)uiBlkYSize;iYY++,ppxlcTexture+=iFieldSkip)
  610.                                                 memcpy(ppxlcTexture,ppxlcUpperRow,uiBlkXSize*iUnit);
  611.                                 }
  612.                                 iY=iYY-1;
  613.                                 ppxlcTexture -= iFieldSkip;
  614.                         }
  615.         }
  616. }
  618. Void CVideoObject::padNeighborTranspMBFields (
  619.         CoordI  xb,
  620.         CoordI  yb,
  621.         CMBMode *pmbmd,
  622.         Int     mode,
  623.         PixelC  *ppxlcMBField1,
  624.         PixelC  *ppxlcMBField2,
  625.         Int     uiBlkXSize,
  626.         Int     uiStride
  627. )
  628. {
  629.         CMBMode* pmbmdLeft = pmbmd - 1;
  630.         CMBMode* pmbmdAbov = pmbmd - m_iNumMBX;
  631.  
  632.         if (xb > 0) {
  633.                 if (pmbmdLeft->m_rgFieldTranspStatus [mode] == ALL)
  634.                         if (!(pmbmdLeft->m_rgbFieldPadded [mode])) {
  635.                                 mcPadLeftMBFields (ppxlcMBField1, ppxlcMBField2, uiBlkXSize, uiStride);
  636.                                 pmbmdLeft->m_rgbFieldPadded[mode] = TRUE;
  637.                         }
  638.         }
  639.         if (yb > 0) {
  640.                 if (pmbmdAbov->m_rgFieldTranspStatus [mode] == ALL)
  641.                         if (!(pmbmdAbov->m_rgbFieldPadded [mode])) {
  642.                                 mcPadTopMBFields (ppxlcMBField1, ppxlcMBField2, uiBlkXSize, uiStride);
  643.                                 pmbmdAbov->m_rgbFieldPadded[mode] = TRUE;
  644.                         }
  645.         }        
  646. }
  648. Void CVideoObject::padCurrAndTopTranspMBFieldsFromNeighbor (
  649.         CoordI  xb,
  650.         CoordI  yb,
  651.         CMBMode *pmbmd,
  652.         Int     mode,
  653.         PixelC* ppxlcMBField1,
  654.         PixelC* ppxlcMBField2,
  655.         Int     uiBlkXSize,
  656.         Int     uiStride
  657. )
  658. {
  659.         CMBMode* pmbmdLeft = pmbmd - 1;
  660.         CMBMode* pmbmdAbov = pmbmd - m_iNumMBX;
  661.  
  662.         if (xb > 0) {
  663.                 if (pmbmdLeft->m_rgFieldTranspStatus [mode] != ALL) {
  664.                         mcPadCurrMBFieldsFromLeft (ppxlcMBField1, ppxlcMBField2, uiBlkXSize, uiStride);
  665.                         pmbmd->m_rgbFieldPadded [mode] = TRUE;
  666.                 }
  667.         }
  668.         if (yb > 0) {
  669.                 if (pmbmdAbov->m_rgFieldTranspStatus [mode] != ALL) {
  670.                         if (!(pmbmd->m_rgbFieldPadded [mode])) {
  671.                                 mcPadCurrMBFieldsFromTop (ppxlcMBField1, ppxlcMBField2, uiBlkXSize, uiStride);
  672.                                 pmbmd->m_rgbFieldPadded [mode] = TRUE;
  673.                         }
  674.                 } else {
  675.                         if (!(pmbmdAbov->m_rgbFieldPadded [mode]))
  676.                                 mcSetTopMBFieldsGray (ppxlcMBField1, ppxlcMBField2, uiBlkXSize, uiStride);
  677.                 }
  678.         }
  679.         if(yb == m_iNumMBY-1) {
  680.                 if(xb > 0 && pmbmdLeft->m_rgFieldTranspStatus [mode] == ALL && !(pmbmdLeft->m_rgbFieldPadded [mode]))
  681.                         mcSetLeftMBFieldsGray (ppxlcMBField1, ppxlcMBField2, uiBlkXSize, uiStride);
  682.                 if(xb == m_iNumMBX-1 && !(pmbmd->m_rgbFieldPadded [mode]))
  683.                         mcSetCurrMBFieldsGray (ppxlcMBField1, ppxlcMBField2, uiBlkXSize, uiStride);
  684.         }
  685. }
  687. Void CVideoObject::mcPadLeftMBFields (
  688.         PixelC* ppxlcMBField1,
  689.         PixelC* ppxlcMBField2,
  690.         Int     uiBlkXSize,
  691.         Int     uiStride
  692. )
  693. {
  694.         UInt    iy, uiBlkYSize = uiBlkXSize/2;
  695.  
  696.         for (iy = 0; iy < uiBlkYSize; iy++) {
  697.                 pxlcmemset (ppxlcMBField1 - uiBlkXSize, *ppxlcMBField1, uiBlkXSize);
  698.                 ppxlcMBField1 += 2*uiStride;
  699.         }
  700.         if (!ppxlcMBField2) return;
  701.         for (iy = 0; iy < uiBlkYSize; iy++) {
  702.                 pxlcmemset (ppxlcMBField2 - uiBlkXSize, *ppxlcMBField2, uiBlkXSize);
  703.                 ppxlcMBField2 += 2*uiStride;
  704.         }
  705. }
  706.  
  707. Void CVideoObject::mcPadTopMBFields (
  708.         PixelC* ppxlcMBField1,
  709.         PixelC* ppxlcMBField2,
  710.         Int     iBlkXSize,
  711.         Int     iStride
  712. )
  713. {
  714.         Int    ix, iy, iBlkYSize = iBlkXSize/2;
  715.  
  716.         for (ix = 0; ix < iBlkXSize; ix++) {
  717.                 PixelC* ppxlcYCol = ppxlcMBField1;
  718.                 for (iy = 0; iy < iBlkYSize; iy++) {
  719.                         ppxlcYCol -= 2*iStride;
  720.                         *ppxlcYCol = *ppxlcMBField1;
  721.                 }
  722.                 ppxlcMBField1++;
  723.         }
  724.         if (!ppxlcMBField2) return;
  725.         for (ix = 0; ix < iBlkXSize; ix++) {
  726.                 PixelC* ppxlcACol = ppxlcMBField2;
  727.                 for (iy = 0; iy < iBlkYSize; iy++) {
  728.                         ppxlcACol -= 2*iStride;
  729.                         *ppxlcACol = *ppxlcMBField2;
  730.                 }
  731.                 ppxlcMBField2++;
  732.         }
  733. }
  735. Void CVideoObject::mcPadCurrMBFieldsFromLeft (
  736.         PixelC* ppxlcMBField1,
  737.         PixelC* ppxlcMBField2,
  738.         Int     uiBlkXSize,
  739.         Int     uiStride)
  740. {
  741.         UInt iy, uiBlkYSize = uiBlkXSize/2;
  743.         for (iy = 0; iy < uiBlkYSize; iy++) {
  744.                 pxlcmemset (ppxlcMBField1, *(ppxlcMBField1 - 1), uiBlkXSize);
  745.                 ppxlcMBField1 += 2*uiStride;
  746.         }
  747.         if (!ppxlcMBField2) return;
  748.         for (iy = 0; iy < uiBlkYSize; iy++) {
  749.                 pxlcmemset (ppxlcMBField2, *(ppxlcMBField2 - 1), uiBlkXSize);
  750.                 ppxlcMBField2 += 2*uiStride;
  751.         }
  752. }
  753.  
  754. Void CVideoObject::mcPadCurrMBFieldsFromTop (
  755.         PixelC* ppxlcMBField1,
  756.         PixelC* ppxlcMBField2,
  757.         Int     iBlkXSize,
  758.         Int     iStride)
  759. {
  760.         Int    ix, iy, iBlkYSize = iBlkXSize/2;
  762.         PixelC  *ppxlcSrcMBField = ppxlcMBField1-2*iStride;
  763.         for (ix = 0; ix < iBlkXSize; ix++) {
  764.                 PixelC* ppxlcDstMBField = ppxlcSrcMBField;
  765.                 for (iy = 0; iy < iBlkYSize; iy++) {
  766.                         ppxlcDstMBField += 2*iStride;
  767.                         *ppxlcDstMBField = *ppxlcSrcMBField;
  768.                 }
  769.                 ppxlcSrcMBField++;
  770.         }
  771.         if(!ppxlcMBField2) return;
  772.         ppxlcSrcMBField = ppxlcMBField2-2*iStride;
  773.         for (ix = 0; ix < iBlkXSize; ix++) {
  774.                 PixelC* ppxlcDstMBField = ppxlcSrcMBField;
  775.                 for (iy = 0; iy < iBlkYSize; iy++) {
  776.                         ppxlcDstMBField += 2*iStride;
  777.                         *ppxlcDstMBField = *ppxlcSrcMBField;
  778.                 }
  779.                 ppxlcSrcMBField++;
  780.         }
  781. }
  783. Void CVideoObject::mcSetTopMBFieldsGray (
  784.         PixelC* ppxlcMBField1,
  785.         PixelC* ppxlcMBField2,
  786.         Int     uiBlkXSize,
  787.         Int     uiStride
  788. )
  789. {
  790.         UInt    iy, uiBlkYSize = uiBlkXSize/2;
  791. PixelC pxlcGrayVal = 128;
  792. if(m_volmd.bNot8Bit)
  793. pxlcGrayVal = 1<<(m_volmd.nBits-1);
  795.         ppxlcMBField1 -= 2*uiStride;
  796.         for (iy = 0; iy < uiBlkYSize; iy++) {
  797.                 pxlcmemset (ppxlcMBField1, pxlcGrayVal, uiBlkXSize);
  798.                 ppxlcMBField1 -= 2*uiStride;
  799.         }
  800.         if (!ppxlcMBField2) return;
  801.         ppxlcMBField2 -= 2*uiStride;
  802.         for (iy = 0; iy < uiBlkYSize; iy++) {
  803.                 pxlcmemset (ppxlcMBField2, pxlcGrayVal, uiBlkXSize);
  804.                 ppxlcMBField2 -= 2*uiStride;
  805.         }
  806. }
  807.  
  808. Void CVideoObject::mcSetLeftMBFieldsGray (
  809.         PixelC* ppxlcMBField1,
  810.         PixelC* ppxlcMBField2,
  811.         Int     uiBlkXSize,
  812.         Int     uiStride)
  813. {
  814.         UInt    iy, uiBlkYSize = uiBlkXSize/2;
  815. PixelC pxlcGrayVal = 128;
  816. if(m_volmd.bNot8Bit)
  817. pxlcGrayVal = 1<<(m_volmd.nBits-1);
  819. ppxlcMBField1 = ppxlcMBField1-uiBlkXSize;
  820.         for (iy = 0; iy < uiBlkYSize; iy++) {
  821.                 pxlcmemset (ppxlcMBField1, pxlcGrayVal, uiBlkXSize);
  822.                 ppxlcMBField1 += 2*uiStride;
  823.         }
  824.         if (!ppxlcMBField2) return;
  825. ppxlcMBField2 = ppxlcMBField2-uiBlkXSize;
  826.         for (iy = 0; iy < uiBlkYSize; iy++) {
  827.                 pxlcmemset (ppxlcMBField2, pxlcGrayVal, uiBlkXSize);
  828.                 ppxlcMBField2 += 2*uiStride;
  829.         }
  830. }
  831.  
  832. Void CVideoObject::mcSetCurrMBFieldsGray (
  833.         PixelC* ppxlcMBField1,
  834.         PixelC* ppxlcMBField2,
  835.         Int     uiBlkXSize,
  836.         Int     uiStride)
  837. {
  838.         UInt    iy, uiBlkYSize = uiBlkXSize/2;
  839. PixelC pxlcGrayVal = 128;
  840. if(m_volmd.bNot8Bit)
  841. pxlcGrayVal = 1<<(m_volmd.nBits-1);
  843.         for (iy = 0; iy < uiBlkYSize; iy++) {
  844.                 pxlcmemset (ppxlcMBField1, pxlcGrayVal, uiBlkXSize);
  845.                 ppxlcMBField1 += 2*uiStride;
  846.         }
  847.         if (!ppxlcMBField2) return;
  848.         for (iy = 0; iy < uiBlkYSize; iy++) {
  849.                 pxlcmemset (ppxlcMBField2, pxlcGrayVal, uiBlkXSize);
  850.                 ppxlcMBField2 += 2*uiStride;
  851.         }
  852. }
  853.  
  854. // End of HYUNDAI(1998-5-9)