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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

sptdec.cpp：源码内容
  1. /*************************************************************************
  3. This software module was originally developed by 
  5. Chuang Gu (chuanggu@microsoft.com), Microsoft Corporation
  6. (date: Augest, 1997)
  8. and also edited by
  9. David B. Shu (dbshu@hrl.com), Hughes Electronics/HRL Laboratories
  11. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  12. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  13. as specified by the MPEG-4 Video. 
  14. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  15. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  16. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
  17. The original developer of this software module and his/her company, 
  18. the subsequent editors and their companies, 
  19. and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
  20. Copyright is not released for non MPEG-4 Video conforming products. 
  21. Microsoft retains full right to use the code for his/her own purpose, 
  22. assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
  23. This copyright notice must be included in all copies or derivative works. 
  25. Copyright (c) 1996, 1997.
  27. Module Name:
  29. sptdec.cpp
  31. Abstract:
  33. Sprite decoder.
  35. Revision History:
  37. *************************************************************************/
  38. #include <stdio.h>
  39. #include <fstream.h>
  40. #include <math.h>
  42. #include "typeapi.h"
  43. #include "codehead.h"
  44. #include "entropy/bitstrm.hpp"
  45. #include "entropy/entropy.hpp"
  46. #include "entropy/huffman.hpp"
  47. #include "global.hpp"
  48. #include "mode.hpp"
  49. #include "vopses.hpp"
  50. #include "vopsedec.hpp"
  52. #ifdef __MFC_
  53. #ifdef _DEBUG
  54. #undef THIS_FILE
  55. static char BASED_CODE THIS_FILE[] = __FILE__;
  56. #endif
  58. #define new DEBUG_NEW    
  59. #endif // __MFC_
  61. #ifdef __PC_COMPILER_
  62. #define IOSBINARY ios::binary
  63. #else
  64. #define IOSBINARY ios::bin
  65. #endif // __PC_COMPILER_
  67. Int CVideoObjectDecoder::decodeSpt ()
  68. {
  69. //David Shu: please insert your stuff in this function
  70. assert (m_vopmd.vopPredType == SPRITE);
  71. if (m_iNumOfPnts > 0)
  72. decodeWarpPoints ();
  74. // Begin: modified by Hughes   4/9/98
  75. if (m_sptMode != BASIC_SPRITE)
  76. decodeSpritePieces  ();
  77. // End: modified by Hughes   4/9/98
  79. if (m_iNumOfPnts > 0) {
  80. CRct rctWarp = (m_volmd.fAUsage != RECTANGLE)? m_rctCurrVOPY : CRct (0, 0, m_ivolWidth, m_ivolHeight);
  81.         if(m_iNumOfPnts==2 || m_iNumOfPnts==3) {
  82. FastAffineWarp (rctWarp, rctWarp / 2, m_uiWarpingAccuracy, m_iNumOfPnts);
  83.         }
  84.         else {
  85. CPerspective2D perspYA (m_iNumOfPnts, m_rgstSrcQ, m_rgstDstQ, m_uiWarpingAccuracy);
  86. warpYA (perspYA, rctWarp, m_uiWarpingAccuracy);
  87. CSiteD rgstSrcQUV [4], rgstDstQUV [4];
  88. for (Int i = 0; i < m_iNumOfPnts; i++) {
  89. rgstSrcQUV [i] = (m_rgstSrcQ [i] - CSiteD (0.5, 0.5)) / 2;
  90. rgstDstQUV [i] = (m_rgstDstQ [i] - CSiteD (0.5, 0.5)) / 2;
  91. }
  92. CPerspective2D perspUV (m_iNumOfPnts, rgstSrcQUV, rgstDstQUV, m_uiWarpingAccuracy);
  93. warpUV (perspUV, rctWarp / 2, m_uiWarpingAccuracy);
  94. }
  95. }
  96. return TRUE;
  97. }
  99. Void CVideoObjectDecoder::decodeWarpPoints ()
  100. {
  101. assert (m_iNumOfPnts > 0);
  103. // Dest corner points MV decoding
  104. Int rgiU [4], rgiV [4], rgiDU [4], rgiDV [4];
  105. Int rgiWrpPnt0Del [2];
  106. CInBitStream* pibstrmWrpPt0 = m_pentrdecSet->m_pentrdecWrpPnt -> bitstream ();
  107. Int j;
  108. for (j = 0; j < m_iNumOfPnts; j++) { 
  109. for (UInt iXorY = 0; iXorY < 2; iXorY++) {
  110. Long lSz = m_pentrdecSet->m_pentrdecWrpPnt->decodeSymbol();
  111. Int iSign = pibstrmWrpPt0->peekBits (1); //get the sign
  112. if (iSign == 1)
  113. rgiWrpPnt0Del[iXorY] = pibstrmWrpPt0->getBits (lSz);
  114. else {
  115. Int iAbsWrpPnt0Del = ~(pibstrmWrpPt0->getBits (lSz)); //get the magnitude
  116. Int iMask = ~(0xFFFFFFFF << lSz); //mask out the irrelavent bits
  117. rgiWrpPnt0Del[iXorY] = -1 * (iAbsWrpPnt0Del & iMask); //masking and signing
  118. }
  119. assert (rgiWrpPnt0Del[iXorY] >= -16383 && rgiWrpPnt0Del[iXorY] <= 16383);
  120. Int iMarker = pibstrmWrpPt0->getBits(1);
  121. assert(iMarker==1);
  122. }
  123. rgiDU [j] = rgiWrpPnt0Del[0];
  124. rgiDV [j] = rgiWrpPnt0Del[1];
  125. }
  127. // create Src VOP bounding box
  128. switch (m_iNumOfPnts) {
  129. case 1: 
  130. m_rgstSrcQ [0] = CSiteD (m_rctCurrVOPY.left, m_rctCurrVOPY.top);
  131. break;
  132. case 2: 
  133. m_rgstSrcQ [0] = CSiteD (m_rctCurrVOPY.left, m_rctCurrVOPY.top);
  134. m_rgstSrcQ [1] = CSiteD (m_rctCurrVOPY.right, m_rctCurrVOPY.top);
  135. break;
  136. case 3:
  137. m_rgstSrcQ [0] = CSiteD (m_rctCurrVOPY.left, m_rctCurrVOPY.top);
  138. m_rgstSrcQ [1] = CSiteD (m_rctCurrVOPY.right, m_rctCurrVOPY.top);
  139. m_rgstSrcQ [2] = CSiteD (m_rctCurrVOPY.left, m_rctCurrVOPY.bottom);
  140. break;
  141. case 4:
  142. m_rgstSrcQ [0] = CSiteD (m_rctCurrVOPY.left, m_rctCurrVOPY.top);
  143. m_rgstSrcQ [1] = CSiteD (m_rctCurrVOPY.right, m_rctCurrVOPY.top);
  144. m_rgstSrcQ [2] = CSiteD (m_rctCurrVOPY.left, m_rctCurrVOPY.bottom);
  145. m_rgstSrcQ [3] = CSiteD (m_rctCurrVOPY.right, m_rctCurrVOPY.bottom);
  146. break;
  147. }
  149. // Dest corner points reconstruction 
  150. rgiU [0] = rgiDU [0]; rgiV [0] = rgiDV [0];
  151. rgiU [1] = rgiDU [1] + rgiU [0]; rgiV [1] = rgiDV [1] + rgiV [0];
  152. rgiU [2] = rgiDU [2] + rgiU [0]; rgiV [2] = rgiDV [2] + rgiV [0];
  153. rgiU [3] = rgiDU [3] + rgiU [2] + rgiU [1] - rgiU [0]; rgiV [3] = rgiDV [3] + rgiV [2] + rgiV [1] - rgiV [0];
  154. for (j = 0; j < m_iNumOfPnts; j++) {
  155. m_rgstDstQ [j].x = (rgiU [j] + 2 * m_rgstSrcQ [j].x) / 2.0;
  156. m_rgstDstQ [j].y = (rgiV [j] + 2 * m_rgstSrcQ [j].y) / 2.0;
  157. }
  158. }
  160. Void CVideoObjectDecoder::decodeInitSprite ()
  161. // decode initial sprite piece and initialize MB status array
  162. {
  163. Int iMod = m_rctSpt.width % MB_SIZE;
  164. Int iSptWidth = (iMod > 0) ? m_rctSpt.width + MB_SIZE - iMod : m_rctSpt.width;
  165. iMod = m_rctSpt.height () % MB_SIZE;
  166. Int iSptHeight = (iMod > 0) ? m_rctSpt.height () + MB_SIZE - iMod : m_rctSpt.height ();
  168. // Begin: modified by Hughes   4/9/98
  169. // m_rctSptExp = m_pvopcRefQ1->whereY();
  170. if (m_sptMode == BASIC_SPRITE)
  171. {
  172.         m_rctCurrVOPY = CRct (0, 0, iSptWidth, iSptHeight);
  173.         m_rctCurrVOPUV = m_rctCurrVOPY.downSampleBy2 ();
  174.         decode ();
  175. if (m_iNumOfPnts > 0) {
  176. swapRefQ1toSpt ();
  177. changeSizeofCurrQ (m_rctDisplayWindow);
  178. }
  179. m_pbitstrmIn->flush (8);
  180. return ;
  181. }
  182. // end:  modified by Hughes   4/9/98
  184. m_rctSptQ =  CRct (0, 0, iSptWidth, iSptHeight) ;  //  save sprite object information
  185. Int iNumMBX = iSptWidth / MB_SIZE; //for the whole sprite
  186. Int iNumMBY = iSptHeight / MB_SIZE;//for the whole sprite
  187. m_ppPieceMBstatus = new SptMBstatus* [iNumMBY]; 
  188. m_ppUpdateMBstatus = new SptMBstatus* [iNumMBY];
  190. // dshu: [v071]  Begin of modification
  191. Int iNumMB = iNumMBX * iNumMBY;
  192. m_rgmbmdSprite = new CMBMode [iNumMB];
  193. // dshu: [v071] end of modification
  195. m_rgmbmdSpt = new CMBMode* [iNumMBY]; 
  196. m_rgpmbmCurr_Spt = new MacroBlockMemory** [iNumMBY];
  198. // Begin: modified by Hughes   4/9/98
  199. Int iMBY;
  200. // Int iMBX, iMBY;
  201. // end:  modified by Hughes   4/9/98
  203. Int iMB, iBlk;
  204. Int nBlk = (m_volmd.fAUsage == EIGHT_BIT) ? 10 : 6;
  205. // Allocate MB hole status array and reconstructed MB  array
  206. for (iMBY = 0; iMBY < iNumMBY; iMBY++) {
  207. m_ppPieceMBstatus[iMBY] = new SptMBstatus [iNumMBX];
  208. m_ppUpdateMBstatus[iMBY] = new SptMBstatus [iNumMBX];
  209. m_rgmbmdSpt[iMBY] = new CMBMode [iNumMBX];
  210. m_rgpmbmCurr_Spt[iMBY] = new MacroBlockMemory* [iNumMBX];
  211. for (iMB = 0; iMB < iNumMBX; iMB++) {
  212. m_rgpmbmCurr_Spt[iMBY][iMB] = new MacroBlockMemory;
  213. m_rgpmbmCurr_Spt[iMBY][iMB]->rgblkm = new BlockMemory [nBlk];
  214. for (iBlk = 0; iBlk < nBlk; iBlk++) {
  215. (m_rgpmbmCurr_Spt[iMBY][iMB]->rgblkm) [iBlk] = new Int [(BLOCK_SIZE << 1) - 1];
  216. }
  217. // Begin: modified by Hughes   4/9/98
  218. m_ppPieceMBstatus[iMBY][iMB] = NOT_DONE;
  219. m_ppUpdateMBstatus[iMBY][iMB] = NOT_DONE;
  220. // end:  modified by Hughes   4/9/98
  221. }
  222. }
  224. // Begin: modified by Hughes   4/9/98
  225. CRct rctSptQ48 = m_pvopcRefQ1->whereY();
  226. m_pvopcSptQ = new CVOPU8YUVBA (m_volmd.fAUsage, rctSptQ48);
  227. m_pvopcSptQ -> shift (m_rctSpt.left, m_rctSpt.top); // change to absolute value in sprite coordinates
  228. m_pbitstrmIn->flush ();
  229. m_tPiece = 0;
  230. m_rctCurrVOPY = m_rctSptQ;
  231. m_rctCurrVOPUV = m_rctCurrVOPY.downSampleBy2 ();
  232. if (m_volmd.fAUsage != RECTANGLE) {
  233. m_iNumMBRef = iNumMB;
  234. m_iNumMBXRef = iNumMBX;
  235. m_iNumMBYRef = iNumMBY;
  236. m_iOffsetForPadY = m_rctRefFrameY.offset (m_rctCurrVOPY.left, m_rctCurrVOPY.top);
  237. m_iOffsetForPadUV = m_rctRefFrameUV.offset (m_rctCurrVOPUV.left, m_rctCurrVOPUV.top);
  238. m_rctRefVOPY1 = m_rctCurrVOPY;
  239. m_rctRefVOPY1.expand (EXPANDY_REFVOP);
  240. m_rctRefVOPUV1 = m_rctCurrVOPUV;
  241. m_rctRefVOPUV1.expand (EXPANDUV_REFVOP);
  242. m_pvopcRefQ1->setBoundRct (m_rctRefVOPY1);
  243. }
  244. /*
  245. m_tPiece = -1;
  246. decode ();
  248. // dshu: begin of modification
  249. // delete the following statement
  250. // m_rctSptPieceY = m_rctCurrVOPY; //for non-rectangular only becomes known now
  251. // dshu: end of modification
  252. m_tPiece = 0;
  253. m_iStepI = m_vopmd.intStepI ;
  254. // ensure byte alignment; 9/16/97
  255. m_pbitstrmIn->flush (8);
  256.     
  257. // dshu: begin of modification
  258. // m_pvopcSptQ = new CVOPU8YUVBA (*m_pvopcRefQ1);
  259. // m_pvopcSptQ -> shift (m_rctSptPieceY.left, m_rctSptPieceY.top); 
  260. m_pvopcSptQ = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctSptExp);
  261. m_pvopcSptQ -> shift (m_rctSpt.left, m_rctSpt.top);   // change to absolute value in sprite coordinates
  262. PiecePut(*m_pvopcRefQ1, *m_pvopcSptQ, m_rctSptPieceY);
  263. // dshu: end of modification
  266. //m_pvopcSptQ->vdlDump("c:\SptQ.vdl");
  268. //wchen: temporally out due to memory problem
  270. CMBMode* pmbmd = m_rgmbmdRef;
  271. IntraPredDirection* Spreddir;
  272. IntraPredDirection* preddir;
  273. // initialize  MB hole status array
  275. // dshu: begin of modification
  276. // Int iMB_left = m_rctSptPieceY.left / MB_SIZE;
  277. // Int iMB_right = m_rctSptPieceY.right / MB_SIZE;
  278. // Int iMB_top = m_rctSptPieceY.top / MB_SIZE;
  279. // Int iMB_bottom = m_rctSptPieceY.bottom / MB_SIZE;
  281. // MBs are based on vector, not on absolute value in sprite coordinates
  282. Int iMB_left = m_iPieceXoffset;
  283. Int iMB_right = m_iPieceXoffset + m_iPieceWidth;
  284. Int iMB_top = m_iPieceYoffset;
  285. Int iMB_bottom = m_iPieceYoffset + m_iPieceHeight;
  286. // dshu: end of modification
  288. for (iMBY = 0; iMBY < iNumMBY; iMBY++) 
  289. for (iMBX = 0; iMBX < iNumMBX; iMBX++) {
  290. if ((iMBX >= iMB_left && iMBX < iMB_right) && (iMBY >= iMB_top && iMBY < iMB_bottom)) 
  291. {
  292. m_ppPieceMBstatus[iMBY][iMBX] = PIECE_DONE;
  293. m_rgmbmdSpt[iMBY][iMBX] = CMBMode (*pmbmd);
  294. m_rgmbmdSprite[iMBX + iNumMBX * iMBY] = CMBMode (*pmbmd);  // dshu: [v071]  added to store mbmd array for sprite
  295. Spreddir = m_rgmbmdSpt[iMBY][iMBX].m_preddir;
  296. preddir = (*pmbmd).m_preddir;
  297. memcpy (Spreddir, preddir, 10  * sizeof (IntraPredDirection));
  298. pmbmd++;
  299. }
  300. else
  301. m_ppPieceMBstatus[iMBY][iMBX] = NOT_DONE;
  302. m_ppUpdateMBstatus[iMBY][iMBX] = NOT_DONE;
  303. }
  304. */
  305. // End: modified by Hughes   4/9/98
  307. m_oldSptXmitMode = PIECE;
  308. m_vopmd.SpriteXmitMode = PAUSE;
  309. }
  311. Void CVideoObjectDecoder::decodeSpritePieces  ()
  312. // decode sprite pieces
  313. {
  314. if ( m_vopmd.SpriteXmitMode == STOP)
  315. return;
  317. m_vopmd.SpriteXmitMode = m_oldSptXmitMode;
  318. CRct rctCurrVOPY = m_rctCurrVOPY; //caching for warping
  319. do {
  320. decodeOneSpritePiece ();
  321. } while (( m_vopmd.SpriteXmitMode != STOP) && ( m_vopmd.SpriteXmitMode != PAUSE));
  323. // dshu: [v071]  Begin of modification
  324. m_rctCurrVOPY = rctCurrVOPY;  //    restore for warping
  325. if (m_volmd.fAUsage != RECTANGLE)
  326. padSprite() ;  //    final padding just before warping 
  327. // dshu: [v071] end of modification
  329. if ( m_vopmd.SpriteXmitMode == STOP) {
  331. // dshu: begin of modification
  332. Int iNumMBX = m_rctSptQ.width / MB_SIZE; 
  333. Int iNumMBY = m_rctSptQ.height () / MB_SIZE;
  334. Int nBlk = (m_volmd.fAUsage == EIGHT_BIT) ? 10 : 6;
  335. for (Int iMBY = 0; iMBY < iNumMBY; iMBY++){
  336. for (Int iMB = 0; iMB < iNumMBX; iMB++) {
  337. for (Int iBlk = 0; iBlk < nBlk; iBlk++)
  338. delete [] (m_rgpmbmCurr_Spt[iMBY][iMB]->rgblkm) [iBlk];
  340. delete [] m_rgpmbmCurr_Spt [iMBY][iMB]->rgblkm;
  341. delete [] m_rgpmbmCurr_Spt [iMBY][iMB];
  342. }
  343. delete [] m_ppPieceMBstatus[iMBY] ; 
  344. delete [] m_ppUpdateMBstatus[iMBY] ;  
  345. delete [] m_rgmbmdSpt[iMBY] ;
  346. delete [] m_rgpmbmCurr_Spt[iMBY];
  347. }
  348. delete [] m_ppPieceMBstatus ; 
  349. delete [] m_ppUpdateMBstatus ;  
  350. delete [] m_rgmbmdSpt ;
  351. delete [] m_rgpmbmCurr_Spt;
  352. delete [] m_rgmbmdSprite ;    // dshu: [v071] 
  353. // dshu: end of modification
  354. //wchen: can you just delete double points like this?
  355. //temporarilly removed 
  357. // delete [] m_ppPieceMBstatus ;
  358. // delete [] m_ppUpdateMBstatus ;
  359. }
  361. //restore since it was changed during decoding to I/P
  362. m_vopmd.vopPredType = SPRITE;
  363. //restore for warping
  364. // m_rctCurrVOPY = rctCurrVOPY;   // dshu: [v071];   move to location of one statement before padSprite()
  365. // ensure byte alignment
  366. m_pbitstrmIn->flush (8);
  367. }
  369. //wchen: moved decode piece part from vopsedec.cpp -- decode ()
  370. Int CVideoObjectDecoder::decodeOneSpritePiece ()
  371. {
  372. //wchen: the part deals with stop and pause stay in decode ()
  373. assert (m_vopmd.SpriteXmitMode != STOP && m_vopmd.SpriteXmitMode != PAUSE);
  374. m_rctSptPieceY = decodeVOSHead ();
  375. if (m_vopmd.SpriteXmitMode == STOP || m_vopmd.SpriteXmitMode == PAUSE)
  376. return TRUE;
  377. else if (m_vopmd.SpriteXmitMode == PIECE ) //faking the paramters to fool vopmbdec
  378. m_vopmd.vopPredType = IVOP;
  379. else 
  380. m_vopmd.vopPredType = PVOP;
  382. // dshu: begin of modification
  383. // m_pvopcRefQ1 -> shift (m_rctSptPieceY.left, m_rctSptPieceY.top);
  384. // PieceOverlay(*m_pvopcSptQ, *m_pvopcRefQ1,  m_rctSptPieceY);   // extract reference
  385. // m_pvopcRefQ1 -> shift (-m_rctSptPieceY.left, -m_rctSptPieceY.top); // restore the m_pvopcRefQ1 to zero offset
  386. // dshu: end of modification
  389. // dshu: begin of modification
  390. //copy to Q0 via SptP
  391. // CVOPU8YUVBA* pvopcSptP = new CVOPU8YUVBA (*m_pvopcSptQ, m_volmd.fAUsage, m_rctSptPieceY);  // extract reference
  392. // m_pvopcRefQ0->overlay (*pvopcSptP);
  393. // delete pvopcSptP;
  395. PieceGet(*m_pvopcRefQ1, *m_pvopcSptQ, m_rctSptPieceY);
  396. // dshu: end of modification
  399. //always to that since the rect keeps changing
  400. //internally, every piece starts from (0, 0)
  401. m_rctCurrVOPY  = CRct(0,0, m_rctSptPieceY.width, m_rctSptPieceY.height());
  402. m_rctCurrVOPUV = m_rctCurrVOPY.downSampleBy2 ();
  403. setRefStartingPointers ();
  404. computeVOPMembers ();
  406. decodeVOP ();
  408. //delete ac/dc pred stuff
  409. Int nBlk = (m_volmd.fAUsage == EIGHT_BIT) ? 10 : 6;
  410. delete [] m_rgblkmCurrMB;
  411. m_rgblkmCurrMB = NULL;
  412. for (Int iMB = 0; iMB < m_iNumMBX; iMB++) {
  413. for (Int iBlk = 0; iBlk < nBlk; iBlk++) {
  414. delete [] (m_rgpmbmAbove [iMB]->rgblkm) [iBlk];
  415. delete [] (m_rgpmbmCurr  [iMB]->rgblkm) [iBlk];
  416. }
  417. delete [] m_rgpmbmAbove [iMB]->rgblkm;
  418. delete m_rgpmbmAbove [iMB];
  419. delete [] m_rgpmbmCurr [iMB]->rgblkm;
  420. delete m_rgpmbmCurr [iMB];
  421. }
  422. delete [] m_rgpmbmAbove;
  423. m_rgpmbmAbove = NULL;
  424. delete [] m_rgpmbmCurr;
  425. m_rgpmbmCurr = NULL;
  427. // Place the decoded sprite piece into sprite buffer.
  428. // Please notice that initial piece is offset by a vector like any VOP;
  429. // the rest of sprite pieces have zero offset, thus require shifting to be placed into buffer.
  430. // shift back to absolutes in sprite coordinates for overlaying
  432. // dshu: begin of modification
  433. // m_pvopcRefQ1 -> shift (m_rctSptPieceY.left, m_rctSptPieceY.top);
  434. // m_pvopcSptQ -> overlay (*m_pvopcRefQ1, m_rctSptPieceY);
  436. PiecePut(*m_pvopcRefQ1, *m_pvopcSptQ, m_rctSptPieceY);
  437. // PieceOverlay(*m_pvopcRefQ1, *m_pvopcSptQ, m_rctSptPieceY);
  438. // restore the m_pvopcRefQ1 to zero offset
  439. // m_pvopcRefQ1 -> shift (-m_rctSptPieceY.left, -m_rctSptPieceY.top);
  440. // dshu: end of modification
  442. return TRUE;
  443. }
  445. CRct CVideoObjectDecoder::decodeVOSHead ()
  446. {
  447. m_oldSptXmitMode = m_vopmd.SpriteXmitMode;
  448. m_vopmd.SpriteXmitMode = (SptXmitMode) m_pbitstrmIn -> getBits (NUMBITS_SPRITE_XMIT_MODE);
  449. if (( m_vopmd.SpriteXmitMode != STOP) &&( m_vopmd.SpriteXmitMode != PAUSE)) {
  450. Int stepToBeDeCoded = m_pbitstrmIn -> getBits (NUMBITS_VOP_QUANTIZER);
  451. if (m_vopmd.SpriteXmitMode == UPDATE) 
  452. m_vopmd.intStep = stepToBeDeCoded;
  453. else
  454. m_vopmd.intStepI = stepToBeDeCoded;
  455. m_iPieceWidth = m_pbitstrmIn -> getBits (NUMBITS_SPRITE_MB_OFFSET);
  456. m_iPieceHeight = m_pbitstrmIn -> getBits (NUMBITS_SPRITE_MB_OFFSET);
  457. // Begin: modified by Hughes   4/9/98
  458. /* Int iMarker = wmay */ m_pbitstrmIn -> getBits (MARKER_BIT);
  459. // End: modified by Hughes   4/9/98
  461. m_iPieceXoffset = m_pbitstrmIn -> getBits (NUMBITS_SPRITE_MB_OFFSET);
  462. m_iPieceYoffset = m_pbitstrmIn -> getBits (NUMBITS_SPRITE_MB_OFFSET);
  463. //wchen: changed to absolute value in sprite coordinates
  464. Int left  = (m_iPieceXoffset * MB_SIZE) + m_rctSpt.left;
  465. Int top = (m_iPieceYoffset * MB_SIZE)  + m_rctSpt.top;
  466. Int right = left + m_iPieceWidth * MB_SIZE ;
  467. Int bottom = top + m_iPieceHeight * MB_SIZE ;
  468. return CRct (left, top, right, bottom);
  469. }
  470. else
  471. return CRct();
  472. }