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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

vopsedec.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. and also edited by
  15. Yoshihiro Kikuchi (TOSHIBA CORPORATION)
  16. Takeshi Nagai (TOSHIBA CORPORATION)
  17. Toshiaki Watanabe (TOSHIBA CORPORATION)
  18. Noboru Yamaguchi (TOSHIBA CORPORATION)
  20. and also edited by
  21. David B. Shu (dbshu@hrl.com), Hughes Electronics/HRL Laboratories
  23. and also edited by
  24. Dick van Smirren (D.vanSmirren@research.kpn.com), KPN Research
  25. Cor Quist (C.P.Quist@research.kpn.com), KPN Research
  27. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  28. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  29. as specified by the MPEG-4 Video. 
  30. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  31. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  32. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
  33. The original developer of this software module and his/her company, 
  34. the subsequent editors and their companies, 
  35. and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
  36. Copyright is not released for non MPEG-4 Video conforming products. 
  37. Microsoft retains full right to use the code for his/her own purpose, 
  38. assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
  39. This copyright notice must be included in all copies or derivative works. 
  41. Copyright (c) 1996, 1997.
  43. Module Name:
  45. vopSeDec.cpp
  47. Abstract:
  49. Decoder for one Video Object.
  51. Revision History:
  52. Dec 20, 1997: Interlaced tools added by NextLevel Systems
  53.                     X. Chen (xchen@nlvl.com) B. Eifrig (beifrig@nlvl.com)
  55. *************************************************************************/
  56. #include <stdio.h>
  57. #ifdef __GNUC__
  58. #include <strstream.h>
  59. #else
  60. #include <strstrea.h>
  61. #endif
  62. #include <math.h>
  64. #include "typeapi.h"
  65. #include "codehead.h"
  66. #include "entropy/bitstrm.hpp"
  67. #include "entropy/entropy.hpp"
  68. #include "entropy/huffman.hpp"
  69. #include "global.hpp"
  70. #include "mode.hpp"
  71. #include "vopses.hpp"
  72. #include "cae.h" // Added for error resilient mode by Toshiba(1997-11-14)
  74. #include "tps_enhcbuf.hpp" // Added by Sharp(1998-02-10)
  75. #include "enhcbufdec.hpp" //
  76. #include "vopsedec.hpp"
  78. #ifdef __MFC_
  79. #ifdef _DEBUG
  80. #undef THIS_FILE
  81. static char BASED_CODE THIS_FILE[] = __FILE__;
  82. #endif
  84. #define new DEBUG_NEW    
  85. #endif // __MFC_
  87. #define _FOR_GSSP_
  88. #undef assert
  89. #define assert(a) if (!(a)) { printf("iso throw %dn", __LINE__);throw((int)0);}
  90. CVideoObjectDecoder::~CVideoObjectDecoder ()
  91. {
  92. // delete m_pistrm;
  93.   if (m_pistrm >= 0) close(m_pistrm);
  94. delete m_pbitstrmIn;
  95. delete m_pentrdecSet;
  96. delete m_pvopcRightMB;
  97. }
  100. Int CVideoObjectDecoder::h263_decode ()
  101. {
  102. static Bool first_time = TRUE;
  104. if (!first_time) 
  105. {
  106. while ( m_pbitstrmIn -> peekBits(NUMBITS_SHORT_HEADER_START_CODE) != SHORT_VIDEO_START_MARKER)
  107. {
  108. if(m_pbitstrmIn->eof()==EOF)  // [FDS] 
  109. return EOF;
  110. m_pbitstrmIn -> getBits(1);
  111. }
  114. m_pbitstrmIn -> getBits(22);
  115. video_plane_with_short_header(); 
  116. }
  117. else
  118. first_time = FALSE;
  120. m_bUseGOV=FALSE; 
  121. m_bLinkisBroken=FALSE;
  122. m_vopmd.iRoundingControl=0;
  123. m_vopmd.iIntraDcSwitchThr=0; 
  124. m_vopmd.bInterlace=FALSE;
  125. m_vopmd.bAlternateScan=FALSE;
  126. m_t=1; 
  127. m_vopmd.mvInfoForward.uiFCode=1; 
  128. m_vopmd.mvInfoForward.uiScaleFactor = 1 << (m_vopmd.mvInfoForward.uiFCode - 1);
  129. m_vopmd.mvInfoForward.uiRange = 16 << m_vopmd.mvInfoForward.uiFCode;
  130. // Added for error resilient mode by Toshiba(1998-1-16)
  131. m_vopmd.mvInfoBackward.uiFCode = 1;
  132. // End Toshiba(1998-1-16)
  133. m_vopmd.bShapeCodingType=1;
  135. // set time stamps for Base/Temporal-Enhc/Spatial-Enhc Layer Modified by Sharp(1998-02-10)
  136. if(m_volmd.volType == BASE_LAYER) {
  137. if(m_vopmd.vopPredType==IVOP || m_vopmd.vopPredType==PVOP) {
  138. m_tPastRef = m_tFutureRef; 
  139. m_tFutureRef = m_t; 
  140. m_iBCount = 0;
  141. }
  143. }
  145. // set time stamps for Base/Temporal-Enhc/Spatial-Enhc Layer End      Sharp(1998-02-10)
  147. // select reference frames for Base/Temporal-Enhc/Spatial-Enhc Layer Modified by Sharp(1998-02-10)
  148. if(m_volmd.volType == BASE_LAYER) {
  149. updateAllRefVOPs ();            // update all reconstructed VOP'sm_pvopcRefQ1->vdlDump ("c:\refq1.vdl");
  150. }
  152. // select reference frames for Base/Temporal-Enhc/Spatial-Enhc Layer End     Sharp(1998-02-10)
  154. switch(m_vopmd.vopPredType)
  155. {
  156. case IVOP:
  157. #ifdef DEBUG_OUTPUT
  158. cout << "tIVOP";
  159. #endif
  160. /*Added by SONY (98/03/30)*/
  161. if(m_bLinkisBroken == TRUE && m_bUseGOV == TRUE)        m_bLinkisBroken = FALSE;
  162. /*Added by SONY (98/03/30) END*/
  163. break;
  164. case PVOP:
  165. #ifdef DEBUG_OUTPUT
  166. cout << "tPVOP (reference: t=" << m_tPastRef <<")";
  167. #endif
  168. break;
  169. default:
  170. break;
  171. }
  172. #ifdef DEBUG_OUTPUT
  173. cout << "n";
  174. cout.flush ();
  175. #endif
  176. /* Added by SONY (98/03/30)*/
  177. if(m_bLinkisBroken == TRUE && m_bUseGOV == TRUE)
  178. fprintf(stderr,"WARNING: broken_link = 1  --- Output image must be broken.n");
  179. /*Added by SONY (98/03/30) End*/
  181. decodeVOP ();  
  183. CMBMode* pmbmdTmp = m_rgmbmd;
  184. m_rgmbmd = m_rgmbmdRef;
  185. m_rgmbmdRef = pmbmdTmp;
  186. CMotionVector* pmvTmp = m_rgmv;
  187. m_rgmv = m_rgmvRef;
  188. m_rgmvRef = pmvTmp;
  189. m_rgmvBackward = m_rgmv + BVOP_MV_PER_REF_PER_MB * m_iSessNumMB;
  190. // ? For Temporal Scalability End  Sharp(1998-02-10)
  191. m_iBVOPOffsetForPadY = m_iOffsetForPadY;
  192. m_iBVOPOffsetForPadUV = m_iOffsetForPadUV;
  193. m_rctBVOPPrevNoExpandY = m_rctPrevNoExpandY;
  194. m_rctBVOPPrevNoExpandUV = m_rctPrevNoExpandUV;
  196. m_rctBVOPRefVOPY1 = m_rctRefVOPY1;
  197. m_rctBVOPRefVOPUV1 = m_rctRefVOPUV1;
  198. // For Temporal Scalability End  Sharp(1998-02-10)
  200. repeatPadYOrA ((PixelC*) m_pvopcRefQ1->pixelsY () + m_iOffsetForPadY, m_pvopcRefQ1);
  201. repeatPadUV (m_pvopcRefQ1);
  203. //reset by in RefQ1 so that no left-over from last frame
  205. return TRUE; 
  206. }
  208. Void CVideoObjectDecoder::video_plane_with_short_header()
  209. {
  210.   /* UInt uiTemporalReference = wmay */ m_pbitstrmIn -> getBits (8);
  211. m_pbitstrmIn -> getBits(5);
  212. UInt uiSourceFormat = m_pbitstrmIn -> getBits (3);
  214. if (uiSourceFormat==1) {
  215. //fprintf(stderr,"Sub-QCIF, 128x96, 8 macroblocks/gob, 6 gobs in vopn");
  216. uiNumGobsInVop=6;
  217. uiNumMacroblocksInGob=8;
  218. m_ivolWidth=128;
  219. m_ivolHeight=96;
  220. } else if (uiSourceFormat==2) {
  221. //fprintf(stderr,"QCIF, 176x144, 11 macroblocks/gob, 9 gobs in vopn");
  222. uiNumGobsInVop=9;
  223. uiNumMacroblocksInGob=11;
  224. m_ivolWidth=176;
  225. m_ivolHeight=144;
  226. } else if (uiSourceFormat==3) {
  227. //fprintf(stderr,"CIF, 352x288, 22 macroblocks/gob, 18 gobs in vopn");
  228. uiNumGobsInVop=18;
  229. uiNumMacroblocksInGob=22;
  230. m_ivolWidth=352;
  231. m_ivolHeight=288;
  232. } else if (uiSourceFormat==4) {
  233. //fprintf(stderr,"4CIF, 704x576, 88 macroblocks/gob, 18 gobs in vopn");
  234. uiNumGobsInVop=18;
  235. uiNumMacroblocksInGob=88;
  236. m_ivolWidth=704;
  237. m_ivolHeight=576;
  238. } else if (uiSourceFormat==5) {
  239. //fprintf(stderr,"16CIF, 1408x1152, 352 macroblocks/gob, 18 gobs in vopn");
  240. uiNumGobsInVop=18;
  241. uiNumMacroblocksInGob=352;
  242. m_ivolWidth=1408;
  243. m_ivolHeight=1152;
  244. } else {
  245. fprintf(stderr,"Wrong Source Format in video_plane_with_short_header()n");
  246. exit (0);
  247. }
  248. UInt uiPictureCodingType = m_pbitstrmIn -> getBits(1);
  249. if (uiPictureCodingType==0) 
  250. m_vopmd.vopPredType=IVOP;
  251. else
  252. m_vopmd.vopPredType=PVOP;
  254. m_pbitstrmIn -> getBits(4);
  255. UInt uiVopQuant = m_pbitstrmIn -> getBits(5);
  256. //fprintf(stderr,"vop_quant (0..31)             %dn",uiVopQuant);
  257. m_vopmd.intStepI=uiVopQuant; 
  258. m_vopmd.intStep=uiVopQuant; // idem
  259. m_pbitstrmIn -> getBits(1);
  260. do {
  261. uiPei = m_pbitstrmIn -> getBits(1);
  262. //fprintf(stderr,"pei gelezen %dn",uiPei);
  263. if (uiPei==1) {
  265. m_pbitstrmIn -> getBits(8);
  266. }
  267. // [bezig]
  268. } while (uiPei==1);
  270. m_uiVOId = 1; 
  271. m_volmd.iClockRate = 30; 
  272. m_iNumBitsTimeIncr = 4; 
  273. m_volmd.bShapeOnly=FALSE; 
  274. m_volmd.fAUsage = RECTANGLE; 
  275. m_volmd.bAdvPredDisable = TRUE; 
  276. m_uiSprite = FALSE; 
  277. m_volmd.bNot8Bit=FALSE; 
  278. m_volmd.uiQuantPrecision=5;
  279. m_volmd.nBits=8;
  280. m_volmd.fQuantizer=Q_H263; 
  281. m_volmd.bDataPartitioning=FALSE;
  282. m_volmd.bReversibleVlc=FALSE;
  283. m_volmd.volType=BASE_LAYER;
  284. m_volmd.ihor_sampling_factor_n=1;
  285. m_volmd.ihor_sampling_factor_m=1;
  286. m_volmd.iver_sampling_factor_n=1;
  287. m_volmd.iver_sampling_factor_m=1;
  288. m_volmd.bDeblockFilterDisable=TRUE;
  291. }
  294. void CVideoObjectDecoder::decodeShortHeaderIntraMBDC(Int *rgiCoefQ)
  295. {
  296. UInt uiIntraDC;
  297. uiIntraDC=m_pbitstrmIn->getBits(8);
  298. if (uiIntraDC==128||uiIntraDC==0) fprintf(stderr,"IntraDC = 0 of 128, not allowed in H.263 moden");
  299. if (uiIntraDC==255) uiIntraDC=128;
  301. rgiCoefQ[0]=uiIntraDC;
  302. }
  305. CVideoObjectDecoder::CVideoObjectDecoder () : CVideoObject()
  306. {
  307.   m_t = m_tPastRef = m_tFutureRef = 0;
  308.   m_iBCount = 0;
  309.   m_vopmd.iVopConstantAlphaValue = 255;
  310.   short_video_header = FALSE;
  311.   m_pbitstrmIn = new CInBitStream();
  312.   m_pentrdecSet = new CEntropyDecoderSet (*m_pbitstrmIn);
  314. }
  316. CVideoObjectDecoder::CVideoObjectDecoder (
  317. const Char* pchStrFile,
  318. Int iDisplayWidth, Int iDisplayHeight,
  319. Bool *pbSpatialScalability,
  320. Bool *p_short_video_header//,
  321. //strstreambuf* pistrm
  322. ) : CVideoObject ()
  323. {
  324. #if 0
  325. if (pistrm == NULL) {
  326. #endif
  327.   m_pistrm = open(pchStrFile, O_RDONLY);
  328.   if(m_pistrm < 0)
  329. fatal_error("Can't open bitstream file");
  330. #if 0
  331. }
  332. else {
  333. m_pistrm = (ifstream *)new istream (pistrm);
  334. }
  335. #endif
  336. m_pbitstrmIn = new CInBitStream(m_pistrm);
  337. m_pentrdecSet = new CEntropyDecoderSet (*m_pbitstrmIn);
  339. m_t = m_tPastRef = m_tFutureRef = 0;
  340. m_iBCount = 0;
  342. m_vopmd.iVopConstantAlphaValue = 255;
  344. *p_short_video_header=FALSE; // Added by KPN for short headers
  347. if (m_pbitstrmIn->peekBits(NUMBITS_SHORT_HEADER_START_CODE) == SHORT_VIDEO_START_MARKER) 
  348.  
  349. { 
  351. fprintf(stderr, "nBitstream with short header format detectedn"); 
  352. *p_short_video_header=TRUE;  
  353. m_pbitstrmIn -> getBits(22);
  354. video_plane_with_short_header();
  355. }
  356. else {
  358. fprintf(stderr,"nBitstream without short headers detectedn");
  359. decodeVOHead ();
  360. printf ("VO %d...n", m_uiVOId);
  361. decodeVOLHead ();
  363. } 
  365. short_video_header=*p_short_video_header; 
  366. postVO_VOLHeadInit(iDisplayWidth, iDisplayHeight, pbSpatialScalability);
  367. }
  369. void CVideoObjectDecoder::postVO_VOLHeadInit (Int iDisplayWidth, 
  370.       Int iDisplayHeight,
  371.       Bool *pbSpatialScalability)
  373. {
  375. /* (98/03/30 added by SONY)*/
  376. m_bLinkisBroken = FALSE;
  377. m_bUseGOV = FALSE;
  378. /* (98/03/30 added by SONY)*/
  379. // Added for error resilient mode by Toshiba(1997-11-14): Moved (1998-1-16)
  380. g_iMaxHeading = MAXHEADING_ERR;
  381. g_iMaxMiddle = MAXMIDDLE_ERR;
  382. g_iMaxTrailing = MAXTRAILING_ERR;
  383. // End Toshiba(1997-11-14)
  385. setClipTab(); // NBIT
  387. if(m_volmd.volType == ENHN_LAYER){ // check scalability type
  388. if(pbSpatialScalability != NULL)
  389. if(m_volmd.iHierarchyType == 0)
  390. *pbSpatialScalability = TRUE;
  391. else 
  392. *pbSpatialScalability = FALSE;
  393. }
  394. if (m_volmd.fAUsage == RECTANGLE) {
  395. if (m_volmd.volType == ENHN_LAYER &&
  396. (m_volmd.ihor_sampling_factor_n != m_volmd.ihor_sampling_factor_m ||
  397.        m_volmd.iver_sampling_factor_n != m_volmd.iver_sampling_factor_m )){
  398. iDisplayWidth = m_ivolWidth;
  399. iDisplayHeight= m_ivolHeight;
  401. }
  402. else if (iDisplayWidth == -1 && iDisplayHeight == -1) {
  403.   iDisplayWidth = m_ivolWidth;
  404.   iDisplayHeight = m_ivolHeight;
  405. }
  406. else if (iDisplayWidth != m_ivolWidth || iDisplayHeight != m_ivolHeight){
  407. fprintf(stderr, "nDecode aborted! This rectangular VOP stream requires displaynwidth and height to be set to %dx%d.n",
  408. m_ivolWidth, m_ivolHeight);
  409. exit(1);
  410. }
  411. }
  412. m_rctDisplayWindow = CRct (0, 0, iDisplayWidth, iDisplayHeight); //same as m_rctOrg? will fixe later
  413. /*
  414. if (m_volmd.fAUsage == RECTANGLE) {
  415. if (m_volmd.volType == ENHN_LAYER &&
  416. (m_volmd.ihor_sampling_factor_n/m_volmd.ihor_sampling_factor_m != 1||
  417.        m_volmd.iver_sampling_factor_n/m_volmd.iver_sampling_factor_m != 1)){
  418. iDisplayWidth = m_ivolWidth;
  419. iDisplayHeight= m_ivolHeight;
  420. if(pbSpatialScalability!=NULL)
  421. *pbSpatialScalability = TRUE;
  422. fprintf(stderr,"display size %d %d n",iDisplayWidth, iDisplayHeight);
  423. }
  424. else if (iDisplayWidth != m_ivolWidth || iDisplayHeight != m_ivolHeight){
  425. fprintf(stderr, "nDecode aborted! This rectangular VOP stream requires displaynwidth and height to be set to %dx%d.n",
  426. m_ivolWidth, m_ivolHeight);
  427. exit(1);
  428. }
  429. else if(pbSpatialScalability!=NULL)
  430. *pbSpatialScalability = FALSE;
  431. }
  432. m_rctDisplayWindow = CRct (0, 0, iDisplayWidth, iDisplayHeight); //same as m_rctOrg? will fixe later
  433. */
  435. if (m_uiSprite == 1) { // change iDisplay size in order to get the first sprite piece
  436. iDisplayWidth = (Int) m_rctSpt.width;
  437. iDisplayHeight = (Int) m_rctSpt.height ();
  438. }
  440. Int iMod = iDisplayWidth % MB_SIZE;
  441. Int iDisplayWidthRound = (iMod > 0) ? iDisplayWidth + MB_SIZE - iMod : iDisplayWidth;
  442. iMod = iDisplayHeight % MB_SIZE;
  443. Int iDisplayHeightRound = (iMod > 0) ? iDisplayHeight + MB_SIZE - iMod : iDisplayHeight;
  444. m_rctRefFrameY = CRct (
  445. -EXPANDY_REF_FRAME, -EXPANDY_REF_FRAME, 
  446. EXPANDY_REF_FRAME + iDisplayWidthRound, EXPANDY_REF_FRAME + iDisplayHeightRound
  447. );
  448. m_rctRefFrameUV = m_rctRefFrameY.downSampleBy2 ();
  449. allocateVOLMembers (iDisplayWidth, iDisplayHeight);
  451. if (m_volmd.fAUsage == RECTANGLE) {
  453. //wchen: if sprite; set it according to the initial piece instead
  454. m_rctCurrVOPY = (m_uiSprite == 0) ? CRct (0, 0, iDisplayWidthRound, iDisplayHeightRound) : m_rctSpt;
  456. m_rctCurrVOPUV = m_rctCurrVOPY.downSampleBy2 ();
  458. m_rctRefVOPY0 = m_rctCurrVOPY;
  459. m_rctRefVOPY0.expand (EXPANDY_REFVOP);
  460. m_rctRefVOPUV0 = m_rctRefVOPY0.downSampleBy2 ();
  462. m_rctRefVOPY1 = m_rctRefVOPY0;
  463. m_rctRefVOPUV1 = m_rctRefVOPUV0;
  465. computeVOLConstMembers (); // these VOP members are the same for all frames
  466. }
  467. // buffer for shape decoding
  468. m_pvopcRightMB = new CVOPU8YUVBA (m_volmd.fAUsage, CRct (0, 0, MB_SIZE, MB_SIZE));
  469. m_ppxlcRightMBBY = (PixelC*) m_pvopcRightMB->pixelsBY ();
  470. m_ppxlcRightMBBUV = (PixelC*) m_pvopcRightMB->pixelsBUV ();
  472. // buffers for Temporal Scalabe Decoding Added by Sharp(1998-02-10)
  473. if (m_volmd.volType == ENHN_LAYER) {
  474. m_pBuffP1 = new CEnhcBufferDecoder (m_rctRefFrameY.width, m_rctRefFrameY.height ());
  475. m_pBuffP2 = new CEnhcBufferDecoder (m_rctRefFrameY.width, m_rctRefFrameY.height ());
  476. m_pBuffB1 = new CEnhcBufferDecoder (m_rctRefFrameY.width, m_rctRefFrameY.height ());
  477. m_pBuffB2 = new CEnhcBufferDecoder (m_rctRefFrameY.width, m_rctRefFrameY.height ());
  478. m_pBuffE  = new CEnhcBufferDecoder (m_rctRefFrameY.width, m_rctRefFrameY.height ());
  479. }
  480. // buffers for Temporal Scalabe Decoding End  Sharp(1998-02-10)
  481. m_iClockRateScale = 1; // added by Sharp (98/6/26)
  483. // Set sprite_transmit_mode to STOP for the duration of VOL if (fSptUsage () == 0),
  484. // and later set to PIECE by decode_init_sprite () if (fSptUsage () == 1)
  485. m_vopmd.SpriteXmitMode = STOP;   
  486. }
  487. // for back/forward shape Added by Sharp(1998-02-10)
  488. CVideoObjectDecoder::CVideoObjectDecoder (
  489. Int iDisplayWidth, Int iDisplayHeight
  490. ) : CVideoObject ()
  491. {
  492. m_pistrm = -1;
  493. m_pbitstrmIn = NULL;
  494. m_pentrdecSet = NULL;
  496. m_uiVOId = 0;
  497. Void set_modes(VOLMode* volmd, VOPMode* vopmd);
  498. set_modes(&m_volmd, &m_vopmd); // set VOL modes, VOP modes
  500. m_vopmd.iVopConstantAlphaValue = 255;
  502. Int iMod = iDisplayWidth % MB_SIZE;
  503. Int iDisplayWidthRound = (iMod > 0) ? iDisplayWidth + MB_SIZE - iMod : iDisplayWidth;
  504. iMod = iDisplayHeight % MB_SIZE;
  505. Int iDisplayHeightRound = (iMod > 0) ? iDisplayHeight + MB_SIZE - iMod : iDisplayHeight;
  506. m_rctRefFrameY = CRct (
  507. -EXPANDY_REF_FRAME, -EXPANDY_REF_FRAME,
  508. EXPANDY_REF_FRAME + iDisplayWidthRound, EXPANDY_REF_FRAME + iDisplayHeightRound
  509. );
  510. m_rctRefFrameUV = m_rctRefFrameY.downSampleBy2 ();
  511. allocateVOLMembers (iDisplayWidth, iDisplayHeight);
  513. // buffer for shape decoding
  514. m_pvopcRightMB = new CVOPU8YUVBA (m_volmd.fAUsage, CRct (0, 0, MB_SIZE, MB_SIZE));
  515. m_ppxlcRightMBBY = (PixelC*) m_pvopcRightMB->pixelsBY ();
  516. m_ppxlcRightMBBUV = (PixelC*) m_pvopcRightMB->pixelsBUV ();
  517. }
  518. // for back/forward shape End  Sharp(1998-02-10)
  520. Int CVideoObjectDecoder::decode (const CVOPU8YUVBA* pvopcBVOPQuant, /*strstreambuf* pistrm, */ Bool waitForI, Bool drop)
  521. {
  522. #if 0
  523. if (pistrm != NULL) {
  524. delete (istream *)m_pistrm;
  525. delete m_pbytestrmIn;
  526. delete m_pbitstrmIn;
  527. delete m_pentrdecSet;
  528. m_pistrm = (ifstream *)new istream (pistrm);
  529. m_pbytestrmIn = new CInByteStreamFile(*m_pistrm);
  530. m_pbitstrmIn = new CInBitStream (m_pbytestrmIn);
  531. m_pentrdecSet = new CEntropyDecoderSet (*m_pbitstrmIn);
  532. }
  533. #endif
  534. //sprite piece should not come here
  535. assert ((m_vopmd.SpriteXmitMode == STOP) || ( m_vopmd.SpriteXmitMode == PAUSE));
  537. if (findStartCode () == EOF)
  538. return EOF;
  540. Bool bCoded = decodeVOPHead (); // set the bounding box here
  541. if (waitForI && 
  542.     !(m_vopmd.vopPredType == IVOP)) {
  543. #ifdef DEBUG_OUTPUT
  544.   cout << "tFrame is not IVOP " << m_vopmd.vopPredType << "n";
  545.   cout.flush();
  546. #endif
  547.   return -1;
  548. }
  549. if (drop && m_vopmd.vopPredType == BVOP) {
  550.   return -1;
  551. }
  552. #ifdef DEBUG_OUTPUT
  553. cout << "t" << "Time..." << m_t << " (" << m_t / (double)m_volmd.iClockRate << " sec)n";
  554. if(bCoded == FALSE)
  555. cout << "tNot coded.n";
  556. cout.flush ();
  557. #endif
  559. Bool bPrevRefVopWasCoded = m_bCodedFutureRef;
  560. if(m_vopmd.vopPredType==IVOP || m_vopmd.vopPredType==PVOP)
  561. m_bCodedFutureRef = bCoded; // flag used by bvop prediction
  563. if (m_vopmd.vopPredType == SPRITE) {
  564. decodeSpt ();
  565. return TRUE;
  566. }
  568. // set time stamps for Base/Temporal-Enhc/Spatial-Enhc Layer Modified by Sharp(1998-02-10)
  569. if(m_volmd.volType == BASE_LAYER) {
  570. if(m_vopmd.vopPredType==IVOP || m_vopmd.vopPredType==PVOP) {
  571. if(bPrevRefVopWasCoded)
  572. m_tPastRef = m_tFutureRef;
  573. m_tFutureRef = m_t;
  574. m_iBCount = 0;
  575. }
  576. // count B-VOPs
  577. if(m_vopmd.vopPredType==BVOP)
  578. m_iBCount++;
  579. }
  580. else if (pvopcBVOPQuant != NULL) { // Spatial Scalability Enhancement Layer
  581. /* (98/03/30) modified by SONY */
  582. if(m_vopmd.vopPredType == BVOP && m_vopmd.iRefSelectCode == 0) {
  583. if(bPrevRefVopWasCoded)
  584. m_tPastRef = m_tFutureRef;
  585. m_tFutureRef = m_t;
  586. m_iBCount = 0;
  587. } if(m_vopmd.vopPredType == PVOP && m_vopmd.iRefSelectCode == 3) {
  588. m_tPastRef = m_t;
  589. m_tFutureRef = m_t;
  590. m_iBCount = 0;
  591. }
  592. /* (98/03/30) modified by SONY */
  594. // count B-VOPs
  595. if(m_vopmd.vopPredType==BVOP)
  596. m_iBCount++;
  597. }
  598. // set time stamps for Base/Temporal-Enhc/Spatial-Enhc Layer End      Sharp(1998-02-10)
  600. // select reference frames for Base/Temporal-Enhc/Spatial-Enhc Layer Modified by Sharp(1998-02-10)
  601. if(bPrevRefVopWasCoded)
  602. {
  603. if(m_volmd.volType == BASE_LAYER) {
  604. updateAllRefVOPs ();            // update all reconstructed VOP's
  605. }
  606. else {
  607. if (pvopcBVOPQuant == NULL) // Temporal Scalability Enhancement Layer
  608. updateRefVOPsEnhc ();
  609. else { // Spatial Scalability Enhancement Layer
  610. updateAllRefVOPs (pvopcBVOPQuant);
  611. }
  612. }
  613. }
  614. // select reference frames for Base/Temporal-Enhc/Spatial-Enhc Layer End     Sharp(1998-02-10)
  616. switch(m_vopmd.vopPredType)
  617. {
  618. case IVOP:
  619. #ifdef DEBUG_OUTPUT
  620. cout << "tIVOP";
  621. #endif
  622. /*Added by SONY (98/03/30)*/
  623. if(m_bLinkisBroken == TRUE && m_bUseGOV == TRUE)        m_bLinkisBroken = FALSE;
  624. /*Added by SONY (98/03/30) END*/
  625. break;
  626. case PVOP:
  627. #ifdef DEBUG_OUTPUT
  628. cout << "tPVOP (reference: t=" << m_tPastRef <<")";
  629. #endif
  630. break;
  631. case BVOP:
  632. #ifdef DEBUG_OUTPUT
  633. cout << "tBVOP (past ref: t=" << m_tPastRef
  634. << ", future ref: t=" << m_tFutureRef <<")";
  635. #endif
  636. break;
  637. default:
  638. break;
  639. }
  640. #ifdef DEBUG_OUTPUT
  641. cout << "n";
  642. cout.flush ();
  643. #endif
  644. /* Added by SONY (98/03/30)*/
  645. if(m_bLinkisBroken == TRUE && m_bUseGOV == TRUE)
  646. fprintf(stderr,"WARNING: broken_link = 1  --- Output image must be broken.n");
  647. /*Added by SONY (98/03/30) End*/
  649. if(bCoded==FALSE)
  650. {
  651. if (m_vopmd.vopPredType != BVOP
  652. && m_volmd.fAUsage != RECTANGLE && bPrevRefVopWasCoded)
  653. {
  654. // give the current object a dummy size
  655. m_iNumMBX = m_iNumMBY = m_iNumMB = 1;
  656. saveShapeMode(); // save the previous reference vop shape mode
  657. }
  658. return FALSE;
  659. }
  661. if (m_volmd.fAUsage != RECTANGLE)
  662. resetBYPlane ();
  664. if (m_volmd.fAUsage != RECTANGLE) {
  665. setRefStartingPointers ();
  666. computeVOPMembers ();
  667. }
  669. decodeVOP ();
  671. //wchen: added by sony-probably not the best way
  672. if(m_volmd.volType == ENHN_LAYER &&
  673. (m_vopmd.vopPredType == BVOP && m_vopmd.iRefSelectCode == 0))
  674. swapVOPU8Pointers(m_pvopcCurrQ,m_pvopcRefQ1);
  676. // store the direct mode data
  677. if (m_vopmd.vopPredType != BVOP ||
  678. (m_volmd.volType == ENHN_LAYER && m_vopmd.vopPredType == BVOP && m_vopmd.iRefSelectCode == 0)) {
  679. if(m_volmd.fAUsage != RECTANGLE && bPrevRefVopWasCoded)
  680. saveShapeMode();
  681. CMBMode* pmbmdTmp = m_rgmbmd;
  682. m_rgmbmd = m_rgmbmdRef;
  683. m_rgmbmdRef = pmbmdTmp;
  684. CMotionVector* pmvTmp = m_rgmv;
  685. m_rgmv = m_rgmvRef;
  686. m_rgmvRef = pmvTmp;
  687. m_rgmvBackward = m_rgmv + BVOP_MV_PER_REF_PER_MB * m_iSessNumMB;
  688. }
  690. if (m_volmd.fAUsage != RECTANGLE) {
  691. if (m_vopmd.vopPredType != BVOP ||
  692. (m_volmd.volType == ENHN_LAYER && m_vopmd.vopPredType == BVOP && m_vopmd.iRefSelectCode == 0)) {
  693. m_iNumMBRef = m_iNumMB;
  694. m_iNumMBXRef = m_iNumMBX;
  695. m_iNumMBYRef = m_iNumMBY;
  696. m_iOffsetForPadY = m_rctRefFrameY.offset (m_rctCurrVOPY.left, m_rctCurrVOPY.top);
  697. m_iOffsetForPadUV = m_rctRefFrameUV.offset (m_rctCurrVOPUV.left, m_rctCurrVOPUV.top);
  698. m_rctPrevNoExpandY = m_rctCurrVOPY;
  699. m_rctPrevNoExpandUV = m_rctCurrVOPUV;
  701. m_rctRefVOPY1 = m_rctCurrVOPY;
  702. m_rctRefVOPY1.expand (EXPANDY_REFVOP);
  703. m_rctRefVOPUV1 = m_rctCurrVOPUV;
  704. m_rctRefVOPUV1.expand (EXPANDUV_REFVOP);
  705. m_pvopcRefQ1->setBoundRct (m_rctRefVOPY1);
  706. }
  707. else { // For Temporal Scalability Added by Sharp(1998-02-10)
  708. m_iBVOPOffsetForPadY = m_rctRefFrameY.offset (m_rctCurrVOPY.left, m_rctCurrVOPY.top);
  709. m_iBVOPOffsetForPadUV = m_rctRefFrameUV.offset (m_rctCurrVOPUV.left, m_rctCurrVOPUV.top);
  710. m_rctBVOPPrevNoExpandY = m_rctCurrVOPY;
  711. m_rctBVOPPrevNoExpandUV = m_rctCurrVOPUV;
  713. m_rctBVOPRefVOPY1 = m_rctCurrVOPY;
  714. m_rctBVOPRefVOPY1.expand (EXPANDY_REFVOP);
  715. m_rctBVOPRefVOPUV1 = m_rctCurrVOPUV;
  716. m_rctBVOPRefVOPUV1.expand (EXPANDUV_REFVOP);
  717. } // For Temporal Scalability End  Sharp(1998-02-10)
  719. //give a comment that this is ac/dc pred stuff
  720. Int nBlk = (m_volmd.fAUsage == EIGHT_BIT) ? 10 : 6;
  721. delete [] m_rgblkmCurrMB;
  722. for (Int iMB = 0; iMB < m_iNumMBX; iMB++) {
  723. for (Int iBlk = 0; iBlk < nBlk; iBlk++) {
  724. delete [] (m_rgpmbmAbove [iMB]->rgblkm) [iBlk];
  725. delete [] (m_rgpmbmCurr  [iMB]->rgblkm) [iBlk];
  726. }
  727. delete [] m_rgpmbmAbove [iMB]->rgblkm;
  728. delete m_rgpmbmAbove [iMB];
  729. delete [] m_rgpmbmCurr [iMB]->rgblkm;
  730. delete m_rgpmbmCurr [iMB];
  731. }
  732. delete [] m_rgpmbmAbove;
  733. delete [] m_rgpmbmCurr;
  734. }
  735. else { // For Temporal Scalability Added by Sharp(1998-02-10)
  736. m_iBVOPOffsetForPadY = m_iOffsetForPadY;
  737. m_iBVOPOffsetForPadUV = m_iOffsetForPadUV;
  738. m_rctBVOPPrevNoExpandY = m_rctPrevNoExpandY;
  739. m_rctBVOPPrevNoExpandUV = m_rctPrevNoExpandUV;
  741. m_rctBVOPRefVOPY1 = m_rctRefVOPY1;
  742. m_rctBVOPRefVOPUV1 = m_rctRefVOPUV1;
  743. } // For Temporal Scalability End  Sharp(1998-02-10)
  745.     if (m_vopmd.vopPredType != BVOP ||
  746. (m_volmd.volType == ENHN_LAYER && m_vopmd.vopPredType == BVOP && m_vopmd.iRefSelectCode == 0)) {
  747. repeatPadYOrA ((PixelC*) m_pvopcRefQ1->pixelsY () + m_iOffsetForPadY, m_pvopcRefQ1);
  748. repeatPadUV (m_pvopcRefQ1);
  750. //reset by in RefQ1 so that no left-over from last frame
  751. if (m_volmd.fAUsage != RECTANGLE)       {
  752. if (m_volmd.fAUsage == EIGHT_BIT)
  753. repeatPadYOrA ((PixelC*) m_pvopcRefQ1->pixelsA () + m_iOffsetForPadY, m_pvopcRefQ1);
  754. }
  755. }
  757. // update buffers for temporal scalability Added by Sharp(1998-02-10)
  758. if(m_volmd.volType != BASE_LAYER)  updateBuffVOPsEnhc ();
  760. return TRUE;
  761. }
  763. Int CVideoObjectDecoder::findStartCode(int dontloop)
  764. {
  765. // ensure byte alignment
  766. m_pbitstrmIn->flush ();
  768. Int bUserData;
  769. do {
  770. bUserData = 0;
  771. while(m_pbitstrmIn->peekBits(NUMBITS_START_CODE_PREFIX)!=START_CODE_PREFIX)
  772. {
  773. m_pbitstrmIn->getBits(8);
  774. if(m_pbitstrmIn->eof()==EOF || dontloop != 0)
  775. return EOF;
  777. }
  778. m_pbitstrmIn->getBits(NUMBITS_START_CODE_PREFIX);
  779. if(m_pbitstrmIn->peekBits(NUMBITS_START_CODE_SUFFIX)==USER_DATA_START_CODE)
  780. bUserData = 1;
  781. } while(bUserData);
  783. return 0;
  784. }
  786. Void CVideoObjectDecoder::decodeVOHead ()
  787. {
  788. findStartCode();
  789.   // Added for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)(for Skip Session_Start_Code)
  790.   if( m_pbitstrmIn->peekBits(NUMBITS_START_CODE_SUFFIX)==SESSION_START_CODE){
  791.   m_pbitstrmIn -> getBits (NUMBITS_START_CODE_SUFFIX);
  792.   if (findStartCode () == EOF)
  793.   assert(FALSE);
  794.   }
  795.   // End Toshiba(1998-1-16:DP+RVLC)
  796. UInt uiVoStartCode = m_pbitstrmIn -> getBits (NUMBITS_VO_START_CODE);
  797. assert(uiVoStartCode == VO_START_CODE);
  798. decodeVOBody();
  799. }
  801. Void CVideoObjectDecoder::decodeVOBody ()
  802. {
  804. m_uiVOId = m_pbitstrmIn -> getBits (NUMBITS_VO_ID);
  805. }
  807. Void CVideoObjectDecoder::decodeVOLHead ()
  808. {
  809. findStartCode();
  810. UInt uiVolStartCode = m_pbitstrmIn -> getBits (NUMBITS_VOL_START_CODE);
  811. assert(uiVolStartCode == VOL_START_CODE);
  812. decodeVOLBody();
  813. }
  815. Void CVideoObjectDecoder::decodeVOLBody()
  816. {
  817.   int ver_id;
  819. /* UInt uiVOLId = wmay */m_pbitstrmIn -> getBits (NUMBITS_VOL_ID);
  820. // Begin: modified by Hughes   4/9/98   per clause 2.1.7. in N2171 document
  821. /* Bool bRandom = wmay */m_pbitstrmIn->getBits (1); //VOL_Random_Access
  822. // End: modified by Hughes   4/9/98
  823. /* UInt uiOLType = wmay*/m_pbitstrmIn -> getBits(8); // VOL_type_indication
  824. UInt uiOLI = m_pbitstrmIn -> getBits (1); //VOL_Is_Object_Layer_Identifier, useless flag for now
  825. if(uiOLI)
  826. {
  827.   ver_id = m_pbitstrmIn -> getBits (4); // video_oject_layer_verid
  828. m_pbitstrmIn -> getBits (3); // video_oject_layer_priority
  829. } else {
  830.   ver_id = 1;
  831. }
  833. //assert(uiOLI == 0);
  835. UInt uiAspect = m_pbitstrmIn -> getBits (4);
  836. if(uiAspect==15) // extended PAR
  837. {
  838.   /* UInt iParWidth = wmay */ m_pbitstrmIn -> getBits (8);
  839.   /* UInt iParHeight = wmay */ m_pbitstrmIn -> getBits (8);
  840. }
  842. UInt uiMark;
  843. UInt uiCTP = m_pbitstrmIn -> getBits (1); //VOL_Control_Parameter, useless flag for now
  844. if(uiCTP)
  845. {
  846.   /* UInt uiChromaFormat = wmay */ m_pbitstrmIn -> getBits (2);
  847.   /* UInt uiLowDelay = wmay */m_pbitstrmIn -> getBits (1);
  848. UInt uiVBVParams = m_pbitstrmIn -> getBits (1);
  850. if(uiVBVParams)
  851. {
  852.   /* UInt uiFirstHalfBitRate = wmay */m_pbitstrmIn -> getBits (15);
  853. uiMark = m_pbitstrmIn -> getBits (1);
  854. assert(uiMark==1);
  855. /* UInt uiLatterHalfBitRate = wmay */ m_pbitstrmIn -> getBits (15);
  856. uiMark = m_pbitstrmIn -> getBits (1);
  857. assert(uiMark==1);
  858. /* UInt uiFirstHalfVbvBufferSize = wmay */m_pbitstrmIn -> getBits (15);
  859. uiMark = m_pbitstrmIn -> getBits (1);
  860. assert(uiMark==1);
  861. /* UInt uiLatterHalfVbvBufferSize = wmay */m_pbitstrmIn -> getBits (3);
  862. /* UInt uiFirstHalfVbvBufferOccupany = wmay */m_pbitstrmIn -> getBits (11);
  863. uiMark = m_pbitstrmIn -> getBits (1);
  864. assert(uiMark==1);
  865. /* UInt uiLatterHalfVbvBufferOccupany = wmay */m_pbitstrmIn -> getBits (15);
  866. uiMark = m_pbitstrmIn -> getBits (1);
  867. assert(uiMark==1);
  868. }
  869. }
  871. //assert(uiCTP == 0);
  873. UInt uiAUsage = m_pbitstrmIn -> getBits (NUMBITS_VOL_SHAPE);
  874. uiMark = m_pbitstrmIn -> getBits (1);
  875. assert(uiMark==1);
  876. m_volmd.iClockRate = m_pbitstrmIn -> getBits (NUMBITS_TIME_RESOLUTION);
  877. #ifdef DEBUG_OUTPUT
  878. cout << m_volmd.iClockRate << "n";
  879. #endif
  880. uiMark = m_pbitstrmIn -> getBits (1);
  881. assert(uiMark==1);
  882. Int iClockRate = m_volmd.iClockRate;
  883. assert (iClockRate >= 1 && iClockRate < 65536);
  884. for (m_iNumBitsTimeIncr = 1; m_iNumBitsTimeIncr < NUMBITS_TIME_RESOLUTION; m_iNumBitsTimeIncr++) {
  885. if (iClockRate == 1)
  886. break;
  887. iClockRate = (iClockRate >> 1);
  888. }
  890. Bool bFixFrameRate = m_pbitstrmIn -> getBits (1);
  891. //assert (bFixFrameRate == FALSE);
  892. if(bFixFrameRate)
  893. {
  894.   UInt uiFixedVOPTimeIncrement = m_pbitstrmIn -> getBits (m_iNumBitsTimeIncr);
  895.   m_volmd.iClockRate = m_volmd.iClockRate / uiFixedVOPTimeIncrement;
  896. // not used
  897. //
  898. //
  899. }
  901. if(uiAUsage==2)  // shape-only mode
  902. {
  903.   /* UInt uiResyncMarkerDisable = wmay */m_pbitstrmIn -> getBits (1);
  905. // default to some values - probably not all needed
  906. m_volmd.bShapeOnly=TRUE;
  907. m_volmd.fAUsage=ONE_BIT;
  908. m_volmd.bAdvPredDisable = 0;
  909. m_volmd.fQuantizer = Q_H263;
  910. m_volmd.volType = BASE_LAYER;
  911. m_volmd.bDeblockFilterDisable = TRUE;
  912. m_uiSprite = 0;
  913. m_volmd.bNot8Bit = 0;
  914. m_volmd.bComplexityEstimationDisable = 1;
  915. m_volmd.bDataPartitioning = 0;
  916. m_volmd.bReversibleVlc = FALSE;
  917. m_volmd.bDeblockFilterDisable = TRUE;
  918. return;
  919. }
  921. m_volmd.bShapeOnly=FALSE;
  922. if(uiAUsage==3)
  923. uiAUsage=2;
  924. m_volmd.fAUsage = (AlphaUsage) uiAUsage;
  925. if (m_volmd.fAUsage == RECTANGLE) {
  926. UInt uiMarker = m_pbitstrmIn -> getBits (1);
  927. //wmay for divx assert(uiMarker==1);
  928. m_ivolWidth = m_pbitstrmIn -> getBits (NUMBITS_VOP_WIDTH);
  929. uiMarker  = m_pbitstrmIn -> getBits (1);
  930. // wmay for divx assert(uiMarker==1);
  931. m_ivolHeight = m_pbitstrmIn -> getBits (NUMBITS_VOP_HEIGHT);
  932. uiMarker  = m_pbitstrmIn -> getBits (1);
  933. // wmay for dixv assert(uiMarker==1);
  934. }
  936. m_vopmd.bInterlace = m_pbitstrmIn -> getBits (1); // interlace (was vop flag)
  937. m_volmd.bAdvPredDisable = m_pbitstrmIn -> getBits (1);  //VOL_obmc_Disable
  939. // decode sprite info
  940. // wmay m_uiSprite = m_pbitstrmIn -> getBits (NUMBITS_SPRITE_USAGE);
  941. m_uiSprite = m_pbitstrmIn->getBits(ver_id == 1 ? 1 : 2);
  942. if (m_uiSprite == 1) { // sprite information
  943. Int isprite_hdim = m_pbitstrmIn -> getBits (NUMBITS_SPRITE_HDIM);
  944. Int iMarker = m_pbitstrmIn -> getBits (MARKER_BIT);
  945. assert (iMarker == 1);
  946. Int isprite_vdim = m_pbitstrmIn -> getBits (NUMBITS_SPRITE_VDIM);
  947. iMarker = m_pbitstrmIn -> getBits (MARKER_BIT);
  948. assert (iMarker == 1);
  949. Int isprite_left_edge = (m_pbitstrmIn -> getBits (1) == 0) ?
  950.     m_pbitstrmIn->getBits (NUMBITS_SPRITE_LEFT_EDGE - 1) : ((Int)m_pbitstrmIn->getBits (NUMBITS_SPRITE_LEFT_EDGE - 1) - (1 << 12));
  951. assert(isprite_left_edge%2 == 0);
  952. iMarker = m_pbitstrmIn -> getBits (MARKER_BIT);
  953. assert (iMarker == 1);
  954. Int isprite_top_edge = (m_pbitstrmIn -> getBits (1) == 0) ?
  955.     m_pbitstrmIn->getBits (NUMBITS_SPRITE_TOP_EDGE - 1) : ((Int)m_pbitstrmIn->getBits (NUMBITS_SPRITE_LEFT_EDGE - 1) - (1 << 12));
  956. assert(isprite_top_edge%2 == 0);
  957. iMarker = m_pbitstrmIn -> getBits (MARKER_BIT);
  958. assert (iMarker == 1);
  959. m_rctSpt.left = isprite_left_edge;
  960. m_rctSpt.right = isprite_left_edge + isprite_hdim;
  961. m_rctSpt.top = isprite_top_edge;
  962. m_rctSpt.bottom = isprite_top_edge + isprite_vdim;
  963. m_rctSpt.width = isprite_hdim;
  964.         m_rctSptPieceY = m_rctSpt; //initialization; will be overwritten by first vop header
  965. m_iNumOfPnts = m_pbitstrmIn -> getBits (NUMBITS_NUM_SPRITE_POINTS);
  966. m_rgstSrcQ = new CSiteD [m_iNumOfPnts];
  967. m_rgstDstQ = new CSiteD [m_iNumOfPnts];
  968. m_uiWarpingAccuracy = m_pbitstrmIn -> getBits (NUMBITS_WARPING_ACCURACY);
  969. /* Bool bLightChange = wmay */m_pbitstrmIn -> getBits (1);
  971. // Begin: modified by Hughes   4/9/98
  972. Bool bsptMode = m_pbitstrmIn -> getBits (1);  // Low_latency_sprite_enable
  973. if (  bsptMode)
  974. m_sptMode = LOW_LATENCY ;
  975. else
  976. m_sptMode = BASIC_SPRITE ;
  977. // End: modified by Hughes   4/9/98
  978. }
  980. m_volmd.bNot8Bit = (Bool) m_pbitstrmIn -> getBits(1);
  981. if (m_volmd.bNot8Bit) {
  982. m_volmd.uiQuantPrecision = (UInt) m_pbitstrmIn -> getBits (4);
  983. m_volmd.nBits = (UInt) m_pbitstrmIn -> getBits (4);
  984. assert(m_volmd.nBits>3);
  985. } else {
  986. m_volmd.uiQuantPrecision = 5;
  987. m_volmd.nBits = 8;
  988. }
  990. if (m_volmd.fAUsage == EIGHT_BIT)
  991. {
  992. m_volmd.bNoGrayQuantUpdate = m_pbitstrmIn -> getBits (1);
  993. /* UInt uiCompMethod = wmay */m_pbitstrmIn -> getBits (1);
  994. /* UInt uiLinearComp = wmay */m_pbitstrmIn -> getBits (1);
  995. }
  997. m_volmd.fQuantizer = (Quantizer) m_pbitstrmIn -> getBits (1); 
  998. if (m_volmd.fQuantizer == Q_MPEG) {
  999. m_volmd.bLoadIntraMatrix = m_pbitstrmIn -> getBits (1);
  1000. if (m_volmd.bLoadIntraMatrix) {
  1001. UInt i = 0;
  1002. Int iElem;
  1003. do {
  1004. iElem = m_pbitstrmIn -> getBits (NUMBITS_QMATRIX);
  1005. m_volmd.rgiIntraQuantizerMatrix [grgiStandardZigzag[i]] = iElem;
  1006. } while (iElem != 0 && ++i < BLOCK_SQUARE_SIZE);
  1007. for (UInt j = i; j < BLOCK_SQUARE_SIZE; j++) {
  1008. m_volmd.rgiIntraQuantizerMatrix [grgiStandardZigzag[j]] = m_volmd.rgiIntraQuantizerMatrix [grgiStandardZigzag[i - 1]];
  1009. }
  1010. }
  1011. else {
  1012. memcpy (m_volmd.rgiIntraQuantizerMatrix, rgiDefaultIntraQMatrix, BLOCK_SQUARE_SIZE * sizeof (Int));
  1013. }
  1014. m_volmd.bLoadInterMatrix = m_pbitstrmIn -> getBits (1);
  1015. if (m_volmd.bLoadInterMatrix) {
  1016. UInt i = 0;
  1017. Int iElem;
  1018. do {
  1019. iElem = m_pbitstrmIn -> getBits (NUMBITS_QMATRIX);
  1020. m_volmd.rgiInterQuantizerMatrix [grgiStandardZigzag[i]] = iElem;
  1021. } while (iElem != 0 && ++i < BLOCK_SQUARE_SIZE);
  1022. for (UInt j = i; j < BLOCK_SQUARE_SIZE; j++) {
  1023. m_volmd.rgiInterQuantizerMatrix [grgiStandardZigzag[j]] = m_volmd.rgiInterQuantizerMatrix [grgiStandardZigzag[i - 1]];
  1024. }
  1025. }
  1026. else {
  1027. memcpy (m_volmd.rgiInterQuantizerMatrix, rgiDefaultInterQMatrix, BLOCK_SQUARE_SIZE * sizeof (Int));
  1028. }
  1029. if (m_volmd.fAUsage == EIGHT_BIT) {
  1030. m_volmd.bLoadIntraMatrixAlpha = m_pbitstrmIn -> getBits (1);
  1031. if (m_volmd.bLoadIntraMatrixAlpha) {
  1032. for (UInt i = 0; i < BLOCK_SQUARE_SIZE; i++) {
  1033. Int iElem = m_pbitstrmIn -> getBits (NUMBITS_QMATRIX);
  1034. if (iElem != 0)
  1035. m_volmd.rgiIntraQuantizerMatrixAlpha [grgiStandardZigzag[i]] = iElem;
  1036. else
  1037. m_volmd.rgiIntraQuantizerMatrixAlpha [i] = m_volmd.rgiIntraQuantizerMatrixAlpha [grgiStandardZigzag[i - 1]];
  1038. }
  1039. }
  1040. else {
  1041. #ifdef _FOR_GSSP_
  1042. memcpy (m_volmd.rgiIntraQuantizerMatrixAlpha, rgiDefaultIntraQMatrix, BLOCK_SQUARE_SIZE * sizeof (Int));
  1043. #else
  1044. for (UInt i = 0; i < BLOCK_SQUARE_SIZE; i++)
  1045. m_volmd.rgiIntraQuantizerMatrixAlpha [i] = 16;
  1046. #endif
  1047. }
  1048. m_volmd.bLoadInterMatrixAlpha = m_pbitstrmIn -> getBits (1);
  1049. if (m_volmd.bLoadInterMatrixAlpha) {
  1050. for (UInt i = 0; i < BLOCK_SQUARE_SIZE; i++) {
  1051. Int iElem = m_pbitstrmIn -> getBits (NUMBITS_QMATRIX);
  1052. if (iElem != 0)
  1053. m_volmd.rgiInterQuantizerMatrixAlpha [grgiStandardZigzag[i]] = iElem;
  1054. else
  1055. m_volmd.rgiInterQuantizerMatrixAlpha [i] = m_volmd.rgiInterQuantizerMatrixAlpha [grgiStandardZigzag[i - 1]];
  1056. }
  1057. }
  1058. else {
  1059. #ifdef _FOR_GSSP_
  1060. memcpy (m_volmd.rgiInterQuantizerMatrixAlpha, rgiDefaultInterQMatrix, BLOCK_SQUARE_SIZE * sizeof (Int));
  1061. #else
  1062. for (UInt i = 0; i < BLOCK_SQUARE_SIZE; i++)
  1063. m_volmd.rgiInterQuantizerMatrixAlpha [i] = 16;
  1064. #endif
  1065. }
  1066. }
  1067. }
  1068. if (ver_id != 1) // wmay
  1069.   m_pbitstrmIn->getBits(1); // wmay vol quarter pixel
  1071. // Bool bComplxityEsti = m_pbitstrmIn->getBits (1); //Complexity estimation; don't know how to use it
  1073. // START: Complexity Estimation syntax support - Marc Mongenet (EPFL) - 15 Jun 1998
  1075. m_volmd.bComplexityEstimationDisable = m_pbitstrmIn -> getBits (1);
  1076. if (! m_volmd.bComplexityEstimationDisable) {
  1078. m_volmd.iEstimationMethod = m_pbitstrmIn -> getBits (2);
  1079. if (m_volmd.iEstimationMethod != 0) {
  1080. fprintf (stderr, "ERROR: Unknown complexity estimation method number %d.n", m_volmd.iEstimationMethod);
  1081. exit (1);
  1082. }
  1084. m_volmd.bShapeComplexityEstimationDisable = m_pbitstrmIn -> getBits (1);
  1085. if (! m_volmd.bShapeComplexityEstimationDisable) {
  1086. m_volmd.bOpaque = m_pbitstrmIn -> getBits (1);
  1087. m_volmd.bTransparent = m_pbitstrmIn -> getBits (1);
  1088. m_volmd.bIntraCAE = m_pbitstrmIn -> getBits (1);
  1089. m_volmd.bInterCAE = m_pbitstrmIn -> getBits (1);
  1090. m_volmd.bNoUpdate = m_pbitstrmIn -> getBits (1);
  1091. m_volmd.bUpsampling = m_pbitstrmIn -> getBits (1);
  1092. if (!(m_volmd.bOpaque ||
  1093.   m_volmd.bTransparent ||
  1094.   m_volmd.bIntraCAE ||
  1095.   m_volmd.bInterCAE ||
  1096.   m_volmd.bNoUpdate ||
  1097.   m_volmd.bUpsampling)) {
  1098. fatal_error("Shape complexity estimation is enabled,nbut no correponding flag is enabled.");
  1099. }
  1100. }
  1101. else
  1102. m_volmd.bOpaque =
  1103. m_volmd.bTransparent =
  1104. m_volmd.bIntraCAE =
  1105. m_volmd.bInterCAE =
  1106. m_volmd.bNoUpdate =
  1107. m_volmd.bUpsampling = false;
  1109. m_volmd.bTextureComplexityEstimationSet1Disable = m_pbitstrmIn -> getBits (1);
  1110. if (! m_volmd.bTextureComplexityEstimationSet1Disable) {
  1111. m_volmd.bIntraBlocks = m_pbitstrmIn -> getBits (1);
  1112. m_volmd.bInterBlocks = m_pbitstrmIn -> getBits (1);
  1113. m_volmd.bInter4vBlocks = m_pbitstrmIn -> getBits (1);
  1114. m_volmd.bNotCodedBlocks = m_pbitstrmIn -> getBits (1);
  1115. if (!(m_volmd.bIntraBlocks ||
  1116.   m_volmd.bInterBlocks ||
  1117.   m_volmd.bInter4vBlocks ||
  1118.   m_volmd.bNotCodedBlocks)) {
  1119. fatal_error("Texture complexity estimation set 1 is enabled,nbut no correponding flag is enabled.");
  1120. }
  1121. }
  1122. else
  1123. m_volmd.bIntraBlocks =
  1124. m_volmd.bInterBlocks =
  1125. m_volmd.bInter4vBlocks =
  1126. m_volmd.bNotCodedBlocks = false;
  1128. uiMark = m_pbitstrmIn -> getBits (1);
  1129. assert (uiMark == 1);
  1131. m_volmd.bTextureComplexityEstimationSet2Disable = m_pbitstrmIn -> getBits (1);
  1132. if (! m_volmd.bTextureComplexityEstimationSet2Disable) {
  1133. m_volmd.bDCTCoefs = m_pbitstrmIn -> getBits (1);
  1134. m_volmd.bDCTLines = m_pbitstrmIn -> getBits (1);
  1135. m_volmd.bVLCSymbols = m_pbitstrmIn -> getBits (1);
  1136. m_volmd.bVLCBits = m_pbitstrmIn -> getBits (1);
  1137. if (!(m_volmd.bDCTCoefs ||
  1138.   m_volmd.bDCTLines ||
  1139.   m_volmd.bVLCSymbols ||
  1140.   m_volmd.bVLCBits)) {
  1141. fatal_error("Texture complexity estimation set 2 is enabled,nbut no correponding flag is enabled.");
  1142. }
  1143. }
  1144. else
  1145. m_volmd.bDCTCoefs =
  1146. m_volmd.bDCTLines =
  1147. m_volmd.bVLCSymbols =
  1148. m_volmd.bVLCBits = false;
  1150. m_volmd.bMotionCompensationComplexityDisable = m_pbitstrmIn -> getBits (1);
  1151. if (! m_volmd.bMotionCompensationComplexityDisable) {
  1152. m_volmd.bAPM = m_pbitstrmIn -> getBits (1);
  1153. m_volmd.bNPM = m_pbitstrmIn -> getBits (1);
  1154. m_volmd.bInterpolateMCQ = m_pbitstrmIn -> getBits (1);
  1155. m_volmd.bForwBackMCQ = m_pbitstrmIn -> getBits (1);
  1156. m_volmd.bHalfpel2 = m_pbitstrmIn -> getBits (1);
  1157. m_volmd.bHalfpel4 = m_pbitstrmIn -> getBits (1);
  1158. if (!(m_volmd.bAPM ||
  1159.   m_volmd.bNPM ||
  1160.   m_volmd.bInterpolateMCQ ||
  1161.   m_volmd.bForwBackMCQ ||
  1162.   m_volmd.bHalfpel2 ||
  1163.   m_volmd.bHalfpel4)) {
  1164. fatal_error("Motion complexity estimation is enabled,nbut no correponding flag is enabled.");
  1165. }
  1166. }
  1167. else
  1168. m_volmd.bAPM =
  1169. m_volmd.bNPM =
  1170. m_volmd.bInterpolateMCQ =
  1171. m_volmd.bForwBackMCQ =
  1172. m_volmd.bHalfpel2 =
  1173. m_volmd.bHalfpel4 = false;
  1175. uiMark = m_pbitstrmIn -> getBits (1);
  1176. assert (uiMark == 1);
  1177. }
  1178. // END: Complexity Estimation syntax support
  1180. /* UInt uiResyncMarkerDisable = wmay */m_pbitstrmIn -> getBits (1);
  1182. // Modified by Toshiba(1998-4-7)
  1183. m_volmd.bDataPartitioning = m_pbitstrmIn -> getBits (1);
  1184. if( m_volmd.bDataPartitioning )
  1185. m_volmd.bReversibleVlc = m_pbitstrmIn -> getBits (1);
  1186. else
  1187. m_volmd.bReversibleVlc = FALSE;
  1188. // End Toshiba
  1189. //wchen: wd changes
  1190. m_volmd.volType = (m_pbitstrmIn -> getBits (1) == 0) ? BASE_LAYER : ENHN_LAYER;
  1191. m_volmd.ihor_sampling_factor_n = 1;
  1192. m_volmd.ihor_sampling_factor_m = 1;
  1193. m_volmd.iver_sampling_factor_n = 1;
  1194. m_volmd.iver_sampling_factor_m = 1;
  1195. if (m_volmd.volType == ENHN_LAYER) {
  1196. //#ifdef _Scalable_SONY_
  1197. m_volmd.iHierarchyType = m_pbitstrmIn->getBits (1); // 
  1198. if(m_volmd.iHierarchyType == 0)
  1199. fprintf(stdout,"Hierarchy_Type == 0 (Spatial scalability)n");
  1200. else if(m_volmd.iHierarchyType == 1)
  1201. fprintf(stdout,"Hierarchy_type == 1 (Temporal scalability)n");
  1202. //#endif _Scalable_SONY_
  1203. m_pbitstrmIn->getBits (4); // ref_layer_id
  1204. m_pbitstrmIn->getBits (1); // ref_layer_samping_director
  1205. m_volmd.ihor_sampling_factor_n = m_pbitstrmIn->getBits (5);
  1206. m_volmd.ihor_sampling_factor_m = m_pbitstrmIn->getBits (5);
  1207. m_volmd.iver_sampling_factor_n = m_pbitstrmIn->getBits (5);
  1208. m_volmd.iver_sampling_factor_m = m_pbitstrmIn->getBits (5);
  1209. m_volmd.iEnhnType     = m_pbitstrmIn->getBits (1); //enhancement_type
  1210. }
  1212. m_volmd.bDeblockFilterDisable = TRUE; //no deblocking filter
  1213. }
  1215. Void CVideoObjectDecoder::FakeOutVOVOLHead (int h, int w, int fr, Bool *pbSpatialScalability)
  1216. {
  1217.   m_volmd.iClockRate = fr;
  1218.   Int iClockRate = m_volmd.iClockRate;
  1219.   assert (iClockRate >= 1 && iClockRate < 65536);
  1220.   for (m_iNumBitsTimeIncr = 1; m_iNumBitsTimeIncr < NUMBITS_TIME_RESOLUTION; m_iNumBitsTimeIncr++) {
  1221.     if (iClockRate == 1)
  1222.       break;
  1223.     iClockRate = (iClockRate >> 1);
  1224.   }
  1225.   m_volmd.bShapeOnly = FALSE;
  1226.   m_volmd.fAUsage = RECTANGLE;
  1227.   m_ivolWidth = w;
  1228.   m_ivolHeight = h;
  1229.   m_vopmd.bInterlace = 0;
  1230.   m_volmd.bAdvPredDisable = 1;
  1231.   m_uiSprite = 0;
  1232.   m_volmd.bNot8Bit = 0;
  1233.   m_volmd.uiQuantPrecision = 5;
  1234.   m_volmd.nBits = 8;
  1235.   m_volmd.fQuantizer = Q_H263;
  1236. #if 0
  1237.   m_volmd.bLoadIntraMatrix = 0;
  1238.   memcpy (m_volmd.rgiIntraQuantizerMatrix, rgiDefaultIntraQMatrix, BLOCK_SQUARE_SIZE * sizeof (Int));
  1239.   m_volmd.bLoadInterMatrix = 0;
  1240.   memcpy (m_volmd.rgiInterQuantizerMatrix, rgiDefaultInterQMatrix, BLOCK_SQUARE_SIZE * sizeof (Int));
  1241. #endif
  1242.   m_volmd.bComplexityEstimationDisable = 1; // huh ?
  1243.   m_volmd.bDataPartitioning = 0;
  1244.   m_volmd.bReversibleVlc = FALSE;
  1245.   m_volmd.volType = BASE_LAYER;
  1246.   m_volmd.ihor_sampling_factor_n = 1;
  1247.   m_volmd.ihor_sampling_factor_m = 1;
  1248.   m_volmd.iver_sampling_factor_n = 1;
  1249.   m_volmd.iver_sampling_factor_m = 1;
  1250.   m_volmd.bDeblockFilterDisable = TRUE;
  1251.   postVO_VOLHeadInit(w, h, pbSpatialScalability);
  1252. }
  1255. Int BGComposition; // added by Sharp (98/3/24)
  1257. Bool CVideoObjectDecoder::decodeVOPHead ()
  1258. {
  1259. // Start code
  1260.   UInt uiVopStartCode = m_pbitstrmIn -> getBits (NUMBITS_VOP_START_CODE);
  1261.   while (uiVopStartCode == GOV_START_CODE ||
  1262.  (uiVopStartCode >= 0 && uiVopStartCode <= 0x1f) ||
  1263.  uiVopStartCode == SESSION_START_CODE ||
  1264.  uiVopStartCode == VISUAL_OBJ_START_CODE ||
  1265.  (uiVopStartCode >= 0x20 && uiVopStartCode <= 0x2f)) {
  1266.     if (uiVopStartCode >= 0 && uiVopStartCode <= 0x1f) {
  1267.       decodeVOBody();
  1268.     } else if (uiVopStartCode >= 0x20 && uiVopStartCode <= 0x2f) {
  1269.       decodeVOLBody();
  1270.     } else 
  1271.       switch (uiVopStartCode) {
  1272.       case GOV_START_CODE: {
  1273. /*Added by SONY (98/03/30)*/
  1274. m_bUseGOV = TRUE;
  1275. m_bLinkisBroken = FALSE;
  1276. /*Added by SONY (98/03/30) End */
  1277. Int timecode;
  1278. timecode = m_pbitstrmIn -> getBits (5) * 3600;
  1279. timecode += m_pbitstrmIn -> getBits (6) * 60;
  1280. m_pbitstrmIn -> getBits (1);
  1281. timecode += m_pbitstrmIn -> getBits (6);
  1283. m_tModuloBaseDecd = timecode;
  1284. m_tModuloBaseDisp = timecode;
  1285. #ifdef DEBUG_OUTPUT
  1286. cout << "GOV Header (t=" << timecode << ")nn";
  1287. #endif
  1288. Int closed_gov = m_pbitstrmIn -> getBits (1);
  1289. Int broken_link = m_pbitstrmIn -> getBits (1);
  1290. /*modified by SONY (98/03/30)*/
  1291. if ((closed_gov == 0)&&(broken_link == 1))
  1292.   m_bLinkisBroken = TRUE;
  1293.       }
  1294.         break;
  1295.       default:
  1296. break;
  1297.       }
  1298. /*modified by SONY (98/03/30) End*/
  1300.     Int err = findStartCode();
  1301.     if (err == EOF) return FALSE;
  1302.     uiVopStartCode = m_pbitstrmIn -> getBits (NUMBITS_VOP_START_CODE);
  1303.   }
  1304. //980212
  1305.   if (uiVopStartCode != VOP_START_CODE) {
  1306.     printf("Illegal VOP start code %x found in header", uiVopStartCode);
  1307.   }
  1308. assert(uiVopStartCode == VOP_START_CODE);
  1309. if (m_pbitstrmIn->peekBits(NUMBITS_START_CODE_PREFIX) == START_CODE_PREFIX) {
  1310.   return decodeVOPHead();
  1311. }
  1313. m_vopmd.vopPredType = (VOPpredType) m_pbitstrmIn -> getBits (NUMBITS_VOP_PRED_TYPE);
  1314. // Time reference and VOP_pred_type
  1315. Int iModuloInc = 0;
  1316. while (m_pbitstrmIn -> getBits (1) != 0)
  1317. iModuloInc++;
  1318. Time tCurrSec = iModuloInc + ((m_vopmd.vopPredType != BVOP ||
  1319.   (m_vopmd.vopPredType == BVOP && m_volmd.volType == ENHN_LAYER ))?
  1320. m_tModuloBaseDecd : m_tModuloBaseDisp);
  1321. // Added for error resilient mode by Toshiba(1997-11-14)
  1322. UInt uiMarker = m_pbitstrmIn -> getBits (1);
  1323. assert(uiMarker== 1);
  1324. // End Toshiba(1997-11-14)
  1325. Time tVopIncr = m_pbitstrmIn -> getBits (m_iNumBitsTimeIncr);
  1326. uiMarker = m_pbitstrmIn->getBits (1); // marker bit
  1327. assert(uiMarker ==1);
  1328. m_tOldModuloBaseDecd = m_tModuloBaseDecd;
  1329. m_tOldModuloBaseDisp = m_tModuloBaseDisp;
  1330. if (m_vopmd.vopPredType != BVOP ||
  1331. (m_vopmd.vopPredType == BVOP && m_volmd.volType == ENHN_LAYER ))
  1333. {
  1334. m_tModuloBaseDisp = m_tModuloBaseDecd; //update most recently displayed time base
  1335. m_tModuloBaseDecd = tCurrSec;
  1336. }
  1338.     m_t = tCurrSec * m_volmd.iClockRate*m_iClockRateScale + tVopIncr*m_iClockRateScale;
  1340. if (m_pbitstrmIn->getBits (1) == 0) { //vop_coded == false
  1341. m_vopmd.bInterlace = FALSE; //wchen: temporary solution
  1342. return FALSE;
  1343. }
  1345. if (m_vopmd.vopPredType == PVOP && m_volmd.bShapeOnly==FALSE)
  1346. m_vopmd.iRoundingControl = m_pbitstrmIn->getBits (1); //"VOP_Rounding_Type"
  1347. else
  1348. m_vopmd.iRoundingControl = 0;
  1350. if (m_volmd.fAUsage != RECTANGLE) {
  1351. // Begin: modified by Hughes   4/9/98
  1352.   if (!(m_uiSprite == 1 && m_vopmd.vopPredType == IVOP)) {
  1353. // End: modified by Hughes   4/9/98
  1355. Int width = m_pbitstrmIn -> getBits (NUMBITS_VOP_WIDTH);
  1356. // spt VOP assert (width % MB_SIZE == 0); // for sprite, may not be multiple of MB_SIZE
  1357. Int marker;
  1358. marker = m_pbitstrmIn -> getBits (1); // marker bit
  1359. assert(marker==1);
  1360. Int height = m_pbitstrmIn -> getBits (NUMBITS_VOP_HEIGHT);
  1361. // spt VOP assert (height % MB_SIZE == 0); // for sprite, may not be multiple of MB_SIZE
  1362. marker = m_pbitstrmIn -> getBits (1); // marker bit
  1363. assert(marker==1);
  1364. //wchen: cd changed to 2s complement
  1365. Int left = (m_pbitstrmIn -> getBits (1) == 0) ?
  1366. m_pbitstrmIn->getBits (NUMBITS_VOP_HORIZONTAL_SPA_REF - 1) : 
  1367. ((Int)m_pbitstrmIn->getBits (NUMBITS_VOP_HORIZONTAL_SPA_REF - 1) - (1 << (NUMBITS_VOP_HORIZONTAL_SPA_REF - 1)));
  1368. marker = m_pbitstrmIn -> getBits (1); // marker bit
  1369. assert(marker==1);
  1370. Int top = (m_pbitstrmIn -> getBits (1) == 0) ?
  1371.    m_pbitstrmIn->getBits (NUMBITS_VOP_VERTICAL_SPA_REF - 1) : 
  1372.    ((Int)m_pbitstrmIn->getBits (NUMBITS_VOP_VERTICAL_SPA_REF - 1) - (1 << (NUMBITS_VOP_VERTICAL_SPA_REF - 1)));
  1373. assert(((left | top)&1)==0); // must be even pix unit
  1375. m_rctCurrVOPY = CRct (left, top, left + width, top + height);
  1376. m_rctCurrVOPUV = m_rctCurrVOPY.downSampleBy2 ();
  1377.   }
  1380. if ( m_volmd.volType == ENHN_LAYER && m_volmd.iEnhnType == 1 ){
  1381. BGComposition = m_pbitstrmIn -> getBits (1); // modified by Sharp (98/3/24)
  1382. // assert(BackgroundComposition==1); // modified by Sharp (98/3/24)
  1383. }
  1385. m_volmd.bNoCrChange = m_pbitstrmIn -> getBits (1); //VOP_CR_Change_Disable
  1386. Int iVopConstantAlpha = m_pbitstrmIn -> getBits (1);
  1387. if(iVopConstantAlpha==1)
  1388. m_vopmd.iVopConstantAlphaValue = m_pbitstrmIn -> getBits (8);
  1389. else
  1390. m_vopmd.iVopConstantAlphaValue = 255;
  1391. m_vopmd.bShapeCodingType = (m_vopmd.vopPredType == IVOP) ? 0 : 1; // Added error resilient mode by Toshiba(1998-1-16)
  1392. }
  1394. // START: Complexity Estimation syntax support - Marc Mongenet (EPFL) - 15 Jun 1998
  1396. if (! m_volmd.bComplexityEstimationDisable) {
  1398. if (m_volmd.iEstimationMethod != 0) {
  1399. fprintf (stderr, "ERROR: Unknown estimation method number %d.n", m_volmd.iEstimationMethod);
  1400. exit (1);
  1401. }
  1403. if (m_vopmd.vopPredType == IVOP ||
  1404. m_vopmd.vopPredType == PVOP ||
  1405. m_vopmd.vopPredType == BVOP) {
  1407. if (m_volmd.bOpaque) {
  1408. printf ("dcecs_opaque = %dn", m_vopmd.iOpaque = m_pbitstrmIn -> getBits (8));
  1409. if (m_vopmd.iOpaque == 0) {
  1410. fprintf (stderr, "ERROR: Illegal null value for 'opaque' complexity estimation.n");
  1411. exit (1);
  1412. }
  1413. }
  1414. if (m_volmd.bTransparent) {
  1415. printf ("dcecs_transparent = %dn", m_vopmd.iTransparent = m_pbitstrmIn -> getBits (8));
  1416. if (m_vopmd.iTransparent == 0) {
  1417. fprintf (stderr, "ERROR: Illegal null value for 'transparent' complexity estimation.n");
  1418. exit (1);
  1419. }
  1420. }
  1421. if (m_volmd.bIntraCAE) {
  1422. printf ("dcecs_intra_cae = %dn", m_vopmd.iIntraCAE = m_pbitstrmIn -> getBits (8));
  1423. if (m_vopmd.iIntraCAE == 0) {
  1424. fprintf (stderr, "ERROR: Illegal null value for 'intra_cae' complexity estimation.n");
  1425. exit (1);
  1426. }
  1427. }
  1428. if (m_volmd.bInterCAE) {
  1429. printf ("dcecs_inter_cae = %dn", m_vopmd.iInterCAE = m_pbitstrmIn -> getBits (8));
  1430. if (m_vopmd.iInterCAE == 0) {
  1431. fprintf (stderr, "ERROR: Illegal null value for 'inter_cae' complexity estimation.n");
  1432. exit (1);
  1433. }
  1434. }
  1435. if (m_volmd.bNoUpdate) {
  1436. printf ("dcecs_no_update = %dn", m_vopmd.iNoUpdate = m_pbitstrmIn -> getBits (8));
  1437. if (m_vopmd.iNoUpdate == 0) {
  1438. fprintf (stderr, "ERROR: Illegal null value for 'no_update' complexity estimation.n");
  1439. exit (1);
  1440. }
  1441. }
  1442. if (m_volmd.bUpsampling) {
  1443. printf ("dcecs_upsampling = %dn", m_vopmd.iUpsampling = m_pbitstrmIn -> getBits (8));
  1444. if (m_vopmd.iUpsampling == 0) {
  1445. fprintf (stderr, "ERROR: Illegal null value for 'upsampling' complexity estimation.n");
  1446. exit (1);
  1447. }
  1448. }
  1449. }
  1451. if (m_volmd.bIntraBlocks) {
  1452. printf ("dcecs_intra_blocks = %dn", m_vopmd.iIntraBlocks = m_pbitstrmIn -> getBits (8));
  1453. if (m_vopmd.iIntraBlocks == 0) {
  1454. fprintf (stderr, "ERROR: Illegal null value for 'intra_blocks' complexity estimation.n");
  1455. exit (1);
  1456. }
  1457. }
  1458. if (m_volmd.bNotCodedBlocks) {
  1459. printf ("dcecs_not_coded_blocks = %dn", m_vopmd.iNotCodedBlocks = m_pbitstrmIn -> getBits (8));
  1460. if (m_vopmd.iNotCodedBlocks == 0) {
  1461. fprintf (stderr, "ERROR: Illegal null value for 'not_coded_blocks' complexity estimation.n");
  1462. exit (1);
  1463. }
  1464. }
  1465. if (m_volmd.bDCTCoefs) {
  1466. printf ("dcecs_dct_coefs = %dn", m_vopmd.iDCTCoefs = m_pbitstrmIn -> getBits (8));
  1467. if (m_vopmd.iDCTCoefs == 0) {
  1468. fprintf (stderr, "ERROR: Illegal null value for 'dct_coefs' complexity estimation.n");
  1469. exit (1);
  1470. }
  1471. }
  1472. if (m_volmd.bDCTLines) {
  1473. printf ("dcecs_dct_lines = %dn", m_vopmd.iDCTLines = m_pbitstrmIn -> getBits (8));
  1474. if (m_vopmd.iDCTLines == 0) {
  1475. fprintf (stderr, "ERROR: Illegal null value for 'dct_lines' complexity estimation.n");
  1476. exit (1);
  1477. }
  1478. }
  1479. if (m_volmd.bVLCSymbols) {
  1480. printf ("dcecs_vlc_symbols = %dn", m_vopmd.iVLCSymbols = m_pbitstrmIn -> getBits (8));
  1481. if (m_vopmd.iVLCSymbols == 0) {
  1482. fprintf (stderr, "ERROR: Illegal null value for 'vlc_symbols' complexity estimation.n");
  1483. exit (1);
  1484. }
  1485. }
  1486. if (m_volmd.bVLCBits) {
  1487. printf ("dcecs_vlc_bits = %dn", m_vopmd.iVLCBits = m_pbitstrmIn -> getBits (4));
  1488. if (m_vopmd.iVLCBits == 0) {
  1489. fprintf (stderr, "ERROR: Illegal null value for 'vlc_bits' complexity estimation.n");
  1490. exit (1);
  1491. }
  1492. }
  1494. if (m_vopmd.vopPredType == PVOP ||
  1495. m_vopmd.vopPredType == BVOP ||
  1496. m_vopmd.vopPredType == SPRITE) {
  1498. if (m_volmd.bInterBlocks) {
  1499. printf ("dcecs_inter_blocks = %dn", m_vopmd.iInterBlocks = m_pbitstrmIn -> getBits (8));
  1500. if (m_vopmd.iInterBlocks == 0) {
  1501. fprintf (stderr, "ERROR: Illegal null value for 'inter_blocks' complexity estimation.n");
  1502. exit (1);
  1503. }
  1504. }
  1505. if (m_volmd.bInter4vBlocks) {
  1506. printf ("dcecs_inter4v_blocks = %dn", m_vopmd.iInter4vBlocks = m_pbitstrmIn -> getBits (8));
  1507. if (m_vopmd.iInter4vBlocks == 0) {
  1508. fprintf (stderr, "ERROR: Illegal null value for 'inter4v_blocks' complexity estimation.n");
  1509. exit (1);
  1510. }
  1511. }
  1512. if (m_volmd.bAPM) {
  1513. printf ("dcecs_apm = %dn", m_vopmd.iAPM = m_pbitstrmIn -> getBits (8));
  1514. if (m_vopmd.iAPM == 0) {
  1515. fprintf (stderr, "ERROR: Illegal null value for 'apm' complexity estimation.n");
  1516. exit (1);
  1517. }
  1518. }
  1519. if (m_volmd.bNPM) {
  1520. printf ("dcecs_npm = %dn", m_vopmd.iNPM = m_pbitstrmIn -> getBits (8));
  1521. if (m_vopmd.iNPM == 0) {
  1522. fprintf (stderr, "ERROR: Illegal null value for 'npm' complexity estimation.n");
  1523. exit (1);
  1524. }
  1525. }
  1526. if (m_volmd.bForwBackMCQ) {
  1527. printf ("dcecs_forw_back_mc_q = %dn", m_vopmd.iForwBackMCQ = m_pbitstrmIn -> getBits (8));
  1528. if (m_vopmd.iForwBackMCQ == 0) {
  1529. fprintf (stderr, "ERROR: Illegal null value for 'forw_back_mc_q' complexity estimation.n");
  1530. exit (1);
  1531. }
  1532. }
  1533. if (m_volmd.bHalfpel2) {
  1534. printf ("dcecs_halfpel2 = %dn", m_vopmd.iHalfpel2 = m_pbitstrmIn -> getBits (8));
  1535. if (m_vopmd.iHalfpel2 == 0) {
  1536. fprintf (stderr, "ERROR: Illegal null value for 'halfpel2' complexity estimation.n");
  1537. exit (1);
  1538. }
  1539. }
  1540. if (m_volmd.bHalfpel4) {
  1541. printf ("dcecs_halfpel4 = %dn", m_vopmd.iHalfpel4 = m_pbitstrmIn -> getBits (8));
  1542. if (m_vopmd.iHalfpel4 == 0) {
  1543. fprintf (stderr, "ERROR: Illegal null value for 'halfpel4' complexity estimation.n");
  1544. exit (1);
  1545. }
  1546. }
  1547. }
  1548. if (m_vopmd.vopPredType == BVOP ||
  1549. m_vopmd.vopPredType == SPRITE) {
  1551. if (m_volmd.bInterpolateMCQ) {
  1552. printf ("dcecs_interpolate_mc_q = %dn", m_vopmd.iInterpolateMCQ = m_pbitstrmIn -> getBits (8));
  1553. if (m_vopmd.iInterpolateMCQ == 0) {
  1554. fprintf (stderr, "ERROR: Illegal null value for 'interpolate_mc_q' complexity estimation.n");
  1555. exit (1);
  1556. }
  1557. }
  1558. }
  1559. }
  1560. // END: Complexity Estimation syntax support
  1562. if(m_volmd.bShapeOnly==TRUE)
  1563. {
  1564. m_vopmd.intStep = 10; // probably not needed 
  1565. m_vopmd.intStepI = 10;
  1566. m_vopmd.intStepB = 10;
  1567. m_vopmd.mvInfoForward.uiFCode = m_vopmd.mvInfoBackward.uiFCode = 1; // Modified error resilient mode by Toshiba (1998-1-16)
  1568. m_vopmd.bInterlace = FALSE; //wchen: temporary solution
  1569. return TRUE;
  1570. }
  1571. m_vopmd.iIntraDcSwitchThr = m_pbitstrmIn->getBits (3);
  1573. // INTERLACE
  1574. if (m_vopmd.bInterlace) {
  1575. m_vopmd.bTopFieldFirst = m_pbitstrmIn -> getBits (1);
  1576.         m_vopmd.bAlternateScan = m_pbitstrmIn -> getBits (1);
  1577. assert(m_volmd.volType == BASE_LAYER);
  1578. } else
  1579. // ~INTERLACE
  1580.     {
  1581.         m_vopmd.bAlternateScan = FALSE;
  1582.     }
  1584. if (m_vopmd.vopPredType == IVOP) { 
  1585. m_vopmd.intStepI = m_vopmd.intStep = m_pbitstrmIn -> getBits (m_volmd.uiQuantPrecision); //also assign intStep to be safe
  1586. m_vopmd.mvInfoForward.uiFCode = m_vopmd.mvInfoBackward.uiFCode = 1; // Modified error resilient mode by Toshiba(1998-1-16)
  1587. if(m_volmd.fAUsage == EIGHT_BIT)
  1588. m_vopmd.intStepIAlpha = m_pbitstrmIn -> getBits (NUMBITS_VOP_ALPHA_QUANTIZER);
  1589. }
  1590. else if (m_vopmd.vopPredType == PVOP) {
  1591. m_vopmd.intStep = m_pbitstrmIn -> getBits (m_volmd.uiQuantPrecision);
  1592. if(m_volmd.fAUsage == EIGHT_BIT)
  1593. m_vopmd.intStepPAlpha = m_pbitstrmIn -> getBits (NUMBITS_VOP_ALPHA_QUANTIZER);
  1595. m_vopmd.mvInfoForward.uiFCode = m_pbitstrmIn -> getBits (NUMBITS_VOP_FCODE);
  1596. m_vopmd.mvInfoForward.uiScaleFactor = 1 << (m_vopmd.mvInfoForward.uiFCode - 1);
  1597. m_vopmd.mvInfoForward.uiRange = 16 << m_vopmd.mvInfoForward.uiFCode;
  1598. // Added for error resilient mode by Toshiba(1998-1-16)
  1599. m_vopmd.mvInfoBackward.uiFCode = 1;
  1600. // End Toshiba(1998-1-16)
  1601. }
  1602. else if (m_vopmd.vopPredType == BVOP) {
  1603. m_vopmd.intStepB = m_vopmd.intStep = m_pbitstrmIn -> getBits (m_volmd.uiQuantPrecision); //also assign intStep to be safe
  1605. if(m_volmd.fAUsage == EIGHT_BIT)
  1606. m_vopmd.intStepBAlpha = m_pbitstrmIn -> getBits (NUMBITS_VOP_ALPHA_QUANTIZER);
  1608. m_vopmd.mvInfoForward.uiFCode = m_pbitstrmIn -> getBits (NUMBITS_VOP_FCODE);
  1609. m_vopmd.mvInfoForward.uiScaleFactor = 1 << (m_vopmd.mvInfoForward.uiFCode - 1);
  1610. m_vopmd.mvInfoForward.uiRange = 16 << m_vopmd.mvInfoForward.uiFCode;
  1611. m_vopmd.mvInfoBackward.uiFCode = m_pbitstrmIn -> getBits (NUMBITS_VOP_FCODE);
  1612. m_vopmd.mvInfoBackward.uiScaleFactor = 1 << (m_vopmd.mvInfoBackward.uiFCode - 1);
  1613. m_vopmd.mvInfoBackward.uiRange = 16 << m_vopmd.mvInfoBackward.uiFCode;
  1614. }
  1615. // Added for error resilient mode by Toshiba(1997-11-14)
  1616. m_vopmd.bShapeCodingType = 1;
  1617. if ( m_volmd.volType == BASE_LAYER ) // added by Sharp (98/4/13)
  1618.         if (m_volmd.fAUsage != RECTANGLE && m_vopmd.vopPredType != IVOP
  1619. && m_uiSprite != 1)
  1620. {
  1621. m_vopmd.bShapeCodingType = m_pbitstrmIn -> getBits (1);
  1622.         }
  1623. // End Toshiba(1997-11-14)
  1624. if(m_volmd.volType == ENHN_LAYER) { //sony
  1625. if( m_volmd.iEnhnType == 1 ){
  1626. m_vopmd.iLoadBakShape = m_pbitstrmIn -> getBits (1); // load_backward_shape
  1627. if(m_vopmd.iLoadBakShape){
  1628. CVOPU8YUVBA* pvopcCurr = new CVOPU8YUVBA (*(rgpbfShape [0]->pvopcReconCurr()));
  1629. copyVOPU8YUVBA(rgpbfShape [1]->m_pvopcRefQ1, pvopcCurr);
  1630. // previous backward shape is saved to current forward shape
  1631. rgpbfShape [1]->m_rctCurrVOPY.left   = rgpbfShape [0]->m_rctCurrVOPY.left;
  1632. rgpbfShape [1]->m_rctCurrVOPY.right  = rgpbfShape [0]->m_rctCurrVOPY.right;
  1633. rgpbfShape [1]->m_rctCurrVOPY.top    = rgpbfShape [0]->m_rctCurrVOPY.top;
  1634. rgpbfShape [1]->m_rctCurrVOPY.bottom = rgpbfShape [0]->m_rctCurrVOPY.bottom;
  1636. Int width = m_pbitstrmIn -> getBits (NUMBITS_VOP_WIDTH); assert (width % MB_SIZE == 0); // has to be multiples of MB_SIZE
  1637. UInt uiMark = m_pbitstrmIn -> getBits (1);
  1638. assert (uiMark == 1);
  1639. Int height = m_pbitstrmIn -> getBits (NUMBITS_VOP_HEIGHT); assert (height % MB_SIZE == 0); // has to be multiples of MB_SIZE
  1640. uiMark = m_pbitstrmIn -> getBits (1);
  1641. assert (uiMark == 1);
  1642. width = ((width+15)>>4)<<4; // not needed if the asserts are present
  1643. height = ((height+15)>>4)<<4;
  1644. Int iSign = (m_pbitstrmIn -> getBits (1) == 1)? -1 : 1;
  1645. Int left = iSign * m_pbitstrmIn -> getBits (NUMBITS_VOP_HORIZONTAL_SPA_REF - 1);
  1646. Int marker = m_pbitstrmIn -> getBits (1); // marker bit
  1647. iSign = (m_pbitstrmIn -> getBits (1) == 1)? -1 : 1;
  1648. Int top = iSign * m_pbitstrmIn -> getBits (NUMBITS_VOP_VERTICAL_SPA_REF - 1);
  1650. rgpbfShape[0]->m_rctCurrVOPY = CRct (left, top, left + width, top + height);
  1651. rgpbfShape[0]->m_rctCurrVOPUV = rgpbfShape[0]->m_rctCurrVOPY.downSampleBy2 ();
  1653. // decode backward shape
  1654. rgpbfShape[0]->setRefStartingPointers ();
  1655. rgpbfShape[0]->compute_bfShapeMembers (); // clear m_pvopcRefQ1
  1656. rgpbfShape[0]->resetBYPlane ();// clear BY of RefQ1 (katata)
  1657. rgpbfShape[0]->m_volmd.bShapeOnly = TRUE;
  1658. rgpbfShape[0]->m_volmd.bNoCrChange = m_volmd.bNoCrChange; // set CR change disable(Oct. 9 1997)
  1659. rgpbfShape[0]->m_vopmd.bInterlace = FALSE;
  1660. rgpbfShape[0]->decodeIVOP_WithShape ();
  1662. m_vopmd.iLoadForShape = m_pbitstrmIn -> getBits (1); // load_forward_shape
  1663. if(m_vopmd.iLoadForShape){
  1664. width = m_pbitstrmIn -> getBits (NUMBITS_VOP_WIDTH); assert (width % MB_SIZE == 0); // has to be multiples of MB_SIZE
  1665. uiMark = m_pbitstrmIn -> getBits (1);
  1666. assert (uiMark == 1);
  1667. height = m_pbitstrmIn -> getBits (NUMBITS_VOP_HEIGHT); assert (height % MB_SIZE == 0); // has to be multiples of MB_SIZE
  1668. uiMark = m_pbitstrmIn -> getBits (1);
  1669. assert (uiMark == 1);
  1670. width = ((width+15)>>4)<<4; // not needed if the asserts are present
  1671. height = ((height+15)>>4)<<4;
  1672. iSign = (m_pbitstrmIn -> getBits (1) == 1)? -1 : 1;
  1673. left = iSign * m_pbitstrmIn -> getBits (NUMBITS_VOP_HORIZONTAL_SPA_REF - 1);
  1674. marker = m_pbitstrmIn -> getBits (1); // marker bit
  1675. iSign = (m_pbitstrmIn -> getBits (1) == 1)? -1 : 1;
  1676. top = iSign * m_pbitstrmIn -> getBits (NUMBITS_VOP_VERTICAL_SPA_REF - 1);
  1678. rgpbfShape[1]->m_rctCurrVOPY = CRct (left, top, left + width, top + height);
  1679. rgpbfShape[1]->m_rctCurrVOPUV = rgpbfShape[1]->m_rctCurrVOPY.downSampleBy2 ();
  1681. // decode forward shape
  1682. rgpbfShape[1]->setRefStartingPointers ();
  1683. rgpbfShape[1]->compute_bfShapeMembers (); // clear m_pvopcRefQ1
  1684. rgpbfShape[1]->resetBYPlane ();// clear BY of RefQ1 (katata)
  1685. rgpbfShape[1]->m_volmd.bShapeOnly = TRUE;
  1686. rgpbfShape[1]->m_volmd.bNoCrChange = m_volmd.bNoCrChange; // set CR change disable(Oct. 9 1997)
  1687. rgpbfShape[1]->m_vopmd.bInterlace = FALSE;
  1688. rgpbfShape[1]->decodeIVOP_WithShape ();
  1689. }
  1690. } // end of "if(m_vopmd.iLoadBakShape)"
  1691. else
  1692. m_vopmd.iLoadForShape = 0; // no forward shape when backward shape is not decoded
  1693. }
  1694. else {
  1695. m_vopmd.iLoadForShape = 0;
  1696. m_vopmd.iLoadBakShape = 0;
  1697. }
  1698.         m_vopmd.iRefSelectCode = m_pbitstrmIn ->getBits (2) ;
  1699. }
  1700. return TRUE;
  1701. }
  1703. //added by sony for spatial scalability decoding loop
  1704. Int CVideoObjectDecoder::ReadNextVopPredType ()
  1705. {
  1706. m_pbitstrmIn -> setBookmark ();
  1708. if (findStartCode () == EOF) {
  1709. m_pbitstrmIn -> gotoBookmark ();
  1710. return EOF;
  1711. }
  1713. // Start code
  1714. UInt uiVopStartCode = m_pbitstrmIn -> getBits (NUMBITS_VOP_START_CODE);
  1715. assert(uiVopStartCode == VOP_START_CODE);
  1717. Int vopPredType = (VOPpredType) m_pbitstrmIn -> getBits (NUMBITS_VOP_PRED_TYPE);
  1718. // Time reference and VOP_pred_type
  1720. m_pbitstrmIn -> gotoBookmark ();
  1722. return(vopPredType);
  1723. }
  1725. Void CVideoObjectDecoder::errorInBitstream (Char* rgchErorrMsg)
  1726. {
  1727. fprintf (stderr, "%s at %dn", rgchErorrMsg, 0);
  1728. assert (FALSE);
  1729. exit (1);
  1730. }
  1733. // Added by Sharp(1998-02-10)
  1734. void CVideoObjectDecoder::updateBuffVOPsBase (
  1735. CVideoObjectDecoder* pvodecEnhc
  1736. )
  1737. {
  1738. switch(m_vopmd.vopPredType) {
  1739. case IVOP:
  1740. if (!pvodecEnhc -> m_pBuffP2 -> empty ()) // added by Sharp (98/3/11)
  1741. if ( pvodecEnhc -> m_pBuffP2 -> m_bCodedFutureRef == 1 ) // added by Sharp (99/1/28)
  1742. pvodecEnhc -> m_pBuffP1 -> copyBuf (*(pvodecEnhc -> m_pBuffP2)); // added by Sharp (98/3/11)
  1743. pvodecEnhc -> m_pBuffP2 -> getBuf (this);
  1744. break;
  1745. case PVOP:
  1746. if ( pvodecEnhc -> m_pBuffP2 -> m_bCodedFutureRef == 1 ) // added by Sharp (99/1/28)
  1747. pvodecEnhc -> m_pBuffP1 -> copyBuf (*(pvodecEnhc -> m_pBuffP2));
  1748. pvodecEnhc -> m_pBuffP2 -> getBuf (this);
  1749. break;
  1750. case BVOP:
  1751. if(!(pvodecEnhc -> m_pBuffB2 -> empty ())) {
  1752. if ( pvodecEnhc -> m_pBuffB2 -> m_bCodedFutureRef == 1 ) // added by Sharp (99/1/28)
  1753. pvodecEnhc -> m_pBuffB1 -> copyBuf (*(pvodecEnhc -> m_pBuffB2));
  1754. }
  1755. pvodecEnhc -> m_pBuffB2 -> getBuf (this);
  1756. break;
  1757. default: exit(1);
  1758. }
  1759. }
  1761. void CVideoObjectDecoder::updateRefVOPsEnhc ()
  1762. {
  1763. Int tQ0 = 0, tQ1 = 0;
  1764. switch(m_vopmd.vopPredType) {
  1765. case IVOP: // printf(" Not defined in updateRefVOPsEnhc. n");  exit(1); // deleted by Sharp (99/1/25)
  1766. break; // added by Sharp (99/1/25)
  1767. case PVOP:
  1768. switch(m_vopmd.iRefSelectCode) {
  1769. case 0: m_pBuffE -> putBufToQ0 (this);  tQ0 = m_pBuffE -> m_t;
  1770. break;
  1771. case 1: if(!(m_pBuffB1 -> empty ())) { m_pBuffB1 -> putBufToQ0 (this); tQ0 = m_pBuffB1 -> m_t; }
  1772. else { m_pBuffP1 -> putBufToQ0 (this); tQ0 = m_pBuffP1 -> m_t; }
  1773. break;
  1774. case 2: if(!(m_pBuffB2 -> empty ())) { m_pBuffB2 -> putBufToQ0 (this); tQ0 = m_pBuffB2 -> m_t; }
  1775. else { m_pBuffP2 -> putBufToQ0 (this); tQ0 = m_pBuffP2 -> m_t; }
  1776. break;
  1777. case 3: // printf(" For Spatial Scalability -- Not definedn"); exit(1);
  1778. if(!(m_pBuffB1 -> empty ())) { m_pBuffB1 -> putBufToQ0 (this); tQ0 = m_pBuffB1 -> m_t; }
  1779. else { m_pBuffP1 -> putBufToQ0 (this); tQ0 = m_pBuffP1 -> m_t; }
  1780. break;
  1781. }
  1782. m_tPastRef   = tQ0;
  1783. break;
  1784. case BVOP:
  1785. switch(m_vopmd.iRefSelectCode) {
  1786. case 0: // printf(" For Spatial Scalability -- Not definedn"); exit(1);
  1787. m_pBuffE -> putBufToQ0 (this); tQ0 = m_pBuffE -> m_t;
  1788. if(!(m_pBuffB1 -> empty ())) { m_pBuffB1 -> putBufToQ1 (this); tQ1 = m_pBuffB1 -> m_t; }
  1789. else { m_pBuffP1 -> putBufToQ1 (this); tQ1 = m_pBuffP1 -> m_t; }
  1790. break;
  1791. case 1: m_pBuffE -> putBufToQ0 (this); tQ0 = m_pBuffE -> m_t;
  1792. if(!(m_pBuffB1 -> empty ())) { m_pBuffB1 -> putBufToQ1 (this); tQ1 = m_pBuffB1 -> m_t; }
  1793. else { m_pBuffP1 -> putBufToQ1 (this); tQ1 = m_pBuffP1 -> m_t; }
  1794. break;
  1795. case 2: m_pBuffE -> putBufToQ0 (this); tQ0 = m_pBuffE -> m_t;
  1796. if(!(m_pBuffB2 -> empty ())) { m_pBuffB2 -> putBufToQ1 (this); tQ1 = m_pBuffB2 -> m_t; }
  1797. else { m_pBuffP2 -> putBufToQ1 (this); tQ1 = m_pBuffP2 -> m_t; }
  1798. break;
  1799. case 3: if(!(m_pBuffB1 -> empty ())) { m_pBuffB1 -> putBufToQ0 (this); tQ0 = m_pBuffB1 -> m_t; }
  1800. else { m_pBuffP1 -> putBufToQ0 (this); tQ0 = m_pBuffP1 -> m_t; }
  1801. if(!(m_pBuffB2 -> empty ())) { m_pBuffB2 -> putBufToQ1 (this); tQ1 = m_pBuffB2 -> m_t; }
  1802. else { m_pBuffP2 -> putBufToQ1 (this); tQ1 = m_pBuffP2 -> m_t; }
  1803. m_iBCount = (getTime () - tQ0);
  1804. break;
  1805. }
  1806. m_tPastRef   = tQ0;
  1807. m_tFutureRef = tQ1;
  1808. break;
  1809. default: exit(1);
  1810. }
  1811. }
  1813. void CVideoObjectDecoder::updateBuffVOPsEnhc ()
  1814. {
  1815. if ( this -> m_bCodedFutureRef == 1 ){ // added by Sharp (99/1/28)
  1816. switch(m_vopmd.vopPredType) {
  1817. case IVOP: // printf(" Not defined in updateBuffVOPsEnhc. n");  exit(1); // deleted by Sharp (99/1/25)
  1818.         m_pBuffE -> getBuf (this); // added by Sharp (99/1/22)
  1819. break; //added by Sharp (99/1/25)
  1820. case PVOP: m_pBuffE -> getBuf (this);
  1821. break;
  1822. case BVOP: m_pBuffE -> getBuf (this);
  1823. break;
  1824. default: exit(1);
  1825. }
  1826. } // added by Sharp (99/1/28)
  1827. }
  1829. void CVideoObjectDecoder::bufferB2flush ()
  1830. {
  1831. if (!(m_pBuffB2 -> empty ())) {
  1832. if ( m_pBuffB2 -> m_bCodedFutureRef == 1 ) // added by Sharp (99/1/28)
  1833. m_pBuffB1 -> copyBuf (*m_pBuffB2);
  1834. m_pBuffB2 -> dispose ();
  1835. }
  1836. }
  1837. /* Added */
  1838. void CVideoObjectDecoder::set_enh_display_size(CRct rctDisplay, CRct *rctDisplay_SSenh)
  1839. {
  1841. float tmp_right,tmp_left,tmp_top,tmp_bottom,tmp_width;
  1843. tmp_right = (float) rctDisplay.right * ((float) m_volmd.ihor_sampling_factor_n / m_volmd.ihor_sampling_factor_m);
  1844. tmp_left  = (float) rctDisplay.left  * ((float) m_volmd.ihor_sampling_factor_n / m_volmd.ihor_sampling_factor_m);
  1845. tmp_width = (float) rctDisplay.width * ((float) m_volmd.ihor_sampling_factor_n / m_volmd.ihor_sampling_factor_m);
  1847. tmp_top     = (float) rctDisplay.top * ((float) m_volmd.iver_sampling_factor_n / m_volmd.iver_sampling_factor_m);
  1848. tmp_bottom  = (float) rctDisplay.bottom  * ((float) m_volmd.iver_sampling_factor_n / m_volmd.iver_sampling_factor_m);
  1850. rctDisplay_SSenh->right  = (Int) tmp_right;
  1851. rctDisplay_SSenh->left   = (Int) tmp_left;
  1853. rctDisplay_SSenh->width  = (Int) tmp_width;
  1855. rctDisplay_SSenh->top    = (Int) tmp_top;
  1856. rctDisplay_SSenh->bottom = (Int) tmp_bottom;
  1858. }
  1861. void CVideoObjectDecoder::bufferB1flush ()
  1862. {
  1863. m_pBuffB1 -> dispose ();
  1864. }
  1866. void CVideoObjectDecoder::bufferP1flush ()
  1867. {
  1868. m_pBuffP1 -> dispose ();
  1869. }
  1871. void CVideoObjectDecoder::copyBufP2ToB1 ()
  1872. {
  1873. if ( m_pBuffP2 -> m_bCodedFutureRef == 1 ) // added by Sharp (99/1/28)
  1874. m_pBuffB1 -> copyBuf (*m_pBuffP2);
  1875. }
  1877. void CVideoObjectDecoder::copyRefQ1ToQ0 ()
  1878. {
  1879. copyVOPU8YUVBA(m_pvopcRefQ0, m_pvopcRefQ1);
  1880. }
  1882. Time CVideoObjectDecoder::senseTime ()
  1883. {
  1884. m_pbitstrmIn -> setBookmark ();
  1886. if (findStartCode () == EOF) {
  1887. m_pbitstrmIn -> gotoBookmark ();
  1888. return EOF;
  1889. }
  1890. // Start code
  1891. UInt uiVopStartCode = m_pbitstrmIn -> getBits (NUMBITS_VOP_START_CODE);
  1892. if (uiVopStartCode == GOV_START_CODE) {
  1893. m_bUseGOV = TRUE;
  1894. m_bLinkisBroken = FALSE;
  1895. Int timecode;
  1896. timecode = m_pbitstrmIn -> getBits (5) * 3600;
  1897. timecode += m_pbitstrmIn -> getBits (6) * 60;
  1898. m_pbitstrmIn -> getBits (1);
  1899. timecode += m_pbitstrmIn -> getBits (6);
  1900. m_tModuloBaseDecd = timecode;
  1901. m_tModuloBaseDisp = timecode;
  1903. Int closed_gov = m_pbitstrmIn -> getBits (1);
  1904. Int broken_link = m_pbitstrmIn -> getBits (1);
  1905. if ((closed_gov == 0)&&(broken_link == 1))
  1906. m_bLinkisBroken = TRUE;
  1908. findStartCode();
  1909. /*
  1910. m_pbitstrmIn -> getBits (4);
  1911. Int uiPrefix = m_pbitstrmIn -> getBits (NUMBITS_START_CODE_PREFIX);
  1912. assert(uiPrefix == START_CODE_PREFIX);
  1913. */
  1914. uiVopStartCode = m_pbitstrmIn -> getBits (NUMBITS_VOP_START_CODE);
  1915. }
  1916. assert(uiVopStartCode == VOP_START_CODE);
  1918. m_vopmd.vopPredType = (VOPpredType) m_pbitstrmIn -> getBits (NUMBITS_VOP_PRED_TYPE);
  1919. // Time reference and VOP_pred_type
  1920. Int iModuloInc = 0;
  1921. while (m_pbitstrmIn -> getBits (1) != 0)
  1922. iModuloInc++;
  1923. Time tCurrSec = iModuloInc + ((m_vopmd.vopPredType != BVOP || 
  1924. (m_vopmd.vopPredType == BVOP && m_volmd.volType == ENHN_LAYER )) ?
  1925. m_tModuloBaseDecd : m_tModuloBaseDisp);
  1926. UInt uiMarker = m_pbitstrmIn -> getBits (1);
  1927. assert(uiMarker == 1);
  1928. Time tVopIncr = m_pbitstrmIn -> getBits (m_iNumBitsTimeIncr);
  1930. m_pbitstrmIn -> gotoBookmark ();
  1932. Time t = tCurrSec * m_volmd.iClockRate*m_iClockRateScale + tVopIncr*m_iClockRateScale;
  1933. return(t);
  1934. }
  1936. Time CVideoObjectDecoder::getTime ()
  1937. {
  1938. return m_t;
  1939. }
  1941. int CVideoObjectDecoder::getPredType ()
  1942. {
  1943. return m_vopmd.vopPredType;
  1944. }
  1946. Void CVideoObjectDecoder::BackgroundComposition(char* argv[], Bool bScalability, Int width, Int height, FILE *pfYUV) // modified by Sharp (98/10/26)
  1947. {
  1948.     Int iFrame = getTime (); // current frame nubmer
  1949.     Int iPrev; // previous base frame 
  1950.     Int iNext; // next     base frame 
  1952.     if(!(m_pBuffB1 -> empty ()))  iPrev = m_pBuffB1 -> m_t;
  1953.     else           iPrev = m_pBuffP1 -> m_t;
  1954.     if(!(m_pBuffB2 -> empty ()))  iNext = m_pBuffB2 -> m_t;
  1955.     else           iNext = m_pBuffP2 -> m_t;
  1957.     Void convertYuv(const CVOPU8YUVBA* pvopcSrc, PixelC* destY, PixelC* destU, PixelC* destV, Int width, Int height);
  1958.     Void convertSeg(const CVOPU8YUVBA* pvopcSrc, PixelC* destBY,PixelC* destBUV,              Int width, Int height,
  1959.     Int left, Int right, Int top, Int bottom
  1960.     );
  1961.     Void bg_comp_each(PixelC* curr, PixelC* prev, PixelC* next, PixelC* mask_curr, PixelC* mask_prev, PixelC* mask_next, 
  1962.       Int curr_t, Int prev_t, Int next_t, Int width, Int height, Int CoreMode); // modified by Sharp (98/3/24)
  1963.     Void inv_convertYuv(const CVOPU8YUVBA* pvopcSrc, PixelC* destY, PixelC* destU, PixelC* destV, Int width, Int height);
  1964.     //Void write420(Int num, char *name, PixelC* destY, PixelC* destU, PixelC* destV, Int width, Int height);
  1965.     Void write420_sep(Int num, char *name, PixelC* destY, PixelC* destU, PixelC* destV, Int width, Int height); // modified by Sharp (98/10/26)
  1966.     Void write420_jnt(FILE *pfYUV, PixelC* destY, PixelC* destU, PixelC* destV, Int width, Int height); // added by Sharp (98/10/26)
  1967.     Void write_seg_test(Int num, char *name, PixelC* destY, Int width, Int height);
  1969.     PixelC* currY = new PixelC [width*height];
  1970.     PixelC* currU = new PixelC [width*height/4];
  1971.     PixelC* currV = new PixelC [width*height/4];
  1972.     PixelC* currBY  = new PixelC [width*height];
  1973.     PixelC* currBUV = new PixelC [width*height/4];
  1975.     PixelC* prevY = new PixelC [width*height];
  1976.     PixelC* prevU = new PixelC [width*height/4];
  1977.     PixelC* prevV = new PixelC [width*height/4];
  1978.     PixelC* prevBY  = new PixelC [width*height];
  1979.     PixelC* prevBUV = new PixelC [width*height/4];
  1981.     PixelC* nextY = new PixelC [width*height];
  1982.     PixelC* nextU = new PixelC [width*height/4];
  1983.     PixelC* nextV = new PixelC [width*height/4];
  1984.     PixelC* nextBY  = new PixelC [width*height];
  1985.     PixelC* nextBUV = new PixelC [width*height/4];
  1987.     // current frame
  1988.     convertYuv(pvopcReconCurr(), currY, currU, currV, width, height);
  1989.     if(pvopcReconCurr ()->pixelsBY () != NULL)
  1990.       convertSeg(pvopcReconCurr(), currBY, currBUV, width, height,
  1991.        m_rctCurrVOPY.left,
  1992.        m_rctCurrVOPY.right,
  1993.        m_rctCurrVOPY.top,
  1994.        m_rctCurrVOPY.bottom); /* forward shape */
  1996.     // previouse frame
  1997.     if(!(m_pBuffB1 -> empty ()))
  1998.       convertYuv(m_pBuffB1->m_pvopcBuf, prevY, prevU, prevV, width, height);
  1999.     else
  2000.       convertYuv(m_pBuffP1->m_pvopcBuf, prevY, prevU, prevV, width, height);
  2002.     convertSeg(rgpbfShape [1]->pvopcReconCurr (), prevBY, prevBUV, width, height,
  2003.        rgpbfShape [1]->m_rctCurrVOPY.left,
  2004.        rgpbfShape [1]->m_rctCurrVOPY.right,
  2005.        rgpbfShape [1]->m_rctCurrVOPY.top,
  2006.        rgpbfShape [1]->m_rctCurrVOPY.bottom); // forward shape
  2008. //    write_test(iPrev, "bbb", prevY, prevU, prevV, width, height);
  2009. //    write_seg_test(iPrev, "bbb", prevBY, width, height);
  2011.     // next frame
  2012.     if(!(m_pBuffB2 -> empty ()))
  2013.       convertYuv(m_pBuffB2->m_pvopcBuf, nextY, nextU, nextV, width, height);
  2014.     else
  2015.       convertYuv(m_pBuffP2->m_pvopcBuf, nextY, nextU, nextV, width, height);
  2016.     convertSeg(rgpbfShape [0]->pvopcReconCurr (), nextBY, nextBUV, width, height,
  2017.        rgpbfShape [0]->m_rctCurrVOPY.left,
  2018.        rgpbfShape [0]->m_rctCurrVOPY.right,
  2019.        rgpbfShape [0]->m_rctCurrVOPY.top,
  2020.        rgpbfShape [0]->m_rctCurrVOPY.bottom); // backward shape
  2022. //    write_test(iNext, "bbb", nextY, nextU, nextV, width, height);
  2023. //    write_seg_test(iNext, "bbb", nextBY, width, height);
  2025. // begin: modified by Sharp (98/3/24)
  2026.     bg_comp_each(currY, prevY, nextY, currBY,  prevBY,  nextBY,  iFrame, iPrev, iNext, width,   height, BGComposition == 0);
  2027.     bg_comp_each(currU, prevU, nextU, currBUV, prevBUV, nextBUV, iFrame, iPrev, iNext, width/2, height/2, BGComposition == 0);
  2028.     bg_comp_each(currV, prevV, nextV, currBUV, prevBUV, nextBUV, iFrame, iPrev, iNext, width/2, height/2, BGComposition == 0);
  2029. // end: modified by Sharp (98/3/24)
  2031. //    inv_convertYuv(pvopcReconCurr(), currY, currU, currV, width, height);
  2033. // write background compsition image
  2034. #ifdef __OUT_ONE_FRAME_ // added by Sharp (98/10/26)
  2035. static Char pchYUV [100];
  2036. sprintf (pchYUV, "%s.yuv", argv [2 + bScalability]); // modified by Sharp (98/10/26)
  2037.     write420_sep(iFrame, pchYUV, currY, currU, currV, width, height);
  2038. // begin: added by Sharp (98/10/26)
  2039. #else
  2040.     write420_jnt(pfYUV, currY, currU, currV, width, height);
  2041. #endif
  2042. // end: added by Sharp (98/10/26)
  2044.     delete currY;
  2045.     delete currU;
  2046.     delete currV;
  2047.     delete currBY;
  2048.     delete currBUV;
  2050.     delete prevY;
  2051.     delete prevU;
  2052.     delete prevV;
  2053.     delete prevBY;
  2054.     delete prevBUV;
  2056.     delete nextY;
  2057.     delete nextU;
  2058.     delete nextV;
  2059.     delete nextBY;
  2060.     delete nextBUV;
  2061. }
  2063. Void CVideoObjectDecoder::dumpDataOneFrame(char* argv[], Bool bScalability, CRct& rctDisplay)
  2064. {
  2065. Int iFrame = getTime ();
  2067. // cout << "n=== write with Sharp's format : frame no. = " << iFrame << "n";
  2069. static Char pchYUV [100], pchSeg [100];
  2071. // if(m_volmd.volType == BASE_LAYER) { // deleted by Sharp (98/11/11)
  2072. sprintf (pchYUV, "%s.yuv", argv [2 + bScalability]);
  2073. // begin: added by Sharp (99/1/25)
  2074. if ( m_volmd.iEnhnType == 1 && m_volmd.volType == ENHN_LAYER )
  2075. sprintf (pchSeg, "%s_e.seg", argv [2 + bScalability]);
  2076. else
  2077. // end: added by Sharp (99/1/25)
  2078. sprintf (pchSeg, "%s.seg", argv [2 + bScalability]);
  2079. // begin: deleted by Sharp (98/11/11)
  2080. // }
  2081. // else {
  2082. // sprintf (pchYUV, "%s_e.yuv", argv [2 + bScalability]);
  2083. // sprintf (pchSeg, "%s_e.seg", argv [2 + bScalability]);
  2084. // }
  2085. // end: deleted by Sharp (98/11/11)
  2087. sprintf (pchYUV, "%s%d", pchYUV, iFrame);
  2088. sprintf (pchSeg, "%s%d", pchSeg, iFrame);
  2090. FILE* pfYuvDst = fopen(pchYUV, "wb");
  2092. const CVOPU8YUVBA* pvopcQuant = pvopcReconCurr ();
  2093. if ( m_volmd.iEnhnType != 1 ){ // added by Sharp (99/1/18)
  2094. pvopcQuant->getPlane (Y_PLANE)->dump (pfYuvDst, rctDisplay);
  2095. pvopcQuant->getPlane (U_PLANE)->dump (pfYuvDst, rctDisplay / 2);
  2096. pvopcQuant->getPlane (V_PLANE)->dump (pfYuvDst, rctDisplay / 2);
  2097. } // added by Sharp (99/1/18)
  2098. fclose(pfYuvDst);
  2100. if (m_volmd.fAUsage != RECTANGLE) {
  2101. FILE* pfSegDst = fopen(pchSeg, "wb");
  2102. pvopcQuant->getPlane (BY_PLANE)->dump (pfSegDst, rctDisplay, m_vopmd.iVopConstantAlphaValue);
  2103. fclose(pfSegDst);
  2104. }
  2105. }
  2107. Void CVideoObjectDecoder::dumpDataAllFrame(FILE* pfReconYUV, FILE* pfReconSeg, CRct& rctDisplay)
  2108. {
  2109. const CVOPU8YUVBA* pvopcQuant = pvopcReconCurr ();
  2110.   if ( m_volmd.iEnhnType != 1 ){ // added by Sharp (99/1/18)
  2111. pvopcQuant->getPlane (Y_PLANE)->dump (pfReconYUV, rctDisplay);
  2112. pvopcQuant->getPlane (U_PLANE)->dump (pfReconYUV, rctDisplay / 2);
  2113. pvopcQuant->getPlane (V_PLANE)->dump (pfReconYUV, rctDisplay / 2);
  2114. } // added by Sharp (99/1/18)
  2115. if (m_volmd.fAUsage != RECTANGLE)
  2116. pvopcQuant->getPlane (BY_PLANE)->dump (pfReconSeg, rctDisplay, m_vopmd.iVopConstantAlphaValue);
  2117. }
  2119. void CVideoObjectDecoder::copyTobfShape ()
  2120. {
  2121.             rgpbfShape[0]->m_pistrm      = m_pistrm;
  2122.             rgpbfShape[0]->m_pbitstrmIn  = m_pbitstrmIn;
  2123.             rgpbfShape[0]->m_pentrdecSet = m_pentrdecSet;
  2124.             rgpbfShape[1]->m_pistrm      = m_pistrm;
  2125.             rgpbfShape[1]->m_pbitstrmIn  = m_pbitstrmIn;
  2126.             rgpbfShape[1]->m_pentrdecSet = m_pentrdecSet;
  2127. }
  2129. // begin: added by Sharp (98/6/26)
  2130. void CVideoObjectDecoder::setClockRateScale ( CVideoObjectDecoder *pvopdec )
  2131. {
  2132. m_iClockRateScale = pvopdec->m_volmd.iClockRate / m_volmd.iClockRate;
  2133. }
  2134. // end: added by Sharp (98/6/26)
  2136. /******************************************
  2137. *** class CEnhcBufferDecoder ***
  2138. ******************************************/
  2139. CEnhcBufferDecoder::CEnhcBufferDecoder (Int iSessionWidth, Int iSessionHeight)
  2140. : CEnhcBuffer (iSessionWidth, iSessionHeight)
  2141. {
  2142. }
  2144. Void CEnhcBufferDecoder::copyBuf (const CEnhcBufferDecoder& srcBuf)
  2145. {
  2146. m_iNumMBRef = srcBuf.m_iNumMBRef;
  2147. m_iNumMBXRef = srcBuf.m_iNumMBXRef;
  2148. m_iNumMBYRef = srcBuf.m_iNumMBYRef;
  2149. m_iOffsetForPadY = srcBuf.m_iOffsetForPadY;
  2150. m_iOffsetForPadUV = srcBuf.m_iOffsetForPadUV;
  2151. m_rctPrevNoExpandY = srcBuf.m_rctPrevNoExpandY;
  2152. m_rctPrevNoExpandUV = srcBuf.m_rctPrevNoExpandUV;
  2154. m_rctRefVOPY0 = srcBuf.m_rctRefVOPY0;
  2155. m_rctRefVOPUV0 = srcBuf.m_rctRefVOPUV0;
  2156. m_rctRefVOPY1 = srcBuf.m_rctRefVOPY1;
  2157. m_rctRefVOPUV1 = srcBuf.m_rctRefVOPUV1;
  2158. m_bCodedFutureRef = srcBuf.m_bCodedFutureRef; // added by Sharp (99/1/26)
  2160. CMBMode* pmbmdRefSrc = srcBuf.m_rgmbmdRef;
  2161. CMBMode* pmbmdRef    = m_rgmbmdRef;
  2162. CMotionVector* pmvRefSrc = srcBuf.m_rgmvRef;
  2163. CMotionVector* pmvRef = m_rgmvRef;
  2165. // TPS FIX
  2166. Int iMaxIndex = max(PVOP_MV_PER_REF_PER_MB, 2*BVOP_MV_PER_REF_PER_MB);
  2168. for (Int iMB=0; iMB<m_iNumMBRef; iMB++){
  2169. *pmbmdRef = *pmbmdRefSrc;
  2170. pmbmdRef++;
  2171. pmbmdRefSrc++;
  2173. // TPS FIX
  2174. for (Int iVecIndex=0; iVecIndex<iMaxIndex; iVecIndex++ ){
  2175. *pmvRef = *pmvRefSrc;
  2176. pmvRef++;
  2177. pmvRefSrc++;
  2178. }
  2179. }
  2181. CVOPU8YUVBA* pvop = srcBuf.m_pvopcBuf;
  2182. delete m_pvopcBuf;
  2183. m_pvopcBuf = NULL;
  2184. m_pvopcBuf = new CVOPU8YUVBA( *pvop );
  2186. m_t = srcBuf.m_t;
  2187. }
  2189. Void CEnhcBufferDecoder::getBuf(CVideoObjectDecoder* pvopc)  // get params from Base layer
  2190. {
  2191. // assert(pvopc->m_volmd.volType == BASE_LAYER);
  2192. CMBMode* pmbmdRef;
  2193. CMBMode* pmbmdRefSrc;
  2194. CMotionVector* pmvRef;
  2195. CMotionVector* pmvRefSrc;
  2197. m_bCodedFutureRef = pvopc->m_bCodedFutureRef; // added by Sharp (99/1/26)
  2198. if ( pvopc->m_vopmd.vopPredType != BVOP ){
  2199. pmbmdRef = m_rgmbmdRef;
  2200. pmbmdRefSrc = pvopc->m_rgmbmdRef;
  2201. pmvRef = m_rgmvRef;
  2202. pmvRefSrc = pvopc->m_rgmvRef;
  2203. m_iNumMBRef = pvopc->m_iNumMBRef;
  2204. m_iNumMBXRef = pvopc->m_iNumMBXRef;
  2205. m_iNumMBYRef = pvopc->m_iNumMBYRef;
  2206. }
  2207. else {
  2209. pmbmdRef = m_rgmbmdRef;
  2210. pmbmdRefSrc = pvopc->m_rgmbmd;
  2211. pmvRef = m_rgmvRef;
  2212. pmvRefSrc = pvopc->m_rgmv;
  2213. m_iNumMBRef = pvopc->m_iNumMB;
  2214. m_iNumMBXRef = pvopc->m_iNumMBX;
  2215. m_iNumMBYRef = pvopc->m_iNumMBY;
  2216. }
  2218. // TPS FIX
  2219. Int iMaxIndex = max(PVOP_MV_PER_REF_PER_MB, 2*BVOP_MV_PER_REF_PER_MB);
  2221. for (Int iMB=0; iMB<m_iNumMBRef; iMB++ ) {
  2222. *pmbmdRef = *pmbmdRefSrc;
  2223. pmbmdRef++;
  2224. pmbmdRefSrc++;
  2226. // TPS FIX
  2227. for (Int iVecIndex=0; iVecIndex<iMaxIndex; iVecIndex++ ){
  2228. *pmvRef = *pmvRefSrc;
  2229. pmvRef++;
  2230. pmvRefSrc++;
  2231. }
  2232. }
  2233. ///// 97/12/22 start
  2234. m_t = pvopc->m_t;
  2235. delete m_pvopcBuf;
  2236. m_pvopcBuf = NULL;
  2237. m_pvopcBuf = new CVOPU8YUVBA( *(pvopc->pvopcReconCurr()) );
  2238. if ( pvopc->m_vopmd.vopPredType != BVOP ) {
  2239. m_iOffsetForPadY = pvopc->m_iOffsetForPadY;
  2240. m_iOffsetForPadUV = pvopc->m_iOffsetForPadUV;
  2241. m_rctPrevNoExpandY = pvopc->m_rctPrevNoExpandY;
  2242. m_rctPrevNoExpandUV = pvopc->m_rctPrevNoExpandUV;
  2243. m_rctRefVOPY1 = pvopc->m_rctRefVOPY1;
  2244. m_rctRefVOPUV1 = pvopc->m_rctRefVOPUV1;
  2245. }
  2246. else {
  2247. m_iOffsetForPadY = pvopc->m_iBVOPOffsetForPadY;
  2248. m_iOffsetForPadUV = pvopc->m_iBVOPOffsetForPadUV;
  2249. m_rctPrevNoExpandY = pvopc->m_rctBVOPPrevNoExpandY;
  2250. m_rctPrevNoExpandUV = pvopc->m_rctBVOPPrevNoExpandUV;
  2251. m_rctRefVOPY1 = pvopc->m_rctBVOPRefVOPY1;
  2252. m_rctRefVOPUV1 = pvopc->m_rctBVOPRefVOPUV1;
  2253. }
  2254. ///// 97/12/22 end
  2255. }
  2257. Void CEnhcBufferDecoder::putBufToQ0(CVideoObjectDecoder* pvopc)  // store params to Enhancement layer pvopcRefQ0
  2258. {
  2259. assert(pvopc->m_volmd.volType == ENHN_LAYER);
  2261. delete pvopc->m_pvopcRefQ0;
  2262. pvopc->m_pvopcRefQ0 = NULL;
  2263. pvopc->m_pvopcRefQ0 = new CVOPU8YUVBA ( *m_pvopcBuf );
  2265. pvopc->m_bCodedFutureRef = m_bCodedFutureRef; // added by Sharp (99/1/26)
  2266. if ( pvopc->m_volmd.iEnhnType == 1  &&
  2267. (((pvopc->m_vopmd.iRefSelectCode == 1 || pvopc->m_vopmd.iRefSelectCode == 2) && pvopc->m_vopmd.vopPredType == PVOP) ||
  2268.  (pvopc->m_vopmd.iRefSelectCode == 3 && pvopc->m_vopmd.vopPredType == BVOP))
  2269. )
  2270. {
  2271. CRct rctRefFrameYTemp = pvopc->m_rctRefFrameY;
  2272. CRct rctRefFrameUVTemp = pvopc->m_rctRefFrameUV;
  2273. rctRefFrameYTemp.expand(-EXPANDY_REF_FRAME);
  2274. rctRefFrameUVTemp.expand(-EXPANDY_REF_FRAME/2);
  2275. pvopc->m_pvopcRefQ0->addBYPlain(rctRefFrameYTemp, rctRefFrameUVTemp);
  2276. }
  2278. // if ( pvopc->m_volmd.fAUsage != RECTANGLE ){
  2279. CMBMode* pmbmdRefSrc = m_rgmbmdRef;
  2280. CMBMode* pmbmdRef = pvopc->m_rgmbmdRef;
  2281. CMotionVector* pmvRefSrc = m_rgmvRef;
  2282. CMotionVector* pmvRef = pvopc->m_rgmvRef;
  2283. pvopc->m_iNumMBRef = m_iNumMBRef;
  2284. pvopc->m_iNumMBXRef = m_iNumMBXRef;
  2285. pvopc->m_iNumMBYRef = m_iNumMBYRef;
  2287. // TPS FIX
  2288. Int iMaxIndex = max(PVOP_MV_PER_REF_PER_MB, 2*BVOP_MV_PER_REF_PER_MB);
  2290. for (Int iMB=0; iMB<m_iNumMBRef; iMB++ ) {
  2291. *pmbmdRef = *pmbmdRefSrc;
  2292. if ( pvopc->m_volmd.iEnhnType == 1  &&
  2293. (((pvopc->m_vopmd.iRefSelectCode == 1 || pvopc->m_vopmd.iRefSelectCode == 2) && pvopc->m_vopmd.vopPredType == PVOP) ||
  2294.  (pvopc->m_vopmd.iRefSelectCode == 3 && pvopc->m_vopmd.vopPredType == BVOP))
  2295. ) {
  2296. pmbmdRef->m_shpmd = ALL_OPAQUE;
  2297. }
  2298. pmbmdRef++;
  2299. pmbmdRefSrc++;
  2300. // TPS FIX
  2301. for (Int iVecIndex=0; iVecIndex<iMaxIndex; iVecIndex++ ){
  2302. *pmvRef = *pmvRefSrc;
  2303. pmvRef ++;
  2304. pmvRefSrc ++;
  2305. }
  2306. }
  2307. pvopc->saveShapeMode ();
  2309. // for padding operation
  2310. pvopc->m_iOffsetForPadY = m_iOffsetForPadY;
  2311. pvopc->m_iOffsetForPadUV = m_iOffsetForPadUV;
  2312. pvopc->m_rctPrevNoExpandY = m_rctPrevNoExpandY;
  2313. pvopc->m_rctPrevNoExpandUV = m_rctPrevNoExpandUV;
  2315. // This part is needed for storing RefQ0
  2316. pvopc->m_rctRefVOPY0 = m_rctRefVOPY1;
  2317. pvopc->m_rctRefVOPUV0 = m_rctRefVOPUV1;
  2319. pvopc->m_pvopcRefQ0->setBoundRct(m_rctRefVOPY1);
  2320. // }
  2322. pvopc->repeatPadYOrA ((PixelC*) pvopc->m_pvopcRefQ0->pixelsY () + m_iOffsetForPadY, pvopc->m_pvopcRefQ0);
  2323. pvopc->repeatPadUV(pvopc->m_pvopcRefQ0);
  2324. if ( pvopc->m_volmd.fAUsage != RECTANGLE ){
  2325. if ( pvopc->m_volmd.fAUsage == EIGHT_BIT )
  2326. pvopc->repeatPadYOrA ((PixelC*) pvopc->m_pvopcRefQ0->pixelsA () + m_iOffsetForPadY, pvopc->m_pvopcRefQ0);
  2327. }
  2328. }
  2330. Void CEnhcBufferDecoder::putBufToQ1(CVideoObjectDecoder* pvopc)  // store params to Enhancement layer pvopcRefQ1
  2331. {
  2332. assert(pvopc->m_volmd.volType == ENHN_LAYER);
  2334. delete pvopc->m_pvopcRefQ1;
  2335. pvopc->m_pvopcRefQ1 = NULL;
  2336. pvopc->m_pvopcRefQ1 = new CVOPU8YUVBA ( *m_pvopcBuf );
  2337. pvopc->m_bCodedFutureRef = m_bCodedFutureRef; // added by Sharp (99/1/26)
  2338. if ( pvopc->m_volmd.iEnhnType == 1  &&
  2339. (((pvopc->m_vopmd.iRefSelectCode == 1 || pvopc->m_vopmd.iRefSelectCode == 2) && pvopc->m_vopmd.vopPredType == PVOP) ||
  2340. ((pvopc->m_vopmd.iRefSelectCode == 1 || pvopc->m_vopmd.iRefSelectCode == 3) && pvopc->m_vopmd.vopPredType == BVOP)) // modified by Sharp (98/5/25)
  2341. )
  2342. {
  2343. CRct rctRefFrameYTemp = pvopc->m_rctRefFrameY;
  2344. CRct rctRefFrameUVTemp = pvopc->m_rctRefFrameUV;
  2345. rctRefFrameYTemp.expand(-EXPANDY_REF_FRAME);
  2346. rctRefFrameUVTemp.expand(-EXPANDY_REF_FRAME/2);
  2347. pvopc->m_pvopcRefQ1->addBYPlain(rctRefFrameYTemp, rctRefFrameUVTemp); // modified by Sharp (98/5/25)
  2348. }
  2350. // if ( pvopc->m_volmd.fAUsage != RECTANGLE ){
  2351. CMBMode* pmbmdRefSrc = m_rgmbmdRef;
  2352. CMBMode* pmbmdRef = pvopc->m_rgmbmdRef;
  2353. CMotionVector* pmvRefSrc = m_rgmvRef;
  2354. CMotionVector* pmvRef = pvopc->m_rgmvRef;
  2356. // This part is stored in CVideoObjectDecoder::decode()
  2357. pvopc->m_iNumMBRef = m_iNumMBRef;
  2358. pvopc->m_iNumMBXRef = m_iNumMBXRef;
  2359. pvopc->m_iNumMBYRef = m_iNumMBYRef;
  2361. // TPS FIX
  2362. Int iMaxIndex = max(PVOP_MV_PER_REF_PER_MB, 2*BVOP_MV_PER_REF_PER_MB);
  2364. for (Int iMB=0; iMB<m_iNumMBRef; iMB++ ) {
  2365. *pmbmdRef = *pmbmdRefSrc;
  2366. if ( pvopc->m_volmd.iEnhnType == 1 ) {
  2367. pmbmdRef->m_shpmd = ALL_OPAQUE;
  2368. }
  2369. pmbmdRef++;
  2370. pmbmdRefSrc++;
  2371. // TPS FIX
  2372. for (Int iVecIndex=0; iVecIndex<iMaxIndex; iVecIndex++ ){
  2373. *pmvRef = *pmvRefSrc;
  2374. pmvRef ++;
  2375. pmvRefSrc++;
  2376. }
  2377. }
  2379. // for padding operation
  2380. pvopc->m_iOffsetForPadY = m_iOffsetForPadY;
  2381. pvopc->m_iOffsetForPadUV = m_iOffsetForPadUV;
  2382. pvopc->m_rctPrevNoExpandY = m_rctPrevNoExpandY;
  2383. pvopc->m_rctPrevNoExpandUV = m_rctPrevNoExpandUV;
  2385. // This part is needed for storing RefQ0
  2386. pvopc->m_rctRefVOPY1 = m_rctRefVOPY1;
  2387. pvopc->m_rctRefVOPUV1 = m_rctRefVOPUV1;
  2389. pvopc->m_pvopcRefQ1->setBoundRct(m_rctRefVOPY1);
  2390. // }
  2392. pvopc->repeatPadYOrA ((PixelC*) pvopc->m_pvopcRefQ1->pixelsY () + m_iOffsetForPadY, pvopc->m_pvopcRefQ1);
  2393. pvopc->repeatPadUV(pvopc->m_pvopcRefQ1);
  2394. if ( pvopc->m_volmd.fAUsage != RECTANGLE ){
  2395. if ( pvopc->m_volmd.fAUsage == EIGHT_BIT )
  2396. pvopc->repeatPadYOrA ((PixelC*) pvopc->m_pvopcRefQ1->pixelsA () + m_iOffsetForPadY, pvopc->m_pvopcRefQ1);
  2397. }
  2398. }