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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

mcenc.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. mcenc.cpp
  32. Abstract:
  34. Motion compensation routines for encoder.
  36. Revision History:
  37. Dec 20, 1997: Interlaced tools added by NextLevel Systems
  39. *************************************************************************/
  41. #include <stdio.h>
  42. #include <math.h>
  43. #include <stdlib.h>
  44. #include <iostream.h>
  46. #include "typeapi.h"
  47. #include "codehead.h"
  48. #include "global.hpp"
  49. #include "entropy/bitstrm.hpp"
  50. #include "entropy/entropy.hpp"
  51. #include "entropy/huffman.hpp"
  52. #include "mode.hpp"
  53. #include "vopses.hpp"
  54. #include "vopseenc.hpp"
  56. #ifdef __MFC_
  57. #ifdef _DEBUG
  58. #undef THIS_FILE
  59. static char BASED_CODE THIS_FILE[] = __FILE__;
  60. #endif
  62. #define new DEBUG_NEW    
  63. #endif // __MFC_
  65. #define OFFSET_BLK1 8
  66. #define OFFSET_BLK2 128
  67. #define OFFSET_BLK3 136
  69. Void CVideoObjectEncoder::motionCompMBYEnc (
  70. const CMotionVector* pmv, const CMBMode* pmbmd, 
  71. Int imbX, Int imbY,
  72. CoordI x, CoordI y,
  73. CRct *prctMVLimit
  74. )
  75. {
  76. if (!m_volmd.bAdvPredDisable /* && pmbmd -> m_bhas4MVForward */ && !pmbmd->m_bFieldMV) {
  77. motionCompOverLapEncY (
  78. pmv, pmbmd,
  79. (imbX == 0), (imbX == m_iNumMBX - 1), (imbY == 0),
  80. x, y,
  81. prctMVLimit
  82. );
  83. }
  84. else {
  85. if (!pmbmd -> m_bhas4MVForward && !pmbmd -> m_bFieldMV)
  86. motionCompEncY (
  87. m_pvopcRefQ0->pixelsY (), 
  88. m_puciRefQZoom0->pixels (),
  89. m_ppxlcPredMBY, MB_SIZE, pmv, x, y,
  90. prctMVLimit
  91. );
  92. // INTERLACE
  93. else if (pmbmd -> m_bFieldMV) {
  94. const CMotionVector* pmvTop = pmv + 5 + pmbmd->m_bForwardTop;
  95. motionCompYField(m_ppxlcPredMBY,
  96. m_pvopcRefQ0->pixelsY () + pmbmd->m_bForwardTop * m_iFrameWidthY,
  97. 2*x + pmvTop->m_vctTrueHalfPel.x, 2*y + pmvTop->m_vctTrueHalfPel.y);
  99. const CMotionVector* pmvBottom = pmv + 7 + pmbmd->m_bForwardBottom;
  100. motionCompYField(m_ppxlcPredMBY + MB_SIZE,
  101. m_pvopcRefQ0->pixelsY () + pmbmd->m_bForwardBottom * m_iFrameWidthY,
  102. 2*x + pmvBottom->m_vctTrueHalfPel.x, 2*y + pmvBottom->m_vctTrueHalfPel.y);
  103. }
  104. // ~INTERLACE
  105. else {
  106. const CMotionVector* pmv8 = pmv;
  107. pmv8++;
  108. CoordI blkX = x + BLOCK_SIZE;
  109. CoordI blkY = y + BLOCK_SIZE;
  110. motionCompEncY (
  111. m_pvopcRefQ0->pixelsY (), 
  112. m_puciRefQZoom0->pixels (),
  113. m_ppxlcPredMBY, 
  114. BLOCK_SIZE, pmv8, x, y,
  115. prctMVLimit
  116. );
  117. pmv8++;
  118. motionCompEncY (
  119. m_pvopcRefQ0->pixelsY (), 
  120. m_puciRefQZoom0->pixels (),
  121. m_ppxlcPredMBY + OFFSET_BLK1, 
  122. BLOCK_SIZE, pmv8, blkX, y,
  123. prctMVLimit
  124. );
  125. pmv8++;
  126. motionCompEncY (
  127. m_pvopcRefQ0->pixelsY (), 
  128. m_puciRefQZoom0->pixels (),
  129. m_ppxlcPredMBY + OFFSET_BLK2, 
  130. BLOCK_SIZE, pmv8, x, blkY,
  131. prctMVLimit
  132. );
  133. pmv8++;
  134. motionCompEncY (
  135. m_pvopcRefQ0->pixelsY (), 
  136. m_puciRefQZoom0->pixels (),
  137. m_ppxlcPredMBY + OFFSET_BLK3, 
  138. BLOCK_SIZE, pmv8, blkX, blkY,
  139. prctMVLimit
  140. );
  141. }
  142. }
  143. if(m_volmd.fAUsage == EIGHT_BIT)
  144. motionCompMBAEnc (
  145. pmv, pmbmd,
  146. m_ppxlcPredMBA,
  147. m_pvopcRefQ0,
  148. x, y,
  149. m_vopmd.iRoundingControl,
  150. prctMVLimit,
  151. 0
  152. );
  153. }
  155. Void CVideoObjectEncoder::motionCompMBAEnc (
  156. const CMotionVector* pmv, const CMBMode* pmbmd, 
  157. PixelC *ppxlcPredMBA,
  158. CVOPU8YUVBA* pvopcRefQ,
  159. CoordI x, CoordI y,
  160. Int iRoundingControl,
  161. CRct *prctMVLimit,
  162. Int direction //12.22.98
  163. )
  164. {
  165. if (!pmbmd -> m_bhas4MVForward && !pmbmd -> m_bFieldMV) //12.22.98
  166. motionComp (
  167. ppxlcPredMBA,
  168. pvopcRefQ->pixelsA (), 
  169. MB_SIZE,
  170. x * 2 + pmv->trueMVHalfPel ().x, 
  171. y * 2 + pmv->trueMVHalfPel ().y ,
  172. iRoundingControl,
  173. prctMVLimit
  174. );
  175. // INTERLACE  12.22.98
  176. else if (pmbmd -> m_bFieldMV) {
  177. Int itmpref1,itmpref2;
  179. itmpref1=pmbmd->m_bForwardTop;
  180. itmpref2=pmbmd->m_bForwardBottom;
  182. if(m_vopmd.vopPredType==BVOP&&direction)
  183. {
  184. itmpref1=pmbmd->m_bBackwardTop;
  185. itmpref2=pmbmd->m_bBackwardBottom;
  186. }
  188. const CMotionVector* pmvTop,*pmvBottom;
  189. if(m_vopmd.vopPredType==BVOP)
  190. pmvTop = pmv + 1 + itmpref1;
  191. else
  192. pmvTop = pmv + 5 + itmpref1;
  193. motionCompYField(ppxlcPredMBA,
  194. pvopcRefQ->pixelsA () + itmpref1 * m_iFrameWidthY,
  195. 2*x + pmvTop->trueMVHalfPel ().x, 2*y + pmvTop->trueMVHalfPel ().y);
  196. if(m_vopmd.vopPredType==BVOP)
  197. pmvBottom = pmv + 3 + itmpref2;
  198. else
  199. pmvBottom = pmv + 7 + itmpref2;
  200. motionCompYField(ppxlcPredMBA + MB_SIZE,
  201. pvopcRefQ->pixelsA () + itmpref2 * m_iFrameWidthY,
  202. 2*x + pmvBottom->trueMVHalfPel ().x, 2*y + pmvBottom->trueMVHalfPel ().y);
  203. }
  204. // ~INTERLACE 12.22.98
  205. else {
  206. const CMotionVector* pmv8 = pmv;
  207. pmv8++;
  208. CoordI blkX = x + BLOCK_SIZE;
  209. CoordI blkY = y + BLOCK_SIZE;
  210. motionComp (
  211. ppxlcPredMBA,
  212. pvopcRefQ->pixelsA (),
  213. BLOCK_SIZE,
  214. x * 2 + pmv8->trueMVHalfPel ().x, 
  215. y * 2 + pmv8->trueMVHalfPel ().y,
  216. iRoundingControl,
  217. prctMVLimit
  218. );
  219. pmv8++;
  220. motionComp (
  221. ppxlcPredMBA + OFFSET_BLK1,
  222. pvopcRefQ->pixelsA (),   
  223. BLOCK_SIZE,
  224. blkX * 2 + pmv8->trueMVHalfPel ().x, 
  225. y * 2 + pmv8->trueMVHalfPel ().y,
  226. iRoundingControl,
  227. prctMVLimit
  228. );
  229. pmv8++;
  230. motionComp (
  231. ppxlcPredMBA + OFFSET_BLK2, 
  232. pvopcRefQ->pixelsA (), 
  233. BLOCK_SIZE,
  234. x * 2 + pmv8->trueMVHalfPel ().x, 
  235. blkY * 2 + pmv8->trueMVHalfPel ().y,
  236. iRoundingControl,
  237. prctMVLimit
  238. );
  239. pmv8++;
  240. motionComp (
  241. ppxlcPredMBA + OFFSET_BLK3,
  242. pvopcRefQ->pixelsA (),
  243. BLOCK_SIZE,
  244. blkX * 2 + pmv8->trueMVHalfPel ().x, 
  245. blkY * 2 + pmv8->trueMVHalfPel ().y,
  246. iRoundingControl,
  247. prctMVLimit
  248. );
  249. }
  250. }
  252. Void CVideoObjectEncoder::motionCompEncY (
  253. const PixelC* ppxlcRef, const PixelC* ppxlcRefZoom,
  254. PixelC* ppxlcPred,
  255. Int iSize, // either MB or BLOCK size
  256. const CMotionVector* pmv, // motion vector
  257. CoordI x, CoordI y, // current coordinate system
  258. CRct *prctMVLimit
  259. )
  260. {
  261. Int iUnit = sizeof(PixelC); // NBIT: for memcpy
  262. CoordI ix, iy;
  263.   Bool bXSubPxl, bYSubPxl;
  264.     CoordI xHalf = 2*x + pmv->m_vctTrueHalfPel.x;
  265.     CoordI yHalf = 2*y + pmv->m_vctTrueHalfPel.y;
  266. // CoordI xHalf = 2*(x + pmv->iMVX) + pmv->iHalfX;
  267. // CoordI yHalf = 2*(y + pmv->iMVY) + pmv->iHalfY;
  268. limitMVRangeToExtendedBBHalfPel(xHalf,yHalf,prctMVLimit,iSize);
  270. bXSubPxl = (xHalf&1);
  271. bYSubPxl = (yHalf&1);
  272. if (!bYSubPxl && !bXSubPxl) {
  273. const PixelC* ppxlcRefMB = ppxlcRef + m_rctRefFrameY.offset (xHalf>>1, yHalf>>1);
  274. for (iy = 0; iy < iSize; iy++) {
  275. memcpy (ppxlcPred, ppxlcRefMB, iSize*iUnit);
  276. ppxlcRefMB += m_iFrameWidthY;
  277. ppxlcPred += MB_SIZE;
  278. }
  279. }
  280. else {
  281. const PixelC* ppxlcPrevZoomY = ppxlcRefZoom
  282. + m_puciRefQZoom0->where ().offset (xHalf, yHalf);
  283. for (iy = 0; iy < iSize; iy++) {
  284. for (ix = 0; ix < iSize; ix++)
  285. ppxlcPred [ix] = ppxlcPrevZoomY [2 * ix]; 
  286. ppxlcPrevZoomY += m_iFrameWidthZoomY * 2;
  287. ppxlcPred += MB_SIZE;
  288. }
  289. }
  290. }
  292. Void CVideoObjectEncoder::motionCompOverLapEncY (
  293. const CMotionVector* pmv, // motion vector
  294. const CMBMode* pmbmd, // macroblk mode
  295. Bool bLeftBndry, Bool bRightBndry, Bool bTopBndry,
  296. CoordI x, // current coordinate system
  297. CoordI y, // current coordinate system
  298. CRct *prctMVLimit
  299. )
  300. {
  301. // Overlap Motion Comp use motion vector of current blk and motion vectors of neighboring blks.
  302. const CMotionVector *pmvC, *pmvT = NULL, *pmvB = NULL, *pmvR = NULL, *pmvL = NULL; // MVs of Cur, Top, Bot, Right and Left Blocks. 
  303. const CMotionVector *pmvCurrMb, *pmvTopMb, *pmvRightMb, *pmvLeftMb; // MVs of Cur, Top, Right and Left MacroBlocks.
  304. const CMBMode *pmbmdTopMb, *pmbmdRightMb, *pmbmdLeftMb; // MVs of Cur, Top, Right and Left MacroBlocks.
  305. Bool bIntraT, bIntraR, bIntraL; // flags of 4MV for Cur, Top, Right and Left MacroBlocks.
  306. pmvTopMb = NULL; // compile warning
  307. pmvRightMb = NULL;
  308. pmvLeftMb = NULL;
  309. pmbmdTopMb = NULL;
  310. pmbmdRightMb = NULL;
  311. pmbmdLeftMb = NULL;
  312. bIntraT = FALSE;
  313. bIntraR = FALSE;
  314. bIntraL = FALSE;
  315. pmvCurrMb = pmv;
  316. // assign values to bIntra[TRL] and pmv{TRL}Mb, when they are valid. 
  317. if (!bTopBndry) {
  318. pmbmdTopMb = pmbmd - m_iNumMBX; 
  319. bIntraT = (pmbmdTopMb->m_dctMd == INTRA || pmbmdTopMb->m_dctMd == INTRAQ);
  320. pmvTopMb = pmv - m_iNumOfTotalMVPerRow;
  321. }
  322. if (!bLeftBndry) {
  323. pmbmdLeftMb = pmbmd - 1;
  324. bIntraL = (pmbmdLeftMb->m_dctMd == INTRA || pmbmdLeftMb->m_dctMd == INTRAQ);
  325. pmvLeftMb = pmv - PVOP_MV_PER_REF_PER_MB;
  326. }
  327. if (!bRightBndry) {
  328. pmbmdRightMb = pmbmd + 1;
  329. bIntraR = (pmbmdRightMb->m_dctMd == INTRA || pmbmdRightMb->m_dctMd == INTRAQ);
  330. pmvRightMb = pmv + PVOP_MV_PER_REF_PER_MB;
  331. }
  332. UInt i;
  333. // assign the neighboring blk's MVs to pmv[TBRLC] 
  334. for (i = 1; i < 5; i++) {
  335. if (pmbmd->m_rgTranspStatus [i] == ALL)
  336. continue;
  337. pmvC = pmvCurrMb + i;
  338. switch (i) {
  339. case 1:
  340. if (pmbmd->m_rgTranspStatus [3] == ALL)
  341. pmvB = pmvCurrMb + 1;
  342. else
  343. pmvB = pmvCurrMb + 3;
  345. if (pmbmd->m_rgTranspStatus [2] == ALL)
  346. pmvR = pmvCurrMb + 1; 
  347. else
  348. pmvR = pmvCurrMb + 2; 
  350. if (bTopBndry || bIntraT || pmbmdTopMb->m_rgTranspStatus [3] == ALL)
  351. pmvT = pmvCurrMb + 1;
  352. else
  353. pmvT = pmvTopMb + 3;
  355. if (bLeftBndry || bIntraL || pmbmdLeftMb->m_rgTranspStatus [2] == ALL)
  356. pmvL = pmvCurrMb + 1;
  357. else
  358. pmvL = pmvLeftMb + 2;
  359. break;
  360. case 2:
  361. if (pmbmd->m_rgTranspStatus [4] == ALL)
  362. pmvB = pmvCurrMb + 2;
  363. else
  364. pmvB = pmvCurrMb + 4;
  366. if (pmbmd->m_rgTranspStatus [1] == ALL)
  367. pmvL = pmvCurrMb + 2;
  368. else
  369. pmvL = pmvCurrMb + 1;
  371. if (bTopBndry || bIntraT || pmbmdTopMb->m_rgTranspStatus [4] == ALL)
  372. pmvT = pmvCurrMb + 2;
  373. else
  374. pmvT = pmvTopMb + 4;      
  376. if (bRightBndry || bIntraR || pmbmdRightMb->m_rgTranspStatus [1] == ALL)
  377. pmvR = pmvCurrMb + 2;
  378. else
  379. pmvR = pmvRightMb + 1;
  380. break;
  381. case 3:
  382. if (pmbmd->m_rgTranspStatus [1] == ALL)
  383. pmvT = pmvCurrMb + 3;  
  384. else
  385. pmvT = pmvCurrMb + 1;
  387. pmvB = pmvCurrMb + 3; // use the current mv
  389. if (pmbmd->m_rgTranspStatus [4] == ALL)
  390. pmvR = pmvCurrMb + 3;
  391. else
  392. pmvR = pmvCurrMb + 4;
  394. if (bLeftBndry || bIntraL || pmbmdLeftMb->m_rgTranspStatus [4] == ALL)
  395. pmvL = pmvCurrMb + 3;
  396. else
  397. pmvL = pmvLeftMb + 4;
  398. break;
  399. case 4:
  400. if (pmbmd->m_rgTranspStatus [2] == ALL)
  401. pmvT = pmvCurrMb + 4;    
  402. else
  403. pmvT = pmvCurrMb + 2;
  405. pmvB = pmvCurrMb + 4;
  407. if (pmbmd->m_rgTranspStatus [3] == ALL)
  408. pmvL = pmvCurrMb + 4;  
  409. else
  410. pmvL = pmvCurrMb + 3;
  412. if (bRightBndry || bIntraR || pmbmdRightMb->m_rgTranspStatus [3] == ALL)
  413. pmvR = pmvCurrMb + 4;
  414. else
  415. pmvR = pmvRightMb + 3;
  416. break;
  417. default:
  418. assert (FALSE);
  419. }
  420. // Compute the top left corner's x,y coordinates of current block.
  421. UInt dxc = (((i - 1) & 1) << 3); 
  422. UInt dyc = (((i - 1) & 2) << 2);
  423. UInt nxcY = (x + dxc) << 1; 
  424. UInt nycY = (y + dyc) << 1; 
  425. // Compute the corresponding positions on Ref frm, using 5 MVs.
  426. CoordI xRefC = nxcY + pmvC->m_vctTrueHalfPel.x, yRefC = nycY + pmvC->m_vctTrueHalfPel.y;
  427. CoordI xRefT = nxcY + pmvT->m_vctTrueHalfPel.x, yRefT = nycY + pmvT->m_vctTrueHalfPel.y;
  428. CoordI xRefB = nxcY + pmvB->m_vctTrueHalfPel.x, yRefB = nycY + pmvB->m_vctTrueHalfPel.y;
  429. CoordI xRefR = nxcY + pmvR->m_vctTrueHalfPel.x, yRefR = nycY + pmvR->m_vctTrueHalfPel.y;
  430. CoordI xRefL = nxcY + pmvL->m_vctTrueHalfPel.x, yRefL = nycY + pmvL->m_vctTrueHalfPel.y;
  431. // UInt nxcY = x + dxc; 
  432. //   UInt nycY = y + dyc; 
  433. // // Compute the corresponding positions on Ref frm, using 5 MVs.
  434. // CoordI xRefC = ((nxcY + pmvC->iMVX) << 1) + pmvC->iHalfX, yRefC = ((nycY + pmvC->iMVY) << 1) + pmvC->iHalfY;
  435. // CoordI xRefT = ((nxcY + pmvT->iMVX) << 1) + pmvT->iHalfX, yRefT = ((nycY + pmvT->iMVY) << 1) + pmvT->iHalfY;
  436. // CoordI xRefB = ((nxcY + pmvB->iMVX) << 1) + pmvB->iHalfX, yRefB = ((nycY + pmvB->iMVY) << 1) + pmvB->iHalfY;
  437. // CoordI xRefR = ((nxcY + pmvR->iMVX) << 1) + pmvR->iHalfX, yRefR = ((nycY + pmvR->iMVY) << 1) + pmvR->iHalfY;
  438. // CoordI xRefL = ((nxcY + pmvL->iMVX) << 1) + pmvL->iHalfX, yRefL = ((nycY + pmvL->iMVY) << 1) + pmvL->iHalfY;
  440. limitMVRangeToExtendedBBHalfPel (xRefC,yRefC,prctMVLimit,BLOCK_SIZE);
  441. limitMVRangeToExtendedBBHalfPel (xRefT,yRefT,prctMVLimit,BLOCK_SIZE);
  442. limitMVRangeToExtendedBBHalfPel (xRefB,yRefB,prctMVLimit,BLOCK_SIZE);
  443. limitMVRangeToExtendedBBHalfPel (xRefR,yRefR,prctMVLimit,BLOCK_SIZE);
  444. limitMVRangeToExtendedBBHalfPel (xRefL,yRefL,prctMVLimit,BLOCK_SIZE);
  446. //PixelC* ppxlcPredY = ppxlcYMB + dxc + dyc * m_iWidthY;  // Starting of Pred. Frame
  447. PixelC* ppxlcPred = m_ppxlcPredMBY + dxc + dyc * MB_SIZE;  // Starting of Pred. Frame
  448. // 5 starting pos. in Zoomed Ref. Frames
  449. // m_ppxlcRefZoom0Y +  (xRefC, yRefC);
  450. const PixelC* ppxlcPrevZoomYC;
  451. const PixelC* ppxlcPrevZoomYT;
  452. const PixelC* ppxlcPrevZoomYB;
  453. const PixelC* ppxlcPrevZoomYR;
  454. const PixelC* ppxlcPrevZoomYL;
  455. ppxlcPrevZoomYC = m_puciRefQZoom0->pixels () + 
  456. (yRefC + EXPANDY_REF_FRAMEx2) * m_iFrameWidthZoomY +
  457. xRefC + EXPANDY_REF_FRAMEx2;
  458. ppxlcPrevZoomYT = m_puciRefQZoom0->pixels () + 
  459. (yRefT + EXPANDY_REF_FRAMEx2) * m_iFrameWidthZoomY +
  460. xRefT + EXPANDY_REF_FRAMEx2;
  461. ppxlcPrevZoomYB = m_puciRefQZoom0->pixels () + 
  462. (yRefB + EXPANDY_REF_FRAMEx2) * m_iFrameWidthZoomY +
  463. xRefB + EXPANDY_REF_FRAMEx2;
  464. ppxlcPrevZoomYR = m_puciRefQZoom0->pixels () + 
  465. (yRefR + EXPANDY_REF_FRAMEx2) * m_iFrameWidthZoomY +
  466. xRefR + EXPANDY_REF_FRAMEx2;
  467. ppxlcPrevZoomYL = m_puciRefQZoom0->pixels () + 
  468. (yRefL + EXPANDY_REF_FRAMEx2) * m_iFrameWidthZoomY +
  469. xRefL + EXPANDY_REF_FRAMEx2;
  470. UInt *pWghtC, *pWghtT, *pWghtB, *pWghtR, *pWghtL;
  471. pWghtC = (UInt*) gWghtC;
  472. pWghtT = (UInt*) gWghtT;
  473. pWghtB = (UInt*) gWghtB;
  474. pWghtR = (UInt*) gWghtR;
  475. pWghtL = (UInt*) gWghtL;
  476. for (UInt iy = 0; iy < BLOCK_SIZE; iy++) {
  477. for (UInt ix = 0; ix < BLOCK_SIZE; ix++) {
  478. *ppxlcPred++ = (
  479. *ppxlcPrevZoomYC * *pWghtC++ + 
  480. *ppxlcPrevZoomYT * *pWghtT++ + 
  481. *ppxlcPrevZoomYB * *pWghtB++ + 
  482. *ppxlcPrevZoomYR * *pWghtR++ + 
  483. *ppxlcPrevZoomYL * *pWghtL++ + 4
  484. ) >> 3;
  485. ppxlcPrevZoomYC += 2;
  486. ppxlcPrevZoomYT += 2;
  487. ppxlcPrevZoomYB += 2;
  488. ppxlcPrevZoomYR += 2;
  489. ppxlcPrevZoomYL += 2;
  490. }
  491. ppxlcPrevZoomYC += m_iFrameWidthZoomYx2Minus2Blk;
  492. ppxlcPrevZoomYT += m_iFrameWidthZoomYx2Minus2Blk;
  493. ppxlcPrevZoomYB += m_iFrameWidthZoomYx2Minus2Blk;
  494. ppxlcPrevZoomYR += m_iFrameWidthZoomYx2Minus2Blk;
  495. ppxlcPrevZoomYL += m_iFrameWidthZoomYx2Minus2Blk;
  496. ppxlcPred += BLOCK_SIZE;
  497. }
  498. }
  499. }
  501. // for B-VOP
  503. Void CVideoObjectEncoder::averagePredAndComputeErrorY()
  504. {
  505. Int ic;
  506. for (ic = 0; ic < MB_SQUARE_SIZE; ic++) {
  507. m_ppxlcPredMBY [ic] = (m_ppxlcPredMBY [ic] + m_ppxlcPredMBBackY [ic] + 1) >> 1;
  508. m_ppxliErrorMBY [ic] = m_ppxlcCurrMBY [ic] - m_ppxlcPredMBY [ic];
  509. }
  510. }
  512. //INTERLACE
  513. //new changes
  514. Void CVideoObjectEncoder::averagePredAndComputeErrorY_WithShape()
  515. {
  516. Int ic;
  517. for (ic = 0; ic < MB_SQUARE_SIZE; ic++) {
  518. if (m_ppxlcCurrMBBY [ic] == transpValue)
  519. m_ppxliErrorMBY [ic] = 0;
  520. else {
  521. m_ppxlcPredMBY [ic] = (m_ppxlcPredMBY [ic] + m_ppxlcPredMBBackY [ic] + 1) >> 1;
  522. m_ppxliErrorMBY [ic] = m_ppxlcCurrMBY [ic] - m_ppxlcPredMBY [ic];
  523. }
  524. }
  525. }
  526. // new changes
  527. //INTERLACE
  529. Void CVideoObjectEncoder::motionCompAndDiff_BVOP_MB (
  530. const CMotionVector* pmvForward, const CMotionVector* pmvBackward, 
  531.  CMBMode* pmbmd, 
  532. CoordI x, CoordI y,
  533. CRct *prctMVLimitForward,CRct *prctMVLimitBackward
  534. )
  535. {
  536.     if (m_vopmd.bInterlace) {           // Should work for both progressive and interlaced, but keep
  537.                                         // original code for now due to differences in direct mode.   Bob Eifrig
  538.     switch (pmbmd->m_mbType) {
  540.     case FORWARD:
  541.     motionCompOneBVOPReference(m_pvopcPredMB, FORWARD,  x, y, pmbmd, pmvForward, prctMVLimitForward);
  542.     computeTextureError();
  543.     break;
  545.     case BACKWARD:
  546.     motionCompOneBVOPReference(m_pvopcPredMB, BACKWARD, x, y, pmbmd, pmvBackward, prctMVLimitBackward);
  547.     computeTextureError();
  548.     break;
  550.     case DIRECT:
  551.     motionCompDirectMode(x, y, pmbmd,
  552.                 &m_rgmvRef[(PVOP_MV_PER_REF_PER_MB*(x + m_iNumMBX * y)) / MB_SIZE],
  553.                 prctMVLimitForward, prctMVLimitBackward,0);  // new change 02-19-99
  554.     averagePredAndComputeErrorY();
  555.     averagePredAndComputeErrorUV();
  556.     break;
  558.     case INTERPOLATE:
  559.     motionCompOneBVOPReference(m_pvopcPredMB,     FORWARD,  x, y, pmbmd, pmvForward, prctMVLimitForward);
  560.     motionCompOneBVOPReference(m_pvopcPredMBBack, BACKWARD, x, y, pmbmd, pmvBackward, prctMVLimitBackward);
  561.     averagePredAndComputeErrorY();
  562.     averagePredAndComputeErrorUV();
  563.     break;
  564.     }
  565.         return;
  566.     }
  567. if (pmbmd->m_mbType == DIRECT || pmbmd->m_mbType == INTERPOLATE) { // Y is done when doing motion estimation
  568. motionCompInterpAndError (pmvForward, pmvBackward, x, y,prctMVLimitForward,prctMVLimitBackward);
  569. CoordI xRefUVForward, yRefUVForward;
  570. mvLookupUVWithShape (pmbmd, pmvForward, xRefUVForward, yRefUVForward);
  571. motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, x, y, xRefUVForward, yRefUVForward, 0, prctMVLimitForward);
  573. CoordI xRefUVBackward, yRefUVBackward;
  574. mvLookupUVWithShape (pmbmd, pmvBackward, xRefUVBackward, yRefUVBackward);
  575. motionCompUV (m_ppxlcPredMBBackU, m_ppxlcPredMBBackV, m_pvopcRefQ1, x, y, xRefUVBackward, yRefUVBackward, 0, prctMVLimitBackward);
  576. averagePredAndComputeErrorUV ();
  577. }
  578. else { 
  579. const CMotionVector* pmv;
  580. const PixelC* ppxlcRef; // point to left-top of the reference VOP
  581. const PixelC* ppxlcRefZoom; // point to left-top of the reference VOP
  582. const CVOPU8YUVBA* pvopcRef;
  583. CRct *prctMVLimit;
  584. if (pmbmd->m_mbType == FORWARD) { // Y is done when doing motion estimation
  585. pmv = pmvForward;
  586. pvopcRef = m_pvopcRefQ0;
  587. ppxlcRef = m_pvopcRefQ0->pixelsY (); // point to left-top of the reference VOP
  588. ppxlcRefZoom = m_puciRefQZoom0->pixels (); // point to left-top of the reference VOP
  589. prctMVLimit=prctMVLimitForward;
  590. }
  591. else {
  592. pmv = pmvBackward;
  593. pvopcRef = m_pvopcRefQ1;
  594. ppxlcRef = m_pvopcRefQ1->pixelsY (); // point to left-top of the reference VOP
  595. ppxlcRefZoom = m_puciRefQZoom1->pixels (); // point to left-top of the reference VOP
  596. prctMVLimit=prctMVLimitBackward;
  597. }
  598. CoordI xRefUV, yRefUV;
  599. mvLookupUVWithShape (pmbmd, pmv, xRefUV, yRefUV);
  600. motionCompEncY (ppxlcRef, ppxlcRefZoom, m_ppxlcPredMBY, MB_SIZE, pmv, x, y,prctMVLimit);
  601. motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, pvopcRef, x, y, xRefUV, yRefUV, 0, prctMVLimit);
  602. computeTextureError ();
  603. }
  604. }
  606. Void CVideoObjectEncoder::motionCompAndDiff_BVOP_MB_WithShape (
  607. const CMotionVector* pmvForward, const CMotionVector* pmvBackward, 
  608.  CMBMode* pmbmd, 
  609. CoordI x, CoordI y,
  610. CRct *prctMVLimitForward,
  611. CRct *prctMVLimitBackward
  612. )
  613. {
  614. // INTERLACED
  615. // new changes
  616.     if (m_vopmd.bInterlace&&pmbmd->m_bFieldMV) {           // Should work for both progressive and interlaced, but keep
  617.                                         // original code for now due to differences in direct mode.   Bob Eifrig
  618.     switch (pmbmd->m_mbType) {
  620.     case FORWARD:
  621.     motionCompOneBVOPReference(m_pvopcPredMB, FORWARD,  x, y, pmbmd, pmvForward, prctMVLimitForward);
  622.     computeTextureErrorWithShape();
  623.     break;
  625.     case BACKWARD:
  626.     motionCompOneBVOPReference(m_pvopcPredMB, BACKWARD, x, y, pmbmd, pmvBackward, prctMVLimitBackward);
  627.     computeTextureErrorWithShape();
  628.     break;
  630.     case DIRECT:
  631.     motionCompDirectMode(x, y, pmbmd,
  632.                 &m_rgmvRef[(PVOP_MV_PER_REF_PER_MB*(x + m_iNumMBX * y)) / MB_SIZE],
  633.                 prctMVLimitForward, prctMVLimitBackward,0);   // new change 02-19-99
  634.     averagePredAndComputeErrorY_WithShape();
  635.     averagePredAndComputeErrorUV_WithShape();
  636.     break;
  638.     case INTERPOLATE:
  639.     motionCompOneBVOPReference(m_pvopcPredMB,     FORWARD,  x, y, pmbmd, pmvForward, prctMVLimitForward);
  640.     motionCompOneBVOPReference(m_pvopcPredMBBack, BACKWARD, x, y, pmbmd, pmvBackward, prctMVLimitBackward);
  641.     averagePredAndComputeErrorY_WithShape();
  642.     averagePredAndComputeErrorUV_WithShape();
  643.     break;
  644.     }
  645.         return;
  646.     }
  647. // INTERLACED
  648. // end of new changes
  650. if (pmbmd->m_mbType == DIRECT || pmbmd->m_mbType == INTERPOLATE) { // Y is done when doing motion estimation
  651. motionCompInterpAndError_WithShape (pmvForward, pmvBackward, x, y,prctMVLimitForward,prctMVLimitBackward);
  652. CoordI xRefUVForward, yRefUVForward;
  653. mvLookupUVWithShape (pmbmd, pmvForward, xRefUVForward, yRefUVForward);
  654. motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, m_pvopcRefQ0, x, y, xRefUVForward, yRefUVForward, 0, prctMVLimitForward);
  656. CoordI xRefUVBackward, yRefUVBackward;
  657. mvLookupUVWithShape (pmbmd, pmvBackward, xRefUVBackward, yRefUVBackward);
  658. motionCompUV (m_ppxlcPredMBBackU, m_ppxlcPredMBBackV, m_pvopcRefQ1, x, y, xRefUVBackward, yRefUVBackward, 0, prctMVLimitBackward);
  659. averagePredAndComputeErrorUV_WithShape ();
  660. }
  661. else { 
  662. const CMotionVector* pmv;
  663. const PixelC* ppxlcRef; // point to left-top of the reference VOP
  664. const PixelC* ppxlcRefZoom; // point to left-top of the reference VOP
  665. const CVOPU8YUVBA* pvopcRef;
  666. CRct *prctMVLimit;
  667. if (pmbmd->m_mbType == FORWARD) { // Y is done when doing motion estimation
  668. pmv = pmvForward;
  669. pvopcRef = m_pvopcRefQ0;
  670. ppxlcRef = m_pvopcRefQ0->pixelsY (); // point to left-top of the reference VOP
  671. ppxlcRefZoom = m_puciRefQZoom0->pixels (); // point to left-top of the reference VOP
  672. prctMVLimit = prctMVLimitForward;
  673. }
  674. else {
  675. pmv = pmvBackward;
  676. pvopcRef = m_pvopcRefQ1;
  677. ppxlcRef = m_pvopcRefQ1->pixelsY (); // point to left-top of the reference VOP
  678. ppxlcRefZoom = m_puciRefQZoom1->pixels (); // point to left-top of the reference VOP
  679. prctMVLimit = prctMVLimitBackward;
  680. }
  681. CoordI xRefUV, yRefUV;
  682. mvLookupUVWithShape (pmbmd, pmv, xRefUV, yRefUV);
  683. motionCompEncY (ppxlcRef, ppxlcRefZoom, m_ppxlcPredMBY, MB_SIZE, pmv, x, y,prctMVLimit);
  684. motionCompUV (m_ppxlcPredMBU, m_ppxlcPredMBV, pvopcRef, x, y, xRefUV, yRefUV, 0, prctMVLimit);
  685. computeTextureErrorWithShape ();
  686. }
  687. }
  689. Void CVideoObjectEncoder::motionCompAndDiffAlpha_BVOP_MB (
  690. const CMotionVector* pmvForward, const CMotionVector* pmvBackward, 
  691. const CMBMode* pmbmd, 
  692. CoordI x, CoordI y,
  693. CRct *prctMVLimitForward,CRct *prctMVLimitBackward
  694. )
  695. {
  696. if (pmbmd->m_mbType == DIRECT || pmbmd->m_mbType == INTERPOLATE) {
  697. motionCompMBAEnc (pmvForward, pmbmd, m_ppxlcPredMBA, m_pvopcRefQ0,
  698. x, y, 0, prctMVLimitForward,0);
  699. motionCompMBAEnc (pmvBackward, pmbmd, m_ppxlcPredMBBackA, m_pvopcRefQ1,
  700. x, y, 0, prctMVLimitBackward,1);
  702. // average predictions
  703. Int i;
  704. for(i = 0; i<MB_SQUARE_SIZE; i++)
  705. m_ppxlcPredMBA[i] = (m_ppxlcPredMBA[i] + m_ppxlcPredMBBackA[i] + 1)>>1;
  706. }
  707. else { 
  708. const CMotionVector* pmv;
  709. const PixelC* ppxlcRef; // point to left-top of the reference VOP
  710. CRct *prctMVLimit;
  711. if (pmbmd->m_mbType == FORWARD) {
  712. pmv = pmvForward;
  713. ppxlcRef = m_pvopcRefQ0->pixelsA (); // point to left-top of the reference VOP
  714. prctMVLimit = prctMVLimitForward;
  715. // 12.22.98 begin of changes
  716. if(m_vopmd.bInterlace&&pmbmd->m_bFieldMV)
  717. motionCompMBAEnc (pmvForward, pmbmd, m_ppxlcPredMBA, m_pvopcRefQ0,
  718. x, y, 0, prctMVLimitForward,0);
  719. // end of changes
  720. }
  721. else {
  722. pmv = pmvBackward;
  723. ppxlcRef = m_pvopcRefQ1->pixelsA (); // point to left-top of the reference VOP
  724. prctMVLimit = prctMVLimitBackward;
  725. // 12.22.98 begin of changes
  726. if(m_vopmd.bInterlace&&pmbmd->m_bFieldMV)
  727. motionCompMBAEnc (pmvBackward, pmbmd, m_ppxlcPredMBA, m_pvopcRefQ1,
  728. x, y, 0, prctMVLimitBackward,1);
  729. // end of changes
  730. }
  731. if((!m_vopmd.bInterlace||(m_vopmd.bInterlace&&!pmbmd->m_bFieldMV))) // 12.22.98 changes
  732. motionComp (
  733. m_ppxlcPredMBA,
  734. ppxlcRef,
  735. MB_SIZE, // MB size
  736. x * 2 + pmv->trueMVHalfPel ().x, 
  737. y * 2 + pmv->trueMVHalfPel ().y,
  738. 0,
  739. prctMVLimit
  740. );
  741. }
  742. computeAlphaError();
  743. }
  745. Void CVideoObjectEncoder::averagePredAndComputeErrorUV ()
  746. {
  747. Int i = 0;
  748. for (i = 0; i < BLOCK_SQUARE_SIZE; i++) {
  749. m_ppxlcPredMBU [i] = (m_ppxlcPredMBU [i] + m_ppxlcPredMBBackU [i] + 1) >> 1;
  750. m_ppxlcPredMBV [i] = (m_ppxlcPredMBV [i] + m_ppxlcPredMBBackV [i] + 1) >> 1;
  751. m_ppxliErrorMBU [i] = m_ppxlcCurrMBU [i] - m_ppxlcPredMBU [i];
  752. m_ppxliErrorMBV [i] = m_ppxlcCurrMBV [i] - m_ppxlcPredMBV [i];
  753. }
  754. }
  756. Void CVideoObjectEncoder::averagePredAndComputeErrorUV_WithShape ()
  757. {
  758. Int i = 0;
  759. for (i = 0; i < BLOCK_SQUARE_SIZE; i++) {
  760. if (m_ppxlcCurrMBBUV [i] == transpValue)
  761. m_ppxliErrorMBU [i] = m_ppxliErrorMBV [i] = 0;
  762. else {
  763. m_ppxlcPredMBU [i] = (m_ppxlcPredMBU [i] + m_ppxlcPredMBBackU [i] + 1) >> 1;
  764. m_ppxlcPredMBV [i] = (m_ppxlcPredMBV [i] + m_ppxlcPredMBBackV [i] + 1) >> 1;
  765. m_ppxliErrorMBU [i] = m_ppxlcCurrMBU [i] - m_ppxlcPredMBU [i];
  766. m_ppxliErrorMBV [i] = m_ppxlcCurrMBV [i] - m_ppxlcPredMBV [i];
  767. }
  768. }
  769. }
  771. // B-VOP ME/MC stuff
  772. Int CVideoObjectEncoder::interpolateAndDiffY (
  773. const CMotionVector* pmvForward, const CMotionVector* pmvBackward, 
  774. CoordI x, CoordI y,
  775. CRct *prctMVLimitForward,CRct *prctMVLimitBackward
  776. )
  777. {
  778. motionCompEncY (
  779. m_pvopcRefQ0->pixelsY (), 
  780. m_puciRefQZoom0->pixels (),
  781. m_ppxlcPredMBY, MB_SIZE, pmvForward, x, y,
  782. prctMVLimitForward
  783. );
  784. /*Int iLeft  = (x << 1) + pmvBackward->m_vctTrueHalfPel.x;
  785. Int iRight = (y << 1) + pmvBackward->m_vctTrueHalfPel.y;
  787. //make sure don't end up with a mv that points out of a frame; object-based not done
  788. if (!m_puciRefQZoom1->where ().includes (CRct (iLeft, iRight, iLeft + (MB_SIZE << 1), iRight + (MB_SIZE << 1))))
  789. return 1000000000;
  790. else*/
  791. motionCompEncY (
  792. m_pvopcRefQ1->pixelsY (), 
  793. m_puciRefQZoom1->pixels (),
  794. m_ppxlcPredMBBackY, MB_SIZE, pmvBackward, x, y,
  795. prctMVLimitBackward
  796. );
  797. Int ic;
  798. Int iSAD = 0;
  799. for (ic = 0; ic < MB_SQUARE_SIZE; ic++)
  800. iSAD += abs (m_ppxlcCurrMBY [ic] - ((m_ppxlcPredMBY [ic] + m_ppxlcPredMBBackY [ic] + 1) >> 1));
  801. return iSAD;
  802. }
  804. Int CVideoObjectEncoder::interpolateAndDiffY_WithShape (
  805. const CMotionVector* pmvForward, const CMotionVector* pmvBackward, 
  806. CoordI x, CoordI y,
  807. CRct *prctMVLimitForward,CRct *prctMVLimitBackward
  808. )
  809. {
  810. motionCompEncY (
  811. m_pvopcRefQ0->pixelsY (), 
  812. m_puciRefQZoom0->pixels (),
  813. m_ppxlcPredMBY, MB_SIZE, pmvForward, x, y,
  814. prctMVLimitForward
  815. );
  816. motionCompEncY (
  817. m_pvopcRefQ1->pixelsY (), 
  818. m_puciRefQZoom1->pixels (),
  819. m_ppxlcPredMBBackY, MB_SIZE, pmvBackward, x, y,
  820. prctMVLimitBackward
  821. );
  822. Int ic;
  823. Int iSAD = 0;
  824. for (ic = 0; ic < MB_SQUARE_SIZE; ic++) {
  825. if (m_ppxlcCurrMBBY [ic] != transpValue)
  826. iSAD += abs (m_ppxlcCurrMBY [ic] - ((m_ppxlcPredMBY [ic] + m_ppxlcPredMBBackY [ic] + 1) >> 1));
  827. }
  828. return iSAD;
  829. }
  831. Int CVideoObjectEncoder::interpolateAndDiffYField(
  832. const CMotionVector* pmvFwdTop,
  833. const CMotionVector* pmvFwdBot,
  834. const CMotionVector* pmvBakTop,
  835. const CMotionVector* pmvBakBot,
  836. CoordI x, CoordI y,
  837. CMBMode *pmbmd
  838. )
  839. {
  840. x <<= 1;
  841. y <<= 1;
  842. motionCompYField(m_ppxlcPredMBY,
  843. m_pvopcRefQ0->pixelsY () + pmbmd->m_bForwardTop * m_iFrameWidthY,
  844. x + pmvFwdTop->m_vctTrueHalfPel.x, y + pmvFwdTop->m_vctTrueHalfPel.y);
  845. motionCompYField(m_ppxlcPredMBY + MB_SIZE,
  846. m_pvopcRefQ0->pixelsY () + pmbmd->m_bForwardBottom * m_iFrameWidthY,
  847. x + pmvFwdBot->m_vctTrueHalfPel.x, y + pmvFwdBot->m_vctTrueHalfPel.y);
  849. motionCompYField(m_ppxlcPredMBBackY,
  850. m_pvopcRefQ1->pixelsY () + pmbmd->m_bBackwardTop * m_iFrameWidthY,
  851. x + pmvBakTop->m_vctTrueHalfPel.x, y + pmvBakTop->m_vctTrueHalfPel.y);
  852. motionCompYField(m_ppxlcPredMBBackY + MB_SIZE,
  853. m_pvopcRefQ1->pixelsY () + pmbmd->m_bBackwardBottom * m_iFrameWidthY,
  854. x + pmvBakBot->m_vctTrueHalfPel.x, y + pmvBakBot->m_vctTrueHalfPel.y);
  856. Int ic;
  857. Int iSAD = 0;
  858. // new changes by X. Chen
  859. if (pmbmd->m_rgTranspStatus[0]==NONE) {
  860. for (ic = 0; ic < MB_SQUARE_SIZE; ic++)
  861. iSAD += abs (m_ppxlcCurrMBY [ic] - ((m_ppxlcPredMBY [ic] + m_ppxlcPredMBBackY [ic] + 1) >> 1));
  862. } else if (pmbmd->m_rgTranspStatus[0]==PARTIAL) {
  863. for (ic = 0; ic < MB_SQUARE_SIZE; ic++) {
  864. if (m_ppxlcCurrMBBY [ic] != transpValue)
  865. iSAD += abs (m_ppxlcCurrMBY [ic] - ((m_ppxlcPredMBY [ic] + m_ppxlcPredMBBackY [ic] + 1) >> 1));
  866. }
  867. }
  868. // end of new changes
  869. return iSAD;
  870. }
  873. Void CVideoObjectEncoder::motionCompInterpAndError (
  874. const CMotionVector* pmvForward, const CMotionVector* pmvBackward, 
  875. CoordI x, CoordI y,
  876. CRct *prctMVLimitForward,CRct *prctMVLimitBackward
  877. )
  878. {
  879. motionCompEncY (
  880. m_pvopcRefQ0->pixelsY (), 
  881. m_puciRefQZoom0->pixels (),
  882. m_ppxlcPredMBY, MB_SIZE, pmvForward, x, y,
  883. prctMVLimitForward
  884. );
  885. motionCompEncY (
  886. m_pvopcRefQ1->pixelsY (), 
  887. m_puciRefQZoom1->pixels (),
  888. m_ppxlcPredMBBackY, MB_SIZE, pmvBackward, x, y,
  889. prctMVLimitBackward
  890. );
  891. Int ic;
  892. for (ic = 0; ic < MB_SQUARE_SIZE; ic++) {
  893. m_ppxlcPredMBY [ic] = (m_ppxlcPredMBY [ic] + m_ppxlcPredMBBackY [ic] + 1) >> 1;
  894. m_ppxliErrorMBY [ic] = m_ppxlcCurrMBY [ic] - m_ppxlcPredMBY [ic];
  895. }
  896. }
  898. Void CVideoObjectEncoder::motionCompInterpAndError_WithShape (
  899. const CMotionVector* pmvForward, const CMotionVector* pmvBackward, 
  900. CoordI x, CoordI y,
  901. CRct *prctMVLimitForward,CRct *prctMVLimitBackward
  902. )
  903. {
  904. motionCompEncY (
  905. m_pvopcRefQ0->pixelsY (), 
  906. m_puciRefQZoom0->pixels (),
  907. m_ppxlcPredMBY, MB_SIZE, pmvForward, x, y,
  908. prctMVLimitForward
  909. );
  910. motionCompEncY (
  911. m_pvopcRefQ1->pixelsY (), 
  912. m_puciRefQZoom1->pixels (),
  913. m_ppxlcPredMBBackY, MB_SIZE, pmvBackward, x, y,
  914. prctMVLimitBackward
  915. );
  916. Int ic;
  917. for (ic = 0; ic < MB_SQUARE_SIZE; ic++) {
  918. if (m_ppxlcCurrMBBY [ic] == transpValue){
  919. m_ppxlcPredMBY [ic] = (m_ppxlcPredMBY [ic] + m_ppxlcPredMBBackY [ic] + 1) >> 1;
  920. /*m_ppxlcPredMBY [ic] = */m_ppxliErrorMBY [ic] = 0;
  921. }
  922. else {
  923. m_ppxlcPredMBY [ic] = (m_ppxlcPredMBY [ic] + m_ppxlcPredMBBackY [ic] + 1) >> 1;
  924. m_ppxliErrorMBY [ic] = m_ppxlcCurrMBY [ic] - m_ppxlcPredMBY [ic];
  925. }
  926. }
  927. }