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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

mode.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)
  12. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  13. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  14. as specified by the MPEG-4 Video. 
  15. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  16. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  17. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
  18. The original developer of this software module and his/her company, 
  19. the subsequent editors and their companies, 
  20. and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
  21. Copyright is not released for non MPEG-4 Video conforming products. 
  22. Microsoft retains full right to use the code for his/her own purpose, 
  23. assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
  24. This copyright notice must be included in all copies or derivative works. 
  26. Copyright (c) 1996, 1997.
  29. Module Name:
  31. mode.h
  33. Abstract:
  35. basic coding modes for VOP and MB
  37. Revision History:
  38. Dec. 12, 1997: Interlaced tools added by NextLevel Systems
  39.         May. 9   1998:  add boundary by Hyundai Electronics
  40.                                   Cheol-Soo Park (cspark@super5.hyundai.co.kr)
  41.         May. 9   1998:  add field based MC padding by Hyundai Electronics
  42.                                   Cheol-Soo Park (cspark@super5.hyundai.co.kr)
  43. May 9, 1999: tm5 rate control by DemoGraFX, duhoff@mediaone.net
  44. *************************************************************************/
  47. #include <string.h>
  48. #include <iostream.h>
  49. #include <math.h>
  50. #include "typeapi.h"
  51. #include "mode.hpp"
  52. #include "warp.hpp"
  54. #ifdef __MFC_
  55. #ifdef _DEBUG
  56. #undef THIS_FILE
  57. static char BASED_CODE THIS_FILE[] = __FILE__;
  58. #endif
  60. #define new DEBUG_NEW    
  61. #endif // __MFC_
  63. // only works for 4:2:0
  64. #define MAX_NUM_MV 4
  65. UInt uiNumBlks = 10;
  66. //#define uiNumBlks 10
  68. CMBMode::~CMBMode ()
  69. { 
  70. delete [] m_rgbCodedBlockPattern; 
  71. delete [] m_rgfltMinErrors; 
  72. }
  74. CMBMode::CMBMode ()
  75. {
  76. UInt i;
  77. for (i = 0; i < uiNumBlks + 1; i++) {
  78. m_rgTranspStatus [i] = NONE;
  79. m_rgNumNonTranspPixels [i] = 0;
  80. }
  81. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  82.         for (i = 0; i < uiNumBlks + 1; i++)
  83.                 m_rgTranspStatusBBM[i] = NONE;
  84.         memset (m_bMerged, FALSE, 7 * sizeof(Bool));
  85. // End of Hyundai(1998-5-9)*/
  87. // Added for field based MC padding by Hyundai(1998-5-9)
  88.         for (i = 0; i < 5; i++)
  89. m_rgFieldTranspStatus [i] = ALL;
  90. memset (m_rgbFieldPadded, 0, 5 * sizeof(Bool));
  91. // End of Hyundai(1998-5-9)
  93. m_rgbCodedBlockPattern = new Bool [uiNumBlks];
  94. memset (m_rgbCodedBlockPattern, FALSE, uiNumBlks * sizeof (Bool));
  95. m_rgfltMinErrors = new Float [uiNumBlks];
  96. memset (m_rgfltMinErrors, 0, uiNumBlks * sizeof (Float));
  97. m_bPadded = FALSE;
  98. m_bSkip = FALSE;
  99. m_dctMd = INTRA;
  100. m_shpmd = UNKNOWN;
  101. m_mbType = FORWARD;
  102. m_intStepDelta = 0;
  103. m_bhas4MVForward = FALSE; 
  104. m_bhas4MVBackward = FALSE;
  105. m_bFieldMV = FALSE;
  106. m_bForwardTop = FALSE;   
  107. m_bForwardBottom = FALSE;
  108. m_bBackwardTop = FALSE;
  109. m_bBackwardBottom = FALSE;
  110. m_bFieldDCT = FALSE;
  111. m_bPerspectiveForward = FALSE;
  112. m_bPerspectiveBackward = FALSE;
  113. m_stepSize = 0;
  114. m_stepSizeDelayed = 0;
  115. m_stepSizeAlpha = 0;
  116. m_bACPrediction = FALSE;
  117. m_bInterShapeCoding = FALSE;
  118. m_bColocatedMBSkip = FALSE;
  119. m_iVideoPacketNumber = 0;
  120. m_vctDirectDeltaMV = CVector (0, 0);
  121. }
  123. CMBMode::CMBMode (const CMBMode& md)
  124. {
  125. memcpy (m_rgTranspStatus, md.m_rgTranspStatus, (uiNumBlks + 1)  * sizeof (TransparentStatus));
  126. memcpy (m_rgNumNonTranspPixels, md.m_rgNumNonTranspPixels, (uiNumBlks + 1)  * sizeof (UInt));
  127. memcpy (m_preddir,md.m_preddir,uiNumBlks * sizeof(IntraPredDirection));
  129. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  130.         memcpy (m_rgTranspStatusBBM, md.m_rgTranspStatusBBM, (uiNumBlks + 1)  * sizeof (TransparentStatus));
  131.         memcpy (m_bMerged, md.m_bMerged, 7 * sizeof (Bool));
  132. // End of Hyundai(1998-5-9)*/
  134. // Added for field based MC padding by Hyundai(1998-5-9)
  135.         memcpy (m_rgFieldTranspStatus, md.m_rgFieldTranspStatus, 5  * sizeof (TransparentStatus));
  136. memcpy (m_rgbFieldPadded, md.m_rgbFieldPadded, 5 * sizeof (Bool));
  137. // End of Hyundai(1998-5-9)
  139. m_bPadded = md.m_bPadded;
  140. m_bSkip = md.m_bSkip;
  141. m_CODAlpha = md.m_CODAlpha;
  142. m_mbType = md.m_mbType;
  143. m_dctMd = md.m_dctMd;
  144. m_shpmd = md.m_shpmd ;
  145. m_intStepDelta = md.m_intStepDelta;
  146. m_bhas4MVForward = md.m_bhas4MVForward; 
  147. m_bhas4MVBackward = md.m_bhas4MVBackward; 
  148. m_bPerspectiveForward = md.m_bPerspectiveForward;
  149. m_bPerspectiveBackward = md.m_bPerspectiveBackward;
  150. m_stepSize = md.m_stepSize;
  151. m_stepSizeDelayed = md.m_stepSizeDelayed;
  152. m_stepSizeAlpha = md.m_stepSizeAlpha;
  153. m_bACPrediction = md.m_bACPrediction;
  154. m_bACPredictionAlpha = md.m_bACPredictionAlpha;
  155. m_bInterShapeCoding = md.m_bInterShapeCoding;
  156. m_bCodeDcAsAc = md.m_bCodeDcAsAc;
  157. m_bCodeDcAsAcAlpha = md.m_bCodeDcAsAcAlpha;
  158. m_bColocatedMBSkip = md.m_bColocatedMBSkip;
  159. m_iVideoPacketNumber = md.m_iVideoPacketNumber;
  161. m_rgbCodedBlockPattern = new Bool [uiNumBlks];
  162. memcpy (m_rgbCodedBlockPattern, md.m_rgbCodedBlockPattern, uiNumBlks * sizeof (Bool));
  163. m_rgfltMinErrors = new Float [uiNumBlks];
  164. memcpy (m_rgfltMinErrors, md.m_rgfltMinErrors, uiNumBlks * sizeof (Float));
  165. }
  167. Void CMBMode::operator = (const CMBMode& md)
  168. {
  169. memcpy (m_rgTranspStatus, md.m_rgTranspStatus, (uiNumBlks + 1) * sizeof (TransparentStatus));
  170. memcpy (m_rgNumNonTranspPixels, md.m_rgNumNonTranspPixels, (uiNumBlks + 1) * sizeof (UInt));
  171. memcpy (m_preddir,md.m_preddir,uiNumBlks * sizeof(IntraPredDirection));
  173. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  174. memcpy (m_rgTranspStatusBBM, md.m_rgTranspStatusBBM, (uiNumBlks + 1)  * sizeof (TransparentStatus));
  175.         memcpy (m_bMerged, md.m_bMerged, 7 * sizeof (Bool));
  176. // End of Hyundai(1998-5-9)*/
  178. // Added for field based MC padding by Hyundai(1998-5-9)
  179.         memcpy (m_rgFieldTranspStatus, md.m_rgFieldTranspStatus, 5  * sizeof (TransparentStatus));
  180.         memcpy (m_rgbFieldPadded, md.m_rgbFieldPadded, 5 * sizeof (Bool));
  181. // End of Hyundai(1998-5-9)
  183. m_bPadded = md.m_bPadded;
  184. m_bSkip = md.m_bSkip;
  185. m_CODAlpha = md.m_CODAlpha;
  186. m_mbType = md.m_mbType;
  187. m_dctMd = md.m_dctMd;
  188. m_shpmd = md.m_shpmd ;
  189. m_intStepDelta = md.m_intStepDelta;
  190. m_bhas4MVForward = md.m_bhas4MVForward; 
  191. m_bhas4MVBackward = md.m_bhas4MVBackward; 
  192. m_bPerspectiveForward = md.m_bPerspectiveForward;
  193. m_bPerspectiveBackward = md.m_bPerspectiveBackward;
  194. m_stepSize = md.m_stepSize;
  195. m_stepSizeDelayed = md.m_stepSizeDelayed;
  196. m_stepSizeAlpha = md.m_stepSizeAlpha;
  197. m_bACPrediction = md.m_bACPrediction;
  198. m_bACPredictionAlpha = md.m_bACPredictionAlpha;
  199. m_bInterShapeCoding = md.m_bInterShapeCoding;
  200. m_bCodeDcAsAc = md.m_bCodeDcAsAc;
  201. m_bCodeDcAsAcAlpha = md.m_bCodeDcAsAcAlpha;
  202. m_bColocatedMBSkip = md.m_bColocatedMBSkip;
  203. m_iVideoPacketNumber = md.m_iVideoPacketNumber;
  205. memcpy (m_rgbCodedBlockPattern, md.m_rgbCodedBlockPattern, uiNumBlks * sizeof (Bool));
  206. memcpy (m_rgfltMinErrors, md.m_rgfltMinErrors, uiNumBlks * sizeof (Float));
  207. }
  209. Void CMBMode::setCodedBlockPattern (const Bool* rgbblockNum)
  210. { 
  211. for (UInt i = 0; i < uiNumBlks; i++)
  212. m_rgbCodedBlockPattern[i] = rgbblockNum [i];
  213. }
  215. Void CMBMode::setMinError (const Float* pfltminError)
  216. {
  217. for (UInt i = 0; i < uiNumBlks; i++)
  218. m_rgfltMinErrors[i] = pfltminError [i];
  220. }
  222. CDirectModeData::~CDirectModeData ()
  223. {
  224. destroyMem ();
  225. }
  227. CDirectModeData::CDirectModeData ()
  228. {
  229. m_ppmbmd = NULL;
  230. m_prgmv = NULL;
  231. }
  233. Bool CDirectModeData::inBound (UInt iMbIdx) const
  234. {
  235. if (iMbIdx >= m_uiNumMB)
  236. return FALSE;
  237. else
  238. return TRUE;
  239. }
  241. Bool CDirectModeData::inBound (UInt idX, UInt idY) const
  242. {
  243. if (idX >= m_uiNumMBX || idY >= m_uiNumMBY || idX * idY >= m_uiNumMB)
  244. return FALSE;
  245. else
  246. return TRUE;
  247. }
  249. Void CDirectModeData::reassign (UInt numMBX, UInt numMBY)
  250. {
  251. destroyMem ();
  252. m_uiNumMBX = numMBX;
  253. m_uiNumMBY = numMBY;
  254. m_uiNumMB = m_uiNumMBX * m_uiNumMBY;
  255. m_ppmbmd = new CMBMode* [m_uiNumMB];
  256. m_prgmv = new CMotionVector* [m_uiNumMB];
  257. for (UInt i = 0; i < m_uiNumMB; i++) {
  258. m_ppmbmd [i] = new CMBMode;
  259. m_prgmv [i] = new CMotionVector [5];
  260. }
  261. }
  263. Void CDirectModeData::assign (UInt imb, const CMBMode& mbmd, const CMotionVector* rgmv)
  264. {
  265. assert (inBound (imb));
  266. *(m_ppmbmd [imb]) = mbmd;
  267. memcpy (m_prgmv [imb], rgmv, 5 * sizeof (CMotionVector));
  268. }
  270. Void CDirectModeData::destroyMem ()
  271. {
  272. if (m_ppmbmd != NULL) {
  273. for (UInt i = 0; i < m_uiNumMB; i++)
  274. delete m_ppmbmd [i];
  275. delete [] m_ppmbmd;
  276. }
  277. if (m_prgmv != NULL) {
  278. for (UInt i = 0; i < m_uiNumMB; i++)
  279. delete [] m_prgmv [i];
  280. delete [] m_prgmv;
  281. }
  282. }
  284. CStatistics::CStatistics ()
  285. {
  286. reset ();
  287. }
  289. Void CStatistics::print (Bool bVOPPrint)
  290. {
  291. (Void) total ();
  293. if (bVOPPrint)
  294. cout << "t" << "VOP overhead:" << "tt" << nBitsHead << "n";
  295. cout << "t" << "Y:" << "ttt" << nBitsY << "n";
  296. cout << "t" << "Cr:" << "ttt" << nBitsCr << "n";
  297. cout << "t" << "Cb:" << "ttt" << nBitsCb << "n";
  298. cout << "t" << "A:" << "ttt" << nBitsA << "n";
  299. // cout << "t" << "1st Shape Code:" << "tt" << nBits1stShpCode << "n";
  300. cout << "t" << "CBPY:" << "ttt" << nBitsCBPY << "n";
  301. cout << "t" << "MCBPC:" << "ttt" << nBitsMCBPC << "n";
  302. cout << "t" << "DQUANT:" << "ttt" << nBitsDQUANT << "n";
  303. cout << "t" << "nBitsMODB:" << "tt" << nBitsMODB << "n";
  304. cout << "t" << "nBitsCBPB:" << "tt" << nBitsCBPB << "n";
  305. cout << "t" << "nBitsMBTYPE:" << "tt" << nBitsMBTYPE << "n";
  306. cout << "t" << "nBitsIntraPred:" << "tt" << nBitsIntraPred << "n";
  307. cout << "t" << "nBitsNoDCT:" << "tt" << nBitsNoDCT << "n";
  308. cout << "t" << "nBitsCODA:" << "tt" << nBitsCODA << "n";
  309. cout << "t" << "nBitsCBPA:" << "tt" << nBitsCBPA << "n";
  310. cout << "t" << "nBitsMODBA:" << "tt" << nBitsMODBA << "n";
  311. cout << "t" << "nBitsCBPBA:" << "tt" << nBitsCBPBA << "n";
  312. cout << "t" << "nBitsInterlace:" << "tt" << nBitsInterlace << "n";
  313. cout << "t" << "nBitsSTUFFING:" << "tt" << nBitsStuffing << "n";
  314. cout << "t" << "# of Skipped MB:" << "t" << nSkipMB << "n";
  315. cout << "t" << "# of Inter MB:" << "tt" << nInterMB << "n";
  316. cout << "t" << "# of Inter4V MB:" << "t" << nInter4VMB << "n";
  317. cout << "t" << "# of Intra MB:" << "tt" << nIntraMB << "n";
  318. cout << "t" << "# of Direct MB:" << "tt" << nDirectMB << "n";
  319. cout << "t" << "# of Forward MB:" << "t" << nForwardMB << "n";
  320. cout << "t" << "# of Backward MB:" << "t" << nBackwardMB << "n";
  321. cout << "t" << "# of Interpolate MB:" << "t" << nInterpolateMB << "n";
  322. cout << "t" << "# of Field Fwd MB:" << "t" << nFieldForwardMB << "n";
  323. cout << "t" << "# of Field Back MB:" << "t" << nFieldBackwardMB << "n";
  324. cout << "t" << "# of Field Ave MB:" << "t" << nFieldInterpolateMB << "n";
  325. cout << "t" << "# of Field Direct MB:" << "t" << nFieldDirectMB << "n";
  326. cout << "t" << "# of Field DCT MBs:" << "t" << nFieldDCTMB << "n";
  327. cout << "t" << "Motion:" << "ttt" << nBitsMV << "n";
  328. cout << "t" << "Texture:" << "tt" << nBitsTexture << "n";
  329. // if (bVOPPrint)
  330. cout << "t" << "Shape:" << "ttt" << nBitsShape << "n";
  331. cout << "t" << "Total:" << "ttt" << nBitsTotal << "n";
  332. cout << "t" << "SNR Y:" << "ttt" << dSNRY / nVOPs << " dBn";
  333. cout << "t" << "SNR U:" << "ttt" << dSNRU / nVOPs << " dBn";
  334. cout << "t" << "SNR V:" << "ttt" << dSNRV / nVOPs << " dBn";
  335. cout << "t" << "SNR A:" << "ttt" << dSNRA / nVOPs << " dBnn";
  336. cout << "t" << "average Qp:" << "tt" << (Double)nQp / nQMB << "nn";
  337. cout.flush ();
  338. }
  340. Void CStatistics::operator += (const CStatistics& statSrc)
  341. {
  342. nBitsHead += statSrc.nBitsHead;
  343. nBitsY += statSrc.nBitsY;
  344. nBitsCr += statSrc.nBitsCr;
  345. nBitsCb += statSrc.nBitsCb;
  346. nBitsA += statSrc.nBitsA;
  347. // nBits1stShpCode += statSrc.nBits1stShpCode;
  348. nBitsCOD += statSrc.nBitsCOD;
  349. nBitsCBPY += statSrc.nBitsCBPY;
  350. nBitsMCBPC += statSrc.nBitsMCBPC;
  351. nBitsDQUANT += statSrc.nBitsDQUANT;
  352. nBitsMODB += statSrc.nBitsMODB;
  353. nBitsCBPB += statSrc.nBitsCBPB;
  354. nBitsMBTYPE += statSrc.nBitsMBTYPE;
  355. nBitsIntraPred += statSrc.nBitsIntraPred;
  356. nBitsNoDCT += statSrc.nBitsNoDCT;
  357. nBitsCODA += statSrc.nBitsCODA;
  358. nBitsCBPA += statSrc.nBitsCBPA;
  359. nBitsMODBA += statSrc.nBitsMODBA;
  360. nBitsCBPBA += statSrc.nBitsCBPBA;
  361. nBitsStuffing += statSrc.nBitsStuffing;
  362. nSkipMB += statSrc.nSkipMB;
  363. nInterMB += statSrc.nInterMB;
  364. nInter4VMB += statSrc.nInter4VMB;
  365. nIntraMB += statSrc.nIntraMB;
  366. nDirectMB += statSrc.nDirectMB;
  367. nForwardMB += statSrc.nForwardMB;
  368. nBackwardMB += statSrc.nBackwardMB;
  369. nInterpolateMB += statSrc.nInterpolateMB;
  370. nBitsInterlace += statSrc.nBitsInterlace;
  371. nFieldForwardMB += statSrc.nFieldForwardMB;
  372. nFieldBackwardMB += statSrc.nFieldBackwardMB;
  373. nFieldInterpolateMB += statSrc.nFieldInterpolateMB;
  374. nFieldDirectMB += statSrc.nFieldDirectMB;
  375. nFieldDCTMB += statSrc.nFieldDCTMB;
  376. nVOPs += statSrc.nVOPs;
  377. nBitsMV += statSrc.nBitsMV;
  378. nBitsTexture += statSrc.nBitsTexture;
  379. nBitsShape += statSrc.nBitsShape;
  380. nBitsTotal += statSrc.nBitsTotal;
  381. dSNRY += statSrc.dSNRY;
  382. dSNRU += statSrc.dSNRU;
  383. dSNRV += statSrc.dSNRV;
  384. dSNRA += statSrc.dSNRA;
  385. nQMB += statSrc.nQMB;
  386. nQp += statSrc.nQp;
  387. }
  389. Void CStatistics::reset ()
  390. {
  391. nBitsHead = 0;
  392. nBitsY = 0;
  393. nBitsCr = 0;
  394. nBitsCb = 0;
  395. nBitsA = 0;
  396. // nBits1stShpCode = 0;
  397. nBitsCOD = 0;
  398. nBitsCBPY = 0;
  399. nBitsMCBPC = 0;
  400. nBitsDQUANT = 0;
  401. nBitsMODB = 0;
  402. nBitsCBPB = 0;
  403. nBitsMBTYPE = 0;
  404. nBitsIntraPred = 0;
  405. nBitsNoDCT = 0;
  406. nBitsCODA = 0;
  407. nBitsCBPA = 0;
  408. nBitsMODBA = 0;
  409. nBitsCBPBA = 0;
  410. nBitsStuffing = 0;
  411. nSkipMB = 0;
  412. nInterMB = 0;
  413. nInter4VMB = 0;
  414. nIntraMB = 0;
  415. nDirectMB = 0;
  416. nForwardMB = 0;
  417. nBackwardMB = 0;
  418. nInterpolateMB = 0;
  419. nBitsInterlace = 0;
  420. nFieldForwardMB = 0;
  421. nFieldBackwardMB = 0;
  422. nFieldInterpolateMB = 0;
  423. nFieldDirectMB = 0;
  424. nFieldDCTMB = 0;
  425. nVOPs = 0;
  426. nBitsMV = 0;
  427. nBitsTexture = 0;
  428. nBitsShape = 0;
  429. nBitsTotal = 0;
  430. dSNRY = 0;
  431. dSNRU = 0;
  432. dSNRV = 0;
  433. dSNRA = 0;
  434. nQMB = 0;
  435. nQp = 0;
  436. }
  438. CStatistics& CStatistics::operator = (const CStatistics& statSrc)
  439. {
  440. nBitsHead = statSrc.nBitsHead;
  441. nBitsY = statSrc.nBitsY;
  442. nBitsCr = statSrc.nBitsCr;
  443. nBitsCb = statSrc.nBitsCb;
  444. nBitsA = statSrc.nBitsA;
  445. // nBits1stShpCode = statSrc.nBits1stShpCode;
  446. nBitsCOD = statSrc.nBitsCOD;
  447. nBitsCBPY = statSrc.nBitsCBPY;
  448. nBitsMCBPC = statSrc.nBitsMCBPC;
  449. nBitsDQUANT = statSrc.nBitsDQUANT;
  450. nBitsMODB = statSrc.nBitsMODB;
  451. nBitsCBPB = statSrc.nBitsCBPB;
  452. nBitsMBTYPE = statSrc.nBitsMBTYPE;
  453. nBitsIntraPred = statSrc.nBitsIntraPred;
  454. nBitsNoDCT = statSrc.nBitsNoDCT;
  455. nBitsCODA = statSrc.nBitsCODA;
  456. nBitsCBPA = statSrc.nBitsCBPA;
  457. nBitsMODBA = statSrc.nBitsMODBA;
  458. nBitsCBPBA = statSrc.nBitsCBPBA;
  459. nBitsStuffing = statSrc.nBitsStuffing;
  460. nSkipMB = statSrc.nSkipMB;
  461. nInterMB = statSrc.nInterMB;
  462. nInter4VMB = statSrc.nInter4VMB;
  463. nIntraMB = statSrc.nIntraMB;
  464. nDirectMB = statSrc.nDirectMB;
  465. nForwardMB = statSrc.nForwardMB;
  466. nBackwardMB = statSrc.nBackwardMB;
  467. nInterpolateMB = statSrc.nInterpolateMB;
  468. nBitsInterlace = statSrc.nBitsInterlace;
  469. nFieldForwardMB = statSrc.nFieldForwardMB;
  470. nFieldBackwardMB = statSrc.nFieldBackwardMB;
  471. nFieldInterpolateMB = statSrc.nFieldInterpolateMB;
  472. nFieldDirectMB = statSrc.nFieldDirectMB;
  473. nFieldDCTMB = statSrc.nFieldDCTMB;
  474. nVOPs = statSrc.nVOPs;
  475. nBitsMV = statSrc.nBitsMV;
  476. nBitsTexture = statSrc.nBitsTexture;
  477. nBitsShape = statSrc.nBitsShape;
  478. nBitsTotal = statSrc.nBitsTotal;
  479. dSNRY = statSrc.dSNRY;
  480. dSNRU = statSrc.dSNRU;
  481. dSNRV = statSrc.dSNRV;
  482. dSNRA = statSrc.dSNRA;
  483. nQMB = statSrc.nQMB;
  484. nQp = statSrc.nQp;
  485. return *this;
  486. }
  489. UInt CStatistics::total ()
  490. {
  491. nBitsTexture = nBitsY + nBitsCr + nBitsCb + nBitsA + nBitsCOD
  492. + nBitsCBPY + nBitsMCBPC + nBitsDQUANT
  493. + nBitsMODB + nBitsCBPB + nBitsMBTYPE 
  494. + nBitsIntraPred + nBitsNoDCT
  495. + nBitsInterlace
  496. + nBitsCODA + nBitsCBPA + nBitsMODBA + nBitsCBPBA;
  497. nBitsTotal = nBitsHead + nBitsTexture + nBitsMV + nBitsShape + nBitsStuffing;
  498. return nBitsTotal;
  499. }
  501. UInt CStatistics::head ()
  502. {
  503. /*
  504. UInt bitsHead = nBitsCr + nBitsCb + nBitsA + nBitsCOD
  505. + nBitsCBPY + nBitsMCBPC + nBitsDQUANT
  506. + nBitsMODB + nBitsCBPB + nBitsMBTYPE 
  507. + nBitsIntraPred + nBitsNoDCT
  508. + nBitsInterlace
  509. + nBitsCODA + nBitsCBPA + nBitsMODBA + nBitsCBPBA;
  510. bitsHead +=  nBitsHead + nBitsMV + nBitsShape + nBitsStuffing;
  511. */
  512. UInt bitsHead = nBitsTotal - nBitsTexture;
  513. return bitsHead;
  514. }
  516. Void CRCMode::reset (UInt uiFirstFrame, UInt uiLastFrame, UInt uiTemporalRate, 
  517.    UInt uiBufferSize, Double mad, UInt uiBitsFirstFrame, Double dFrameHz)
  518. {
  519. m_Ts = (uiLastFrame - uiFirstFrame + 1) / 30.0;
  520. m_Rs = (UInt) (uiBufferSize / m_Ts);
  521. m_Ns = uiTemporalRate;
  522. m_X1 = m_Rs * m_Ns / 2.0; // 1st order coefficient transient
  523. m_X2 = 0.0; // 2nd order coeeficient transient
  524. m_Nr = (uiLastFrame - uiFirstFrame + 1) / m_Ns - 1;
  525. m_Nc = 0;
  526. m_Rf = uiBitsFirstFrame;
  527. m_Rc = uiBitsFirstFrame;
  528. m_S = uiBitsFirstFrame;
  529. m_Qc = 15;
  530. m_Qp = 15; // a simple solution (assumption)
  531. m_Rr = (UInt) (m_Ts * m_Rs) - m_Rf; // total number of bits available for this segment
  532. m_Rp = m_Rr / m_Nr; // average bits to be removed from the buffer
  533. m_Bs = m_Rs / 2; // assumed buffer size
  534. m_B = m_Rs / 4; // current buffer level containing the bits for first frame
  535. for (UInt i = 0; i < RC_MAX_SLIDING_WINDOW; i++) {// if 0, don't use that frame (rejected outliers)
  536. m_rgQp[i] = 0;
  537. m_rgRp[i] = 0.0;
  538. }
  539. m_Ec = mad; 
  540. m_skipNextFrame = FALSE;
  541. }
  543. UInt CRCMode::updateQuanStepsize ()
  544. {
  545. // Target bit calculation 
  546. m_T = (UInt) max (m_Rs / 30.0, m_Rr / m_Nr * (1.0 - RC_PAST_PERCENT) + m_S * RC_PAST_PERCENT); // a minimum of Rs/30 is assigned to each frame
  547. m_T = (UInt) (m_T * (m_B + 2.0 * (m_Bs - m_B)) / (2.0 * m_B + (m_Bs - m_B))); // increase if less than half, decrease if more than half, don't change if half
  548. if ((m_B + m_T) > (1.0 - RC_SAFETY_MARGIN) * m_Bs)
  549. m_T = (UInt) max (m_Rs / 30.0, (1.0 - RC_SAFETY_MARGIN) * m_Bs - m_B); // to avoid buffer overflow
  550. else if ((m_B - m_Rp + m_T) < RC_SAFETY_MARGIN * m_Bs)
  551. m_T = m_Rp - m_B + (UInt) (RC_SAFETY_MARGIN * m_Bs);   // to avoid buffer underflow
  552. m_T = min (m_T, (UInt)m_Rr);
  554. // Quantization level calculation
  555. m_T = max (m_Rp / 3 + m_Hp, m_T);
  556. Double dtmp = m_Ec * m_X1 * m_Ec * m_X1 + 4 * m_X2 * m_Ec * (m_T - m_Hp);
  557. if ((m_X2 == 0.0) || (dtmp < 0) || ((sqrt (dtmp) - m_X1 * m_Ec) <= 0.0)) // fall back 1st order mode
  558. m_Qc = (UInt) (m_X1 * m_Ec / (Double) (m_T - m_Hp));
  559. else // 2nd order mode
  560. m_Qc = (UInt) ((2 * m_X2 * m_Ec) / (sqrt (dtmp) - m_X1 * m_Ec));
  561. m_Qc = (UInt) min (ceil(m_Qp * (1.0 + RC_MAX_Q_INCREASE)), (Double) m_Qc); // control variation
  562. m_Qc = min (m_Qc, RC_MAX_QUANT); // clipping
  563. m_Qc = (UInt) max (ceil(m_Qp * (1.0 - RC_MAX_Q_INCREASE)), (Double) m_Qc); // control variation
  564. m_Qc = max (m_Qc, RC_MIN_QUANT); // clipping
  565. return m_Qc;
  566. }
  568. Void CRCMode::updateRCModel (UInt uiBitsTotalCurr, UInt uiBitsHeadCurr)
  569. {
  570. UInt n_windowSize;
  572. m_Rc = uiBitsTotalCurr; // total bits used for the current frame 
  573. m_B += m_Rc - m_Rp; // update buffer fillness
  574. m_Rr -= m_Rc; // update the remaining bits
  575. if (m_Nr != 1) 
  576. assert (m_Rr > 0.0); // check if there is any bits left, except the last frame
  577. m_S = m_Rc; // update the previous bits
  578. m_Hc = uiBitsHeadCurr; // update the current header and motion bits
  579. m_Hp = m_Hc; // update the previous header and motion bits
  580. m_Qp = m_Qc; // update the previous qunatization level
  581. m_Nr--; // update the frame counter
  582. m_Nc++;
  584. Int i;
  585. for (i = RC_MAX_SLIDING_WINDOW - 1; i > 0; i--) {// update the history
  586. m_rgQp[i] = m_rgQp[i - 1];
  587. m_rgRp[i] = m_rgRp[i - 1];
  588. }
  589. m_rgQp[0] = m_Qc;
  590. m_rgRp[0] = (m_Rc - m_Hc) / m_Ec;
  592. n_windowSize = (m_Ep > m_Ec) ? (UInt) (m_Ec / m_Ep * 20) : (UInt) (m_Ep / m_Ec * 20);
  593. n_windowSize = max (n_windowSize, 1);
  594. n_windowSize = min (n_windowSize, m_Nc);
  595. for (i = 0; i < RC_MAX_SLIDING_WINDOW; i++) {
  596. m_rgRejected[i] = FALSE;
  597. }
  599. // initial RD model estimator
  600. RCModelEstimator (n_windowSize);
  602. // remove outlier
  603. Double error[20], std = 0.0, threshold;
  604. for (i = 0; i < (Int) n_windowSize; i++) {
  605. error[i] = m_X1 / m_rgQp[i] + m_X2 / (m_rgQp[i] * m_rgQp[i]) - m_rgRp[i];
  606. std += error[i] * error[i];
  607. }
  608. threshold = (n_windowSize == 2) ? 0 : sqrt (std / n_windowSize);
  609. for (i = 0; i < (Int) n_windowSize; i++) {
  610. if (fabs(error[i]) > threshold)
  611. m_rgRejected[i] = TRUE;
  612. }
  613.     // always include the last data point
  614. m_rgRejected[0] = FALSE;
  616. // second RD model estimator
  617. RCModelEstimator (n_windowSize);
  618. }
  620. Bool CRCMode::skipThisFrame ()
  621. {
  622. if (m_B > (Int) ((RC_SKIP_MARGIN / 100.0) * m_Bs)) { // buffer full!
  623. m_skipNextFrame = TRUE; // set the status
  624. m_Nr--; // skip one frame
  625. m_B -= m_Rp; // decrease current buffer level
  626. } else
  627. m_skipNextFrame = FALSE;
  628. return m_skipNextFrame;
  629. }
  631. Void CRCMode::RCModelEstimator (UInt n_windowSize)
  632. {
  633. UInt n_realSize = n_windowSize;
  634. UInt i;
  635. for (i = 0; i < n_windowSize; i++) {// find the number of samples which are not rejected
  636. if (m_rgRejected[i])
  637. n_realSize--;
  638. }
  640. // default RD model estimation results
  641. Bool estimateX2 = FALSE;
  642. m_X1 = m_X2 = 0.0;
  643. Double oneSampleQ = 0.0;
  644. for (i = 0; i < n_windowSize; i++) {
  645. if (!m_rgRejected[i])
  646. oneSampleQ = m_rgQp[i];
  647. }
  648. for (i = 0; i < n_windowSize; i++) {// if all non-rejected Q are the same, take 1st order model
  649. if ((m_rgQp[i] != oneSampleQ) && !m_rgRejected[i])
  650. estimateX2 = TRUE;
  651. if (!m_rgRejected[i])
  652. m_X1 += (m_rgQp[i] * m_rgRp[i]) / n_realSize;
  653. }
  655. // take 2nd order model to estimate X1 and X2
  656. if ((n_realSize >= RC_START_RATE_CONTROL) && estimateX2) {
  657. Double a00 = 0.0, a01 = 0.0, a10 = 0.0, a11 = 0.0, b0 = 0.0, b1 = 0.0;
  658. for (UInt i = 0; i < n_windowSize; i++) {
  659. if (!m_rgRejected[i]) {
  660. a00 = a00 + 1.0;
  661. a01 += 1.0 / m_rgQp[i];
  662. a10 = a01;
  663. a11 += 1.0 / (m_rgQp[i] * m_rgQp[i]);
  664. b0 += m_rgQp[i] * m_rgRp[i];
  665. b1 += m_rgRp[i];
  666. }
  667. }
  668. // solve the equation of AX = B
  669. CMatrix2x2D A = CMatrix2x2D (a00, a01, a10, a11);
  670. CMatrix2x2D AInv = A.inverse ();
  671. CVector2D B = CVector2D (b0, b1);
  672. CVector2D solution = AInv.apply (B);
  673. if (solution.x != 0.0) {
  674. m_X1 = solution.x;
  675. m_X2 = solution.y;
  676. }
  677. }
  678. }