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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

vopses.hpp：源码内容
  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. (date: March, 1996)
  10. and edited by
  11.         Wei Wu (weiwu@stallion.risc.rockwell.com) Rockwell Science Center
  13. and also edited by
  14. Yoshihiro Kikuchi (TOSHIBA CORPORATION)
  15. Takeshi Nagai (TOSHIBA CORPORATION)
  16. Toshiaki Watanabe (TOSHIBA CORPORATION)
  17. Noboru Yamaguchi (TOSHIBA CORPORATION)
  19. and edited by Xuemin Chen (General Instrument Corp.)
  21. in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
  22. This software module is an implementation of a part of one or more MPEG-4 Video tools 
  23. as specified by the MPEG-4 Video. 
  24. ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
  25. thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
  26. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
  27. The original developer of this software module and his/her company, 
  28. the subsequent editors and their companies, 
  29. and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
  30. Copyright is not released for non MPEG-4 Video conforming products. 
  31. Microsoft retains full right to use the code for his/her own purpose, 
  32. assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
  33. This copyright notice must be included in all copies or derivative works. 
  35. Copyright (c) 1996, 1997.
  37. Module Name:
  39. vopSes.hpp
  41. Abstract:
  43. Base class for the encoder for one Video Object.
  45. Revision History:
  46.     December 20, 1997   Interlaced tools added by General Instrument Corp.(GI)
  47.                         X. Chen (xchen@gi.com), B. Eifrig (beifrig@gi.com)
  48.         May. 9   1998:  add boundary by Hyundai Electronics 
  49.                                   Cheol-Soo Park (cspark@super5.hyundai.co.kr) 
  50.         May. 9   1998:  add field based MC padding by Hyundai Electronics 
  51.                                   Cheol-Soo Park (cspark@super5.hyundai.co.kr) 
  52. *************************************************************************/
  54. #ifndef __VOPSES_HPP_ 
  55. #define __VOPSES_HPP_
  57. typedef enum {NOT_DONE, PIECE_DONE, UPDATE_DONE} SptMBstatus;
  59. #define BlockMemory Int*
  60. typedef struct MacroBlockMemory {
  61. BlockMemory* rgblkm;
  62. } MacroBlockMemory;
  64. Class ArCodec;
  66. Class CInvBlockDCT;
  68. Class CVideoObject
  69. {
  70. public:
  71. // Constructors
  72. virtual ~CVideoObject ();
  73. CVideoObject ();
  75. // Attributes
  76. const CVOPU8YUVBA* pvopcQuantCurr () const {return m_pvopcCurrQ;}
  77. const CVOPU8YUVBA* pvopcRefQPrev () const {return m_pvopcRefQ0;}
  78. const CVOPU8YUVBA* pvopcRefQLater () const {return m_pvopcRefQ1;}
  79. //This modification is for reconstructed BVOP image in SS coding should be used as refrence layer 
  80. const CVOPU8YUVBA* pvopcReconCurr () const; 
  81. // {return   ((m_vopmd.vopPredType == BVOP && m_volmd.volType == BASE_LAYER) 
  82. //  ||(m_vopmd.vopPredType == BVOP && m_vopmd.iRefSelectCode != 0)
  83. //  ||(m_vopmd.vopPredType == SPRITE && m_volmd.fAUsage != RECTANGLE)) 
  84. //  ? m_pvopcCurrQ : m_pvopcRefQ1;} //reconstructed current frame
  85. const VOLMode& volmd () const {return m_volmd;}
  86. const VOPMode& vopmd () const {return m_vopmd;}
  87. UInt fSptUsage () const {return m_uiSprite;}
  89. // Operations
  90. //virtual Void encode () {}
  92. Void swapRefQ1toSpt ();
  93. Void changeSizeofCurrQ (CRct rctOrg);
  94. Void setRctDisp (CRct rctDisp) {m_rctSptDisp = rctDisp;}
  96. Int iNumOfPnts () const {return m_iNumOfPnts;}
  97. const CVOPU8YUVBA* pvopcSptQ () const {return m_pvopcSptQ;}   
  99. //low latency sprite stuff
  100. Void Overlay (CU8Image& uci1, CU8Image& uci2, float fscale); //1 on 2
  101. Void VOPOverlay (CVOPU8YUVBA& pvopc1, CVOPU8YUVBA& pvopc2, Int iscale = 0); //1 on 2
  103. // dshu: begin of modification
  104. Void U8iGet (CU8Image& uci1, CU8Image& uci2, CRct rctPieceY); 
  105. Void PieceGet (CVOPU8YUVBA& pvopc1, CVOPU8YUVBA& pvopc2, CRct rctPieceY);
  106. Void U8iPut (CU8Image& uci1, CU8Image& uci2, CRct rctPieceY); 
  107. Void PiecePut (CVOPU8YUVBA& pvopc1, CVOPU8YUVBA& pvopc2, CRct rctPieceY); 
  108. // dshu: end of modification
  110. // dshu: [v071]  Begin of modification
  111. Void padSprite();
  112. Void copySptQShapeYToMb (PixelC* ppxlcDstMB, const PixelC* ppxlcSrc) ;
  113. // dshu: [v071] end of modification
  115. Bool SptPieceMB_NOT_HOLE(Int iMBXoffset, Int iMBYoffset, CMBMode* pmbmd); 
  116. Bool SptUpdateMB_NOT_HOLE(Int iMBXoffset, Int iMBYoffset, CMBMode* pmbmd);
  117. Void SaveMBmCurrRow (Int iMBYoffset, MacroBlockMemory** rgpmbmCurr);
  118. Void RestoreMBmCurrRow (Int iMBYoffset, MacroBlockMemory** rgpmbmCurr);
  119. Void CopyCurrQToPred (PixelC* ppxlcQMBY, PixelC* ppxlcQMBU, PixelC* ppxlcQMBV);
  120. ///// 97/12/22 start
  121. Void copyVOPU8YUVBA (CVOPU8YUVBA*& pvopc0, CVOPU8YUVBA*& pvopc1);
  122. Void copyVOPU8YUVBA (CVOPU8YUVBA*& pvopc0, CVOPU8YUVBA*& pvopc1, CVOPU8YUVBA*& pvopc2);
  123. Void compute_bfShapeMembers ();
  124. ///// 97/12/22 end
  125. ///////////////// implementation /////////////////
  126. Int getWidth(void) { return m_ivolWidth;};
  127. Int getHeight(void) { return m_ivolHeight;};
  128. double getFrameTime(void) { return (m_t / (double)m_volmd.iClockRate); };
  129. Int getClockRate(void) { return m_volmd.iClockRate; };
  130. protected:
  131. // general routines
  132. Void swapVOPU8Pointers (CVOPU8YUVBA*& pvopc0, CVOPU8YUVBA*& pvopc1);
  133. Void swapVOPIntPointers (CVOPIntYUVBA*& pvopi0, CVOPIntYUVBA*& pvopi1);
  135. // VOL routines
  136. Void allocateVOLMembers (Int iSessionWidth, Int iSessionHeight);
  137. Void computeVOLConstMembers ();
  139. // VOP routines
  140. Void computeVOPMembers ();
  141. Void setRefStartingPointers ();
  142. Void updateAllRefVOPs ();
  143. Void updateAllRefVOPs (const CVOPU8YUVBA *pvopcRefBaselayer); // for spatial scalability
  144. Void repeatPadYOrA (PixelC* ppxlcOldLeft, CVOPU8YUVBA* pvopcRef);
  145. Void repeatPadUV (CVOPU8YUVBA* pvopcRef);
  146. Void resetBYPlane ();
  148. // MB routines
  149. Void decideTransparencyStatus (CMBMode* pmbmd, const PixelC* ppxlcMBBY);
  150. Void decideMBTransparencyStatus (CMBMode* pmbmd);
  151. Void downSampleBY (const PixelC* ppxlcMBBY, PixelC* ppxlcMBBUV); // downsample original BY now for LPE padding (using original shape)
  153. // Added for field based MC padding by Hyundai(1998-5-9)
  154.         Void decideFieldTransparencyStatus (
  155.                 CMBMode* pmbmd,
  156.                 const PixelC* ppxlcMBBY,
  157.                 const PixelC* ppxlcMBBUV
  158.         );
  159.         Void fieldBasedDownSampleBY (
  160.                 const PixelC* ppxlcMBBY,
  161.                 PixelC* ppxlcMBBUV
  162.         );
  163. // End of Hyundai(1998-5-9)
  165. // error signal processing
  166. Void addErrorAndPredToCurrQ (PixelC* ppxlcRefMBY, PixelC* ppxlcRefMBU, PixelC* ppxlcRefMBV);
  167. Void addAlphaErrorAndPredToCurrQ (PixelC* ppxlcRefMBA);
  169. // shape coding functions
  170. Void saveShapeMode();
  171. own Int* computeShapeSubBlkIndex (Int iSubBlkSize, Int iSrcSize);
  172. Int getContextUS (PixelC a, PixelC b, PixelC c, PixelC d, PixelC e, PixelC f, PixelC g, PixelC h);
  173. PixelC getRefValue (const PixelC* ppxlcRow, Int x_adr, Int y_adr, Int h_size, Int v_size);
  174. Void adaptiveUpSampleShape (const PixelC* rgpxlcSrc, PixelC* rgpxlcDst, Int h_size, Int v_size);
  175. Void downSampleShapeMCPred(const PixelC* ppxlcSrc,PixelC* ppxlcDst,Int iRate);
  176. Void upSampleShape (PixelC* ppxlcBYFrm,const PixelC* rgpxlcSrc, PixelC* rgpxlcDst);
  177. Void copyLeftTopBorderFromVOP (PixelC* ppxlcSrc, PixelC* ppxlcDst);
  178. Void subsampleLeftTopBorderFromVOP (PixelC* ppxlcSrc, PixelC* ppxlcDst);
  179. Void makeRightBottomBorder (PixelC* ppxlcSrc, Int iWidth);
  180. Int contextIntra (const PixelC* ppxlcSrc);
  181. Int contextIntraTranspose (const PixelC* ppxlcSrc);
  182. Int contextInter (const PixelC* ppxlcSrc, const PixelC* ppxlcPred);
  183. Int contextInterTranspose (const PixelC* ppxlcSrc, const PixelC* ppxlcPred);
  184. Void copyReconShapeToMbAndRef (PixelC* ppxlcDstMB, PixelC* ppxlcRefFrm, PixelC pxlcSrc);
  185. Void copyReconShapeToMbAndRef (PixelC* ppxlcDstMB, PixelC* ppxlcRefFrm, const PixelC* ppxlcSrc, Int iSrcWidth, Int iBorder);
  186. Void copyRefShapeToMb (PixelC* ppxlcDstMB, const PixelC* ppxlcSrc); // Added for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)
  187. Void copyReconShapeUVToRef (PixelC* ppxlcRefFrm, const PixelC* ppxlcSrc);
  188. CMotionVector findShapeMVP (const CMotionVector* pmv, const CMotionVector* pmvBY, 
  189. const CMBMode* pmbmd, Int iMBX, Int iMBY) const;
  190. Int m_iInverseCR;
  192. // B-VOP stuff
  193. Void findColocatedMB (Int iMBX, Int iMBY, const CMBMode*& pmbmdRef, const CMotionVector*& pmvRef);
  195. // motion compensation
  196. Void limitMVRangeToExtendedBBHalfPel (CoordI &x,CoordI &y,CRct *prct,Int iBlkSize);
  197. Void limitMVRangeToExtendedBBFullPel (CoordI &x,CoordI &y,CRct *prct,Int iBlkSize);
  198. Void motionCompMB (
  199. PixelC* ppxlcPredMB,
  200. const PixelC* ppxlcRefLeftTop,
  201. const CMotionVector* pmv, const CMBMode* pmbmd, 
  202. Int imbX, Int imbY,
  203. CoordI x, CoordI y,
  204. Bool bSkipNonOBMC,
  205. Bool bAlphaMB,
  206. CRct *prctMVLimit
  207. );
  208. Void motionComp (
  209. PixelC* ppxlcPred, // can be either Y or A
  210. const PixelC* ppxlcRefLeftTop,
  211. Int iSize, // either MB or BLOCK size
  212. CoordI xRef, CoordI yRef, // x + mvX, in half pel unit
  213. Int iRoundingControl,
  214. CRct *prctMVLimit
  215. );
  216. Void motionCompUV (
  217. PixelC* ppxlcPredMBU, PixelC* ppxlcPredMBV,
  218. const CVOPU8YUVBA* pvopcRef,
  219. CoordI x, CoordI y, 
  220. CoordI xRefUV, CoordI yRefUV, Int iRoundingControl,
  221. CRct *prctMVLimit
  222. );
  224. // INTERLACE
  225. Void motionCompFieldUV (PixelC* ppxlcPredMBU, PixelC* ppxlcPredMBV,
  226. const CVOPU8YUVBA* pvopcRef,CoordI x, CoordI y, 
  227. CoordI xRefUV, CoordI yRefUV, Int iRefFieldSelect);
  228. Void motionCompYField ( PixelC* ppxlcPred, const PixelC* ppxlcRefLeftTop,
  229. CoordI xRef, CoordI yRef);
  230. // new change 02-19-99
  231. Void motionCompDirectMode(CoordI x, CoordI y,  CMBMode *pmbmd, const CMotionVector *pmvRef,
  232.                             CRct *prctMVLimitFwd, CRct *prctMVLimitBak, Int plane);
  233. Void motionCompOneBVOPReference(CVOPU8YUVBA *pvopcPred, MBType type, CoordI x, CoordI y,
  234.                             const CMBMode *pmbmd, const CMotionVector *pmv, CRct *prctMVLimit);
  235. // ~INTERLACE
  237. Void motionCompOverLap (
  238. PixelC* ppxlcPredMB, 
  239. const PixelC* ppxlcRefLeftTop,
  240. const CMotionVector* pmv, // motion vector
  241. const CMBMode* pmbmd, // macroblk mode
  242. Int imbx, // current macroblk index
  243. Int imby, // current macroblk index
  244. CoordI x, // current coordinate system
  245. CoordI y, // current coordinate system
  246. CRct *prctMVLimit
  247. );
  248. Void motionCompBY (
  249. PixelC* ppxlcPred,
  250. const PixelC* ppxlcRefLeftTop,
  251. CoordI iXRef, CoordI iYRef
  252. );
  254. // B-VOP stuff
  255. Void motionCompInterp (
  256. const CMotionVector* pmvForward, const CMotionVector* pmvBackward, 
  257. CoordI x, CoordI y
  258. );
  260. Void bilnrMCVH (UInt* PredY, const PixelC* ppxliPrevYC, UInt* pMWght, UInt xlow, UInt xhigh, UInt ylow, UInt yhigh, Bool bAdd);
  261. Void bilnrMCV (UInt* PredY, const PixelC* ppxliPrevYC, UInt* pMWght, UInt xlow, UInt xhigh, UInt ylow, UInt yhigh, Bool bAdd);
  262. Void bilnrMCH (UInt* PredY, const PixelC* ppxliPrevYC, UInt* pMWght, UInt xlow, UInt xhigh, UInt ylow, UInt yhigh, Bool bAdd);
  263. Void bilnrMC (UInt* PredY, const PixelC* ppxliPrevYC, UInt* pMWght, UInt xlow, UInt xhigh, UInt ylow, UInt yhigh, Bool bAdd);
  264. Void assignPredToCurrQ (PixelC* ppxlcRefMBY, PixelC* ppxlcRefMBU, PixelC* ppxlcRefMBV);
  265. Void assignAlphaPredToCurrQ (PixelC* ppxlcRefMBA);
  267. Void copyFromRefToCurrQ ( // zero motion case
  268. const CVOPU8YUVBA* pvopcRef, // reference VOP
  269. CoordI x, CoordI y, 
  270. PixelC* ppxlcCurrQMBY, PixelC* ppxlcCurrQMBU, PixelC* ppxlcCurrQMBV,
  271. CRct *prctMVLimit
  272. ); // for non-obmc mode
  273. Void copyFromRefToCurrQ_WithShape ( // zero motion case
  274. const CVOPU8YUVBA* pvopcRef, // reference VOP
  275. CoordI x, CoordI y, 
  276. PixelC* ppxlcCurrQMBY, PixelC* ppxlcCurrQMBU, PixelC* ppxlcCurrQMBV, PixelC* ppxlcCurrQMBBY
  277. ); // for non-obmc mode
  278. Void copyAlphaFromRefToCurrQ (
  279. const CVOPU8YUVBA* pvopcRef,
  280. CoordI x, CoordI y, 
  281. PixelC* ppxlcCurrQMBA,
  282. CRct *prctMVLimit
  283. );
  285. // MC padding 
  286. Void mcPadCurrMB (
  287. PixelC* ppxlcRefMBY, 
  288. PixelC* ppxlcRefMBU, PixelC* ppxlcRefMBV,
  289. PixelC* ppxlcRefMBA 
  290. );
  291. Void mcPadCurr (
  292. PixelC *ppxlcTextureBase, // (uiStride X ???)
  293. const PixelC *ppxlcAlphaBase, // uiBlkSize X uiBlkSize
  294. UInt uiBlkSize, UInt uiStride
  295. );
  296. Void padNeighborTranspMBs (
  297. CoordI xb, CoordI yb,
  298. CMBMode* pmbmd,
  299. PixelC* ppxlcRefMBY, PixelC* ppxlcRefMBU, PixelC* ppxlcRefMBV,
  300. PixelC* ppxlcRefMBA
  301. );
  302. Void padCurrAndTopTranspMBFromNeighbor (
  303. CoordI xb, CoordI yb,
  304. CMBMode* pmbmd,
  305. PixelC* ppxlcRefMBY, PixelC* ppxlcRefMBU, PixelC* ppxlcRefMBV,
  306. PixelC* ppxlcRefMBA
  307. );
  308. Void mcPadLeftMB (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC* ppxlcRefMBA);
  309. Void mcPadTopMB (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC* ppxlcRefMBA);
  310. Void mcPadCurrMBFromLeft (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC* ppxlcRefMBA);
  311. Void mcPadCurrMBFromTop (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC* ppxlcRefMBA);
  312. Void mcSetTopMBGray (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC* ppxlcRefMBA);
  313. Void mcSetCurrMBGray (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC* ppxlcRefMBA);
  314. Void mcSetLeftMBGray (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC* ppxlcRefMBA);
  316. // Added for field based MC padding by Hyundai(1998-5-9)
  317.         Void fieldBasedMCPadding (
  318.                 CMBMode* pmbmd,
  319.                 CVOPU8YUVBA* pvopcCurrQ
  320.         );
  321.         Void mcPadCurrAndNeighborsMBFields (
  322.                 Int     iMBX,
  323.                 Int     iMBY,
  324.                 CMBMode *pmbmd,
  325.                 PixelC* ppxlcRefMBY,
  326.                 PixelC* ppxlcRefMBU,
  327.                 PixelC* ppxlcRefMBV,
  328.                 PixelC* ppxlcRefMBBY,
  329.                 PixelC* ppxlcRefMBBUV,
  330. PixelC* ppxlcRefMBA
  331.         );
  332.         Void mcPadFieldsCurr (
  333.                 Int     iMBX,
  334.                 Int     iMBY,
  335.                 CMBMode *pmbmd,
  336.                 Int     mode,
  337.                 PixelC  *ppxlcCurrMB1,
  338.                 PixelC  *ppxlcCurrMB2,
  339.                 PixelC  *ppxlcCurrMBB,
  340.                 Int     uiBlkXSize,
  341.                 Int     uiStride
  342.         );
  343.         Void mcPadOneField (
  344.                         PixelC *ppxlcTextureBase,
  345.                         const PixelC *ppxlcAlphaBase,
  346.                         Int uiBlkXSize,
  347.                         Int uiStride
  348.         );
  349.         Void padNeighborTranspMBFields (
  350.                 CoordI  xb,
  351.                 CoordI  yb,
  352.                 CMBMode *pmbmd,
  353.                 Int     mode,
  354.                 PixelC  *ppxlcMBField1,
  355.                 PixelC  *ppxlcMBField2,
  356.                 Int     uiBlkXSize,
  357.                 Int     uiStride
  358.         );         
  359.         Void padCurrAndTopTranspMBFieldsFromNeighbor (
  360.                 CoordI  xb,
  361.                 CoordI  yb,
  362.                 CMBMode *pmbmd,
  363.                 Int     mode,
  364.                 PixelC* ppxlcMBField1,
  365.                 PixelC* ppxlcMBField2,
  366.                 Int     uiBlkXSize,
  367.                 Int     uiStride
  368.         );         
  369.         Void mcPadLeftMBFields (
  370.                 PixelC* ppxlcMBField1,
  371.                 PixelC* ppxlcMBField2,
  372.                 Int uiBlkXSize,
  373.                 Int uiStride
  374.         );         
  375.         Void mcPadTopMBFields (
  376.                 PixelC* ppxlcMBField1,
  377.                 PixelC* ppxlcMBField2,
  378.                 Int uiBlkXSize,
  379.                 Int uiStride
  380.         );         
  381.         Void mcPadCurrMBFieldsFromLeft (
  382.                 PixelC* ppxlcMBField1,
  383.                 PixelC* ppxlcMBField2,
  384.                 Int uiBlkXSize,
  385.                 Int uiStride
  386.         );         
  387.         Void mcPadCurrMBFieldsFromTop (
  388.                 PixelC* ppxlcMBField1,
  389.                 PixelC* ppxlcMBField2,
  390.                 Int uiBlkXSize,
  391.                 Int uiStride
  392.         );         
  393.         Void mcSetTopMBFieldsGray (
  394.                 PixelC* ppxlcMBField1,
  395.                 PixelC* ppxlcMBField2,
  396.                 Int uiBlkXSize,
  397.                 Int uiStride
  398.         );         
  399.         Void mcSetLeftMBFieldsGray (
  400.                 PixelC* ppxlcMBField1,
  401.                 PixelC* ppxlcMBField2,
  402.                 Int uiBlkXSize,
  403.                 Int uiStride
  404.         );         
  405.         Void mcSetCurrMBFieldsGray (
  406.                 PixelC* ppxlcMBField1,
  407.                 PixelC* ppxlcMBField2,
  408.                 Int uiBlkXSize,
  409.                 Int uiStride
  410.         );         
  411. // End of Hyundai(1998-5-9)
  413. // motion vector
  414. Void find16x16MVpred (CVector& vctPred, const CMotionVector* pmv, Bool bLeftBndry, Bool bRightBndry, Bool bTopBndry) const;
  415. Void find8x8MVpredAtBoundary (CVector& vctPred, const CMotionVector* pmv, Bool bLeftBndry, Bool bRightBndry, Bool bTopBndry, BlockNum blknCurr) const;
  416. Void find8x8MVpredInterior (CVector& vctPred, const CMotionVector* pmv, BlockNum blknCurr) const;
  417. Void findMVpredGeneric (CVector& vctPred, const CMotionVector* pmv, const CMBMode* pmbmd, Int iBlk, Int iXMB, Int iYMB) const;
  418. Void findMVpredictorOfBVOP (CVector& vctPred, const CMotionVector* pmv, const CMBMode* pmbmd, Int iMBX) const;       //for B-VOP only
  419. Void mvLookupUV (const CMBMode* pmbmd, const CMotionVector* pmv, CoordI& xRefUV, CoordI& yRefUV,
  420.         CoordI& xRefUV1, CoordI& yRefUV1);
  421. Void mvLookupUVWithShape (const CMBMode* pmbmd, const CMotionVector* pmv, CoordI& xRefUV, CoordI& yRefUV);
  422. Bool validBlock (const CMBMode* pmbmdCurr, const CMBMode* pmbmd, BlockNum blkn) const;
  423. Void computeDirectDeltaMV (CVector& vctDiff, const CMotionVector* pmv, const CMotionVector* pmvRef, const CMBMode* pmbmdRef); //for B-VOP only
  424. CVector averageOfRefMV (const CMotionVector* pmvRef, const CMBMode* pmbmdRef); //for B-VOP only
  425. Void padMotionVectors(const CMBMode *pmbmd,CMotionVector *pmv);
  426. Void backwardMVFromForwardMV ( //compute back mv from forward mv and ref mv for direct mode
  427. CMotionVector& mvBackward, const CMotionVector& mvForward, const CMotionVector& mvRef,
  428. CVector vctDirectDeltaMV);
  431. // Added for error resilient mode by Toshiba(1997-11-14)
  432. Bool bVPNoLeft(Int iMBnum, Int iMBX) const;
  433. Bool bVPNoRightTop(Int iMBnum, Int iMBX) const;
  434. Bool bVPNoTop(Int iMBnum) const;
  435. Bool bVPNoLeftTop(Int iMBnum, Int iMBX) const;
  436. Int VPMBnum(Int iMBX, Int iMBY) const;
  437. // End Toshiba(1997-11-14)
  439. // block level
  440. Void inverseQuantizeIntraDc (Int* rgiCoefQ, Int iDcScaler);
  441. Void inverseQuantizeDCTcoefH263 (Int* rgiCoefQ, Int iStart, Int iQP);
  442. Void inverseQuantizeIntraDCTcoefMPEG (Int* rgiCoefQ, Int iStart, Int iQP, Bool bUseAlphaMatrix);
  443. Void inverseQuantizeInterDCTcoefMPEG (Int* rgiCoefQ, Int iStart, Int iQP, Bool bUseAlphaMatrix);
  444. const BlockMemory findPredictorBlock (
  445. BlockNum iBlk, 
  446. IntraPredDirection predDir,
  447. const MacroBlockMemory* pmbmLeft, 
  448. const MacroBlockMemory* pmbmTop,
  449. const MacroBlockMemory* pmbmLeftTop,
  450. const MacroBlockMemory* pmbmCurr,
  451. const CMBMode* pmbmdLeft, 
  452. const CMBMode* pmbmdTop,
  453. const CMBMode* pmbmdLeftTop,
  454. const CMBMode* pmbmdCurr,
  455. Int& iQPpred
  456. );
  457. Int decideIntraPredDir (
  458. Int* rgiCoefQ,
  459. BlockNum blkn,
  460. const BlockMemory* blkmRet, 
  461. const MacroBlockMemory* pmbmLeft, 
  462. const MacroBlockMemory* pmbmTop, 
  463. const MacroBlockMemory* pmbmLeftTop,
  464. const MacroBlockMemory* pmbmCurr,
  465. const CMBMode* pmbmdLeft,
  466. const CMBMode* pmbmdTop,
  467. const CMBMode* pmbmdLeftTop,
  468. CMBMode* pmbmdCurr,
  469. Int& iQPpred,
  470. Int iQPcurr,
  471. Bool bDecideDCOnly = FALSE
  472. );
  474. Time m_t; // current time
  475. Time m_tPastRef; // time of reference frame in past (for P/B)
  476. Time m_tFutureRef; // time of reference frame in future (for B)
  477. Int m_iBCount; // counts 1,2,3 with B frames, used to pad ref vop once.
  478. Bool m_bCodedFutureRef;
  480.     CRct m_rctDisplayWindow; //display windoew position
  482. Int  m_iNumBitsTimeIncr;
  483. Time m_tDistanceBetwIPVOP; //no. of frms betw. I/PVOP = PeriodOfPVOP except for at irregular period (end of sequence)
  484. Time m_tPrevIorPVOPCounter; //frm. no of previous encoded I/PVOP
  485. Time m_tModuloBaseDisp; //of the most recently displayed I/Pvop
  486. Time m_tModuloBaseDecd; //of the most recently decoded I/Pvop
  487. /*Added by SONY (98/03/30)*/
  488. Bool m_bUseGOV ;
  489. Bool m_bLinkisBroken;
  490. /*Added by SONY (98/03/30)*/
  492. // MB buffer data
  493. CVOPU8YUVBA* m_pvopcPredMB;
  494. PixelC *m_ppxlcPredMBY, *m_ppxlcPredMBU, *m_ppxlcPredMBV, *m_ppxlcPredMBA;
  495. CVOPIntYUVBA* m_pvopiErrorMB;
  496. PixelI *m_ppxliErrorMBY, *m_ppxliErrorMBU, *m_ppxliErrorMBV, *m_ppxliErrorMBA;
  498. // B-VOP MB buffer
  499. CVOPU8YUVBA* m_pvopcPredMBBack; // backward buffer data
  500. PixelC *m_ppxlcPredMBBackY, *m_ppxlcPredMBBackU, *m_ppxlcPredMBBackV, *m_ppxlcPredMBBackA;
  502. // MB shape data
  503. ArCodec* m_parcodec; //arithmatic coder
  504. CU8Image* m_puciPredBAB; //motion compensated binary shape
  505. PixelC *m_ppxlcPredBABDown2, *m_ppxlcPredBABDown4;
  506. PixelC* m_ppxlcReconCurrBAB;
  507. Int m_iWidthCurrBAB;
  508. PixelC* m_rgpxlcCaeSymbol;
  509. PixelC *m_ppxlcCurrMBBYDown4, *m_ppxlcCurrMBBYDown2;
  511. ShapeMode* m_rgshpmd;  // for saving reference shape mode
  512. Int m_iRefShpNumMBX;
  513. Int m_iRefShpNumMBY;
  515. CVOPU8YUVBA* m_pvopcCurrMB;
  516. PixelC *m_ppxlcCurrMBY, *m_ppxlcCurrMBU, *m_ppxlcCurrMBV, *m_ppxlcCurrMBBY, *m_ppxlcCurrMBBUV, *m_ppxlcCurrMBA;
  518. /*BBM// Added for Boundary by Hyundai(1998-5-9)
  519.         Void boundaryMacroBlockMerge (CMBMode* pmbmd);
  520.         Void isBoundaryMacroBlockMerged (CMBMode* pmbmd);
  521.         Void isBoundaryMacroBlockMerged (CMBMode* pmbmd, PixelC* ppxlcRightMBBY);
  522.         Void overlayBlocks (UInt x1, UInt x2, UInt y1, UInt y2, DCTMode dctMd);
  523.         Void overlayBlocks (PixelC* SB2, PixelI* ppxlcB1, PixelI* ppxlcB2);
  524.         Void overlayBlocks (PixelC* SB1, PixelC* SB2, PixelC* ppxlcB1, PixelC* ppxlcB2);
  525.         Bool checkMergedStatus (UInt x1, UInt x2, UInt y1, UInt y2);
  526.         Bool checkMergedStatus (UInt x1, UInt x2, UInt y1, UInt y2, PixelC* ppxlcBY);
  527.         Void mergedMacroBlockSplit (CMBMode* pmbmd, PixelC* ppxlcRefMBY = NULL, PixelC* ppxlcRefMBA = NULL);
  528.         Void splitTwoMergedBlocks (UInt x1, UInt x2, UInt y1, UInt y2, PixelC* ppxlcIn1, PixelC* ppxlcIn2 = NULL);
  529.         Void splitTwoMergedBlocks (UInt x1, UInt x2, UInt y1, UInt y2, PixelI* ppxlcIn1, PixelI* ppxlcIn2 = NULL);
  530.         Void swapTransparentModes (CMBMode* pmbmd, Bool mode);
  531.         Void setMergedTransparentModes (CMBMode* pmbmd);
  532.         Void initMergedMode (CMBMode* pmbmd);
  533. // End of Hyundai(1998-5-9)*/
  535. // for MC-padding
  536. Bool* m_pbEmptyRowArray;
  537. Bool* m_pbEmptyColArray;
  539. // VOP mode 
  540. VOLMode m_volmd; // vol mode
  541. VOPMode m_vopmd; // vop mode
  542. UInt m_uiVOId; // VOP ID
  544. // sprite info
  545. UInt m_uiSprite; // whether this is a sprite VOP: 1 - yes; other - no
  546. UInt m_uiWarpingAccuracy; // accuracy for sprite warping
  547. Int m_iNumOfPnts; // for sprite warping
  548. own CSiteD* m_rgstSrcQ; // quantized src sts for sprite warping
  549. own CSiteD* m_rgstDstQ; // quantized dst sts for sprite warping
  550. own CVOPU8YUVBA* m_pvopcSptQ; // Loaded first as original sprite and then become quantized sprite. 
  551. CRct m_rctSpt; // rct of m_pvopcSptQ
  552. CRct m_rctSptDisp; //rct to display sprite (decoder side)
  553. SptMode m_sptMode;  // sprite reconstruction mode : 0 -- basic sprite , 1 -- Object piece only, 2 -- Update piece only, 3 -- intermingled
  554. own MBSptMode* m_rgsptmd; // sprite mode 0: untransmitted; 1: transmitted; 2: updated; 3: done
  556. // internal data
  557. own CVOPU8YUVBA* m_pvopcRefQ0; // original reference VOP in a previous time
  558. own CVOPU8YUVBA* m_pvopcRefQ1; // original reference VOP in a later time
  559. own CVOPU8YUVBA* m_pvopcCurrQ; // original reference VOP in a later time
  560. Int m_iStartInRefToCurrRctY, m_iStartInRefToCurrRctUV;
  562. // motion data
  563. own CDirectModeData* m_pdrtmdRef1; // for direct mode
  564. CVector m_vctForwardMvPredBVOP[2]; // motion vector predictors for B-VOP
  565. CVector m_vctBackwardMvPredBVOP[2];     // [2] added for interlace (top & bottom fields)
  567. // some fixed variables (VOL)
  568. CRct m_rctRefFrameY, m_rctRefFrameUV;
  569. Int m_iFrameWidthYxMBSize, m_iFrameWidthYxBlkSize, m_iFrameWidthUVxBlkSize;
  570. Int m_iFrameWidthY, m_iFrameWidthUV;
  571. Int m_ivolWidth, m_ivolHeight;
  573. // VOP variables
  574. CRct m_rctCurrVOPY, m_rctCurrVOPUV;
  575. CRct m_rctRefVOPY0, m_rctRefVOPUV0;
  576. CRct m_rctRefVOPY1, m_rctRefVOPUV1;
  577. Int m_iOffsetForPadY, m_iOffsetForPadUV;
  578. CRct m_rctPrevNoExpandY, m_rctPrevNoExpandUV;
  579. ////// 97/12/22 start
  580. CRct m_rctBVOPRefVOPY1, m_rctBVOPRefVOPUV1;
  581. Int m_iBVOPOffsetForPadY, m_iBVOPOffsetForPadUV;
  582. CRct m_rctBVOPPrevNoExpandY, m_rctBVOPPrevNoExpandUV;
  583. ///// 97/12/22 end
  585. Int m_iVOPWidthY, m_iVOPWidthUV;
  586. Int m_iNumMB, m_iNumMBX, m_iNumMBY;
  587. Int m_iNumOfTotalMVPerRow;
  588. Int m_iSessNumMB;
  590. CMBMode* m_rgmbmd; // VOP size.  need to renew every VOP
  591. CMotionVector* m_rgmv; // VOP size.  need to renew every VOP
  592. CMotionVector* m_rgmvBackward; // VOP size.  need to renew every VOP
  593. CMotionVector* m_rgmvBY; //Motion vectors for BY plane
  595. CMBMode* m_rgmbmdRef;
  596. CMotionVector* m_rgmvRef; // VOP size.  need to renew every VOP
  597. Int m_iNumMBRef, m_iNumMBXRef, m_iNumMBYRef;
  599. // clipping tables
  600. /* NBIT: change U8 to PixelC
  601. U8* m_rgiClipTab; // clapping the reconstructed pixels
  602. */
  603. PixelC* m_rgiClipTab; // clapping the reconstructed pixels
  604. Int m_iOffset; // NBIT
  605. Void setClipTab(); // NBIT
  607. // Added for error resilient mode by Toshiba(1997-11-14)
  608. Bool  m_bVPNoLeft;
  609. Bool  m_bVPNoRightTop;
  610. Bool  m_bVPNoTop;
  611. Bool  m_bVPNoLeftTop;
  612. Int m_iVPMBnum; // start MB in a VP
  613. // End Toshiba(1997-11-14)
  615. // MB data
  616. Int** m_rgpiCoefQ;
  617. MacroBlockMemory** m_rgpmbmAbove;
  618. MacroBlockMemory** m_rgpmbmCurr;
  619. BlockMemory* m_rgblkmCurrMB; //predictor blocks for each current block
  620. Int* m_rgiQPpred; //QP from previous block for intra ac prediction
  621. Int m_rgiDcScalerY [32]; //intra dc quantization scaler; qp dependent
  622. Int m_rgiDcScalerC [32]; //[0] elem never used
  624. // block data
  625. Int m_rgiDCTcoef [BLOCK_SQUARE_SIZE];
  626. CInvBlockDCT* m_pidct;
  628. // Sprite routines
  629. Void warpYA (const CPerspective2D& persp, const CRct& rctWarpedBound, UInt accuracy);
  630. Void warpUV (const CPerspective2D& persp, const CRct& rctWarpedBound, UInt accuracy);
  632.     // Fast Affine Warping
  633.     Void FastAffineWarp (const CRct& rctWarpedBound, const CRct& rctWarpedBoundUV, UInt accuracy, UInt pntNum);
  634.     PixelC CInterpolatePixelValue (PixelC* F, Int pos, Int width, Int rx, Int ry, Int wpc, Int bias, Int pow_denom);
  635.     Int LinearExtrapolation(Int x0, Int x1, Int x0p, Int x1p, Int W, Int VW);
  636.     Void FourSlashes(Int num, Int denom, Int *quot, Int *res);
  637.     // tentative solution for indicating the first Sprite VOP
  638.     Int tentativeFirstSpriteVop;
  640. // Low-latency sprite info
  641.     Bool m_bFirstSpriteVop ;// flag for indicating the first Sprite VOP     
  642. MacroBlockMemory*** m_rgpmbmCurr_Spt;  //  save MB data to be used as holes
  643. SptMBstatus** m_ppPieceMBstatus;  // MB transmission status (done or not-done)
  644. SptMBstatus** m_ppUpdateMBstatus;
  646. CMBMode* m_rgmbmdSprite;  // dshu: [v071]  added to store mbmd array for sprite
  648. CMBMode** m_rgmbmdSpt; // Sprite size. 
  649. Bool m_bSptMB_NOT_HOLE;    // Current MB is not a hole
  650. own CSiteD* m_rgstSrcQP; // for sprite piece warping
  651. Time m_tPiece; // current sprite piece encode time
  652. Time m_tUpdate; // current sprite update encode time 
  653. own CVOPU8YUVBA* m_pvopcSptP; //  sprite piece    
  654. CRct m_rctSptQ;   //  rct of m_pvopcSptQ 
  655. CRct m_rctOrg;   // Frame size
  656. CRct m_rctPieceQ;  // Region of pieces which have been encoded
  657. CRct m_rctUpdateQ;  // Region of updates which have been encoded
  658. CRct m_rctSptPieceY;  // piece of sprite which is currently been encoded
  659. CRct m_rctSptPieceUV;  // piece of sprite which is currently been encoded
  660. Int m_iStepI;
  661. Int m_iStep; 
  662. Int m_iStep_VOP;
  663. Int m_iPieceXoffset;
  664. Int m_iPieceYoffset;
  665. Int m_iPieceWidth;
  666. Int m_iPieceHeight; 
  667. Bool m_bSptZoom;  // the type of sprite warping(zoom/pan)
  668.     Bool m_bSptHvPan; // the type of sprite warping(Horizontal or vertical panning)
  669. Bool m_bSptRightPiece;  //direction (up/down or right/left) for encoding sprite piece
  670. Int *m_pSptmbBits; // bits used by a sprite macroblock
  671. CRct m_rctSptExp;  // Extend the sprite size to multiples of MBSize
  673. };
  675. #endif // __VOPSES_HPP_