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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

blkenc.cpp：源码内容
  1. /*************************************************************************
  3. This software module was originally developed by 
  5. Ming-Chieh Lee (mingcl@microsoft.com), Microsoft Corporation
  6. Wei-ge Chen (wchen@microsoft.com), Microsoft Corporation
  7. Bruce Lin (blin@microsoft.com), Microsoft Corporation
  8. Chuang Gu (chuanggu@microsoft.com), Microsoft Corporation
  9. Simon Winder (swinder@microsoft.com), Microsoft Corporation
  10. (date: March, 1996)
  11. and edited by
  12.         Wei Wu (weiwu@stallion.risc.rockwell.com) Rockwell Science Center
  14. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  15. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  16. as specified by the MPEG-4 Video. 
  17. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  18. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  19. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
  20. The original developer of this software module and his/her company, 
  21. the subsequent editors and their companies, 
  22. and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
  23. Copyright is not released for non MPEG-4 Video conforming products. 
  24. Microsoft retains full right to use the code for his/her own purpose, 
  25. assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
  26. This copyright notice must be included in all copies or derivative works. 
  28. Copyright (c) 1996, 1997.
  30. Module Name:
  32. blkenc.cpp
  34. Abstract:
  36. functions for block-level encoding.
  38. Revision History:
  40. *************************************************************************/
  42. #include <stdlib.h>
  43. #include <math.h>
  44. #include "typeapi.h"
  45. #include "codehead.h"
  46. #include "mode.hpp"
  47. #include "global.hpp"
  48. #include "entropy/bitstrm.hpp"
  49. #include "entropy/entropy.hpp"
  50. #include "entropy/huffman.hpp"
  51. #include "dct.hpp"
  52. #include "vopses.hpp"
  53. #include "vopseenc.hpp"
  55. #ifdef __MFC_
  56. #ifdef _DEBUG
  57. #undef THIS_FILE
  58. static char BASED_CODE THIS_FILE[] = __FILE__;
  59. #endif
  61. #define new DEBUG_NEW    
  62. #endif // __MFC_
  64. Int CVideoObjectEncoder::quantizeIntraBlockTexture (PixelC* ppxlcBlkSrc, 
  65.  Int iWidthSrc,  
  66.  PixelC* ppxlcCurrQBlock, 
  67.  Int iWidthCurrQ,
  68.  Int* rgiCoefQ, 
  69.  Int iQP,
  70.  Int iDcScaler,
  71.  Int iBlk, 
  72.  MacroBlockMemory* pmbmLeft, 
  73.  MacroBlockMemory* pmbmTop, 
  74.  MacroBlockMemory* pmbmLeftTop,
  75.  MacroBlockMemory* pmbmCurr,
  76.  CMBMode* pmbmdLeft,
  77.  CMBMode* pmbmdTop,
  78.  CMBMode* pmbmdLeftTop,
  79.  CMBMode* pmbmdCurr)
  80. {
  81. // m_pentrencSet->m_pentrencDCT->bitstream()->trace (ppxlcCurrQBlock, "BLK_TEXTURE");
  82. m_pfdct->apply  (ppxlcBlkSrc, iWidthSrc, m_rgiDCTcoef, BLOCK_SIZE);
  83. quantizeIntraDCcoef (rgiCoefQ, (Float) iDcScaler);
  84. inverseQuantizeIntraDc (rgiCoefQ, iDcScaler); //get the quantized block
  85. if (m_volmd.fQuantizer == Q_H263) {
  86. quantizeIntraDCTcoefH263 (rgiCoefQ, 1, iQP);
  87. inverseQuantizeDCTcoefH263 (rgiCoefQ, 1, iQP); //get the quantized block
  88. }
  89. else {
  90. quantizeIntraDCTcoefMPEG (rgiCoefQ, 1, iQP, (iBlk > V_BLOCK));
  91. inverseQuantizeIntraDCTcoefMPEG (rgiCoefQ, 1, iQP, (iBlk > V_BLOCK)); //get the quantized block
  92. }
  94. Int i, j;
  95. // pmbmCurr->rgblkm [iBlk - 1] [0] = rgiCoefQ [0]; //save Qcoef in memory
  96. pmbmCurr->rgblkm [iBlk - 1] [0] = m_rgiDCTcoef [0]; //save reconstructed DC but quantized AC in memory
  97. for (i = 1, j = 8; i < BLOCK_SIZE; i++, j += BLOCK_SIZE) {
  98. pmbmCurr->rgblkm [iBlk - 1] [i] = rgiCoefQ [i];
  99. pmbmCurr->rgblkm [iBlk - 1] [i + BLOCK_SIZE - 1] = rgiCoefQ [j];
  100. }
  102. Int iSumErr = 0;
  103. m_rgiQPpred [iBlk - 1] = iQP; //default to current in case no predictor
  104. // wmay - hope this is right...
  105. iSumErr += decideIntraPredDir ( rgiCoefQ,
  106. (BlockNum) iBlk,
  107. (const BlockMemory*)&m_rgblkmCurrMB[iBlk - 1],
  108. pmbmLeft, 
  109. pmbmTop, 
  110. pmbmLeftTop,
  111. pmbmCurr,
  112. pmbmdLeft,
  113. pmbmdTop,
  114. pmbmdLeftTop,
  115. pmbmdCurr,
  116. m_rgiQPpred [iBlk - 1],
  117. (int)iQP);
  118. if(iBlk < A_BLOCK1 || pmbmdCurr->m_CODAlpha == ALPHA_CODED)
  119. m_pidct->apply (m_rgiDCTcoef, BLOCK_SIZE, ppxlcCurrQBlock, iWidthCurrQ);
  120. return iSumErr;
  121. }
  123. Void CVideoObjectEncoder::quantizeIntraDCcoef (Int* rgiCoefQ, Float fltDcScaler)
  124. {
  125. if (m_volmd.nBits<=8) { // NBIT: may not valid when nBits>8
  126. assert (fltDcScaler > 0 && fltDcScaler < 128);
  127. }
  128. #ifdef NO_APPENDIXF
  129. Float fltDCquantized = (Float) m_rgiDCTcoef [0] / 8.0F;
  130. #else
  131. Float fltDCquantized = (Float) m_rgiDCTcoef [0] / fltDcScaler;
  132. #endif
  133. assert (fltDCquantized >= 0);
  134. fltDCquantized = fltDCquantized + 0.5F;
  135. Int iMaxDC = (1<<m_volmd.nBits) - 2; // NBIT 1..254
  136. rgiCoefQ [0] = (Int) max (1, min (iMaxDC, fltDCquantized));
  137. }
  139. Void CVideoObjectEncoder::quantizeIntraDCTcoefH263 (Int* rgiCoefQ, Int iStart, Int iQP)
  140. {
  141. Int iLevelBits = 12; // 12 bit FLC (= m_volmd.nBits?)
  142. Int iMaxAC = (1<<(iLevelBits - 1)) - 1; // NBIT 127
  143. for (Int i = iStart; i < BLOCK_SQUARE_SIZE; i++) {
  144. Int ilevel = sign(m_rgiDCTcoef [i]) * (abs (m_rgiDCTcoef [i]) / (2 * iQP));
  145. rgiCoefQ [i] =  min(iMaxAC, max(-iMaxAC, ilevel));
  146. }
  147. }
  149. Void CVideoObjectEncoder::quantizeInterDCTcoefH263 (Int* rgiCoefQ, Int iStart, Int iQP)
  150. {
  151. Int iLevelBits = 12; // 12 bit FLC (= m_volmd.nBits?)
  152. Int iMaxAC = (1<<(iLevelBits - 1)) - 1; // NBIT 127
  153. for (Int i = iStart; i < BLOCK_SQUARE_SIZE; i++) {
  154. Int ilevel = sign(m_rgiDCTcoef [i]) * ((abs (m_rgiDCTcoef [i]) - iQP / 2) / (2 * iQP));
  155. rgiCoefQ [i] =  min(iMaxAC, max(-iMaxAC, ilevel));
  156. }
  157. }
  159. Void CVideoObjectEncoder::quantizeIntraDCTcoefMPEG (Int* rgiCoefQ, Int iStart, Int iQP,
  160. Bool bUseAlphaMatrix)
  161. {
  162. Float fltScaledCoef;
  163. Int i, iScaledQP, iScaledCoef;
  164. Int *piQuantizerMatrix;
  165. if(bUseAlphaMatrix)
  166. piQuantizerMatrix = m_volmd.rgiIntraQuantizerMatrixAlpha;
  167. else
  168. piQuantizerMatrix = m_volmd.rgiIntraQuantizerMatrix;
  169. Int iMaxVal = 1<<(m_volmd.nBits+3); // NBIT 2048
  170. Int iLevelBits = 12; // 12 bit FLC (= m_volmd.nBits?)
  171. Int iMaxAC = (1<<(iLevelBits - 1)) - 1; // NBIT 127
  173. for (i = iStart; i < BLOCK_SQUARE_SIZE; i++) {
  174. fltScaledCoef = 16.0F * m_rgiDCTcoef [i] / piQuantizerMatrix [i]; 
  175. iScaledCoef = (Int) rounded (fltScaledCoef);
  176. iScaledCoef = checkrange (iScaledCoef, -iMaxVal, iMaxVal - 1);
  177. iScaledQP = (Int) (3.0F * (Float) iQP / 4.0F + 0.5);
  178. assert (iScaledQP >= 0);
  179. iScaledCoef = (iScaledCoef + sign(iScaledCoef) * iScaledQP) / (2 * iQP);
  180. rgiCoefQ [i]  = min(iMaxAC, max(-iMaxAC, iScaledCoef ));
  181. }
  182. }
  184. Void CVideoObjectEncoder::quantizeInterDCTcoefMPEG (Int* rgiCoefQ, Int iStart, Int iQP,
  185. Bool bUseAlphaMatrix)
  186. {
  187. Float fltScaledCoef;
  188. Int i, iScaledCoef;
  189. Int *piQuantizerMatrix;
  190. if(bUseAlphaMatrix)
  191. piQuantizerMatrix = m_volmd.rgiInterQuantizerMatrixAlpha;
  192. else
  193. piQuantizerMatrix = m_volmd.rgiInterQuantizerMatrix;
  194. Int iLevelBits = 12; // 12 bit FLC (= m_volmd.nBits?)
  195. Int iMaxAC = (1<<(iLevelBits - 1)) - 1; // NBIT 127
  197. for (i = iStart; i < BLOCK_SQUARE_SIZE; i++) {
  198. fltScaledCoef = 16.0F * m_rgiDCTcoef [i] / piQuantizerMatrix [i]; 
  199. iScaledCoef = (Int) rounded (fltScaledCoef);
  200. iScaledCoef  = iScaledCoef / (2 * iQP);
  201. rgiCoefQ [i] = min(iMaxAC, max(-iMaxAC, iScaledCoef ));
  202. }
  203. }
  205. Int CVideoObject::decideIntraPredDir (Int* rgiCoefQ,
  206.    BlockNum blkn,
  207.    const BlockMemory* blkmRet, 
  208.    const MacroBlockMemory* pmbmLeft, 
  209.       const MacroBlockMemory* pmbmTop, 
  210.    const MacroBlockMemory* pmbmLeftTop,
  211.    const MacroBlockMemory* pmbmCurr,
  212.    const CMBMode* pmbmdLeft,
  213.    const CMBMode* pmbmdTop,
  214.    const CMBMode* pmbmdLeftTop,
  215.    CMBMode* pmbmdCurr,
  216.    Int& iQPpred,
  217.    Int iQPcurr,
  218.    Bool bDecideDCOnly)
  219. {
  220. UInt nBits = m_volmd.nBits;
  221. Int iDefVal = 1<<(nBits+2);// NBIT: start to calculate default value
  222. Int iRange = (1<<(nBits-1))-1; // 127 for 8-bit
  224. Int iQPpredTop, iQPpredLeftTop, iQPpredLeft;
  225. const BlockMemory blkmTop = findPredictorBlock (blkn, VERTICAL,
  226. pmbmLeft, pmbmTop, pmbmLeftTop, pmbmCurr,
  227. pmbmdLeft, pmbmdTop, pmbmdLeftTop, pmbmdCurr, iQPpredTop);
  228. const BlockMemory blkmLeftTop = findPredictorBlock (blkn, DIAGONAL,
  229. pmbmLeft, pmbmTop, pmbmLeftTop, pmbmCurr,
  230. pmbmdLeft, pmbmdTop, pmbmdLeftTop, pmbmdCurr, iQPpredLeftTop);
  231. const BlockMemory blkmLeft = findPredictorBlock (blkn, HORIZONTAL,
  232. pmbmLeft, pmbmTop, pmbmLeftTop, pmbmCurr,
  233. pmbmdLeft, pmbmdTop, pmbmdLeftTop, pmbmdCurr, iQPpredLeft);
  234. //wchen: changed to 1024 per CD (based on recon instead of Q value now)
  235. /* NBIT: change 1024 to iDefVal
  236. Int iPredLeftTop = (blkmLeftTop == NULL) ? 1024 : blkmLeftTop [0];
  237. Int iHorizontalGrad = ((blkmTop  == NULL) ? 1024 : blkmTop  [0]) - iPredLeftTop;
  238. Int iVerticalGrad = ((blkmLeft == NULL) ? 1024 : blkmLeft [0]) - iPredLeftTop;
  239. */
  240. Int iPredLeftTop = (blkmLeftTop == NULL) ? iDefVal : blkmLeftTop [0];
  241. Int iHorizontalGrad = ((blkmTop  == NULL) ? iDefVal : blkmTop  [0]) - iPredLeftTop;
  242. Int iVerticalGrad = ((blkmLeft == NULL) ? iDefVal : blkmLeft [0]) - iPredLeftTop;
  244. *blkmRet = NULL;
  245. UInt i, j;
  246. Int iSumErr = 0; //per vm4.0, p53
  247. if (abs(iVerticalGrad)  < abs (iHorizontalGrad)) {
  248. pmbmdCurr->m_preddir [blkn - 1] = VERTICAL;
  249. if (blkmTop != NULL) {
  250. *blkmRet = blkmTop;
  251. iQPpred = iQPpredTop;
  252. if (bDecideDCOnly != TRUE) {
  253. for (i = 1; i < BLOCK_SIZE; i++) {
  254. Int iDiff = rgiCoefQ [i] - divroundnearest(blkmTop [i] * iQPpred, iQPcurr);
  255. if (iDiff >= -iRange && iDiff <= iRange) //hack to deal with vm deficiency: ac pred out of range; dc pred is not dealt with
  256. iSumErr += abs (rgiCoefQ [i]) - abs (iDiff);
  257. else
  258. return -100000; //arbitrary  negative number to turn off ac pred.
  259. }
  260. }
  261. }
  262. }
  263. else {
  264. pmbmdCurr->m_preddir [blkn - 1] = HORIZONTAL;
  265. if (blkmLeft != NULL) {
  266. *blkmRet = blkmLeft;
  267. iQPpred = iQPpredLeft;
  268. if (bDecideDCOnly != TRUE) {
  269. for (i = 8, j = 8; i < BLOCK_SQUARE_SIZE; i += 8, j++) {
  270. Int iDiff = rgiCoefQ [i] - divroundnearest(blkmLeft [j] * iQPpred, iQPcurr);
  271. if (iDiff >= -iRange && iDiff <= iRange) //hack to deal with vm deficiency: ac pred out of range; dc pred is not dealt with
  272. iSumErr += abs (rgiCoefQ [i]) - abs (iDiff);
  273. else
  274. return -100000; //arbitrary negative number to turn off ac pred.
  275. }
  276. }
  277. }
  278. }
  279. return iSumErr;
  280. }
  283. Void CVideoObjectEncoder::intraPred (BlockNum blkn, const CMBMode* pmbmd, 
  284.  Int* rgiCoefQ, Int iQPcurr, Int iDcScaler, 
  285.  const BlockMemory blkmPred, Int iQPpred)
  286. {
  287. Int iDefVal; // NBIT: start to calculate default value
  288. UInt nBits = m_volmd.nBits;
  289. Int iMaxDC = (1<<nBits) - 1;
  290. Int iLevelBits = 12; // 12 bit FLC (= m_volmd.nBits?)
  291. Int iMaxAC = (1<<(iLevelBits - 1)) - 1; // NBIT 127
  292. iDefVal = 1<<(nBits + 2);
  295. //do DC prediction
  296. if (blkmPred == NULL)
  297. /* NBIT: change 1024 to iDefVal
  298. rgiCoefQ [0] -= (1024 + (iDcScaler >> 1)) / iDcScaler;
  299. */
  300. rgiCoefQ [0] -= divroundnearest(iDefVal, iDcScaler);
  301. else {
  302. rgiCoefQ [0] -= divroundnearest(blkmPred [0], iDcScaler);
  303. /* NBIT: change 255 to iMaxVal
  304. assert (rgiCoefQ [0] >= -255 && rgiCoefQ [0] <= 255);
  305. */
  306. assert (rgiCoefQ [0] >= -iMaxDC && rgiCoefQ [0] <= iMaxDC);
  308. if (blkn < A_BLOCK1 && pmbmd->m_bACPrediction
  309. || blkn >=A_BLOCK1 && pmbmd->m_bACPredictionAlpha)
  310. {
  311. Int i, j;
  312. //do AC prediction
  313. if (pmbmd->m_preddir [blkn - 1] == HORIZONTAL) {
  314. for (i = 8, j = 8; j < 2 * BLOCK_SIZE - 1; i += 8, j++) {
  315. rgiCoefQ [i] -= (blkmPred == NULL) ? 0 : (iQPcurr == iQPpred) ?
  316.  blkmPred [j] : divroundnearest(blkmPred [j] * iQPpred, iQPcurr);
  317. assert (rgiCoefQ [i] >= -iMaxAC && rgiCoefQ [i]  <= iMaxAC);
  318. }
  320. }
  321. else if  (pmbmd->m_preddir [blkn - 1] == VERTICAL) {
  322. //horizontal zigzag scan
  323. for (i = 1; i < BLOCK_SIZE; i++) {
  324. rgiCoefQ [i] -= (blkmPred == NULL) ? 0 : (iQPcurr == iQPpred) ?
  325.  blkmPred [i] : divroundnearest(blkmPred [i] * iQPpred, iQPcurr);
  326. assert (rgiCoefQ [i] >= -iMaxAC && rgiCoefQ [i] <= iMaxAC);
  327. }
  328. }
  329. else
  330. assert (FALSE);
  331. }
  332. }
  333. }
  335. Void CVideoObjectEncoder::quantizeTextureInterBlock (PixelI* ppxliCurrQBlock, 
  336.  Int iWidthCurrQ,
  337.  Int* rgiCoefQ, 
  338.  Int iQP,
  339.  Bool bAlphaBlock)
  340. {
  341. // m_pentrencSet->m_pentrencDCT->bitstream()->trace (rgiCoefQ, "BLK_TEXTURE");
  342. m_pfdct->apply  (ppxliCurrQBlock, iWidthCurrQ, m_rgiDCTcoef, BLOCK_SIZE);
  343. if (m_volmd.fQuantizer == Q_H263) {
  344. quantizeInterDCTcoefH263 (rgiCoefQ, 0, iQP);
  345. inverseQuantizeDCTcoefH263 (rgiCoefQ, 0, iQP);
  346. }
  347. else {
  348. quantizeInterDCTcoefMPEG (rgiCoefQ, 0, iQP, bAlphaBlock);
  349. inverseQuantizeInterDCTcoefMPEG (rgiCoefQ, 0, iQP, bAlphaBlock);
  350. }
  352. m_pidct->apply (m_rgiDCTcoef, BLOCK_SIZE, ppxliCurrQBlock, iWidthCurrQ);
  353. // m_pentrencSet->m_pentrencDCT->bitstream()->trace (ppxliCurrQBlock, "BLK_TEXTURE_Q");
  354. }
  356. UInt CVideoObjectEncoder::sendIntraDC (const Int* rgiCoefQ, BlockNum blkn)
  357. {
  358. UInt nBits = 0;
  359. UInt nBitsPerPixel = m_volmd.nBits; // NBIT
  360. Int iMaxVal = 1<<nBitsPerPixel; // NBIT
  362. assert (rgiCoefQ [0] >= -iMaxVal && rgiCoefQ [0] < iMaxVal);
  363. Int iAbsDiffIntraDC = abs (rgiCoefQ [0]);
  364. Long lSzDiffIntraDC = 0;
  365. for (Int i = nBitsPerPixel; i > 0; i--)
  366. if (iAbsDiffIntraDC & (1 << (i - 1))) {
  367. lSzDiffIntraDC = i;
  368. break;
  369. }
  371. COutBitStream* pobstrmIntraDC;
  372. if (blkn == U_BLOCK || blkn == V_BLOCK) {
  373. nBits = m_pentrencSet->m_pentrencIntraDCc->encodeSymbol(lSzDiffIntraDC, "IntraDClen"); // huffman encode 
  374. pobstrmIntraDC = m_pentrencSet->m_pentrencIntraDCc -> bitstream ();
  375. }
  376. else {
  377. nBits = m_pentrencSet->m_pentrencIntraDCy->encodeSymbol(lSzDiffIntraDC, "IntraDClen"); // huffman encode 
  378. pobstrmIntraDC = m_pentrencSet->m_pentrencIntraDCy -> bitstream ();
  379. }
  380. if (lSzDiffIntraDC<=8) { // NBIT
  381.     if (rgiCoefQ [0] > 0)
  382. pobstrmIntraDC->putBits ((Char) rgiCoefQ [0], lSzDiffIntraDC, "IntraDC"); //fix length code
  383.     else if (rgiCoefQ [0] < 0)
  384. pobstrmIntraDC->putBits (~iAbsDiffIntraDC, lSzDiffIntraDC, "IntraDC"); //fix length code
  385.     nBits += lSzDiffIntraDC;
  386. } else { // NBIT: MARKER bit inserted after first 8 bits
  387.  //   UInt uiOffset = lSzDiffIntraDC-8;
  388.     UInt uiValue = iAbsDiffIntraDC;
  389.     if (rgiCoefQ [0] < 0) {
  390. uiValue = ~iAbsDiffIntraDC;
  391.     }
  392. /*
  393.     uiValue = ( (uiValue>>uiOffset)<<(uiOffset+1) )
  394. + ( 1<<uiOffset )
  395.    + ( uiValue&((1<<uiOffset)-1) );
  396.     pobstrmIntraDC->putBits (uiValue, lSzDiffIntraDC+1, "IntraDC");
  397. */
  398.     pobstrmIntraDC->putBits (uiValue, lSzDiffIntraDC, "IntraDC");
  399.     pobstrmIntraDC->putBits (1, 1, "Marker");
  400.     nBits += lSzDiffIntraDC+1;
  401. }
  402. return nBits;
  403. }
  405. UInt CVideoObjectEncoder::sendTCOEFIntra (const Int* rgiCoefQ, Int iStart, Int* rgiZigzag)
  406. {
  407. Bool bIsFirstRun = TRUE;
  408. Bool bIsLastRun = FALSE;
  409. UInt uiCurrRun = 0;
  410. UInt uiPrevRun = 0;
  411. // Int  iCurrLevel = 0;
  412. Int  iPrevLevel = 0;
  413. //UInt uiCoefToStart = 0;
  414. UInt numBits = 0;
  416. for (Int j = iStart; j < BLOCK_SQUARE_SIZE; j++) {
  417. if (rgiCoefQ [rgiZigzag [j]] == 0) // zigzag here
  418. uiCurrRun++; // counting zeros
  419. else {
  420. if (!bIsFirstRun)
  421. numBits += putBitsOfTCOEFIntra (uiPrevRun, iPrevLevel, bIsLastRun);
  422. uiPrevRun = uiCurrRun;  // reset for next run
  423. iPrevLevel = rgiCoefQ [rgiZigzag [j]]; 
  424. uiCurrRun = 0;
  425. bIsFirstRun = FALSE;
  426. }
  427. }
  428. assert (uiPrevRun <= (BLOCK_SQUARE_SIZE - 1) - 1); // Some AC must be non-zero; at least for inter
  429. bIsLastRun = TRUE;
  430. numBits += putBitsOfTCOEFIntra (uiPrevRun, iPrevLevel, bIsLastRun);
  431. return numBits;
  432. }
  435. UInt CVideoObjectEncoder::sendTCOEFInter (const Int* rgiCoefQ, Int iStart, Int* rgiZigzag)
  436. {
  437. Bool bIsFirstRun = TRUE;
  438. Bool bIsLastRun = FALSE;
  439. UInt uiCurrRun = 0;
  440. UInt uiPrevRun = 0;
  441. //Int  iCurrLevel = 0;
  442. Int  iPrevLevel = 0;
  443. UInt numBits = 0;
  445. for (Int j = iStart; j < BLOCK_SQUARE_SIZE; j++) {
  446. if (rgiCoefQ [rgiZigzag [j]] == 0) // zigzag here
  447. uiCurrRun++; // counting zeros
  448. else {
  449. if (!bIsFirstRun)
  450. numBits += putBitsOfTCOEFInter (uiPrevRun, iPrevLevel, bIsLastRun);
  451. uiPrevRun = uiCurrRun;  // reset for next run
  452. iPrevLevel = rgiCoefQ [rgiZigzag [j]]; 
  453. uiCurrRun = 0;
  454. bIsFirstRun = FALSE;
  455. }
  456. }
  457. assert (uiPrevRun <= (BLOCK_SQUARE_SIZE - 1)); // Some AC must be non-zero; at least for inter
  458. bIsLastRun = TRUE;
  459. numBits += putBitsOfTCOEFInter (uiPrevRun, iPrevLevel, bIsLastRun);
  460. return numBits;
  461. }
  463. UInt CVideoObjectEncoder::putBitsOfTCOEFInter (UInt uiRun, Int iLevel, Bool bIsLastRun)
  464. {
  465. UInt nBits = 0;
  466. Long lVLCtableIndex;
  467. if (bIsLastRun == FALSE) {
  468. lVLCtableIndex = findVLCtableIndexOfNonLastEvent (bIsLastRun, uiRun, abs(iLevel));
  469. if (lVLCtableIndex != NOT_IN_TABLE)  {
  470. nBits += m_pentrencSet->m_pentrencDCT->encodeSymbol(lVLCtableIndex, "Vlc_TCOEF"); // huffman encode 
  471. m_pentrencSet->m_pentrencDCT->bitstream()->putBits ((Char) invSignOf (iLevel), 1, "Sign_TCOEF");
  472. nBits++;
  473. }
  474. else
  475. nBits += escapeEncode (uiRun, iLevel, bIsLastRun, g_rgiLMAXinter, g_rgiRMAXinter, &CVideoObjectEncoder::findVLCtableIndexOfNonLastEvent);
  476. }
  477. else {
  478. lVLCtableIndex = findVLCtableIndexOfLastEvent (bIsLastRun, uiRun, abs(iLevel));
  479. if (lVLCtableIndex != NOT_IN_TABLE)  {
  480. nBits += m_pentrencSet->m_pentrencDCT->encodeSymbol(lVLCtableIndex, "Vlc_TCOEF"); // huffman encode 
  481. m_pentrencSet->m_pentrencDCT->bitstream()->putBits ((Char) invSignOf (iLevel), 1, "Sign_TCOEF");
  482. nBits++;
  483. }
  484. else
  485. nBits += escapeEncode (uiRun, iLevel, bIsLastRun, g_rgiLMAXinter, g_rgiRMAXinter, &CVideoObjectEncoder::findVLCtableIndexOfLastEvent);
  486. }
  487. return nBits;
  488. }
  492. UInt CVideoObjectEncoder::putBitsOfTCOEFIntra (UInt uiRun, Int iLevel, Bool bIsLastRun)
  493. {
  494. //fprintf(stderr,"%d %d %dn", iLevel,uiRun,bIsLastRun);
  496. Int nBits = 0;
  497. Long lVLCtableIndex;
  498. lVLCtableIndex = findVLCtableIndexOfIntra (bIsLastRun, uiRun, abs(iLevel));
  500. if (lVLCtableIndex != NOT_IN_TABLE)  {
  501. nBits += m_pentrencSet->m_pentrencDCTIntra->encodeSymbol(lVLCtableIndex, "Vlc_TCOEF"); // huffman encode 
  502. m_pentrencSet->m_pentrencDCTIntra->bitstream()->putBits ((Char) invSignOf (iLevel), 1, "Sign_TCOEF");
  503. nBits++;
  504. }
  505. else
  506. nBits += escapeEncode (uiRun, iLevel, bIsLastRun, g_rgiLMAXintra, g_rgiRMAXintra, &CVideoObjectEncoder::findVLCtableIndexOfIntra);
  508. return nBits;
  509. }
  511. UInt CVideoObjectEncoder::escapeEncode (UInt uiRun, Int iLevel, Bool bIsLastRun, Int* rgiLMAX, Int* rgiRMAX, 
  512. FIND_TABLE_INDEX findVLCtableIndex)
  513. {
  514. UInt nBits = 0;
  515. nBits += m_pentrencSet->m_pentrencDCT->encodeSymbol(TCOEF_ESCAPE, "Esc_TCOEF");
  516. Int iLevelAbs = abs (iLevel);
  517. Int iLevelPlus = iLevelAbs - rgiLMAX [(uiRun & 0x0000003F) + (bIsLastRun << 6)]; //hashing the table
  518. Int iVLCtableIndex = (this->*findVLCtableIndex) (bIsLastRun, uiRun, abs (iLevelPlus));
  519. if (iVLCtableIndex != NOT_IN_TABLE)  {
  520. m_pbitstrmOut->putBits (0, 1, "Esc_0");
  521. nBits++;
  522. nBits += m_pentrencSet->m_pentrencDCT->encodeSymbol(iVLCtableIndex, "Esc_1_Vlc_TCOEF"); // huffman encode 
  523. m_pbitstrmOut->putBits ((Char) invSignOf (iLevel), 1, "Sign_TCOEF");
  524. nBits++;
  525. }
  526. else {
  527. Int iRunPlus = uiRun - rgiRMAX [(iLevelAbs & 0x0000001F) + (bIsLastRun << 5)];  //RMAX table includes + 1 already
  528. iVLCtableIndex = (this->*findVLCtableIndex) (bIsLastRun, (UInt) iRunPlus, iLevelAbs);
  529. if (iVLCtableIndex != NOT_IN_TABLE)  {
  530. m_pbitstrmOut->putBits (2, 2, "Esc_10");
  531. nBits += 2;
  532. nBits += m_pentrencSet->m_pentrencDCT->encodeSymbol(iVLCtableIndex, "Esc_01_Vlc_TCOEF"); // huffman encode 
  533. m_pbitstrmOut->putBits ((Char) invSignOf (iLevel), 1, "Sign_TCOEF");
  534. nBits++;
  535. }
  536. else {
  537. m_pbitstrmOut->putBits (3, 2, "Esc_11");
  538. nBits += 2;
  539. nBits += fixLengthCode (uiRun, iLevel, bIsLastRun);
  540. }
  541. }
  542. return nBits;
  543. }
  545. UInt CVideoObjectEncoder::fixLengthCode (UInt uiRun, Int iLevel, Bool bIsLastRun)
  546. {
  547. UInt nBits = 0;
  548. m_pentrencSet->m_pentrencDCT->bitstream()->putBits ((Char) bIsLastRun, 1, "Last_Run_TCOEF");
  549. nBits++;
  551. assert (uiRun < BLOCK_SQUARE_SIZE);
  552. m_pentrencSet->m_pentrencDCT->bitstream()->putBits (uiRun, NUMBITS_ESC_RUN, "Run_Esc_TCOEF");
  553. nBits+=NUMBITS_ESC_RUN;
  555. Int iLevelBits = 12; // 12 bit FLC (= m_volmd.nBits?)
  556. Int iMaxAC = (1<<(iLevelBits - 1)) - 1; // NBIT
  557. assert (iLevel >= -iMaxAC && iLevel <= iMaxAC && iLevel != 0);
  558. if (iLevel < 0)
  559. iLevel = (1<<iLevelBits) - abs(iLevel);
  560. m_pentrencSet->m_pentrencDCT->bitstream()->putBits (1, 1, "Marker");
  561. m_pentrencSet->m_pentrencDCT->bitstream()->putBits (iLevel, iLevelBits, "Level_Esc_TCOEF");
  562. m_pentrencSet->m_pentrencDCT->bitstream()->putBits (1, 1, "Marker");
  563. nBits += iLevelBits + 2;
  565. return nBits;
  566. }
  568. Int CVideoObjectEncoder::findVLCtableIndexOfNonLastEvent (Bool bIsLastRun, UInt uiRun, UInt uiLevel)
  569. {
  571. assert (uiRun >= 0);
  572. if (uiRun > 26 || (uiLevel > grgIfNotLastNumOfLevelAtRun [uiRun]))
  573. return NOT_IN_TABLE;
  574. else {
  575. UInt uiTableIndex = 0;
  576. for (UInt i = 0; i < uiRun; i++)
  577. uiTableIndex += grgIfNotLastNumOfLevelAtRun [i];
  578. uiTableIndex += uiLevel;
  579. uiTableIndex--; // make it zero-based; see Table H13/H.263
  580. return uiTableIndex;
  581. }
  582. }
  584. Int CVideoObjectEncoder::findVLCtableIndexOfLastEvent (Bool bIsLastRun, UInt uiRun, UInt uiLevel)
  585. {
  586. assert (uiRun >= 0);
  587. if (uiRun > 40 || (uiLevel > grgIfLastNumOfLevelAtRun [uiRun]))
  588. return NOT_IN_TABLE;
  589. else {
  590. UInt uiTableIndex = 0;
  591. for (UInt i = 0; i < uiRun; i++)
  592. uiTableIndex += grgIfLastNumOfLevelAtRun [i];
  593. uiTableIndex += uiLevel;
  594. uiTableIndex += 57; // make it zero-based and 
  595. return uiTableIndex; //correction of offset; see Table H13/H.263
  596. }
  597. }
  599. Int CVideoObjectEncoder::findVLCtableIndexOfIntra (Bool bIsLastRun, UInt uiRun, UInt uiLevel)
  600. {
  601. UInt i;
  602. assert (uiRun >= 0);
  603. if (uiRun > 20 || uiLevel > 27)
  604. return NOT_IN_TABLE;
  605. else {
  606.   //UInt uiTableIndex = 0;
  607. for (i = 0; i < TCOEF_ESCAPE; i++) {
  608. UInt iHashing = (bIsLastRun << 10) | (uiRun << 5) | uiLevel;
  609. if (iHashing == grgiIntraYAVCLHashingTable [i])
  610. return i;
  611. }
  612. return NOT_IN_TABLE;
  613. }
  614. }