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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

shpenc.cpp：源码内容
  1. /*************************************************************************
  3. This software module was originally developed by 
  5. Wei-ge Chen (wchen@microsoft.com), Microsoft Corporation
  6. (April, 1997)
  7. and edited by
  8.         Wei Wu (weiwu@stallion.risc.rockwell.com) Rockwell Science Center
  10. and also edited by
  11. Yoshihiro Kikuchi (TOSHIBA CORPORATION)
  12. Takeshi Nagai (TOSHIBA CORPORATION)
  13. Toshiaki Watanabe (TOSHIBA CORPORATION)
  14. Noboru Yamaguchi (TOSHIBA CORPORATION)
  16. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  17. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  18. as specified by the MPEG-4 Video. 
  19. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  20. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  21. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
  22. The original developer of this software module and his/her company, 
  23. the subsequent editors and their companies, 
  24. and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
  25. Copyright is not released for non MPEG-4 Video conforming products. 
  26. Microsoft retains full right to use the code for his/her own purpose, 
  27. assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
  28. This copyright notice must be included in all copies or derivative works. 
  30. Copyright (c) 1996, 1997.
  32. Module Name:
  34. shpenc.hpp
  36. Abstract:
  38. binary shape encoder with context-based arithmatic coder
  40. Revision History:
  42. *************************************************************************/
  44. #include "typeapi.h"
  45. #include "entropy/entropy.hpp"
  46. #include "entropy/huffman.hpp"
  47. #include "entropy/bitstrm.hpp"
  48. #include "global.hpp"
  49. #include "mode.hpp"
  50. #include "codehead.h"
  51. #include "cae.h"
  52. #include "vopses.hpp"
  53. #include "vopseenc.hpp"
  56. #ifdef __MFC_
  57. #ifdef _DEBUG
  58. #undef THIS_FILE
  59. static char BASED_CODE THIS_FILE[] = __FILE__;
  60. #endif
  62. #define new DEBUG_NEW    
  63. #endif // __MFC_
  65. Int CVideoObjectEncoder::codeIntraShape (PixelC* ppxlcSrcFrm, CMBMode* pmbmd, Int iMBX, Int iMBY)
  66. {
  67. m_iInverseCR = 1;
  68. m_iWidthCurrBAB = BAB_SIZE;
  70. #ifdef __TRACE_AND_STATS_
  72. if(pmbmd->m_rgTranspStatus [0] == NONE)
  73. m_pbitstrmOut->trace ("ORIGINAL BAB IS ALL OPAQUE");
  74. else if(pmbmd->m_rgTranspStatus [0] == ALL)
  75. m_pbitstrmOut->trace ("ORIGINAL BAB IS ALL TRANSP");
  76. else
  77. m_pbitstrmOut->trace (m_ppxlcCurrMBBY, MB_SIZE, MB_SIZE, "ORIGINAL_BAB");
  78. #endif // __TRACE_AND_STATS_
  80. Int iMBnum = VPMBnum(iMBX, iMBY);
  81. m_bVPNoLeft = bVPNoLeft(iMBnum, iMBX);
  82. m_bVPNoTop = bVPNoTop(iMBnum);
  83. m_bVPNoRightTop = bVPNoRightTop(iMBnum, iMBX);
  84. m_bVPNoLeftTop = bVPNoLeftTop(iMBnum, iMBX);
  86. if (pmbmd->m_rgTranspStatus [0] == NONE)
  87. pmbmd->m_shpmd = ALL_OPAQUE;
  88. else if (pmbmd->m_rgTranspStatus [0] == ALL)
  89. pmbmd->m_shpmd = ALL_TRANSP;
  90. else if (!isErrorLarge (m_ppxlcCurrMBBY, m_rgiSubBlkIndx16x16, 16, MPEG4_TRANSPARENT, pmbmd))
  91. {
  92. pmbmd->m_shpmd = ALL_TRANSP;
  93. if ( !isErrorLarge (m_ppxlcCurrMBBY, m_rgiSubBlkIndx16x16, 16, MPEG4_OPAQUE, pmbmd))
  94. {
  95. // both opaque and transparent are good, so count pixels to decide
  96. Int i,iSum=0;
  97. for(i=0;i<MB_SQUARE_SIZE;i++)
  98. iSum+=(m_ppxlcCurrMBBY[i]>0);
  99. if(iSum>=(MB_SQUARE_SIZE>>1))
  100. pmbmd->m_shpmd = ALL_OPAQUE;
  101. }
  102. }
  103. else if (!isErrorLarge (m_ppxlcCurrMBBY, m_rgiSubBlkIndx16x16, 16, MPEG4_OPAQUE, pmbmd))
  104. pmbmd->m_shpmd = ALL_OPAQUE;
  105. else
  106. pmbmd->m_shpmd = round (ppxlcSrcFrm, pmbmd);
  108. if(pmbmd->m_shpmd==ALL_TRANSP)
  109. {
  110. #ifdef __TRACE_AND_STATS_
  111. m_pbitstrmOut->trace ("MB_ALL_TRANSP");
  112. #endif // __TRACE_AND_STATS_
  113. copyReconShapeToMbAndRef (m_ppxlcCurrMBBY, ppxlcSrcFrm, MPEG4_TRANSPARENT);
  114. return codeShapeModeIntra (ALL_TRANSP, pmbmd, iMBX, iMBY);
  115. }
  116. else if(pmbmd->m_shpmd==ALL_OPAQUE)
  117. {
  118. #ifdef __TRACE_AND_STATS_
  119. m_pbitstrmOut->trace ("MB_ALL_OPAQUE");
  120. #endif // __TRACE_AND_STATS_
  121. copyReconShapeToMbAndRef (m_ppxlcCurrMBBY, ppxlcSrcFrm, MPEG4_OPAQUE);
  122. return codeShapeModeIntra (ALL_OPAQUE, pmbmd, iMBX, iMBY);
  123. }
  124. else
  125. {
  126. // intra CAE
  127. assert(pmbmd->m_shpmd == INTRA_CAE);
  128. #ifdef __TRACE_AND_STATS_
  129. m_pbitstrmOut->trace (m_ppxlcReconCurrBAB, TOTAL_BAB_SIZE, TOTAL_BAB_SIZE, "MB_RECON_BAB (Ignore border)");
  130. m_pbitstrmOut->trace (m_rgpxlcCaeSymbol, m_iWidthCurrBAB , m_iWidthCurrBAB , "MB_ENCODED_BAB");
  131. #endif // __TRACE_AND_STATS_
  133. if (m_bNoShapeChg) //must be partial
  134. copyReconShapeToRef (ppxlcSrcFrm, m_ppxlcReconCurrBAB, TOTAL_BAB_SIZE, BAB_BORDER);
  135. else
  136. copyReconShapeToMbAndRef (m_ppxlcCurrMBBY, ppxlcSrcFrm, m_ppxlcReconCurrBAB, TOTAL_BAB_SIZE, BAB_BORDER);
  137. UInt nBitsMode = codeShapeModeIntra (INTRA_CAE, pmbmd, iMBX, iMBY);
  138. m_pbitstrmShapeMBOut->setBookmark ();
  139. UInt nBitsV = encodeCAEIntra (INTRA_CAE, VERTICAL);
  140. m_pbitstrmShapeMBOut->gotoBookmark ();
  141. UInt nBitsH = encodeCAEIntra (INTRA_CAE, HORIZONTAL);
  143. if (nBitsV < nBitsH)
  144. {
  145. m_pbitstrmShapeMBOut->gotoBookmark ();
  146. nBitsV = encodeCAEIntra (INTRA_CAE, VERTICAL);
  147. return nBitsV+nBitsMode;
  148. }
  149. else
  150. return nBitsH+nBitsMode;
  151. }
  152. }
  154. Int CVideoObjectEncoder::codeInterShape (PixelC* ppxlcSrcFrm,
  155.  CVOPU8YUVBA* pvopcRefQ,
  156.  CMBMode* pmbmd, 
  157.  const ShapeMode& shpmdColocatedMB,
  158.  const CMotionVector* pmv, 
  159.  CMotionVector* pmvBY, 
  160.  CoordI iX, CoordI iY, 
  161.  Int iMBX, Int iMBY)
  162. {
  163. m_iInverseCR = 1;
  164. m_iWidthCurrBAB = BAB_SIZE;
  165. pmbmd->m_shpmd = UNKNOWN;
  166. CMotionVector mvBYD (0, 0);
  167. CMotionVector mvShapeMVP;
  169. #ifdef __TRACE_AND_STATS_
  170. if(pmbmd->m_rgTranspStatus [0] == NONE)
  171. m_pbitstrmOut->trace ("ORIGINAL BAB IS ALL OPAQUE");
  172. else if(pmbmd->m_rgTranspStatus [0] == ALL)
  173. m_pbitstrmOut->trace ("ORIGINAL BAB IS ALL TRANSP");
  174. else
  175. m_pbitstrmOut->trace (m_ppxlcCurrMBBY, MB_SIZE, MB_SIZE, "ORIGINAL_BAB");
  176. #endif // __TRACE_AND_STATS_
  178. Int iMBnum = VPMBnum(iMBX, iMBY);
  179. m_bVPNoLeft = bVPNoLeft(iMBnum, iMBX);
  180. m_bVPNoTop = bVPNoTop(iMBnum);
  181. m_bVPNoRightTop = bVPNoRightTop(iMBnum, iMBX);
  182. m_bVPNoLeftTop = bVPNoLeftTop(iMBnum, iMBX);
  184. if (pmbmd->m_rgTranspStatus [0] == ALL)
  185. pmbmd->m_shpmd = ALL_TRANSP;
  186. else if (!isErrorLarge (m_ppxlcCurrMBBY, m_rgiSubBlkIndx16x16, 16, MPEG4_TRANSPARENT, pmbmd))
  187. {
  188. pmbmd->m_shpmd = ALL_TRANSP;
  189. if ( !isErrorLarge (m_ppxlcCurrMBBY, m_rgiSubBlkIndx16x16, 16, MPEG4_OPAQUE, pmbmd))
  190. {
  191. // both opaque and transparent are good, so count pixels to decide
  192. Int i,iSum=0;
  193. for(i=0;i<MB_SQUARE_SIZE;i++)
  194. iSum+=(m_ppxlcCurrMBBY[i]>0);
  195. if(iSum>=(MB_SQUARE_SIZE>>1))
  196. pmbmd->m_shpmd = ALL_OPAQUE;
  197. }
  198. }
  199. else if(pmbmd->m_rgTranspStatus [0] == NONE)
  200. pmbmd->m_shpmd = ALL_OPAQUE;
  201. else if(!isErrorLarge (m_ppxlcCurrMBBY, m_rgiSubBlkIndx16x16, 16, MPEG4_OPAQUE, pmbmd))
  202. pmbmd->m_shpmd = ALL_OPAQUE;
  204. if(pmbmd->m_shpmd!=ALL_TRANSP)
  205. {
  206. // find motion vectors
  207. mvShapeMVP = findShapeMVP (pmv, pmvBY, pmbmd, iMBX, iMBY);
  208. assert (mvShapeMVP.iMVX != NOT_MV && mvShapeMVP.iMVY != NOT_MV);
  209. // mvShapeMVP = CMotionVector ((mvShapeMVP.iMVX * 2 + mvShapeMVP.iHalfX) / 2,  //rounding
  210. // (mvShapeMVP.iMVY * 2 + mvShapeMVP.iHalfY) / 2);
  211. motionCompBY ((PixelC*) m_puciPredBAB->pixels (),
  212.   (PixelC*) pvopcRefQ->getPlane (BY_PLANE)->pixels (),
  213.   mvShapeMVP.iMVX + iX - 1,
  214.   mvShapeMVP.iMVY + iY - 1); //-1 due to 18x18 motion comp
  215. if (!isErrorLarge (m_ppxlcCurrMBBY, m_rgiSubBlkIndx16x16, 16,
  216.   m_puciPredBAB->pixels (), m_rgiSubBlkIndx18x18, 18, pmbmd))
  217. // zero mvd is ok
  218. *pmvBY = mvShapeMVP;
  219. else
  220. {
  221. // do block matching
  222. CMotionVector mvShape;
  223. blkmatchForShape (pvopcRefQ,&mvShape, mvShapeMVP.trueMVHalfPel (), iX, iY);
  224. assert (mvShape.iMVX != NOT_MV && mvShape.iMVY != NOT_MV);
  225. *pmvBY = mvShape;
  226. mvBYD = mvShape - mvShapeMVP;
  227. motionCompBY ((PixelC*) m_puciPredBAB->pixels (),
  228.   (PixelC*) pvopcRefQ->getPlane (BY_PLANE)->pixels (),
  229.   mvShape.iMVX + iX - 1,
  230.   mvShape.iMVY + iY - 1); //-1 due to 18x18 motion comp
  231. }
  233. // check status of motion compensated prediction BAB
  234. PixelC *ppxlcPredBAB = (PixelC *)m_puciPredBAB->pixels()+MC_BAB_SIZE*MC_BAB_BORDER;
  235. Int iXX,iYY,iOpaqueCount = 0;
  236. for(iYY=MC_BAB_BORDER;iYY<MC_BAB_SIZE-MC_BAB_BORDER;iYY++,ppxlcPredBAB+=MC_BAB_SIZE)
  237. for(iXX=MC_BAB_BORDER;iXX<MC_BAB_SIZE-MC_BAB_BORDER;iXX++)
  238. if(ppxlcPredBAB[iXX] == opaqueValue)
  239. iOpaqueCount++;
  241. if(iOpaqueCount==0 || isErrorLarge (m_ppxlcCurrMBBY, m_rgiSubBlkIndx16x16, 16,
  242. m_puciPredBAB->pixels (), m_rgiSubBlkIndx18x18, 18, pmbmd))
  243. {
  244. // MC BAB is all transparent or not acceptable, so code.
  245. round(ppxlcSrcFrm, pmbmd);
  246. if(mvBYD.isZero())
  247. pmbmd->m_shpmd = INTER_CAE_MVDZ;
  248. else
  249. pmbmd->m_shpmd = INTER_CAE_MVDNZ;
  250. }
  251. else if(pmbmd->m_shpmd==ALL_OPAQUE && !mvBYD.isZero())
  252. ;
  253. else if(pmbmd->m_rgTranspStatus[0] == NONE && iOpaqueCount!=MB_SQUARE_SIZE)
  254. pmbmd->m_shpmd=ALL_OPAQUE;
  255. else if(mvBYD.isZero())
  256. pmbmd->m_shpmd = MVDZ_NOUPDT;
  257. else
  258. pmbmd->m_shpmd = MVDNZ_NOUPDT;
  259. }
  261. switch(pmbmd->m_shpmd)
  262. {
  263. case ALL_OPAQUE:
  264. #ifdef __TRACE_AND_STATS_
  265. m_pbitstrmOut->trace ("MB_ALL_OPAQUE");
  266. #endif // __TRACE_AND_STATS_
  267. pmvBY->iMVX = NOT_MV;
  268. pmvBY->iMVY = NOT_MV;
  269. copyReconShapeToMbAndRef (m_ppxlcCurrMBBY, ppxlcSrcFrm, MPEG4_OPAQUE);
  270. return (codeShapeModeInter (ALL_OPAQUE, shpmdColocatedMB));
  272. case ALL_TRANSP:
  273. #ifdef __TRACE_AND_STATS_
  274. m_pbitstrmOut->trace ("MB_ALL_TRANSP");
  275. #endif // __TRACE_AND_STATS_
  276. pmvBY->iMVX = NOT_MV;
  277. pmvBY->iMVY = NOT_MV;
  278. copyReconShapeToMbAndRef (m_ppxlcCurrMBBY, ppxlcSrcFrm, MPEG4_TRANSPARENT);
  279. return (codeShapeModeInter (ALL_TRANSP, shpmdColocatedMB));
  281. case INTER_CAE_MVDZ:
  282. case INTER_CAE_MVDNZ:
  283. {
  284. if (m_bNoShapeChg)
  285. copyReconShapeToRef (ppxlcSrcFrm, m_ppxlcReconCurrBAB, TOTAL_BAB_SIZE, BAB_BORDER);
  286. else
  287. copyReconShapeToMbAndRef (m_ppxlcCurrMBBY, ppxlcSrcFrm, m_ppxlcReconCurrBAB, TOTAL_BAB_SIZE, BAB_BORDER);
  288. #ifdef __TRACE_AND_STATS_
  289. m_pbitstrmOut->trace ((PixelC *)m_puciPredBAB->pixels(), MC_BAB_SIZE, MC_BAB_SIZE, "MB_MC_PRED_BAB");
  290. m_pbitstrmOut->trace (m_ppxlcReconCurrBAB, TOTAL_BAB_SIZE, TOTAL_BAB_SIZE, "MB_RECON_BAB (Ignore Borders)");
  291. m_pbitstrmOut->trace (m_rgpxlcCaeSymbol, m_iWidthCurrBAB , m_iWidthCurrBAB , "MB_ENCODED_BAB");
  292. #endif // __TRACE_AND_STATS_
  294. m_pbitstrmShapeMBOut->setBookmark ();
  296. // try intra
  297. UInt nBitsModeIntra = codeShapeModeInter (INTRA_CAE, shpmdColocatedMB);
  298. #ifdef __TRACE_AND_STATS_
  299. m_pbitstrmOut->trace ("MB_CAE_INTRA_HORIZONTAL_CODING (TRIAL)");
  300. #endif // __TRACE_AND_STATS_
  301. UInt nBitsHIntra = encodeCAEIntra (INTRA_CAE, HORIZONTAL);
  302. #ifdef __TRACE_AND_STATS_
  303. m_pbitstrmOut->trace ("MB_CAE_INTRA_VERTICAL_CODING (TRIAL)");
  304. #endif // __TRACE_AND_STATS_
  305. UInt nBitsVIntra = encodeCAEIntra (INTRA_CAE, VERTICAL);
  306. UInt nBitsIntra = nBitsModeIntra + min (nBitsVIntra, nBitsHIntra);
  308. // try inter
  309. UInt nBitsMV=0;
  310. UInt nBitsModeInter = codeShapeModeInter (pmbmd->m_shpmd, shpmdColocatedMB);
  311. if(pmbmd->m_shpmd==INTER_CAE_MVDNZ)
  312. nBitsMV = encodeMVDS (mvBYD);
  313. #ifdef __TRACE_AND_STATS_
  314. m_pbitstrmOut->trace ("MB_CAE_INTER_VERTICAL_CODING (TRIAL)");
  315. #endif // __TRACE_AND_STATS_
  316. UInt nBitsVInter = encodeCAEInter (pmbmd->m_shpmd, VERTICAL);
  317. #ifdef __TRACE_AND_STATS_
  318. m_pbitstrmOut->trace ("MB_CAE_INTER_HORIZONTAL_CODING (TRIAL)");
  319. #endif // __TRACE_AND_STATS_
  320. UInt nBitsHInter = encodeCAEInter (pmbmd->m_shpmd, HORIZONTAL);
  321. UInt nBitsInter = nBitsModeInter + nBitsMV + min (nBitsVInter, nBitsHInter);
  323. m_pbitstrmShapeMBOut->gotoBookmark ();
  325. if (nBitsInter < nBitsIntra)
  326. {
  327. // choose inter coding
  328. #ifdef __TRACE_AND_STATS_
  329. m_pbitstrmOut->trace ("MB_CAE_INTER_CODING (REAL)");
  330. m_pbitstrmOut->trace (mvShapeMVP, "MB_SHP_MV_PRED (half pel)");
  331. m_pbitstrmOut->trace (*pmvBY, "MB_SHP_MV (half pel)");
  332. m_pbitstrmOut->trace (mvBYD, "MB_SHP_MVD (half pel)");
  333. #endif // __TRACE_AND_STATS_
  334. codeShapeModeInter (pmbmd->m_shpmd, shpmdColocatedMB);
  335. if(pmbmd->m_shpmd==INTER_CAE_MVDNZ)
  336. encodeMVDS (mvBYD);
  337. if(nBitsVInter<nBitsHInter)
  338. encodeCAEInter (pmbmd->m_shpmd, VERTICAL);
  339. else
  340. encodeCAEInter (pmbmd->m_shpmd, HORIZONTAL);
  341. return nBitsInter;
  342. }
  343. else
  344. {
  345. // choose intra coding
  346. #ifdef __TRACE_AND_STATS_
  347. m_pbitstrmOut->trace ("MB_CAE_INTRA_CODING (REAL)");
  348. #endif // __TRACE_AND_STATS_
  349. pmvBY->iMVX = NOT_MV;
  350. pmvBY->iMVY = NOT_MV;
  351. pmbmd->m_shpmd = INTRA_CAE;
  352. codeShapeModeInter (pmbmd->m_shpmd, shpmdColocatedMB);
  353. if(nBitsVIntra<nBitsHIntra)
  354. encodeCAEIntra (pmbmd->m_shpmd, VERTICAL);
  355. else
  356. encodeCAEIntra (pmbmd->m_shpmd, HORIZONTAL);
  357. return nBitsIntra;
  358. }
  359. }
  360. case MVDZ_NOUPDT:
  361. case MVDNZ_NOUPDT:
  362. {
  363. #ifdef __TRACE_AND_STATS_
  364. m_pbitstrmOut->trace ("MB_CAE_INTER_CODING_NO_UPDATE");
  365. m_pbitstrmOut->trace (mvShapeMVP, "MB_SHP_MV_PRED (half pel)");
  366. m_pbitstrmOut->trace (*pmvBY, "MB_SHP_MV (half pel)");
  367. m_pbitstrmOut->trace (mvBYD, "MB_SHP_MVD (half pel)");
  368. #endif // __TRACE_AND_STATS_
  369. copyReconShapeToMbAndRef (m_ppxlcCurrMBBY, ppxlcSrcFrm, m_puciPredBAB->pixels (), MC_BAB_SIZE, MC_BAB_BORDER);
  370. #ifdef __TRACE_AND_STATS_
  371. m_pbitstrmOut->trace ((PixelC *)m_puciPredBAB->pixels(), MC_BAB_SIZE, MC_BAB_SIZE, "MB_MC_PRED_BAB");
  372. #endif // __TRACE_AND_STATS_
  373. Int nBits = codeShapeModeInter (pmbmd->m_shpmd, shpmdColocatedMB);
  374. if(pmbmd->m_shpmd==MVDNZ_NOUPDT)
  375. nBits += encodeMVDS (mvBYD);
  376. return nBits;
  377. }
  378. default:
  379. assert(FALSE);
  380. return 0;
  381. }
  382. }
  384. UInt CVideoObjectEncoder::codeShapeModeIntra (ShapeMode shpmd, const CMBMode* pmbmd, Int iMBX, Int iMBY)
  385. {
  386. UInt nBits = 0;
  387. assert (shpmd == ALL_TRANSP || shpmd == ALL_OPAQUE || shpmd == INTRA_CAE);
  389. //static Int iLeftTopMostMB = 0;
  390. //Int iRightMostMB = m_iNumMBX - 1;
  392. //get previous shape codes; 
  393. Bool bLeftBndry, bRightTopBndry, bTopBndry, bLeftTopBndry;
  394. Int iMBnum = VPMBnum(iMBX, iMBY);
  395. bLeftBndry = bVPNoLeft(iMBnum, iMBX);
  396. bTopBndry = bVPNoTop(iMBnum);
  397. bRightTopBndry = bVPNoRightTop(iMBnum, iMBX);
  398. bLeftTopBndry = bVPNoLeftTop(iMBnum, iMBX);
  400. ShapeMode shpmdTop = ALL_TRANSP;
  401. ShapeMode shpmdTopRight = ALL_TRANSP;
  402. ShapeMode shpmdTopLeft = ALL_TRANSP;
  403. ShapeMode shpmdLeft = ALL_TRANSP;
  404. // Modified for error resilient mode by Toshiba(1997-11-14)
  405. if (!bTopBndry)
  406. shpmdTop = (pmbmd - m_iNumMBX)->m_shpmd;
  407. if (!bRightTopBndry)
  408. shpmdTopRight = (pmbmd - m_iNumMBX + 1)->m_shpmd;
  409. if (!bLeftBndry)
  410. shpmdLeft = (pmbmd - 1)->m_shpmd;
  411. if (!bLeftTopBndry)
  412. shpmdTopLeft = (pmbmd - m_iNumMBX - 1)->m_shpmd;
  413. //if (iMBY > iLeftTopMostMB) {
  414. // shpmdTop = (pmbmd - m_iNumMBX)->m_shpmd;
  415. // if (iMBX < iRightMostMB)
  416. // shpmdTopRight = (pmbmd - m_iNumMBX + 1)->m_shpmd;
  417. //}
  418. //if (iMBX > iLeftTopMostMB) {
  419. // shpmdLeft = (pmbmd - 1)->m_shpmd;
  420. // if (iMBY > iLeftTopMostMB)
  421. // shpmdTopLeft = (pmbmd - m_iNumMBX - 1)->m_shpmd;
  422. //}
  423. // End Toshiba(1997-11-14)
  424. assert (shpmdTop != UNKNOWN && shpmdTopRight != UNKNOWN && 
  425. shpmdTopLeft != UNKNOWN && shpmdLeft != UNKNOWN);
  426. //get code and its size
  427. UInt uiTblIndex = shpmdTopLeft * 81 +  shpmdTop * 27 +
  428.   shpmdTopRight * 9 + shpmdLeft * 3 + shpmd;
  429. assert (uiTblIndex >= 0 && uiTblIndex < 243);
  430. assert (grgchFirstShpCd [uiTblIndex] == 0 || grgchFirstShpCd [uiTblIndex] == 2 || 
  431. grgchFirstShpCd [uiTblIndex] == 3);
  432. // Modified for error resilient mode by Toshiba(1997-11-14)
  433. UInt nCodeSize = (grgchFirstShpCd [uiTblIndex] == 0) ? 1
  434.  : grgchFirstShpCd [uiTblIndex];
  435. #ifdef __TRACE_AND_STATS_
  436. m_pbitstrmOut->trace ((Int) shpmd, "MB_Curr_ShpMd");
  437. #endif // __TRACE_AND_STATS_
  438. m_pbitstrmShapeMBOut->putBits ((Int) 1, nCodeSize, "MB_Shape_Mode");
  439. // End Toshiba(1997-11-14)
  440. nBits += nCodeSize;
  441. return nBits;
  442. }
  444. UInt CVideoObjectEncoder::codeShapeModeInter (const ShapeMode& shpmd, const ShapeMode& shpmdColocatedMB)
  445. {
  446. assert (shpmdColocatedMB != UNKNOWN && shpmd != UNKNOWN);
  447. UInt nBits = 0;
  448. CEntropyEncoder* pentrenc = m_pentrencSet->m_ppentrencShapeMode [shpmdColocatedMB];
  449. #ifdef __TRACE_AND_STATS_
  450. m_pbitstrmOut->trace ((Int) shpmdColocatedMB, "MB_Colocated_ShpMd");
  451. m_pbitstrmOut->trace ((Int) shpmd, "MB_Curr_ShpMd");
  452. #endif // __TRACE_AND_STATS_
  453. pentrenc->attachStream(*m_pbitstrmShapeMBOut);
  454. nBits += pentrenc->encodeSymbol (shpmd, "MB_Shape_Mode");
  455. pentrenc->attachStream(*m_pbitstrmOut);
  456. return nBits;
  457. }
  459. // find appropriate size for coded babs
  460. ShapeMode CVideoObjectEncoder::round (PixelC* ppxlcSrcFrm, const CMBMode* pmbmd) //only to partial BABs
  461. {
  462. ShapeMode shpmd;
  463. Bool bIsErrorLarge;
  465. if (m_volmd.bNoCrChange == FALSE)
  466. {
  467. // attempt to reduce bab size
  468. m_bNoShapeChg = FALSE;
  469. #define iThreshD4  (7 * MPEG4_OPAQUE)
  471. // reduce by factor 4
  472. downSampleShape (m_ppxlcCurrMBBY, 
  473.    m_rgiSubBlkIndx16x16,
  474.    m_ppxlcCurrMBBYDown4, 
  475.    m_rgiPxlIndx8x8,
  476.    4, iThreshD4, 16);
  478. // see if this size is acceptable
  479. shpmd = INTRA_CAE;
  480. m_iInverseCR = 4;
  481. m_iWidthCurrBAB = 8;
  483. // subsample border before upsample to original size
  484. subsampleLeftTopBorderFromVOP (ppxlcSrcFrm, m_ppxlcCurrMBBYDown4);
  485. makeRightBottomBorder (m_ppxlcCurrMBBYDown4, 8);
  486. upSampleShape(ppxlcSrcFrm,m_ppxlcCurrMBBYDown4,m_ppxlcReconCurrBAB);
  488. // check if approximation is acceptable
  489. bIsErrorLarge = isErrorLarge (m_ppxlcCurrMBBY, m_rgiSubBlkIndx16x16, 16,
  490. m_ppxlcReconCurrBAB, m_rgiSubBlkIndx20x20, 20, pmbmd);
  491. if(!bIsErrorLarge)
  492. {
  493. // ok, so assign encoding buffer
  494. m_rgpxlcCaeSymbol = m_ppxlcCurrMBBYDown4; 
  495. return shpmd;
  496. }
  498. #define iThreshD2 (MPEG4_OPAQUE)
  500. // factor 4 failed, so try to reduce by factor 2
  501. downSampleShape (m_ppxlcCurrMBBY, 
  502.    m_rgiSSubBlkIndx16x16,
  503.    m_ppxlcCurrMBBYDown2, 
  504.    m_rgiPxlIndx12x12,
  505.    2, iThreshD2, 64);
  507. // mixed, so see if this size is acceptable
  508. shpmd = INTRA_CAE;
  509. m_iInverseCR = 2;
  510. m_iWidthCurrBAB = 12;
  512. // subsample border before upsample to original size
  513. subsampleLeftTopBorderFromVOP (ppxlcSrcFrm, m_ppxlcCurrMBBYDown2);
  514. makeRightBottomBorder (m_ppxlcCurrMBBYDown2, 12);
  515. upSampleShape(ppxlcSrcFrm,m_ppxlcCurrMBBYDown2, m_ppxlcReconCurrBAB);
  517. // check if approximation is acceptable
  518. bIsErrorLarge = isErrorLarge (m_ppxlcCurrMBBY, m_rgiSubBlkIndx16x16, 16,
  519. m_ppxlcReconCurrBAB, m_rgiSubBlkIndx20x20, 20, pmbmd);
  520. if(!bIsErrorLarge)
  521. {
  522. // ok, so assign encoding buffer
  523. m_rgpxlcCaeSymbol = m_ppxlcCurrMBBYDown2; 
  524. return shpmd;
  525. }
  526. }
  528. // has to be original size
  529. m_bNoShapeChg = TRUE;
  530. shpmd = INTRA_CAE;
  531. m_iInverseCR = 1;
  532. m_iWidthCurrBAB = BAB_SIZE;
  534. // copy data to ReconCurrBAB
  535. PixelC* ppxlcDst = m_ppxlcReconCurrBAB + BAB_BORDER + BAB_BORDER * TOTAL_BAB_SIZE;
  536. PixelC* ppxlcSrc = m_ppxlcCurrMBBY;
  537. Int iUnit = sizeof(PixelC); // NBIT: for memcpy
  538. Int i;
  539. for (i = 0; i < MB_SIZE; i++) {
  540. memcpy (ppxlcDst, ppxlcSrc, MB_SIZE*iUnit);
  541. ppxlcSrc += MB_SIZE;
  542. ppxlcDst += BAB_SIZE;
  543. }
  545. // make borders
  546. copyLeftTopBorderFromVOP (ppxlcSrcFrm, m_ppxlcReconCurrBAB);
  547. makeRightBottomBorder (m_ppxlcReconCurrBAB, TOTAL_BAB_SIZE);
  549. // assign encoding buffer
  550. m_rgpxlcCaeSymbol = m_ppxlcReconCurrBAB;
  551. return shpmd;
  552. }
  555. Int CVideoObjectEncoder::downSampleShape (const PixelC* ppxlcSrc, 
  556.    Int* rgiSrcSubBlk,
  557.    PixelC* ppxlcDst, 
  558.    Int* piDstPxl, 
  559.    Int iRate,
  560.    Int iThreshold,
  561.    Int nSubBlk)
  562. {
  563. Int nOpaquePixel = 0, iSum = 0;
  564. Int iSubBlk;
  565. for (iSubBlk = 0; iSubBlk < nSubBlk; iSubBlk++) {
  566. Int i = rgiSrcSubBlk [iSubBlk];
  567. iSum = 0;
  568. for (CoordI iY = 0; iY < iRate; iY++) {
  569. for (CoordI iX = 0; iX < iRate; iX++)  {
  570. iSum += abs (ppxlcSrc [i++]);  //abs???
  571. }
  572. i += MB_SIZE - iRate;
  573. }
  574. ppxlcDst [*piDstPxl] = (iSum > iThreshold) ? MPEG4_OPAQUE : MPEG4_TRANSPARENT;
  575. nOpaquePixel += ppxlcDst [*piDstPxl];
  576. piDstPxl++;
  577. }
  578. return (nOpaquePixel /= MPEG4_OPAQUE);
  579. }
  581. Bool CVideoObjectEncoder::isErrorLarge (const PixelC* rgppxlcSrc, const Int* rgiSubBlkIndx, Int iWidthSrc, PixelC pxlcRecon, const CMBMode* pmbmd)
  582. {
  583. if (pmbmd->m_bhas4MVForward == TRUE) {
  584. if (!sameBlockTranspStatus (pmbmd, pxlcRecon))
  585. return TRUE;
  586. } 
  588. //check error in each 4x4 subblock
  589. Int iSubBlk;
  590. Int iError = 0;
  591. for (iSubBlk = 0; iSubBlk < 16; iSubBlk++) {
  592. Int i = rgiSubBlkIndx [iSubBlk];
  593. for (CoordI iY = 0; iY < 4; iY++) {
  594. for (CoordI iX = 0; iX < 4; iX++)  {
  595. iError += abs (rgppxlcSrc [i++] - pxlcRecon);
  596. }
  597. if (iError > m_volmd.iBinaryAlphaTH) 
  598. return TRUE;
  599. i += iWidthSrc - 4;
  600. }
  601. }
  602. return FALSE;
  603. }
  605. Bool CVideoObjectEncoder::isErrorLarge (const PixelC* rgppxlcSrc, const Int* rgiSubBlkIndxSrc, const Int iSizeSrc,
  606. const PixelC* rgppxlcDst, const Int* rgiSubBlkIndxDst, const Int iSizeDst, const CMBMode* pmbmd)
  607. {
  608. if (pmbmd->m_bhas4MVForward == TRUE) {
  609. if (!sameBlockTranspStatus (pmbmd, rgppxlcDst, iSizeDst))
  610. return TRUE;
  611. } 
  613. //check error in each 4x4 subblock
  614. Int iSubBlk;
  615. Int iError = 0;
  616. for (iSubBlk = 0; iSubBlk < 16; iSubBlk++) {
  617. Int iSrc = rgiSubBlkIndxSrc [iSubBlk];
  618. Int iDst = rgiSubBlkIndxDst [iSubBlk];
  619. for (CoordI iY = 0; iY < 4; iY++) {
  620. for (CoordI iX = 0; iX < 4; iX++)  {
  621. iError += abs (rgppxlcSrc [iSrc] - rgppxlcDst [iDst]);
  622. iSrc++;
  623. iDst++;
  624. }
  625. if (iError > m_volmd.iBinaryAlphaTH)
  626. return TRUE;
  627. iSrc += iSizeSrc - 4;
  628. iDst += iSizeDst - 4;
  629. }
  630. }
  631. return FALSE;
  632. }
  634. UInt CVideoObjectEncoder::encodeCAEIntra (ShapeMode shpmd, CAEScanDirection shpdir)
  635. {
  636. assert (shpmd == INTRA_CAE);
  637. // m_pbitstrmOut->trace (m_rgiCurrShp, TOTAL_BAB_SQUARE_SIZE, "MB_BAB");
  638. UInt nBits = 0;
  639. nBits += codeCrAndSt (shpdir, m_iInverseCR);
  640. //the real arithmatic encoding
  641. StartArCoder (m_parcodec);
  642. if (shpdir == HORIZONTAL) {
  643. const PixelC* ppxlcSrcRow = m_rgpxlcCaeSymbol + m_iWidthCurrBAB * BAB_BORDER + BAB_BORDER;
  644. for (Int iRow = BAB_BORDER; iRow < m_iWidthCurrBAB - BAB_BORDER; iRow++) {
  645. const PixelC* ppxlcSrc = ppxlcSrcRow;
  646. for (Int iCol = BAB_BORDER; iCol < m_iWidthCurrBAB - BAB_BORDER; iCol++) {
  647. Int iContext = contextIntra (ppxlcSrc);
  648. #ifdef __TRACE_AND_STATS_
  649. // m_pbitstrmOut->trace (iContext, "MB_CAE_Context");
  650. #endif // __TRACE_AND_STATS_
  651. ArCodeSymbol ((*ppxlcSrc == MPEG4_OPAQUE), gCAEintraProb [iContext], m_parcodec, m_pbitstrmShapeMBOut);
  652. ppxlcSrc++;
  653. }
  654. ppxlcSrcRow += m_iWidthCurrBAB;
  655. }
  656. }
  657. else {
  658. const PixelC* ppxlcSrcCol = m_rgpxlcCaeSymbol + m_iWidthCurrBAB * BAB_BORDER + BAB_BORDER;
  659. for (Int iCol = BAB_BORDER; iCol < m_iWidthCurrBAB - BAB_BORDER; iCol++) {
  660. const PixelC* ppxlcSrc = ppxlcSrcCol;
  661. for (Int iRow = BAB_BORDER; iRow < m_iWidthCurrBAB - BAB_BORDER; iRow++) {
  662. Int iContext = contextIntraTranspose (ppxlcSrc);
  663. #ifdef __TRACE_AND_STATS_
  664. //m_pbitstrmOut->trace (iContext, "MB_CAE_Context");
  665. #endif // __TRACE_AND_STATS_
  666. ArCodeSymbol ((*ppxlcSrc == MPEG4_OPAQUE), gCAEintraProb [iContext], m_parcodec, m_pbitstrmShapeMBOut);
  667. ppxlcSrc += m_iWidthCurrBAB ;
  668. }
  669. ppxlcSrcCol++;
  670. }
  671. }
  672. StopArCoder (m_parcodec, m_pbitstrmShapeMBOut);
  673. nBits += m_parcodec->nBits;
  674. return nBits;
  675. }
  677. UInt CVideoObjectEncoder::encodeCAEInter (ShapeMode shpmd, CAEScanDirection shpdir)
  678. {
  679. assert (shpmd == INTER_CAE_MVDNZ || shpmd == INTER_CAE_MVDZ);
  680. // m_pbitstrmOut->trace (m_rgiCurrShp, TOTAL_BAB_SQUARE_SIZE, "MB_BAB");
  682. UInt nBits = 0;
  683. nBits += codeCrAndSt (shpdir, m_iInverseCR);
  684. const PixelC *ppxlcPredBAB = m_puciPredBAB->pixels();
  685. Int iSizeMB = m_iWidthCurrBAB-BAB_BORDER*2;
  686. Int iSizePredBAB = iSizeMB+MC_BAB_BORDER*2;
  687. if(m_iInverseCR==2)
  688. {
  689. downSampleShapeMCPred(ppxlcPredBAB,m_ppxlcPredBABDown2,2);
  690. ppxlcPredBAB = m_ppxlcPredBABDown2;
  691. }
  692. else if(m_iInverseCR==4)
  693. {
  694. downSampleShapeMCPred(ppxlcPredBAB,m_ppxlcPredBABDown4,4);
  695. ppxlcPredBAB = m_ppxlcPredBABDown4;
  696. }
  698. //the real arithmatic encoding
  699. StartArCoder (m_parcodec);
  700. if (shpdir == HORIZONTAL) {
  701. const PixelC* ppxlcSrcRow  = m_rgpxlcCaeSymbol + m_iWidthCurrBAB * BAB_BORDER + BAB_BORDER;
  702. const PixelC* ppxlcPredRow = ppxlcPredBAB + iSizePredBAB * MC_BAB_BORDER + MC_BAB_BORDER;
  703. for (Int iRow = 0; iRow < iSizeMB; iRow++) {
  704. const PixelC* ppxlcSrc = ppxlcSrcRow;
  705. const PixelC* ppxlcPred = ppxlcPredRow;
  706. for (Int iCol = 0; iCol < iSizeMB; iCol++) {
  707. Int iContext = contextInter (ppxlcSrc, ppxlcPred);
  708. #ifdef __TRACE_AND_STATS_
  709. //m_pbitstrmOut->trace (iContext, "MB_CAE_Context");
  710. #endif // __TRACE_AND_STATS_
  711. ArCodeSymbol ((*ppxlcSrc == MPEG4_OPAQUE), gCAEinterProb [iContext], m_parcodec, m_pbitstrmShapeMBOut);
  712. ppxlcSrc++;
  713. ppxlcPred++;
  714. }
  715. ppxlcSrcRow += m_iWidthCurrBAB;
  716. ppxlcPredRow += iSizePredBAB;
  717. }
  718. }
  719. else {
  720. const PixelC* ppxlcSrcCol  = m_rgpxlcCaeSymbol + m_iWidthCurrBAB * BAB_BORDER + BAB_BORDER;
  721. const PixelC* ppxlcPredCol = ppxlcPredBAB + iSizePredBAB * MC_BAB_BORDER + MC_BAB_BORDER;
  722. for (Int iCol = 0; iCol < iSizeMB; iCol++) {
  723. const PixelC* ppxlcSrc = ppxlcSrcCol;
  724. const PixelC* ppxlcPred = ppxlcPredCol;
  725. for (Int iRow = 0; iRow < iSizeMB; iRow++) {
  726. Int iContext = contextInterTranspose (ppxlcSrc, ppxlcPred);
  727. #ifdef __TRACE_AND_STATS_
  728. //m_pbitstrmOut->trace (iContext, "MB_CAE_Context");
  729. #endif // __TRACE_AND_STATS_
  730. ArCodeSymbol ((*ppxlcSrc == MPEG4_OPAQUE), gCAEinterProb [iContext], m_parcodec, m_pbitstrmShapeMBOut);
  731. ppxlcSrc += m_iWidthCurrBAB;
  732. ppxlcPred += iSizePredBAB;
  733. }
  734. ppxlcSrcCol++;
  735. ppxlcPredCol++;
  736. }
  737. }
  738. StopArCoder (m_parcodec, m_pbitstrmShapeMBOut);
  739. nBits += m_parcodec->nBits;
  740. return nBits;
  741. }
  744. UInt CVideoObjectEncoder::encodeMVDS (CMotionVector mvBYD)
  745. {
  746. assert (!mvBYD.isZero());
  748. m_pentrencSet->m_pentrencShapeMV1->attachStream(*m_pbitstrmShapeMBOut);
  749. m_pentrencSet->m_pentrencShapeMV2->attachStream(*m_pbitstrmShapeMBOut);
  750. UInt nBits = 0;
  751. nBits += m_pentrencSet->m_pentrencShapeMV1->encodeSymbol (abs (mvBYD.iMVX), "MB_SHP_MVDX");
  752. if (mvBYD.iMVX != 0) {
  753. m_pbitstrmShapeMBOut->putBits (signOf(mvBYD.iMVX), (UInt) 1, "MB_SHP_MVDX_Sign");
  754. nBits++;
  755. nBits += m_pentrencSet->m_pentrencShapeMV1->encodeSymbol (abs (mvBYD.iMVY), "MB_SHP_MVDY");
  756. }
  757. else 
  758. nBits += m_pentrencSet->m_pentrencShapeMV2->encodeSymbol (abs (mvBYD.iMVY) - 1, "MB_SHP_MVDY");
  759. if (mvBYD.iMVY != 0) {
  760. m_pbitstrmShapeMBOut->putBits (signOf(mvBYD.iMVY), (UInt) 1, "MB_SHP_MVDY_Sign");
  761. nBits++;
  762. }
  764. m_pentrencSet->m_pentrencShapeMV1->attachStream(*m_pbitstrmOut);
  765. m_pentrencSet->m_pentrencShapeMV2->attachStream(*m_pbitstrmOut);
  766. return nBits;
  767. }
  769. Bool CVideoObjectEncoder::sameBlockTranspStatus (const CMBMode* pmbmd, PixelC pxlcRecon) //assume src is 16 x 16 buffer
  770. {
  771. if (pxlcRecon == opaqueValue)
  772. return ((pmbmd->m_rgTranspStatus [Y_BLOCK1] != ALL) && //if recon is all opaque
  773. (pmbmd->m_rgTranspStatus [Y_BLOCK2] != ALL) && //then each orig. blk has to be not all transp
  774. (pmbmd->m_rgTranspStatus [Y_BLOCK3] != ALL) &&
  775. (pmbmd->m_rgTranspStatus [Y_BLOCK4] != ALL));
  776. return TRUE;
  777. }
  779. Bool CVideoObjectEncoder::sameBlockTranspStatus (const CMBMode* pmbmd, const PixelC* pxlcRecon, Int iSizeRecon) //src: 16x16 Recon: 18 x 18 || 20 x 20
  780. {
  781. Int iBorder = (iSizeRecon == 18) ? 1 : 2;
  782. const PixelC* ppxlcBlk1 = pxlcRecon + iBorder + iBorder * iSizeRecon;
  783. const PixelC* ppxlcBlk2 = ppxlcBlk1 + BLOCK_SIZE;
  784. const PixelC* ppxlcBlk3 = pxlcRecon + iSizeRecon * iSizeRecon / 2 + iBorder;
  785. const PixelC* ppxlcBlk4 = ppxlcBlk3 + BLOCK_SIZE;
  786. static PixelC rgnOpaquePixels [4];
  787. rgnOpaquePixels [0] = rgnOpaquePixels [1] = rgnOpaquePixels [2] = rgnOpaquePixels [3] = 0;
  788. CoordI ix, iy;
  789. for (iy = 0; iy < BLOCK_SIZE; iy++) {
  790. for (ix = 0; ix < BLOCK_SIZE; ix++) {
  791. rgnOpaquePixels [0] += ppxlcBlk1 [ix];
  792. rgnOpaquePixels [1] += ppxlcBlk2 [ix];
  793. rgnOpaquePixels [2] += ppxlcBlk3 [ix];
  794. rgnOpaquePixels [3] += ppxlcBlk4 [ix];
  795. }
  796. ppxlcBlk1 += iSizeRecon;
  797. ppxlcBlk2 += iSizeRecon;
  798. ppxlcBlk3 += iSizeRecon;
  799. ppxlcBlk4 += iSizeRecon;
  800. }
  802. Int iBlk;
  803. for (iBlk = Y_BLOCK1; iBlk <= Y_BLOCK4; iBlk++)
  804. if (pmbmd->m_rgTranspStatus [iBlk] == ALL) //if org. blk is all transp, the recon can be otherwise
  805. if (rgnOpaquePixels [iBlk - 1] != 0)
  806. return FALSE;
  807. return TRUE;
  808. }
  811. UInt CVideoObjectEncoder::codeCrAndSt (CAEScanDirection shpdir, Int iInverseCR)
  812. {
  813. UInt nBits = 0;
  814. if (m_volmd.bNoCrChange == FALSE) {
  815. UInt nBitsCR = (iInverseCR == 1) ? 1 : 2;
  816. Int iCode = (iInverseCR == 1) ? 0 : (iInverseCR == 2) ? 2 : 3;
  817. m_pbitstrmShapeMBOut->putBits (iCode, nBitsCR, "MB_CR");
  818. nBits += nBitsCR;
  819. }
  820. //Scan direction
  821. m_pbitstrmShapeMBOut->putBits ((shpdir == HORIZONTAL) ? 1 : 0, (UInt) 1, "MB_ST");
  822. nBits++;
  823. return nBits;
  824. }
  826. Void CVideoObjectEncoder::copyReconShapeToRef (PixelC* ppxlcRefFrm, PixelC pxlcSrc) //no need to reset MB buffer
  827. {
  828. for (Int i = 0; i < MB_SIZE; i++) {
  829. pxlcmemset (ppxlcRefFrm, pxlcSrc, MB_SIZE);
  830. ppxlcRefFrm+= m_iFrameWidthY;
  831. }
  832. }
  834. Void CVideoObjectEncoder::copyReconShapeToRef (PixelC* ppxlcRefFrm, 
  835.    const PixelC* ppxlcSrc, Int iSrcWidth, Int iBorder)
  836. {
  837. ppxlcSrc += iSrcWidth * iBorder + iBorder;
  838. Int iUnit = sizeof(PixelC); // NBIT: for memcpy
  839. for (Int i = 0; i < MB_SIZE; i++) {
  840. memcpy (ppxlcRefFrm, ppxlcSrc, MB_SIZE*iUnit);
  841. ppxlcRefFrm += m_iFrameWidthY;
  842. ppxlcSrc += iSrcWidth;
  843. }
  844. }
  846. Int CVideoObjectEncoder::sadForShape (const PixelC* ppxlcRefBY) const
  847. {
  848. Int iInitSAD = 0;
  849. CoordI ix, iy;
  850. const PixelC* ppxlcCurrBY = m_ppxlcCurrMBBY;
  851. for (iy = 0; iy < MB_SIZE; iy++) {
  852. for (ix = 0; ix < MB_SIZE; ix++)
  853. iInitSAD += abs (ppxlcCurrBY [ix] - ppxlcRefBY [ix]);
  854. ppxlcCurrBY += MB_SIZE;
  855. ppxlcRefBY += m_iFrameWidthY;
  856. }
  857. return iInitSAD;
  858. }
  860. Void CVideoObjectEncoder::blkmatchForShape (
  861. CVOPU8YUVBA* pvopcRefQ,
  862. CMotionVector* pmv,
  863. const CVector& mvPredHalfPel,
  864. CoordI iX, CoordI iY
  865. )
  866. {
  867. Int mbDiff;
  868. CoordI x = iX + (mvPredHalfPel.x >> 1), y = iY + (mvPredHalfPel.y >> 1); 
  869. Int iXDest = x, iYDest = y;
  870. CoordI ix, iy;
  871. const PixelC* ppxlcRefMBY = pvopcRefQ->pixelsBY () + m_rctRefFrameY.offset (x, y);
  872. Int iMinSAD = sadForShape (ppxlcRefMBY);
  873. pmv->iMVX = pmv->iMVY = 0;
  874. Int uiPosInLoop, iLoop;
  875. // Spiral Search for the rest
  876. for (iLoop = 1; iLoop <= 16; iLoop++) {
  877. x++;
  878. y++;
  879. ppxlcRefMBY += m_iFrameWidthY + 1;
  880. for (uiPosInLoop = 0; uiPosInLoop < (iLoop << 3); uiPosInLoop++) {
  881. // inside each spiral loop 
  882. if (
  883. x >= m_rctRefVOPY0.left && y >= m_rctRefVOPY0.top && 
  884. x <= m_rctRefVOPY0.right - MB_SIZE && y <= m_rctRefVOPY0.bottom - MB_SIZE
  885. ) {
  886. const PixelC* ppxlcTmpC = m_ppxlcCurrMBBY;
  887. const PixelC* ppxlcRefMB = ppxlcRefMBY;
  888. mbDiff = 0;
  889. for (iy = 0; iy < MB_SIZE; iy++) {
  890. for (ix = 0; ix < MB_SIZE; ix++)
  891. mbDiff += abs (ppxlcTmpC [ix] - ppxlcRefMB [ix]);
  892. if (mbDiff >= iMinSAD)
  893. goto NEXT_POSITION; // skip the current position
  894. ppxlcRefMB += m_iFrameWidthY;
  895. ppxlcTmpC += MB_SIZE;
  896. }
  897. iMinSAD = mbDiff;
  898. iXDest = x;
  899. iYDest = y;
  900. }
  901. NEXT_POSITION:
  902. if (uiPosInLoop < (iLoop << 1)) {
  903. ppxlcRefMBY--;
  904. x--;
  905. }
  906. else if (uiPosInLoop < (iLoop << 2)) {
  907. ppxlcRefMBY -= m_iFrameWidthY;
  908. y--;
  909. }
  910. else if (uiPosInLoop < (iLoop * 6)) {
  911. ppxlcRefMBY++;   
  912. x++;
  913. }
  914. else {
  915. ppxlcRefMBY += m_iFrameWidthY;
  916. y++;
  917. }
  918. }
  919. }
  920. *pmv = CMotionVector (iXDest - iX, iYDest - iY);
  921. }