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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

mc.cpp：源码内容
  1. /*************************************************************************
  3. This software module was originally developed by 
  5. Ming-Chieh Lee (mingcl@microsoft.com), Microsoft Corporation
  6. Bruce Lin (blin@microsoft.com), Microsoft Corporation
  7. Simon Winder (swinder@microsoft.com), Microsoft Corporation
  8. (date: June, 1997)
  9. and edited by
  10.         Wei Wu (weiwu@stallion.risc.rockwell.com) Rockwell Science Center
  12. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  13. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  14. as specified by the MPEG-4 Video. 
  15. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  16. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  17. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
  18. The original developer of this software module and his/her company, 
  19. the subsequent editors and their companies, 
  20. and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
  21. Copyright is not released for non MPEG-4 Video conforming products. 
  22. Microsoft retains full right to use the code for his/her own purpose, 
  23. assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
  24. This copyright notice must be included in all copies or derivative works. 
  26. Copyright (c) 1996, 1997.
  28. Module Name:
  30. mc.cpp
  32. Abstract:
  34. Motion compensation routines (common for encoder and decoder).
  36. Revision History:
  37.     December 20, 1997   Interlaced tools added by NextLevel Systems (GI)
  38.                         X. Chen (xchen@nlvl.com) B. Eifrig (beifrig@nlvl.com)
  39. `
  40. *************************************************************************/
  42. #include <stdio.h>
  44. #include "typeapi.h"
  45. #include "codehead.h"
  46. #include "mode.hpp"
  47. #include "vopses.hpp"
  48. #include "global.hpp"
  50. #ifdef __MFC_
  51. #ifdef _DEBUG
  52. #undef THIS_FILE
  53. static char BASED_CODE THIS_FILE[] = __FILE__;
  54. #endif
  56. #define new DEBUG_NEW    
  57. #endif // __MFC_
  59. Void CVideoObject::limitMVRangeToExtendedBBFullPel (CoordI &x,CoordI &y,CRct *prct,Int iBlkSize)
  60. {
  61. if(prct==NULL)
  62. return;
  64. if(x < prct->left)
  65. x=prct->left;
  66. else if(x > (prct->right-iBlkSize))
  67. x=(prct->right-iBlkSize);
  68. if(y < prct->top)
  69. y=prct->top;
  70. else if(y > (prct->bottom-iBlkSize))
  71. y=(prct->bottom-iBlkSize);
  72. }
  74. Void CVideoObject::limitMVRangeToExtendedBBHalfPel (CoordI &x,CoordI &y,CRct *prct,Int iBlkSize)
  75. {
  76. if(prct==NULL)
  77. return;
  79. if(x < prct->left*2)
  80. x=prct->left*2;
  81. else if(x > (prct->right-iBlkSize)*2)
  82. x=(prct->right-iBlkSize)*2;
  83. if(y < prct->top*2)
  84. y=prct->top*2;
  85. else if(y > (prct->bottom-iBlkSize)*2)
  86. y=(prct->bottom-iBlkSize)*2;
  87. }
  89. Void CVideoObject::motionCompMB (
  90. PixelC* ppxlcPredMB,
  91. const PixelC* ppxlcRefLeftTop,
  92. const CMotionVector* pmv, const CMBMode* pmbmd, 
  93. Int imbX, Int imbY,
  94. CoordI x, CoordI y,
  95. Bool bSkipNonOBMC,
  96. Bool bAlphaMB,
  97. CRct *prctMVLimit
  98. )
  99. {
  100. if (!bAlphaMB && !m_volmd.bAdvPredDisable && !pmbmd->m_bFieldMV) {
  101. motionCompOverLap (
  102. ppxlcPredMB, ppxlcRefLeftTop,
  103. pmv, pmbmd,
  104. imbX, imbY,
  105. x, y,
  106. prctMVLimit
  107. );
  108. }
  109. else {
  110. if (bSkipNonOBMC)
  111. return;
  112. if (!pmbmd -> m_bhas4MVForward && !pmbmd -> m_bFieldMV)
  113. motionComp (
  114. ppxlcPredMB, ppxlcRefLeftTop,
  115. MB_SIZE, 
  116. x * 2 + pmv->trueMVHalfPel ().x, 
  117. y * 2 + pmv->trueMVHalfPel ().y ,
  118. m_vopmd.iRoundingControl,
  119. prctMVLimit
  120. );
  121. else if (pmbmd -> m_bFieldMV) {
  122. const CMotionVector* pmv16x8 = pmv+5;
  123. if(pmbmd->m_bForwardTop) {
  124. pmv16x8++;
  125. motionCompYField (
  126. ppxlcPredMB,
  127. ppxlcRefLeftTop+m_iFrameWidthY,
  128. x * 2 + pmv16x8->trueMVHalfPel ().x, 
  129. y * 2 + pmv16x8->trueMVHalfPel ().y 
  130. );
  131. pmv16x8++;
  132. }
  133. else {
  134. motionCompYField (
  135. ppxlcPredMB,
  136. ppxlcRefLeftTop,
  137. x * 2 + pmv16x8->trueMVHalfPel ().x, 
  138. y * 2 + pmv16x8->trueMVHalfPel ().y 
  139. );
  140. pmv16x8++;
  141. pmv16x8++;
  142. }
  143. if(pmbmd->m_bForwardBottom) {
  144. pmv16x8++;
  145. motionCompYField (
  146. ppxlcPredMB+MB_SIZE,
  147. ppxlcRefLeftTop+m_iFrameWidthY,
  148. x * 2 + pmv16x8->trueMVHalfPel ().x, 
  149. y * 2 + pmv16x8->trueMVHalfPel ().y 
  150. );
  151. }
  152. else {
  153. motionCompYField (
  154. ppxlcPredMB+MB_SIZE,
  155. ppxlcRefLeftTop,
  156. x * 2 + pmv16x8->trueMVHalfPel ().x, 
  157. y * 2 + pmv16x8->trueMVHalfPel ().y 
  158. );
  159. }
  160. }
  161. else {
  162. const CMotionVector* pmv8 = pmv;
  163. pmv8++;
  164. CoordI blkX = x + BLOCK_SIZE;
  165. CoordI blkY = y + BLOCK_SIZE;
  166. if (pmbmd->m_rgTranspStatus [Y_BLOCK1] != ALL)
  167. motionComp (
  168. ppxlcPredMB, ppxlcRefLeftTop,
  169. BLOCK_SIZE, 
  170. x * 2 + pmv8->trueMVHalfPel ().x, 
  171. y * 2 + pmv8->trueMVHalfPel ().y,
  172. m_vopmd.iRoundingControl,
  173. prctMVLimit
  174. );
  175. pmv8++;
  176. if (pmbmd->m_rgTranspStatus [Y_BLOCK2] != ALL)
  177. motionComp (
  178. ppxlcPredMB + OFFSET_BLK1, ppxlcRefLeftTop,
  179. BLOCK_SIZE, 
  180. blkX * 2 + pmv8->trueMVHalfPel ().x, 
  181. y * 2 + pmv8->trueMVHalfPel ().y,
  182. m_vopmd.iRoundingControl,
  183. prctMVLimit
  184. );
  185. pmv8++;
  186. if (pmbmd->m_rgTranspStatus [Y_BLOCK3] != ALL)
  187. motionComp (
  188. ppxlcPredMB + OFFSET_BLK2, ppxlcRefLeftTop,
  189. BLOCK_SIZE, 
  190. x * 2 + pmv8->trueMVHalfPel ().x, 
  191. blkY * 2 + pmv8->trueMVHalfPel ().y,
  192. m_vopmd.iRoundingControl,
  193. prctMVLimit
  194. );
  195. pmv8++;
  196. if (pmbmd->m_rgTranspStatus [Y_BLOCK4] != ALL)
  197. motionComp (
  198. ppxlcPredMB + OFFSET_BLK3, ppxlcRefLeftTop,
  199. BLOCK_SIZE, 
  200. blkX * 2 + pmv8->trueMVHalfPel ().x, 
  201. blkY * 2 + pmv8->trueMVHalfPel ().y,
  202. m_vopmd.iRoundingControl,
  203. prctMVLimit
  204. );
  205. }
  206. }
  207. }
  209. Void CVideoObject::motionComp (
  210. PixelC* ppxlcPred, // can be either Y or A
  211. const PixelC* ppxlcRefLeftTop, // point to left-top of the frame
  212. Int iSize, // either MB or BLOCK size
  213. CoordI xRef, CoordI yRef, // x + mvX, in half pel unit
  214. Int iRoundingControl,
  215. CRct *prctMVLimit // extended bounding box
  216. )
  217. {
  218. CoordI ix, iy;
  220. limitMVRangeToExtendedBBHalfPel(xRef,yRef,prctMVLimit,iSize);
  222. const PixelC* ppxlcRef = 
  223. ppxlcRefLeftTop + 
  224. ((yRef >> 1) + EXPANDY_REF_FRAME) * m_iFrameWidthY + (xRef >> 1) + EXPANDY_REF_FRAME;
  226. if(iSize==8 || iSize==16)
  227. {
  228. // optimisation
  229. if (!(yRef & 1)) {
  230. if (!(xRef & 1)) {
  231. Int iSz = iSize * sizeof(PixelC);
  232. for(iy = 0; iy < iSize; iy+=8)
  233. {
  234. memcpy (ppxlcPred, ppxlcRef, iSz);
  235. ppxlcRef += m_iFrameWidthY; ppxlcPred += MB_SIZE;
  236. memcpy (ppxlcPred, ppxlcRef, iSz);
  237. ppxlcRef += m_iFrameWidthY; ppxlcPred += MB_SIZE;
  238. memcpy (ppxlcPred, ppxlcRef, iSz);
  239. ppxlcRef += m_iFrameWidthY; ppxlcPred += MB_SIZE;
  240. memcpy (ppxlcPred, ppxlcRef, iSz);
  241. ppxlcRef += m_iFrameWidthY; ppxlcPred += MB_SIZE;
  242. memcpy (ppxlcPred, ppxlcRef, iSz);
  243. ppxlcRef += m_iFrameWidthY; ppxlcPred += MB_SIZE;
  244. memcpy (ppxlcPred, ppxlcRef, iSz);
  245. ppxlcRef += m_iFrameWidthY; ppxlcPred += MB_SIZE;
  246. memcpy (ppxlcPred, ppxlcRef, iSz);
  247. ppxlcRef += m_iFrameWidthY; ppxlcPred += MB_SIZE;
  248. memcpy (ppxlcPred, ppxlcRef, iSz);
  249. ppxlcRef += m_iFrameWidthY; ppxlcPred += MB_SIZE;
  250. }
  251. }
  252. else {
  253. PixelC pxlcT1,pxlcT2, *ppxlcDst;
  254. const PixelC *ppxlcSrc;
  255. Int iRndCtrl = 1 - iRoundingControl;
  256. for (iy = 0; iy < iSize; iy++){
  257. ppxlcDst = ppxlcPred;
  258. ppxlcSrc = ppxlcRef;
  259. for (ix = 0; ix < iSize; ix+=8) {
  260. ppxlcDst [0] = (ppxlcSrc[0] + (pxlcT1=ppxlcSrc[1]) + iRndCtrl) >> 1;
  261. ppxlcDst [1] = (pxlcT1 + (pxlcT2=ppxlcSrc[2]) + iRndCtrl) >> 1;
  262. ppxlcDst [2] = (pxlcT2 + (pxlcT1=ppxlcSrc[3]) + iRndCtrl) >> 1;
  263. ppxlcDst [3] = (pxlcT1 + (pxlcT2=ppxlcSrc[4]) + iRndCtrl) >> 1;
  264. ppxlcDst [4] = (pxlcT2 + (pxlcT1=ppxlcSrc[5]) + iRndCtrl) >> 1;
  265. ppxlcDst [5] = (pxlcT1 + (pxlcT2=ppxlcSrc[6]) + iRndCtrl) >> 1;
  266. ppxlcDst [6] = (pxlcT2 + (pxlcT1=ppxlcSrc[7]) + iRndCtrl) >> 1;
  267. ppxlcDst [7] = (pxlcT1 + ppxlcSrc[8] + iRndCtrl) >> 1;
  268. ppxlcDst += 8;
  269. ppxlcSrc += 8;
  270. }
  271. ppxlcRef += m_iFrameWidthY;
  272. ppxlcPred += MB_SIZE;
  273. }
  274. }
  275. }
  276. else {
  277. if (!(xRef & 1)) {
  278. Int iRndCtrl = 1 - iRoundingControl;
  279. const PixelC *ppxlcSrc, *ppxlcSrc2;
  280. PixelC *ppxlcDst;
  281. for (iy = 0; iy < iSize; iy++) {
  282. ppxlcDst = ppxlcPred;
  283. ppxlcSrc = ppxlcRef;
  284. ppxlcSrc2 = ppxlcRef + m_iFrameWidthY;
  285. for (ix = 0; ix < iSize; ix+=8) {
  286. ppxlcDst [0] = (ppxlcSrc [0] + ppxlcSrc2 [0] + iRndCtrl) >> 1;
  287. ppxlcDst [1] = (ppxlcSrc [1] + ppxlcSrc2 [1] + iRndCtrl) >> 1;
  288. ppxlcDst [2] = (ppxlcSrc [2] + ppxlcSrc2 [2] + iRndCtrl) >> 1;
  289. ppxlcDst [3] = (ppxlcSrc [3] + ppxlcSrc2 [3] + iRndCtrl) >> 1;
  290. ppxlcDst [4] = (ppxlcSrc [4] + ppxlcSrc2 [4] + iRndCtrl) >> 1;
  291. ppxlcDst [5] = (ppxlcSrc [5] + ppxlcSrc2 [5] + iRndCtrl) >> 1;
  292. ppxlcDst [6] = (ppxlcSrc [6] + ppxlcSrc2 [6] + iRndCtrl) >> 1;
  293. ppxlcDst [7] = (ppxlcSrc [7] + ppxlcSrc2 [7] + iRndCtrl) >> 1;
  294. ppxlcDst += 8;
  295. ppxlcSrc += 8;
  296. ppxlcSrc2 += 8;
  297. }
  298. ppxlcRef += m_iFrameWidthY;
  299. ppxlcPred += MB_SIZE;
  300. }
  301. }
  302. else {
  303. Int iRndCtrl = 2 - iRoundingControl;
  304. PixelC pxlcT1, pxlcT2, pxlcT3, pxlcT4, *ppxlcDst;
  305. const PixelC *ppxlcSrc, *ppxlcSrc2;
  306. for (iy = 0; iy < iSize; iy++) {
  307. ppxlcDst = ppxlcPred;
  308. ppxlcSrc = ppxlcRef;
  309. ppxlcSrc2 = ppxlcRef + m_iFrameWidthY;
  310. for (ix = 0; ix < iSize; ix+=8) {
  311. ppxlcDst [0] = (ppxlcSrc[0] + (pxlcT1=ppxlcSrc[1]) + ppxlcSrc2[0] + (pxlcT3=ppxlcSrc2[1]) + iRndCtrl) >> 2;
  312. ppxlcDst [1] = (pxlcT1 + (pxlcT2=ppxlcSrc[2]) + pxlcT3 + (pxlcT4=ppxlcSrc2[2]) + iRndCtrl) >> 2;
  313. ppxlcDst [2] = (pxlcT2 + (pxlcT1=ppxlcSrc[3]) + pxlcT4 + (pxlcT3=ppxlcSrc2[3]) + iRndCtrl) >> 2;
  314. ppxlcDst [3] = (pxlcT1 + (pxlcT2=ppxlcSrc[4]) + pxlcT3 + (pxlcT4=ppxlcSrc2[4]) + iRndCtrl) >> 2;
  315. ppxlcDst [4] = (pxlcT2 + (pxlcT1=ppxlcSrc[5]) + pxlcT4 + (pxlcT3=ppxlcSrc2[5]) + iRndCtrl) >> 2;
  316. ppxlcDst [5] = (pxlcT1 + (pxlcT2=ppxlcSrc[6]) + pxlcT3 + (pxlcT4=ppxlcSrc2[6]) + iRndCtrl) >> 2;
  317. ppxlcDst [6] = (pxlcT2 + (pxlcT1=ppxlcSrc[7]) + pxlcT4 + (pxlcT3=ppxlcSrc2[7]) + iRndCtrl) >> 2;
  318. ppxlcDst [7] = (pxlcT1 + ppxlcSrc[8] + pxlcT3 + ppxlcSrc2[8] + iRndCtrl) >> 2;
  319. ppxlcDst += 8;
  320. ppxlcSrc += 8;
  321. ppxlcSrc2 += 8;
  322. }
  323. ppxlcRef += m_iFrameWidthY;
  324. ppxlcPred += MB_SIZE;
  325. }
  326. }
  327. }
  328. }
  329. else {
  330. if (!(yRef & 1)) {
  331. if (!(xRef & 1)) {  //!bXSubPxl && !bYSubPxl
  332. for (iy = 0; iy < iSize; iy++) {
  333. memcpy (ppxlcPred, ppxlcRef, iSize*sizeof(PixelC));
  334. ppxlcRef += m_iFrameWidthY;
  335. ppxlcPred += MB_SIZE;
  336. }
  337. }
  338. else {  //bXSubPxl && !bYSubPxl
  339. for (iy = 0; iy < iSize; iy++){
  340. for (ix = 0; ix < iSize; ix++)
  341. ppxlcPred [ix] = (ppxlcRef [ix] + ppxlcRef [ix + 1] + 1 - iRoundingControl) >> 1;
  342. ppxlcRef += m_iFrameWidthY;
  343. ppxlcPred += MB_SIZE;
  344. }
  345. }
  346. }
  347. else {
  348. const PixelC* ppxlcRefBot;
  349. if (!(xRef & 1)) {  //!bXSubPxl&& bYSubPxl
  350. for (iy = 0; iy < iSize; iy++) {
  351. ppxlcRefBot = ppxlcRef + m_iFrameWidthY; //UPln -> pixels (xInt,yInt+1);
  352. for (ix = 0; ix < iSize; ix++) 
  353. ppxlcPred [ix] = (ppxlcRef [ix] + ppxlcRefBot [ix] + 1 - iRoundingControl) >> 1;
  354. ppxlcRef = ppxlcRefBot;
  355. ppxlcPred += MB_SIZE;
  356. }
  357. }
  358. else { // bXSubPxl && bYSubPxl
  359. for (iy = 0; iy < iSize; iy++) {
  360. ppxlcRefBot = ppxlcRef + m_iFrameWidthY; //UPln -> pixels (xInt,yInt+1);
  361. for (ix = 0; ix < iSize; ix++){
  362. ppxlcPred [ix] = (
  363. ppxlcRef [ix + 1] + ppxlcRef [ix] +
  364. ppxlcRefBot [ix + 1] + ppxlcRefBot [ix] + 2 - iRoundingControl
  365. ) >> 2;
  367. }
  368. ppxlcRef = ppxlcRefBot;
  369. ppxlcPred += MB_SIZE;
  370. }
  371. }
  372. }
  373. }
  374. }
  376. Void CVideoObject::motionCompDirectMode(                // Interlaced direct mode
  377. CoordI x, CoordI y,
  378.  CMBMode *pmbmd,   
  379. const CMotionVector *pmvRef,
  380.     CRct *prctMVLimitFwd, CRct *prctMVLimitBak,
  381. Int plane // plane=1 for grey scale, plane=0 for texture, 02-17-99
  382. )
  383. {
  384. Int* rgiMvRound = NULL;
  385. UInt uiDivisor = 0;
  386. Int xRefUVF,yRefUVF,xRefUVB,yRefUVB;
  388. // begin of new changes 10/21/98
  389. Int iMBX,iMBY;
  390. const CMBMode *pmbmdRef; 
  392. if(m_volmd.fAUsage != RECTANGLE)
  393. {
  394. iMBX=(x-m_rctCurrVOPY.left)/MB_SIZE;
  395. iMBY=(y-m_rctCurrVOPY.top)/MB_SIZE;
  396. pmbmdRef= m_rgmbmdRef +
  397. (iMBX+iMBY*m_iNumMBXRef);
  398. }
  399. else
  400. {
  401. iMBX=x/MB_SIZE;
  402. iMBY=y/MB_SIZE;
  403. pmbmdRef= m_rgmbmdRef +
  404. iMBX+iMBY*m_iNumMBXRef;
  405. }
  406. // end of new changes 10/21/98
  408. if (pmbmdRef->m_rgTranspStatus[0]==ALL) {
  409. static CMotionVector mvZero[5];
  410. pmvRef = mvZero;
  411. }
  413. if ((iMBX<m_iNumMBXRef && iMBX>=0 && iMBY<m_iNumMBYRef && iMBY>=0)&& // new change 10/21/98
  414. (pmbmdRef->m_bFieldMV&&pmbmdRef->m_rgTranspStatus[0]!=ALL)) {
  415. static I8 iTROffsetTop[] = {  0, 0,  1, 1, 0, 0, -1, -1 };
  416. static I8 iTROffsetBot[] = { -1, 0, -1, 0, 1, 0,  1,  0 };
  417. CoordI iXFwdTop, iXFwdBot, iXBakTop, iXBakBot;
  418. CoordI iYFwdTop, iYFwdBot, iYBakTop, iYBakBot;
  419. const CMotionVector *pmvRefTop, *pmvRefBot;
  420. Int iTopRefFldOffset = 0, iBotRefFldOffset = 0;
  421. Int iCode = (Int)(vopmd().bTopFieldFirst) << 2;
  423. pmbmd->m_bFieldMV = 1;  // set field direct mode for grey scale // new change 02-19-99
  425. assert((pmbmdRef->m_dctMd != INTRA) && (pmbmdRef->m_dctMd != INTRAQ));
  426. if (pmbmdRef->m_bForwardTop) {
  427. iCode |= 2;
  428. iTopRefFldOffset = 1;
  429. pmvRefTop = pmvRef + 6;
  430. } else
  431. pmvRefTop = pmvRef + 5;
  432. if (pmbmdRef->m_bForwardBottom) {
  433. iCode |= 1;
  434. iBotRefFldOffset = 1;
  435. pmvRefBot = pmvRef + 8;
  436. } else
  437. pmvRefBot = pmvRef + 7;
  438. Int iTempRefDTop = 2*(m_tFutureRef - m_tPastRef) + iTROffsetTop[iCode];
  439. Int iTempRefDBot = 2*(m_tFutureRef - m_tPastRef) + iTROffsetBot[iCode];
  440. Int iTempRefBTop = 2*(m_t          - m_tPastRef) + iTROffsetTop[iCode];
  441. Int iTempRefBBot = 2*(m_t          - m_tPastRef) + iTROffsetBot[iCode];
  443. assert(iTempRefDTop > 0); assert(iTempRefDBot > 0); assert(iTempRefBTop > 0); assert(iTempRefBBot > 0);
  445. // Find MVs for the top field
  446. iXFwdTop = (pmvRefTop->m_vctTrueHalfPel.x * iTempRefBTop) / iTempRefDTop + pmbmd->m_vctDirectDeltaMV.x;
  447. iYFwdTop = (pmvRefTop->m_vctTrueHalfPel.y * iTempRefBTop) / iTempRefDTop + pmbmd->m_vctDirectDeltaMV.y;
  448.         iXBakTop = pmbmd->m_vctDirectDeltaMV.x ? (iXFwdTop - pmvRefTop->m_vctTrueHalfPel.x) :
  449.             ((pmvRefTop->m_vctTrueHalfPel.x * (iTempRefBTop - iTempRefDTop)) / iTempRefDTop);
  450.         iYBakTop = pmbmd->m_vctDirectDeltaMV.y ? (iYFwdTop - pmvRefTop->m_vctTrueHalfPel.y) :
  451.             ((pmvRefTop->m_vctTrueHalfPel.y * (iTempRefBTop - iTempRefDTop)) / iTempRefDTop);
  453. // Find MVs for the bottom field
  454. iXFwdBot = (pmvRefBot->m_vctTrueHalfPel.x * iTempRefBBot) / iTempRefDBot + pmbmd->m_vctDirectDeltaMV.x;
  455. iYFwdBot = (pmvRefBot->m_vctTrueHalfPel.y * iTempRefBBot) / iTempRefDBot + pmbmd->m_vctDirectDeltaMV.y;
  456.         iXBakBot = pmbmd->m_vctDirectDeltaMV.x ? (iXFwdBot - pmvRefBot->m_vctTrueHalfPel.x) :
  457.             ((pmvRefBot->m_vctTrueHalfPel.x * (iTempRefBBot - iTempRefDBot)) / iTempRefDBot);
  458.         iYBakBot = pmbmd->m_vctDirectDeltaMV.y ? (iYFwdBot - pmvRefBot->m_vctTrueHalfPel.y) :
  459.             ((pmvRefBot->m_vctTrueHalfPel.y * (iTempRefBBot - iTempRefDBot)) / iTempRefDBot);
  461. // Motion compensate the top field forward
  462.         iXFwdTop += 2*x; iYFwdTop += 2*y;
  463.         limitMVRangeToExtendedBBHalfPel(iXFwdTop, iYFwdTop, prctMVLimitFwd, MB_SIZE);
  464. if (plane==0) {  // texture MC // new change 02-19-99
  465. motionCompYField(m_ppxlcPredMBY,
  466. m_pvopcRefQ0->pixelsY() + iTopRefFldOffset * m_iFrameWidthY, iXFwdTop, iYFwdTop);
  467. iXFwdTop -= 2*x; iYFwdTop -= 2*y;
  468. motionCompFieldUV(m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, x, y,
  469. (iXFwdTop & 3) ? ((iXFwdTop >> 1) | 1) : (iXFwdTop >> 1),
  470. (iYFwdTop & 6) ? ((iYFwdTop >> 1) | 2) : (iYFwdTop >> 1), iTopRefFldOffset);
  471. }
  472. else {  // plane=1, grey scale MC // begin of new change 02-19-99
  473. motionCompYField(m_ppxlcPredMBA,
  474. m_pvopcRefQ0->pixelsA() + iTopRefFldOffset * m_iFrameWidthY, iXFwdTop, iYFwdTop);
  475. iXFwdTop -= 2*x; iYFwdTop -= 2*y;
  476. } // end of new change 02-19-99
  478. // Motion compensate the top field backward
  479.         iXBakTop += 2*x; iYBakTop += 2*y;
  480.         limitMVRangeToExtendedBBHalfPel(iXBakTop, iYBakTop, prctMVLimitBak, MB_SIZE);
  481. if (plane==0) {  // texture MC // new change 02-19-99
  482. motionCompYField(m_ppxlcPredMBBackY, m_pvopcRefQ1->pixelsY(), iXBakTop,  iYBakTop);
  483. iXBakTop -= 2*x; iYBakTop -= 2*y;
  484. motionCompFieldUV(m_ppxlcPredMBBackU, m_ppxlcPredMBBackV, m_pvopcRefQ1, x, y,
  485. (iXBakTop & 3) ? ((iXBakTop >> 1) | 1) : (iXBakTop >> 1),
  486. (iYBakTop & 6) ? ((iYBakTop >> 1) | 2) : (iYBakTop >> 1), 0);
  487. }
  488. else {  // plane=1, grey scale MC // begin of new change 02-19-99
  489. motionCompYField(m_ppxlcPredMBBackA, m_pvopcRefQ1->pixelsA(), iXBakTop,  iYBakTop);
  490. iXBakTop -= 2*x; iYBakTop -= 2*y;
  491. } // end of new change 02-19-99
  493. // Motion compensate the bottom field forward
  494.         iXFwdBot += 2*x; iYFwdBot += 2*y;
  495.         limitMVRangeToExtendedBBHalfPel(iXFwdBot, iYFwdBot, prctMVLimitFwd, MB_SIZE);
  496. if (plane==0) {  // texture MC // new change 02-19-99
  497. motionCompYField(m_ppxlcPredMBY + MB_SIZE,
  498. m_pvopcRefQ0->pixelsY() + iBotRefFldOffset * m_iFrameWidthY, iXFwdBot, iYFwdBot);
  499. iXFwdBot -= 2*x; iYFwdBot -= 2*y;
  500. motionCompFieldUV(m_ppxlcPredMBU + BLOCK_SIZE, m_ppxlcPredMBV + BLOCK_SIZE, m_pvopcRefQ0, x, y,
  501. (iXFwdBot & 3) ? ((iXFwdBot >> 1) | 1) : (iXFwdBot >> 1),
  502. (iYFwdBot & 6) ? ((iYFwdBot >> 1) | 2) : (iYFwdBot >> 1), iBotRefFldOffset);
  503. }
  504. else {  // plane=1, grey scale MC // begin of new change 02-19-99
  505. motionCompYField(m_ppxlcPredMBA + MB_SIZE,
  506. m_pvopcRefQ0->pixelsA() + iBotRefFldOffset * m_iFrameWidthY, iXFwdBot, iYFwdBot);
  507. iXFwdBot -= 2*x; iYFwdBot -= 2*y;
  508. } // end of new change 02-19-99
  510. // Motion compensate the bottom field backward
  511.         iXBakBot += 2*x; iYBakBot += 2*y;
  512.         limitMVRangeToExtendedBBHalfPel(iXBakBot, iYBakBot, prctMVLimitBak, MB_SIZE);
  513. if (plane==0) {  // texture MC // new change 02-19-99
  514. motionCompYField(m_ppxlcPredMBBackY + MB_SIZE, m_pvopcRefQ1->pixelsY() + m_iFrameWidthY,
  515. iXBakBot, iYBakBot);
  516.     iXBakBot -= 2*x; iYBakBot -= 2*y;
  517. motionCompFieldUV(m_ppxlcPredMBBackU + BLOCK_SIZE, m_ppxlcPredMBBackV + BLOCK_SIZE, m_pvopcRefQ1, x, y,
  518. (iXBakBot & 3) ? ((iXBakBot >> 1) | 1) : (iXBakBot >> 1),
  519. (iYBakBot & 6) ? ((iYBakBot >> 1) | 2) : (iYBakBot >> 1), 1);
  520. }
  521. else {  // plane=1, grey scale MC // begin of new change 02-19-99
  522. motionCompYField(m_ppxlcPredMBBackA + MB_SIZE, m_pvopcRefQ1->pixelsA() + m_iFrameWidthY,
  523. iXBakBot, iYBakBot);
  524.     iXBakBot -= 2*x; iYBakBot -= 2*y;
  525. } // end of new change 02-19-99
  526. } else {
  528. Int iTempRefD = m_tFutureRef - m_tPastRef;
  529. Int iTempRefB = m_t          - m_tPastRef;
  530. assert(iTempRefD > 0); assert(iTempRefB > 0);
  531. Int iChromaFwdX = 0, iChromaFwdY = 0, iChromaBakX = 0, iChromaBakY = 0;
  532. CVector vctFwd, vctBak;
  533. static I8 iBlkXOffset[] = { 0, 2*BLOCK_SIZE, 0, 2*BLOCK_SIZE };
  534. static I8 iBlkYOffset[] = { 0, 0, 2*BLOCK_SIZE, 2*BLOCK_SIZE };
  535. static Int iMBOffset[] = { 0, BLOCK_SIZE, MB_SIZE*BLOCK_SIZE, MB_SIZE*BLOCK_SIZE + BLOCK_SIZE };
  536. if ((pmbmdRef->m_dctMd == INTRA) || (pmbmdRef->m_dctMd == INTRAQ)) {
  537. static CMotionVector mvZero[5];
  538. pmvRef = mvZero;
  539. }
  540. if(iMBX<m_iNumMBXRef && iMBX>=0 && iMBY<m_iNumMBYRef && iMBY>=0) // new changes 10/21/98
  541. {
  542.    if (pmbmdRef -> m_bhas4MVForward) {
  543. for (Int iBlk = 0; iBlk < 4; iBlk++) {
  544. if(pmbmd->m_rgTranspStatus[iBlk+1]!=ALL) {
  545. vctFwd = (pmvRef[iBlk + 1].m_vctTrueHalfPel * iTempRefB) / iTempRefD + pmbmd->m_vctDirectDeltaMV;
  546. vctBak.x = pmbmd->m_vctDirectDeltaMV.x ? (vctFwd.x - pmvRef[iBlk + 1].m_vctTrueHalfPel.x) :
  547. ((pmvRef[iBlk + 1].m_vctTrueHalfPel.x * (iTempRefB - iTempRefD)) / iTempRefD);
  548. vctBak.y = pmbmd->m_vctDirectDeltaMV.y ? (vctFwd.y - pmvRef[iBlk + 1].m_vctTrueHalfPel.y) :
  549. ((pmvRef[iBlk + 1].m_vctTrueHalfPel.y * (iTempRefB - iTempRefD)) / iTempRefD);
  550. // rounding control is messed up here
  551. motionComp(m_ppxlcPredMBY + iMBOffset[iBlk], m_pvopcRefQ0->pixelsY(), BLOCK_SIZE,
  552. x * 2 + iBlkXOffset[iBlk] + vctFwd.x, y * 2 + iBlkYOffset[iBlk] + vctFwd.y, 0, prctMVLimitFwd);
  553. motionComp(m_ppxlcPredMBBackY + iMBOffset[iBlk], m_pvopcRefQ1->pixelsY(), BLOCK_SIZE,
  554. x * 2 + iBlkXOffset[iBlk] + vctBak.x, y * 2 + iBlkYOffset[iBlk] + vctBak.y, 0, prctMVLimitBak);
  556. iChromaFwdX += vctFwd.x;
  557. iChromaFwdY += vctFwd.y;
  558. iChromaBakX += vctBak.x;
  559. iChromaBakY += vctBak.y;
  560. uiDivisor += 4;
  561. }
  562. }
  563. switch (uiDivisor) {
  564. case 4:
  565. rgiMvRound = grgiMvRound4;
  566. break;
  567. case 8:
  568. rgiMvRound = grgiMvRound8;
  569. break;
  570. case 12:
  571. rgiMvRound = grgiMvRound12;
  572. break;
  573. case 16:
  574. rgiMvRound = grgiMvRound16;
  575. break;
  576. }
  577. xRefUVF = sign (iChromaFwdX) * (rgiMvRound [abs (iChromaFwdX) % uiDivisor] + (abs (iChromaFwdX) / uiDivisor) * 2);
  578. yRefUVF = sign (iChromaFwdY) * (rgiMvRound [abs (iChromaFwdY) % uiDivisor] + (abs (iChromaFwdY) / uiDivisor) * 2);
  579. xRefUVB = sign (iChromaBakX) * (rgiMvRound [abs (iChromaBakX) % uiDivisor] + (abs (iChromaBakX) / uiDivisor) * 2);
  580. yRefUVB = sign (iChromaBakY) * (rgiMvRound [abs (iChromaBakY) % uiDivisor] + (abs (iChromaBakY) / uiDivisor) * 2);
  581. }
  582. else // 16x16
  583. {
  584. vctFwd = (pmvRef[0].m_vctTrueHalfPel * iTempRefB) / iTempRefD + pmbmd->m_vctDirectDeltaMV;
  585. vctBak.x = pmbmd->m_vctDirectDeltaMV.x ? (vctFwd.x - pmvRef[0].m_vctTrueHalfPel.x) :
  586. ((pmvRef[0].m_vctTrueHalfPel.x * (iTempRefB - iTempRefD)) / iTempRefD);
  587. vctBak.y = pmbmd->m_vctDirectDeltaMV.y ? (vctFwd.y - pmvRef[0].m_vctTrueHalfPel.y) :
  588. ((pmvRef[0].m_vctTrueHalfPel.y * (iTempRefB - iTempRefD)) / iTempRefD);
  589. // rounding control is messed up here
  590. motionComp(m_ppxlcPredMBY, m_pvopcRefQ0->pixelsY(), MB_SIZE,
  591. x * 2 +  vctFwd.x, y * 2 +  vctFwd.y, 0, prctMVLimitFwd);
  592. motionComp(m_ppxlcPredMBBackY , m_pvopcRefQ1->pixelsY(), MB_SIZE,
  593. x * 2 +  vctBak.x, y * 2 +  vctBak.y, 0, prctMVLimitBak);
  595. xRefUVF = sign (vctFwd.x) * (grgiMvRound4  [abs (vctFwd.x) % 4] + (abs (vctFwd.x) / 4) * 2);
  596. yRefUVF = sign (vctFwd.y) * (grgiMvRound4  [abs (vctFwd.y) % 4] + (abs (vctFwd.y) / 4) * 2);
  597. xRefUVB = sign (vctBak.x) * (grgiMvRound4  [abs (vctBak.x) % 4] + (abs (vctBak.x) / 4) * 2);
  598. yRefUVB = sign (vctBak.y) * (grgiMvRound4  [abs (vctBak.y) % 4] + (abs (vctBak.y) / 4) * 2);
  600. }
  601. }
  602. // begin of new changes 10/21/98
  603. else
  604. {
  605. vctFwd = pmbmd->m_vctDirectDeltaMV;
  606. vctBak.x = pmbmd->m_vctDirectDeltaMV.x ? vctFwd.x :0;
  607. vctBak.y = pmbmd->m_vctDirectDeltaMV.y ? vctFwd.y :0;
  608. // rounding control is messed up here
  609. motionComp(m_ppxlcPredMBY, m_pvopcRefQ0->pixelsY(), MB_SIZE,
  610. x * 2 +  vctFwd.x, y * 2 +  vctFwd.y, 0, prctMVLimitFwd);
  611. motionComp(m_ppxlcPredMBBackY , m_pvopcRefQ1->pixelsY(), MB_SIZE,
  612. x * 2 +  vctBak.x, y * 2 +  vctBak.y, 0, prctMVLimitBak);
  614. xRefUVF = sign (vctFwd.x) * (grgiMvRound4  [abs (vctFwd.x) % 4] + (abs (vctFwd.x) / 4) * 2);
  615. yRefUVF = sign (vctFwd.y) * (grgiMvRound4  [abs (vctFwd.y) % 4] + (abs (vctFwd.y) / 4) * 2);
  616. xRefUVB = sign (vctBak.x) * (grgiMvRound4  [abs (vctBak.x) % 4] + (abs (vctBak.x) / 4) * 2);
  617. yRefUVB = sign (vctBak.y) * (grgiMvRound4  [abs (vctBak.y) % 4] + (abs (vctBak.y) / 4) * 2);
  619. }
  620. // end of new changes 10/21/98
  622. motionCompUV(m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, x, y,
  623. xRefUVF,
  624. yRefUVF,0, prctMVLimitFwd);
  625. motionCompUV(m_ppxlcPredMBBackU, m_ppxlcPredMBBackV, m_pvopcRefQ1, x, y,
  626. xRefUVB,
  627. yRefUVB,0, prctMVLimitBak);
  629. }
  630. }
  632. Void CVideoObject::motionCompOneBVOPReference(
  633. CVOPU8YUVBA *pvopcPred,
  634. MBType type,
  635. CoordI x, CoordI y,
  636. const CMBMode *pmbmd,
  637. const CMotionVector *pmv,
  638. CRct *prctMVLimit
  639. )
  640. { 
  641. CVOPU8YUVBA *pvopcRef;
  642. Int topRef, botRef;
  644. if (type == BACKWARD) {
  645. pvopcRef = m_pvopcRefQ1;
  646. topRef = (Int)pmbmd->m_bBackwardTop;
  647. botRef = (Int)pmbmd->m_bBackwardBottom;
  648. } else {
  649. pvopcRef = m_pvopcRefQ0;
  650. topRef = (Int)pmbmd->m_bForwardTop;
  651. botRef = (Int)pmbmd->m_bForwardBottom;
  652. }
  653. if (pmbmd->m_bFieldMV) {
  654. const CMotionVector *pmvTop = pmv + 1 + topRef;
  655. const CMotionVector *pmvBot = pmv + 3 + botRef;
  656. assert((topRef & ~1) == 0); assert((botRef & ~1) == 0);
  657.         CoordI iMVX, iMVY;
  659.         iMVX = 2*x + pmvTop->m_vctTrueHalfPel.x;
  660.         iMVY = 2*y + pmvTop->m_vctTrueHalfPel.y;
  661.         limitMVRangeToExtendedBBHalfPel(iMVX, iMVY, prctMVLimit, MB_SIZE);
  662. motionCompYField((PixelC *)pvopcPred->pixelsY(), // Luma top field
  663. pvopcRef->pixelsY() + topRef * m_iFrameWidthY, iMVX, iMVY);
  664.  
  665.         iMVX -= 2*x; iMVY -= 2*y;
  666. motionCompFieldUV((PixelC *)pvopcPred->pixelsU(), // Chroma top field
  667. (PixelC *)pvopcPred->pixelsV(), pvopcRef, x, y,
  668. (iMVX & 3) ? ((iMVX >> 1) | 1) : (iMVX >> 1),
  669. (iMVY & 6) ? ((iMVY >> 1) | 2) : (iMVY >> 1), topRef);
  671.         iMVX = 2*x + pmvBot->m_vctTrueHalfPel.x;
  672.         iMVY = 2*y + pmvBot->m_vctTrueHalfPel.y;
  673.         limitMVRangeToExtendedBBHalfPel(iMVX, iMVY, prctMVLimit, MB_SIZE);
  674. motionCompYField((PixelC *)(pvopcPred->pixelsY()) + MB_SIZE, // Luma bottom field
  675. pvopcRef->pixelsY() + botRef * m_iFrameWidthY, iMVX, iMVY);
  677.         iMVX -= 2*x; iMVY -= 2*y;
  678. motionCompFieldUV((PixelC *)(pvopcPred->pixelsU()) + BLOCK_SIZE, // Chroma bottom field
  679. (PixelC *)(pvopcPred->pixelsV()) + BLOCK_SIZE, pvopcRef, x, y,
  680. (iMVX & 3) ? ((iMVX >> 1) | 1) : (iMVX >> 1),
  681. (iMVY & 6) ? ((iMVY >> 1) | 2) : (iMVY >> 1), botRef);
  682. } else { // rounding control is messed up here
  683. motionComp((PixelC *)pvopcPred->pixelsY(), pvopcRef->pixelsY(), MB_SIZE,
  684. x * 2 + pmv->trueMVHalfPel().x, y * 2 + pmv->trueMVHalfPel().y, 0, prctMVLimit);
  685. motionCompUV((PixelC *)pvopcPred->pixelsU(), (PixelC *)pvopcPred->pixelsV(), pvopcRef, x, y,
  686. (pmv->m_vctTrueHalfPel.x & 3) ? ((pmv->m_vctTrueHalfPel.x >> 1) | 1) :
  687. (pmv->m_vctTrueHalfPel.x >> 1),
  688. (pmv->m_vctTrueHalfPel.y & 3) ? ((pmv->m_vctTrueHalfPel.y >> 1) | 1) :
  689. (pmv->m_vctTrueHalfPel.y >> 1), 0, prctMVLimit);
  690. }
  691. }
  693. Void CVideoObject::motionCompYField (
  694. PixelC* ppxlcPred, // can be either Y or A
  695. const PixelC* ppxlcRefLeftTop, // point to left-top of the frame
  696. CoordI xRef, CoordI yRef // current coordinate system
  697. )
  698. {
  699. CoordI ix, iy;
  700. const PixelC* ppxlcRef = ppxlcRefLeftTop + 
  701. (((yRef >> 1) & ~1) + EXPANDY_REF_FRAME) * m_iFrameWidthY + (xRef >> 1) + EXPANDY_REF_FRAME;
  702. Int iRound = 1 - m_vopmd.iRoundingControl;
  703. Int iFieldStep = 2 * m_iFrameWidthY;
  705. if (!(yRef & 2)) {
  706. if (!(xRef & 1)) {  //!bXSubPxl && !bYSubPxl
  707. for (iy = 0; iy < MB_SIZE; iy+=2) {
  708. memcpy (ppxlcPred, ppxlcRef, MB_SIZE*sizeof(PixelC));
  709. ppxlcRef += iFieldStep;
  710. ppxlcPred += MB_SIZE*2;
  711. }
  712. }
  713. else {  //bXSubPxl && !bYSubPxl
  714. for (iy = 0; iy < MB_SIZE; iy+=2){
  715. for (ix = 0; ix < MB_SIZE; ix++)
  716. ppxlcPred [ix] = (ppxlcRef [ix] + ppxlcRef [ix + 1] + iRound) >> 1;
  717. ppxlcRef += iFieldStep;
  718. ppxlcPred += MB_SIZE*2;
  719. }
  720. }
  721. }
  722. else {
  723. const PixelC* ppxlcRefBot;
  724. if (!(xRef & 1)) {  //!bXSubPxl&& bYSubPxl
  725. for (iy = 0; iy < MB_SIZE; iy+=2) {
  726. ppxlcRefBot = ppxlcRef + iFieldStep; //UPln -> pixels (xInt,yInt+1);
  727. for (ix = 0; ix < MB_SIZE; ix++) 
  728. ppxlcPred [ix] = (ppxlcRef [ix] + ppxlcRefBot [ix] + iRound) >> 1;
  729. ppxlcRef = ppxlcRefBot;
  730. ppxlcPred += MB_SIZE*2;
  731. }
  732. }
  733. else { // bXSubPxl && bYSubPxl
  734. iRound++;
  735. for (iy = 0; iy < MB_SIZE; iy+=2) {
  736. ppxlcRefBot = ppxlcRef + iFieldStep; //UPln -> pixels (xInt,yInt+1);
  737. for (ix = 0; ix < MB_SIZE; ix++){
  738. ppxlcPred [ix] = (ppxlcRef [ix + 1] + ppxlcRef [ix] +
  739. ppxlcRefBot [ix + 1] + ppxlcRefBot [ix] + iRound) >> 2;
  741. }
  742. ppxlcRef = ppxlcRefBot;
  743. ppxlcPred += MB_SIZE*2;
  744. }
  745. }
  746. }
  747. }
  749. Void CVideoObject::motionCompFieldUV ( PixelC* ppxlcPredMBU, PixelC* ppxlcPredMBV,
  750.  const CVOPU8YUVBA* pvopcRef,
  751.  CoordI x, CoordI y, 
  752.  CoordI xRefUV, CoordI yRefUV,Int iRefFieldSelect
  753.  )
  754. {
  755. UInt ix, iy;
  756. // delete by Hyundai for Microsoft and MoMusys alignment
  757. //Int iPxLoc = ((((y + yRefUV) >> 1) & ~1) + EXPANDUV_REF_FRAME) * m_iFrameWidthUV + ((x + xRefUV) >> 1) + EXPANDUV_REF_FRAME;
  758. // insert by Hyundai for Microsoft and MoMusys alignment
  759. Int iPxLoc = (y/2 + ((yRefUV >> 1) & ~1) + EXPANDUV_REF_FRAME) * m_iFrameWidthUV + ((x + xRefUV) >> 1) + EXPANDUV_REF_FRAME;
  761. const PixelC* ppxlcPrevU = pvopcRef->pixelsU () + iPxLoc + iRefFieldSelect*m_iFrameWidthUV;
  762. const PixelC* ppxlcPrevV = pvopcRef->pixelsV () + iPxLoc + iRefFieldSelect*m_iFrameWidthUV;
  763. Int iRound = 1 - m_vopmd.iRoundingControl;
  764. Int iFieldStep = 2 * m_iFrameWidthUV;
  766. if (!(yRefUV & 2)) {
  767. if (!(xRefUV & 1)) {  //!bXSubPxl && !bYSubPxl
  768. for (iy = 0; iy < BLOCK_SIZE; iy+=2) {
  769. memcpy (ppxlcPredMBU, ppxlcPrevU, BLOCK_SIZE*sizeof(PixelC));
  770. memcpy (ppxlcPredMBV, ppxlcPrevV, BLOCK_SIZE*sizeof(PixelC));
  771. ppxlcPrevU += iFieldStep;
  772. ppxlcPrevV += iFieldStep;
  773. ppxlcPredMBU += 2*BLOCK_SIZE;
  774. ppxlcPredMBV += 2*BLOCK_SIZE;
  775. }
  776. }
  777. else {  //bXSubPxl && !bYSubPxl
  778. for (iy = 0; iy < BLOCK_SIZE; iy+=2) {
  779. for (ix = 0; ix < BLOCK_SIZE; ix++) {
  780. ppxlcPredMBU [ix] = (ppxlcPrevU [ix + 1] + ppxlcPrevU [ix] + iRound) >> 1;
  781. ppxlcPredMBV [ix] = (ppxlcPrevV [ix + 1] + ppxlcPrevV [ix] + iRound) >> 1;
  782. }
  783. ppxlcPrevU += iFieldStep;
  784. ppxlcPrevV += iFieldStep;
  785. ppxlcPredMBU += 2*BLOCK_SIZE;
  786. ppxlcPredMBV += 2*BLOCK_SIZE;
  787. }
  788. }
  789. }
  790. else {
  791. const PixelC* ppxlcPrevUBot; 
  792. const PixelC* ppxlcPrevVBot; 
  793. if (!(xRefUV & 1)) {  //!bXSubPxl&& bYSubPxl
  794. for (iy = 0; iy < BLOCK_SIZE; iy+=2) {
  795. ppxlcPrevUBot = ppxlcPrevU + iFieldStep;            //UPln -> pixels (xInt,yInt+1);
  796. ppxlcPrevVBot = ppxlcPrevV + iFieldStep;            //VPln -> pixels (xInt,yInt+1);
  797. for (ix = 0; ix < BLOCK_SIZE; ix++) {
  798. ppxlcPredMBU [ix] = (ppxlcPrevU [ix] + ppxlcPrevUBot [ix] + iRound) >> 1;
  799. ppxlcPredMBV [ix] = (ppxlcPrevV [ix] + ppxlcPrevVBot [ix] + iRound) >> 1;
  800. }
  801. ppxlcPredMBU += 2*BLOCK_SIZE;
  802. ppxlcPredMBV += 2*BLOCK_SIZE;
  803. ppxlcPrevU = ppxlcPrevUBot; 
  804. ppxlcPrevV = ppxlcPrevVBot; 
  805. }
  806. }
  807. else { // bXSubPxl && bYSubPxl
  808. iRound++;
  809. for (iy = 0; iy < BLOCK_SIZE; iy+=2){
  810. ppxlcPrevUBot = ppxlcPrevU + iFieldStep; //UPln -> pixels (xInt,yInt+1);
  811. ppxlcPrevVBot = ppxlcPrevV + iFieldStep; //VPln -> pixels (xInt,yInt+1);
  812. for (ix = 0; ix < BLOCK_SIZE; ix++){
  813. ppxlcPredMBU [ix] = (ppxlcPrevU [ix + 1] + ppxlcPrevU [ix] + 
  814. ppxlcPrevUBot [ix + 1] + ppxlcPrevUBot [ix] + iRound) >> 2;
  815. ppxlcPredMBV [ix] = (ppxlcPrevV [ix + 1] + ppxlcPrevV [ix] + 
  816. ppxlcPrevVBot [ix + 1] + ppxlcPrevVBot [ix] + iRound) >> 2;
  817. }
  818. ppxlcPredMBU += 2*BLOCK_SIZE;
  819. ppxlcPredMBV += 2*BLOCK_SIZE;
  820. ppxlcPrevU = ppxlcPrevUBot; 
  821. ppxlcPrevV = ppxlcPrevVBot; 
  822. }
  823. }
  824. }
  825. }
  827. // #endif // INTERLACE
  829. Void CVideoObject::motionCompUV (
  830. PixelC* ppxlcPredMBU, PixelC* ppxlcPredMBV,
  831. const CVOPU8YUVBA* pvopcRef,
  832. CoordI x, CoordI y, 
  833. CoordI xRefUV, CoordI yRefUV,
  834. Int iRoundingControl,
  835. CRct *prctMVLimit
  836. )
  837. {
  838. UInt ix, iy;
  839. CoordI iTmpX = x + xRefUV;
  840. CoordI iTmpY = y + yRefUV;
  841. limitMVRangeToExtendedBBFullPel (iTmpX,iTmpY,prctMVLimit,MB_SIZE);
  842. xRefUV = iTmpX - x;
  843. yRefUV = iTmpY - y;
  845. Int iPxLoc = (((y + yRefUV) >> 1) + EXPANDUV_REF_FRAME) * m_iFrameWidthUV + ((x + xRefUV) >> 1) + EXPANDUV_REF_FRAME;
  846. const PixelC* ppxlcPrevU = pvopcRef->pixelsU () + iPxLoc;
  847. const PixelC* ppxlcPrevV = pvopcRef->pixelsV () + iPxLoc;
  848. if (!(yRefUV & 1)) {
  849. if (!(xRefUV & 1)) {  //!bXSubPxl && !bYSubPxl
  850. for (iy = 0; iy < BLOCK_SIZE; iy++) {
  851. memcpy (ppxlcPredMBU, ppxlcPrevU, BLOCK_SIZE*sizeof(PixelC));
  852. memcpy (ppxlcPredMBV, ppxlcPrevV, BLOCK_SIZE*sizeof(PixelC));
  853. ppxlcPrevU += m_iFrameWidthUV;
  854. ppxlcPrevV += m_iFrameWidthUV;
  855. ppxlcPredMBU += BLOCK_SIZE;
  856. ppxlcPredMBV += BLOCK_SIZE;
  857. }
  858. }
  859. else {  //bXSubPxl && !bYSubPxl
  860. for (iy = 0; iy < BLOCK_SIZE; iy++) {
  861. for (ix = 0; ix < BLOCK_SIZE; ix++) {
  862. ppxlcPredMBU [ix] = (ppxlcPrevU [ix + 1] + ppxlcPrevU [ix] + 1 - iRoundingControl) >> 1;
  863. ppxlcPredMBV [ix] = (ppxlcPrevV [ix + 1] + ppxlcPrevV [ix] + 1 - iRoundingControl) >> 1;
  864. }
  865. ppxlcPrevU += m_iFrameWidthUV;
  866. ppxlcPrevV += m_iFrameWidthUV;
  867. ppxlcPredMBU += BLOCK_SIZE;
  868. ppxlcPredMBV += BLOCK_SIZE;
  869. }
  870. }
  871. }
  872. else {
  873. const PixelC* ppxlcPrevUBot; 
  874. const PixelC* ppxlcPrevVBot; 
  875. if (!(xRefUV & 1)) {  //!bXSubPxl&& bYSubPxl
  876. for (iy = 0; iy < BLOCK_SIZE; iy++) {
  877. ppxlcPrevUBot = ppxlcPrevU + m_iFrameWidthUV;            //UPln -> pixels (xInt,yInt+1);
  878. ppxlcPrevVBot = ppxlcPrevV + m_iFrameWidthUV;            //VPln -> pixels (xInt,yInt+1);
  879. for (ix = 0; ix < BLOCK_SIZE; ix++) {
  880. // ppxlcPredMBU [ix] = (ppxlcPrevU [ix] + ppxlcPrevUBot [ix] + 1) >> 1;
  881. // ppxlcPredMBV [ix] = (ppxlcPrevV [ix] + ppxlcPrevVBot [ix] + 1) >> 1;
  882. ppxlcPredMBU [ix] = (ppxlcPrevU [ix] + ppxlcPrevUBot [ix] + 1 - iRoundingControl) >> 1;
  883. ppxlcPredMBV [ix] = (ppxlcPrevV [ix] + ppxlcPrevVBot [ix] + 1 - iRoundingControl) >> 1;
  884. }
  885. ppxlcPredMBU += BLOCK_SIZE;
  886. ppxlcPredMBV += BLOCK_SIZE;
  887. ppxlcPrevU = ppxlcPrevUBot; 
  888. ppxlcPrevV = ppxlcPrevVBot; 
  889. }
  890. }
  891. else { // bXSubPxl && bYSubPxl
  892. for (iy = 0; iy < BLOCK_SIZE; iy++){
  893. ppxlcPrevUBot = ppxlcPrevU + m_iFrameWidthUV; //UPln -> pixels (xInt,yInt+1);
  894. ppxlcPrevVBot = ppxlcPrevV + m_iFrameWidthUV; //VPln -> pixels (xInt,yInt+1);
  895. for (ix = 0; ix < BLOCK_SIZE; ix++){
  896. /*
  897. ppxlcPredMBU [ix] = (
  898. ppxlcPrevU [ix + 1] + ppxlcPrevU [ix] + 
  899. ppxlcPrevUBot [ix + 1] + ppxlcPrevUBot [ix] + 2
  900. ) >> 2;
  901. ppxlcPredMBV [ix] = (
  902. ppxlcPrevV [ix + 1] + ppxlcPrevV [ix] + 
  903. ppxlcPrevVBot [ix + 1] + ppxlcPrevVBot [ix] + 2
  904. ) >> 2;
  905. */
  906. ppxlcPredMBU [ix] = (
  907. ppxlcPrevU [ix + 1] + ppxlcPrevU [ix] + 
  908. ppxlcPrevUBot [ix + 1] + ppxlcPrevUBot [ix] + 2 - iRoundingControl
  909. ) >> 2;
  910. ppxlcPredMBV [ix] = (
  911. ppxlcPrevV [ix + 1] + ppxlcPrevV [ix] + 
  912. ppxlcPrevVBot [ix + 1] + ppxlcPrevVBot [ix] + 2 - iRoundingControl
  913. ) >> 2;
  914. }
  915. ppxlcPredMBU += BLOCK_SIZE;
  916. ppxlcPredMBV += BLOCK_SIZE;
  917. ppxlcPrevU = ppxlcPrevUBot; 
  918. ppxlcPrevV = ppxlcPrevVBot; 
  919. }
  920. }
  921. }
  922. }
  924. UInt gOvrlpPredY [64];
  926. Void CVideoObject::motionCompOverLap (
  927. PixelC* ppxlcPredMB, 
  928. const PixelC* ppxlcRefLeftTop,
  929. const CMotionVector* pmv, // motion vector
  930. const CMBMode* pmbmd, // macroblk mode
  931. Int imbx, // current macroblk index
  932. Int imby, // current macroblk index
  933. CoordI x, // current coordinate system
  934. CoordI y, // current coordinate system
  935. CRct *prctMVLimit
  936. )
  937. {
  938. // Overlap Motion Comp use motion vector of current blk and motion vectors of neighboring blks.
  939. const CMotionVector *pmvC,*pmvT = NULL,*pmvB = NULL,*pmvR = NULL,*pmvL = NULL; // MVs of Cur, Top, Bot, Right and Left Blocks.
  940. const CMotionVector *pmvCurrMb,*pmvTopMb = NULL;
  941. const CMotionVector *pmvRightMb = NULL,*pmvLeftMb = NULL; // MVs of Cur, Top, Right and Left MacroBlocks.
  942. const CMBMode *pmbmdTopMb = NULL, *pmbmdRightMb = NULL, *pmbmdLeftMb = NULL; 
  943. // MVs of Cur, Top, Right and Left MacroBlocks.
  944. Bool bIntraT = FALSE, bIntraR = FALSE, bIntraL = FALSE; // flags of 4MV for Cur, Top, Right and Left MacroBlocks.
  945. Bool bLeftBndry, bRightBndry, bTopBndry;
  946. bLeftBndry = (imbx == 0);
  947. bRightBndry = (imbx == m_iNumMBX - 1);
  948. bTopBndry = (imby == 0);
  950. pmvCurrMb = pmv;
  951. // assign the neighboring blk's MVs to pmv[TBRLC]
  952. if (!bTopBndry) {
  953. pmbmdTopMb = pmbmd - m_iNumMBX; 
  954. bIntraT = (pmbmdTopMb->m_dctMd == INTRA || pmbmdTopMb->m_dctMd == INTRAQ);
  955. pmvTopMb = pmv - m_iNumOfTotalMVPerRow;
  956. }
  957. if (!bLeftBndry) {
  958. pmbmdLeftMb = pmbmd - 1;
  959. bIntraL = (pmbmdLeftMb->m_dctMd == INTRA || pmbmdLeftMb->m_dctMd == INTRAQ);
  960. pmvLeftMb = pmv - PVOP_MV_PER_REF_PER_MB;
  961. }
  962. if (!bRightBndry) {
  963. pmbmdRightMb = pmbmd + 1;
  964. bIntraR = (pmbmdRightMb->m_dctMd == INTRA || pmbmdRightMb->m_dctMd == INTRAQ);
  965. pmvRightMb = pmv + PVOP_MV_PER_REF_PER_MB;
  966. }
  968. UInt i;
  969. // assign the neighboring blk's MVs to pmv[TBRLC] 
  970. for (i = 1; i < 5; i++) {
  971. if (pmbmd->m_rgTranspStatus [i] == ALL)
  972. continue;
  973. pmvC = pmvCurrMb + i;
  974. switch (i) {
  975. case 1:
  976. if (pmbmd->m_rgTranspStatus [3] == ALL)
  977. pmvB = pmvCurrMb + 1;
  978. else
  979. pmvB = pmvCurrMb + 3;
  981. if (pmbmd->m_rgTranspStatus [2] == ALL)
  982. pmvR = pmvCurrMb + 1; 
  983. else
  984. pmvR = pmvCurrMb + 2; 
  986. if (bTopBndry || bIntraT || pmbmdTopMb->m_rgTranspStatus [3] == ALL)
  987. pmvT = pmvCurrMb + 1;
  988. else
  989. pmvT = pmvTopMb + 3;
  991. if (bLeftBndry || bIntraL || pmbmdLeftMb->m_rgTranspStatus [2] == ALL)
  992. pmvL = pmvCurrMb + 1;
  993. else
  994. pmvL = pmvLeftMb + 2;
  995. break;
  996. case 2:
  997. if (pmbmd->m_rgTranspStatus [4] == ALL)
  998. pmvB = pmvCurrMb + 2;
  999. else
  1000. pmvB = pmvCurrMb + 4;
  1002. if (pmbmd->m_rgTranspStatus [1] == ALL)
  1003. pmvL = pmvCurrMb + 2;
  1004. else
  1005. pmvL = pmvCurrMb + 1;
  1007. if (bTopBndry || bIntraT || pmbmdTopMb->m_rgTranspStatus [4] == ALL)
  1008. pmvT = pmvCurrMb + 2;
  1009. else
  1010. pmvT = pmvTopMb + 4;      
  1012. if (bRightBndry || bIntraR || pmbmdRightMb->m_rgTranspStatus [1] == ALL)
  1013. pmvR = pmvCurrMb + 2;
  1014. else
  1015. pmvR = pmvRightMb + 1;
  1016. break;
  1017. case 3:
  1018. if (pmbmd->m_rgTranspStatus [1] == ALL)
  1019. pmvT = pmvCurrMb + 3;  
  1020. else
  1021. pmvT = pmvCurrMb + 1;
  1023. pmvB = pmvCurrMb + 3; // use the current mv
  1025. if (pmbmd->m_rgTranspStatus [4] == ALL)
  1026. pmvR = pmvCurrMb + 3;
  1027. else
  1028. pmvR = pmvCurrMb + 4;
  1030. if (bLeftBndry || bIntraL || pmbmdLeftMb->m_rgTranspStatus [4] == ALL)
  1031. pmvL = pmvCurrMb + 3;
  1032. else
  1033. pmvL = pmvLeftMb + 4;
  1034. break;
  1035. case 4:
  1036. if (pmbmd->m_rgTranspStatus [2] == ALL)
  1037. pmvT = pmvCurrMb + 4;    
  1038. else
  1039. pmvT = pmvCurrMb + 2;
  1041. pmvB = pmvCurrMb + 4;
  1043. if (pmbmd->m_rgTranspStatus [3] == ALL)
  1044. pmvL = pmvCurrMb + 4;  
  1045. else
  1046. pmvL = pmvCurrMb + 3;
  1048. if (bRightBndry || bIntraR || pmbmdRightMb->m_rgTranspStatus [3] == ALL)
  1049. pmvR = pmvCurrMb + 4;
  1050. else
  1051. pmvR = pmvRightMb + 3;
  1052. break;
  1053. default:
  1054. assert (FALSE);
  1055. }
  1056. // Compute the top left corner's x,y coordinates of current block.
  1057. UInt dxc = (((i - 1) & 1) << 3);
  1058. UInt dyc = (((i - 1) & 2) << 2);
  1059. UInt nxcY = (x + dxc) << 1; 
  1060. UInt nycY = (y + dyc) << 1; 
  1061. // Compute the corresponding positions on Ref frm, using 5 MVs.
  1062. CoordI xRefC = nxcY + pmvC->m_vctTrueHalfPel.x, yRefC = nycY + pmvC->m_vctTrueHalfPel.y;
  1063. CoordI xRefT = nxcY + pmvT->m_vctTrueHalfPel.x, yRefT = nycY + pmvT->m_vctTrueHalfPel.y;
  1064. CoordI xRefB = nxcY + pmvB->m_vctTrueHalfPel.x, yRefB = nycY + pmvB->m_vctTrueHalfPel.y;
  1065. CoordI xRefR = nxcY + pmvR->m_vctTrueHalfPel.x, yRefR = nycY + pmvR->m_vctTrueHalfPel.y;
  1066. CoordI xRefL = nxcY + pmvL->m_vctTrueHalfPel.x, yRefL = nycY + pmvL->m_vctTrueHalfPel.y;
  1067. // UInt nxcY = x + dxc;
  1068. // UInt nycY = y + dyc;
  1069. // // Compute the corresponding positions on Ref frm, using 5 MVs.
  1070. // CoordI xRefC = ((nxcY + pmvC -> iMVX) << 1) + pmvC -> iHalfX, yRefC = ((nycY + pmvC -> iMVY) << 1) + pmvC -> iHalfY;
  1071. // CoordI xRefT = ((nxcY + pmvT -> iMVX) << 1) + pmvT -> iHalfX, yRefT = ((nycY + pmvT -> iMVY) << 1) + pmvT -> iHalfY;
  1072. //   CoordI xRefB = ((nxcY + pmvB -> iMVX) << 1) + pmvB -> iHalfX, yRefB = ((nycY + pmvB -> iMVY) << 1) + pmvB -> iHalfY;
  1073. // CoordI xRefR = ((nxcY + pmvR -> iMVX) << 1) + pmvR -> iHalfX, yRefR = ((nycY + pmvR -> iMVY) << 1) + pmvR -> iHalfY;
  1074. // CoordI xRefL = ((nxcY + pmvL -> iMVX) << 1) + pmvL -> iHalfX, yRefL = ((nycY + pmvL -> iMVY) << 1) + pmvL -> iHalfY;
  1075. limitMVRangeToExtendedBBHalfPel (xRefC,yRefC,prctMVLimit,BLOCK_SIZE);
  1076. limitMVRangeToExtendedBBHalfPel (xRefT,yRefT,prctMVLimit,BLOCK_SIZE);
  1077. limitMVRangeToExtendedBBHalfPel (xRefB,yRefB,prctMVLimit,BLOCK_SIZE);
  1078. limitMVRangeToExtendedBBHalfPel (xRefR,yRefR,prctMVLimit,BLOCK_SIZE);
  1079. limitMVRangeToExtendedBBHalfPel (xRefL,yRefL,prctMVLimit,BLOCK_SIZE);
  1081. Bool bXSubPxlC = (xRefC & 1), bYSubPxlC = (yRefC & 1),
  1082.  bXSubPxlT = (xRefT & 1), bYSubPxlT = (yRefT & 1),
  1083.  bXSubPxlB = (xRefB & 1), bYSubPxlB = (yRefB & 1),
  1084.  bXSubPxlR = (xRefR & 1), bYSubPxlR = (yRefR & 1),
  1085.  bXSubPxlL = (xRefL & 1), bYSubPxlL = (yRefL & 1);
  1087. // 5 starting pos. in Zoomed Ref. Frames
  1088. const PixelC* ppxliPrevYC = ppxlcRefLeftTop + ((yRefC >> 1) + EXPANDY_REF_FRAME) * m_iFrameWidthY + (xRefC >> 1) + EXPANDY_REF_FRAME;
  1089. const PixelC* ppxliPrevYT = ppxlcRefLeftTop + ((yRefT >> 1) + EXPANDY_REF_FRAME) * m_iFrameWidthY + (xRefT >> 1) + EXPANDY_REF_FRAME;
  1090. const PixelC* ppxliPrevYB = ppxlcRefLeftTop + ((yRefB >> 1) + EXPANDY_REF_FRAME) * m_iFrameWidthY + (xRefB >> 1) + EXPANDY_REF_FRAME;
  1091. const PixelC* ppxliPrevYR = ppxlcRefLeftTop + ((yRefR >> 1) + EXPANDY_REF_FRAME) * m_iFrameWidthY + (xRefR >> 1) + EXPANDY_REF_FRAME;
  1092. const PixelC* ppxliPrevYL = ppxlcRefLeftTop + ((yRefL >> 1) + EXPANDY_REF_FRAME) * m_iFrameWidthY + (xRefL >> 1) + EXPANDY_REF_FRAME;
  1093. UInt *pWghtC, *pWghtT, *pWghtB, *pWghtR, *pWghtL;
  1094. pWghtC = (UInt*) gWghtC;
  1095. pWghtT = (UInt*) gWghtT;
  1096. pWghtB = (UInt*) gWghtB + 32;
  1097. pWghtR = (UInt*) gWghtR;
  1098. pWghtL = (UInt*) gWghtL;
  1099. UInt* uiOvrlpPredY = gOvrlpPredY;
  1101. if (bXSubPxlC && bYSubPxlC)
  1102. bilnrMCVH (uiOvrlpPredY, ppxliPrevYC, pWghtC, 0, 8, 0, 8, FALSE);
  1103. else if (bXSubPxlC && !bYSubPxlC)
  1104. bilnrMCH (uiOvrlpPredY, ppxliPrevYC, pWghtC, 0, 8, 0, 8, FALSE);
  1105. else if (!bXSubPxlC && bYSubPxlC)
  1106. bilnrMCV (uiOvrlpPredY, ppxliPrevYC, pWghtC, 0, 8, 0, 8, FALSE);
  1107. else // (!bXSubPxlC && !bYSubPxlC)
  1108. bilnrMC (uiOvrlpPredY, ppxliPrevYC, pWghtC, 0, 8, 0, 8, FALSE);
  1110. if (bXSubPxlT && bYSubPxlT)
  1111. bilnrMCVH (uiOvrlpPredY, ppxliPrevYT, pWghtT, 0, 8, 0, 4, TRUE);
  1112. else if (bXSubPxlT && !bYSubPxlT)
  1113. bilnrMCH (uiOvrlpPredY, ppxliPrevYT, pWghtT, 0, 8, 0, 4, TRUE);
  1114. else if (!bXSubPxlT && bYSubPxlT)
  1115. bilnrMCV (uiOvrlpPredY, ppxliPrevYT, pWghtT, 0, 8, 0, 4, TRUE);
  1116. else // (!bXSubPxlT && !bYSubPxlT)
  1117. bilnrMC (uiOvrlpPredY, ppxliPrevYT, pWghtT, 0, 8, 0, 4, TRUE);
  1119. if (bXSubPxlB && bYSubPxlB)
  1120. bilnrMCVH (&uiOvrlpPredY [32], ppxliPrevYB + (m_iFrameWidthY << 2), pWghtB, 0, 8, 4, 8, TRUE);
  1121. else if (bXSubPxlB && !bYSubPxlB)
  1122. bilnrMCH (&uiOvrlpPredY [32], ppxliPrevYB + (m_iFrameWidthY << 2), pWghtB, 0, 8, 4, 8, TRUE);
  1123. else if (!bXSubPxlB && bYSubPxlB)
  1124. bilnrMCV (&uiOvrlpPredY [32], ppxliPrevYB + (m_iFrameWidthY << 2), pWghtB, 0, 8, 4, 8, TRUE);
  1125. else // (!bXSubPxlB && !bYSubPxlB)
  1126. bilnrMC (&uiOvrlpPredY [32], ppxliPrevYB + (m_iFrameWidthY << 2), pWghtB, 0, 8, 4, 8, TRUE);
  1128. if (bXSubPxlR && bYSubPxlR)
  1129. bilnrMCVH (uiOvrlpPredY, ppxliPrevYR, pWghtR, 4, 8, 0, 8, TRUE);
  1130. else if (bXSubPxlR && !bYSubPxlR)
  1131. bilnrMCH (uiOvrlpPredY, ppxliPrevYR, pWghtR, 4, 8, 0, 8, TRUE);
  1132. else if (!bXSubPxlR && bYSubPxlR)
  1133. bilnrMCV (uiOvrlpPredY, ppxliPrevYR, pWghtR, 4, 8, 0, 8, TRUE);
  1134. else // (!bXSubPxlR && !bYSubPxlR)
  1135. bilnrMC (uiOvrlpPredY, ppxliPrevYR, pWghtR, 4, 8, 0, 8, TRUE);
  1137. if (bXSubPxlL && bYSubPxlL)
  1138. bilnrMCVH (uiOvrlpPredY, ppxliPrevYL, pWghtL, 0, 4, 0, 8, TRUE);
  1139. else if (bXSubPxlL && !bYSubPxlL)
  1140. bilnrMCH (uiOvrlpPredY, ppxliPrevYL, pWghtL, 0, 4, 0, 8, TRUE);
  1141. else if (!bXSubPxlL && bYSubPxlL)
  1142. bilnrMCV (uiOvrlpPredY, ppxliPrevYL, pWghtL, 0, 4, 0, 8, TRUE);
  1143. else // (!bXSubPxlL && !bYSubPxlL)
  1144. bilnrMC (uiOvrlpPredY, ppxliPrevYL, pWghtL, 0, 4, 0, 8, TRUE);
  1146. PixelC* ppxliPredY = ppxlcPredMB + dxc + dyc * MB_SIZE;  // Starting of Pred. Frame
  1147. for (UInt iy = 0; iy < BLOCK_SIZE; iy++){
  1148. for (UInt ix = 0; ix < BLOCK_SIZE; ix++)
  1149. *ppxliPredY++= (*uiOvrlpPredY++ + 4) >> 3;
  1150. ppxliPredY += BLOCK_SIZE;
  1151. }
  1152. }
  1153. }
  1155. Void CVideoObject::bilnrMCVH (UInt* PredY, const PixelC* ppxliPrevYC, UInt* pMWght, UInt xlow, UInt xhigh, UInt ylow, UInt yhigh, Bool bAdd)
  1156. {
  1157. const PixelC* ppxliPrevYCBot = ppxliPrevYC + m_iFrameWidthY;
  1158. if (bAdd)
  1159. for (UInt iy = ylow; iy < yhigh; iy++) {
  1160. for (UInt ix = xlow; ix < xhigh; ix++)
  1161. // PredY [ix] += ((UInt) (ppxliPrevYC [ix] + ppxliPrevYC [ix + 1] + ppxliPrevYCBot [ix] + ppxliPrevYCBot[ix+1] + 2) >> 2) * pMWght [ix];
  1162. PredY [ix] += ((UInt) (ppxliPrevYC [ix] + ppxliPrevYC [ix + 1] + ppxliPrevYCBot [ix] + ppxliPrevYCBot[ix+1] + 2 - m_vopmd.iRoundingControl) >> 2) * pMWght [ix];
  1163. ppxliPrevYC += m_iFrameWidthY;
  1164. ppxliPrevYCBot += m_iFrameWidthY;
  1165. PredY += BLOCK_SIZE;
  1166. pMWght += BLOCK_SIZE;
  1167. }
  1168. else
  1169. for (UInt iy = ylow; iy < yhigh; iy++) {
  1170. for (UInt ix = xlow; ix < xhigh; ix++)
  1171. // PredY [ix] = ((UInt) (ppxliPrevYC [ix] + ppxliPrevYC [ix + 1] + ppxliPrevYCBot [ix] + ppxliPrevYCBot[ix+1] + 2) >> 2) * pMWght [ix];
  1172. PredY [ix] = ((UInt) (ppxliPrevYC [ix] + ppxliPrevYC [ix + 1] + ppxliPrevYCBot [ix] + ppxliPrevYCBot[ix+1] + 2 - m_vopmd.iRoundingControl) >> 2) * pMWght [ix];
  1173. ppxliPrevYC += m_iFrameWidthY;
  1174. ppxliPrevYCBot += m_iFrameWidthY;
  1175. PredY += BLOCK_SIZE;
  1176. pMWght += BLOCK_SIZE;
  1177. }
  1178. }
  1180. Void CVideoObject::bilnrMCV (UInt* PredY, const PixelC* ppxliPrevYC, UInt* pMWght, UInt xlow, UInt xhigh, UInt ylow, UInt yhigh, Bool bAdd)
  1181. {
  1182. const PixelC* ppxliPrevYCBot = ppxliPrevYC + m_iFrameWidthY;
  1183. if (bAdd)
  1184. for (UInt iy = ylow; iy < yhigh; iy++) {
  1185. for (UInt ix = xlow; ix < xhigh; ix++)
  1186. // PredY [ix] += ((UInt) (ppxliPrevYC [ix] + ppxliPrevYCBot [ix] + 1) >> 1) * pMWght [ix];
  1187.   PredY [ix] += ((UInt) (ppxliPrevYC [ix] + ppxliPrevYCBot [ix] + 1 - m_vopmd.iRoundingControl) >> 1) * pMWght [ix];
  1188. ppxliPrevYC += m_iFrameWidthY;
  1189. ppxliPrevYCBot += m_iFrameWidthY;
  1190. PredY += BLOCK_SIZE;
  1191. pMWght += BLOCK_SIZE;
  1192. }
  1193. else
  1194. for (UInt iy = ylow; iy < yhigh; iy++) {
  1195. for (UInt ix = xlow; ix < xhigh; ix++)
  1196. // PredY [ix] = ((UInt) (ppxliPrevYC [ix] + ppxliPrevYCBot [ix] + 1) >> 1) * pMWght [ix];
  1197. PredY [ix] = ((UInt) (ppxliPrevYC [ix] + ppxliPrevYCBot [ix] + 1 - m_vopmd.iRoundingControl) >> 1) * pMWght [ix];
  1198. ppxliPrevYC += m_iFrameWidthY;
  1199. ppxliPrevYCBot += m_iFrameWidthY;
  1200. PredY += BLOCK_SIZE;
  1201. pMWght += BLOCK_SIZE;
  1202. }
  1203. }
  1205. Void CVideoObject::bilnrMCH (UInt* PredY, const PixelC* ppxliPrevYC, UInt* pMWght, UInt xlow, UInt xhigh, UInt ylow, UInt yhigh, Bool bAdd)
  1206. {
  1207. //PixelC* ppxliPrevYCBot = ppxliPrevYC + m_iFrameWidthY;
  1208. if (bAdd)
  1209. for (UInt iy = ylow; iy < yhigh; iy++) {
  1210. for (UInt ix = xlow; ix < xhigh; ix++)
  1211. // PredY [ix] += ((UInt) (ppxliPrevYC [ix] + ppxliPrevYC [ix + 1] + 1) >> 1) * pMWght [ix];
  1212. PredY [ix] += ((UInt) (ppxliPrevYC [ix] + ppxliPrevYC [ix + 1] + 1 - m_vopmd.iRoundingControl) >> 1) * pMWght [ix];
  1213. ppxliPrevYC += m_iFrameWidthY;
  1214. PredY += BLOCK_SIZE;
  1215. pMWght += BLOCK_SIZE;
  1216. }
  1217. else
  1218. for (UInt iy = ylow; iy < yhigh; iy++) {
  1219. for (UInt ix = xlow; ix < xhigh; ix++)
  1220. // PredY [ix] = ((UInt) (ppxliPrevYC [ix] + ppxliPrevYC [ix + 1] + 1) >> 1) * pMWght [ix];
  1221. PredY [ix] = ((UInt) (ppxliPrevYC [ix] + ppxliPrevYC [ix + 1] + 1 - m_vopmd.iRoundingControl) >> 1) * pMWght [ix];
  1222. ppxliPrevYC += m_iFrameWidthY;
  1223. PredY += BLOCK_SIZE;
  1224. pMWght += BLOCK_SIZE;
  1225. }
  1226. }
  1228. Void CVideoObject::bilnrMC (UInt* PredY, const PixelC* ppxliPrevYC, UInt* pMWght, UInt xlow, UInt xhigh, UInt ylow, UInt yhigh, Bool bAdd)
  1229. {
  1230. //PixelC* ppxliPrevYCBot = ppxliPrevYC + m_iFrameWidthY;
  1231. if (bAdd)
  1232. for (UInt iy = ylow; iy < yhigh; iy++) {
  1233. for (UInt ix = xlow; ix < xhigh; ix++)
  1234. PredY [ix] += (UInt) ppxliPrevYC [ix] * pMWght[ix];
  1235. ppxliPrevYC += m_iFrameWidthY;
  1236. PredY += BLOCK_SIZE;
  1237. pMWght += BLOCK_SIZE;
  1238. }
  1239. else
  1240. for (UInt iy = ylow; iy < yhigh; iy++) {
  1241. for (UInt ix = xlow; ix < xhigh; ix++)
  1242. PredY [ix] = (UInt) ppxliPrevYC [ix] * pMWght [ix];
  1243. ppxliPrevYC += m_iFrameWidthY;
  1244. PredY += BLOCK_SIZE;
  1245. pMWght += BLOCK_SIZE;
  1246. }
  1247. }
  1249. Void CVideoObject::motionCompBY (
  1250. PixelC* ppxlcPred, // can be either Y or A
  1251. const PixelC* ppxlcRefLeftTop,
  1252. CoordI iXRef, CoordI iYRef // x + mvX in full pel unit
  1253. )
  1254. {
  1255. CoordI iY;
  1256. const PixelC* ppxlcRef = ppxlcRefLeftTop + 
  1257. (iYRef + EXPANDY_REF_FRAME) * m_iFrameWidthY + iXRef + EXPANDY_REF_FRAME;
  1258.     // bugfix: use the proper bounding rect (!), 981028 mwi
  1259.     Int iLeftBound;
  1260.     Int iRightBound;
  1261.     Int iTopBound;
  1262.     Int iBottomBound;
  1263.     if (m_vopmd.vopPredType == BVOP && m_vopmd.fShapeBPredDir == B_BACKWARD) {
  1264.       iLeftBound = max(0,m_rctRefVOPY1.left - iXRef);
  1265.       iRightBound = max(0,m_rctRefVOPY1.right - iXRef);
  1266.       iTopBound = max(0,m_rctRefVOPY1.top - iYRef);
  1267.       iBottomBound = max(0,m_rctRefVOPY1.bottom - iYRef);
  1268.     }
  1269.     else {
  1270.       iLeftBound = max(0,m_rctRefVOPY0.left - iXRef);
  1271.       iRightBound = max(0,m_rctRefVOPY0.right - iXRef);
  1272.       iTopBound = max(0,m_rctRefVOPY0.top - iYRef);
  1273.       iBottomBound = max(0,m_rctRefVOPY0.bottom - iYRef);
  1274.     }
  1275.     // ~bugfix: use the proper bounding rect
  1277. iLeftBound = min(MC_BAB_SIZE,iLeftBound);
  1278. iRightBound = min(MC_BAB_SIZE,iRightBound);
  1279. iTopBound = min(MC_BAB_SIZE,iTopBound);
  1280. iBottomBound = min(MC_BAB_SIZE,iBottomBound);
  1282. Int iHeightMax = iBottomBound-iTopBound;
  1283. Int iWidthMax  = iRightBound-iLeftBound;
  1285. if (iHeightMax == MC_BAB_SIZE && iWidthMax == MC_BAB_SIZE) {
  1286. for (iY = 0; iY < MC_BAB_SIZE; iY++) {
  1287. memcpy (ppxlcPred, ppxlcRef, MC_BAB_SIZE*sizeof(PixelC));
  1288. ppxlcRef  += m_iFrameWidthY;
  1289. ppxlcPred += MC_BAB_SIZE;
  1290. }
  1291. } else if(iWidthMax == 0 || iHeightMax==0)
  1292. for (iY = 0; iY < MC_BAB_SIZE; iY++) {
  1293. memset (ppxlcPred, 0, MC_BAB_SIZE*sizeof(PixelC));
  1294. ppxlcPred += MC_BAB_SIZE;
  1295. }
  1296. else {
  1297. for (iY = 0; iY < MC_BAB_SIZE; iY++) {
  1298. if(iY<iTopBound || iY>=iBottomBound)
  1299. memset (ppxlcPred, 0, MC_BAB_SIZE*sizeof(PixelC));  // clear row
  1300. else
  1301. {
  1302. if(iLeftBound>0)
  1303. memset (ppxlcPred, 0, iLeftBound*sizeof(PixelC)); // clear left hand span
  1304. if(iRightBound<MC_BAB_SIZE)
  1305. memset (ppxlcPred+iRightBound, 0, (MC_BAB_SIZE-iRightBound)*sizeof(PixelC)); // right span
  1306. memcpy (ppxlcPred+iLeftBound, ppxlcRef+iLeftBound, iWidthMax*sizeof(PixelC)); // copy middle region
  1307. }
  1309. ppxlcRef += m_iFrameWidthY;
  1310. ppxlcPred += MC_BAB_SIZE;
  1311. }
  1312. }
  1313. }
  1315. Void CVideoObject::copyFromRefToCurrQ (
  1316. const CVOPU8YUVBA* pvopcRef, // reference VOP
  1317. CoordI x, CoordI y, 
  1318. PixelC* ppxlcCurrQMBY, PixelC* ppxlcCurrQMBU, PixelC* ppxlcCurrQMBV,
  1319. CRct *prctMVLimit
  1320. )
  1321. {
  1322. // needs limiting to reference area bounding box
  1323. limitMVRangeToExtendedBBFullPel(x,y,prctMVLimit,MB_SIZE);
  1325. Int iOffsetY = (y + EXPANDY_REF_FRAME) * m_iFrameWidthY + x + EXPANDY_REF_FRAME;
  1326. Int iOffsetUV = (y / 2 + EXPANDUV_REF_FRAME) * m_iFrameWidthUV + x / 2 + EXPANDUV_REF_FRAME;
  1327. const PixelC* ppxlcRefMBY = pvopcRef->pixelsY () + iOffsetY;
  1328. const PixelC* ppxlcRefMBU = pvopcRef->pixelsU () + iOffsetUV;
  1329. const PixelC* ppxlcRefMBV = pvopcRef->pixelsV () + iOffsetUV;
  1331. CoordI iY;
  1332. for (iY = 0; iY < BLOCK_SIZE; iY++) {
  1333. memcpy (ppxlcCurrQMBY, ppxlcRefMBY, MB_SIZE*sizeof(PixelC));
  1334. memcpy (ppxlcCurrQMBU, ppxlcRefMBU, BLOCK_SIZE*sizeof(PixelC));
  1335. memcpy (ppxlcCurrQMBV, ppxlcRefMBV, BLOCK_SIZE*sizeof(PixelC));
  1337. ppxlcCurrQMBY += m_iFrameWidthY; ppxlcRefMBY += m_iFrameWidthY;
  1338. ppxlcCurrQMBU += m_iFrameWidthUV; ppxlcRefMBU += m_iFrameWidthUV;
  1339. ppxlcCurrQMBV += m_iFrameWidthUV; ppxlcRefMBV += m_iFrameWidthUV;
  1341. memcpy (ppxlcCurrQMBY, ppxlcRefMBY, MB_SIZE*sizeof(PixelC));
  1342. ppxlcCurrQMBY += m_iFrameWidthY; ppxlcRefMBY += m_iFrameWidthY;
  1343. }
  1344. }
  1346. Void CVideoObject::copyFromRefToCurrQ_WithShape (
  1347. const CVOPU8YUVBA* pvopcRef, // reference VOP
  1348. CoordI x, CoordI y, 
  1349. PixelC* ppxlcCurrQMBY, PixelC* ppxlcCurrQMBU, PixelC* ppxlcCurrQMBV, PixelC* ppxlcCurrQMBBY
  1350. )
  1351. {
  1352. Int iOffsetY = (y + EXPANDY_REF_FRAME) * m_iFrameWidthY + x + EXPANDY_REF_FRAME;
  1353. Int iOffsetUV = (y / 2 + EXPANDUV_REF_FRAME) * m_iFrameWidthUV + x / 2 + EXPANDUV_REF_FRAME;
  1354. const PixelC* ppxlcRefMBY = pvopcRef->pixelsY () + iOffsetY;
  1355. const PixelC* ppxlcRefMBBY = pvopcRef->pixelsBY () + iOffsetY;
  1356. const PixelC* ppxlcRefMBU = pvopcRef->pixelsU () + iOffsetUV;
  1357. const PixelC* ppxlcRefMBV = pvopcRef->pixelsV () + iOffsetUV;
  1359. CoordI iY;
  1360. for (iY = 0; iY < BLOCK_SIZE; iY++) {
  1361. memcpy (ppxlcCurrQMBY, ppxlcRefMBY, MB_SIZE*sizeof(PixelC));
  1362. memcpy (ppxlcCurrQMBBY, ppxlcRefMBBY, MB_SIZE*sizeof(PixelC));
  1363. memcpy (ppxlcCurrQMBU, ppxlcRefMBU, BLOCK_SIZE*sizeof(PixelC));
  1364. memcpy (ppxlcCurrQMBV, ppxlcRefMBV, BLOCK_SIZE*sizeof(PixelC));
  1366. ppxlcCurrQMBY += m_iFrameWidthY; ppxlcRefMBY += m_iFrameWidthY;
  1367. ppxlcCurrQMBBY += m_iFrameWidthY; ppxlcRefMBBY += m_iFrameWidthY;
  1368. ppxlcCurrQMBU += m_iFrameWidthUV; ppxlcRefMBU += m_iFrameWidthUV;
  1369. ppxlcCurrQMBV += m_iFrameWidthUV; ppxlcRefMBV += m_iFrameWidthUV;
  1371. memcpy (ppxlcCurrQMBY, ppxlcRefMBY, MB_SIZE*sizeof(PixelC));
  1372. ppxlcCurrQMBY += m_iFrameWidthY; ppxlcRefMBY += m_iFrameWidthY;
  1373. memcpy (ppxlcCurrQMBBY, ppxlcRefMBBY, MB_SIZE*sizeof(PixelC));
  1374. ppxlcCurrQMBBY += m_iFrameWidthY; ppxlcRefMBBY += m_iFrameWidthY;
  1375. }
  1376. }
  1378. Void CVideoObject::copyAlphaFromRefToCurrQ (
  1379. const CVOPU8YUVBA* pvopcRef, // reference VOP
  1380. CoordI x, CoordI y, 
  1381. PixelC* ppxlcCurrQMBA,
  1382. CRct *prctMVLimit
  1383. )
  1384. {
  1385. // needs limiting to reference area bounding box
  1386. limitMVRangeToExtendedBBFullPel(x,y,prctMVLimit,MB_SIZE);
  1388. Int iOffsetY = (y + EXPANDY_REF_FRAME) * m_iFrameWidthY + x + EXPANDY_REF_FRAME;
  1389. const PixelC* ppxlcRefMBA = pvopcRef->pixelsA () + iOffsetY;
  1391. CoordI iY;
  1392. for (iY = 0; iY < MB_SIZE; iY++) {
  1393. memcpy (ppxlcCurrQMBA, ppxlcRefMBA, MB_SIZE*sizeof(PixelC));
  1394. ppxlcCurrQMBA += m_iFrameWidthY; 
  1395. ppxlcRefMBA += m_iFrameWidthY;
  1396. }
  1397. }