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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

sptenc.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. sptenc.cpp
  31. Abstract:
  33. Sprite Encoder.
  35. Revision History:
  37. *************************************************************************/
  39. #include <stdio.h>
  40. #include <iostream.h>
  41. #include <fstream.h>
  42. #include <math.h>
  43. #include <stdlib.h>
  44. #include "basic.hpp"
  45. #include "typeapi.h"
  46. #include "codehead.h"
  47. #include "global.hpp"
  48. #include "entropy/bitstrm.hpp"
  49. #include "entropy/entropy.hpp"
  50. #include "entropy/huffman.hpp"
  51. #include "mode.hpp"
  52. #include "dct.hpp"
  53. #include "vopses.hpp"
  54. #include "vopseenc.hpp"
  56. #ifdef __MFC_
  57. #ifdef _DEBUG
  58. #undef THIS_FILE
  59. static char BASED_CODE THIS_FILE[] = __FILE__;
  60. #endif
  62. #define new DEBUG_NEW    
  63. #endif // __MFC_
  65. Void CVideoObjectEncoder::encodeSptTrajectory (Time t, const CSiteD* rgstDest, const CRct& rctWarp)
  66. // code sprite trajactory and make reconstructed frame
  67. {
  68. m_t = t;
  69. m_statsVOP.reset ();
  70. m_pbitstrmOut->reset ();
  71. cout << "nVOP " << m_uiVOId << "n";
  72. m_vopmd.vopPredType = SPRITE;
  73. m_rctCurrVOPY = rctWarp;
  74. codeVOPHead ();
  75. cout << "t" << "Time..." << m_t << " (" << m_t/m_volmd.dFrameHz << " sec)n";
  76. cout.flush ();
  77. if (m_iNumOfPnts > 0) {
  78. quantizeSptTrajectory (rgstDest, rctWarp);
  79. codeWarpPoints ();
  80. }
  82. if (m_sptMode != BASIC_SPRITE)
  83. encodeSpritePiece (t);
  84. if (m_iNumOfPnts > 0) {
  85.         if(m_iNumOfPnts==2 || m_iNumOfPnts==3) {
  86. FastAffineWarp (rctWarp, rctWarp / 2, m_uiWarpingAccuracy, m_iNumOfPnts);
  87.         }
  88.         else {
  89. CPerspective2D perspYA (m_iNumOfPnts, m_rgstSrcQ, m_rgstDstQ, m_uiWarpingAccuracy);
  90. warpYA (perspYA, rctWarp, m_uiWarpingAccuracy);
  91. CSiteD rgstSrcQUV [4], rgstDstQUV [4];
  92. for (Int i = 0; i < m_iNumOfPnts; i++) {
  93. rgstSrcQUV [i] = (m_rgstSrcQ [i] - CSiteD (0.5, 0.5)) / 2;
  94. rgstDstQUV [i] = (m_rgstDstQ [i] - CSiteD (0.5, 0.5)) / 2;
  95. }
  96. CPerspective2D perspUV (m_iNumOfPnts, rgstSrcQUV, rgstDstQUV, m_uiWarpingAccuracy);
  97. warpUV (perspUV, rctWarp / 2, m_uiWarpingAccuracy);
  98. }
  99. }
  101. // Begin: modified by Hughes   4/9/98
  102. // if((!tentativeFirstSpriteVop) &&  (m_sptMode == BASIC_SPRITE)) {
  103. // Transmit sprite_trasmit_mode="stop" at the first Sprite VOP.
  104. // This is a tentative solution for bitstream exchange of
  105. // normal sprite bitstreams. This part needs to be changed
  106. // when low latency sprites is integrated.
  107. // m_pbitstrmOut->putBits (0, 2, "sprite_transmit_mode");
  108. // tentativeFirstSpriteVop = 1;
  109. // }
  110. // End: modified by Hughes   4/9/98
  112. m_statsVOP.nBitsStuffing += m_pbitstrmOut->flush ();
  113. m_statsVOL += m_statsVOP;
  114. }
  116. Void CVideoObjectEncoder::quantizeSptTrajectory (const CSiteD* rgstDest, CRct rctWarp)
  117. // construction of m_rgstSrcQ and m_rgstDstQ
  118. {
  119. CSiteD rgstSrcQ [4];
  120. rgstSrcQ [0] = CSiteD (rctWarp.left, rctWarp.top);
  121. rgstSrcQ [1] = CSiteD (rctWarp.right, rctWarp.top);
  122. rgstSrcQ [2] = CSiteD (rctWarp.left, rctWarp.bottom);
  123. rgstSrcQ [3] = CSiteD (rctWarp.right, rctWarp.bottom);
  125. for (Int i = 0; i < m_iNumOfPnts; i++) {
  126. // quantization rgstSrc
  127. CoordD x = rgstSrcQ [i].x, y = rgstSrcQ [i].y;
  128. Int rnd = (x > 0) ? (Int) (2.0 * x + .5) : (Int) (2.0 * x - .5);
  129. m_rgstSrcQ [i].x = (CoordD) rnd / (CoordD) 2.;
  130. rnd = (y > 0) ? (Int) (2.0 * y + .5) : (Int) (2.0 * y - .5);
  131. m_rgstSrcQ [i].y = (CoordD) rnd / (CoordD) 2.;
  132. // quantization rgstDest
  133. x = rgstDest [i].x;
  134. y = rgstDest [i].y;
  135. rnd = (x > 0) ? (Int) (2.0 * x + .5) : (Int) (2.0 * x - .5);
  136. m_rgstDstQ [i].x = (CoordD) rnd / (CoordD) 2.;
  137. rnd = (y > 0) ? (Int) (2.0 * y + .5) : (Int) (2.0 * y - .5);
  138. m_rgstDstQ [i].y = (CoordD) rnd / (CoordD) 2.;
  139. }
  140. }
  142. UInt CVideoObjectEncoder::codeWarpPoints ()
  143. {
  144. UInt nBits = 0;
  145. assert (m_iNumOfPnts > 0);
  147. // Dest corner points MV encoding
  148. // construct u, v, du, dv
  149. Int rgiU [4], rgiV [4], rgiDU [4], rgiDV [4];
  150. Int j;
  151. for (j = 0; j < m_iNumOfPnts; j++) {  //here both m_rgstDstQ and m_rgstSrcQ are in fulpel accuracy
  152. rgiU [j] = (Int) (2 * (m_rgstDstQ [j].x -  m_rgstSrcQ [j].x));
  153. rgiV [j] = (Int) (2 * (m_rgstDstQ [j].y -  m_rgstSrcQ [j].y));
  154. }
  155. rgiDU [0] = rgiU [0]; rgiDV [0] = rgiV [0];
  156. rgiDU [1] = rgiU [1] - rgiU [0]; rgiDV [1] = rgiV [1] - rgiV [0];
  157. rgiDU [2] = rgiU [2] - rgiU [0]; rgiDV [2] = rgiV [2] - rgiV [0];
  158. rgiDU [3] = rgiU [3] - rgiU [2] - rgiU [1] + rgiU [0]; rgiDV [3] = rgiV [3] - rgiV [2] - rgiV [1] + rgiV [0];
  159. // du, dv encoding
  160. Int rgiWrpPnt0Del [2];
  161. COutBitStream* pobstrmWrpPt0 = m_pentrencSet->m_pentrencWrpPnt -> bitstream ();
  162. pobstrmWrpPt0->trace (m_rgstDstQ [0], "SPRT_Warp_Point_Q");
  163. for (j = 0; j < m_iNumOfPnts; j++) { 
  164. rgiWrpPnt0Del [0] = rgiDU [j]; //make them half pel units
  165. rgiWrpPnt0Del [1] = rgiDV [j]; //make them half pel units
  166. for (UInt iXorY = 0; iXorY < 2; iXorY++) {
  167. assert (rgiWrpPnt0Del [iXorY] >= -16383 && rgiWrpPnt0Del [iXorY] <= 16383);
  168. UInt uiAbsWrpPnt0Del = (UInt) abs (rgiWrpPnt0Del [iXorY]);
  169. Long lSz = 0;
  170. for (Int i = 14; i > 0; i--) {
  171. if (uiAbsWrpPnt0Del & (1 << (i - 1))) {
  172. lSz = i;
  173. break;
  174. }
  175. }
  176. m_pentrencSet->m_pentrencWrpPnt->encodeSymbol(lSz, "SPRT_Warp_Point"); // huffman encode 
  177.  
  178. if (rgiWrpPnt0Del [iXorY] > 0)
  179. pobstrmWrpPt0->putBits (rgiWrpPnt0Del [iXorY], lSz, "SPRT_Warp_Point_Sgn"); //fix length code
  180. else if (rgiWrpPnt0Del[iXorY] < 0)
  181. pobstrmWrpPt0->putBits (~abs(rgiWrpPnt0Del [iXorY]), lSz, "SPRT_Warp_Point_Sgn"); //fix length code
  182. pobstrmWrpPt0->putBits (MARKER_BIT, 1, "Marker_Bit");
  183. nBits += lSz + lSz + 1;
  184. }
  185. }
  186. return nBits;
  187. }
  189. //low latency stuff from now on
  190. static CRct InitPieceRect ;
  191. static CRct InitPartialRect ;
  193. // code initial sprite piece 
  194. Void CVideoObjectEncoder::encodeInitSprite (const CRct& rctOrg)
  195. {
  197. m_rctOrg =  rctOrg;
  199. if (( m_rctSpt.width < rctOrg.width)  &&    // handle the bream caption case
  200. ( m_rctSpt.height() < rctOrg.height() ) ) {
  201. m_vopmd.SpriteXmitMode = NEXT;
  202. encode (TRUE, -1, IVOP);
  203. return;
  204. }
  205. m_bSptZoom = FALSE;  // Assuming sprite is not zooming
  206. m_bSptHvPan = TRUE;  // Assuming sprite is panning horizontally
  207. m_bSptRightPiece = TRUE;  // Assuming sent right side of the sprite piece
  208. /* Int OldCount =*/ m_pbitstrmOut -> getCounter (); // used to compute average macroblock bits
  209. //  save sprite object information
  210. m_pvopcSpt =  m_pvopcOrig;
  211. m_rctSptQ =  m_pvopcSpt -> whereY ();
  213. if (m_volmd.fAUsage != RECTANGLE) {
  214. m_iPieceWidth = m_rctSptQ.width - 2 * EXPANDY_REF_FRAME;
  215. m_iPieceHeight = m_rctSptQ.height() - 2 * EXPANDY_REF_FRAME;
  216. m_rctCurrVOPY = CRct(0, 0, m_iPieceWidth, m_iPieceHeight);
  217. }
  219. // Begin: modified by Hughes   4/9/98
  220. // m_rctSptExp = m_rctCurrVOPY;  // see initialSpritePiece()
  221. // end:  modified by Hughes   4/9/98
  223. m_iNumMBX = m_rctSptExp.width / MB_SIZE; 
  224. m_iNumMBY = m_rctSptExp.height () / MB_SIZE;
  225. m_ppPieceMBstatus = new SptMBstatus* [m_iNumMBY]; 
  226. m_ppUpdateMBstatus = new SptMBstatus* [m_iNumMBY];
  227. m_rgmbmdSpt = new CMBMode* [m_iNumMBY];
  228. m_rgpmbmCurr_Spt = new MacroBlockMemory** [m_iNumMBY];
  230. // Begin: modified by Hughes   4/9/98
  231. Int iNumMB = m_iNumMBX * m_iNumMBY;
  232. m_rgmbmdSprite = new CMBMode [iNumMB];
  233. Int iMBY;
  234. // Int iMBX, iMBY;
  235. // end:  modified by Hughes   4/9/98
  237. Int iMB, iBlk;
  238. Int nBlk = (m_volmd.fAUsage == EIGHT_BIT) ? 10 : 6;
  239. for (iMBY = 0; iMBY < m_iNumMBY; iMBY++) {
  240. m_ppPieceMBstatus[iMBY] = new SptMBstatus [m_iNumMBX];
  241. m_ppUpdateMBstatus[iMBY] = new SptMBstatus [m_iNumMBX];
  242. m_rgmbmdSpt[iMBY] = new CMBMode [m_iNumMBX];
  243. m_rgpmbmCurr_Spt[iMBY] = new MacroBlockMemory* [m_iNumMBX];
  244. for (iMB = 0; iMB < m_iNumMBX; iMB++) {
  245. m_rgpmbmCurr_Spt[iMBY][iMB] = new MacroBlockMemory;
  246. m_rgpmbmCurr_Spt[iMBY][iMB]->rgblkm = new BlockMemory [nBlk];
  247. for (iBlk = 0; iBlk < nBlk; iBlk++) {
  248. (m_rgpmbmCurr_Spt[iMBY][iMB]->rgblkm) [iBlk] = new Int [(BLOCK_SIZE << 1) - 1];
  249. }
  250. // Begin: modified by Hughes   4/9/98
  251. m_ppPieceMBstatus[iMBY][iMB] = NOT_DONE;
  252. m_ppUpdateMBstatus[iMBY][iMB] = NOT_DONE;
  253. // end:  modified by Hughes   4/9/98
  254. }
  255. }
  257. // Begin: modified by Hughes   4/9/98
  258. /*
  259. CRct rctRefFrameY ;
  260. if (m_volmd.fAUsage != RECTANGLE) 
  261. {
  262. m_pvopcSptP = new CVOPU8YUVBA (*m_pvopcSpt, m_volmd.fAUsage, m_rctSptPieceY);
  263. m_rctSptPieceY = findTightBoundingBox (m_pvopcSptP);
  264. delete m_pvopcSptP;
  265. }
  266. rctRefFrameY = m_rctSptPieceY ;
  267. m_rctCurrVOPY = rctRefFrameY;
  269. m_rctSptPieceY.shift(m_rctSpt.left, m_rctSpt.top);   // absolute coordinates for VOP
  270. if ( m_sptMode == PIECE_UPDATE)
  271. m_vopmd.SpriteXmitMode  = UPDATE;
  273.   // encode initial sprite piece
  274. m_pvopcSptP = new CVOPU8YUVBA (*m_pvopcSpt, m_volmd.fAUsage, rctRefFrameY);
  275. m_rctRefFrameY = CRct (
  276. -EXPANDY_REF_FRAME, -EXPANDY_REF_FRAME, 
  277. EXPANDY_REF_FRAME + rctRefFrameY.width, 
  278. EXPANDY_REF_FRAME + rctRefFrameY.height()
  279. );
  280. m_rctRefFrameY.shift (rctRefFrameY.left, rctRefFrameY.top);
  281. m_rctRefFrameUV = m_rctRefFrameY.downSampleBy2 ();
  283. m_pvopcOrig = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctRefFrameY); 
  284. VOPOverlay (*m_pvopcSptP, *m_pvopcOrig);
  286. m_pvopcOrig->setBoundRct (rctRefFrameY);
  288. // dshu: begin of modification  
  289. delete m_pvopcRefQ0;
  290. delete m_pvopcRefQ1;
  291. // dshu: end of modification
  293. m_pvopcRefQ1 = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctRefFrameY);
  294.   m_pvopcRefQ0 = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctRefFrameY);
  295. m_iFrameWidthY = m_pvopcRefQ0->whereY ().width;
  296. m_iFrameWidthUV = m_pvopcRefQ0->whereUV ().width;
  297. m_iFrameWidthYxMBSize = MB_SIZE * m_pvopcRefQ0->whereY ().width; 
  298. m_iFrameWidthYxBlkSize = BLOCK_SIZE * m_pvopcRefQ0->whereY ().width; 
  299. m_iFrameWidthUVxBlkSize = BLOCK_SIZE * m_pvopcRefQ0->whereUV ().width;
  301. m_iPieceHeight = rctRefFrameY.height () / MB_SIZE;
  302. m_iPieceWidth= rctRefFrameY.width  / MB_SIZE;
  303. m_iPieceXoffset= (rctRefFrameY.left - m_rctSptExp.left) / MB_SIZE;
  304. m_iPieceYoffset= (rctRefFrameY.top - m_rctSptExp.top) / MB_SIZE;
  305. if (m_volmd.fAUsage == RECTANGLE) {
  306. // m_rctCurrVOPY = CRct (0, 0, iSessionWidthRound, iSessionHeightRound);
  307. m_pvopcOrig->setBoundRct (m_rctCurrVOPY);
  308. m_rctCurrVOPUV = m_rctCurrVOPY.downSampleBy2 ();
  310. m_rctRefVOPY0 = m_rctCurrVOPY;
  311. m_rctRefVOPY0.expand (EXPANDY_REFVOP);
  312. m_rctRefVOPUV0 = m_rctRefVOPY0.downSampleBy2 ();
  314. m_rctRefVOPY1 = m_rctRefVOPY0;
  315. m_rctRefVOPUV1 = m_rctRefVOPUV0;
  317. m_rctRefVOPZoom0 = m_rctRefVOPY0.upSampleBy2 ();
  318. m_rctRefVOPZoom1 = m_rctRefVOPY1.upSampleBy2 ();
  319. m_pvopcRefOrig0->setBoundRct (m_rctRefVOPY0);
  320. m_pvopcRefOrig1->setBoundRct (m_rctRefVOPY1);
  321. computeVOLConstMembers (); // these VOP members are the same for all frames
  322. }
  324. m_tPiece = -1;
  325. encode (TRUE, -1, IVOP);
  327. m_pvopcSptQ = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctSptQ);  
  328. VOPOverlay(*m_pvopcRefQ1, *m_pvopcSptQ, 1);
  329.   delete m_pvopcSptP;   m_pvopcSptP = NULL;  
  330. delete m_pvopcOrig;   m_pvopcOrig  = NULL;
  331. delete m_pvopcRefQ0; m_pvopcRefQ0 = NULL;
  332. delete m_pvopcRefQ1;
  334. m_pvopcRefQ1 =  m_pvopcSptQ ; // to support "rgpvoenc [BASE_LAYER] -> swapRefQ1toSpt (); "
  336. m_iNumMBX = m_rctSptExp.width / MB_SIZE; 
  337. m_iNumMBY = m_rctSptExp.height () / MB_SIZE;
  339. CMBMode* pmbmd = m_rgmbmdRef;
  340. IntraPredDirection* Spreddir;
  341. IntraPredDirection* preddir;
  342. // initialize  MB hole status array
  343. Int iMB_left = (rctRefFrameY.left - m_rctSptExp.left) / MB_SIZE;
  344. Int iMB_right = (rctRefFrameY.right - m_rctSptExp.left) / MB_SIZE;  
  345. Int iMB_top = (rctRefFrameY.top - m_rctSptExp.top) / MB_SIZE;
  346. Int iMB_bottom = (rctRefFrameY.bottom - m_rctSptExp.top) / MB_SIZE;
  347. for (iMBY = 0; iMBY < m_iNumMBY; iMBY++) 
  348. for (iMBX = 0; iMBX < m_iNumMBX; iMBX++) {
  349. if ((iMBX >= iMB_left && iMBX < iMB_right) && (iMBY >= iMB_top && iMBY < iMB_bottom)) 
  350. {
  351. m_ppPieceMBstatus[iMBY][iMBX] = PIECE_DONE;
  352. m_rgmbmdSpt[iMBY][iMBX] = CMBMode (*pmbmd);
  353. Spreddir = m_rgmbmdSpt[iMBY][iMBX].m_preddir;
  354. preddir = (*pmbmd).m_preddir;
  355. memcpy (Spreddir, preddir, 10  * sizeof (IntraPredDirection));
  356. pmbmd++;
  357. }
  358. else
  359. m_ppPieceMBstatus[iMBY][iMBX] = NOT_DONE;
  360. m_ppUpdateMBstatus[iMBY][iMBX] = NOT_DONE;
  361. }
  362. Int Curr = (m_pbitstrmOut -> getCounter ()) - OldCount;
  363. Int Num_MB = (iMB_right-iMB_left) * (iMB_bottom-iMB_top);
  364. m_pSptmbBits[AVGPIECEMB] = Curr / Num_MB; // average macroblock bits used by a sprite piece
  366. InitPieceRect = rctRefFrameY; 
  367. InitPartialRect = InitPieceRect; 
  368. m_rctPieceQ = InitPieceRect;
  369. */
  370. #ifdef __TRACE_AND_STATS_
  371. m_pbitstrmOut -> trace (-1, "VOP_Time");
  372. #endif // __TRACE_AND_STATS_
  373. m_rctPieceQ = CRct ( m_rctSptPieceY.left, m_rctSptPieceY.top, m_rctSptPieceY.left, m_rctSptPieceY.top);
  374. m_pvopcSptQ = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctSptQ);  
  375. m_pvopcRefQ1 =  m_pvopcSptQ ; // to support "rgpvoenc [BASE_LAYER] -> swapRefQ1toSpt (); "
  376. m_pbitstrmOut->reset (); // inserted as a result of half day debug
  377. // end:  modified by Hughes   4/9/98
  379. m_tPiece = m_nFirstFrame;
  380. m_tUpdate = m_nFirstFrame;
  381. m_vopmd.SpriteXmitMode = PIECE;
  382. if ( m_sptMode == BASIC_SPRITE)
  383. m_vopmd.SpriteXmitMode  = NEXT;
  384. }
  386. Void CVideoObjectEncoder::initialSpritePiece (Int iSessionWidth, Int iSessionHeight)
  387. {
  388. // identify initial sprite piece
  389. CRct rctRefFrameY, rct ;
  390. Bool SpriteObject =  (m_sptMode == PIECE_UPDATE) || ( m_sptMode == BASIC_SPRITE);
  392. // Begin: modified by Hughes   4/9/98
  393. m_rctSptExp = CRct (0, 0, iSessionWidth, iSessionHeight);  // m_rctSptExp is specified in relative coordinate
  394. // end:  modified by Hughes   4/9/98
  396. if (!SpriteObject) 
  397. {
  398. if (m_iNumOfPnts == 0) 
  399. rct =  CRct (0, 0, iSessionWidth, iSessionHeight);
  400. else
  401. rct = InitialPieceRect (0);
  402. rctRefFrameY = CRct (rct.left, rct.top, rct.right, (rct.bottom + 16 - rct.height()/2));    //dshu: 12/22/97
  403. // rctRefFrameY = CRct (rct.left, rct.top, rct.right, (rct.bottom - rct.width/2));  
  404. }
  405. else
  406. rctRefFrameY = CRct (0, 0, iSessionWidth, iSessionHeight);
  407. if (!SpriteObject)
  408. rctRefFrameY =  PieceExpand (rctRefFrameY);
  409. m_rctSptPieceY =  rctRefFrameY;
  410. }
  412. CRct CVideoObjectEncoder::InitialPieceRect (Time ts)
  413. {
  414. CRct rctSpt, rctSptQ;
  415. CSiteD rgstSrcQ [4];
  416. rgstSrcQ [0] = CSiteD (m_rctOrg.left, m_rctOrg.top);
  417. rgstSrcQ [1] = CSiteD (m_rctOrg.right, m_rctOrg.top);
  418. rgstSrcQ [2] = CSiteD (m_rctOrg.left, m_rctOrg.bottom);
  419. rgstSrcQ [3] = CSiteD (m_rctOrg.right, m_rctOrg.bottom);
  421. for (Int i = 0; i < m_iNumOfPnts; i++) {
  422. // quantization rgstSrc
  423. CoordD x = rgstSrcQ [i].x, y = rgstSrcQ [i].y;
  424. Int rnd = (x > 0) ? (Int) (2.0 * x + .5) : (Int) (2.0 * x - .5);
  425. m_rgstSrcQ [i].x = (CoordD) rnd / (CoordD) 2.;
  426. rnd = (y > 0) ? (Int) (2.0 * y + .5) : (Int) (2.0 * y - .5);
  427. m_rgstSrcQ [i].y = (CoordD) rnd / (CoordD) 2.;
  428. }
  429.    
  430. rctSptQ = CornerWarp (m_pprgstDest[ts], m_rgstSrcQ); 
  431. rctSpt = CRct (rctSptQ.left, 0, rctSptQ.right, m_rctSpt.height());  
  432. return rctSpt;
  433. }
  435. CRct CVideoObjectEncoder::CornerWarp (const CSiteD* rgstDst, 
  436.   const CSiteD* rgstSrcQ)
  437. {
  438. CSiteD stdLeftTopWarp, stdRightTopWarp, stdLeftBottomWarp, stdRightBottomWarp;
  439. CPerspective2D persp (m_iNumOfPnts, rgstSrcQ, rgstDst, m_uiWarpingAccuracy);
  440. stdLeftTopWarp = (persp * CSiteD (0, 0)).s;
  441. stdRightTopWarp = (persp * CSiteD (m_rctOrg.width, 0)).s;
  442. stdLeftBottomWarp = (persp * CSiteD (0, m_rctOrg.height())).s;
  443. stdRightBottomWarp = (persp * CSiteD (m_rctOrg.width, m_rctOrg.height())).s;
  445. CRct rctWarp (stdLeftTopWarp, stdRightTopWarp, stdLeftBottomWarp, stdRightBottomWarp);
  446. UInt accuracy1 = 1 << (m_uiWarpingAccuracy + 1);
  447. rctWarp =  rctWarp / accuracy1 ; 
  448. rctWarp.shift(-m_rctSpt.left, -m_rctSpt.top);  // rectangle is w.r.t. UL corner of sprite object
  450. return rctWarp;
  451. }
  453. Void CVideoObjectEncoder::encodeSpritePiece (Time t)
  454. // code sprite pieces 
  455. {
  456. if (m_vopmd.SpriteXmitMode  == STOP)
  457. return ;
  458. if ((m_vopmd.SpriteXmitMode  == PIECE) || (m_vopmd.SpriteXmitMode  == UPDATE)){
  459. m_pvopcSptQ -> shift(-m_rctSpt.left, -m_rctSpt.top); // prepare m_pvopcSptQ to merge new piece
  460. UInt uiF = t + m_volmd.iTemporalRate;
  461. uiF = ( uiF >  m_nLastFrame) ?  m_nLastFrame :  uiF;
  462. UInt uiSptPieceSize = m_iBufferSize/(300/m_volmd.iTemporalRate);
  463. CRct rct = m_rctPieceQ;
  464. if (( m_sptMode != PIECE_UPDATE) && (m_tPiece == (Time) m_nFirstFrame))
  465. {
  466. // Begin: modified by Hughes   4/9/98
  467. InitPieceRect = encPiece (m_rctSptPieceY);
  468. rct = InitPieceRect;
  469. // End: modified by Hughes   4/9/98
  470. rct = CRct (rct.left, (rct.top - 3*MB_SIZE + m_rctSpt.height()/2), rct.right, m_rctSpt.height()); // dshu: 1/4/98  
  471. InitPartialRect = encPiece (rct);
  473. m_vopmd.SpriteXmitMode = UPDATE;
  474. m_rctUpdateQ = CRct ( rct.left, rct.top, rct.left, rct.bottom);
  475. CRct rcttemp = encPiece (rct);
  476. rcttemp = encPiece (CRct ( rct.left, m_rctPieceQ.top, rct.right, rct.top));
  477. m_vopmd.SpriteXmitMode = PIECE;
  478. m_tPiece =  uiF;
  480. if (m_iNumOfPnts == 0)
  481. m_vopmd.SpriteXmitMode  = NEXT; 
  482. }
  483. else  {
  484. if (( InitPartialRect.right >= InitPieceRect.right) &&
  485. ( InitPartialRect.left <= InitPieceRect.left))  {
  486. CRct rctSptQ = ZoomOrPan ();
  487. encSptPiece (rctSptQ, uiSptPieceSize);
  488. while ((m_tPiece < (Time) uiF) &&
  489. (m_vopmd.SpriteXmitMode  == PIECE) )
  490. encSptPiece (ZoomOrPan (), uiSptPieceSize);
  491. }
  492. else {
  493. m_bSptRightPiece = TRUE;
  494. encSptPiece (m_rctUpdateQ, uiSptPieceSize);
  495. InitPartialRect = m_rctUpdateQ;
  496. }
  497. Bool StartUpdate = (m_tPiece >= (Time) m_nLastFrame) 
  498. && (m_tUpdate == (Time) m_nFirstFrame);
  499. if ( StartUpdate ) {
  500. m_vopmd.SpriteXmitMode  = UPDATE;
  501. if(( t < (Time) m_nLastFrame) && (m_sptMode != PIECE_OBJECT)) {
  502. // identify initial update piece
  503. rct = InitialPieceRect (t-m_nFirstFrame);
  504. Int left = (rct.left < m_rctSptExp.left) ?  m_rctSptExp.left : rct.left;
  505. Int right = (rct.right > m_rctSptExp.right) ?  m_rctSptExp.right : rct.right;
  506. InitPieceRect = CRct (left, rct.top, right, rct.bottom);
  507. rct = InitPieceRect ;
  508. if (m_sptMode == PIECE_UPDATE) {
  509. cout << "t" << "n start sending updates for sprite..."  << "n";
  510. cout.flush ();
  511. m_tUpdate = -1;
  512. m_rctUpdateQ = CRct ( left, rct.top, left, rct.bottom);
  513. m_pSptmbBits[AVGUPDATEMB] = m_pSptmbBits[AVGUPDATEMB] ;
  514. rct = PieceSize (TRUE, uiSptPieceSize);
  515. }
  516. rct = encPiece (rct);
  517. InitPartialRect = m_rctUpdateQ;
  518. m_tUpdate = t;
  519. }
  520. else 
  521. m_vopmd.SpriteXmitMode = NEXT;
  522. }
  523. }
  524. m_pvopcSptQ -> shift(m_rctSpt.left, m_rctSpt.top);  // prepare m_pvopcSptQ for warping
  525. m_vopmd.vopPredType = SPRITE;
  526. // --- begin of bug fix (David Shu)
  527. if (m_volmd.fAUsage != RECTANGLE)
  528. {
  529. CRct r1 =  m_rctSptQ;
  530. m_rctSptQ = m_rctSptExp;
  531. m_rctCurrVOPY  = CRct(0,0, m_rctSptQ.width, m_rctSptQ.height());
  532. m_rctCurrVOPUV = m_rctCurrVOPY.downSampleBy2 ();
  533. m_rctRefFrameY = CRct (-EXPANDY_REF_FRAME, -EXPANDY_REF_FRAME,
  534. EXPANDY_REF_FRAME + m_rctSptQ.width, EXPANDY_REF_FRAME + m_rctSptQ.height());
  535. m_rctRefFrameUV = m_rctRefFrameY.downSampleBy2 ();
  536. setRefStartingPointers ();
  537. m_iFrameWidthY = m_rctRefFrameY.width;
  538. m_iFrameWidthUV = m_rctRefFrameUV.width;
  539. m_iFrameWidthYxMBSize = MB_SIZE * m_iFrameWidthY;
  540. m_iFrameWidthYxBlkSize = BLOCK_SIZE * m_iFrameWidthY;
  541. m_iFrameWidthUVxBlkSize = BLOCK_SIZE * m_iFrameWidthUV;
  542. m_iOffsetForPadY = m_rctRefFrameY.offset (m_rctCurrVOPY.left, m_rctCurrVOPY.top);
  543. m_iOffsetForPadUV = m_rctRefFrameUV.offset (m_rctCurrVOPUV.left,m_rctCurrVOPUV.top);
  544. padSprite() ;  //    final padding just before warping
  546. m_rctSptQ = r1;
  547. }
  548. // --- end of bug fix
  549. }
  551. if (m_vopmd.SpriteXmitMode  != STOP){
  552. SptXmitMode  PieceXmitMode = m_vopmd.SpriteXmitMode;
  553. if (m_vopmd.SpriteXmitMode  == NEXT )
  554. {
  555. PieceXmitMode = STOP ;
  556. m_vopmd.SpriteXmitMode  = STOP;
  557. m_iNumMBX = m_rctSptExp.width / MB_SIZE; 
  558. m_iNumMBY = m_rctSptExp.height () / MB_SIZE;
  559. Int nBlk = (m_volmd.fAUsage == EIGHT_BIT) ? 10 : 6;
  560. for (Int iMBY = 0; iMBY < m_iNumMBY; iMBY++){
  561. for (Int iMB = 0; iMB < m_iNumMBX; iMB++) {
  562. for (Int iBlk = 0; iBlk < nBlk; iBlk++)
  563. delete [] (m_rgpmbmCurr_Spt[iMBY][iMB]->rgblkm) [iBlk];
  565. delete [] m_rgpmbmCurr_Spt [iMBY][iMB]->rgblkm;
  566. delete [] m_rgpmbmCurr_Spt [iMBY][iMB];
  567. }
  568. delete [] m_ppPieceMBstatus[iMBY] ; 
  569. delete [] m_ppUpdateMBstatus[iMBY] ;  
  570. delete [] m_rgmbmdSpt[iMBY] ;
  571. delete [] m_rgpmbmCurr_Spt[iMBY];
  572. }
  573. delete [] m_ppPieceMBstatus ; 
  574. delete [] m_ppUpdateMBstatus ;  
  575. delete [] m_rgmbmdSpt ;
  576. delete [] m_rgpmbmCurr_Spt;
  577. // Begin: modified by Hughes   4/9/98
  578. delete [] m_rgmbmdSprite ;    
  579. // end:  modified by Hughes   4/9/98
  580. }
  581. else
  582. m_vopmd.SpriteXmitMode  = PAUSE;
  583. codeVOSHead ();
  584. if (m_vopmd.SpriteXmitMode  != STOP)
  585. m_vopmd.SpriteXmitMode  = PieceXmitMode;
  587. }
  588. }
  590. Void CVideoObjectEncoder::encSptPiece (CRct rctSptQ, UInt uiSptPieceSize)
  591. {
  592. UInt uiTR = m_volmd.iTemporalRate;
  593. CRct rctSpt = (m_vopmd.SpriteXmitMode == PIECE ) ? m_rctPieceQ : m_rctUpdateQ ; 
  594. CRct rctSptQNew = rctSpt;
  595. CRct rctPiece = PieceSize (m_bSptRightPiece, uiSptPieceSize);
  596. rctSpt.include(rctPiece);
  598. UInt uiF = (m_vopmd.SpriteXmitMode == PIECE ) ? m_tPiece : m_tUpdate;
  599. UInt boundary = m_nLastFrame ;
  600. if ( rctSptQ.valid() && (rctSptQNew != m_rctSptExp)) {
  601. rctSptQ = rctSpt;
  602. uiF += uiTR ;  
  603. while ((rctSptQNew.right <= rctSptQ.right) && (rctSptQNew.left >= rctSptQ.left) 
  604. && (uiF <= boundary)) {
  605. CRct rctWarpNew = CornerWarp (m_pprgstDest[uiF- m_nFirstFrame], m_rgstSrcQ);
  606. if (rctWarpNew.left < m_rctSptExp.left) rctWarpNew.left = m_rctSptExp.left;
  607. if (rctWarpNew.right > m_rctSptExp.right) rctWarpNew.right = m_rctSptExp.right;
  608. rctSptQNew.include (rctWarpNew);
  609. uiF = ((rctSptQNew.right <= rctSptQ.right) && (rctSptQNew.left >= rctSptQ.left))
  610. ? (uiF + uiTR) : (uiF - uiTR);
  611. }
  612. Int left = (rctPiece.left < rctSptQNew.left) ?  rctSptQNew.left :  rctPiece.left;
  613. Int right = (rctPiece.right > rctSptQNew.right) ?  rctSptQNew.right :  rctPiece.right;
  614. if ((right-MB_SIZE) > left)
  615. rctSpt = encPiece (CRct (left, m_rctSptExp.top, right, m_rctSptExp.bottom));
  616. }
  617. else {
  618. uiF = boundary;
  619. }
  620. if (uiF  > boundary)
  621. uiF = boundary;
  623. if (m_vopmd.SpriteXmitMode == PIECE )
  624. m_tPiece = uiF;
  625. if (m_vopmd.SpriteXmitMode == UPDATE ) 
  626. m_tUpdate = uiF;
  628. if (uiF  >= boundary) {
  629. if (( m_sptMode == PIECE_OBJECT) || m_vopmd.SpriteXmitMode == UPDATE )
  630. m_vopmd.SpriteXmitMode = NEXT;
  631. }
  632. }
  634. CRct CVideoObjectEncoder::PieceSize (Bool rightpiece, UInt uiSptPieceSize)
  635. {
  637. Int right, left;
  639. CRct rctSptQ = (m_vopmd.SpriteXmitMode == PIECE ) ? m_rctPieceQ : m_rctUpdateQ ; 
  640. Int AvgBitsMb = (m_vopmd.SpriteXmitMode == PIECE ) ? m_pSptmbBits [AVGUPDATEMB] : m_pSptmbBits[AVGUPDATEMB];
  641. assert (AvgBitsMb != 0);
  643. m_iPieceHeight = (MB_SIZE-1 + m_rctPieceQ.height ()) / MB_SIZE;
  644. m_iPieceWidth= (Int) (0.5 + uiSptPieceSize/(AvgBitsMb * m_iPieceHeight));
  646. m_iPieceWidth= (m_iPieceWidth<2)? 2 : m_iPieceWidth;
  648. if (rightpiece) {
  649. right = rctSptQ.right + MB_SIZE * m_iPieceWidth;
  650. if (right > m_rctSptExp.right) {
  651. right = m_rctSptExp.right;
  652. }
  653. if ((m_vopmd.SpriteXmitMode == UPDATE ) && (right > m_rctPieceQ.right)) {
  654. right = m_rctPieceQ.right;
  655. }
  656. left = rctSptQ.right;
  657. }
  658. else  {
  659. left = rctSptQ.left - MB_SIZE* m_iPieceWidth;
  660. if (left < m_rctSptExp.left) {
  661. left = m_rctSptExp.left ;
  662. }
  663. if ((m_vopmd.SpriteXmitMode == UPDATE ) && (left < m_rctPieceQ.left)) {
  664. left = m_rctPieceQ.left ;
  665. }
  666. right = rctSptQ.left;
  667. }
  668. CRct rctSptPieceY = CRct (left, m_rctSptExp.top, right, m_rctSptExp.bottom);
  669. if ((m_tUpdate > (Time) m_nFirstFrame) || (m_vopmd.SpriteXmitMode == PIECE )) 
  670. if (rightpiece) {
  671. if (left > (m_rctSptExp.left+MB_SIZE))
  672. {
  673. left -=  MB_SIZE;
  674. rctSptPieceY = CRct (left, rctSptPieceY.top, rctSptPieceY.right, rctSptPieceY.bottom);
  675. }
  676. }
  677. else{
  678. if (right < (m_rctSptExp.right - MB_SIZE))
  679. {
  680. right +=  MB_SIZE;
  681. rctSptPieceY = CRct (rctSptPieceY.left, rctSptPieceY.top, right, rctSptPieceY.bottom);
  682. }
  683. }
  684. return rctSptPieceY;
  685. }
  687. CRct CVideoObjectEncoder::encPiece (CRct rctpiece)
  688. {
  689. Time ts;
  690. //Int right = rctpiece.right; 
  691. //Int left = rctpiece.left;
  692. CRct rctSpt = (m_vopmd.SpriteXmitMode == PIECE ) ? m_rctPieceQ : m_rctUpdateQ ; 
  694. CRct rctSptPieceY = PieceExpand (rctpiece);
  695. // m_rctSptPieceY = rctSptPieceY;
  696. // m_rctSptPieceY.shift(m_rctSpt.left, m_rctSpt.top);
  698. if (m_volmd.fAUsage == RECTANGLE) {
  699. m_rctCurrVOPY = rctSptPieceY;
  700. m_rctCurrVOPUV = m_rctCurrVOPY.downSampleBy2 ();
  701. }
  703. m_iPieceWidth= rctSptPieceY.width / MB_SIZE;
  704. m_iPieceHeight= rctSptPieceY.height () / MB_SIZE;
  706. m_iPieceXoffset= (rctSptPieceY.left - m_rctSptExp.left) / MB_SIZE;
  707. m_iPieceYoffset= (rctSptPieceY.top - m_rctSptExp.top) / MB_SIZE;
  708. rctSpt.include(rctSptPieceY);
  709. codeVOSHead ();
  711. Int OldCount = m_pbitstrmOut -> getCounter ();
  713.   // encode sprite piece
  714. m_pvopcSptP = new CVOPU8YUVBA (*m_pvopcSpt, m_volmd.fAUsage, rctSptPieceY);
  715. m_pvopcSptP -> shift (-rctSptPieceY.left, -rctSptPieceY.top);
  716. CRct rctRefFrameY = m_pvopcSptP -> whereY() ;
  717. m_rctCurrVOPY = CRct (0, 0, rctRefFrameY.width, rctRefFrameY.height());
  718. m_rctCurrVOPUV = m_rctCurrVOPY.downSampleBy2 ();
  720. m_rctRefFrameY = CRct (
  721. -EXPANDY_REF_FRAME, -EXPANDY_REF_FRAME, 
  722. EXPANDY_REF_FRAME + rctRefFrameY.width, EXPANDY_REF_FRAME + rctRefFrameY.height()
  723. );
  724. m_rctRefFrameUV = m_rctRefFrameY.downSampleBy2 ();
  725. m_pvopcOrig = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctRefFrameY); 
  726. VOPOverlay (*m_pvopcSptP, *m_pvopcOrig);
  728. m_pvopcOrig->setBoundRct (m_rctCurrVOPY);
  730. m_pvopcRefQ1 = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctRefFrameY);
  731. delete m_pvopcSptP;
  732. m_pvopcSptP = new CVOPU8YUVBA (*m_pvopcSptQ, m_volmd.fAUsage, rctSptPieceY);  // extract reference
  733. m_pvopcSptP -> shift (-rctSptPieceY.left, -rctSptPieceY.top);
  734. VOPOverlay (*m_pvopcSptP, *m_pvopcRefQ1);
  736. if (m_vopmd.SpriteXmitMode == PIECE ) {
  737. m_rctPieceQ = rctSpt;
  738. ts = m_tPiece;
  739. m_vopmd.vopPredType = IVOP;
  740. }
  741. else {
  742. m_rctUpdateQ = rctSpt;
  743. ts = m_tUpdate;
  744. m_vopmd.vopPredType = PVOP;
  745. }
  747.   m_pvopcRefQ0 = new CVOPU8YUVBA (m_volmd.fAUsage, m_rctRefFrameY);
  748. m_iFrameWidthY = m_pvopcRefQ0->whereY ().width;
  749. m_iFrameWidthUV = m_pvopcRefQ0->whereUV ().width;
  750. m_iFrameWidthYxMBSize = MB_SIZE * m_pvopcRefQ0->whereY ().width; 
  751. m_iFrameWidthYxBlkSize = BLOCK_SIZE * m_pvopcRefQ0->whereY ().width; 
  752. m_iFrameWidthUVxBlkSize = BLOCK_SIZE * m_pvopcRefQ0->whereUV ().width;
  754. encode (TRUE, ts, m_vopmd.vopPredType);
  755. // encode (TRUE, ts, m_vopmd.SpriteXmitMode);
  757. m_pvopcRefQ1 -> shift (rctSptPieceY.left, rctSptPieceY.top);  
  758. VOPOverlay (*m_pvopcRefQ1, *m_pvopcSptQ, 1);
  759. delete m_pvopcSptP;
  760. delete m_pvopcOrig;  m_pvopcOrig = NULL ;
  761. delete m_pvopcRefQ0; m_pvopcRefQ0 = NULL ;
  762. delete m_pvopcRefQ1; m_pvopcRefQ1 = NULL ;
  763.   if (m_iNumOfPnts == 0) {
  764. m_pvopcRefQ1 = m_pvopcSptQ;   // to avoid "rgpvoenc [BASE_LAYER] -> swapRefQ1toSpt (); "
  765. }
  767. Int Curr = (m_pbitstrmOut -> getCounter ()) - OldCount;
  768. if (m_iNumSptMB > 0) {
  769. if (m_vopmd.SpriteXmitMode == PIECE ) 
  770. m_pSptmbBits[AVGPIECEMB] = Curr / m_iNumSptMB; // average macroblock bits used by a sprite piece
  771. if (m_vopmd.SpriteXmitMode == UPDATE ) 
  772. m_pSptmbBits[AVGUPDATEMB] = Curr / m_iNumSptMB; // average macroblock bits used by a sprite piece 
  773. }
  774. return rctSpt;
  775. }
  776. CRct CVideoObjectEncoder::ZoomOrPan ()
  777. {
  778. CRct rctWarpNew ;
  779. CRct rctWarpOld ;
  780. UInt uiTR = m_volmd.iTemporalRate;
  781. UInt uiF = (m_vopmd.SpriteXmitMode == PIECE ) ? m_tPiece : m_tUpdate;
  782. UInt boundary = m_nLastFrame ;
  784. if (uiF >= boundary)
  785. return rctWarpNew;
  787. rctWarpNew = CornerWarp (m_pprgstDest[uiF- m_nFirstFrame], m_rgstSrcQ);
  788. rctWarpOld = rctWarpNew;
  789. // determine if sprite is zooming or panning?
  790. while (rctWarpNew == rctWarpOld) {
  791. uiF += uiTR ;
  792. rctWarpNew = CornerWarp (m_pprgstDest[uiF- m_nFirstFrame], m_rgstSrcQ);
  793. }
  794. if ((rctWarpNew.right > rctWarpOld.right) && (rctWarpNew.left < rctWarpOld.left))
  795. m_bSptZoom = TRUE;  // sprite is zooming
  796. else {
  797. m_bSptZoom = FALSE ;  // sprite is panning  
  798. if (rctWarpNew.left < rctWarpOld.left)
  799. m_bSptRightPiece = FALSE;  // sprite is panning to the left
  800. else
  801. m_bSptRightPiece = TRUE;  // sprite is panning to the right
  802. }
  803. rctWarpNew.include (rctWarpOld);
  804. return rctWarpNew;
  805. }
  807. Void CVideoObjectEncoder::codeVOSHead ()   
  808. {
  809. m_pbitstrmOut -> putBits (m_vopmd.SpriteXmitMode, NUMBITS_SPRITE_XMIT_MODE, "Sprite_TRANSMIT_MODE");
  810. if (( m_vopmd.SpriteXmitMode != STOP) &&( m_vopmd.SpriteXmitMode != PAUSE)) {
  811. // Sprite piece overhead code
  812.   //static UInt uiNumBitsStart = 4* NUMBITS_SPRITE_MB_OFFSET + NUMBITS_SPRITE_XMIT_MODE + NUMBITS_VOP_QUANTIZER;
  813. Int stepToBeCoded = (m_vopmd.SpriteXmitMode == UPDATE) ? m_vopmd.intStep : m_vopmd.intStepI;
  814. m_pbitstrmOut -> putBits (stepToBeCoded, NUMBITS_VOP_QUANTIZER, "sprite_Piece_Quantier");
  815. m_pbitstrmOut -> putBits (m_iPieceWidth, (UInt) NUMBITS_SPRITE_MB_OFFSET, "sprite_Piece_width"); //plus 9 bits
  816. m_pbitstrmOut -> putBits (m_iPieceHeight, (UInt) NUMBITS_SPRITE_MB_OFFSET, "sprite_Piece_height"); //plus 9 bits
  817. // Begin: modified by Hughes   4/9/98
  818. m_pbitstrmOut -> putBits (MARKER_BIT, MARKER_BIT, "Marker_Bit");
  819. // End: modified by Hughes   4/9/98
  820. m_pbitstrmOut -> putBits (m_iPieceXoffset, (UInt) NUMBITS_SPRITE_MB_OFFSET, "sprite_Piece_Xoffset"); //plus 9 bits
  821. m_pbitstrmOut -> putBits (m_iPieceYoffset, (UInt) NUMBITS_SPRITE_MB_OFFSET, "sprite_Piece_Yoffset"); //plus 9 bits
  822. }
  823. }
  825. CRct CVideoObjectEncoder::findTightBoundingBox (CVOPU8YUVBA* vopuc)
  826. {
  827. const CRct& rctOrig =  vopuc -> whereY ();
  828. CoordI left = rctOrig.right - 1;
  829. CoordI top = rctOrig.bottom - 1;
  830. CoordI right = rctOrig.left;
  831. CoordI bottom = rctOrig.top;
  832. const PixelC* ppxlcBY = vopuc->pixelsBY ();
  833. for (CoordI y = rctOrig.top; y < rctOrig.bottom; y++) {
  834. for (CoordI x = rctOrig.left; x < rctOrig.right; x++) {
  835. if (*ppxlcBY != transpValue) {
  836. left = min (left, x);
  837. top = min (top, y);
  838. right = max (right, x);
  839. bottom = max (bottom, y);
  840. }
  841. ppxlcBY++;
  842. }
  843. }
  844. right++;
  845. bottom++;
  846. if (left % 2 != 0)
  847. left--;
  848. if (top % 2 != 0)
  849. top--;
  851. return PieceExpand (CRct (left, top, right, bottom));
  852. }
  854. //  extend the rctOrg size to multiples of MBSize w.r.t. m_rctSptExp 
  855. CRct CVideoObjectEncoder::PieceExpand (const CRct& rctOrg)
  856. {
  857. // Begin: modified by Hughes   4/9/98
  858. // Int left = rctOrg.left ;
  859. // Int right = rctOrg.right ;
  860. // Int top = rctOrg.top ;
  861. // Int bottom = rctOrg.bottom ;
  863. Int left = (rctOrg.left < m_rctSptExp.left) ? m_rctSptExp.left : rctOrg.left;
  864. Int right = (rctOrg.right > m_rctSptExp.right) ? m_rctSptExp.right : rctOrg.right;
  865. Int top = (rctOrg.top < m_rctSptExp.top) ? m_rctSptExp.top : rctOrg.top;
  866. Int bottom = (rctOrg.bottom > m_rctSptExp.bottom) ? m_rctSptExp.bottom : rctOrg.bottom;
  867. // End: modified by Hughes   4/9/98
  869. Int iMod = (left - m_rctSptExp.left) % MB_SIZE;
  870. if (iMod > 0)
  871. left -= iMod;
  872. iMod = (right - left) % MB_SIZE;
  873. if (iMod > 0)
  874. right += MB_SIZE - iMod;
  875. iMod = (top - m_rctSptExp.top) % MB_SIZE;
  876. if (iMod > 0)
  877. top -= iMod;
  878. iMod = (bottom - top) % MB_SIZE;
  879. if (iMod > 0)
  880. bottom += MB_SIZE - iMod;
  881. // for update pieces, skip the entire row of MBs if the cooresponding object piece if missing
  882. if (m_vopmd.SpriteXmitMode == UPDATE) {
  883. Int iMBX, iMBX_left, iMBX_right ;
  884. Int iMBY, iMBY_top, iMBY_bottom ;
  885. iMBX_left =  (left - m_rctSptExp.left) / MB_SIZE;
  886. iMBX_right =  (right - m_rctSptExp.left) / MB_SIZE;
  887. iMBY_top =  (top - m_rctSptExp.top) / MB_SIZE;
  888. iMBY_bottom =  (bottom - m_rctSptExp.top) / MB_SIZE;
  889. for (iMBY = iMBY_top; iMBY < iMBY_bottom; iMBY++) {
  890. for (iMBX = iMBX_left; iMBX < iMBX_right; iMBX++) {
  891. if ( m_ppPieceMBstatus[iMBY][iMBX] != PIECE_DONE) {
  892. top = top  +  MB_SIZE;
  893. break;
  894. }
  895. }
  896. }
  897. for (iMBY = iMBY_bottom-1; iMBY > iMBY_top; iMBY--) {
  898. for (iMBX = iMBX_left; iMBX < iMBX_right; iMBX++) {
  899. if ( m_ppPieceMBstatus[iMBY][iMBX] != PIECE_DONE) {
  900. bottom = bottom  -  MB_SIZE;
  901. break;
  902. }
  903. }
  904. }
  905. }
  907. return CRct(left, top, right, bottom);
  908. }