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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

errenc.cpp：源码内容
  1. /*************************************************************************
  3. This software module was originally developed by 
  5. Yoshihiro Kikuchi (TOSHIBA CORPORATION)
  6. Takeshi Nagai (TOSHIBA CORPORATION)
  8.     and edited by:
  10. Toshiaki Watanabe (TOSHIBA CORPORATION)
  11. Noboru Yamaguchi (TOSHIBA CORPORATION)
  13. and also edited by 
  15. Xuemin Chen (xchen@nlvl.com) Next Level System, Inc.
  16. Bob Eifrig (beifrig@nlvl.com) Next Level Systems, Inc.
  18.   in the course of development of the <MPEG-4 Video(ISO/IEC 14496-2)>. This
  19.   software module is an implementation of a part of one or more <MPEG-4 Video
  20.   (ISO/IEC 14496-2)> tools as specified by the <MPEG-4 Video(ISO/IEC 14496-2)
  21.   >. ISO/IEC gives users of the <MPEG-4 Video(ISO/IEC 14496-2)> free license
  22.   to this software module or modifications thereof for use in hardware or
  23.   software products claiming conformance to the <MPEG-4 Video(ISO/IEC 14496-2
  24.   )>. Those intending to use this software module in hardware or software
  25.   products are advised that its use may infringe existing patents. The
  26.   original developer of this software module and his/her company, the
  27.   subsequent editors and their companies, and ISO/IEC have no liability for
  28.   use of this software module or modifications thereof in an implementation.
  29.   Copyright is not released for non <MPEG-4 Video(ISO/IEC 14496-2)>
  30.   conforming products. TOSHIBA CORPORATION retains full right to use the code
  31.   for his/her own purpose, assign or donate the code to a third party and to
  32.   inhibit third parties from using the code for non <MPEG-4 Video(ISO/IEC
  33.   14496-2)> conforming products. This copyright notice must be included in
  34.   all copies or derivative works.
  35.   Copyright (c)1997.
  37. Revision History:
  39. May 9, 1999: tm5 rate control by DemoGraFX, duhoff@mediaone.net
  41. *************************************************************************/
  43. #include <stdio.h>
  44. #include <math.h>
  45. #include <stdlib.h>
  46. #include <iostream.h>
  48. #include "typeapi.h"
  49. #include "codehead.h"
  50. #include "entropy/bitstrm.hpp"
  51. #include "entropy/entropy.hpp"
  52. #include "entropy/huffman.hpp"
  53. #include "mode.hpp"
  54. #include "global.hpp"
  55. #include "vopses.hpp"
  56. #include "vopseenc.hpp"
  58. #ifdef __MFC_
  59. #ifdef _DEBUG
  60. #undef THIS_FILE
  61. static char BASED_CODE THIS_FILE[] = __FILE__;
  62. #endif
  64. #define new DEBUG_NEW    
  65. #endif // __MFC_
  67. // inline functions
  68. inline Int clog2(Int a) {return ( ((a)<=0) ? 0 : (int) ceil( log10( (double) (a) ) / log10(2.0) ) );}
  71. Void CVideoObjectEncoder::VideoPacketResetVOP(
  72. )
  73. {
  74. m_iVPCounter = m_pbitstrmOut -> getCounter(); // reset coding bits counter
  75. assert(m_iNumMBX>0 && m_iNumMBY>0);
  76. m_numBitsVPMBnum = clog2 (m_iNumMBX * m_iNumMBY); // number of bits for macroblock_number
  77. m_numVideoPacket = 1; // reset number of video packet in a VOP
  78. m_iVPMBnum = 0; // start MB in the 1st VP
  79. }
  82. Void CVideoObjectEncoder::codeVideoPacketHeader (
  83. Int iMBX, Int iMBY, Int QuantScale
  84. )
  85. {
  86. m_iVPMBnum = VPMBnum(iMBX, iMBY);
  87. m_statsVOP.nBitsHead += codeVideoPacketHeader(QuantScale);
  88. }
  90. #if 0 // revised HEC for shape
  91. Int CVideoObjectEncoder::codeVideoPacketHeader (Int QuantScale)
  92. {
  93. #ifdef __TRACE_AND_STATS_
  94. m_pbitstrmOut->trace ("Video_Packet_Headern");
  95. #endif // __TRACE_AND_STATS_
  96. UInt nBits = 0;
  97. assert(m_iVPMBnum > 0 && m_iVPMBnum < m_iNumMBX * m_iNumMBY);
  98. assert(QuantScale > 0 && QuantScale < 32);
  100. m_pbitstrmOut->flush ();
  101. Int nBitsResyncMarker = NUMBITS_VP_RESYNC_MARKER;
  102. if(m_volmd.bShapeOnly==FALSE)
  103. {
  104. if(m_vopmd.vopPredType == PVOP)
  105. nBitsResyncMarker += (m_vopmd.mvInfoForward.uiFCode - 1);
  106. else if(m_vopmd.vopPredType == BVOP)
  107. nBitsResyncMarker += max(m_vopmd.mvInfoForward.uiFCode, m_vopmd.mvInfoBackward.uiFCode) - 1;
  108. }
  109. m_pbitstrmOut -> putBits (RESYNC_MARKER, nBitsResyncMarker, "resync_marker");
  110. m_pbitstrmOut -> putBits (m_iVPMBnum, m_numBitsVPMBnum, "VPH_macroblock_number");
  111. if(m_volmd.bShapeOnly==FALSE) {
  112. m_pbitstrmOut -> putBits (QuantScale, NUMBITS_VP_QUANTIZER, "VPH_quant_scale");
  113. }
  115. Bool HEC = ((++m_numVideoPacket) == 2); // use HEC in 2nd VP
  116. m_pbitstrmOut -> putBits (HEC, NUMBITS_VP_HEC, "VPH_header_extension_code");
  117. #ifdef __TRACE_AND_STATS_
  118. nBits += nBitsResyncMarker + m_numBitsVPMBnum + NUMBITS_VP_QUANTIZER + NUMBITS_VP_HEC;
  119. #endif // __TRACE_AND_STATS_
  120. if( HEC == TRUE ) {
  121. m_pbitstrmOut -> putBits ((Int) 0xFFFFFFFE, (UInt) m_nBitsModuloBase + 1, "VPH_Modulo_Time_Base");
  122. m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
  123. m_pbitstrmOut -> putBits (m_iVopTimeIncr, m_iNumBitsTimeIncr, "VPH_Time_Incr");
  124. m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
  125. m_pbitstrmOut -> putBits (m_vopmd.vopPredType, NUMBITS_VP_PRED_TYPE, "VPH_Pred_Type");
  126. #ifdef __TRACE_AND_STATS_
  127. nBits += m_nBitsModuloBase+1 + m_iNumBitsTimeIncr +2 + NUMBITS_VP_PRED_TYPE + NUMBITS_VP_INTRA_DC_SWITCH_THR;
  128. #endif // __TRACE_AND_STATS_
  129. if(m_volmd.bShapeOnly==FALSE) {
  130. m_pbitstrmOut -> putBits (m_vopmd.iIntraDcSwitchThr, NUMBITS_VP_INTRA_DC_SWITCH_THR, "VOP_DC_VLC_Switch");
  131. if(m_vopmd.vopPredType != IVOP) {
  132. m_pbitstrmOut -> putBits (m_vopmd.mvInfoForward.uiFCode, NUMBITS_VOP_FCODE, "VPH_Fcode_Forward");
  133. #ifdef __TRACE_AND_STATS_
  134. nBits += NUMBITS_VOP_FCODE;
  135. #endif // __TRACE_AND_STATS_
  136. if (m_vopmd.vopPredType == BVOP) {
  137. m_pbitstrmOut -> putBits (m_vopmd.mvInfoBackward.uiFCode, NUMBITS_VOP_FCODE, "VOP_Fcode_Backward");
  138. #ifdef __TRACE_AND_STATS_
  139. nBits += NUMBITS_VOP_FCODE;
  140. #endif // __TRACE_AND_STATS_
  141. }
  142. }
  143. }
  144. }
  146. return nBits;
  147. }
  148. #else
  149. Int CVideoObjectEncoder::codeVideoPacketHeader (Int QuantScale)
  150. {
  151. #ifdef __TRACE_AND_STATS_
  152. m_pbitstrmOut->trace ("Video_Packet_Headern");
  153. #endif // __TRACE_AND_STATS_
  154. UInt nBits = 0;
  155. assert(m_iVPMBnum > 0 && m_iVPMBnum < m_iNumMBX * m_iNumMBY);
  156. assert(QuantScale > 0 && QuantScale < 32);
  158. m_pbitstrmOut->flush ();
  159. Int nBitsResyncMarker = NUMBITS_VP_RESYNC_MARKER;
  160. Bool HEC = ((++m_numVideoPacket) == 2); // use HEC in 2nd VP
  161. if(m_volmd.bShapeOnly==FALSE)
  162. {
  163. if(m_vopmd.vopPredType == PVOP)
  164. nBitsResyncMarker += (m_vopmd.mvInfoForward.uiFCode - 1);
  165. else if(m_vopmd.vopPredType == BVOP)
  166. nBitsResyncMarker += max(m_vopmd.mvInfoForward.uiFCode, m_vopmd.mvInfoBackward.uiFCode) - 1;
  167. }
  168. m_pbitstrmOut -> putBits (RESYNC_MARKER, nBitsResyncMarker, "resync_marker");
  170. if(m_volmd.fAUsage != RECTANGLE) {
  171. m_pbitstrmOut -> putBits (HEC, NUMBITS_VP_HEC, "VPH_header_extension_code");
  172. if (HEC == TRUE && !(m_uiSprite == 1 && m_vopmd.vopPredType == IVOP)) {
  173. m_pbitstrmOut->putBits (m_rctCurrVOPY.width, NUMBITS_VOP_WIDTH, "VPH_VOP_Width");
  174. m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
  175. m_pbitstrmOut->putBits (m_rctCurrVOPY.height (), NUMBITS_VOP_HEIGHT, "VPH_VOP_Height");
  176. m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
  177. #ifdef __TRACE_AND_STATS_
  178. nBits += NUMBITS_VOP_WIDTH + NUMBITS_VOP_HEIGHT + 2;
  179. #endif // __TRACE_AND_STATS_
  181. if (m_rctCurrVOPY.left >= 0) {
  182. m_pbitstrmOut -> putBits (m_rctCurrVOPY.left, NUMBITS_VOP_HORIZONTAL_SPA_REF, "VPH_VOP_Hori_Ref");
  183. } else {
  184. m_pbitstrmOut -> putBits (m_rctCurrVOPY.left & 0x00001FFFF, NUMBITS_VOP_HORIZONTAL_SPA_REF, "VPH_VOP_Hori_Ref");
  185. }
  186. m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
  187. if (m_rctCurrVOPY.top >= 0) {
  188. m_pbitstrmOut -> putBits (m_rctCurrVOPY.top, NUMBITS_VOP_VERTICAL_SPA_REF, "VPH_VOP_Vert_Ref");
  189. } else {
  190. m_pbitstrmOut -> putBits (m_rctCurrVOPY.top & 0x00001FFFF, NUMBITS_VOP_VERTICAL_SPA_REF, "VPH_VOP_Vert_Ref");
  191. }
  192. m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
  193. #ifdef __TRACE_AND_STATS_
  194. nBits += NUMBITS_VOP_HORIZONTAL_SPA_REF + NUMBITS_VOP_VERTICAL_SPA_REF + 2;
  195. #endif // __TRACE_AND_STATS_
  196. }
  197. }
  199. m_pbitstrmOut -> putBits (m_iVPMBnum, m_numBitsVPMBnum, "VPH_macroblock_number");
  200. if(m_volmd.bShapeOnly==FALSE) {
  201. m_pbitstrmOut -> putBits (QuantScale, NUMBITS_VP_QUANTIZER, "VPH_quant_scale");
  202. }
  204. if(m_volmd.fAUsage == RECTANGLE)
  205. m_pbitstrmOut -> putBits (HEC, NUMBITS_VP_HEC, "VPH_header_extension_code");
  206. #ifdef __TRACE_AND_STATS_
  207. nBits += nBitsResyncMarker + m_numBitsVPMBnum + NUMBITS_VP_QUANTIZER + NUMBITS_VP_HEC;
  208. #endif // __TRACE_AND_STATS_
  209. if( HEC == TRUE ) {
  210. m_pbitstrmOut -> putBits ((Int) 0xFFFFFFFE, (UInt) m_nBitsModuloBase + 1, "VPH_Modulo_Time_Base");
  211. m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
  212. m_pbitstrmOut -> putBits (m_iVopTimeIncr, m_iNumBitsTimeIncr, "VPH_Time_Incr");
  213. m_pbitstrmOut->putBits ((Int) 1, 1, "Marker"); // marker bit
  214. m_pbitstrmOut -> putBits (m_vopmd.vopPredType, NUMBITS_VP_PRED_TYPE, "VPH_Pred_Type");
  215. #ifdef __TRACE_AND_STATS_
  216. nBits += m_nBitsModuloBase+1 + m_iNumBitsTimeIncr +2 + NUMBITS_VP_PRED_TYPE + NUMBITS_VP_INTRA_DC_SWITCH_THR;
  217. #endif // __TRACE_AND_STATS_
  219. if(m_volmd.fAUsage != RECTANGLE) {
  220. m_pbitstrmOut->putBits (m_volmd.bNoCrChange, 1, "VPH_VOP_CR_Change_Disable");
  221. #ifdef __TRACE_AND_STATS_
  222. nBits ++;
  223. #endif // __TRACE_AND_STATS_
  224. if (m_volmd.bShapeOnly==FALSE && m_vopmd.vopPredType != IVOP)  
  225. {  
  226. m_pbitstrmOut -> putBits (m_vopmd.bShapeCodingType, 1, "VPH_shape_coding_type");
  227. #ifdef __TRACE_AND_STATS_
  228. nBits ++;
  229. #endif // __TRACE_AND_STATS_
  230. }
  231. }
  233. if(m_volmd.bShapeOnly==FALSE) {
  234. m_pbitstrmOut -> putBits (m_vopmd.iIntraDcSwitchThr, NUMBITS_VP_INTRA_DC_SWITCH_THR, "VOP_DC_VLC_Switch");
  235. if(m_vopmd.vopPredType != IVOP) {
  236. m_pbitstrmOut -> putBits (m_vopmd.mvInfoForward.uiFCode, NUMBITS_VOP_FCODE, "VPH_Fcode_Forward");
  237. #ifdef __TRACE_AND_STATS_
  238. nBits += NUMBITS_VOP_FCODE;
  239. #endif // __TRACE_AND_STATS_
  240. if (m_vopmd.vopPredType == BVOP) {
  241. m_pbitstrmOut -> putBits (m_vopmd.mvInfoBackward.uiFCode, NUMBITS_VOP_FCODE, "VOP_Fcode_Backward");
  242. #ifdef __TRACE_AND_STATS_
  243. nBits += NUMBITS_VOP_FCODE;
  244. #endif // __TRACE_AND_STATS_
  245. }
  246. }
  247. }
  248. }
  250. return nBits;
  251. }
  252. #endif
  254. UInt CVideoObjectEncoder::encodeMVVP (const CMotionVector* pmv, const CMBMode* pmbmd, Int iMBX, Int iMBY)
  255. {
  256. Int iMBnum = iMBY * m_iNumMBX + iMBX;
  257. assert(iMBnum >= m_iVPMBnum);
  258. return encodeMV (pmv, pmbmd, bVPNoLeft(iMBnum, iMBX), bVPNoRightTop(iMBnum, iMBX), bVPNoTop(iMBnum),
  259. iMBX, iMBY);
  260. }
  263. //////////////////////////////////////////////////////////////////
  264. ////  The following functions are for Data partitioning mode  ////
  265. //////////////////////////////////////////////////////////////////
  267. Void CVideoObjectEncoder::encodeNSForPVOP_DP ()
  268. {
  269. assert( m_volmd.bDataPartitioning );
  270. assert( m_vopmd.vopPredType==PVOP );
  271. //assert(m_volmd.nBits==8);
  273. if (m_uiSprite == 0) //low latency: not motion esti
  274. motionEstPVOP ();
  276. // Rate Control
  277. if (m_uiRateControl == RC_MPEG4) {
  278. Double Ec = m_iMAD / (Double) (m_iNumMBY * m_iNumMBX * 16 * 16);
  279. m_statRC.setMad (Ec);
  280. if (m_statRC.noCodedFrame () >= RC_START_RATE_CONTROL) {
  281. UInt newQStep = m_statRC.updateQuanStepsize ();
  282. m_vopmd.intStepDiff = newQStep - m_vopmd.intStep; // DQUANT
  283. m_vopmd.intStep = newQStep;
  284. }
  285. cout << "t" << "Q:" << "ttt" << m_vopmd.intStep << "n";
  286. m_statRC.setQc (m_vopmd.intStep);
  287. }
  289. // MB rate control
  290. //Int iIndexofQ = 0;
  291. //Int rgiQ [4] = {-1, -2, 1, 2};
  292. // -----
  294. Int iMBX, iMBY;
  295. CoordI y = 0; 
  296. CMBMode* pmbmd = m_rgmbmd;
  297. Int iQPPrev = m_vopmd.intStep;
  298. CMotionVector* pmv = m_rgmv;
  299. PixelC* ppxlcRefY = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
  300. PixelC* ppxlcRefU = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
  301. PixelC* ppxlcRefV = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
  303. PixelC* ppxlcOrigY = (PixelC*) m_pvopcOrig->pixelsBoundY ();
  304. PixelC* ppxlcOrigU = (PixelC*) m_pvopcOrig->pixelsBoundU ();
  305. PixelC* ppxlcOrigV = (PixelC*) m_pvopcOrig->pixelsBoundV ();
  307. Int iVPCounter = m_statsVOP.total();
  308. Int iVPtotal;
  309. m_iVPMBnum = 0;
  310. CStatistics m_statsVP;
  311. // DCT coefficient buffer for Data Partitioning mode
  312. Int*** iCoefQ_DP = new Int** [m_iNumMB];
  314. // Set not to output but count bitstream
  315. m_pbitstrmOut->SetDontSendBits(TRUE);
  317. Bool bRestartDelayedQP = TRUE;
  319. for (iMBY = 0; iMBY < m_iNumMBY; iMBY++, y += MB_SIZE) {
  320. PixelC* ppxlcRefMBY = ppxlcRefY;
  321. PixelC* ppxlcRefMBU = ppxlcRefU;
  322. PixelC* ppxlcRefMBV = ppxlcRefV;
  323. PixelC* ppxlcOrigMBY = ppxlcOrigY;
  324. PixelC* ppxlcOrigMBU = ppxlcOrigU;
  325. PixelC* ppxlcOrigMBV = ppxlcOrigV;
  326. CoordI x = 0; 
  327. for (iMBX = 0; iMBX < m_iNumMBX; iMBX++, x += MB_SIZE) {
  329. ////#ifdef __TRACE_AND_STATS_
  330. //// m_statsMB.reset ();
  331. //// m_pbitstrmOut->trace (CSite (iMBX, iMBY), "MB_X_Y");
  332. ////#endif // __TRACE_AND_STATS_
  334. m_statsMB.reset ();
  336. // MB rate control
  337. //pmbmd->m_intStepDelta = 0;
  338. //iIndexofQ = (iIndexofQ + 1) % 4;
  339. //if (!pmbmd ->m_bhas4MVForward && !pmbmd ->m_bSkip) {
  340. // if (pmbmd ->m_dctMd == INTRA)
  341. // pmbmd ->m_dctMd == INTRAQ;
  342. // else if (pmbmd ->m_dctMd == INTER)
  343. // pmbmd->m_dctMd = INTERQ;
  344. // pmbmd->m_intStepDelta = rgiQ [iIndexofQ];
  345. //}
  346. // -----
  348. pmbmd->m_stepSize = iQPPrev + pmbmd->m_intStepDelta;
  349. if(bRestartDelayedQP)
  350. pmbmd->m_stepSizeDelayed = pmbmd->m_stepSize;
  351. else
  352. pmbmd->m_stepSizeDelayed = iQPPrev;
  354. copyToCurrBuff (ppxlcOrigMBY, ppxlcOrigMBU, ppxlcOrigMBV, m_iFrameWidthY, m_iFrameWidthUV); 
  355. encodePVOPMB (
  356. ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV,
  357. pmbmd, pmv,
  358. iMBX, iMBY,
  359. x, y
  360. );
  362. Int iVPlastMBnum = iMBY * m_iNumMBX + iMBX;
  364. // copy DCT coefficient to buffer
  365. iCoefQ_DP[iVPlastMBnum] = new Int* [6];
  366. Int iBlk;
  367. for (iBlk = 0; iBlk < 6; iBlk++) {
  368. iCoefQ_DP [iVPlastMBnum] [iBlk] = new Int [BLOCK_SQUARE_SIZE];
  370. for( Int t = 0; t < BLOCK_SQUARE_SIZE; t++ )
  371. iCoefQ_DP[iVPlastMBnum][iBlk][t] = m_rgpiCoefQ[iBlk][t];
  372. }
  374. if (!pmbmd->m_bSkip)
  375. {
  376. iQPPrev = pmbmd->m_stepSize;
  377. bRestartDelayedQP = FALSE;
  378. }
  380. pmbmd++;
  381. pmv += PVOP_MV_PER_REF_PER_MB;
  382. #ifdef __TRACE_AND_STATS_
  383. m_statsVOP += m_statsMB;
  384. #endif // __TRACE_AND_STATS_
  385. ppxlcRefMBY += MB_SIZE;
  386. ppxlcRefMBU += BLOCK_SIZE;
  387. ppxlcRefMBV += BLOCK_SIZE;
  388. ppxlcOrigMBY += MB_SIZE;
  389. ppxlcOrigMBU += BLOCK_SIZE;
  390. ppxlcOrigMBV += BLOCK_SIZE;
  392. iVPtotal = (int) m_statsVOP.total() - iVPCounter;
  393. if( iVPtotal > m_volmd.bVPBitTh || iVPlastMBnum == m_iNumMB-1 /* last MB in a VOP */) {
  394. // Set to output bitstream
  395. m_pbitstrmOut->SetDontSendBits(FALSE);
  396. // encode video packet
  397. iVPCounter = m_statsVOP.total();
  398. m_statsVP.reset();
  399. if( m_iVPMBnum > 0 )
  400. {
  401. m_statsVP.nBitsHead = codeVideoPacketHeader (m_rgmbmd[m_iVPMBnum].m_stepSize);
  402. bRestartDelayedQP = TRUE;
  403. }
  405. DataPartitioningMotionCoding(m_iVPMBnum, iVPlastMBnum, &m_statsVP, iCoefQ_DP);
  407. m_pbitstrmOut -> putBits (MOTION_MARKER, NUMBITS_DP_MOTION_MARKER, "motion_marker");
  408. m_statsVP.nBitsHead += NUMBITS_DP_MOTION_MARKER;
  410. DataPartitioningTextureCoding(m_iVPMBnum, iVPlastMBnum, &m_statsVP, iCoefQ_DP);
  412. //assert( iVPtotal + m_statsVP.nBitsHead == (int) m_statsVP.total() );
  414. m_iVPMBnum = iVPlastMBnum + 1;
  416. // Set not to output but count bitstream
  417. m_pbitstrmOut->SetDontSendBits(TRUE);
  418. }
  420. }
  421. MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
  422. m_rgpmbmAbove = m_rgpmbmCurr;
  423. m_rgpmbmCurr  = ppmbmTemp;
  425. ppxlcRefY += m_iFrameWidthYxMBSize;
  426. ppxlcRefU += m_iFrameWidthUVxBlkSize;
  427. ppxlcRefV += m_iFrameWidthUVxBlkSize;
  429. ppxlcOrigY += m_iFrameWidthYxMBSize;
  430. ppxlcOrigU += m_iFrameWidthUVxBlkSize;
  431. ppxlcOrigV += m_iFrameWidthUVxBlkSize;
  432. }
  434. // delete CoefQ_DP
  435. for( Int iMB = 0; iMB < m_iNumMB; iMB++ )  {
  436. for (Int iBlk = 0; iBlk < 6; iBlk++) {
  437. delete [] iCoefQ_DP [iMB] [iBlk];
  438. }
  439. delete [] iCoefQ_DP[iMB];
  440. }
  441. delete [] iCoefQ_DP;
  443. // Set to output bitstream
  444. m_pbitstrmOut->SetDontSendBits(FALSE);
  445. }
  447. Void CVideoObjectEncoder::encodeNSForIVOP_DP ()
  448. {
  449. assert( m_volmd.bDataPartitioning );
  450. assert( m_vopmd.vopPredType==IVOP );
  451. //assert(m_volmd.nBits==8);
  452. // bug fix by toshiba 98-9-24 start
  453. //in case the IVOP is used as an ref for direct mode
  454. memset (m_rgmv, 0, m_iNumMB * PVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
  455. // bug fix by toshiba 98-9-24 end
  457. CMBMode* pmbmd = m_rgmbmd;
  458. Int iQPPrev = m_vopmd.intStepI; //initialization
  459. PixelC* ppxlcRefY  = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
  460. PixelC* ppxlcRefU  = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
  461. PixelC* ppxlcRefV  = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
  463. PixelC* ppxlcOrigY = (PixelC*) m_pvopcOrig->pixelsBoundY ();
  464. PixelC* ppxlcOrigU = (PixelC*) m_pvopcOrig->pixelsBoundU ();
  465. PixelC* ppxlcOrigV = (PixelC*) m_pvopcOrig->pixelsBoundV ();
  467. // MB rate control
  468. //Int iIndexofQ = 0;
  469. //Int rgiQ [4] = {-1, -2, 1, 2};
  470. // -----
  472. Int iMBX, iMBY;
  474. Int iVPCounter = m_statsVOP.total();
  475. Int iVPtotal;
  476. m_iVPMBnum = 0;
  477. CStatistics m_statsVP;
  478. // DCT coefficient buffer for Data Partitioning mode
  479. Int*** iCoefQ_DP = new Int** [m_iNumMB];
  481. // Set not to output but count bitstream
  482. m_pbitstrmOut->SetDontSendBits(TRUE);
  484. Bool bRestartDelayedQP = TRUE;
  486. for (iMBY = 0; iMBY < m_iNumMBY; iMBY++) {
  487. PixelC* ppxlcRefMBY  = ppxlcRefY;
  488. PixelC* ppxlcRefMBU  = ppxlcRefU;
  489. PixelC* ppxlcRefMBV  = ppxlcRefV;
  490. PixelC* ppxlcOrigMBY = ppxlcOrigY;
  491. PixelC* ppxlcOrigMBU = ppxlcOrigU;
  492. PixelC* ppxlcOrigMBV = ppxlcOrigV;
  493. for (iMBX = 0; iMBX < m_iNumMBX; iMBX++) {
  494. #ifdef __TRACE_AND_STATS_
  495. m_pbitstrmOut->trace (CSite (iMBX, iMBY), "MB_X_Y");
  496. #endif // __TRACE_AND_STATS_
  498. m_statsMB.reset ();
  500. // MB rate control
  501. //pmbmd->m_intStepDelta = 0;
  502. //iIndexofQ = (iIndexofQ + 1) % 4;
  503. //pmbmd->m_intStepDelta = rgiQ [iIndexofQ];
  504. // -----
  506. // bug fix by toshiba 98-9-24 start
  507. pmbmd->m_bSkip = FALSE; //reset for direct mode
  508. // bug fix by toshiba 98-9-24 end
  509. pmbmd->m_stepSize = iQPPrev + pmbmd->m_intStepDelta;
  511. if(bRestartDelayedQP)
  512. {
  513. pmbmd->m_stepSizeDelayed = pmbmd->m_stepSize;
  514. bRestartDelayedQP = FALSE;
  515. }
  516. else
  517. pmbmd->m_stepSizeDelayed = iQPPrev;
  519. iQPPrev = pmbmd->m_stepSize;
  520. if (pmbmd->m_intStepDelta == 0)
  521. pmbmd->m_dctMd = INTRA;
  522. else
  523. pmbmd->m_dctMd = INTRAQ;
  525. copyToCurrBuff (ppxlcOrigMBY, ppxlcOrigMBU, ppxlcOrigMBV, m_iFrameWidthY, m_iFrameWidthUV); 
  526. quantizeTextureIntraMB (iMBX, iMBY, pmbmd, ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, NULL);
  527. codeMBTextureHeadOfIVOP (pmbmd);
  528. sendDCTCoefOfIntraMBTexture (pmbmd);
  530. Int iVPlastMBnum = iMBY * m_iNumMBX + iMBX;
  532. // copy DCT coefficient to buffer
  533. iCoefQ_DP[iVPlastMBnum] = new Int* [6];
  534. Int iBlk;
  535. for (iBlk = 0; iBlk < 6; iBlk++) {
  536. iCoefQ_DP [iVPlastMBnum] [iBlk] = new Int [BLOCK_SQUARE_SIZE];
  538. for( Int t = 0; t < BLOCK_SQUARE_SIZE; t++ )
  539. iCoefQ_DP[iVPlastMBnum][iBlk][t] = m_rgpiCoefQ[iBlk][t];
  540. }
  542. pmbmd++;
  543. #ifdef __TRACE_AND_STATS_
  544. m_statsVOP   += m_statsMB;
  545. #endif // __TRACE_AND_STATS_
  546. ppxlcRefMBY  += MB_SIZE;
  547. ppxlcRefMBU  += BLOCK_SIZE;
  548. ppxlcRefMBV  += BLOCK_SIZE;
  549. ppxlcOrigMBY += MB_SIZE;
  550. ppxlcOrigMBU += BLOCK_SIZE;
  551. ppxlcOrigMBV += BLOCK_SIZE;
  553. iVPtotal = (int) m_statsVOP.total() - iVPCounter;
  554. if( iVPtotal > m_volmd.bVPBitTh || iVPlastMBnum == m_iNumMB-1 /* last MB in a VOP */) {
  555. // Set to output bitstream
  556. m_pbitstrmOut->SetDontSendBits(FALSE);
  557. // encode video packet
  558. iVPCounter = m_statsVOP.total();
  559. m_statsVP.reset();
  560. if( m_iVPMBnum > 0 )
  561. {
  562. m_statsVP.nBitsHead = codeVideoPacketHeader (m_rgmbmd[m_iVPMBnum].m_stepSize);
  563. bRestartDelayedQP = TRUE;
  564. }
  566. DataPartitioningMotionCoding(m_iVPMBnum, iVPlastMBnum, &m_statsVP, iCoefQ_DP);
  568. m_pbitstrmOut -> putBits (DC_MARKER, NUMBITS_DP_DC_MARKER, "DC_marker");
  569. m_statsVP.nBitsHead += NUMBITS_DP_DC_MARKER;
  571. DataPartitioningTextureCoding(m_iVPMBnum, iVPlastMBnum, &m_statsVP, iCoefQ_DP);
  573. //assert( iVPtotal + m_statsVP.nBitsHead == (int) m_statsVP.total() );
  575. m_iVPMBnum = iVPlastMBnum + 1;
  577. // Set not to output but count bitstream
  578. m_pbitstrmOut->SetDontSendBits(TRUE);
  579. }
  581. }
  583. MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
  584. m_rgpmbmAbove = m_rgpmbmCurr;
  585. m_rgpmbmCurr  = ppmbmTemp;
  586. ppxlcRefY  += m_iFrameWidthYxMBSize;
  587. ppxlcRefU  += m_iFrameWidthUVxBlkSize;
  588. ppxlcRefV  += m_iFrameWidthUVxBlkSize;
  590. ppxlcOrigY += m_iFrameWidthYxMBSize;
  591. ppxlcOrigU += m_iFrameWidthUVxBlkSize;
  592. ppxlcOrigV += m_iFrameWidthUVxBlkSize;
  593. }
  595. // delete CoefQ_DP
  596. for( Int iMB = 0; iMB < m_iNumMB; iMB++ )  {
  597. for (Int iBlk = 0; iBlk < 6; iBlk++) {
  598. delete [] iCoefQ_DP [iMB] [iBlk];
  599. }
  600. delete [] iCoefQ_DP[iMB];
  601. }
  602. delete [] iCoefQ_DP;
  604. // Set to output bitstream
  605. m_pbitstrmOut->SetDontSendBits(FALSE);
  606. }
  609. Void CVideoObjectEncoder::DataPartitioningMotionCoding(Int iVPMBnum, Int iVPlastMBnum, CStatistics* m_statsVP, Int*** iCoefQ_DP)
  610. {
  611. assert( m_volmd.bDataPartitioning );
  613. Int iMBnum;
  614. CMBMode* pmbmd;
  615. CMotionVector* pmv = m_rgmv;
  616. Int iMBX, iMBY;
  618. for(iMBnum = iVPMBnum, pmbmd = m_rgmbmd+iVPMBnum, pmv = m_rgmv+iVPMBnum*PVOP_MV_PER_REF_PER_MB;
  619. iMBnum <= iVPlastMBnum; iMBnum++, pmbmd++, pmv+=PVOP_MV_PER_REF_PER_MB) {
  620. iMBX = iMBnum % m_iNumMBX;
  621. iMBY = iMBnum / m_iNumMBX;
  622. #ifdef __TRACE_AND_STATS_
  623. m_pbitstrmOut->trace (CSite (iMBX, iMBY), "Motion_MB_X_Y");
  624. #endif // __TRACE_AND_STATS_
  625. if( m_volmd.fAUsage != RECTANGLE ) {
  626. m_statsVP->nBitsShape += dumpCachedShapeBits_DP(iMBnum);
  627. }
  629. if (pmbmd -> m_rgTranspStatus [0] != ALL) {
  630. if( m_vopmd.vopPredType==PVOP ) {
  631. m_pbitstrmOut->putBits (pmbmd->m_bSkip, 1, "MB_Skip");
  632. m_statsVP->nBitsCOD++;
  633. }
  635. if (!pmbmd->m_bSkip) {
  636. UInt CBPC = (pmbmd->getCodedBlockPattern (U_BLOCK) << 1)
  637. | pmbmd->getCodedBlockPattern (V_BLOCK);
  638. //per defintion of H.263's CBPC 
  639. assert (CBPC >= 0 && CBPC <= 3);
  641. Int iMBtype; //per H.263's MBtype
  642. Int iSymbol;
  643. switch( m_vopmd.vopPredType ) {
  644. case PVOP:
  645. if (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ)
  646. iMBtype = pmbmd->m_dctMd + 3;
  647. else
  648. iMBtype = (pmbmd -> m_dctMd - 2) | pmbmd -> m_bhas4MVForward << 1;
  649. assert (iMBtype >= 0 && iMBtype <= 4);
  650. #ifdef __TRACE_AND_STATS_
  651. m_pbitstrmOut->trace (iMBtype, "MB_MBtype");
  652. m_pbitstrmOut->trace (CBPC, "MB_CBPC");
  653. #endif // __TRACE_AND_STATS_
  654. m_statsVP->nBitsMCBPC += m_pentrencSet->m_pentrencMCBPCinter->encodeSymbol (iMBtype * 4 + CBPC, "MCBPC");
  655. break;
  656. case IVOP:
  657. iSymbol = 4 * pmbmd->m_dctMd + CBPC;
  658. assert (iSymbol >= 0 && iSymbol <= 7); //send MCBPC
  659. #ifdef __TRACE_AND_STATS_
  660. m_pbitstrmOut->trace (CBPC, "MB_CBPC");
  661. #endif // __TRACE_AND_STATS_
  662. m_statsVP->nBitsMCBPC += m_pentrencSet->m_pentrencMCBPCintra->encodeSymbol (iSymbol, "MB_MCBPC");
  663. break;
  664. default:
  665. assert(FALSE);
  666. }
  668. if ( m_vopmd.vopPredType == IVOP ) {
  669. if( pmbmd->m_dctMd == INTRAQ) {
  670. Int DQUANT = pmbmd->m_intStepDelta; //send DQUANT
  671. assert (DQUANT >= -2 && DQUANT <= 2);
  672. if (DQUANT != 0) {
  673. if (sign (DQUANT) == 1)
  674. m_pbitstrmOut->putBits (DQUANT + 1, 2, "MB_DQUANT");
  675. else
  676. m_pbitstrmOut->putBits (-1 - DQUANT, 2, "MB_DQUANT");
  677. m_statsVP->nBitsDQUANT += 2;
  678. }
  679. }  
  681. UInt iBlk = 0;
  682. for (iBlk = Y_BLOCK1; iBlk <= V_BLOCK; iBlk++) {
  683. UInt nBits = 0;
  684. #ifdef __TRACE_AND_STATS_
  685. m_pbitstrmOut->trace (iBlk, "BLK_NO");
  686. #endif // __TRACE_AND_STATS_
  687. if (iBlk < U_BLOCK)
  688. if (pmbmd -> m_rgTranspStatus [iBlk] == ALL) continue;
  689. Int* rgiCoefQ = iCoefQ_DP [iMBnum][iBlk - 1];
  690. #ifdef __TRACE_AND_STATS_
  691. m_pbitstrmOut->trace (rgiCoefQ[0], "IntraDC");
  692. #endif // __TRACE_AND_STATS_
  693. if (pmbmd->m_bCodeDcAsAc != TRUE) {
  694. nBits = sendIntraDC (rgiCoefQ, (BlockNum) iBlk);
  695. }
  696. switch (iBlk) {
  697. case U_BLOCK: 
  698. m_statsVP->nBitsCr += nBits;
  699. break;
  700. case V_BLOCK: 
  701. m_statsVP->nBitsCb += nBits;
  702. break;
  703. default:
  704. m_statsVP->nBitsY += nBits;
  705. }
  706. }
  707. }
  709. if (pmbmd->m_dctMd != INTRA && pmbmd->m_dctMd != INTRAQ) {
  710. if( m_volmd.fAUsage == RECTANGLE )
  711. m_statsVP->nBitsMV += encodeMVVP (pmv, pmbmd, iMBX, iMBY);
  712. else
  713. m_statsVP->nBitsMV += encodeMVWithShape (pmv, pmbmd, iMBX, iMBY);
  714. }
  715. }
  716. }
  717. }
  718. }
  720. Void CVideoObjectEncoder::DataPartitioningTextureCoding(Int iVPMBnum, Int iVPlastMBnum, CStatistics* m_statsVP, Int*** iCoefQ_DP)
  721. {
  722. assert( m_volmd.bDataPartitioning );
  724. Int iMBnum;
  725. CMBMode* pmbmd;
  726. CMotionVector* pmv = m_rgmv;
  727. Int iMBX, iMBY;
  729. for(iMBnum = iVPMBnum, pmbmd = m_rgmbmd+iVPMBnum, pmv = m_rgmv+iVPMBnum*PVOP_MV_PER_REF_PER_MB;
  730. iMBnum <= iVPlastMBnum; iMBnum++, pmbmd++, pmv+=PVOP_MV_PER_REF_PER_MB) {
  731. if (pmbmd->m_bSkip || pmbmd -> m_rgTranspStatus [0] == ALL)
  732. continue;
  734. iMBX = iMBnum % m_iNumMBX;
  735. iMBY = iMBnum / m_iNumMBX;
  736. #ifdef __TRACE_AND_STATS_
  737. m_pbitstrmOut->trace (CSite (iMBX, iMBY), "TextureHeader_MB_X_Y");
  738. #endif // __TRACE_AND_STATS_
  739. Int CBPY = 0;
  740. UInt cNonTrnspBlk = 0, iBlk;
  741. for (iBlk = (UInt) Y_BLOCK1; iBlk <= (UInt) Y_BLOCK4; iBlk++) {
  742. if (pmbmd->m_rgTranspStatus [iBlk] != ALL)
  743. cNonTrnspBlk++;
  744. }
  745. UInt iBitPos = 1;
  746. for (iBlk = (UInt) Y_BLOCK1; iBlk <= (UInt) Y_BLOCK4; iBlk++) {
  747. if (pmbmd->m_rgTranspStatus [iBlk] != ALL) {
  748. CBPY |= pmbmd->getCodedBlockPattern ((BlockNum) iBlk) << (cNonTrnspBlk - iBitPos);
  749. iBitPos++;
  750. }
  751. }
  752. assert (CBPY >= 0 && CBPY <= 15); //per defintion of H.263's CBPY 
  753. if (m_volmd.fAUsage == RECTANGLE)
  754. assert (cNonTrnspBlk==4); // Only all opaque is only supportedin DP mode at present
  756. if (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ) {
  757. m_pbitstrmOut->putBits (pmbmd->m_bACPrediction, 1, "MB_ACPRED");
  758. m_statsVP->nBitsIntraPred++;
  759. #ifdef __TRACE_AND_STATS_
  760. m_pbitstrmOut->trace (cNonTrnspBlk, "MB_NumNonTranspBlks");
  761. m_pbitstrmOut->trace (CBPY, "MB_CBPY (I-style)");
  762. #endif // __TRACE_AND_STATS_
  763. switch (cNonTrnspBlk) {
  764. case 1:
  765. m_statsVP->nBitsCBPY += m_pentrencSet->m_pentrencCBPY1->encodeSymbol (CBPY, "MB_CBPY1");
  766. break;
  767. case 2:
  768. m_statsVP->nBitsCBPY += m_pentrencSet->m_pentrencCBPY2->encodeSymbol (CBPY, "MB_CBPY2");
  769. break;
  770. case 3:
  771. m_statsVP->nBitsCBPY += m_pentrencSet->m_pentrencCBPY3->encodeSymbol (CBPY, "MB_CBPY3");
  772. break;
  773. case 4:
  774. m_statsVP->nBitsCBPY += m_pentrencSet->m_pentrencCBPY->encodeSymbol (CBPY, "MB_CBPY");
  775. break;
  776. default:
  777. assert (FALSE);
  778. }
  779. m_statsVP->nIntraMB++;
  780. }
  781. else {
  782. #ifdef __TRACE_AND_STATS_
  783. m_pbitstrmOut->trace (cNonTrnspBlk, "MB_NumNonTranspBlks");
  784. m_pbitstrmOut->trace (CBPY, "MB_CBPY (P-style)");
  785. #endif // __TRACE_AND_STATS_
  786. switch (cNonTrnspBlk) {
  787. case 1:
  788. m_statsVP->nBitsCBPY += m_pentrencSet->m_pentrencCBPY1->encodeSymbol (1 - CBPY, "MB_CBPY1");
  789. break;
  790. case 2:
  791. m_statsVP->nBitsCBPY += m_pentrencSet->m_pentrencCBPY2->encodeSymbol (3 - CBPY, "MB_CBPY2");
  792. break;
  793. case 3:
  794. m_statsVP->nBitsCBPY += m_pentrencSet->m_pentrencCBPY3->encodeSymbol (7 - CBPY, "MB_CBPY3");
  795. break;
  796. case 4:
  797. m_statsVP->nBitsCBPY += m_pentrencSet->m_pentrencCBPY->encodeSymbol (15 - CBPY, "MB_CBPY");
  798. break;
  799. default:
  800. assert (FALSE);
  801. }
  802. }
  804. if ( m_vopmd.vopPredType != IVOP &&
  805. (pmbmd->m_dctMd == INTERQ || pmbmd->m_dctMd == INTRAQ)) {
  806. Int DQUANT = pmbmd->m_intStepDelta; //send DQUANT
  807. assert (DQUANT >= -2 && DQUANT <= 2);
  808. if (DQUANT != 0) {
  809. if (sign (DQUANT) == 1)
  810. m_pbitstrmOut->putBits (DQUANT + 1, 2, "MB_DQUANT");
  811. else
  812. m_pbitstrmOut->putBits (-1 - DQUANT, 2, "MB_DQUANT");
  813. m_statsVP->nBitsDQUANT += 2;
  814. }
  815. }  
  817. if (m_vopmd.vopPredType != IVOP &&
  818. (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ)) {
  819. UInt iBlk = 0;
  820. for (iBlk = Y_BLOCK1; iBlk <= V_BLOCK; iBlk++) {
  821. UInt nBits = 0;
  822. #ifdef __TRACE_AND_STATS_
  823. m_pbitstrmOut->trace (iBlk, "BLK_NO");
  824. #endif // __TRACE_AND_STATS_
  825. if (iBlk < U_BLOCK)
  826. if (pmbmd -> m_rgTranspStatus [iBlk] == ALL) continue;
  827. //// Int* rgiCoefQ = m_rgpiCoefQ [iBlk - 1];
  828. Int* rgiCoefQ = iCoefQ_DP [iMBnum][iBlk - 1];
  829. #ifdef __TRACE_AND_STATS_
  830. //// m_pbitstrmOut->trace (rgiCoefQ, BLOCK_SQUARE_SIZE, "BLK_QUANTIZED_COEF");
  831. m_pbitstrmOut->trace (rgiCoefQ[0], "IntraDC");
  832. #endif // __TRACE_AND_STATS_
  833. //// Int iCoefStart = 0;
  834. if (pmbmd->m_bCodeDcAsAc != TRUE) {
  835. //// iCoefStart = 1;
  836. nBits = sendIntraDC (rgiCoefQ, (BlockNum) iBlk);
  837. }
  838. switch (iBlk) {
  839. case U_BLOCK: 
  840. m_statsVP->nBitsCr += nBits;
  841. break;
  842. case V_BLOCK: 
  843. m_statsVP->nBitsCb += nBits;
  844. break;
  845. default:
  846. m_statsVP->nBitsY += nBits;
  847. }
  848. }
  849. }
  850. }
  852. for(iMBnum = iVPMBnum, pmbmd = m_rgmbmd+iVPMBnum, pmv = m_rgmv+iVPMBnum*PVOP_MV_PER_REF_PER_MB;
  853. iMBnum <= iVPlastMBnum; iMBnum++, pmbmd++, pmv+=PVOP_MV_PER_REF_PER_MB) {
  854. if (pmbmd->m_bSkip || pmbmd -> m_rgTranspStatus [0] == ALL)
  855. continue;
  857. iMBX = iMBnum % m_iNumMBX;
  858. iMBY = iMBnum / m_iNumMBX;
  859. #ifdef __TRACE_AND_STATS_
  860. m_pbitstrmOut->trace (CSite (iMBX, iMBY), "TextureTcoef_MB_X_Y");
  861. #endif // __TRACE_AND_STATS_
  862. if (pmbmd->m_dctMd == INTRA || pmbmd->m_dctMd == INTRAQ) {
  863. UInt iBlk = 0;
  864. for (iBlk = Y_BLOCK1; iBlk <= V_BLOCK; iBlk++) {
  865. UInt nBits = 0;
  866. #ifdef __TRACE_AND_STATS_
  867. m_pbitstrmOut->trace (iBlk, "BLK_NO");
  868. #endif // __TRACE_AND_STATS_
  869. if (iBlk < U_BLOCK)
  870. if (pmbmd -> m_rgTranspStatus [iBlk] == ALL) continue;
  871. //// Int* rgiCoefQ = m_rgpiCoefQ [iBlk - 1];
  872. Int* rgiCoefQ = iCoefQ_DP [iMBnum][iBlk - 1];
  873. #ifdef __TRACE_AND_STATS_
  874. m_pbitstrmOut->trace (rgiCoefQ, BLOCK_SQUARE_SIZE, "BLK_QUANTIZED_COEF");
  875. #endif // __TRACE_AND_STATS_
  876. Int iCoefStart;
  877. if (pmbmd->m_bCodeDcAsAc != TRUE) {
  878. iCoefStart = 1;
  879. } else {
  880. iCoefStart = 0;
  881. }
  882. if (pmbmd->getCodedBlockPattern ((BlockNum) iBlk)) {
  883. Int* rgiZigzag = grgiStandardZigzag;
  884. if (pmbmd->m_bACPrediction)
  885. rgiZigzag = (pmbmd->m_preddir [iBlk - 1] == HORIZONTAL) ? grgiVerticalZigzag : grgiHorizontalZigzag;
  886. if( m_volmd.bReversibleVlc == TRUE )
  887. nBits += sendTCOEFIntraRVLC (rgiCoefQ, iCoefStart, rgiZigzag, FALSE);
  888. else
  889. nBits += sendTCOEFIntra (rgiCoefQ, iCoefStart, rgiZigzag);
  890. }
  891. switch (iBlk) {
  892. case U_BLOCK: 
  893. m_statsVP->nBitsCr += nBits;
  894. break;
  895. case V_BLOCK: 
  896. m_statsVP->nBitsCb += nBits;
  897. break;
  898. default:
  899. m_statsVP->nBitsY += nBits;
  900. }
  901. }
  902. } else {
  903. UInt nBits, iBlk = 0;
  904. for (iBlk = Y_BLOCK1; iBlk <= V_BLOCK; iBlk++) {
  905. #ifdef __TRACE_AND_STATS_
  906. m_pbitstrmOut->trace (iBlk, "BLK_NO");
  907. #endif // __TRACE_AND_STATS_
  908. if (iBlk < U_BLOCK)
  909. if (pmbmd -> m_rgTranspStatus [iBlk] == ALL) continue;
  910. if (pmbmd->getCodedBlockPattern ((BlockNum) iBlk)) {
  911. //// Int* rgiCoefQ = m_rgpiCoefQ [iBlk - 1];
  912. Int* rgiCoefQ = iCoefQ_DP [iMBnum][iBlk - 1];
  913. #ifdef __TRACE_AND_STATS_
  914. m_pbitstrmOut->trace (rgiCoefQ, BLOCK_SQUARE_SIZE, "BLK_QUANTIZED_COEF");
  915. #endif // __TRACE_AND_STATS_
  916. if( m_volmd.bReversibleVlc == TRUE )
  917. nBits = sendTCOEFInterRVLC (rgiCoefQ, 0, grgiStandardZigzag, FALSE);
  918. else
  919. nBits = sendTCOEFInter (rgiCoefQ, 0, grgiStandardZigzag);
  921. switch (iBlk) {
  922. case U_BLOCK: 
  923. m_statsVP->nBitsCr += nBits;
  924. break;
  925. case V_BLOCK: 
  926. m_statsVP->nBitsCb += nBits;
  927. break;
  928. default:
  929. m_statsVP->nBitsY += nBits;
  930. }
  931. }
  932. }
  933. }
  934. }
  935. }
  938. Void CVideoObjectEncoder::encodeNSForIVOP_WithShape_DP ()
  939. {
  940. assert( m_volmd.bDataPartitioning );
  941. assert( m_vopmd.vopPredType==IVOP );
  942. assert( m_volmd.fAUsage == ONE_BIT && m_volmd.bShapeOnly == FALSE );
  943. assert(m_volmd.nBits==8);
  945. //in case the IVOP is used as an ref for direct mode
  946. memset (m_rgmv, 0, m_iNumMB * PVOP_MV_PER_REF_PER_MB * sizeof (CMotionVector));
  947. //#ifdef __SHARP_FIX_
  948. memset (m_rgmvBY, 0, m_iNumMB * sizeof (CMotionVector));
  949. //#endif
  951. Int iMBX, iMBY;
  952. CMBMode* pmbmd = m_rgmbmd;
  953. Int iQPPrev = m_vopmd.intStepI; //initialization
  955. Int iVPCounter = m_statsVOP.total();
  956. Int iVPtotal;
  957. m_iVPMBnum = 0;
  958. CStatistics m_statsVP;
  959. // DCT coefficient buffer for Data Partitioning mode
  960. Int*** iCoefQ_DP = new Int** [m_iNumMB];
  961. // Set not to output but count bitstream
  962. // m_pbitstrmOut->SetDontSendBits(TRUE);
  964. PixelC* ppxlcRefY  = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
  965. PixelC* ppxlcRefU  = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
  966. PixelC* ppxlcRefV  = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
  967. PixelC* ppxlcRefBY = (PixelC*) m_pvopcRefQ1->pixelsBY () + m_iStartInRefToCurrRctY;
  968. PixelC* ppxlcRefBUV = (PixelC*) m_pvopcRefQ1->pixelsBUV () + m_iStartInRefToCurrRctUV;
  969. PixelC *ppxlcRefA = (PixelC*) m_pvopcRefQ1->pixelsA () + m_iStartInRefToCurrRctY;
  971. PixelC* ppxlcOrigY = (PixelC*) m_pvopcOrig->pixelsBoundY ();
  972. PixelC* ppxlcOrigU = (PixelC*) m_pvopcOrig->pixelsBoundU ();
  973. PixelC* ppxlcOrigV = (PixelC*) m_pvopcOrig->pixelsBoundV ();
  974. PixelC* ppxlcOrigBY = (PixelC*) m_pvopcOrig->pixelsBoundBY ();
  975. PixelC* ppxlcOrigA = (PixelC*) m_pvopcOrig->pixelsBoundA ();
  977. Bool bRestartDelayedQP = TRUE;
  979. for (iMBY = 0; iMBY < m_iNumMBY; iMBY++) {
  980. PixelC* ppxlcRefMBY  = ppxlcRefY;
  981. PixelC* ppxlcRefMBU  = ppxlcRefU;
  982. PixelC* ppxlcRefMBV  = ppxlcRefV;
  983. PixelC* ppxlcRefMBBY = ppxlcRefBY;
  984. PixelC* ppxlcRefMBBUV = ppxlcRefBUV;
  985. PixelC* ppxlcRefMBA  = ppxlcRefA;
  986. PixelC* ppxlcOrigMBY = ppxlcOrigY;
  987. PixelC* ppxlcOrigMBU = ppxlcOrigU;
  988. PixelC* ppxlcOrigMBV = ppxlcOrigV;
  989. PixelC* ppxlcOrigMBBY = ppxlcOrigBY;
  990. PixelC* ppxlcOrigMBA = ppxlcOrigA;
  991. for (iMBX = 0; iMBX < m_iNumMBX; iMBX++) {
  992. #ifdef __TRACE_AND_STATS_
  993. m_pbitstrmOut->trace (CSite (iMBX, iMBY), "MB_X_Y");
  994. #endif // __TRACE_AND_STATS_
  995. pmbmd->m_stepSize = iQPPrev + pmbmd->m_intStepDelta;
  997. if(bRestartDelayedQP)
  998. pmbmd->m_stepSizeDelayed = pmbmd->m_stepSize;
  999. else
  1000. pmbmd->m_stepSizeDelayed = iQPPrev;
  1002. Int iVPlastMBnum = iMBY * m_iNumMBX + iMBX;
  1004. // shape bitstream is set to shape cache
  1005. m_pbitstrmShapeMBOut = m_pbitstrmShape_DP[iVPlastMBnum];
  1006. m_statsMB.reset ();
  1008. pmbmd->m_bSkip = FALSE; //reset for direct mode 
  1009. pmbmd->m_bPadded=FALSE;
  1010. copyToCurrBuffWithShape (
  1011. ppxlcOrigMBY, ppxlcOrigMBU, ppxlcOrigMBV, 
  1012. ppxlcOrigMBBY, ppxlcOrigMBA,
  1013. m_iFrameWidthY, m_iFrameWidthUV
  1014. );
  1015. downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV); // downsample original BY now for LPE padding (using original shape)
  1016. decideTransparencyStatus (pmbmd, m_ppxlcCurrMBBY);
  1017. if (pmbmd -> m_rgTranspStatus [0] == PARTIAL) {
  1018. LPEPadding (pmbmd);
  1019. m_statsMB.nBitsShape += codeIntraShape (ppxlcRefMBBY, pmbmd, iMBX, iMBY);
  1020. downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV);
  1021. decideTransparencyStatus (pmbmd, m_ppxlcCurrMBBY); // need to modify it a little (NONE block won't change)
  1022. }
  1023. else
  1024. m_statsMB.nBitsShape += codeIntraShape (ppxlcRefMBBY, pmbmd, iMBX, iMBY);
  1025. if(m_volmd.bShapeOnly == FALSE) {
  1026. // // Set not to output but count bitstream
  1027. m_pbitstrmOut->SetDontSendBits(TRUE);
  1029. if (pmbmd -> m_rgTranspStatus [0] != ALL) {
  1030. pmbmd->m_stepSize = iQPPrev + pmbmd->m_intStepDelta;
  1031. bRestartDelayedQP = FALSE;
  1033. Int iQuantMax = (1<<m_volmd.uiQuantPrecision) - 1;
  1034. assert (pmbmd->m_stepSize <= iQuantMax && pmbmd->m_stepSize > 0);
  1035. iQPPrev = pmbmd->m_stepSize;
  1036. if (pmbmd->m_intStepDelta == 0)
  1037. pmbmd->m_dctMd = INTRA;
  1038. else
  1039. pmbmd->m_dctMd = INTRAQ;
  1040. quantizeTextureIntraMB (iMBX, iMBY, pmbmd, ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA);
  1041. codeMBTextureHeadOfIVOP (pmbmd);
  1042. sendDCTCoefOfIntraMBTexture (pmbmd);
  1044. // MC padding
  1045. if (pmbmd -> m_rgTranspStatus [0] == PARTIAL)
  1046. mcPadCurrMB (ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA);
  1047. padNeighborTranspMBs (
  1048. iMBX, iMBY,
  1049. pmbmd,
  1050. ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA
  1051. );
  1052. }
  1053. else {
  1054. padCurrAndTopTranspMBFromNeighbor (
  1055. iMBX, iMBY,
  1056. pmbmd,
  1057. ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA
  1058. );
  1059. }
  1060. // // Set to output bitstream
  1061. m_pbitstrmOut->SetDontSendBits(FALSE);
  1062. }
  1064. // copy DCT coefficient to buffer
  1065. iCoefQ_DP[iVPlastMBnum] = new Int* [6];
  1066. Int iBlk;
  1067. for (iBlk = 0; iBlk < 6; iBlk++) {
  1068. iCoefQ_DP [iVPlastMBnum] [iBlk] = new Int [BLOCK_SQUARE_SIZE];
  1070. for( Int t = 0; t < BLOCK_SQUARE_SIZE; t++ )
  1071. iCoefQ_DP[iVPlastMBnum][iBlk][t] = m_rgpiCoefQ[iBlk][t];
  1072. }
  1074. ppxlcRefMBA += MB_SIZE;
  1075. ppxlcOrigMBBY += MB_SIZE;
  1076. ppxlcOrigMBA += MB_SIZE;
  1077. pmbmd++;
  1078. #ifdef __TRACE_AND_STATS_
  1079. m_statsVOP   += m_statsMB;
  1080. #endif // __TRACE_AND_STATS_
  1081. ppxlcRefMBY  += MB_SIZE;
  1082. ppxlcRefMBU  += BLOCK_SIZE;
  1083. ppxlcRefMBV  += BLOCK_SIZE;
  1084. ppxlcRefMBBY += MB_SIZE;
  1085. ppxlcRefMBBUV += BLOCK_SIZE;
  1086. ppxlcOrigMBY += MB_SIZE;
  1087. ppxlcOrigMBU += BLOCK_SIZE;
  1088. ppxlcOrigMBV += BLOCK_SIZE;
  1090. iVPtotal = (int) m_statsVOP.total() - iVPCounter;
  1091. if( iVPtotal > m_volmd.bVPBitTh || iVPlastMBnum == m_iNumMB-1 /* last MB in a VOP */) {
  1092. // Set to output bitstream
  1093. m_pbitstrmOut->SetDontSendBits(FALSE);
  1094. // encode video packet
  1095. iVPCounter = m_statsVOP.total();
  1096. m_statsVP.reset();
  1097. if( m_iVPMBnum > 0 )
  1098. {
  1099. m_statsVP.nBitsHead = codeVideoPacketHeader (m_rgmbmd[m_iVPMBnum].m_stepSize);
  1100. bRestartDelayedQP = TRUE;
  1101. }
  1103. DataPartitioningMotionCoding(m_iVPMBnum, iVPlastMBnum, &m_statsVP, iCoefQ_DP);
  1105. m_pbitstrmOut -> putBits (DC_MARKER, NUMBITS_DP_DC_MARKER, "DC_marker");
  1106. m_statsVP.nBitsHead += NUMBITS_DP_DC_MARKER;
  1108. DataPartitioningTextureCoding(m_iVPMBnum, iVPlastMBnum, &m_statsVP, iCoefQ_DP);
  1110. assert( iVPtotal + m_statsVP.nBitsHead ==  m_statsVP.total() );
  1112. m_iVPMBnum = iVPlastMBnum + 1;
  1113. }
  1114. }
  1116. MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
  1117. m_rgpmbmAbove = m_rgpmbmCurr;
  1118. m_rgpmbmCurr  = ppmbmTemp;
  1119. ppxlcRefY  += m_iFrameWidthYxMBSize;
  1120. ppxlcRefA  += m_iFrameWidthYxMBSize;
  1121. ppxlcRefU  += m_iFrameWidthUVxBlkSize;
  1122. ppxlcRefV  += m_iFrameWidthUVxBlkSize;
  1123. ppxlcRefBY += m_iFrameWidthYxMBSize;
  1124. ppxlcRefBUV += m_iFrameWidthUVxBlkSize;
  1126. ppxlcOrigY += m_iFrameWidthYxMBSize;
  1127. ppxlcOrigBY += m_iFrameWidthYxMBSize;
  1128. ppxlcOrigA += m_iFrameWidthYxMBSize;
  1129. ppxlcOrigU += m_iFrameWidthUVxBlkSize;
  1130. ppxlcOrigV += m_iFrameWidthUVxBlkSize;
  1131. }
  1133. // delete CoefQ_DP
  1134. for( Int iMB = 0; iMB < m_iNumMB; iMB++ )  {
  1135. for (Int iBlk = 0; iBlk < 6; iBlk++) {
  1136. delete [] iCoefQ_DP [iMB] [iBlk];
  1137. }
  1138. delete [] iCoefQ_DP[iMB];
  1139. }
  1140. delete [] iCoefQ_DP;
  1142. // restore normal output stream
  1143. m_pbitstrmShapeMBOut = m_pbitstrmOut;
  1145. // Set to output bitstream
  1146. m_pbitstrmOut->SetDontSendBits(FALSE);
  1147. }
  1149. Void CVideoObjectEncoder::encodeNSForPVOP_WithShape_DP ()
  1150. {
  1151. assert( m_volmd.bDataPartitioning );
  1152. assert( m_vopmd.vopPredType==PVOP );
  1153. assert( m_volmd.fAUsage == ONE_BIT && m_volmd.bShapeOnly == FALSE );
  1154. assert(m_volmd.nBits==8);
  1156. Int iMBX, iMBY;
  1158. motionEstPVOP_WithShape ();
  1160. // Rate Control
  1161. if (m_uiRateControl == RC_MPEG4) {
  1162. Double Ec = m_iMAD / (Double) (m_iNumMBY * m_iNumMBX * 16 * 16);
  1163. m_statRC.setMad (Ec);
  1164. if (m_statRC.noCodedFrame () >= RC_START_RATE_CONTROL) {
  1165. UInt newQStep = m_statRC.updateQuanStepsize ();
  1166. m_vopmd.intStepDiff = newQStep - m_vopmd.intStep; // DQUANT
  1167. m_vopmd.intStep = newQStep;
  1168. }
  1169. cout << "t" << "Q:" << "ttt" << m_vopmd.intStep << "n";
  1170. m_statRC.setQc (m_vopmd.intStep);
  1171. }
  1173. CoordI y = m_rctCurrVOPY.top; 
  1174. CMBMode* pmbmd = m_rgmbmd;
  1175. Int iQPPrev = m_vopmd.intStep;
  1176. Int iQPPrevAlpha = m_vopmd.intStepPAlpha;
  1177. CMotionVector* pmv = m_rgmv;
  1178. CMotionVector* pmvBY = m_rgmvBY;
  1180. Int iVPCounter = m_statsVOP.total();
  1181. Int iVPtotal;
  1182. m_iVPMBnum = 0;
  1183. CStatistics m_statsVP;
  1184. // DCT coefficient buffer for Data Partitioning mode
  1185. Int*** iCoefQ_DP = new Int** [m_iNumMB];
  1187. PixelC* ppxlcRefY = (PixelC*) m_pvopcRefQ1->pixelsY () + m_iStartInRefToCurrRctY;
  1188. PixelC* ppxlcRefU = (PixelC*) m_pvopcRefQ1->pixelsU () + m_iStartInRefToCurrRctUV;
  1189. PixelC* ppxlcRefV = (PixelC*) m_pvopcRefQ1->pixelsV () + m_iStartInRefToCurrRctUV;
  1190. PixelC* ppxlcRefBY = (PixelC*) m_pvopcRefQ1->pixelsBY () + m_iStartInRefToCurrRctY;
  1191. PixelC* ppxlcRefBUV = (PixelC*) m_pvopcRefQ1->pixelsBUV () + m_iStartInRefToCurrRctUV;
  1192. PixelC *ppxlcRefA = (PixelC*) m_pvopcRefQ1->pixelsA () + m_iStartInRefToCurrRctY;
  1194. PixelC* ppxlcOrigY = (PixelC*) m_pvopcOrig->pixelsBoundY ();
  1195. PixelC* ppxlcOrigU = (PixelC*) m_pvopcOrig->pixelsBoundU ();
  1196. PixelC* ppxlcOrigV = (PixelC*) m_pvopcOrig->pixelsBoundV ();
  1197. PixelC* ppxlcOrigBY = (PixelC*) m_pvopcOrig->pixelsBoundBY ();
  1198. PixelC* ppxlcOrigA = (PixelC*) m_pvopcOrig->pixelsBoundA ();
  1200. // Added for error resilient mode by Toshiba(1997-11-14)
  1201. Bool bCodeVPHeaderNext = FALSE; // needed only for OBMC
  1202. Int iTempVPMBnum = 0;
  1203. Int iCounter;
  1204. // End Toshiba(1997-11-14)
  1206. Bool bRestartDelayedQP = TRUE;
  1208. for (iMBY = 0; iMBY < m_iNumMBY; iMBY++, y += MB_SIZE) {
  1209. PixelC* ppxlcRefMBY = ppxlcRefY;
  1210. PixelC* ppxlcRefMBU = ppxlcRefU;
  1211. PixelC* ppxlcRefMBV = ppxlcRefV;
  1212. PixelC* ppxlcRefMBBY = ppxlcRefBY;
  1213. PixelC* ppxlcRefMBBUV = ppxlcRefBUV;
  1214. PixelC* ppxlcRefMBA = ppxlcRefA;
  1215. PixelC* ppxlcOrigMBY = ppxlcOrigY;
  1216. PixelC* ppxlcOrigMBU = ppxlcOrigU;
  1217. PixelC* ppxlcOrigMBV = ppxlcOrigV;
  1218. PixelC* ppxlcOrigMBBY = ppxlcOrigBY;
  1219. PixelC* ppxlcOrigMBA = ppxlcOrigA;
  1220. CoordI x = m_rctCurrVOPY.left;
  1222. #ifdef __TRACE_AND_STATS_
  1223. m_statsMB.reset ();
  1224. #endif // __TRACE_AND_STATS_
  1226. // initiate advance shape coding
  1227. // shape bitstream is set to shape cache
  1228. m_pbitstrmShapeMBOut = m_pbitstrmShape_DP[iMBY * m_iNumMBX];
  1229. // pmbmd->m_bPadded=FALSE;
  1230. // Added for error resilient mode by Toshiba(1997-11-14)
  1231. // The following operation is needed only for OBMC
  1232. // if( bCodeVPHeaderNext ) {
  1233. // iTempVPMBnum  = m_iVPMBnum;
  1234. // m_iVPMBnum = VPMBnum(0, iMBY);
  1235. // }
  1236. // End Toshiba(1997-11-14)
  1237. copyToCurrBuffJustShape (ppxlcOrigMBBY, m_iFrameWidthY);
  1238. // Modified for error resilient mode by Toshiba(1997-11-14)
  1239. ShapeMode shpmdColocatedMB;
  1240. if(m_vopmd.bShapeCodingType) {
  1241. shpmdColocatedMB = m_rgmbmdRef [
  1242. min (max (0, iMBY), m_iNumMBYRef - 1) * m_iNumMBXRef].m_shpmd;
  1243. encodePVOPMBJustShape(ppxlcRefMBBY, pmbmd, shpmdColocatedMB, pmv, pmvBY, x, y, 0, iMBY);
  1244. }
  1245. else {
  1246. m_statsMB.nBitsShape += codeIntraShape (ppxlcRefMBBY, pmbmd, 0, iMBY);
  1247. decideTransparencyStatus (pmbmd, m_ppxlcCurrMBBY); 
  1248. }
  1249. // if( bCodeVPHeaderNext )
  1250. // m_iVPMBnum = iTempVPMBnum;
  1251. // End Toshiba(1997-11-14)
  1252. if(pmbmd->m_bhas4MVForward)
  1253. padMotionVectors(pmbmd,pmv);
  1254. for (iMBX = 0; iMBX < m_iNumMBX; iMBX++, x += MB_SIZE) {
  1255. pmbmd->m_stepSize = iQPPrev + pmbmd->m_intStepDelta;
  1257. #ifdef __TRACE_AND_STATS_
  1258. m_pbitstrmOut->trace (CSite (iMBX, iMBY), "MB_X_Y (Texture)");
  1259. // shape quantization part
  1260. m_statsMB.reset ();
  1261. #endif // __TRACE_AND_STATS_
  1263. Int iVPlastMBnum = iMBY * m_iNumMBX + iMBX;
  1265. pmbmd->m_bPadded=FALSE;
  1267. if(iMBX<m_iNumMBX-1)
  1268. {
  1269. // shape bitstream is set to shape cache
  1270. m_pbitstrmShapeMBOut = m_pbitstrmShape_DP[iMBY * m_iNumMBX + iMBX + 1];
  1271. // Added for error resilient mode by Toshiba(1997-11-14)
  1272. // The following operation is needed only for OBMC
  1273. if( bCodeVPHeaderNext ) {
  1274. iTempVPMBnum  = m_iVPMBnum;
  1275. m_iVPMBnum = VPMBnum(iMBX+1, iMBY);
  1276. }
  1277. // End Toshiba(1997-11-14)
  1278. // code shape 1mb in advance
  1279. copyToCurrBuffJustShape (ppxlcOrigMBBY+MB_SIZE,m_iFrameWidthY);
  1280. // Modified for error resilient mode by Toshiba(1997-11-14)
  1281. if(m_vopmd.bShapeCodingType) {
  1282. shpmdColocatedMB = m_rgmbmdRef [
  1283. min (max (0, iMBX+1), m_iNumMBXRef-1) + 
  1284.   min (max (0, iMBY), m_iNumMBYRef-1) * m_iNumMBXRef
  1285. ].m_shpmd;
  1286. encodePVOPMBJustShape(
  1287. ppxlcRefMBBY+MB_SIZE, pmbmd+1,
  1288.  shpmdColocatedMB,
  1289.  pmv+PVOP_MV_PER_REF_PER_MB,
  1290.  pmvBY+1, x+MB_SIZE, y,
  1291.  iMBX+1, iMBY
  1292. );
  1293. }
  1294. else {
  1295. m_statsMB.nBitsShape
  1296. += codeIntraShape (
  1297. ppxlcRefMBBY+MB_SIZE,
  1298. pmbmd+1, iMBX+1, iMBY
  1299. );
  1300. decideTransparencyStatus (pmbmd+1,
  1301.  m_ppxlcCurrMBBY); 
  1302. }
  1303. // End Toshiba(1997-11-14)
  1305. // Added for error resilient mode by Toshiba(1997-11-14)
  1306. // The following operation is needed only for OBMC
  1307. if( bCodeVPHeaderNext )
  1308. m_iVPMBnum = iTempVPMBnum;
  1309. // End Toshiba(1997-11-14)
  1310. if((pmbmd+1)->m_bhas4MVForward)
  1311. padMotionVectors(pmbmd+1, pmv+PVOP_MV_PER_REF_PER_MB);
  1312. }
  1314. // Set not to output but count bitstream
  1315. m_pbitstrmOut->SetDontSendBits(TRUE);
  1317. // copy DCT coefficient to buffer
  1318. iCoefQ_DP[iVPlastMBnum] = new Int* [6];
  1319. Int iBlk;
  1320. for (iBlk = 0; iBlk < 6; iBlk++) {
  1321. iCoefQ_DP [iVPlastMBnum] [iBlk] = new Int [BLOCK_SQUARE_SIZE];
  1322. }
  1324. if(m_volmd.bShapeOnly==FALSE)
  1325. {
  1326. if (pmbmd -> m_rgTranspStatus [0] != ALL) {
  1327. // need to copy binary shape too since curr buff is future shape
  1328. copyToCurrBuffWithShape(ppxlcOrigMBY, ppxlcOrigMBU, ppxlcOrigMBV,
  1329. ppxlcRefMBBY, ppxlcOrigMBA, m_iFrameWidthY, m_iFrameWidthUV);
  1331. downSampleBY (m_ppxlcCurrMBBY, m_ppxlcCurrMBBUV);
  1333. encodePVOPMBTextureWithShape(ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA, pmbmd, pmv, iMBX, iMBY, x, y,
  1334. iQPPrev, iQPPrevAlpha, bRestartDelayedQP);
  1336. // copy DCT coefficient to buffer
  1337. for (iBlk = 0; iBlk < 6; iBlk++) {
  1338. for( Int t = 0; t < BLOCK_SQUARE_SIZE; t++ )
  1339. iCoefQ_DP[iVPlastMBnum][iBlk][t] = m_rgpiCoefQ[iBlk][t];
  1340. }
  1342. if (pmbmd -> m_rgTranspStatus [0] == PARTIAL)
  1343. mcPadCurrMB (ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA);
  1344. padNeighborTranspMBs (
  1345. iMBX, iMBY,
  1346. pmbmd,
  1347. ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA
  1348. );
  1349. }
  1350. else {
  1351. padCurrAndTopTranspMBFromNeighbor (
  1352. iMBX, iMBY,
  1353. pmbmd,
  1354. ppxlcRefMBY, ppxlcRefMBU, ppxlcRefMBV, ppxlcRefMBA
  1355. );
  1356. }
  1357. }
  1359. // Set to output bitstream
  1360. m_pbitstrmOut->SetDontSendBits(FALSE);
  1362. pmbmd++;
  1363. pmv += PVOP_MV_PER_REF_PER_MB;
  1364. pmvBY++;
  1365. ppxlcRefMBBY += MB_SIZE;
  1366. ppxlcRefMBA += MB_SIZE;
  1367. ppxlcRefMBBUV += BLOCK_SIZE;
  1368. ppxlcOrigMBBY += MB_SIZE;
  1369. ppxlcOrigMBA += MB_SIZE;
  1370. #ifdef __TRACE_AND_STATS_
  1371. m_statsVOP += m_statsMB;
  1372. #endif // __TRACE_AND_STATS_
  1373. ppxlcRefMBY += MB_SIZE;
  1374. ppxlcRefMBU += BLOCK_SIZE;
  1375. ppxlcRefMBV += BLOCK_SIZE;
  1376. ppxlcOrigMBY += MB_SIZE;
  1377. ppxlcOrigMBU += BLOCK_SIZE;
  1378. ppxlcOrigMBV += BLOCK_SIZE;
  1379. iVPtotal = (int) m_statsVOP.total() - iVPCounter;
  1380. if( bCodeVPHeaderNext || iVPlastMBnum == m_iNumMB-1 /* last MB in a VOP */) {
  1381. // Set to output bitstream
  1382. m_pbitstrmOut->SetDontSendBits(FALSE);
  1383. // encode video packet
  1384. iVPCounter = m_statsVOP.total();
  1385. m_statsVP.reset();
  1386. if( m_iVPMBnum > 0 )
  1387. {
  1388. m_statsVP.nBitsHead = codeVideoPacketHeader (m_rgmbmd[m_iVPMBnum].m_stepSize);
  1389. bRestartDelayedQP = TRUE;
  1390. }
  1392. DataPartitioningMotionCoding(m_iVPMBnum, iVPlastMBnum, &m_statsVP, iCoefQ_DP);
  1394. m_pbitstrmOut -> putBits (MOTION_MARKER, NUMBITS_DP_MOTION_MARKER, "motion_marker");
  1395. m_statsVP.nBitsHead += NUMBITS_DP_MOTION_MARKER;
  1397. DataPartitioningTextureCoding(m_iVPMBnum, iVPlastMBnum, &m_statsVP, iCoefQ_DP);
  1399. // assert( iVPtotal + m_statsVP.nBitsHead == (int) m_statsVP.total() );
  1401. m_iVPMBnum = iVPlastMBnum + 1;
  1402. }
  1403. // The following operation is needed only for OBMC
  1404. iCounter = m_statsVOP.total();
  1405. bCodeVPHeaderNext = iCounter - iVPCounter > m_volmd.bVPBitTh;
  1406. }
  1407. MacroBlockMemory** ppmbmTemp = m_rgpmbmAbove;
  1408. m_rgpmbmAbove = m_rgpmbmCurr;
  1409. m_rgpmbmCurr  = ppmbmTemp;
  1411. ppxlcRefY += m_iFrameWidthYxMBSize;
  1412. ppxlcRefU += m_iFrameWidthUVxBlkSize;
  1413. ppxlcRefV += m_iFrameWidthUVxBlkSize;
  1414. ppxlcRefBY += m_iFrameWidthYxMBSize;
  1415. ppxlcRefA += m_iFrameWidthYxMBSize;
  1416. ppxlcRefBUV += m_iFrameWidthUVxBlkSize;
  1418. ppxlcOrigY += m_iFrameWidthYxMBSize;
  1419. ppxlcOrigBY += m_iFrameWidthYxMBSize;
  1420. ppxlcOrigA += m_iFrameWidthYxMBSize;
  1421. ppxlcOrigU += m_iFrameWidthUVxBlkSize;
  1422. ppxlcOrigV += m_iFrameWidthUVxBlkSize;
  1423. }
  1425. // delete CoefQ_DP
  1426. for( Int iMB = 0; iMB < m_iNumMB; iMB++ )  {
  1427. for (Int iBlk = 0; iBlk < 6; iBlk++) {
  1428. delete [] iCoefQ_DP [iMB] [iBlk];
  1429. }
  1430. delete [] iCoefQ_DP[iMB];
  1431. }
  1432. delete [] iCoefQ_DP;
  1434. // restore normal output stream
  1435. m_pbitstrmShapeMBOut = m_pbitstrmOut;
  1437. // Set to output bitstream
  1438. m_pbitstrmOut->SetDontSendBits(FALSE);
  1439. }
  1441. //////////////////////////////////////////////////////////
  1442. ////  The following functions are for Reversible VLC  ////
  1443. //////////////////////////////////////////////////////////
  1445. UInt CVideoObjectEncoder::sendTCOEFIntraRVLC (const Int* rgiCoefQ, Int iStart, Int* rgiZigzag, Bool bDontSendBits)
  1446. {
  1447. assert( m_volmd.bDataPartitioning && m_volmd.bReversibleVlc );
  1449. Bool bIsFirstRun = TRUE;
  1450. Bool bIsLastRun = FALSE;
  1451. UInt uiCurrRun = 0;
  1452. UInt uiPrevRun = 0;
  1453. //Int  iCurrLevel = 0;
  1454. Int  iPrevLevel = 0;
  1455. //UInt uiCoefToStart = 0;
  1456. UInt numBits = 0;
  1458. for (Int j = iStart; j < BLOCK_SQUARE_SIZE; j++) {
  1459. if (rgiCoefQ [rgiZigzag [j]] == 0) // zigzag here
  1460. uiCurrRun++; // counting zeros
  1461. else {
  1462. if (!bIsFirstRun)
  1463. numBits += putBitsOfTCOEFIntraRVLC (uiPrevRun, iPrevLevel, bIsLastRun, bDontSendBits);
  1464. uiPrevRun = uiCurrRun;  // reset for next run
  1465. iPrevLevel = rgiCoefQ [rgiZigzag [j]]; 
  1466. uiCurrRun = 0;
  1467. bIsFirstRun = FALSE;
  1468. }
  1469. }
  1470. assert (uiPrevRun <= (BLOCK_SQUARE_SIZE - 1) - 1); // Some AC must be non-zero; at least for inter
  1471. bIsLastRun = TRUE;
  1472. numBits += putBitsOfTCOEFIntraRVLC (uiPrevRun, iPrevLevel, bIsLastRun, bDontSendBits);
  1473. return numBits;
  1474. }
  1476. UInt CVideoObjectEncoder::putBitsOfTCOEFIntraRVLC (UInt uiRun, Int iLevel, Bool bIsLastRun, Bool bDontSendBits)
  1477. {
  1478. assert(m_volmd.bDataPartitioning && m_volmd.bReversibleVlc );
  1480. UInt nBits = 0;
  1481. Long lVLCtableIndex;
  1482. if (bIsLastRun == FALSE) {
  1483. lVLCtableIndex = findVLCtableIndexOfNonLastEventIntraRVLC (bIsLastRun, uiRun, abs(iLevel));
  1484. if (lVLCtableIndex != NOT_IN_TABLE)  {
  1485. nBits += m_pentrencSet->m_pentrencDCTIntraRVLC->encodeSymbol(lVLCtableIndex, "Vlc_TCOEF_RVLC", bDontSendBits); // huffman encode 
  1486. if( !bDontSendBits )
  1487. m_pentrencSet->m_pentrencDCTIntraRVLC->bitstream()->putBits ((Char) invSignOf (iLevel), 1, "Sign_TCOEF_RVLC");
  1488. nBits++;
  1489. }
  1490. else
  1491. escapeEncodeRVLC (uiRun, iLevel, bIsLastRun, bDontSendBits);
  1492. }
  1493. else {
  1494. lVLCtableIndex = findVLCtableIndexOfLastEventIntraRVLC (bIsLastRun, uiRun, abs(iLevel));
  1495. if (lVLCtableIndex != NOT_IN_TABLE)  {
  1496. nBits += m_pentrencSet->m_pentrencDCTIntraRVLC->encodeSymbol(lVLCtableIndex, "Vlc_TCOEF_Last_RVLC", bDontSendBits); // huffman encode 
  1497. if( !bDontSendBits )
  1498. m_pentrencSet->m_pentrencDCTIntraRVLC->bitstream()->putBits ((Char) invSignOf (iLevel), 1, "Sign_TCOEF_Last_RVLC");
  1499. nBits++;
  1500. }
  1501. else
  1502. escapeEncodeRVLC (uiRun, iLevel, bIsLastRun, bDontSendBits);
  1503. }
  1504. return nBits;
  1505. }
  1507. Int CVideoObjectEncoder::findVLCtableIndexOfNonLastEventIntraRVLC (Bool bIsLastRun, UInt uiRun, UInt uiLevel)
  1508. {
  1509. assert( m_volmd.bDataPartitioning && m_volmd.bReversibleVlc );
  1510. assert (uiRun >= 0);
  1511. if (uiRun > 19 || (uiLevel > grgIfNotLastNumOfLevelAtRunIntraRVLC [uiRun]))
  1512. return NOT_IN_TABLE;
  1513. else {
  1514. UInt uiTableIndex = 0;
  1515. for (UInt i = 0; i < uiRun; i++)
  1516. uiTableIndex += grgIfNotLastNumOfLevelAtRunIntraRVLC [i];
  1517. uiTableIndex += uiLevel;
  1518. uiTableIndex--; // make it zero-based; see Table H13/H.263
  1519. return uiTableIndex;
  1520. }
  1521. }
  1523. Int CVideoObjectEncoder::findVLCtableIndexOfLastEventIntraRVLC (Bool bIsLastRun, UInt uiRun, UInt uiLevel)
  1524. {
  1525. assert( m_volmd.bDataPartitioning && m_volmd.bReversibleVlc );
  1526. assert (uiRun >= 0);
  1527. if (uiRun > 44 || (uiLevel > grgIfLastNumOfLevelAtRunIntraRVLC [uiRun]))
  1528. return NOT_IN_TABLE;
  1529. else {
  1530. UInt uiTableIndex = 0;
  1531. for (UInt i = 0; i < uiRun; i++)
  1532. uiTableIndex += grgIfLastNumOfLevelAtRunIntraRVLC [i];
  1533. uiTableIndex += uiLevel;
  1534. uiTableIndex += 102; // make it zero-based and 
  1535. return uiTableIndex; //correction of offset; see Table H13/H.263
  1536. }
  1537. }
  1539. UInt CVideoObjectEncoder::sendTCOEFInterRVLC (const Int* rgiCoefQ, Int iStart, Int* rgiZigzag, Bool bDontSendBits)
  1540. {
  1541. assert( m_volmd.bDataPartitioning && m_volmd.bReversibleVlc );
  1543. Bool bIsFirstRun = TRUE;
  1544. Bool bIsLastRun = FALSE;
  1545. UInt uiCurrRun = 0;
  1546. UInt uiPrevRun = 0;
  1547. //Int  iCurrLevel = 0;
  1548. Int  iPrevLevel = 0;
  1549. UInt numBits = 0;
  1551. for (Int j = iStart; j < BLOCK_SQUARE_SIZE; j++) {
  1552. if (rgiCoefQ [rgiZigzag [j]] == 0) // zigzag here
  1553. uiCurrRun++; // counting zeros
  1554. else {
  1555. if (!bIsFirstRun)
  1556. numBits += putBitsOfTCOEFInterRVLC (uiPrevRun, iPrevLevel, bIsLastRun, bDontSendBits);
  1557. uiPrevRun = uiCurrRun;  // reset for next run
  1558. iPrevLevel = rgiCoefQ [rgiZigzag [j]]; 
  1559. uiCurrRun = 0;
  1560. bIsFirstRun = FALSE;
  1561. }
  1562. }
  1563. assert (uiPrevRun <= (BLOCK_SQUARE_SIZE - 1)); // Some AC must be non-zero; at least for inter
  1564. bIsLastRun = TRUE;
  1565. numBits += putBitsOfTCOEFInterRVLC (uiPrevRun, iPrevLevel, bIsLastRun, bDontSendBits);
  1566. return numBits;
  1567. }
  1569. UInt CVideoObjectEncoder::putBitsOfTCOEFInterRVLC (UInt uiRun, Int iLevel, Bool bIsLastRun, Bool bDontSendBits)
  1570. {
  1571. assert( m_volmd.bDataPartitioning && m_volmd.bReversibleVlc );
  1573. UInt nBits = 0;
  1574. Long lVLCtableIndex;
  1575. if (bIsLastRun == FALSE) {
  1576. lVLCtableIndex = findVLCtableIndexOfNonLastEventInterRVLC (bIsLastRun, uiRun, abs(iLevel));
  1577. if (lVLCtableIndex != NOT_IN_TABLE)  {
  1578. nBits += m_pentrencSet->m_pentrencDCTRVLC->encodeSymbol(lVLCtableIndex, "Vlc_TCOEF_RVLC", bDontSendBits); // huffman encode 
  1579. if( !bDontSendBits )
  1580. m_pentrencSet->m_pentrencDCTRVLC->bitstream()->putBits ((Char) invSignOf (iLevel), 1, "Sign_TCOEF_RVLC");
  1581. nBits++;
  1582. }
  1583. else
  1584. escapeEncodeRVLC (uiRun, iLevel, bIsLastRun, bDontSendBits);
  1585. }
  1586. else {
  1587. lVLCtableIndex = findVLCtableIndexOfLastEventInterRVLC (bIsLastRun, uiRun, abs(iLevel));
  1588. if (lVLCtableIndex != NOT_IN_TABLE)  {
  1589. nBits += m_pentrencSet->m_pentrencDCTRVLC->encodeSymbol(lVLCtableIndex, "Vlc_TCOEF_Last_RVLC", bDontSendBits); // huffman encode 
  1590. if( !bDontSendBits )
  1591. m_pentrencSet->m_pentrencDCTRVLC->bitstream()->putBits ((Char) invSignOf (iLevel), 1, "Sign_TCOEF_Last_RVLC");
  1592. nBits++;
  1593. }
  1594. else
  1595. escapeEncodeRVLC (uiRun, iLevel, bIsLastRun, bDontSendBits);
  1596. }
  1597. return nBits;
  1598. }
  1600. Int CVideoObjectEncoder::findVLCtableIndexOfNonLastEventInterRVLC (Bool bIsLastRun, UInt uiRun, UInt uiLevel)
  1601. {
  1602. assert( m_volmd.bDataPartitioning && m_volmd.bReversibleVlc );
  1603. assert (uiRun >= 0);
  1604. if (uiRun > 38 || (uiLevel > grgIfNotLastNumOfLevelAtRunInterRVLC [uiRun]))
  1605. return NOT_IN_TABLE;
  1606. else {
  1607. UInt uiTableIndex = 0;
  1608. for (UInt i = 0; i < uiRun; i++)
  1609. uiTableIndex += grgIfNotLastNumOfLevelAtRunInterRVLC [i];
  1610. uiTableIndex += uiLevel;
  1611. uiTableIndex--; // make it zero-based; see Table H13/H.263
  1612. return uiTableIndex;
  1613. }
  1614. }
  1616. Int CVideoObjectEncoder::findVLCtableIndexOfLastEventInterRVLC (Bool bIsLastRun, UInt uiRun, UInt uiLevel)
  1617. {
  1618. assert( m_volmd.bDataPartitioning && m_volmd.bReversibleVlc );
  1619. assert (uiRun >= 0);
  1620. if (uiRun > 44 || (uiLevel > grgIfLastNumOfLevelAtRunInterRVLC [uiRun]))
  1621. return NOT_IN_TABLE;
  1622. else {
  1623. UInt uiTableIndex = 0;
  1624. for (UInt i = 0; i < uiRun; i++)
  1625. uiTableIndex += grgIfLastNumOfLevelAtRunInterRVLC [i];
  1626. uiTableIndex += uiLevel;
  1627. uiTableIndex += 102; // make it zero-based and 
  1628. return uiTableIndex; //correction of offset; see Table H13/H.263
  1629. }
  1630. }
  1632. UInt CVideoObjectEncoder::escapeEncodeRVLC (UInt uiRun, Int iLevel, Bool bIsLastRun, Bool bDontSendBits)
  1633. {
  1634. assert( m_volmd.bDataPartitioning && m_volmd.bReversibleVlc );
  1636. UInt nBits = 0;
  1638. Int iLevelAbs = abs (iLevel);
  1639. Char iLevelSign = (Char) invSignOf (iLevel);
  1641. nBits += m_pentrencSet->m_pentrencDCTRVLC->encodeSymbol(TCOEF_RVLC_ESCAPE, "FEsc_TCOEF_RVLC", bDontSendBits);
  1642. if( !bDontSendBits )
  1643. m_pentrencSet->m_pentrencDCTRVLC->bitstream()->putBits (1, 1, "FEsc1_TCOEF_RVLC");
  1644. nBits ++;
  1646. if( !bDontSendBits )
  1647. m_pentrencSet->m_pentrencDCTRVLC->bitstream()->putBits ((Char) bIsLastRun, 1, "Last_Esc_TCOEF_RVLC");
  1648. nBits ++;
  1650. assert (uiRun < BLOCK_SQUARE_SIZE);
  1651. if( !bDontSendBits )
  1652. m_pentrencSet->m_pentrencDCTRVLC->bitstream()->putBits (uiRun, NUMBITS_RVLC_ESC_RUN, "Run_Esc_TCOEF_RVLC");
  1653. nBits += NUMBITS_RVLC_ESC_RUN;
  1655. Int iLevelBits = 12; // = m_volmd.nBits;
  1656. Int iMaxAC = (1<<(iLevelBits - 1)) - 1;
  1657. assert (iLevelAbs <= iMaxAC && iLevelAbs > 0);
  1658. if( !bDontSendBits )
  1659. {
  1660. m_pentrencSet->m_pentrencDCTRVLC->bitstream()->putBits (1, 1, "Marker");
  1661. m_pentrencSet->m_pentrencDCTRVLC->bitstream()->putBits (iLevelAbs, iLevelBits - 1, "Level_Esc_TCOEF_RVLC");
  1662. m_pentrencSet->m_pentrencDCTRVLC->bitstream()->putBits (1, 1, "Marker");
  1663. }
  1664. nBits += iLevelBits - 1 + 2;
  1666. nBits += m_pentrencSet->m_pentrencDCTRVLC->encodeSymbol(TCOEF_RVLC_ESCAPE, "LEsc_TCOEF_RVLC", bDontSendBits);
  1667. if( !bDontSendBits )
  1668. m_pentrencSet->m_pentrencDCTRVLC->bitstream()->putBits (iLevelSign, 1, "Sign_LEsc_TCOEF_RVLC");
  1669. nBits ++;
  1671. return nBits;
  1672. }
  1674. Int CVideoObjectEncoder::dumpCachedShapeBits_DP(Int iMBnum)
  1675. {
  1676. Int ret;
  1677. #ifdef __TRACE_AND_STATS_
  1678. m_pbitstrmOut->trace("INSERTING PRE-ENCODED MB SHAPE STREAM HEREn");
  1679. m_pbitstrmOut->trace(m_pbitstrmOut->getCounter(),"Location Before");
  1680. #endif // __TRACE_AND_STATS_
  1681. m_pbitstrmOut->putBitStream(*m_pbitstrmShape_DP[iMBnum]);
  1682. ret = m_pbitstrmShape_DP[iMBnum]->getCounter();
  1683. #ifdef __TRACE_AND_STATS_
  1684. m_pbitstrmOut->trace(m_pbitstrmOut->getCounter(),"Location After");
  1685. #endif // __TRACE_AND_STATS_
  1686. m_pbitstrmShape_DP[iMBnum]->flush();
  1687. m_pbitstrmShape_DP[iMBnum]->resetAll();
  1689. return(ret);
  1690. }