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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

motest.cpp：源码内容
  1. /*************************************************************************
  3. This software module was originally developed by 
  5. Ming-Chieh Lee (mingcl@microsoft.com), Microsoft Corporation
  6. Wei-ge Chen (wchen@microsoft.com), Microsoft Corporation
  7. Bruce Lin (blin@microsoft.com), Microsoft Corporation
  8. (date: March, 1996)
  9. and edited by
  10.         Wei Wu (weiwu@stallion.risc.rockwell.com) Rockwell Science Center
  11. and edited by Xuemin Chen (xchen@gi.com) General Instrument Corp.)
  13. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  14. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  15. as specified by the MPEG-4 Video. 
  16. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  17. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  18. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
  19. The original developer of this software module and his/her company, 
  20. the subsequent editors and their companies, 
  21. and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
  22. Copyright is not released for non MPEG-4 Video conforming products. 
  23. Microsoft retains full right to use the code for his/her own purpose, 
  24. assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
  25. This copyright notice must be included in all copies or derivative works. 
  27. Copyright (c) 1996, 1997.
  30. Module Name:
  32. motEst.cpp
  34. Abstract:
  36. Motion estimation routines.
  38. Revision History:
  39. Dec 20, 1997: Interlaced tools added by NextLevel Systems
  40. May 9, 1999: tm5 rate control by DemoGraFX, duhoff@mediaone.net
  42. *************************************************************************/
  44. #include <stdio.h>
  45. #include <math.h>
  46. #include <stdlib.h>
  47. #include <iostream.h>
  49. #include "typeapi.h"
  50. #include "codehead.h"
  51. #include "global.hpp"
  52. #include "entropy/bitstrm.hpp"
  53. #include "entropy/entropy.hpp"
  54. #include "entropy/huffman.hpp"
  55. #include "mode.hpp"
  56. #include "vopses.hpp"
  57. #include "vopseenc.hpp"
  59. #ifdef __MFC_
  60. #ifdef _DEBUG
  61. #undef THIS_FILE
  62. static char BASED_CODE THIS_FILE[] = __FILE__;
  63. #endif
  65. #define new DEBUG_NEW    
  66. #endif // __MFC_
  68. #define FAVORZERO 129
  69. #define FAVOR_DIRECT 129
  70. #define FAVOR_INTER 512
  71. #define FAVOR_16x16 129
  72. #define FAVOR_FIELD  65 // P-VOP favor field over 8x8 due to fewer MVs
  74. inline Int minimum (Int a, Int b, Int c, Int d)
  75. {
  76. if (a <= b && a <= c && a <= d)
  77. return a;
  78. else if (b <= a && b <= c && b <= d)
  79. return b;
  80. else if (c <= a && c <= b && c <= d)
  81. return c;
  82. else
  83. return d;
  84. }
  86. Void CVideoObjectEncoder::motionEstPVOP ()
  87. {
  88. m_iMAD = 0;
  89. CoordI y = 0; 
  90. CMBMode* pmbmd = m_rgmbmd;
  91. CMotionVector* pmv = m_rgmv;
  92. const PixelC* ppxlcOrigY = m_pvopcOrig->pixelsBoundY ();
  93. const PixelC* ppxlcRefY = (m_volmd.bOriginalForME ? m_pvopcRefOrig0 : m_pvopcRefQ0)->pixelsY () + m_iStartInRefToCurrRctY;
  94. Int iMBX, iMBY;
  96. if (m_iMVFileUsage == 1)
  97. readPVOPMVs();
  98. for (iMBY = 0; iMBY < m_iNumMBY; iMBY++, y += MB_SIZE) {
  99. const PixelC* ppxlcOrigMBY = ppxlcOrigY;
  100. const PixelC* ppxlcRefMBY = ppxlcRefY;
  101. CoordI x = 0;
  102. for (iMBX = 0; iMBX < m_iNumMBX; iMBX++, x += MB_SIZE) {
  103. #ifdef __TRACE_AND_STATS_
  104. m_pbitstrmOut->trace (CSite (iMBX, iMBY), "MB_X_Y");
  105. #endif // __TRACE_AND_STATS_
  106. if (m_volmd.volType == ENHN_LAYER && m_vopmd.iRefSelectCode == 3) {
  107. motionEstMB_PVOP (x, y, pmv, pmbmd);
  108. }
  109. else {
  110. copyToCurrBuffY (ppxlcOrigMBY);
  111. pmbmd->m_bFieldDCT=0;
  112. m_iMAD += motionEstMB_PVOP (x, y, pmv, pmbmd, ppxlcRefMBY);
  113. }
  115. #ifdef __TRACE_AND_STATS_
  116. m_pbitstrmOut->trace (CSite (iMBX, iMBY), "MB_X_Y");
  117. m_pbitstrmOut->trace (pmv [0], "MV16");
  118. m_pbitstrmOut->trace (pmv [1], "MV8");
  119. m_pbitstrmOut->trace (pmv [2], "MV8");
  120. m_pbitstrmOut->trace (pmv [3], "MV8");
  121. m_pbitstrmOut->trace (pmv [4], "MV8");
  122. // INTERLACE
  123. if(pmbmd->m_bForwardTop)
  124. m_pbitstrmOut->trace (pmv [6], "MV16x8");
  125. else
  126. m_pbitstrmOut->trace (pmv [5], "MV16x8");
  127. if(pmbmd->m_bForwardBottom)
  128. m_pbitstrmOut->trace (pmv [8], "MV16x8");
  129. else
  130. m_pbitstrmOut->trace (pmv [7], "MV16x8");
  131. // ~INTERLACE
  132. #endif // __TRACE_AND_STATS_
  133. pmbmd++;
  134. pmv += PVOP_MV_PER_REF_PER_MB;
  135. ppxlcOrigMBY += MB_SIZE;
  136. ppxlcRefMBY += MB_SIZE;
  137. }
  138. ppxlcOrigY += m_iFrameWidthYxMBSize;
  139. ppxlcRefY += m_iFrameWidthYxMBSize;
  140. }
  141. if (m_iMVFileUsage == 2)
  142. writePVOPMVs();
  143. }
  145. Void CVideoObjectEncoder::motionEstPVOP_WithShape ()
  146. {
  147. m_iMAD = 0;
  148. CoordI y = m_rctCurrVOPY.top; 
  149. CMBMode* pmbmd = m_rgmbmd;
  150. CMotionVector* pmv = m_rgmv;
  151. const PixelC* ppxlcOrigY = m_pvopcOrig->pixelsBoundY ();
  152. const PixelC* ppxlcOrigBY = m_pvopcOrig->pixelsBoundBY ();
  153. const PixelC* ppxlcRefY = (m_volmd.bOriginalForME ? m_pvopcRefOrig0 : m_pvopcRefQ0)->pixelsY () + m_iStartInRefToCurrRctY;
  154. Int iMBX, iMBY;
  156. if (m_iMVFileUsage == 1)
  157. readPVOPMVs();
  158. for (iMBY = 0; iMBY < m_iNumMBY; iMBY++, y += MB_SIZE) {
  159. const PixelC* ppxlcOrigMBY = ppxlcOrigY;
  160. const PixelC* ppxlcOrigMBBY = ppxlcOrigBY;
  161. const PixelC* ppxlcRefMBY = ppxlcRefY;
  162. CoordI x = m_rctCurrVOPY.left;
  163. for (iMBX = 0; iMBX < m_iNumMBX; iMBX++, x += MB_SIZE) {
  164. #ifdef __TRACE_AND_STATS_
  165. if(m_volmd.bShapeOnly==FALSE)
  166. m_pbitstrmOut->trace (CSite (iMBX, iMBY), "MB_X_Y");
  167. #endif // __TRACE_AND_STATS_
  168. copyToCurrBuffWithShapeY (ppxlcOrigMBY, ppxlcOrigMBBY);
  169. decideTransparencyStatus (pmbmd, m_ppxlcCurrMBBY);
  170. if(m_volmd.bShapeOnly==FALSE)
  171. {
  172. if (pmbmd->m_rgTranspStatus [0] == NONE)
  173. {
  174. // new changes X. Chen
  175. pmbmd->m_bFieldDCT=0;
  176. m_iMAD += motionEstMB_PVOP (x, y, pmv, pmbmd, ppxlcRefMBY);
  177. }
  178. else if (pmbmd->m_rgTranspStatus [0] == PARTIAL)
  179. {
  180. // new changes X. Chen
  181. pmbmd->m_bFieldDCT=0;
  182. m_iMAD += motionEstMB_PVOP_WithShape (x, y, pmv, pmbmd, ppxlcRefMBY);
  183. }
  185. #ifdef __TRACE_AND_STATS_
  186. m_pbitstrmOut->trace (CSite (iMBX, iMBY), "MB_X_Y");
  187. m_pbitstrmOut->trace (pmv [0], "MV16");
  188. m_pbitstrmOut->trace (pmv [1], "MV8");
  189. m_pbitstrmOut->trace (pmv [2], "MV8");
  190. m_pbitstrmOut->trace (pmv [3], "MV8");
  191. m_pbitstrmOut->trace (pmv [4], "MV8");
  192. // INTERLACE
  193. // new changes
  194. if(pmbmd->m_bFieldDCT) {
  195. if(pmbmd->m_bForwardTop)
  196. m_pbitstrmOut->trace (pmv [6], "MV16x8");
  197. else
  198. m_pbitstrmOut->trace (pmv [5], "MV16x8");
  199. if(pmbmd->m_bForwardBottom)
  200. m_pbitstrmOut->trace (pmv [8], "MV16x8");
  201. else
  202. m_pbitstrmOut->trace (pmv [7], "MV16x8");
  203. }
  204. // end of new changes
  205. // ~INTERLACE
  206. #endif // __TRACE_AND_STATS_
  207. }
  208. pmbmd++;
  209. pmv += PVOP_MV_PER_REF_PER_MB;
  210. ppxlcOrigMBY += MB_SIZE;
  211. ppxlcOrigMBBY += MB_SIZE;
  212. ppxlcRefMBY += MB_SIZE;
  213. }
  214. ppxlcOrigY += m_iFrameWidthYxMBSize;
  215. ppxlcOrigBY += m_iFrameWidthYxMBSize;
  216. ppxlcRefY += m_iFrameWidthYxMBSize;
  217. }
  218. if (m_iMVFileUsage == 2)
  219. writePVOPMVs();
  220. }
  222. Void CVideoObjectEncoder::motionEstBVOP ()
  223. {
  224. if (m_iMVFileUsage == 1)
  225. readBVOPMVs();
  226. m_iMAD = 0;
  227. CoordI y = 0; // frame-based, always start from 0
  228. CMBMode* pmbmd = m_rgmbmd;
  229. const CMBMode* pmbmdRef = NULL;
  230. const CMotionVector* pmvRef = NULL; //mv in ref frame (for direct mode)
  232. if(m_bCodedFutureRef!=FALSE)
  233. {
  234. pmbmdRef = m_rgmbmdRef;
  235. pmvRef = m_rgmvRef;
  236. }
  238. CMotionVector* pmv = m_rgmv;
  239. CMotionVector* pmvBackward = m_rgmvBackward;
  240. const PixelC* ppxlcOrigY = m_pvopcOrig->pixelsBoundY ();
  241. const PixelC* ppxlcRef0Y = m_pvopcRefQ0->pixelsY () + m_iStartInRefToCurrRctY;
  242. const PixelC* ppxlcRef1Y = m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
  243. Int iMBX, iMBY;
  244. for (iMBY = 0; iMBY < m_iNumMBY; iMBY++, y += MB_SIZE) {
  245. const PixelC* ppxlcOrigMBY = ppxlcOrigY;
  246. const PixelC* ppxlcRef0MBY = ppxlcRef0Y;
  247. const PixelC* ppxlcRef1MBY = ppxlcRef1Y;
  248. CoordI x = 0; // frame-based, always start from 0
  249. for (iMBX = 0; iMBX < m_iNumMBX; iMBX++, x += MB_SIZE) {
  250. pmbmd->m_dctMd = INTER; // B-VOP is always INTER
  251. pmbmd->m_bhas4MVForward = pmbmd->m_bhas4MVBackward = FALSE;  //out encoder doesn't support 4 mv in bvop (not even direct mode)
  252. // TPS FIX
  253. if(m_volmd.volType == ENHN_LAYER && (m_vopmd.iRefSelectCode != 3 || m_volmd.iEnhnType == 1)){
  254. pmbmd->m_bColocatedMBSkip= FALSE;
  255. copyToCurrBuffY(ppxlcOrigMBY); 
  256. // begin: modified by Sharp(98/3/10)
  257. if ( m_vopmd.iRefSelectCode == 0 )
  258. motionEstMB_BVOP (x, y, pmv, pmvBackward, pmbmd, ppxlcRef0MBY, ppxlcRef1MBY);
  259. else
  260. motionEstMB_BVOP (x, y, pmv, pmvBackward, pmbmd, pmbmdRef, pmvRef, ppxlcRef0MBY, ppxlcRef1MBY, TRUE);
  261. // end: modified by Sharp(98/3/10)
  262. }
  263. else {
  264. pmbmd->m_bColocatedMBSkip = (pmbmdRef==NULL) ? FALSE : pmbmdRef->m_bSkip;
  265. if (pmbmd->m_bColocatedMBSkip) {
  266. pmbmd->m_bSkip = TRUE;
  267. memset (pmv, 0, BVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
  268. pmbmd->m_mbType = FORWARD; // can be set to FORWARD mode since the result is the same
  269. }
  270. else {
  271. copyToCurrBuffY (ppxlcOrigMBY);
  272. m_iMAD += m_vopmd.bInterlace ?
  273.                         motionEstMB_BVOP_Interlaced (x, y, pmv, pmvBackward, pmbmd,
  274.                                                      pmbmdRef, pmvRef, ppxlcRef0MBY, ppxlcRef1MBY, pmbmdRef!=NULL) :
  275.                         motionEstMB_BVOP            (x, y, pmv, pmvBackward, pmbmd,
  276.                                                      pmbmdRef, pmvRef, ppxlcRef0MBY, ppxlcRef1MBY, pmbmdRef!=NULL);
  277. }
  278. }
  279. pmbmd++;
  280. pmv         += BVOP_MV_PER_REF_PER_MB;
  281. pmvBackward += BVOP_MV_PER_REF_PER_MB;
  283. if(m_bCodedFutureRef!=FALSE)
  284. {
  285. pmbmdRef++;
  286. pmvRef += PVOP_MV_PER_REF_PER_MB;
  287. }
  289. ppxlcOrigMBY += MB_SIZE;
  290. ppxlcRef0MBY += MB_SIZE;
  291. ppxlcRef1MBY += MB_SIZE;
  292. }
  293. ppxlcOrigY += m_iFrameWidthYxMBSize;
  294. ppxlcRef0Y += m_iFrameWidthYxMBSize;
  295. ppxlcRef1Y += m_iFrameWidthYxMBSize;
  296. }
  297. if (m_iMVFileUsage == 2)
  298. writeBVOPMVs();
  299. }
  301. Void CVideoObjectEncoder::motionEstBVOP_WithShape ()
  302. {
  303. m_iMAD = 0;
  304. CoordI y = m_rctCurrVOPY.top; 
  305. CMBMode* pmbmd = m_rgmbmd;
  306. CMotionVector* pmv = m_rgmv;
  307. CMotionVector* pmvBackward = m_rgmvBackward;
  309. Bool bColocatedMBExist;
  310. const PixelC* ppxlcOrigY = m_pvopcOrig->pixelsBoundY ();
  311. const PixelC* ppxlcOrigBY = m_pvopcOrig->pixelsBoundBY ();
  312. const PixelC* ppxlcRef0Y = m_pvopcRefOrig0->pixelsY () + m_iStartInRefToCurrRctY;
  313. const PixelC* ppxlcRef1Y = m_pvopcRefOrig1->pixelsY () + m_iStartInRefToCurrRctY;
  314. Int iMBX, iMBY;
  316. if (m_iMVFileUsage == 1)
  317. readBVOPMVs();
  319. for (iMBY = 0; iMBY < m_iNumMBY; iMBY++, y += MB_SIZE) {
  320. const PixelC* ppxlcOrigMBY = ppxlcOrigY;
  321. const PixelC* ppxlcOrigMBBY = ppxlcOrigBY;
  322. const PixelC* ppxlcRef0MBY = ppxlcRef0Y;
  323. const PixelC* ppxlcRef1MBY = ppxlcRef1Y;
  324. CoordI x = m_rctCurrVOPY.left;
  325. for (iMBX = 0; iMBX < m_iNumMBX; iMBX++, x += MB_SIZE) {
  326. pmbmd->m_dctMd = INTER; // B-VOP is always INTER
  327. pmbmd->m_bhas4MVForward = pmbmd->m_bhas4MVBackward = FALSE;
  328. copyToCurrBuffWithShapeY (ppxlcOrigMBY, ppxlcOrigMBBY);
  329. decideTransparencyStatus (pmbmd, m_ppxlcCurrMBBY);
  330. if (pmbmd->m_rgTranspStatus [0] != ALL) {
  331. const CMBMode* pmbmdRef;
  332. const CMotionVector* pmvRef;
  333. findColocatedMB (iMBX, iMBY, pmbmdRef, pmvRef);
  334. pmbmd->m_bColocatedMBSkip = (pmbmdRef!=NULL && pmbmdRef->m_bSkip);
  335. // TPS FIX
  336. if(m_volmd.volType == ENHN_LAYER && (m_vopmd.iRefSelectCode != 3 || m_volmd.iEnhnType == 1)) {
  337. pmbmd->m_bColocatedMBSkip= FALSE;
  338. bColocatedMBExist = (pmbmdRef!=NULL);
  339. if (pmbmd->m_rgTranspStatus [0] == NONE) {
  340. m_iMAD += motionEstMB_BVOP (
  341. x, y, 
  342. pmv, pmvBackward,
  343. pmbmd, 
  344. pmbmdRef, pmvRef,
  345. ppxlcRef0MBY, ppxlcRef1MBY,
  346. bColocatedMBExist
  347. );
  348. }
  349. else if (pmbmd->m_rgTranspStatus [0] == PARTIAL) {
  350. m_iMAD += motionEstMB_BVOP_WithShape (
  351. x, y, 
  352. pmv, pmvBackward,
  353. pmbmd, 
  354. pmbmdRef, pmvRef,
  355. ppxlcRef0MBY, ppxlcRef1MBY,
  356. bColocatedMBExist
  357. );
  358. }
  359. } 
  360. else {
  361. if (pmbmd->m_bColocatedMBSkip) {
  362. pmbmd->m_bSkip = TRUE;
  363. memset (pmv, 0, BVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
  364. m_statsMB.nDirectMB++;
  365. pmbmd->m_mbType = FORWARD;
  366. }
  367. else {
  368. bColocatedMBExist = (pmbmdRef!=NULL);
  369. if (pmbmd->m_rgTranspStatus [0] == NONE) {
  370. // new changes
  371. m_iMAD += m_vopmd.bInterlace ?
  372. motionEstMB_BVOP_Interlaced (x, y, pmv, pmvBackward, pmbmd,
  373.                                                      pmbmdRef, pmvRef, ppxlcRef0MBY, 
  374.  ppxlcRef1MBY,
  375.  bColocatedMBExist) :
  376. // end of new changes
  377. motionEstMB_BVOP (
  378. x, y, 
  379. pmv, pmvBackward,
  380. pmbmd, 
  381. pmbmdRef, pmvRef,
  382. ppxlcRef0MBY, ppxlcRef1MBY,
  383. bColocatedMBExist
  384. );
  385. }
  386. else if (pmbmd->m_rgTranspStatus [0] == PARTIAL) {
  387. // new changes
  388. m_iMAD += m_vopmd.bInterlace ?
  389.                         motionEstMB_BVOP_InterlacedWithShape (x, y, pmv, pmvBackward, pmbmd,
  390.                                                      pmbmdRef, pmvRef, ppxlcRef0MBY, 
  391.  ppxlcRef1MBY,
  392.  bColocatedMBExist) :
  393. // end of new changes
  394. motionEstMB_BVOP_WithShape (
  395. x, y, 
  396. pmv, pmvBackward,
  397. pmbmd, 
  398. pmbmdRef, pmvRef,
  399. ppxlcRef0MBY, ppxlcRef1MBY,
  400. bColocatedMBExist
  401. );
  402. }
  403. }
  404. }
  405. }
  406. ppxlcOrigMBBY += MB_SIZE;
  407. pmbmd++;
  408. pmv         += BVOP_MV_PER_REF_PER_MB;
  409. pmvBackward += BVOP_MV_PER_REF_PER_MB;
  410. ppxlcOrigMBY += MB_SIZE;
  411. ppxlcRef0MBY += MB_SIZE;
  412. ppxlcRef1MBY += MB_SIZE;
  413. }
  414. ppxlcOrigY += m_iFrameWidthYxMBSize;
  415. ppxlcOrigBY += m_iFrameWidthYxMBSize;
  416. ppxlcRef0Y += m_iFrameWidthYxMBSize;
  417. ppxlcRef1Y += m_iFrameWidthYxMBSize;
  418. }
  419. if (m_iMVFileUsage == 2)
  420. writeBVOPMVs();
  421. }
  423. Void CVideoObjectEncoder::copyToCurrBuffWithShapeY (const PixelC* ppxlcCurrY, const PixelC* ppxlcCurrBY)
  424. {
  425. Int iUnit = sizeof(PixelC); // NBIT: for memcpy
  426. PixelC* ppxlcCurrMBY = m_ppxlcCurrMBY;
  427. PixelC* ppxlcCurrMBBY = m_ppxlcCurrMBBY;
  428. Int ic;
  429. for (ic = 0; ic < MB_SIZE; ic++) {
  430. memcpy (ppxlcCurrMBY, ppxlcCurrY, MB_SIZE*iUnit);
  431. memcpy (ppxlcCurrMBBY, ppxlcCurrBY, MB_SIZE*iUnit);
  432. ppxlcCurrMBY += MB_SIZE; ppxlcCurrY += m_iFrameWidthY;
  433. ppxlcCurrMBBY += MB_SIZE; ppxlcCurrBY += m_iFrameWidthY;
  434. }
  435. }
  437. Void CVideoObjectEncoder::copyToCurrBuffY (const PixelC* ppxlcCurrY)
  438. {
  439. Int iUnit = sizeof(PixelC); // NBIT: for memcpy
  440. PixelC* ppxlcCurrMBY = m_ppxlcCurrMBY;
  441. Int ic;
  442. for (ic = 0; ic < MB_SIZE; ic++) {
  443. memcpy (ppxlcCurrMBY, ppxlcCurrY, MB_SIZE*iUnit);
  444. ppxlcCurrMBY += MB_SIZE; ppxlcCurrY += m_iFrameWidthY;
  445. }
  446. }
  448. //for spatial sclability: basically set every mv to zero
  449. Void CVideoObjectEncoder::motionEstMB_PVOP (CoordI x, CoordI y, 
  450. CMotionVector* pmv, CMBMode* pmbmd)
  451. {
  452. pmbmd -> m_bhas4MVForward = FALSE;
  453. pmbmd-> m_dctMd = INTER;
  454. memset (pmv, 0, sizeof (CMotionVector) * PVOP_MV_PER_REF_PER_MB);
  455. for (UInt i = 0; i < PVOP_MV_PER_REF_PER_MB; i++)  {
  456. pmv -> computeTrueMV (); 
  457. pmv++;
  458. }
  459. }
  461. Int CVideoObjectEncoder::motionEstMB_PVOP (
  462. CoordI x, CoordI y, 
  463. CMotionVector* pmv, CMBMode* pmbmd, 
  464. const PixelC* ppxlcRefMBY
  465. )
  466. {
  467. Int nBits = m_volmd.nBits; // NBIT
  468. Int iFavorZero = FAVORZERO; // NBIT
  469. Int iFavorInter = FAVOR_INTER; // NBIT
  470. Int iFavor16x16 = FAVOR_16x16; // NBIT
  471. // NBIT: addjust mode selection thresholds
  472. if (nBits > 8) {
  473. iFavorZero <<= (nBits-8);
  474. iFavorInter <<= (nBits-8);
  475. iFavor16x16 <<= (nBits-8);
  476. } else if (nBits < 8) {
  477. iFavorZero >>= (8-nBits);
  478. iFavorInter >>= (8-nBits);
  479. iFavor16x16 >>= (8-nBits);
  480. }
  482. Int iInitSAD = sad16x16At0 (ppxlcRefMBY);
  483. Int iSADInter = blkmatch16 (pmv, x, y, x, y, iInitSAD, ppxlcRefMBY, m_puciRefQZoom0, m_vopmd.iSearchRangeForward);
  484. Int iSumDev = sumDev ();
  485. #ifdef __TRACE_AND_STATS_
  486. m_pbitstrmOut->trace (iSADInter, "MB_SAD16");
  487. #endif // __TRACE_AND_STATS_
  489. // INTERLACE
  490. /* NBIT: change to a bigger number
  491. Int iSAD16x8 = 256*256;
  492. */
  493. Int iSAD16x8 = 4096*256;
  494. pmbmd -> m_bFieldMV = FALSE;
  495. if(m_vopmd.bInterlace) {
  496. // Field-Based Estimation
  497. CMotionVector* pmv16x8 = pmv + 5;
  498. const PixelC *ppxlcHalfPelRef = m_pvopcRefQ0->pixelsY()
  499. + EXPANDY_REF_FRAME * m_iFrameWidthY + EXPANDY_REF_FRAME + x + y * m_iFrameWidthY; // 1.31.99 changes
  501. // top to top
  502. Int iSAD16x8top = blkmatch16x8 (pmv16x8, x, y, 0, ppxlcRefMBY,
  503. ppxlcHalfPelRef, m_vopmd.iSearchRangeForward);
  504. pmv16x8++;
  505. // bot to top
  506. Int iSAD16x8bot = blkmatch16x8 (pmv16x8, x, y, 0, ppxlcRefMBY + m_iFrameWidthY,
  507. ppxlcHalfPelRef + m_iFrameWidthY, m_vopmd.iSearchRangeForward);
  509. iSAD16x8=(iSAD16x8top<iSAD16x8bot) ? iSAD16x8top : iSAD16x8bot;
  510. pmbmd->m_bForwardTop = (iSAD16x8top<iSAD16x8bot) ? 0 : 1;
  511. pmv16x8++;
  512. // top to bot
  513. iSAD16x8top = blkmatch16x8 (pmv16x8, x, y, MB_SIZE, ppxlcRefMBY,
  514. ppxlcHalfPelRef, m_vopmd.iSearchRangeForward);
  515. pmv16x8++;
  516. // bot to bot
  517. iSAD16x8bot = blkmatch16x8 (pmv16x8, x, y, MB_SIZE, ppxlcRefMBY + m_iFrameWidthY,
  518. ppxlcHalfPelRef + m_iFrameWidthY, m_vopmd.iSearchRangeForward);
  519. iSAD16x8 += (iSAD16x8top<iSAD16x8bot) ? iSAD16x8top : iSAD16x8bot;
  520. pmbmd->m_bForwardBottom = (iSAD16x8top<iSAD16x8bot) ? 0 : 1;
  521. } else {
  522. /* NBIT: change to a bigger number
  523. iSAD16x8 = 256*256;
  524. */
  525. iSAD16x8 = 4096*256;
  527. for (Int iBlk = 5; iBlk <= 8; iBlk++) {  // 04/28/99 david ruhoff
  528. pmv [iBlk] = pmv [0];   // fill in field info to make mv file deterministic
  529. }
  530. }
  531. #ifdef __TRACE_AND_STATS_
  532. m_pbitstrmOut->trace (iSAD16x8, "MB_SAD16x8");
  533. #endif // __TRACE_AND_STATS_
  534. // ~INTERLACE
  536. CoordI blkX, blkY;
  537. Int iSAD8 = 0;
  538. CMotionVector* pmv8 = pmv + 1;
  539. blkX = x + BLOCK_SIZE;
  540. blkY = y + BLOCK_SIZE;
  541. const PixelC* ppxlcCodedBlkY = m_ppxlcCurrMBY;
  543. #ifdef __DISABLE_4MV_FOR_PVOP_
  544. iSAD8 = 4096*4096; // big number to disable 8x8 mode
  545. #else
  547. // 8x8
  548. iSAD8 += blockmatch8 (ppxlcCodedBlkY, pmv8, x, y, pmv, m_vopmd.iSearchRangeForward);
  549. pmv8++;
  550. ppxlcCodedBlkY += BLOCK_SIZE;
  551. #ifdef __TRACE_AND_STATS_
  552. m_pbitstrmOut->trace (iSAD8, "MB_SAD8");
  553. #endif // __TRACE_AND_STATS_
  555. iSAD8 += blockmatch8 (ppxlcCodedBlkY, pmv8, blkX, y, pmv, m_vopmd.iSearchRangeForward);
  556. pmv8++;
  557. ppxlcCodedBlkY += BLOCK_SIZE * MB_SIZE - BLOCK_SIZE;
  558. #ifdef __TRACE_AND_STATS_
  559. m_pbitstrmOut->trace (iSAD8, "MB_SAD8");
  560. #endif // __TRACE_AND_STATS_
  562. iSAD8 += blockmatch8 (ppxlcCodedBlkY, pmv8, x, blkY, pmv, m_vopmd.iSearchRangeForward);
  563. pmv8++;
  564. ppxlcCodedBlkY += BLOCK_SIZE;
  565. #ifdef __TRACE_AND_STATS_
  566. m_pbitstrmOut->trace (iSAD8, "MB_SAD8");
  567. #endif // __TRACE_AND_STATS_
  569. iSAD8 += blockmatch8 (ppxlcCodedBlkY, pmv8, blkX, blkY, pmv, m_vopmd.iSearchRangeForward);
  570. #ifdef __TRACE_AND_STATS_
  571. m_pbitstrmOut->trace (iSAD8, "MB_SAD8");
  572. #endif // __TRACE_AND_STATS_
  574. #endif // DISABLE_4MV_FOR_PVOP
  576. /* NBIT: change
  577. iSADInter -= FAVOR_16x16;
  578. */
  579. iSADInter -= iFavor16x16;
  580. iSAD16x8 -= FAVOR_FIELD;
  581. if ((iSADInter <= iSAD8) && (iSADInter <= iSAD16x8)) {
  582. /* NBIT: change
  583.     iSADInter += FAVOR_16x16;
  584. */
  585.     iSADInter += iFavor16x16;
  586. pmbmd -> m_bhas4MVForward = FALSE;
  587. pmv -> computeTrueMV (); // compute here instead of blkmatch to save computation
  588. for (UInt i = 1; i < PVOP_MV_PER_REF_PER_MB; i++) // didn't increment the last pmv
  589. pmv[i].m_vctTrueHalfPel = pmv->m_vctTrueHalfPel; // Save (iMVX, iMVY) for MV file
  590. }
  591. // INTERLACE
  592. else if (iSAD16x8 <= iSAD8) { // Field-based
  593. pmbmd -> m_bhas4MVForward = FALSE;
  594. pmbmd -> m_bFieldMV = TRUE;
  595. Int iTempX1, iTempY1, iTempX2, iTempY2;
  596. if(pmbmd->m_bForwardTop) {
  597. pmv [6].computeTrueMV ();
  598. iTempX1 = pmv[6].m_vctTrueHalfPel.x;
  599. iTempY1 = pmv[6].m_vctTrueHalfPel.y;
  600. }
  601. else {
  602. pmv [5].computeTrueMV ();
  603. iTempX1 = pmv[5].m_vctTrueHalfPel.x;
  604. iTempY1 = pmv[5].m_vctTrueHalfPel.y;
  605. }
  606. if(pmbmd->m_bForwardBottom) {
  607. pmv [8].computeTrueMV ();
  608. iTempX2 = pmv[8].m_vctTrueHalfPel.x;
  609. iTempY2 = pmv[8].m_vctTrueHalfPel.y;
  610. }
  611. else {
  612. pmv [7].computeTrueMV ();
  613. iTempX2 = pmv[7].m_vctTrueHalfPel.x;
  614. iTempY2 = pmv[7].m_vctTrueHalfPel.y;
  615. }
  616. iSADInter = iSAD16x8 + FAVOR_FIELD;
  617. Int iTemp;
  618. for (UInt i = 1; i < 5; i++) {
  619. iTemp = iTempX1 + iTempX2;
  620. pmv [i].m_vctTrueHalfPel.x = (iTemp & 3) ? ((iTemp>>1) | 1) : (iTemp>>1);
  621. iTemp = iTempY1 + iTempY2;
  622. pmv [i].m_vctTrueHalfPel.y = (iTemp & 3) ? ((iTemp>>1) | 1) : (iTemp>>1);
  623. }
  624. }
  625. // ~INTERLACE
  626. else {
  627. pmv [1].computeTrueMV ();
  628. pmv [2].computeTrueMV ();
  629. pmv [3].computeTrueMV ();
  630. pmv [4].computeTrueMV ();
  631. pmbmd -> m_bhas4MVForward = TRUE;
  632. iSADInter = iSAD8;
  633. }
  634. /* NBIT: change
  635. if (iSumDev < (iSADInter - FAVOR_INTER)) {
  636. */
  637. if (iSumDev < (iSADInter - iFavorInter)) {
  638. pmbmd -> m_bSkip = FALSE;
  639. pmbmd -> m_dctMd = INTRA;
  640. pmbmd -> m_bFieldMV = FALSE;
  641. memset (pmv, 0, PVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
  642. return ((m_uiRateControl==RC_MPEG4) ? sumAbsCurrMB () : 0);
  643. }
  644. else {
  645. pmbmd -> m_dctMd = INTER;
  646. if (pmbmd->m_bhas4MVForward == FALSE
  647. && pmbmd -> m_bFieldMV == FALSE
  648. && pmv->m_vctTrueHalfPel.x == 0 && pmv->m_vctTrueHalfPel.y == 0)
  649. /* NBIT: change
  650. return (iSADInter + FAVORZERO);
  651. */
  652. return (iSADInter + iFavorZero);
  653. else 
  654. return iSADInter;
  655. }
  656. }
  658. Int CVideoObjectEncoder::motionEstMB_PVOP_WithShape (
  659. CoordI x, CoordI y, 
  660. CMotionVector* pmv, CMBMode* pmbmd, 
  661. const PixelC* ppxlcRefMBY
  662. )
  663. {
  664. assert (pmbmd->m_rgTranspStatus [0] == PARTIAL);
  665. UInt nBits = m_volmd.nBits; // NBIT
  666. Int iFavorZero = FAVORZERO;
  667. Int iFavor16x16 = (pmbmd->m_rgNumNonTranspPixels [0] >> 1) + 1; // NBIT
  668. Int iFavorInter = pmbmd->m_rgNumNonTranspPixels [0] << 1; // NBIT
  669. // NBIT: addjust mode selection thresholds
  670. if (nBits > 8) {
  671. iFavor16x16 <<= (nBits-8);
  672. iFavorInter <<= (nBits-8);
  673. iFavorZero <<= (nBits-8);
  674. } else if (nBits < 8) {
  675. iFavor16x16 >>= (8-nBits);
  676. iFavorInter >>= (8-nBits);
  677. iFavorZero >>= (8-nBits);
  678. }
  680. Int iInitSAD = sad16x16At0WithShape (ppxlcRefMBY, pmbmd);
  681. Int iSADInter = blkmatch16WithShape (pmv, x, y, x, y, iInitSAD, ppxlcRefMBY, m_puciRefQZoom0, pmbmd, m_vopmd.iSearchRangeForward,0);
  682. Int iSumDev = sumDevWithShape (pmbmd -> m_rgNumNonTranspPixels [0]);
  683. #ifdef __TRACE_AND_STATS_
  684. m_pbitstrmOut->trace (iSADInter, "MB_SAD16");
  685. #endif // __TRACE_AND_STATS_
  686. // INTERLACE
  687. // New Changes
  688. Int iSAD16x8 = 4096*256;
  689. pmbmd -> m_bFieldMV = FALSE;
  690. if(m_vopmd.bInterlace) {
  691. // Field-Based Estimation
  692. CMotionVector* pmv16x8 = pmv + 5;
  693. const PixelC *ppxlcHalfPelRef = m_pvopcRefQ0->pixelsY()
  694. + EXPANDY_REF_FRAME * m_iFrameWidthY + EXPANDY_REF_FRAME + x + y * m_iFrameWidthY; // 1.31.99 changes
  696. // top to top
  697. Int iSAD16x8top = blkmatch16x8WithShape (pmv16x8, x, y, 0, ppxlcRefMBY,
  698. ppxlcHalfPelRef, m_vopmd.iSearchRangeForward,0);
  699. pmv16x8++;
  700. // bot to top
  701. Int iSAD16x8bot = blkmatch16x8WithShape (pmv16x8, x, y, 0, ppxlcRefMBY + m_iFrameWidthY,
  702. ppxlcHalfPelRef + m_iFrameWidthY, m_vopmd.iSearchRangeForward,0);
  704. iSAD16x8=(iSAD16x8top<iSAD16x8bot) ? iSAD16x8top : iSAD16x8bot;
  705. pmbmd->m_bForwardTop = (iSAD16x8top<iSAD16x8bot) ? 0 : 1;
  706. pmv16x8++;
  707. // top to bot
  708. iSAD16x8top = blkmatch16x8WithShape (pmv16x8, x, y, MB_SIZE, ppxlcRefMBY,
  709. ppxlcHalfPelRef, m_vopmd.iSearchRangeForward,0);
  710. pmv16x8++;
  711. // bot to bot
  712. iSAD16x8bot = blkmatch16x8WithShape (pmv16x8, x, y, MB_SIZE, ppxlcRefMBY + m_iFrameWidthY,
  713. ppxlcHalfPelRef + m_iFrameWidthY, m_vopmd.iSearchRangeForward,0);
  714. iSAD16x8 += (iSAD16x8top<iSAD16x8bot) ? iSAD16x8top : iSAD16x8bot;
  715. pmbmd->m_bForwardBottom = (iSAD16x8top<iSAD16x8bot) ? 0 : 1;
  716. } else {
  717. iSAD16x8 = 4096*256;
  719. for (Int iBlk = 5; iBlk <= 8; iBlk++) {  // 04/28/99 david ruhoff
  720. pmv [iBlk] = pmv [0];   // fill in field info to make mv file deterministic
  721. }
  722. }
  723. #ifdef __TRACE_AND_STATS_
  724. m_pbitstrmOut->trace (iSAD16x8, "MB_SAD16x8");
  725. #endif // __TRACE_AND_STATS_
  726. // end of New changes
  727. // ~INTERLACE
  729. CoordI blkX, blkY;
  730. Int iSAD8 = 0;
  731. CMotionVector* pmv8 = pmv + 1;
  732. blkX = x + BLOCK_SIZE;
  733. blkY = y + BLOCK_SIZE;
  734. const PixelC* ppxlcCodedBlkY = m_ppxlcCurrMBY;
  735. const PixelC* ppxlcCodedBlkBY = m_ppxlcCurrMBBY;
  737. // 8 x 8
  738. iSAD8 += 
  739. (pmbmd->m_rgTranspStatus [1] == PARTIAL) ? blockmatch8WithShape (ppxlcCodedBlkY, ppxlcCodedBlkBY, pmv8, x, y, pmv, m_vopmd.iSearchRangeForward,0) :
  740. (pmbmd->m_rgTranspStatus [1] == NONE) ? blockmatch8 (ppxlcCodedBlkY, pmv8, x, y, pmv, m_vopmd.iSearchRangeForward) : 0;
  741. pmv8++;
  742. ppxlcCodedBlkY += BLOCK_SIZE;
  743. ppxlcCodedBlkBY += BLOCK_SIZE;
  744. #ifdef __TRACE_AND_STATS_
  745. m_pbitstrmOut->trace (iSAD8, "MB_SAD8");
  746. #endif // __TRACE_AND_STATS_
  748. iSAD8 += 
  749. (pmbmd->m_rgTranspStatus [2] == PARTIAL) ? blockmatch8WithShape (ppxlcCodedBlkY, ppxlcCodedBlkBY, pmv8, blkX, y, pmv, m_vopmd.iSearchRangeForward,0) :
  750. (pmbmd->m_rgTranspStatus [2] == NONE) ? blockmatch8 (ppxlcCodedBlkY, pmv8, blkX, y, pmv, m_vopmd.iSearchRangeForward) : 0;
  751. pmv8++;
  752. ppxlcCodedBlkY += BLOCK_SIZE * MB_SIZE - BLOCK_SIZE;
  753. ppxlcCodedBlkBY += BLOCK_SIZE * MB_SIZE - BLOCK_SIZE;
  754. #ifdef __TRACE_AND_STATS_
  755. m_pbitstrmOut->trace (iSAD8, "MB_SAD8");
  756. #endif // __TRACE_AND_STATS_
  758. iSAD8 += 
  759. (pmbmd->m_rgTranspStatus [3] == PARTIAL) ? blockmatch8WithShape (ppxlcCodedBlkY, ppxlcCodedBlkBY, pmv8, x, blkY, pmv, m_vopmd.iSearchRangeForward,0) :
  760. (pmbmd->m_rgTranspStatus [3] == NONE) ? blockmatch8 (ppxlcCodedBlkY, pmv8, x, blkY, pmv, m_vopmd.iSearchRangeForward) : 0;
  761. pmv8++;
  762. ppxlcCodedBlkY += BLOCK_SIZE;
  763. ppxlcCodedBlkBY += BLOCK_SIZE;
  765. #ifdef __TRACE_AND_STATS_
  766. m_pbitstrmOut->trace (iSAD8, "MB_SAD8");
  767. #endif // __TRACE_AND_STATS_
  769. iSAD8 += 
  770. (pmbmd->m_rgTranspStatus [4] == PARTIAL) ? blockmatch8WithShape (ppxlcCodedBlkY, ppxlcCodedBlkBY, pmv8, blkX, blkY, pmv, m_vopmd.iSearchRangeForward,0) :
  771. (pmbmd->m_rgTranspStatus [4] == NONE) ? blockmatch8 (ppxlcCodedBlkY, pmv8, blkX, blkY, pmv, m_vopmd.iSearchRangeForward) : 0;
  772. #ifdef __TRACE_AND_STATS_
  773. m_pbitstrmOut->trace (iSAD8, "MB_SAD8");
  774. #endif // __TRACE_AND_STATS_
  776. // begin added by Sharp (98/9/10) prevents inter4v with one transp block
  777. if (( pmbmd->m_rgTranspStatus [1] != ALL && pmbmd->m_rgTranspStatus [2] == ALL
  778. && pmbmd->m_rgTranspStatus [3] == ALL && pmbmd->m_rgTranspStatus [4] == ALL )||
  779. ( pmbmd->m_rgTranspStatus [1] == ALL && pmbmd->m_rgTranspStatus [2] != ALL
  780. && pmbmd->m_rgTranspStatus [3] == ALL && pmbmd->m_rgTranspStatus [4] == ALL )||
  781. ( pmbmd->m_rgTranspStatus [1] == ALL && pmbmd->m_rgTranspStatus [2] == ALL
  782. && pmbmd->m_rgTranspStatus [3] != ALL && pmbmd->m_rgTranspStatus [4] == ALL )||
  783. ( pmbmd->m_rgTranspStatus [1] == ALL && pmbmd->m_rgTranspStatus [2] == ALL
  784. && pmbmd->m_rgTranspStatus [3] == ALL && pmbmd->m_rgTranspStatus [4] != ALL ))
  785. iSAD8 = 256 * 4096;
  786. // end added by Sharp (98/9/10)
  788. #ifdef __TRACE_AND_STATS_
  789. m_pbitstrmOut->trace (iSAD8, "MB_SAD8");
  790. #endif // __TRACE_AND_STATS_
  792. /* NBIT: change
  793. if ((iSADInter - ((pmbmd->m_rgNumNonTranspPixels [0] >> 1) + 1)) <= iSAD8) {
  794. */
  795. // new changes
  796. iSADInter -= iFavor16x16;
  797. iSAD16x8 -= FAVOR_FIELD;
  798. if ((iSADInter <= iSAD8)&&(iSADInter <= iSAD16x8)) {
  799. iSADInter += iFavor16x16;
  800. // end of new changes
  801. pmbmd -> m_bhas4MVForward = FALSE;
  802. pmv -> computeTrueMV (); // compute here instead of blkmatch to save computation
  803. for (UInt i = 1; i < PVOP_MV_PER_REF_PER_MB; i++) // didn't increment the last pmv
  804. pmv [i] = *pmv;
  805. }
  806. // INTERLACE
  807. // new changes
  808. else if (iSAD16x8 <= iSAD8) { // Field-based
  809. pmbmd -> m_bhas4MVForward = FALSE;
  810. pmbmd -> m_bFieldMV = TRUE;
  811. Int iTempX1, iTempY1, iTempX2, iTempY2;
  812. if(pmbmd->m_bForwardTop) {
  813. pmv [6].computeTrueMV ();
  814. iTempX1 = pmv[6].m_vctTrueHalfPel.x;
  815. iTempY1 = pmv[6].m_vctTrueHalfPel.y;
  816. }
  817. else {
  818. pmv [5].computeTrueMV ();
  819. iTempX1 = pmv[5].m_vctTrueHalfPel.x;
  820. iTempY1 = pmv[5].m_vctTrueHalfPel.y;
  821. }
  822. if(pmbmd->m_bForwardBottom) {
  823. pmv [8].computeTrueMV ();
  824. iTempX2 = pmv[8].m_vctTrueHalfPel.x;
  825. iTempY2 = pmv[8].m_vctTrueHalfPel.y;
  826. }
  827. else {
  828. pmv [7].computeTrueMV ();
  829. iTempX2 = pmv[7].m_vctTrueHalfPel.x;
  830. iTempY2 = pmv[7].m_vctTrueHalfPel.y;
  831. }
  832. iSADInter = iSAD16x8 + FAVOR_FIELD;
  833. Int iTemp;
  834. for (UInt i = 1; i < 5; i++) {
  835. iTemp = iTempX1 + iTempX2;
  836. pmv [i].m_vctTrueHalfPel.x = (iTemp & 3) ? ((iTemp>>1) | 1) : (iTemp>>1);
  837. iTemp = iTempY1 + iTempY2;
  838. pmv [i].m_vctTrueHalfPel.y = (iTemp & 3) ? ((iTemp>>1) | 1) : (iTemp>>1);
  839. }
  840. }
  841. //end of new changes
  842. // ~INTERLACE
  843. else {
  844. pmv [1].computeTrueMV ();
  845. pmv [2].computeTrueMV ();
  846. pmv [3].computeTrueMV ();
  847. pmv [4].computeTrueMV ();
  848. pmbmd -> m_bhas4MVForward = TRUE;
  849. iSADInter = iSAD8;
  850. }
  851. /* NBIT: change
  852. if (iSumDev < (iSADInter - (pmbmd->m_rgNumNonTranspPixels [0] << 1))) {
  853. */
  854. if (iSumDev < (iSADInter - iFavorInter)) {
  855. pmbmd -> m_bSkip = FALSE;
  856. pmbmd -> m_dctMd = INTRA;
  857. // new changes
  858. pmbmd -> m_bFieldMV = FALSE;
  859. memset (pmv, 0, PVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
  860. return ((m_uiRateControl==RC_MPEG4) ? sumAbsCurrMB () : 0);
  861. }
  862. else {
  863. pmbmd -> m_dctMd = INTER;
  864. // new changes
  865. if (pmbmd->m_bhas4MVForward == FALSE
  866. && pmbmd -> m_bFieldMV == FALSE
  867. && pmv->m_vctTrueHalfPel.x == 0 && pmv->m_vctTrueHalfPel.y == 0)
  868. return (iSADInter + iFavorZero);
  869. else 
  870. return iSADInter;
  871. }
  872. }
  874. CMotionVector rgmvDirectBack [5];
  875. CMotionVector rgmvDirectForward [5];
  877. Int CVideoObjectEncoder::motionEstMB_BVOP (
  878. CoordI x, CoordI y, 
  879. CMotionVector* pmvForward, CMotionVector* pmvBackward,
  880. CMBMode* pmbmd,
  881. const CMBMode* pmbmdRef, const CMotionVector* pmvRef,
  882. const PixelC* ppxlcRef0MBY, const PixelC* ppxlcRef1MBY,
  883. Bool bColocatedMBExist
  884. )
  885. {
  886. //printf("(%d,%d)n", x, y);
  887. Int iInitSAD = sad16x16At0 (ppxlcRef0MBY) + FAVORZERO;
  888. Int iSADForward = blkmatch16 (pmvForward, x, y, x, y, iInitSAD, ppxlcRef0MBY, m_puciRefQZoom0, m_vopmd.iSearchRangeForward);
  889. pmvForward->computeTrueMV ();
  891. Int iSADDirect = 1000000000;
  892. CVector vctRefScaled;
  893. // TPS FIX
  894. if (bColocatedMBExist && pmbmdRef->m_bhas4MVForward == FALSE &&
  895. (m_volmd.volType != ENHN_LAYER || ( m_vopmd.iRefSelectCode != 1 && m_vopmd.iRefSelectCode != 2))) {
  896. Int iPartInterval = m_t - m_tPastRef; //initialize at MVDB = 0
  897. vctRefScaled = pmvRef->trueMVHalfPel () * iPartInterval;
  898. Int iFullInterval = m_tFutureRef - m_tPastRef;
  899. vctRefScaled.x /= iFullInterval; //truncation as per vm
  900. vctRefScaled.y /= iFullInterval; //truncation as per vm
  901. //set up initial forward vector; 
  902. rgmvDirectForward->iMVX = vctRefScaled.x / 2;
  903. rgmvDirectForward->iMVY = vctRefScaled.y / 2;
  904. rgmvDirectForward->iHalfX = 0;
  905. rgmvDirectForward->iHalfY = 0;
  906. rgmvDirectForward->computeTrueMV ();
  907. //set up initial backward vector
  908. pmbmd->m_vctDirectDeltaMV = rgmvDirectForward->m_vctTrueHalfPel - vctRefScaled; //mvdb not necessaryly 0 due to truncation of half pel 
  909. backwardMVFromForwardMV (rgmvDirectBack [0], rgmvDirectForward [0], *pmvRef, pmbmd->m_vctDirectDeltaMV);
  910. //compute initial sad
  911. iSADDirect = interpolateAndDiffY (rgmvDirectForward, rgmvDirectBack, x, y,
  912. &m_rctRefVOPY0, &m_rctRefVOPY1) - FAVORZERO;
  913. //set up inital position in ref frame
  914. Int iXInit = x + rgmvDirectForward->iMVX;
  915. Int iYInit = y + rgmvDirectForward->iMVY;
  916. const PixelC* ppxlcInitRefMBY = m_pvopcRefQ0->pixelsY () + m_rctRefFrameY.offset (iXInit, iYInit);
  917. //compute forward mv and sad; to be continue in iSADMin==iSADDirect
  918. Int isave = m_iMVFileUsage;                       // 04/28/99 david ruhoff
  919. if (!m_volmd.bOriginalForME) m_iMVFileUsage = 0;  // 04/28/99  must not use mv file based on reconstructed vop
  920. iSADDirect = blkmatch16 (rgmvDirectForward, iXInit, iYInit, x, y, iSADDirect, ppxlcInitRefMBY,
  921.         m_puciRefQZoom0, m_vopmd.iDirectModeRadius) - FAVOR_DIRECT;
  922. m_iMVFileUsage = isave;                           // 04/28/99 
  923. rgmvDirectForward->computeTrueMV ();
  924. pmbmd->m_vctDirectDeltaMV = rgmvDirectForward->m_vctTrueHalfPel - vctRefScaled;
  925. backwardMVFromForwardMV (rgmvDirectBack [0], rgmvDirectForward [0], *pmvRef, 
  926.  pmbmd->m_vctDirectDeltaMV);
  927. iSADDirect = interpolateAndDiffY (rgmvDirectForward, rgmvDirectBack, x, y,
  928.   &m_rctRefVOPY0, &m_rctRefVOPY1);
  929. if (pmbmd->m_vctDirectDeltaMV.x == 0 && pmbmd->m_vctDirectDeltaMV.y == 0)
  930. iSADDirect -= FAVORZERO;
  931. }
  933. iInitSAD = sad16x16At0 (ppxlcRef1MBY) + FAVORZERO;
  934. Int iSADBackward = blkmatch16 (pmvBackward, x, y, x, y, iInitSAD, ppxlcRef1MBY, m_puciRefQZoom1, m_vopmd.iSearchRangeBackward);
  935. pmvBackward->computeTrueMV ();
  936. Int iSADInterpolate = interpolateAndDiffY (
  937. pmvForward, pmvBackward,
  938. x, y, &m_rctRefVOPY0, &m_rctRefVOPY1
  939. );
  941. Int iSADMin = minimum (iSADDirect, iSADForward, iSADBackward, iSADInterpolate);
  943. if(m_bCodedFutureRef==FALSE)
  944. iSADMin = iSADForward; // force forward mode
  946. Int iBlk;
  947. if (iSADMin == iSADDirect) {
  948. pmbmd->m_mbType = DIRECT;
  949. //compute backward mv
  950. pmvForward [0]  = rgmvDirectForward  [0];
  951. pmvBackward [0] = rgmvDirectBack [0];
  952. }
  953. else if (iSADMin == iSADForward) {
  954. pmbmd->m_mbType = FORWARD;
  955. }
  956. else if (iSADMin == iSADBackward) {
  957. pmbmd->m_mbType = BACKWARD;
  958. }
  959. else {
  960. pmbmd->m_mbType = INTERPOLATE;
  961. }
  963. for (iBlk = 1; iBlk <= 4; iBlk++) {
  964. pmvForward [iBlk] = pmvForward [0];
  965. pmvBackward [iBlk] = pmvBackward [0];
  966. }
  968. return iSADMin;
  969. }
  971. // for spatial scalability only
  972. Int CVideoObjectEncoder::motionEstMB_BVOP (
  973. CoordI x, CoordI y, 
  974. CMotionVector* pmvForward, CMotionVector* pmvBackward,
  975. CMBMode* pmbmd,
  976. const PixelC* ppxlcRef0MBY, const PixelC* ppxlcRef1MBY
  977. )
  978. {
  979. Int iInitSAD = sad16x16At0 (ppxlcRef0MBY);
  980. Int iSADForward = blkmatch16 (pmvForward, x, y,x,y, iInitSAD, ppxlcRef0MBY, m_puciRefQZoom0, m_vopmd.iSearchRangeForward);
  982. pmvForward->computeTrueMV ();
  983. //Int iSADDirect = 1000000000;
  985. iInitSAD = sad16x16At0 (ppxlcRef1MBY);
  986. Int iSADBackward = iInitSAD;
  987. *pmvBackward = CMotionVector (0,0);
  988. pmvBackward->computeTrueMV ();
  989. Int iSADInterpolate = interpolateAndDiffY (pmvForward, pmvBackward, x, y,
  990. &m_rctRefVOPY0, &m_rctRefVOPY1);
  992. Int iSADMin=0;
  993. if(iSADForward <= iSADBackward && iSADForward <= iSADInterpolate)
  994. iSADMin = iSADForward;
  995. else if (iSADBackward <= iSADInterpolate)
  996. iSADMin = iSADBackward;
  997. else
  998. iSADMin = iSADInterpolate;
  999. Int iBlk;
  1000. if (iSADMin == iSADForward) {
  1001. pmbmd->m_mbType = FORWARD;
  1002. }
  1003. else if (iSADMin == iSADBackward) {
  1004. pmbmd->m_mbType = BACKWARD;
  1005. }
  1006. else {
  1007. pmbmd->m_mbType = INTERPOLATE;
  1008. }
  1010. for (iBlk = 1; iBlk <= 4; iBlk++) {
  1011. pmvForward [iBlk] = pmvForward [0];
  1012. pmvBackward [iBlk] = pmvBackward [0];
  1013. }
  1014. return iSADMin;
  1015. }
  1017. Int CVideoObjectEncoder::motionEstMB_BVOP_WithShape (
  1018. CoordI x, CoordI y, 
  1019. CMotionVector* pmvForward, CMotionVector* pmvBackward,
  1020. CMBMode* pmbmd, 
  1021. const CMBMode* pmbmdRef, const CMotionVector* pmvRef,
  1022. const PixelC* ppxlcRef0MBY, const PixelC* ppxlcRef1MBY,
  1023. Bool bColocatedMBExist
  1024. )
  1025. {
  1026. assert (pmbmd->m_rgTranspStatus [0] == PARTIAL);
  1028. Int iInitSAD = sad16x16At0WithShape (ppxlcRef0MBY, pmbmd); //shouldn't favor 0 mv inside this function
  1029. Int iSADForward = blkmatch16WithShape (pmvForward, x, y, x, y, iInitSAD, ppxlcRef0MBY,
  1030.         m_puciRefQZoom0, pmbmd, m_vopmd.iSearchRangeForward,0);
  1031. pmvForward->computeTrueMV ();
  1032. Int iSADDirect = 1000000000;
  1033. CVector vctRefScaled;
  1034. if (bColocatedMBExist && pmbmdRef->m_bhas4MVForward == FALSE && 
  1035. (m_volmd.volType != ENHN_LAYER || ( m_vopmd.iRefSelectCode != 1 && m_vopmd.iRefSelectCode != 2))) {
  1036. Int iPartInterval = m_t - m_tPastRef; //initialize at MVDB = 0
  1037. vctRefScaled = pmvRef->trueMVHalfPel () * iPartInterval;
  1038. Int iFullInterval = m_tFutureRef - m_tPastRef;
  1039. vctRefScaled.x /= iFullInterval; //truncation as per vm
  1040. vctRefScaled.y /= iFullInterval; //truncation as per vm
  1041. //set up initial forward vector; 
  1042. rgmvDirectForward->iMVX = vctRefScaled.x / 2;
  1043. rgmvDirectForward->iMVY = vctRefScaled.y / 2;
  1044. rgmvDirectForward->iHalfX = 0;
  1045. rgmvDirectForward->iHalfY = 0;
  1046. rgmvDirectForward->computeTrueMV ();
  1047. //set up initial backward vector
  1048. pmbmd->m_vctDirectDeltaMV = rgmvDirectForward->m_vctTrueHalfPel - vctRefScaled; //mvdb not necessaryly 0 due to truncation of half pel 
  1049. backwardMVFromForwardMV (rgmvDirectBack [0], rgmvDirectForward [0], *pmvRef, pmbmd->m_vctDirectDeltaMV);
  1050. //compute initial sad
  1051. iSADDirect = interpolateAndDiffY_WithShape (rgmvDirectForward, rgmvDirectBack, x, y,
  1052. &m_rctRefVOPY0, &m_rctRefVOPY1) - FAVORZERO;;
  1053. //set up inital position in ref frame
  1054. Int iXInit = x + rgmvDirectForward->iMVX;
  1055. Int iYInit = y + rgmvDirectForward->iMVY;
  1056. const PixelC* ppxlcInitRefMBY = m_pvopcRefQ0->pixelsY () + m_rctRefFrameY.offset (iXInit, iYInit);
  1057. //compute forward mv and sad; to be continue in iSADMin==iSADDirect
  1058. Int isave = m_iMVFileUsage;                       // 04/28/99 david ruhoff
  1059. if (!m_volmd.bOriginalForME) m_iMVFileUsage = 0;  // 04/28/99  must not use mv file based on reconstructed vop
  1060. iSADDirect = blkmatch16WithShape  (rgmvDirectForward, iXInit, iYInit, x, y, iSADDirect, ppxlcInitRefMBY,
  1061.         m_puciRefQZoom0, pmbmd, m_vopmd.iDirectModeRadius,0) - FAVOR_DIRECT;
  1062. m_iMVFileUsage = isave;                           // 04/28/99 
  1063. rgmvDirectForward->computeTrueMV ();
  1064. pmbmd->m_vctDirectDeltaMV = rgmvDirectForward->m_vctTrueHalfPel - vctRefScaled;
  1065. backwardMVFromForwardMV (rgmvDirectBack [0], rgmvDirectForward [0], *pmvRef, 
  1066.  pmbmd->m_vctDirectDeltaMV);
  1067. iSADDirect = interpolateAndDiffY (rgmvDirectForward, rgmvDirectBack, x, y,
  1068.   &m_rctRefVOPY0, &m_rctRefVOPY1);
  1069. if (pmbmd->m_vctDirectDeltaMV.x == 0 && pmbmd->m_vctDirectDeltaMV.y == 0)
  1070. iSADDirect -= FAVORZERO;
  1071. }
  1074. iInitSAD = sad16x16At0WithShape (ppxlcRef1MBY, pmbmd);//shouldn't favor 0 mv inside this function
  1075. Int iSADBackward = blkmatch16WithShape (pmvBackward, x, y, x, y, iInitSAD, ppxlcRef1MBY,
  1076. m_puciRefQZoom1, pmbmd, m_vopmd.iSearchRangeBackward,1);
  1077. pmvBackward->computeTrueMV ();
  1078. Int iSADInterpolate = interpolateAndDiffY_WithShape (
  1079. pmvForward, pmvBackward,
  1080. x, y, &m_rctRefVOPY0, &m_rctRefVOPY1
  1081. );
  1083. Int iSADMin = minimum (iSADDirect, iSADForward, iSADBackward, iSADInterpolate);
  1084. Int iBlk;
  1086. if(m_bCodedFutureRef==FALSE)
  1087. iSADMin = iSADForward; // force forward mode
  1089. if (iSADMin == iSADDirect) {
  1090. pmbmd->m_mbType = DIRECT;
  1091. //compute backward mv
  1092. pmvForward [0] = rgmvDirectForward [0];
  1093. pmvBackward [0] = rgmvDirectBack [0];
  1094. }
  1095. else if (iSADMin == iSADForward) {
  1096. pmbmd->m_mbType = FORWARD;
  1097. }
  1098. else if (iSADMin == iSADBackward) {
  1099. pmbmd->m_mbType = BACKWARD;
  1100. }
  1101. else {
  1102. pmbmd->m_mbType = INTERPOLATE;
  1103. }
  1104. for (iBlk = 1; iBlk <= 4; iBlk++) {
  1105. pmvForward [iBlk] = pmvForward [0];
  1106. pmvBackward [iBlk] = pmvBackward [0];
  1107. }
  1108. return iSADMin;
  1109. }
  1111. // INTERLACE
  1112. #define BbiasAgainstFrameAve ((MB_SIZE*MB_SIZE)/2 + 1) // Biases favor modes with fewer MVs
  1113. #define BbiasAgainstFieldAve ((MB_SIZE*MB_SIZE)/1 + 1)
  1114. #define BbiasAgainstField ((MB_SIZE*MB_SIZE)/2 + 1)
  1115. #define BbiasFavorDirect ((MB_SIZE*MB_SIZE)/2 + 1)
  1117. Int CVideoObjectEncoder::motionEstMB_BVOP_Interlaced (
  1118. CoordI x, CoordI y, 
  1119. CMotionVector* pmvForward, CMotionVector* pmvBackward,
  1120. CMBMode* pmbmd,
  1121. const CMBMode* pmbmdRef, const CMotionVector* pmvRef,
  1122. const PixelC* ppxlcRef0MBY, const PixelC* ppxlcRef1MBY,
  1123. Bool bColocatedMBExist
  1124. )
  1125. {
  1126. Int iSAD, iSADnobias, iFieldSAD, iSADFrmMB[3];
  1127. MBType mbtype;
  1129. iSADFrmMB[0] = blkmatch16(pmvForward, x, y,x,y, sad16x16At0 (ppxlcRef0MBY),
  1130. ppxlcRef0MBY, m_puciRefQZoom0, m_vopmd.iSearchRangeForward);
  1131. pmvForward->computeTrueMV ();
  1132. iSADFrmMB[1] = blkmatch16(pmvBackward, x, y,x,y, sad16x16At0 (ppxlcRef1MBY),
  1133. ppxlcRef1MBY, m_puciRefQZoom1, m_vopmd.iSearchRangeBackward);
  1134. pmvBackward->computeTrueMV ();
  1135. iSADFrmMB[2] = interpolateAndDiffY(pmvForward, pmvBackward, x, y
  1136. , &m_rctRefVOPY0, &m_rctRefVOPY1);
  1138. #ifdef __TRACE_AND_STATS_
  1139. m_pbitstrmOut->trace (iSADFrmMB, 3, "SADFrmMB");
  1140. #endif // __TRACE_AND_STATS_
  1142. // Choose best 16x16 mode
  1143. pmbmd->m_bFieldMV = FALSE;
  1144. if (iSADFrmMB[0] < iSADFrmMB[1]) {
  1145. iSAD = iSADFrmMB[0];
  1146. pmbmd->m_mbType = FORWARD;
  1147. } else {
  1148. iSAD = iSADFrmMB[1];
  1149. pmbmd->m_mbType = BACKWARD;
  1150. }
  1151. iSADnobias = iSAD;
  1152. if ((iSADFrmMB[2] + BbiasAgainstFrameAve) < iSAD) {
  1153. iSAD = iSADFrmMB[2] + BbiasAgainstFrameAve;
  1154. iSADnobias = iSADFrmMB[2];
  1155. pmbmd->m_mbType = INTERPOLATE;
  1156. }
  1159. if(m_bCodedFutureRef==FALSE)
  1160. {
  1161. iSAD = iSADFrmMB[0];
  1162. pmbmd->m_mbType = FORWARD; // force forward mode
  1163. }
  1165. if (m_vopmd.bInterlace) {
  1166. const PixelC *ppxlcFwdHalfPelRef = m_pvopcRefQ0->pixelsY()
  1167. +EXPANDY_REF_FRAME * m_iFrameWidthY + EXPANDY_REF_FRAME+ x + y * m_iFrameWidthY; // 1.31.99 changes
  1168. const PixelC *ppxlcBakHalfPelRef = m_pvopcRefQ1->pixelsY()
  1169. +EXPANDY_REF_FRAME * m_iFrameWidthY + EXPANDY_REF_FRAME+ x + y * m_iFrameWidthY; // 1.31.99 changes
  1170. Int iSADFldMB[3], iSADFld[8];
  1172. // Choose best fwd top field predictor
  1173. iSADFld[0] = blkmatch16x8 (pmvForward+1, x, y, 0,
  1174. ppxlcRef0MBY, ppxlcFwdHalfPelRef, m_vopmd.iSearchRangeForward);
  1175. pmvForward[1].computeTrueMV();
  1176. iSADFld[1] = blkmatch16x8 (pmvForward+2, x, y, 0,
  1177. ppxlcRef0MBY + m_iFrameWidthY, ppxlcFwdHalfPelRef + m_iFrameWidthY,
  1178. m_vopmd.iSearchRangeForward);
  1179. pmvForward[2].computeTrueMV();
  1180. if (iSADFld[0] <= iSADFld[1]) {
  1181. pmbmd->m_bForwardTop = 0;
  1182. iSADFldMB[0] = iSADFld[0];
  1183. } else {
  1184. pmbmd->m_bForwardTop = 1;
  1185. iSADFldMB[0] = iSADFld[1];
  1186. }
  1188. // Choose best fwd botton field predictor
  1189. iSADFld[2] = blkmatch16x8 (pmvForward+3, x, y, MB_SIZE,
  1190. ppxlcRef0MBY, ppxlcFwdHalfPelRef, m_vopmd.iSearchRangeForward);
  1191. pmvForward[3].computeTrueMV();
  1192. iSADFld[3] = blkmatch16x8 (pmvForward+4, x, y, MB_SIZE,
  1193. ppxlcRef0MBY + m_iFrameWidthY, ppxlcFwdHalfPelRef + m_iFrameWidthY,
  1194. m_vopmd.iSearchRangeForward);
  1195. pmvForward[4].computeTrueMV();
  1196. if (iSADFld[2] < iSADFld[3]) {
  1197. pmbmd->m_bForwardBottom = 0;
  1198. iSADFldMB[0] += iSADFld[2];
  1199. } else {
  1200. pmbmd->m_bForwardBottom = 1;
  1201. iSADFldMB[0] += iSADFld[3];
  1202. }
  1205. // Choose best bak top field predictor
  1206. iSADFld[4] = blkmatch16x8 (pmvBackward+1, x, y, 0,
  1207. ppxlcRef1MBY, ppxlcBakHalfPelRef, m_vopmd.iSearchRangeBackward);
  1208. pmvBackward[1].computeTrueMV();
  1209. iSADFld[5] = blkmatch16x8 (pmvBackward+2, x, y, 0,
  1210. ppxlcRef1MBY + m_iFrameWidthY, ppxlcBakHalfPelRef + m_iFrameWidthY,
  1211. m_vopmd.iSearchRangeBackward);
  1212. pmvBackward[2].computeTrueMV();
  1213. if (iSADFld[4] <= iSADFld[5]) {
  1214. pmbmd->m_bBackwardTop = 0;
  1215. iSADFldMB[1] = iSADFld[4];
  1216. } else {
  1217. pmbmd->m_bBackwardTop = 1;
  1218. iSADFldMB[1] = iSADFld[5];
  1219. }
  1221. // Choose best bak bottom field predictor
  1222. iSADFld[6] = blkmatch16x8 (pmvBackward+3, x, y, MB_SIZE,
  1223. ppxlcRef1MBY, ppxlcBakHalfPelRef, m_vopmd.iSearchRangeBackward);
  1224. pmvBackward[3].computeTrueMV();
  1225. iSADFld[7] = blkmatch16x8 (pmvBackward+4, x, y, MB_SIZE,
  1226. ppxlcRef1MBY + m_iFrameWidthY, ppxlcBakHalfPelRef + m_iFrameWidthY,
  1227. m_vopmd.iSearchRangeBackward);
  1228. pmvBackward[4].computeTrueMV();
  1229. if (iSADFld[6] < iSADFld[7]) {
  1230. pmbmd->m_bBackwardBottom = 0;
  1231. iSADFldMB[1] += iSADFld[6];
  1232. } else {
  1233. pmbmd->m_bBackwardBottom = 1;
  1234. iSADFldMB[1] += iSADFld[7];
  1235. }
  1237. // Choose best of forward & backward field prediction
  1238. if (iSADFldMB[0] <= iSADFldMB[1]) {
  1239. iFieldSAD = iSADFldMB[0];
  1240. mbtype = FORWARD;
  1241. } else {
  1242. iFieldSAD = iSADFldMB[1];
  1243. mbtype = BACKWARD;
  1244. }
  1245. iFieldSAD += BbiasAgainstField;
  1246. iSADFldMB[2] = interpolateAndDiffYField(
  1247. pmvForward  + 1 + (int)pmbmd->m_bForwardTop,
  1248. pmvForward  + 3 + (int)pmbmd->m_bForwardBottom,
  1249. pmvBackward + 1 + (int)pmbmd->m_bBackwardTop,
  1250. pmvBackward + 3 + (int)pmbmd->m_bBackwardBottom,
  1251. x, y, pmbmd);
  1252. if ((iSADFldMB[2] + BbiasAgainstFieldAve) < iFieldSAD) {
  1253. iFieldSAD = iSADFldMB[2] + BbiasAgainstFieldAve;
  1254. mbtype = INTERPOLATE;
  1255. }
  1257. if(m_bCodedFutureRef==FALSE) // FORCE FORWARD
  1258. {
  1259. iFieldSAD = iSADFldMB[0];
  1260. mbtype = FORWARD;
  1261. }
  1263. // Field versus Frame prediction
  1264. if (iFieldSAD < iSAD) {
  1265. pmbmd->m_bFieldMV = TRUE;
  1266. pmbmd->m_mbType = mbtype;
  1267. iSAD = iFieldSAD;
  1268. iSADnobias = iFieldSAD - ((mbtype == INTERPOLATE) ? BbiasAgainstFieldAve : BbiasAgainstField);
  1269. }
  1270. #ifdef __TRACE_AND_STATS_
  1271. m_pbitstrmOut->trace (iSADFld,   8, "SADFld");
  1272. m_pbitstrmOut->trace (iSADFldMB, 3, "SADFldMB");
  1273. #endif // __TRACE_AND_STATS_
  1275. }
  1277. #if 1 // #if 0 to temporarily disable direct mode (debug only)
  1278. // Check direct mode
  1279. Int iSADDirect = 0;
  1280. if (bColocatedMBExist && m_volmd.fAUsage == RECTANGLE) {
  1281. iSADDirect= (pmbmdRef->m_bFieldMV) ?
  1282. directSADField(x, y, pmbmd, pmbmdRef, pmvRef, ppxlcRef0MBY, ppxlcRef1MBY) :
  1283. directSAD     (x, y, pmbmd, pmbmdRef, pmvRef);
  1284. if ((iSADDirect - BbiasFavorDirect) < iSAD) {
  1285. pmbmd->m_mbType = DIRECT;
  1286. pmbmd->m_bFieldMV = pmbmdRef->m_bFieldMV;
  1287. iSADnobias = iSADDirect;
  1288. }
  1289. }
  1290. #endif
  1291. #ifdef __TRACE_AND_STATS_
  1292. static char *cDirectType[] = { "FrmDirectSAD", "FldDirectSAD" };
  1293. static char *cWinner[] = { "FrmDirectn", "FrmAven", "FrmBakn", "FrmFwdn", "FldDirectn", "FldAven", "FldBakn", "FldFwdn" };
  1294. if(bColocatedMBExist)
  1295. m_pbitstrmOut->trace (iSADDirect, cDirectType[pmbmdRef->m_bFieldMV]);
  1296. m_pbitstrmOut->trace (cWinner[(Int)pmbmd->m_mbType + 4*pmbmd->m_bFieldMV]);
  1297. #if 0 // Put all MV candidates in trace file
  1298. Int iMV[10];
  1299. iMV[0] = pmvForward[0].m_vctTrueHalfPel.x; iMV[1] = pmvForward[0].m_vctTrueHalfPel.y;
  1300. iMV[2] = pmvForward[1].m_vctTrueHalfPel.x; iMV[3] = pmvForward[1].m_vctTrueHalfPel.y;
  1301. iMV[4] = pmvForward[2].m_vctTrueHalfPel.x; iMV[5] = pmvForward[2].m_vctTrueHalfPel.y;
  1302. iMV[6] = pmvForward[3].m_vctTrueHalfPel.x; iMV[7] = pmvForward[3].m_vctTrueHalfPel.y;
  1303. iMV[8] = pmvForward[4].m_vctTrueHalfPel.x; iMV[9] = pmvForward[4].m_vctTrueHalfPel.y;
  1304. m_pbitstrmOut->trace (iMV, 10, "FwdMV");
  1305. iMV[0] = pmvBackward[0].m_vctTrueHalfPel.x; iMV[1] = pmvBackward[0].m_vctTrueHalfPel.y;
  1306. iMV[2] = pmvBackward[1].m_vctTrueHalfPel.x; iMV[3] = pmvBackward[1].m_vctTrueHalfPel.y;
  1307. iMV[4] = pmvBackward[2].m_vctTrueHalfPel.x; iMV[5] = pmvBackward[2].m_vctTrueHalfPel.y;
  1308. iMV[6] = pmvBackward[3].m_vctTrueHalfPel.x; iMV[7] = pmvBackward[3].m_vctTrueHalfPel.y;
  1309. iMV[8] = pmvBackward[4].m_vctTrueHalfPel.x; iMV[9] = pmvBackward[4].m_vctTrueHalfPel.y;
  1310. m_pbitstrmOut->trace (iMV, 10, "BakMV");
  1311. #endif
  1312. #endif // __TRACE_AND_STATS_
  1314. pmbmd->m_bhas4MVForward  = FALSE;
  1315. pmbmd->m_bhas4MVBackward = FALSE;
  1316. return iSADnobias;
  1317. }
  1319. //end of INTERLACED
  1320. //INTERLACED
  1321. // new changes
  1322. Int CVideoObjectEncoder::motionEstMB_BVOP_InterlacedWithShape (
  1323. CoordI x, CoordI y, 
  1324. CMotionVector* pmvForward, CMotionVector* pmvBackward,
  1325. CMBMode* pmbmd,
  1326. const CMBMode* pmbmdRef, const CMotionVector* pmvRef,
  1327. const PixelC* ppxlcRef0MBY, const PixelC* ppxlcRef1MBY,
  1328. Bool bColocatedMBExist
  1329. )
  1330. {
  1331. assert (pmbmd->m_rgTranspStatus [0] == PARTIAL);
  1333. Int iSAD, iSADnobias, iFieldSAD, iSADFrmMB[3];
  1334. MBType mbtype;
  1336. iSADFrmMB[0] = blkmatch16WithShape(pmvForward, x, y,x,y, sad16x16At0WithShape (ppxlcRef0MBY,pmbmd),
  1337. ppxlcRef0MBY, m_puciRefQZoom0, pmbmd, m_vopmd.iSearchRangeForward,0);
  1338. pmvForward->computeTrueMV ();
  1339. iSADFrmMB[1] = blkmatch16WithShape(pmvBackward, x, y,x,y, sad16x16At0WithShape (ppxlcRef1MBY,pmbmd),
  1340. ppxlcRef1MBY, m_puciRefQZoom1, pmbmd, m_vopmd.iSearchRangeBackward,1);
  1341. pmvBackward->computeTrueMV ();
  1342. iSADFrmMB[2] = interpolateAndDiffY_WithShape(pmvForward, pmvBackward, x, y
  1343. , &m_rctRefVOPY0, &m_rctRefVOPY1);
  1345. #ifdef __TRACE_AND_STATS_
  1346. m_pbitstrmOut->trace (iSADFrmMB, 3, "SADFrmMB");
  1347. #endif // __TRACE_AND_STATS_
  1349. // Choose best 16x16 mode
  1350. pmbmd->m_bFieldMV = FALSE;
  1351. if (iSADFrmMB[0] < iSADFrmMB[1]) {
  1352. iSAD = iSADFrmMB[0];
  1353. pmbmd->m_mbType = FORWARD;
  1354. } else {
  1355. iSAD = iSADFrmMB[1];
  1356. pmbmd->m_mbType = BACKWARD;
  1357. }
  1358. iSADnobias = iSAD;
  1359. if ((iSADFrmMB[2] + BbiasAgainstFrameAve) < iSAD) {
  1360. iSAD = iSADFrmMB[2] + BbiasAgainstFrameAve;
  1361. iSADnobias = iSADFrmMB[2];
  1362. pmbmd->m_mbType = INTERPOLATE;
  1363. }
  1365. if(m_bCodedFutureRef==FALSE) // force forward
  1366. {
  1367. iSAD = iSADFrmMB[0];
  1368. pmbmd->m_mbType = FORWARD;
  1369. }
  1371. if (m_vopmd.bInterlace) {
  1372. const PixelC *ppxlcFwdHalfPelRef = m_pvopcRefQ0->pixelsY()
  1373. +EXPANDY_REF_FRAME * m_iFrameWidthY + EXPANDY_REF_FRAME+ x + y * m_iFrameWidthY; // 1.31.99 changes
  1374. const PixelC *ppxlcBakHalfPelRef = m_pvopcRefQ1->pixelsY()
  1375. +EXPANDY_REF_FRAME * m_iFrameWidthY + EXPANDY_REF_FRAME+ x + y * m_iFrameWidthY; // 1.31.99 changes
  1376. Int iSADFldMB[3], iSADFld[8];
  1378. // Choose best fwd top field predictor
  1379. iSADFld[0] = blkmatch16x8WithShape (pmvForward+1, x, y, 0,
  1380. ppxlcRef0MBY, ppxlcFwdHalfPelRef, m_vopmd.iSearchRangeForward,0);
  1381. pmvForward[1].computeTrueMV();
  1382. iSADFld[1] = blkmatch16x8WithShape (pmvForward+2, x, y, 0,
  1383. ppxlcRef0MBY + m_iFrameWidthY, ppxlcFwdHalfPelRef + m_iFrameWidthY,
  1384. m_vopmd.iSearchRangeForward,0);
  1385. pmvForward[2].computeTrueMV();
  1386. if (iSADFld[0] <= iSADFld[1]) {
  1387. pmbmd->m_bForwardTop = 0;
  1388. iSADFldMB[0] = iSADFld[0];
  1389. } else {
  1390. pmbmd->m_bForwardTop = 1;
  1391. iSADFldMB[0] = iSADFld[1];
  1392. }
  1394. // Choose best fwd botton field predictor
  1395. iSADFld[2] = blkmatch16x8WithShape (pmvForward+3, x, y, MB_SIZE,
  1396. ppxlcRef0MBY, ppxlcFwdHalfPelRef, m_vopmd.iSearchRangeForward,0);
  1397. pmvForward[3].computeTrueMV();
  1398. iSADFld[3] = blkmatch16x8WithShape (pmvForward+4, x, y, MB_SIZE,
  1399. ppxlcRef0MBY + m_iFrameWidthY, ppxlcFwdHalfPelRef + m_iFrameWidthY,
  1400. m_vopmd.iSearchRangeForward,0);
  1401. pmvForward[4].computeTrueMV();
  1402. if (iSADFld[2] < iSADFld[3]) {
  1403. pmbmd->m_bForwardBottom = 0;
  1404. iSADFldMB[0] += iSADFld[2];
  1405. } else {
  1406. pmbmd->m_bForwardBottom = 1;
  1407. iSADFldMB[0] += iSADFld[3];
  1408. }
  1411. // Choose best bak top field predictor
  1412. iSADFld[4] = blkmatch16x8WithShape (pmvBackward+1, x, y, 0,
  1413. ppxlcRef1MBY, ppxlcBakHalfPelRef, m_vopmd.iSearchRangeBackward,1);
  1414. pmvBackward[1].computeTrueMV();
  1415. iSADFld[5] = blkmatch16x8WithShape (pmvBackward+2, x, y, 0,
  1416. ppxlcRef1MBY + m_iFrameWidthY, ppxlcBakHalfPelRef + m_iFrameWidthY,
  1417. m_vopmd.iSearchRangeBackward,1);
  1418. pmvBackward[2].computeTrueMV();
  1419. if (iSADFld[4] <= iSADFld[5]) {
  1420. pmbmd->m_bBackwardTop = 0;
  1421. iSADFldMB[1] = iSADFld[4];
  1422. } else {
  1423. pmbmd->m_bBackwardTop = 1;
  1424. iSADFldMB[1] = iSADFld[5];
  1425. }
  1427. // Choose best bak bottom field predictor
  1428. iSADFld[6] = blkmatch16x8WithShape (pmvBackward+3, x, y, MB_SIZE,
  1429. ppxlcRef1MBY, ppxlcBakHalfPelRef, m_vopmd.iSearchRangeBackward,1);
  1430. pmvBackward[3].computeTrueMV();
  1431. iSADFld[7] = blkmatch16x8WithShape (pmvBackward+4, x, y, MB_SIZE,
  1432. ppxlcRef1MBY + m_iFrameWidthY, ppxlcBakHalfPelRef + m_iFrameWidthY,
  1433. m_vopmd.iSearchRangeBackward,1);
  1434. pmvBackward[4].computeTrueMV();
  1435. if (iSADFld[6] < iSADFld[7]) {
  1436. pmbmd->m_bBackwardBottom = 0;
  1437. iSADFldMB[1] += iSADFld[6];
  1438. } else {
  1439. pmbmd->m_bBackwardBottom = 1;
  1440. iSADFldMB[1] += iSADFld[7];
  1441. }
  1443. // Choose best of forward & backward field prediction
  1444. if (iSADFldMB[0] <= iSADFldMB[1]) {
  1445. iFieldSAD = iSADFldMB[0];
  1446. mbtype = FORWARD;
  1447. } else {
  1448. iFieldSAD = iSADFldMB[1];
  1449. mbtype = BACKWARD;
  1450. }
  1451. iFieldSAD += BbiasAgainstField;
  1452. iSADFldMB[2] = interpolateAndDiffYField(
  1453. pmvForward  + 1 + (int)pmbmd->m_bForwardTop,
  1454. pmvForward  + 3 + (int)pmbmd->m_bForwardBottom,
  1455. pmvBackward + 1 + (int)pmbmd->m_bBackwardTop,
  1456. pmvBackward + 3 + (int)pmbmd->m_bBackwardBottom,
  1457. x, y, pmbmd);
  1458. if ((iSADFldMB[2] + BbiasAgainstFieldAve) < iFieldSAD) {
  1459. iFieldSAD = iSADFldMB[2] + BbiasAgainstFieldAve;
  1460. mbtype = INTERPOLATE;
  1461. }
  1463. if(m_bCodedFutureRef==FALSE) // force forward
  1464. {
  1465. iFieldSAD = iSADFldMB[0];
  1466. mbtype = FORWARD;
  1467. }
  1469. // Field versus Frame prediction
  1470. if (iFieldSAD < iSAD) {
  1471. pmbmd->m_bFieldMV = TRUE;
  1472. pmbmd->m_mbType = mbtype;
  1473. iSAD = iFieldSAD;
  1474. iSADnobias = iFieldSAD - ((mbtype == INTERPOLATE) ? BbiasAgainstFieldAve : BbiasAgainstField);
  1475. }
  1476. #ifdef __TRACE_AND_STATS_
  1477. m_pbitstrmOut->trace (iSADFld,   8, "SADFld");
  1478. m_pbitstrmOut->trace (iSADFldMB, 3, "SADFldMB");
  1479. #endif // __TRACE_AND_STATS_
  1481. }
  1483. #if 1 // #if 0 to temporarily disable direct mode (debug only)
  1484. // Check direct mode
  1485. // new changes
  1486. /* Int iSADDirect;
  1487. if (bColocatedMBExist) {
  1488. iSADDirect = (pmbmdRef->m_bFieldMV) ?
  1489. directSADField(x, y, pmbmd, pmbmdRef, pmvRef, ppxlcRef0MBY, ppxlcRef1MBY) :
  1490. directSAD     (x, y, pmbmd, pmbmdRef, pmvRef);
  1491. if ((iSADDirect - BbiasFavorDirect) < iSAD) {
  1492. pmbmd->m_mbType = DIRECT;
  1493. pmbmd->m_bFieldMV = pmbmdRef->m_bFieldMV;
  1494. iSADnobias = iSADDirect;
  1495. }
  1496. }  */
  1497. #endif
  1498. #ifdef __TRACE_AND_STATS_
  1499. /* static char *cDirectType[] = { "FrmDirectSAD", "FldDirectSAD" };
  1500. static char *cWinner[] = { "FrmDirectn", "FrmAven", "FrmBakn", "FrmFwdn", "FldDirectn", "FldAven", "FldBakn", "FldFwdn" };
  1501. if (bColocatedMBExist)
  1502. m_pbitstrmOut->trace (iSADDirect, cDirectType[pmbmdRef->m_bFieldMV]);
  1503. m_pbitstrmOut->trace (cWinner[(Int)pmbmd->m_mbType + 4*pmbmd->m_bFieldMV]); */
  1504. #if 0 // Put all MV candidates in trace file
  1505. Int iMV[10];
  1506. iMV[0] = pmvForward[0].m_vctTrueHalfPel.x; iMV[1] = pmvForward[0].m_vctTrueHalfPel.y;
  1507. iMV[2] = pmvForward[1].m_vctTrueHalfPel.x; iMV[3] = pmvForward[1].m_vctTrueHalfPel.y;
  1508. iMV[4] = pmvForward[2].m_vctTrueHalfPel.x; iMV[5] = pmvForward[2].m_vctTrueHalfPel.y;
  1509. iMV[6] = pmvForward[3].m_vctTrueHalfPel.x; iMV[7] = pmvForward[3].m_vctTrueHalfPel.y;
  1510. iMV[8] = pmvForward[4].m_vctTrueHalfPel.x; iMV[9] = pmvForward[4].m_vctTrueHalfPel.y;
  1511. m_pbitstrmOut->trace (iMV, 10, "FwdMV");
  1512. iMV[0] = pmvBackward[0].m_vctTrueHalfPel.x; iMV[1] = pmvBackward[0].m_vctTrueHalfPel.y;
  1513. iMV[2] = pmvBackward[1].m_vctTrueHalfPel.x; iMV[3] = pmvBackward[1].m_vctTrueHalfPel.y;
  1514. iMV[4] = pmvBackward[2].m_vctTrueHalfPel.x; iMV[5] = pmvBackward[2].m_vctTrueHalfPel.y;
  1515. iMV[6] = pmvBackward[3].m_vctTrueHalfPel.x; iMV[7] = pmvBackward[3].m_vctTrueHalfPel.y;
  1516. iMV[8] = pmvBackward[4].m_vctTrueHalfPel.x; iMV[9] = pmvBackward[4].m_vctTrueHalfPel.y;
  1517. m_pbitstrmOut->trace (iMV, 10, "BakMV");
  1518. #endif
  1519. #endif // __TRACE_AND_STATS_
  1521. pmbmd->m_bhas4MVForward  = FALSE;
  1522. pmbmd->m_bhas4MVBackward = FALSE;
  1523. return iSADnobias;
  1524. }
  1526. //end of new changes
  1527. //end of INTERLACED
  1529. Int CVideoObjectEncoder::blkmatch16 (
  1530. CMotionVector* pmv, 
  1531. CoordI iXRef, CoordI iYRef,
  1532. CoordI iXCurr, CoordI iYCurr,
  1533. Int iMinSAD,
  1534. const PixelC* ppxlcRefMBY,
  1535. const CU8Image* puciRefQZoomY,
  1536. Int iSearchRange
  1537. )
  1538. {
  1539. Int mbDiff; // start with big
  1540. Int iXDest = iXRef, iYDest = iYRef;
  1541. CoordI x = iXRef, y = iYRef, ix, iy;
  1542. Int uiPosInLoop, iLoop;
  1544. if (m_iMVFileUsage != 1) {
  1545.     // Spiral Search for the rest
  1546.     for (iLoop = 1; iLoop <= iSearchRange; iLoop++) {
  1547.     x++;
  1548.     y++;
  1549.     ppxlcRefMBY += m_iFrameWidthY + 1;
  1550.     for (uiPosInLoop = 0; uiPosInLoop < (iLoop << 3); uiPosInLoop++) { // inside each spiral loop 
  1551. if (
  1552.     x >= m_rctRefVOPY0.left && y >= m_rctRefVOPY0.top && 
  1553.     x <= m_rctRefVOPY0.right - MB_SIZE && y <= m_rctRefVOPY0.bottom - MB_SIZE
  1554.     ) {
  1555.     const PixelC* ppxlcTmpC = m_ppxlcCurrMBY;
  1556.     const PixelC* ppxlcRefMB = ppxlcRefMBY;
  1557.     mbDiff = 0;
  1558.     for (iy = 0; iy < MB_SIZE; iy++) {
  1559.     for (ix = 0; ix < MB_SIZE; ix++)
  1560.     mbDiff += abs (ppxlcTmpC [ix] - ppxlcRefMB [ix]);
  1561.     if (mbDiff >= iMinSAD)
  1562.     goto NEXT_POSITION; // skip the current position
  1563.     ppxlcRefMB += m_iFrameWidthY;
  1564.     ppxlcTmpC += MB_SIZE;
  1565.     }
  1566.     iMinSAD = mbDiff;
  1567.     iXDest = x;
  1568.     iYDest = y;
  1569.     }
  1570. NEXT_POSITION:
  1571.     if (uiPosInLoop < (iLoop << 1)) {
  1572.     ppxlcRefMBY--;
  1573.     x--;
  1574.     }
  1575.     else if (uiPosInLoop < (iLoop << 2)) {
  1576.     ppxlcRefMBY -= m_iFrameWidthY;
  1577.     y--;
  1578.     }
  1579.     else if (uiPosInLoop < (iLoop * 6)) {
  1580.     ppxlcRefMBY++;   
  1581.     x++;
  1582.     }
  1583.     else {
  1584.     ppxlcRefMBY += m_iFrameWidthY;
  1585.     y++;
  1586.     }
  1587.     }
  1588.     }
  1589.     *pmv = CMotionVector (iXDest - iXCurr, iYDest - iYCurr);
  1590. } else {
  1591. iXDest = iXRef + pmv->iMVX;
  1592. iYDest = iYRef + pmv->iMVY;
  1593. }
  1594. /* NBIT: change to a bigger number
  1595. iMinSAD = 256*256; // Reset iMinSAD because reference VOP changed from original to reconstructed (Bob Eifrig)
  1596. */
  1597. iMinSAD = 4096*256;
  1598. /* NBIT: change
  1599. Int iFavorZero = pmv->isZero() ? -FAVORZERO : 0;
  1600. */
  1601. Int iFavorZero = pmv->isZero() ? FAVORZERO : 0;
  1602. Int nBits = m_volmd.nBits;
  1603. if (nBits > 8) {
  1604. iFavorZero <<= (nBits-8);
  1605. } else if (nBits < 8) {
  1606. iFavorZero >>= (8-nBits);
  1607. }
  1608. iFavorZero = -iFavorZero;
  1610. // half pel search
  1611. I8 destHalfX = 0, destHalfY = 0;
  1612. Int lowX = (iXDest == m_rctRefVOPY0.left) ? 0 : -1;
  1613. Int lowY = (iYDest == m_rctRefVOPY0.top) ? 0 : -1;
  1614. Int highX = (iXDest == m_rctRefVOPY0.right - MB_SIZE + 1) ? 0 : 1;
  1615. Int highY = (iYDest == m_rctRefVOPY0.bottom - MB_SIZE + 1) ? 0 : 1;
  1616. const PixelC* ppxlcRefZoom = puciRefQZoomY->pixels ((iXDest << 1) + lowX, (iYDest << 1) + lowY);
  1617. for (Int incY = lowY; incY <= highY; incY++) {
  1618. for (Int incX = lowX; incX <= highX; incX++) {
  1619. const PixelC* ppxlcRefZoomMB = ppxlcRefZoom;
  1620. const PixelC* ppxlcTmpC = m_ppxlcCurrMBY;
  1621. mbDiff = (incX || incY) ? 0 : iFavorZero;
  1622. for (iy = 0; iy < MB_SIZE; iy++) {
  1623. for (ix = 0; ix < MB_SIZE; ix++)
  1624. mbDiff += abs (ppxlcTmpC [ix] - ppxlcRefZoomMB [2 * ix]);
  1625. if (mbDiff > iMinSAD) // Try to find shortest MV in case of equal SADs
  1626. goto NEXT_HALF_POSITION;
  1627. ppxlcRefZoomMB += m_iFrameWidthZoomY * 2;
  1628. ppxlcTmpC += MB_SIZE;
  1629. }
  1630. if ((iMinSAD > mbDiff) ||
  1631. ((abs(pmv->m_vctTrueHalfPel.x + destHalfX) + abs(pmv->m_vctTrueHalfPel.y + destHalfY)) >
  1632.  (abs(pmv->m_vctTrueHalfPel.x + incX)      + abs(pmv->m_vctTrueHalfPel.y + incY)))) {
  1633. iMinSAD = mbDiff;
  1634. destHalfX = incX;
  1635. destHalfY = incY;
  1636. }
  1637. NEXT_HALF_POSITION:
  1638. ppxlcRefZoom++;
  1639. }
  1640. ppxlcRefZoom += m_iFrameWidthZoomY - (highX - lowX + 1);
  1641. }
  1642. pmv -> iHalfX = destHalfX;
  1643. pmv -> iHalfY = destHalfY;
  1644. return iMinSAD;
  1645. }
  1647. Int CVideoObjectEncoder::blkmatch16WithShape (
  1648. CMotionVector* pmv, 
  1649. CoordI iXRef, CoordI iYRef,
  1650. CoordI iXCurr, CoordI iYCurr,
  1651. Int iMinSAD,
  1652. const PixelC* ppxlcRefMBY,
  1653. const CU8Image* puciRefQZoom,
  1654.     const CMBMode *pmbmd,
  1655. Int iSearchRange,
  1656. Int iDirection
  1657. )
  1658. {
  1659. Int mbDiff; // start with big
  1660. Int iXDest = iXRef, iYDest = iYRef;
  1661. CoordI x = iXRef, y = iYRef, ix, iy;
  1662. Int uiPosInLoop, iLoop;
  1664. CRct CTmp=(iDirection) ? m_rctRefVOPY1:m_rctRefVOPY0;
  1666. // Spiral Search for the rest
  1667. if (m_iMVFileUsage != 1) {
  1668.     for (iLoop = 1; iLoop <= iSearchRange; iLoop++) {
  1669.     x++;
  1670.     y++;
  1671.     ppxlcRefMBY += m_iFrameWidthY + 1;
  1672.     for (uiPosInLoop = 0; uiPosInLoop < (iLoop << 3); uiPosInLoop++) { // inside each spiral loop 
  1673. if (
  1674.     x >= CTmp.left && y >= CTmp.top && 
  1675.     x <= CTmp.right - MB_SIZE && y <= CTmp.bottom - MB_SIZE
  1676.     ) {
  1677.     const PixelC* ppxlcTmpC = m_ppxlcCurrMBY;
  1678.     const PixelC* ppxlcTmpCBY = m_ppxlcCurrMBBY;
  1679.     const PixelC* ppxlcRefMB = ppxlcRefMBY;
  1680.     mbDiff = 0;
  1681.     for (iy = 0; iy < MB_SIZE; iy++) {
  1682.     for (ix = 0; ix < MB_SIZE; ix++) {
  1683.     if (ppxlcTmpCBY [ix] != transpValue)
  1684.     mbDiff += abs (ppxlcTmpC [ix] - ppxlcRefMB [ix]);
  1685.     }
  1686.     if (mbDiff >= iMinSAD)
  1687.     goto NEXT_POSITION; // skip the current position
  1688.     ppxlcRefMB += m_iFrameWidthY;
  1689.     ppxlcTmpC += MB_SIZE;
  1690.     ppxlcTmpCBY += MB_SIZE;
  1691.     }
  1692.     iMinSAD = mbDiff;
  1693.     iXDest = x;
  1694.     iYDest = y;
  1695.     }
  1696. NEXT_POSITION:
  1697.     if (uiPosInLoop < (iLoop << 1)) {
  1698.     ppxlcRefMBY--;
  1699.     x--;
  1700.     }
  1701.     else if (uiPosInLoop < (iLoop << 2)) {
  1702.     ppxlcRefMBY -= m_iFrameWidthY;
  1703.     y--;
  1704.     }
  1705.     else if (uiPosInLoop < (iLoop * 6)) {
  1706.     ppxlcRefMBY++;   
  1707.     x++;
  1708.     }
  1709.     else {
  1710.     ppxlcRefMBY += m_iFrameWidthY;
  1711.     y++;
  1712.     }
  1713.     }
  1714.     }
  1715.     *pmv = CMotionVector (iXDest - iXCurr, iYDest - iYCurr);
  1716. } 
  1717. else {
  1718. iXDest = iXRef + pmv->iMVX;
  1719. iYDest = iYRef + pmv->iMVY;
  1720. }
  1721. // check for case when zero MV due to MB outside the extended BB.
  1722. if(iXDest==iXCurr && iYDest==iYCurr
  1723. && (iXDest < CTmp.left || iYDest < CTmp.top // 12.22.98 changes
  1724. || iXDest > CTmp.right - MB_SIZE // 12.22.98 changes
  1725. || iYDest > CTmp.bottom - MB_SIZE)) // 12.22.98 changes
  1726. {
  1727. pmv -> iHalfX = 0;
  1728. pmv -> iHalfY = 0;
  1729. return iMinSAD;  
  1730. }
  1732. /* NBIT: change to a bigger number
  1733. iMinSAD = 256*256; // Reset iMinSAD because reference VOP may change from original to reconstructed (Bob Eifrig)
  1734. */
  1735. iMinSAD = 4096*256;
  1736. Int iFavorZero = pmv->isZero() ? -(pmbmd -> m_rgNumNonTranspPixels [0] >> 1) - 1 : 0;
  1737. // half pel search
  1738. I8 destHalfX = 0, destHalfY = 0;
  1739. Int lowY, highY, lowX, highX;
  1740. lowX = (iXDest == CTmp.left) ? 0 : -1; // 12.22.98 changes
  1741. lowY = (iYDest == CTmp.top) ? 0 : -1; // 12.22.98 changes
  1742. highX = (iXDest == CTmp.right - MB_SIZE + 1) ? 0 : 1; // 12.22.98 changes
  1743. highY = (iYDest == CTmp.bottom - MB_SIZE + 1) ? 0 : 1; // 12.22.98 changes
  1744. const PixelC* ppxlcRefZoom = puciRefQZoom->pixels ((iXDest << 1) + lowX, (iYDest << 1) + lowY);
  1745. for (Int incY = lowY; incY <= highY; incY++) {
  1746. for (Int incX = lowX; incX <= highX; incX++) {
  1747. const PixelC* ppxlcRefZoomMB = ppxlcRefZoom;
  1748. const PixelC* ppxlcTmpC = m_ppxlcCurrMBY;
  1749. const PixelC* ppxlcTmpCBY = m_ppxlcCurrMBBY;
  1750. mbDiff = (incX || incY) ? 0 : iFavorZero;
  1751. for (iy = 0; iy < MB_SIZE; iy++) {
  1752. for (ix = 0; ix < MB_SIZE; ix++) {
  1753. if (ppxlcTmpCBY [ix] != transpValue) 
  1754. mbDiff += abs (ppxlcTmpC [ix] - ppxlcRefZoomMB [2 * ix]);
  1755. }
  1756. if (mbDiff > iMinSAD) // Try to find shortest MV in case of equal SADs
  1757. goto NEXT_HALF_POSITION;
  1758. ppxlcRefZoomMB += m_iFrameWidthZoomY * 2;
  1759. ppxlcTmpC += MB_SIZE;
  1760. ppxlcTmpCBY += MB_SIZE;
  1761. }
  1762. if ((iMinSAD > mbDiff) ||
  1763. ((abs(pmv->m_vctTrueHalfPel.x + destHalfX) + abs(pmv->m_vctTrueHalfPel.y + destHalfY)) >
  1764.  (abs(pmv->m_vctTrueHalfPel.x + incX)      + abs(pmv->m_vctTrueHalfPel.y + incY)))) {
  1765. iMinSAD = mbDiff;
  1766. destHalfX = incX;
  1767. destHalfY = incY;
  1768. }
  1769. NEXT_HALF_POSITION:
  1770. ppxlcRefZoom++;
  1771. }
  1772. ppxlcRefZoom += m_iFrameWidthZoomY - (highX - lowX + 1);
  1773. }
  1774. pmv -> iHalfX = destHalfX;
  1775. pmv -> iHalfY = destHalfY;
  1776. return iMinSAD;
  1777. }
  1779. Int CVideoObjectEncoder::blockmatch8 (
  1780. const PixelC* ppxlcCodedBlkY, 
  1781. CMotionVector* pmv8, 
  1782. CoordI iXBlk, CoordI iYBlk,
  1783. const CMotionVector* pmvPred,
  1784. Int iSearchRange
  1785. )
  1786. {
  1787. Int mbDiff,iMinSAD; // start with big
  1788. CoordI ix,iy,iXDest,iYDest;
  1790. if (m_iMVFileUsage != 1) {
  1791.     CoordI x = iXBlk + pmvPred->iMVX, y = iYBlk + pmvPred->iMVY; // , ix, iy;
  1792.     CoordI left = -1 * min (abs (pmvPred->iMVX + iSearchRange), ADD_DISP);
  1793.     CoordI top = -1 * min (abs (pmvPred->iMVY + iSearchRange), ADD_DISP);
  1794.     CoordI right = min (abs (pmvPred->iMVX - iSearchRange), ADD_DISP);
  1795.     CoordI bottom = min (abs (pmvPred->iMVY - iSearchRange), ADD_DISP);
  1797.     //CoordI iOrigX = x, iOrigY = y;
  1798.     // CoordI 
  1799.     iXDest = x, iYDest = y;
  1800.     Int uiPosInLoop, iLoop;
  1801.     const PixelC* ppxlcRefBlk = (m_volmd.bOriginalForME ? m_pvopcRefOrig0 : m_pvopcRefQ0)->getPlane (Y_PLANE)->pixels (x, y);
  1802.     iMinSAD = sad8x8At0 (ppxlcCodedBlkY, ppxlcRefBlk);
  1803.     // Spiral Search for the rest
  1804.     Int iix = 0, iiy = 0;
  1805.     for (iLoop = 1; iLoop <= ADD_DISP; iLoop++) {
  1806.     x++;
  1807.     y++;
  1808.     iix++; iiy++;
  1809.     ppxlcRefBlk += m_iFrameWidthY + 1;
  1810.     for (uiPosInLoop = 0; uiPosInLoop < (iLoop << 3); uiPosInLoop++) { // inside each spiral loop 
  1811. if (
  1812.     iix >= left && iix <= right &&
  1813.     iiy >= top && iiy <= bottom &&
  1814.     x >= m_rctRefVOPY0.left && y >= m_rctRefVOPY0.top && 
  1815.     x <= m_rctRefVOPY0.right - MB_SIZE && y <= m_rctRefVOPY0.bottom - MB_SIZE
  1816.     ) {
  1817.     const PixelC* ppxlcTmpC = ppxlcCodedBlkY;
  1818.     const PixelC* ppxlcRefMB = ppxlcRefBlk;
  1819.     mbDiff = 0;
  1820.     for (iy = 0; iy < BLOCK_SIZE; iy++) {
  1821.     for (ix = 0; ix < BLOCK_SIZE; ix++)
  1822.     mbDiff += abs (ppxlcTmpC [ix] - ppxlcRefMB [ix]);
  1823.     if (mbDiff > iMinSAD)
  1824.     goto NEXT_POSITION; // skip the current position
  1825.     ppxlcRefMB += m_iFrameWidthY;
  1826.     ppxlcTmpC += MB_SIZE;
  1827.     }
  1828.     iMinSAD = mbDiff;
  1829.     iXDest = x;
  1830.     iYDest = y;
  1831.     }
  1832. NEXT_POSITION:
  1833.     if (uiPosInLoop < (iLoop << 1)) {
  1834.     ppxlcRefBlk--;
  1835.     x--;
  1836.     iix--;
  1837.     }
  1838.     else if (uiPosInLoop < (iLoop << 2)) {
  1839.     ppxlcRefBlk -= m_iFrameWidthY;
  1840.     y--;
  1841.     iiy--;
  1842.     }
  1843.     else if (uiPosInLoop < (iLoop * 6)) {
  1844.     ppxlcRefBlk++;   
  1845.     x++;
  1846.     iix++;
  1847.     }
  1848.     else {
  1849.     ppxlcRefBlk += m_iFrameWidthY;
  1850.     y++;
  1851.     iiy++;
  1852.     }
  1853.     }
  1854.     }
  1855.     *pmv8 = CMotionVector (iXDest - iXBlk, iYDest - iYBlk);
  1856. } 
  1857. else {
  1858. iXDest = iXBlk + pmv8->iMVX;
  1859. iYDest = iYBlk + pmv8->iMVY;
  1860. }
  1861. /* NBIT: change to a bigger number
  1862. iMinSAD = 256*256; // Reset iMinSAD because reference VOP changed from original to reconstructed (Bob Eifrig)
  1863. */
  1864. iMinSAD = 4096*256;
  1866. // half pel search
  1867. I8 destHalfX = 0, destHalfY = 0;
  1868. Int lowY, highY, lowX, highX;
  1869. lowX = (iXDest == m_rctRefVOPY0.left) ? 0 : -1;
  1870. lowY = (iYDest == m_rctRefVOPY0.top) ? 0 : -1;
  1871. highX = (iXDest == m_rctRefVOPY0.right - MB_SIZE + 1) ? 0 : 1;
  1872. highY = (iYDest == m_rctRefVOPY0.bottom - MB_SIZE + 1) ? 0 : 1;
  1873. const PixelC* ppxlcRefZoom = m_puciRefQZoom0->pixels ((iXDest << 1) + lowX, (iYDest << 1) + lowY);
  1874. for (Int incY = lowY; incY <= highY; incY++) {
  1875. for (Int incX = lowX; incX <= highX; incX++) {
  1876. // no longer skipp (0,0) due to using original as interger pel reference
  1877. //if (!(incX == 0 && incY == 0)) {
  1878. const PixelC* ppxlcRefZoomBlk = ppxlcRefZoom;
  1879. const PixelC* ppxlcTmpC = ppxlcCodedBlkY;
  1880. mbDiff = 0;
  1881. for (iy = 0; iy < BLOCK_SIZE; iy++) {
  1882. for (ix = 0; ix < BLOCK_SIZE; ix++)
  1883. mbDiff += abs (ppxlcTmpC [ix] - ppxlcRefZoomBlk [2 * ix]);
  1884. if (mbDiff > iMinSAD)
  1885. goto NEXT_HALF_POSITION;
  1886. ppxlcRefZoomBlk += m_iFrameWidthZoomY * 2;
  1887. ppxlcTmpC += MB_SIZE;
  1888. }
  1889. if ((iMinSAD > mbDiff) ||
  1890. ((abs(pmv8->m_vctTrueHalfPel.x + destHalfX) + abs(pmv8->m_vctTrueHalfPel.y + destHalfY)) >
  1891.  (abs(pmv8->m_vctTrueHalfPel.x + incX)      + abs(pmv8->m_vctTrueHalfPel.y + incY)))) {
  1892. iMinSAD = mbDiff;
  1893. destHalfX = incX;
  1894. destHalfY = incY;
  1895. }
  1896. NEXT_HALF_POSITION:
  1897. ppxlcRefZoom++;
  1898. }
  1899. ppxlcRefZoom += m_iFrameWidthZoomY - (highX - lowX + 1);
  1900. }
  1901. pmv8 -> iHalfX = destHalfX;
  1902. pmv8 -> iHalfY = destHalfY;
  1903. return iMinSAD;
  1904. }
  1906. Int CVideoObjectEncoder::blockmatch8WithShape (
  1907. const PixelC* ppxlcCodedBlkY, 
  1908. const PixelC* ppxlcCodedBlkBY, 
  1909. CMotionVector* pmv8, 
  1910. CoordI iXBlk, CoordI iYBlk,
  1911. const CMotionVector* pmvPred,
  1912. Int iSearchRange,
  1913. Int iDirection
  1914. )
  1915. {
  1916. Int mbDiff; // start with big
  1917. CoordI x = iXBlk + pmvPred->iMVX, y = iYBlk + pmvPred->iMVY, ix, iy;
  1918. CoordI left = -1 * min (abs (pmvPred->iMVX + iSearchRange), ADD_DISP);
  1919. CoordI top = -1 * min (abs (pmvPred->iMVY + iSearchRange), ADD_DISP);
  1920. CoordI right = min (abs (pmvPred->iMVX - iSearchRange), ADD_DISP);
  1921. CoordI bottom = min (abs (pmvPred->iMVY - iSearchRange), ADD_DISP);
  1923. //CoordI iOrigX = x, iOrigY = y;
  1924. CoordI iXDest = x, iYDest = y;
  1925. Int uiPosInLoop, iLoop, iMinSAD = 0;
  1926. const PixelC* ppxlcRefBlk = (m_volmd.bOriginalForME ? m_pvopcRefOrig0 : m_pvopcRefQ0)->getPlane (Y_PLANE)->pixels (x, y);
  1928. CRct CTmp=(iDirection) ? m_rctRefVOPY1:m_rctRefVOPY0;
  1930. if (m_iMVFileUsage != 1) {
  1931.     iMinSAD = sad8x8At0WithShape (ppxlcCodedBlkY, ppxlcCodedBlkBY, ppxlcRefBlk);
  1932.     // Spiral Search for the rest
  1933.     Int iix = 0, iiy = 0;
  1934.     for (iLoop = 1; iLoop <= ADD_DISP; iLoop++) {
  1935.     x++;
  1936.     y++;
  1937.     iix++;
  1938.     iiy++;
  1939.     ppxlcRefBlk += m_iFrameWidthY + 1;
  1940.     for (uiPosInLoop = 0; uiPosInLoop < (iLoop << 3); uiPosInLoop++) { // inside each spiral loop 
  1941. if (
  1942.     iix >= left && iix <= right &&
  1943.     iiy >= top && iiy <= bottom &&
  1944.     x >= CTmp.left && y >= CTmp.top && 
  1945.     x <= CTmp.right - MB_SIZE && y <= CTmp.bottom - MB_SIZE
  1946.     ) {
  1947.     const PixelC* ppxlcTmpC = ppxlcCodedBlkY;
  1948.     const PixelC* ppxlcTmpCBY = ppxlcCodedBlkBY;
  1949.     const PixelC* ppxlcRefMB = ppxlcRefBlk;
  1950.     mbDiff = 0;
  1951.     for (iy = 0; iy < BLOCK_SIZE; iy++) {
  1952.     for (ix = 0; ix < BLOCK_SIZE; ix++) {
  1953.     if (ppxlcTmpCBY [ix] != transpValue)
  1954.     mbDiff += abs (ppxlcTmpC [ix] - ppxlcRefMB [ix]);
  1955.     }
  1956.     if (mbDiff > iMinSAD)
  1957.     goto NEXT_POSITION; // skip the current position
  1958.     ppxlcRefMB += m_iFrameWidthY;
  1959.     ppxlcTmpC += MB_SIZE;
  1960.     ppxlcTmpCBY += MB_SIZE;
  1961.     }
  1962.     iMinSAD = mbDiff;
  1963.     iXDest = x;
  1964.     iYDest = y;
  1965.     }
  1966. NEXT_POSITION:
  1967.     if (uiPosInLoop < (iLoop << 1)) {
  1968.     ppxlcRefBlk--;
  1969.     x--;
  1970.     iix--;
  1971.     }
  1972.     else if (uiPosInLoop < (iLoop << 2)) {
  1973.     ppxlcRefBlk -= m_iFrameWidthY;
  1974.     y--;
  1975.     iiy--;
  1976.     }
  1977.     else if (uiPosInLoop < (iLoop * 6)) {
  1978.     ppxlcRefBlk++;   
  1979.     x++;
  1980.     iix++;
  1981.     }
  1982.     else {
  1983.     ppxlcRefBlk += m_iFrameWidthY;
  1984.     y++;
  1985.     iiy++;
  1986.     }
  1987.     }
  1988.     }
  1989.     *pmv8 = CMotionVector (iXDest - iXBlk, iYDest - iYBlk);
  1990. } 
  1991. else {
  1992. iXDest = iXBlk + pmv8->iMVX;
  1993. iYDest = iYBlk + pmv8->iMVY;
  1994. }
  1996. // check for case when zero MV due to MB outside the extended BB.
  1997. if(iXDest==iXBlk && iYDest==iYBlk
  1998. && (iXDest < CTmp.left || iYDest < CTmp.top
  1999. || iXDest > CTmp.right - MB_SIZE
  2000. || iYDest > CTmp.bottom - MB_SIZE))
  2002. {
  2003. pmv8 -> iHalfX = 0;
  2004. pmv8 -> iHalfY = 0;
  2005. return iMinSAD;  
  2006. }
  2008. iMinSAD = 256*256; // Reset iMinSAD because reference VOP changed from original to reconstructed (Bob Eifrig)
  2009. // half pel search
  2010. I8 destHalfX = 0, destHalfY = 0;
  2011. Int lowY, highY, lowX, highX;
  2012. lowX = (iXDest == CTmp.left) ? 0 : -1;
  2013. lowY = (iYDest == CTmp.top) ? 0 : -1;
  2014. highX = (iXDest == CTmp.right - MB_SIZE + 1) ? 0 : 1;
  2015. highY = (iYDest == CTmp.bottom - MB_SIZE + 1) ? 0 : 1;
  2016. const PixelC* ppxlcRefZoom = m_puciRefQZoom0->pixels ((iXDest << 1) + lowX, (iYDest << 1) + lowY);
  2017. for (Int incY = lowY; incY <= highY; incY++) {
  2018. const PixelC* ppxlcRefZoomRow = ppxlcRefZoom;
  2019. for (Int incX = lowX; incX <= highX; incX++) {
  2020. // no longer skipp (0,0) due to using original as interger pel reference
  2021. //if (!(incX == 0 && incY == 0)) {
  2022. const PixelC* ppxlcRefZoomBlk = ppxlcRefZoomRow;
  2023. const PixelC* ppxlcTmpC = ppxlcCodedBlkY;
  2024. const PixelC* ppxlcTmpCBY = ppxlcCodedBlkBY;
  2025. mbDiff = 0;
  2026. for (iy = 0; iy < BLOCK_SIZE; iy++) {
  2027. for (ix = 0; ix < BLOCK_SIZE; ix++) {
  2028. if (ppxlcTmpCBY [ix] != transpValue)
  2029. mbDiff += abs (ppxlcTmpC [ix] - ppxlcRefZoomBlk [2 * ix]);
  2030. }
  2031. if (mbDiff > iMinSAD) // Try to find shortest MV in case of equal SADs
  2032. goto NEXT_HALF_POSITION;
  2033. ppxlcRefZoomBlk += m_iFrameWidthZoomY * 2;
  2034. ppxlcTmpC += MB_SIZE;
  2035. ppxlcTmpCBY += MB_SIZE;
  2036. }
  2037. if ((iMinSAD > mbDiff) ||
  2038. ((abs(pmv8->m_vctTrueHalfPel.x + destHalfX) + abs(pmv8->m_vctTrueHalfPel.y + destHalfY)) >
  2039.  (abs(pmv8->m_vctTrueHalfPel.x + incX)      + abs(pmv8->m_vctTrueHalfPel.y + incY)))) {
  2040. iMinSAD = mbDiff;
  2041. destHalfX = incX;
  2042. destHalfY = incY;
  2043. }
  2044. NEXT_HALF_POSITION:
  2045. ppxlcRefZoomRow++;
  2046. }
  2047. ppxlcRefZoom += m_iFrameWidthZoomY;
  2048. }
  2049. pmv8 -> iHalfX = destHalfX;
  2050. pmv8 -> iHalfY = destHalfY;
  2051. return iMinSAD;
  2052. }
  2054. Int CVideoObjectEncoder::sumDev () const // compute sum of deviation of an MB
  2055. {
  2056. const PixelC* ppxlcY = m_ppxlcCurrMBY;
  2057. Int iMean = 0;
  2058. UInt iy;
  2059. for (iy = 0; iy < MB_SQUARE_SIZE; iy++)
  2060. iMean += ppxlcY [iy];
  2061. iMean /= MB_SQUARE_SIZE;
  2062. Int iDevRet = 0;
  2063. for (iy = 0; iy < MB_SQUARE_SIZE; iy++)
  2064. iDevRet += abs (m_ppxlcCurrMBY [iy] - iMean);
  2065. return iDevRet;
  2066. }
  2069. Int CVideoObjectEncoder::sumDevWithShape (UInt uiNumTranspPels) const // compute sum of deviation of an MB
  2070. {
  2071. const PixelC* ppxlcY = m_ppxlcCurrMBY;
  2072. const PixelC* ppxlcBY = m_ppxlcCurrMBBY;
  2073. Int iMean = 0;
  2074. CoordI iy;
  2075. for (iy = 0; iy < MB_SQUARE_SIZE; iy++) {
  2076. if (ppxlcBY [iy] != transpValue)
  2077. iMean += ppxlcY [iy];
  2078. }
  2079. iMean /= uiNumTranspPels;
  2080. Int iDevRet = 0;
  2081. for (iy = 0; iy < MB_SQUARE_SIZE; iy++) {
  2082. if (m_ppxlcCurrMBBY [iy] != transpValue)
  2083. iDevRet += abs (m_ppxlcCurrMBY [iy] - iMean);
  2084. }
  2085. return iDevRet;
  2086. }
  2088. Int CVideoObjectEncoder::sad16x16At0 (const PixelC* ppxlcRefY) const
  2089. {
  2090. if (m_iMVFileUsage == 1)
  2091. return 0;
  2092. Int iInitSAD = 0;
  2093. UInt nBits = m_volmd.nBits; // NBIT
  2094. Int iFavorZero = FAVORZERO; // NBIT
  2095. // NBIT: addjust iFavorZero based on nBits
  2096. if (nBits > 8) {
  2097. iFavorZero <<= (nBits-8);
  2098. } else if (nBits < 8) {
  2099. iFavorZero >>= (8-nBits);
  2100. }
  2102. CoordI ix, iy;
  2103. const PixelC* ppxlcCurrY = m_ppxlcCurrMBY;
  2104. for (iy = 0; iy < MB_SIZE; iy++) {
  2105. for (ix = 0; ix < MB_SIZE; ix++)
  2106. iInitSAD += abs (ppxlcCurrY [ix] - ppxlcRefY [ix]);
  2107. ppxlcCurrY += MB_SIZE;
  2108. ppxlcRefY += m_iFrameWidthY;
  2109. }
  2110. /* NBIT: change
  2111. iInitSAD -= FAVORZERO;
  2112. */
  2113. iInitSAD -= iFavorZero;
  2114. return iInitSAD;
  2115. }
  2117. Int CVideoObjectEncoder::sad16x16At0WithShape (const PixelC* ppxlcRefY, const CMBMode* pmbmd) const
  2118. {
  2119. if (m_iMVFileUsage == 1)
  2120. return 0;
  2121. Int iInitSAD = 0;
  2122. UInt nBits = m_volmd.nBits; // NBIT
  2123. Int iFavorZero = (pmbmd->m_rgNumNonTranspPixels [0] >> 1) + 1; // NBIT
  2124. // NBIT: addjust iFavorZero based on nBits 
  2125.         if (nBits > 8) { 
  2126.                 iFavorZero <<= (nBits-8); 
  2127.         } else if (nBits < 8) { 
  2128.                 iFavorZero >>= (8-nBits); 
  2129.         } 
  2131. CoordI ix, iy;
  2132. const PixelC* ppxlcCurrY = m_ppxlcCurrMBY;
  2133. const PixelC* ppxlcCurrBY = m_ppxlcCurrMBBY;
  2134. for (iy = 0; iy < MB_SIZE; iy++) {
  2135. for (ix = 0; ix < MB_SIZE; ix++) {
  2136. if (ppxlcCurrBY [ix] != transpValue)
  2137. iInitSAD += abs (ppxlcCurrY [ix] - ppxlcRefY [ix]);
  2138. }
  2139. ppxlcCurrBY += MB_SIZE;
  2140. ppxlcCurrY += MB_SIZE;
  2141. ppxlcRefY += m_iFrameWidthY;
  2142. }
  2143. /* NBIT: change
  2144. iInitSAD -= (pmbmd->m_rgNumNonTranspPixels [0] >> 1) + 1;
  2145. */
  2146. iInitSAD -= iFavorZero;
  2147. return iInitSAD;
  2148. }
  2150. Int CVideoObjectEncoder::sad8x8At0 (const PixelC* ppxlcCurrY, const PixelC* ppxlcRefY) const
  2151. {
  2152. Int iInitSAD = 0;
  2153. CoordI ix, iy;
  2154. for (iy = 0; iy < BLOCK_SIZE; iy++) {
  2155. for (ix = 0; ix < BLOCK_SIZE; ix++)
  2156. iInitSAD += abs (ppxlcCurrY [ix] - ppxlcRefY [ix]);
  2157. ppxlcCurrY += MB_SIZE;
  2158. ppxlcRefY += m_iFrameWidthY;
  2159. }
  2160. return iInitSAD;
  2161. }
  2163. Int CVideoObjectEncoder::sad8x8At0WithShape (const PixelC* ppxlcCurrY, const PixelC* ppxlcCurrBY, const PixelC* ppxlcRefY) const
  2164. {
  2165. Int iInitSAD = 0;
  2166. CoordI ix, iy;
  2167. for (iy = 0; iy < BLOCK_SIZE; iy++) {
  2168. for (ix = 0; ix < BLOCK_SIZE; ix++) {
  2169. if (ppxlcCurrBY [ix] != transpValue)
  2170. iInitSAD += abs (ppxlcCurrY [ix] - ppxlcRefY [ix]);
  2171. }
  2172. ppxlcCurrBY += MB_SIZE;
  2173. ppxlcCurrY += MB_SIZE;
  2174. ppxlcRefY += m_iFrameWidthY;
  2175. }
  2176. return iInitSAD;
  2177. }
  2179. //Interlaced
  2180. Int CVideoObjectEncoder::directSAD(
  2181. CoordI x, CoordI y,
  2182. CMBMode *pmbmd,
  2183. const CMBMode *pmbmdRef,
  2184. const CMotionVector *pmvRef
  2185. )
  2186. {
  2187. static CRct rctBounds[4];
  2188. static Int iTempRefD, iTempRefB, iZeroOffset, iLastNumber = -1;
  2189. PixelC fwd[MB_SQUARE_SIZE], bak[MB_SQUARE_SIZE];
  2190. static Int iXOffset[] = { 0, BLOCK_SIZE, 0, BLOCK_SIZE };
  2191. static Int iYOffset[] = { 0, 0, BLOCK_SIZE, BLOCK_SIZE };
  2192. static Int iBlkOffset[] = { 0, BLOCK_SIZE, BLOCK_SIZE*MB_SIZE, BLOCK_SIZE*(MB_SIZE + 1) };
  2193. CMotionVector mvFwd[4], mvBak[4];
  2194. Int directSAD = 256*256;
  2196. if (iLastNumber != m_t) {
  2197. iTempRefD = m_tFutureRef - m_tPastRef;
  2198. iTempRefB = m_t          - m_tPastRef;
  2199. assert(m_rctRefVOPY0 == m_rctRefVOPY1);
  2200. rctBounds[0] = m_rctRefVOPY0.upSampleBy2();
  2201. rctBounds[1] = m_rctRefVOPY0.upSampleBy2();
  2202. rctBounds[2] = m_rctRefVOPY0.upSampleBy2();
  2203. rctBounds[3] = m_rctRefVOPY0.upSampleBy2();
  2204. rctBounds[0].expand(           0,            0, - 2*BLOCK_SIZE, - 2*BLOCK_SIZE);
  2205. rctBounds[1].expand(2*BLOCK_SIZE,            0, - 4*BLOCK_SIZE, - 2*BLOCK_SIZE);
  2206. rctBounds[2].expand(           0, 2*BLOCK_SIZE, - 2*BLOCK_SIZE, - 4*BLOCK_SIZE);
  2207. rctBounds[3].expand(2*BLOCK_SIZE, 2*BLOCK_SIZE, - 4*BLOCK_SIZE, - 4*BLOCK_SIZE);
  2208. iZeroOffset = m_puciRefQZoom0->where().offset(0,0);
  2209.         iLastNumber = m_t;
  2210. }
  2211. Int iRadius = m_vopmd.iDirectModeRadius;
  2212. CVector vctDMV, vctCurrZoomMB(x << 1, y << 1);
  2213. if ((pmbmdRef->m_dctMd == INTRA) || (pmbmdRef->m_dctMd == INTRAQ)) {
  2214. static CMotionVector mvZero[5];
  2215. pmvRef = mvZero;
  2216. }
  2217. for (vctDMV.y = -iRadius; vctDMV.y <= iRadius; vctDMV.y++) {
  2218. for (vctDMV.x = -iRadius; vctDMV.x <= iRadius; vctDMV.x++) {
  2219. Int iBlk;
  2220. for (iBlk = 0; iBlk < 4; iBlk++) {
  2221. mvFwd[iBlk] = (pmvRef[iBlk + 1].m_vctTrueHalfPel * iTempRefB) / iTempRefD + vctDMV;
  2222. if (!rctBounds[iBlk].includes(vctCurrZoomMB + mvFwd[iBlk].m_vctTrueHalfPel))
  2223. break;              // out-of-range
  2224.                 mvBak[iBlk] = CVector(vctDMV.x ?
  2225.                     (mvFwd[iBlk].m_vctTrueHalfPel.x - pmvRef[iBlk + 1].m_vctTrueHalfPel.x) :
  2226.                     ((pmvRef[iBlk + 1].m_vctTrueHalfPel.x * (iTempRefB - iTempRefD)) / iTempRefD),
  2227.                     vctDMV.y ? (mvFwd[iBlk].m_vctTrueHalfPel.y - pmvRef[iBlk + 1].m_vctTrueHalfPel.y) :
  2228.                     ((pmvRef[iBlk + 1].m_vctTrueHalfPel.y * (iTempRefB - iTempRefD)) / iTempRefD));
  2229. if (!rctBounds[iBlk].includes(vctCurrZoomMB + mvBak[iBlk].m_vctTrueHalfPel))
  2230. break; // out-of-range
  2231. }
  2232. if (iBlk < 4) // All mvFwd[] and mvBak[] vectors must be inbounds to continue
  2233. continue;
  2235. for (iBlk = 0; iBlk < 4; iBlk++) {
  2236. motionCompEncY(m_pvopcRefQ0->pixelsY (), m_puciRefQZoom0->pixels(),
  2237. fwd + iBlkOffset[iBlk], BLOCK_SIZE, &mvFwd[iBlk], x + iXOffset[iBlk], y + iYOffset[iBlk],0);
  2238. motionCompEncY(m_pvopcRefQ0->pixelsY (), m_puciRefQZoom1->pixels(),
  2239. bak + iBlkOffset[iBlk], BLOCK_SIZE, &mvBak[iBlk], x + iXOffset[iBlk], y + iYOffset[iBlk],0);
  2240. }
  2241. Int iSAD, i;
  2242. for (iSAD = 0, i = 0; i < MB_SQUARE_SIZE; i++)
  2243. iSAD += abs(m_ppxlcCurrMBY[i] - ((fwd[i] + bak[i] + 1) >> 1));
  2245. if (iSAD < directSAD) {
  2246. directSAD = iSAD;
  2247. //pmbmd->m_vctDMV = vctDMV;
  2248. //wchen-Jan06-97: to be consistent with non-interlaced case
  2249. pmbmd->m_vctDirectDeltaMV = vctDMV;
  2250. }
  2251. }
  2252. }
  2253. #if 0 // #ifdef __TRACE_AND_STATS_
  2254. Int iDirInfo[10];
  2255. iDirInfo[0] = pmvRef[1].m_vctTrueHalfPel.x; iDirInfo[1] = pmvRef[1].m_vctTrueHalfPel.y;
  2256. iDirInfo[2] = pmvRef[2].m_vctTrueHalfPel.x; iDirInfo[3] = pmvRef[2].m_vctTrueHalfPel.y;
  2257. iDirInfo[4] = pmvRef[3].m_vctTrueHalfPel.x; iDirInfo[5] = pmvRef[3].m_vctTrueHalfPel.y;
  2258. iDirInfo[6] = pmvRef[4].m_vctTrueHalfPel.x; iDirInfo[7] = pmvRef[4].m_vctTrueHalfPel.y;
  2259. //iDirInfo[8] = pmbmd->m_vctDMV.x;            iDirInfo[9] = pmbmd->m_vctDMV.y;
  2260. iDirInfo[8] = pmbmd->m_vctDirectDeltaMV.x;
  2261. iDirInfo[9] = pmbmd->m_vctDirectDeltaMV.y;
  2262. m_pbitstrmOut->trace (iDirInfo, 10, "FrameDirect");
  2263. #endif // __TRACE_AND_STATS_
  2264. return directSAD;
  2265. }
  2267. Int CVideoObjectEncoder::directSADField(
  2268. CoordI x, CoordI y,
  2269. CMBMode *pmbmd,
  2270. const CMBMode *pmbmdRef,
  2271. const CMotionVector *pmvRef,
  2272. const PixelC* ppxlcRef0MBY,
  2273. const PixelC* ppxlcRef1MBY
  2274. )
  2275. {
  2276. static I8 iTROffsetTop[] = {  0, 0,  1, 1, 0, 0, -1, -1 };
  2277. static I8 iTROffsetBot[] = { -1, 0, -1, 0, 1, 0,  1,  0 };
  2278. static CRct rctBounds;
  2279. static Int iLastNumber = -1;
  2280. const CMotionVector *pmvRefTop, *pmvRefBot;
  2281. PixelC fwd[MB_SQUARE_SIZE], bak[MB_SQUARE_SIZE];
  2282. CVector vctFwdTop, vctFwdBot, vctBakTop, vctBakBot, vctDMV, vctCurrZoomMB(x << 1, y << 1);
  2283. Int iDirectSAD = 256*256;
  2285. if (m_t != iLastNumber) {
  2286. assert(m_rctRefVOPY0 == m_rctRefVOPY1); // Probably only true for rectangular VOPs
  2287. rctBounds = m_rctRefVOPY0.upSampleBy2();
  2288. rctBounds.expand(0, 0, -2*MB_SIZE, -2*MB_SIZE);
  2289. iLastNumber = m_t;
  2290. }
  2291. assert((pmbmdRef->m_dctMd != INTRA) && (pmbmdRef->m_dctMd != INTRAQ));
  2292. Int iTopRefFldOffset = 0, iBotRefFldOffset = 0;
  2293. Int iCode = ((Int)vopmd().bTopFieldFirst) << 2;
  2294. if (pmbmdRef->m_bForwardTop) {
  2295. iCode |= 2;
  2296. iTopRefFldOffset = m_iFrameWidthY;
  2297. pmvRefTop = pmvRef + 6;
  2298. } else
  2299. pmvRefTop = pmvRef + 5;
  2300. if (pmbmdRef->m_bForwardBottom) {
  2301. iCode |= 1;
  2302. iBotRefFldOffset = m_iFrameWidthY;
  2303. pmvRefBot = pmvRef + 8;
  2304. } else
  2305. pmvRefBot = pmvRef + 7;
  2306. Int iTempRefDTop = 2*(m_tFutureRef - m_tPastRef) + iTROffsetTop[iCode];
  2307. Int iTempRefDBot = 2*(m_tFutureRef - m_tPastRef) + iTROffsetBot[iCode];
  2308. Int iTempRefBTop = 2*(m_t          - m_tPastRef) + iTROffsetTop[iCode];
  2309. Int iTempRefBBot = 2*(m_t          - m_tPastRef) + iTROffsetBot[iCode];
  2310. Int iRadius = m_vopmd.iDirectModeRadius;
  2311. ppxlcRef0MBY -= EXPANDY_REF_FRAME * (m_iFrameWidthY + 1);
  2312. ppxlcRef1MBY -= EXPANDY_REF_FRAME * (m_iFrameWidthY + 1);
  2314. for (vctDMV.y = -iRadius; vctDMV.y <= iRadius; vctDMV.y++) {
  2315. for (vctDMV.x = -iRadius; vctDMV.x <= iRadius; vctDMV.x++) {
  2317. // Find MVs for the top field
  2318. vctFwdTop = (pmvRefTop->m_vctTrueHalfPel * iTempRefBTop) / iTempRefDTop + vctDMV;
  2319. if (!rctBounds.includes(vctCurrZoomMB + vctFwdTop))
  2320. continue;
  2321.             vctBakTop.x = vctDMV.x ? (vctFwdTop.x - pmvRefTop->m_vctTrueHalfPel.x) :
  2322.                 ((pmvRefTop->m_vctTrueHalfPel.x * (iTempRefBTop - iTempRefDTop)) / iTempRefDTop);
  2323.             vctBakTop.y = vctDMV.y ? (vctFwdTop.y - pmvRefTop->m_vctTrueHalfPel.y) :
  2324.                 ((pmvRefTop->m_vctTrueHalfPel.y * (iTempRefBTop - iTempRefDTop)) / iTempRefDTop);
  2325. if (!rctBounds.includes(vctCurrZoomMB + vctBakTop))
  2326. continue;
  2328. // Find MVs for the bottom field
  2329. vctFwdBot = (pmvRefBot->m_vctTrueHalfPel * iTempRefBBot) / iTempRefDBot + vctDMV;
  2330. if (!rctBounds.includes(vctCurrZoomMB + vctFwdBot))
  2331. continue;
  2332.             vctBakBot.x = vctDMV.x ? (vctFwdBot.x - pmvRefBot->m_vctTrueHalfPel.x) :
  2333.                 ((pmvRefBot->m_vctTrueHalfPel.x * (iTempRefBBot - iTempRefDBot)) / iTempRefDBot);
  2334.             vctBakBot.y = vctDMV.y ? (vctFwdBot.y - pmvRefBot->m_vctTrueHalfPel.y) :
  2335.                 ((pmvRefBot->m_vctTrueHalfPel.y * (iTempRefBBot - iTempRefDBot)) / iTempRefDBot);
  2336. if (!rctBounds.includes(vctCurrZoomMB + vctBakBot))
  2337. continue;
  2339. // Motion compensate the luma top field
  2340. motionCompYField(fwd,           ppxlcRef0MBY + iTopRefFldOffset, vctFwdTop.x, vctFwdTop.y);
  2341. motionCompYField(bak,           ppxlcRef1MBY,                    vctBakTop.x, vctBakTop.y);
  2343. // Motion compensate the luma bottom field
  2344. motionCompYField(fwd + MB_SIZE, ppxlcRef0MBY + iBotRefFldOffset, vctFwdBot.x, vctFwdBot.y);
  2345. motionCompYField(bak + MB_SIZE, ppxlcRef1MBY + m_iFrameWidthY,   vctBakBot.x, vctBakBot.y);
  2347. // Coumpute SAD
  2348. Int iSAD = 0;
  2349. for (Int i = 0; i < MB_SQUARE_SIZE; i++)
  2350. iSAD += abs(m_ppxlcCurrMBY[i] - ((fwd[i] + bak[i] + 1) >> 1));
  2352. if (iSAD < iDirectSAD) {
  2353. iDirectSAD = iSAD;
  2354. //pmbmd->m_vctDMV = vctDMV;
  2355. pmbmd->m_vctDirectDeltaMV = vctDMV;
  2356. }
  2357. }
  2358. }
  2359. #if 0 // #ifdef __TRACE_AND_STATS_
  2360. Int iDirInfo[8];
  2361. iDirInfo[0] = iCode;
  2362. iDirInfo[1] = pmvRefTop->m_vctTrueHalfPel.x; iDirInfo[2] = pmvRefTop->m_vctTrueHalfPel.y;
  2363. iDirInfo[3] = pmvRefBot->m_vctTrueHalfPel.x; iDirInfo[4] = pmvRefBot->m_vctTrueHalfPel.y;
  2364. //iDirInfo[5] = pmbmd->m_vctDMV.x;             iDirInfo[6] = pmbmd->m_vctDMV.y;
  2365. iDirInfo[5] = pmbmd->m_vctDirectDeltaMV.x;
  2366. iDirInfo[6] = pmbmd->m_vctDirectDeltaMV.y;
  2367. m_pbitstrmOut->trace (iDirInfo, 7, "FieldDirect");
  2368. #endif // __TRACE_AND_STATS_
  2369. return iDirectSAD;
  2370. }
  2371. // ~INTERLACE
  2373. // INTERLACE
  2374. Int CVideoObjectEncoder::blkmatch16x8 (
  2375. CMotionVector* pmv, 
  2376. CoordI iXMB, CoordI iYMB,
  2377. Int iFieldSelect,
  2378. const PixelC* ppxlcRefMBY,
  2379. const PixelC* ppxlcRefHalfPel,
  2380. Int iSearchRange
  2381. )
  2382. {
  2383. Int mbDiff; // start with big
  2384. Int iWidth2 = 2*m_iFrameWidthY;
  2385. Int iXDest = iXMB, iYDest = iYMB;
  2386. CoordI x = iXMB, y = iYMB, ix, iy;
  2387. Int uiPosInLoop, iLoop;
  2388. Int iMinSAD = 0;
  2390. if (m_iMVFileUsage != 1) {
  2392. // Calculate the center point SAD
  2393. const PixelC* ppxlcCurrY = m_ppxlcCurrMBY + iFieldSelect;
  2394. const PixelC* ppxlcRefMB = ppxlcRefMBY;
  2395. for (iy = 0; iy < MB_SIZE/2; iy++) {
  2396. for (ix = 0; ix < MB_SIZE; ix++)
  2397. iMinSAD += abs (ppxlcCurrY [ix] - ppxlcRefMB [ix]);
  2398. ppxlcCurrY += 2*MB_SIZE;
  2399. ppxlcRefMB += iWidth2;
  2400. }
  2401. // iMinSAD -= FAVORZERO/2; // Apply center favoring bias?
  2403. // Spiral Search for the rest
  2404. for (iLoop = 1; iLoop <= iSearchRange; iLoop++) {
  2405. x++;
  2406. y++;
  2407. ppxlcRefMBY += m_iFrameWidthY + 1;
  2408. for (uiPosInLoop = 0; uiPosInLoop < (iLoop << 3); uiPosInLoop++) { // inside each spiral loop 
  2409. if (
  2410. x >= m_rctRefVOPY0.left && y >= m_rctRefVOPY0.top && 
  2411. x <= m_rctRefVOPY0.right - MB_SIZE && y <= m_rctRefVOPY0.bottom - MB_SIZE
  2412. && ((y-iYMB)%2==0)
  2413. ) {
  2414. ppxlcCurrY = m_ppxlcCurrMBY+iFieldSelect;
  2415. ppxlcRefMB = ppxlcRefMBY;
  2416. mbDiff = 0;
  2417. // full pel field prediction
  2418. for (iy = 0; iy < MB_SIZE; iy+=2) {
  2419. for (ix = 0; ix < MB_SIZE; ix++)
  2420. mbDiff += abs (ppxlcCurrY [ix] - ppxlcRefMB [ix]);
  2422. if (mbDiff > iMinSAD)
  2423. goto NEXT_POSITION; // skip the current position
  2424. ppxlcRefMB += iWidth2;
  2425. ppxlcCurrY += MB_SIZE*2;
  2426. }
  2427. iMinSAD = mbDiff;
  2428. iXDest = x;
  2429. iYDest = y;
  2430. }
  2431. NEXT_POSITION:
  2432. if (uiPosInLoop < (iLoop << 1)) {
  2433. ppxlcRefMBY--;
  2434. x--;
  2435. }
  2436. else if (uiPosInLoop < (iLoop << 2)) {
  2437. ppxlcRefMBY -= m_iFrameWidthY;
  2438. y--;
  2439. }
  2440. else if (uiPosInLoop < (iLoop * 6)) {
  2441. ppxlcRefMBY++;   
  2442. x++;
  2443. }
  2444. else {
  2445. ppxlcRefMBY += m_iFrameWidthY;
  2446. y++;
  2447. }
  2448. }
  2449. }
  2450. *pmv = CMotionVector (iXDest - iXMB, iYDest - iYMB);
  2451. } else {
  2452. iXDest = iXMB + pmv->iMVX;
  2453. iYDest = iYMB + pmv->iMVY;
  2454. }
  2456. // half pel search
  2457. I8 destHalfX = 0, destHalfY = 0;
  2458. Int lowX = (iXDest == m_rctRefVOPY0.left) ? 0 : -1;
  2459. Int lowY = (iYDest == m_rctRefVOPY0.top) ? 0 : -2;
  2460. Int highX = (iXDest == m_rctRefVOPY0.right - MB_SIZE) ? 0 : 1;
  2461. Int highY = (iYDest == m_rctRefVOPY0.bottom - MB_SIZE) ? 0 : 2;
  2462. Int iRound1 = 1 - m_vopmd.iRoundingControl;
  2463. Int iRound2 = 2 - m_vopmd.iRoundingControl;
  2464. assert(!(pmv->iMVY & 1));
  2465. ppxlcRefHalfPel += pmv->iMVX + m_iFrameWidthY * pmv->iMVY; // 12.22.98 changes
  2466. iMinSAD = 256*256;
  2467. for (Int incY = lowY; incY <= highY; incY += 2) {
  2468. for (Int incX = lowX; incX <= highX; incX++) {
  2469. const PixelC *ppxlcRef = ppxlcRefHalfPel;
  2470. const PixelC *ppxlcCur = m_ppxlcCurrMBY + iFieldSelect;
  2471. if (incY < 0)
  2472. ppxlcRef -= iWidth2;
  2473. if (incX < 0)
  2474. ppxlcRef--;
  2475. mbDiff = 0;
  2476. if (incY == 0) {
  2477. if (incX == 0) {
  2478. for (iy = 0; iy < MB_SIZE; iy += 2) {
  2479. for (ix = 0; ix < MB_SIZE; ix++)
  2480. mbDiff += abs(ppxlcRef[ix] - ppxlcCur[ix]);
  2481. if (mbDiff > iMinSAD)
  2482. goto NEXT_HALF_POSITION;
  2483. ppxlcRef += iWidth2;
  2484. ppxlcCur += MB_SIZE*2;
  2485. }
  2486. } else {
  2487. for (iy = 0; iy < MB_SIZE; iy += 2) {
  2488. for (ix = 0; ix < MB_SIZE; ix++)
  2489. mbDiff += abs(((ppxlcRef[ix] + ppxlcRef[ix+1] + iRound1) >> 1) - ppxlcCur[ix]);
  2490. if (mbDiff > iMinSAD)
  2491. goto NEXT_HALF_POSITION;
  2492. ppxlcRef += iWidth2;
  2493. ppxlcCur += MB_SIZE*2;
  2494. }
  2495. }
  2496. } else {
  2497. if (incX == 0) {
  2498. for (iy = 0; iy < MB_SIZE; iy += 2) {
  2499. for (ix = 0; ix < MB_SIZE; ix++)
  2500. mbDiff += abs(((ppxlcRef[ix] + ppxlcRef[ix+iWidth2] + iRound1) >> 1) - ppxlcCur[ix]);
  2501. if (mbDiff > iMinSAD)
  2502. goto NEXT_HALF_POSITION;
  2503. ppxlcRef += iWidth2;
  2504. ppxlcCur += MB_SIZE*2;
  2505. }
  2506. } else {
  2507. for (iy = 0; iy < MB_SIZE; iy += 2) {
  2508. for (ix = 0; ix < MB_SIZE; ix++)
  2509. mbDiff += abs(((ppxlcRef[ix] + ppxlcRef[ix+1] + ppxlcRef[ix+iWidth2] +
  2510. ppxlcRef[ix+iWidth2+1] + iRound2) >> 2) - ppxlcCur[ix]);
  2511. if (mbDiff > iMinSAD)
  2512. goto NEXT_HALF_POSITION;
  2513. ppxlcRef += iWidth2;
  2514. ppxlcCur += MB_SIZE*2;
  2515. }
  2516. }
  2517. }
  2518. if ((iMinSAD > mbDiff) ||
  2519. ((abs(pmv->m_vctTrueHalfPel.x + destHalfX) + abs(pmv->m_vctTrueHalfPel.y + destHalfY)) >
  2520.  (abs(pmv->m_vctTrueHalfPel.x + incX)      + abs(pmv->m_vctTrueHalfPel.y + incY)))) {
  2521. iMinSAD = mbDiff;
  2522. destHalfX = incX;
  2523. destHalfY = incY;
  2524. }
  2525. NEXT_HALF_POSITION:
  2526. ;
  2527. }
  2528. }
  2529. pmv->iHalfX = destHalfX;
  2530. pmv->iHalfY = destHalfY; // Violates range of -1,0,1 but need to keep (iMVX,iMVY) pure for MV file write
  2532. return iMinSAD;
  2533. }
  2534. // new changes
  2535. Int CVideoObjectEncoder::blkmatch16x8WithShape (
  2536. CMotionVector* pmv, 
  2537. CoordI iXMB, CoordI iYMB,
  2538. Int iFieldSelect,
  2539. const PixelC* ppxlcRefMBY,
  2540. const PixelC* ppxlcRefHalfPel,
  2541. Int iSearchRange,
  2542. Int iDirection
  2543. )
  2544. {
  2545. Int mbDiff; // start with big
  2546. Int iWidth2 = 2*m_iFrameWidthY;
  2547. Int iXDest = iXMB, iYDest = iYMB;
  2548. CoordI x = iXMB, y = iYMB, ix, iy;
  2549. Int uiPosInLoop, iLoop;
  2550. Int iMinSAD = 0;
  2552. CRct CTmp=(iDirection) ? m_rctRefVOPY1 : m_rctRefVOPY0;
  2554. if (m_iMVFileUsage != 1) {
  2556. // Calculate the center point SAD
  2557. const PixelC* ppxlcCurrY = m_ppxlcCurrMBY + iFieldSelect;
  2558. const PixelC* ppxlcCurrBY = m_ppxlcCurrMBBY + iFieldSelect;
  2559. const PixelC* ppxlcRefMB = ppxlcRefMBY;
  2560. for (iy = 0; iy < MB_SIZE/2; iy++) {
  2561. for (ix = 0; ix < MB_SIZE; ix++) {
  2562. if(ppxlcCurrBY[ix] != transpValue)
  2563. iMinSAD += abs (ppxlcCurrY [ix] - ppxlcRefMB [ix]);
  2564. }
  2565. ppxlcCurrY += 2*MB_SIZE;
  2566. ppxlcCurrBY += 2*MB_SIZE;
  2567. ppxlcRefMB += iWidth2;
  2568. }
  2569. // iMinSAD -= FAVORZERO/2; // Apply center favoring bias?
  2571. // Spiral Search for the rest
  2572. for (iLoop = 1; iLoop <= iSearchRange; iLoop++) {
  2573. x++;
  2574. y++;
  2575. ppxlcRefMBY += m_iFrameWidthY + 1;
  2576. for (uiPosInLoop = 0; uiPosInLoop < (iLoop << 3); uiPosInLoop++) { // inside each spiral loop 
  2577. if (
  2578. x >= CTmp.left && y >= CTmp.top && 
  2579. x <= CTmp.right - MB_SIZE && y <= CTmp.bottom - MB_SIZE
  2580. && ((y-iYMB)%2==0)
  2581. ) {
  2582. ppxlcCurrY = m_ppxlcCurrMBY+iFieldSelect;
  2583. ppxlcCurrBY = m_ppxlcCurrMBBY + iFieldSelect;
  2584. ppxlcRefMB = ppxlcRefMBY;
  2585. mbDiff = 0;
  2586. // full pel field prediction
  2587. for (iy = 0; iy < MB_SIZE; iy+=2) {
  2588. for (ix = 0; ix < MB_SIZE; ix++) {
  2589. if(ppxlcCurrBY[ix] != transpValue)
  2590. mbDiff += abs (ppxlcCurrY [ix] - ppxlcRefMB [ix]);
  2591. }
  2593. if (mbDiff > iMinSAD)
  2594. goto NEXT_POSITION; // skip the current position
  2595. ppxlcRefMB += iWidth2;
  2596. ppxlcCurrY += MB_SIZE*2;
  2597. ppxlcCurrBY += MB_SIZE*2;
  2598. }
  2599. iMinSAD = mbDiff;
  2600. iXDest = x;
  2601. iYDest = y;
  2602. }
  2603. NEXT_POSITION:
  2604. if (uiPosInLoop < (iLoop << 1)) {
  2605. ppxlcRefMBY--;
  2606. x--;
  2607. }
  2608. else if (uiPosInLoop < (iLoop << 2)) {
  2609. ppxlcRefMBY -= m_iFrameWidthY;
  2610. y--;
  2611. }
  2612. else if (uiPosInLoop < (iLoop * 6)) {
  2613. ppxlcRefMBY++;   
  2614. x++;
  2615. }
  2616. else {
  2617. ppxlcRefMBY += m_iFrameWidthY;
  2618. y++;
  2619. }
  2620. }
  2621. }
  2622. *pmv = CMotionVector (iXDest - iXMB, iYDest - iYMB);
  2623. } else {
  2624. iXDest = iXMB + pmv->iMVX;
  2625. iYDest = iYMB + pmv->iMVY;
  2626. }
  2628. // 12.22.98 begin of changes, X. Chen
  2629. // check for case when zero MV due to MB outside the extended BB.
  2630. /* if(iXDest==iXMB && iYDest==iYMB
  2631. && (iXDest < CTmp.left || iYDest < CTmp.top
  2632. || iXDest > CTmp.right - MB_SIZE
  2633. || iYDest > CTmp.bottom - MB_SIZE))
  2634. {
  2635. pmv -> iHalfX = 0;
  2636. pmv -> iHalfY = 0;
  2637. return iMinSAD;  
  2638. } */
  2639. // 12.22.98 end of changes X.Chen
  2641. // half pel search
  2642. I8 destHalfX = 0, destHalfY = 0;
  2643. Int lowX = (iXDest == CTmp.left) ? 0 : -1; // 12.22.98 changes
  2644. Int lowY = (iYDest == CTmp.top) ? 0 : -2; // 12.22.98 changes
  2645. Int highX = (iXDest == CTmp.right - MB_SIZE) ? 0 : 1; // 12.22.98 changes
  2646. Int highY = (iYDest == CTmp.bottom - MB_SIZE) ? 0 : 2; // 12.22.98 changes
  2647. Int iRound1 = 1 - m_vopmd.iRoundingControl;
  2648. Int iRound2 = 2 - m_vopmd.iRoundingControl;
  2649. assert(!(pmv->iMVY & 1));
  2650. ppxlcRefHalfPel += pmv->iMVX + m_iFrameWidthY * pmv->iMVY; // 12.22.98
  2651. iMinSAD = 256*256;
  2652. for (Int incY = lowY; incY <= highY; incY += 2) {
  2653. for (Int incX = lowX; incX <= highX; incX++) {
  2654. const PixelC *ppxlcRef = ppxlcRefHalfPel;
  2655. const PixelC *ppxlcCurB = m_ppxlcCurrMBBY + iFieldSelect;
  2656. const PixelC *ppxlcCur = m_ppxlcCurrMBY + iFieldSelect;
  2657. if (incY < 0)
  2658. ppxlcRef -= iWidth2;
  2659. if (incX < 0)
  2660. ppxlcRef--;
  2661. mbDiff = 0;
  2662. if (incY == 0) {
  2663. if (incX == 0) {
  2664. for (iy = 0; iy < MB_SIZE; iy += 2) {
  2665. for (ix = 0; ix < MB_SIZE; ix++) {
  2666. if(ppxlcCurB[ix] != transpValue)
  2667. mbDiff += abs(ppxlcRef[ix] - ppxlcCur[ix]);
  2668. }
  2669. if (mbDiff > iMinSAD)
  2670. goto NEXT_HALF_POSITION;
  2671. ppxlcRef += iWidth2;
  2672. ppxlcCur += MB_SIZE*2;
  2673. ppxlcCurB += MB_SIZE*2;
  2674. }
  2675. } else {
  2676. for (iy = 0; iy < MB_SIZE; iy += 2) {
  2677. for (ix = 0; ix < MB_SIZE; ix++) {
  2678. if(ppxlcCurB[ix] != transpValue)
  2679. mbDiff += abs(((ppxlcRef[ix] + ppxlcRef[ix+1] + iRound1) >> 1) - ppxlcCur[ix]);
  2680. }
  2681. if (mbDiff > iMinSAD)
  2682. goto NEXT_HALF_POSITION;
  2683. ppxlcRef += iWidth2;
  2684. ppxlcCur += MB_SIZE*2;
  2685. ppxlcCurB += MB_SIZE*2;
  2686. }
  2687. }
  2688. } else {
  2689. if (incX == 0) {
  2690. for (iy = 0; iy < MB_SIZE; iy += 2) {
  2691. for (ix = 0; ix < MB_SIZE; ix++) {
  2692. if(ppxlcCurB[ix] != transpValue)
  2693. mbDiff += abs(((ppxlcRef[ix] + ppxlcRef[ix+iWidth2] + iRound1) >> 1) - ppxlcCur[ix]);
  2694. }
  2695. if (mbDiff > iMinSAD)
  2696. goto NEXT_HALF_POSITION;
  2697. ppxlcRef += iWidth2;
  2698. ppxlcCur += MB_SIZE*2;
  2699. ppxlcCurB += MB_SIZE*2;
  2700. }
  2701. } else {
  2702. for (iy = 0; iy < MB_SIZE; iy += 2) {
  2703. for (ix = 0; ix < MB_SIZE; ix++) {
  2704. if(ppxlcCurB[ix] != transpValue)
  2705. mbDiff += abs(((ppxlcRef[ix] + ppxlcRef[ix+1] + ppxlcRef[ix+iWidth2] +
  2706. ppxlcRef[ix+iWidth2+1] + iRound2) >> 2) - ppxlcCur[ix]);
  2707. }
  2708. if (mbDiff > iMinSAD)
  2709. goto NEXT_HALF_POSITION;
  2710. ppxlcRef += iWidth2;
  2711. ppxlcCur += MB_SIZE*2;
  2712. ppxlcCurB += MB_SIZE*2;
  2713. } 
  2714. } 
  2715. }
  2716. if ((iMinSAD > mbDiff) ||
  2717. ((abs(pmv->m_vctTrueHalfPel.x + destHalfX) + abs(pmv->m_vctTrueHalfPel.y + destHalfY)) >
  2718.  (abs(pmv->m_vctTrueHalfPel.x + incX)      + abs(pmv->m_vctTrueHalfPel.y + incY)))) {
  2719. iMinSAD = mbDiff;
  2720. destHalfX = incX;
  2721. destHalfY = incY;
  2722. }
  2723. NEXT_HALF_POSITION:
  2724. ;
  2725. }
  2726. }
  2727. pmv->iHalfX = destHalfX;
  2728. pmv->iHalfY = destHalfY; // Violates range of -1,0,1 but need to keep (iMVX,iMVY) pure for MV file write
  2730.   return iMinSAD;
  2731. }
  2732. // end of new changes
  2733. // ~INTERLACE
  2735. Void CVideoObjectEncoder::readPVOPMVs()
  2736. {
  2737. Char line[150];
  2738. int pic, type, ref, rad;
  2739. CMotionVector* pmv = m_rgmv;
  2740.     CRct clip[9];
  2742. m_iMVLineNo++;
  2743. if (fgets(line, sizeof line, m_fMVFile) == NULL) {
  2744. fprintf(stderr, "EOF on %s at %dn", m_pchMVFileName, m_iMVLineNo);
  2745. exit(1);
  2746. }
  2747. if ((sscanf(line + 4, "%d %d %d %d", &pic, &type, &ref, &rad) != 4) ||
  2748. (pic != m_t) ||
  2749. (type != m_vopmd.vopPredType) ||
  2750. (ref != m_tPastRef)) {
  2751. fprintf(stderr, "%s:%d MV read error: expected %c%d(%d), got %c%d(%d)n",
  2752. m_pchMVFileName, m_iMVLineNo, "IPBS"[m_vopmd.vopPredType],
  2753. m_t, m_tPastRef, "IPBS"[type], pic, ref);
  2754. exit(1);
  2755. }
  2756. if (rad > m_vopmd.iSearchRangeForward) {
  2757. fprintf(stderr, "ME radius from file (%d) > current ME radius (%d)n",
  2758.   rad, m_vopmd.iSearchRangeForward);
  2759. exit(1);
  2760. }
  2762.     clip[0] = m_rctRefVOPY0; clip[0].expand(0,          0,          -MB_SIZE,    -MB_SIZE);    // 04/28/99
  2763.     clip[1] = m_rctRefVOPY0; clip[1].expand(0,          0,          -BLOCK_SIZE, -BLOCK_SIZE); // 04/28/99
  2764.     clip[2] = m_rctRefVOPY0; clip[2].expand(BLOCK_SIZE, 0,          -BLOCK_SIZE, -BLOCK_SIZE); // 04/28/99
  2765.     clip[3] = m_rctRefVOPY0; clip[3].expand(0,          BLOCK_SIZE, -BLOCK_SIZE, -BLOCK_SIZE); // 04/28/99
  2766.     clip[4] = m_rctRefVOPY0; clip[4].expand(BLOCK_SIZE, BLOCK_SIZE, -BLOCK_SIZE, -BLOCK_SIZE); // 04/28/99
  2767.     clip[5] = clip[0];
  2768.     clip[6] = clip[0];
  2769.     clip[7] = clip[0];
  2770.     clip[8] = clip[0];
  2771.     CRct ball(-rad, -rad, rad, rad);
  2772. for (Int iMBY = 0; iMBY < m_iNumMBY; iMBY++) {
  2773. for (Int iMBX = 0; iMBX < m_iNumMBX; iMBX++) {
  2774. int x, y, inter;
  2776. m_iMVLineNo++;
  2777. if (fgets(line, sizeof line, m_fMVFile) == NULL) {
  2778. fprintf(stderr, "EOF on %s at %dn", m_pchMVFileName, m_iMVLineNo);
  2779. exit(1);
  2780. }
  2781. if (sscanf(line,
  2782. "%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d",
  2783. &x, &y, &inter,  // MB coordinates and predicted-flag
  2784. &pmv[0].iMVX, &pmv[0].iMVY, // 16x16 MV
  2785. &pmv[5].iMVX, &pmv[5].iMVY, // field top-top MV
  2786. &pmv[6].iMVX, &pmv[6].iMVY, // field top-bot MV
  2787. &pmv[7].iMVX, &pmv[7].iMVY, // field bot-top MV
  2788. &pmv[8].iMVX, &pmv[8].iMVY, // field bot-bot MV
  2789. &pmv[1].iMVX, &pmv[1].iMVY, // Upper left  8x8 block MV
  2790. &pmv[2].iMVX, &pmv[2].iMVY, // Upper right 8x8 block MV
  2791. &pmv[3].iMVX, &pmv[3].iMVY, // Lower left  8x8 block MV
  2792. &pmv[4].iMVX, &pmv[4].iMVY) // Lower right 8x8 block MV
  2793. != 21) {
  2794. fprintf(stderr, "%s: Read error on line %d: %sn",
  2795. m_pchMVFileName, m_iMVLineNo, line);
  2796. exit(1);
  2797. }
  2798. assert(x==iMBX && y==iMBY);
  2799.             x *= MB_SIZE;
  2800.             y *= MB_SIZE;
  2801. for (Int i = 0; i < PVOP_MV_PER_REF_PER_MB; i++) {
  2802. pmv[i].iMVX >>= 1;
  2803. pmv[i].iMVY >>= 1;
  2804.                 CRct bounds = clip[i];
  2805.                 bounds.shift(-x, -y);
  2806.                 bounds.clip(ball);
  2807.                 if (bounds.left   > pmv[i].iMVX) pmv[i].iMVX = bounds.left;
  2808.                 if (bounds.right  < pmv[i].iMVX) pmv[i].iMVX = bounds.right;
  2809.                 if (bounds.top    > pmv[i].iMVY) pmv[i].iMVY = bounds.top;
  2810.                 if (bounds.bottom < pmv[i].iMVY) pmv[i].iMVY = bounds.bottom;
  2811. pmv[i].iHalfX = 0;
  2812. pmv[i].iHalfY = 0;
  2813. pmv[i].computeTrueMV();
  2814. }
  2815. pmv += PVOP_MV_PER_REF_PER_MB;
  2816. }
  2817. }
  2818. }
  2820. Void CVideoObjectEncoder::writePVOPMVs()
  2821. {
  2822. CMotionVector* pmv = m_rgmv;
  2823. CMBMode* pmbmd = m_rgmbmd;
  2825. m_iMVLineNo++;
  2826. fprintf(m_fMVFile, "Pic %d %d %d %dn", m_t,
  2827. (int)m_vopmd.vopPredType, m_tPastRef, m_vopmd.iSearchRangeForward);
  2829. for (Int iMBY = 0; iMBY < m_iNumMBY; iMBY++) {
  2830. for (Int iMBX = 0; iMBX < m_iNumMBX; iMBX++) {
  2831. fprintf(m_fMVFile,
  2832. "%3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3dn",
  2833. iMBX, iMBY, pmbmd->m_dctMd != INTRA,
  2834. 2*pmv[0].iMVX, 2*pmv[0].iMVY,
  2835. 2*pmv[5].iMVX, 2*pmv[5].iMVY,
  2836. 2*pmv[6].iMVX, 2*pmv[6].iMVY,
  2837. 2*pmv[7].iMVX, 2*pmv[7].iMVY,
  2838. 2*pmv[8].iMVX, 2*pmv[8].iMVY,
  2839. 2*pmv[1].iMVX, 2*pmv[1].iMVY,
  2840. 2*pmv[2].iMVX, 2*pmv[2].iMVY,
  2841. 2*pmv[3].iMVX, 2*pmv[3].iMVY,
  2842. 2*pmv[4].iMVX, 2*pmv[4].iMVY);
  2843. m_iMVLineNo++;
  2844. pmv += PVOP_MV_PER_REF_PER_MB;
  2845. pmbmd++;  // 04/28/99
  2846. }
  2847. }
  2848. }
  2850. Void CVideoObjectEncoder::readBVOPMVs()
  2851. {
  2852. Char line[150];
  2853. int pic, type, fref, bref, frad, brad;
  2854. CMotionVector* pmvf = m_rgmv;
  2855. CMotionVector* pmvb = m_rgmvBackward;
  2857. m_iMVLineNo++;
  2858. if (fgets(line, sizeof line, m_fMVFile) == NULL) {
  2859. fprintf(stderr, "EOF on %s at %dn", m_pchMVFileName, m_iMVLineNo);
  2860. exit(1);
  2861. }
  2862. if ((sscanf(line + 4, "%d %d %d %d %d %d",
  2863. &pic, &type, &fref, &bref, &frad, &brad) != 6) ||
  2864. (pic != m_t) ||
  2865. (type != m_vopmd.vopPredType) ||
  2866. (fref != m_tPastRef) ||
  2867. (bref != m_tFutureRef)) {
  2868. fprintf(stderr, "%s:%d MV read error: expected %c%d(%d,%d), got %c%d(%d.%d)n",
  2869. m_pchMVFileName, m_iMVLineNo,
  2870. "IPBS"[m_vopmd.vopPredType], m_t,
  2871. m_tPastRef, m_tFutureRef,
  2872. "IPBS"[type], pic, fref, bref);
  2873. exit(1);
  2874. }
  2875. if ((frad > m_vopmd.iSearchRangeForward) ||
  2876. (brad > m_vopmd.iSearchRangeBackward)) {
  2877. fprintf(stderr, "%s:%d(%c%d): MV file ME radii (%d,%d) exceed current range (%d,%d)n",
  2878. m_pchMVFileName, m_iMVLineNo, "IPBS"[type], pic, frad, brad,
  2879. m_vopmd.iSearchRangeForward, m_vopmd.iSearchRangeBackward);
  2880. exit(1);
  2881. }
  2882.     CRct clip = m_rctRefVOPY0; clip.expand(0, 0, -MB_SIZE, -MB_SIZE);
  2883.     CRct fball(-frad, -frad, frad, frad);
  2884.     CRct bball(-brad, -brad, brad, brad);
  2885. Int height = m_iNumMBY * MB_SIZE;
  2887. for (Int y = 0; y < height; y += MB_SIZE) {
  2888. for (Int x = 0; x < m_iVOPWidthY; x += MB_SIZE) {
  2889. m_iMVLineNo++;
  2890. if (fgets(line, sizeof line, m_fMVFile) == NULL) {
  2891. fprintf(stderr, "EOF on %s at %dn", m_pchMVFileName, m_iMVLineNo);
  2892. exit(1);
  2893. }
  2894. if (sscanf(line,
  2895. "%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d",
  2896. &pmvf[0].iMVX, &pmvf[0].iMVY,
  2897. &pmvf[1].iMVX, &pmvf[1].iMVY,
  2898. &pmvf[2].iMVX, &pmvf[2].iMVY,
  2899. &pmvf[3].iMVX, &pmvf[3].iMVY,
  2900. &pmvf[4].iMVX, &pmvf[4].iMVY,
  2901. &pmvb[0].iMVX, &pmvb[0].iMVY,
  2902. &pmvb[1].iMVX, &pmvb[1].iMVY,
  2903. &pmvb[2].iMVX, &pmvb[2].iMVY,
  2904. &pmvb[3].iMVX, &pmvb[3].iMVY,
  2905. &pmvb[4].iMVX, &pmvb[4].iMVY) != 20) {
  2906. fprintf(stderr, "%s: Read error on line %d: %sn",
  2907. m_pchMVFileName, m_iMVLineNo, line);
  2908. exit(1);
  2909. }
  2910. for (Int i = 0; i < BVOP_MV_PER_REF_PER_MB; i++) {
  2911. pmvf[i].iMVX >>= 1;
  2912. pmvf[i].iMVY >>= 1;
  2913.                 CRct bounds(clip);
  2914.                 bounds.shift(-x, -y);
  2915.                 bounds.clip(fball);
  2916.                 if (bounds.left   > pmvf[i].iMVX) pmvf[i].iMVX = bounds.left;
  2917.                 if (bounds.right  < pmvf[i].iMVX) pmvf[i].iMVX = bounds.right;
  2918.                 if (bounds.top    > pmvf[i].iMVY) pmvf[i].iMVY = bounds.top;
  2919.                 if (bounds.bottom < pmvf[i].iMVY) pmvf[i].iMVY = bounds.bottom;
  2920. pmvf[i].iHalfX = 0;
  2921. pmvf[i].iHalfY = 0;
  2922. pmvf[i].computeTrueMV();
  2923. pmvb[i].iMVX >>= 1;
  2924. pmvb[i].iMVY >>= 1;
  2925.                 bounds = clip;
  2926.                 bounds.shift(-x, -y);
  2927.                 bounds.clip(bball);
  2928.                 if (bounds.left   > pmvb[i].iMVX) pmvb[i].iMVX = bounds.left;
  2929.                 if (bounds.right  < pmvb[i].iMVX) pmvb[i].iMVX = bounds.right;
  2930.                 if (bounds.top    > pmvb[i].iMVY) pmvb[i].iMVY = bounds.top;
  2931.                 if (bounds.bottom < pmvb[i].iMVY) pmvb[i].iMVY = bounds.bottom;
  2932. pmvb[i].iHalfX = 0;
  2933. pmvb[i].iHalfY = 0;
  2934. pmvb[i].computeTrueMV();
  2935. }
  2936. pmvf += BVOP_MV_PER_REF_PER_MB;
  2937. pmvb += BVOP_MV_PER_REF_PER_MB;
  2938. }
  2939. }
  2940. }
  2942. Void CVideoObjectEncoder::writeBVOPMVs()
  2943. {
  2944. CMotionVector* pmvf = m_rgmv;
  2945. CMotionVector* pmvb = m_rgmvBackward;
  2946. //CMBMode* pmbmd = m_rgmbmd;
  2948. m_iMVLineNo++;
  2949. fprintf(m_fMVFile, "Pic %d %d %d %d %d %dn",
  2950. m_t, (int)m_vopmd.vopPredType, m_tPastRef, m_tFutureRef,
  2951. m_vopmd.iSearchRangeForward, m_vopmd.iSearchRangeBackward);
  2953. for (Int iMBY = 0; iMBY < m_iNumMBY; iMBY++) {
  2954. for (Int iMBX = 0; iMBX < m_iNumMBX; iMBX++) {
  2955. fprintf(m_fMVFile,
  2956. "%3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3dn",
  2957. 2*pmvf[0].iMVX, 2*pmvf[0].iMVY,
  2958. 2*pmvf[1].iMVX, 2*pmvf[1].iMVY,
  2959. 2*pmvf[2].iMVX, 2*pmvf[2].iMVY,
  2960. 2*pmvf[3].iMVX, 2*pmvf[3].iMVY,
  2961. 2*pmvf[4].iMVX, 2*pmvf[4].iMVY,
  2962. 2*pmvb[0].iMVX, 2*pmvb[0].iMVY,
  2963. 2*pmvb[1].iMVX, 2*pmvb[1].iMVY,
  2964. 2*pmvb[2].iMVX, 2*pmvb[2].iMVY,
  2965. 2*pmvb[3].iMVX, 2*pmvb[3].iMVY,
  2966. 2*pmvb[4].iMVX, 2*pmvb[4].iMVY);
  2967. pmvf += BVOP_MV_PER_REF_PER_MB;
  2968. pmvb += BVOP_MV_PER_REF_PER_MB;
  2969. }
  2970. }
  2971. }