vopses.hpp

网络MPEG4IP流媒体开发源代码

/*************************************************************************

This software module was originally developed by 

	Ming-Chieh Lee ([e-mail]), Microsoft Corporation
	Wei-ge Chen ([e-mail]), Microsoft Corporation
	Bruce Lin ([e-mail]), Microsoft Corporation
	Chuang Gu ([e-mail]), Microsoft Corporation
	(date: March, 1996)
and edited by
        Wei Wu ([e-mail]) Rockwell Science Center

and also edited by
	Yoshihiro Kikuchi (TOSHIBA CORPORATION)
	Takeshi Nagai (TOSHIBA CORPORATION)
	Toshiaki Watanabe (TOSHIBA CORPORATION)
	Noboru Yamaguchi (TOSHIBA CORPORATION)

and edited by Xuemin Chen (General Instrument Corp.)

in the course of development of the MPEG-4 Video (ISO/IEC 14496-2). 
This software module is an implementation of a part of one or more MPEG-4 Video tools 
as specified by the MPEG-4 Video. 
ISO/IEC gives users of the MPEG-4 Video free license to this software module or modifications 
thereof for use in hardware or software products claiming conformance to the MPEG-4 Video. 
Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. 
The original developer of this software module and his/her company, 
the subsequent editors and their companies, 
and ISO/IEC have no liability for use of this software module or modifications thereof in an implementation. 
Copyright is not released for non MPEG-4 Video conforming products. 
Microsoft retains full right to use the code for his/her own purpose, 
assign or donate the code to a third party and to inhibit third parties from using the code for non <MPEG standard> conforming products. 
This copyright notice must be included in all copies or derivative works. 

Copyright (c) 1996, 1997.

Module Name:

	vopSes.hpp

Abstract:

	Base class for the encoder for one Video Object.

Revision History:
    December 20, 1997   Interlaced tools added by General Instrument Corp.(GI)
                        X. Chen ([e-mail]), B. Eifrig ([e-mail])
        May. 9   1998:  add boundary by Hyundai Electronics 
                                  Cheol-Soo Park ([e-mail]) 
        May. 9   1998:  add field based MC padding by Hyundai Electronics 
                                  Cheol-Soo Park ([e-mail]) 
*************************************************************************/

#ifndef __VOPSES_HPP_ 
#define __VOPSES_HPP_

typedef enum {NOT_DONE, PIECE_DONE, UPDATE_DONE} SptMBstatus;

#define BlockMemory Int*
typedef struct MacroBlockMemory {
	BlockMemory* rgblkm;
} MacroBlockMemory;

Class ArCodec;

Class CInvBlockDCT;

Class CVideoObject
{
public:
	// Constructors
	virtual ~CVideoObject ();
	CVideoObject ();

	// Attributes
	const CVOPU8YUVBA* pvopcQuantCurr () const {return m_pvopcCurrQ;}
	const CVOPU8YUVBA* pvopcRefQPrev () const {return m_pvopcRefQ0;}
	const CVOPU8YUVBA* pvopcRefQLater () const {return m_pvopcRefQ1;}
	//This modification is for reconstructed BVOP image in SS coding should be used as refrence layer 
	const CVOPU8YUVBA* pvopcReconCurr () const; 
	//						{return   ((m_vopmd.vopPredType == BVOP && m_volmd.volType == BASE_LAYER) 
	//								 ||(m_vopmd.vopPredType == BVOP && m_vopmd.iRefSelectCode != 0)
	//								 ||(m_vopmd.vopPredType == SPRITE && m_volmd.fAUsage != RECTANGLE)) 
	//								 ? m_pvopcCurrQ : m_pvopcRefQ1;}	//reconstructed current frame
	const VOLMode& volmd () const {return m_volmd;}
	const VOPMode& vopmd () const {return m_vopmd;}
	UInt fSptUsage () const {return m_uiSprite;}

	// Operations
	//virtual Void encode () {}

	Void swapRefQ1toSpt ();
	Void changeSizeofCurrQ (CRct rctOrg);
	Void setRctDisp (CRct rctDisp) {m_rctSptDisp = rctDisp;}

	Int iNumOfPnts () const {return m_iNumOfPnts;}
	const CVOPU8YUVBA* pvopcSptQ () const {return m_pvopcSptQ;}	  

	//low latency sprite stuff
	Void Overlay (CU8Image& uci1, CU8Image& uci2, float fscale); //1 on 2
	Void VOPOverlay (CVOPU8YUVBA& pvopc1, CVOPU8YUVBA& pvopc2, Int iscale = 0); //1 on 2

// dshu: begin of modification			
	Void U8iGet (CU8Image& uci1, CU8Image& uci2, CRct rctPieceY); 
	Void PieceGet (CVOPU8YUVBA& pvopc1, CVOPU8YUVBA& pvopc2, CRct rctPieceY);			
	Void U8iPut (CU8Image& uci1, CU8Image& uci2, CRct rctPieceY); 
	Void PiecePut (CVOPU8YUVBA& pvopc1, CVOPU8YUVBA& pvopc2, CRct rctPieceY); 
// dshu: end of modification

// dshu: [v071]  Begin of modification
	Void padSprite();
	Void copySptQShapeYToMb (PixelC* ppxlcDstMB, const PixelC* ppxlcSrc)	;
// dshu: [v071] end of modification

	Bool SptPieceMB_NOT_HOLE(Int iMBXoffset, Int iMBYoffset, CMBMode* pmbmd); 
	Bool SptUpdateMB_NOT_HOLE(Int iMBXoffset, Int iMBYoffset, CMBMode* pmbmd);	
	Void SaveMBmCurrRow (Int iMBYoffset, MacroBlockMemory** rgpmbmCurr);
	Void RestoreMBmCurrRow (Int iMBYoffset, MacroBlockMemory** rgpmbmCurr);
	Void CopyCurrQToPred (PixelC* ppxlcQMBY, PixelC* ppxlcQMBU,	PixelC* ppxlcQMBV);
///// 97/12/22 start
	Void copyVOPU8YUVBA (CVOPU8YUVBA*& pvopc0, CVOPU8YUVBA*& pvopc1);
	Void copyVOPU8YUVBA (CVOPU8YUVBA*& pvopc0, CVOPU8YUVBA*& pvopc1, CVOPU8YUVBA*& pvopc2);
	Void compute_bfShapeMembers ();
///// 97/12/22 end
///////////////// implementation /////////////////
	Int getWidth(void) { return m_ivolWidth;};
	Int getHeight(void) { return m_ivolHeight;};
	double getFrameTime(void) { return (m_t / (double)m_volmd.iClockRate); };
	Int getClockRate(void) { return m_volmd.iClockRate; };
protected:
	// general routines
	Void swapVOPU8Pointers (CVOPU8YUVBA*& pvopc0, CVOPU8YUVBA*& pvopc1);
	Void swapVOPIntPointers (CVOPIntYUVBA*& pvopi0, CVOPIntYUVBA*& pvopi1);

	// VOL routines
	Void allocateVOLMembers (Int iSessionWidth, Int iSessionHeight);
	Void computeVOLConstMembers ();

	// VOP routines
	Void computeVOPMembers ();
	Void setRefStartingPointers ();
	Void updateAllRefVOPs ();
	Void updateAllRefVOPs (const CVOPU8YUVBA *pvopcRefBaselayer); // for spatial scalability
	Void repeatPadYOrA (PixelC* ppxlcOldLeft, CVOPU8YUVBA* pvopcRef);
	Void repeatPadUV (CVOPU8YUVBA* pvopcRef);
	Void resetBYPlane ();

	// MB routines
	Void decideTransparencyStatus (CMBMode* pmbmd, const PixelC* ppxlcMBBY);
	Void decideMBTransparencyStatus (CMBMode* pmbmd);
	Void downSampleBY (const PixelC* ppxlcMBBY, PixelC* ppxlcMBBUV); // downsample original BY now for LPE padding (using original shape)
	
	// Added for field based MC padding by Hyundai(1998-5-9)
        Void decideFieldTransparencyStatus (
                CMBMode* pmbmd,
                const PixelC* ppxlcMBBY,
                const PixelC* ppxlcMBBUV
        );
        Void fieldBasedDownSampleBY (
                const PixelC* ppxlcMBBY,
                PixelC* ppxlcMBBUV
        );
	// End of Hyundai(1998-5-9)

	// error signal processing
	Void addErrorAndPredToCurrQ (PixelC* ppxlcRefMBY, PixelC* ppxlcRefMBU, PixelC* ppxlcRefMBV);
	Void addAlphaErrorAndPredToCurrQ (PixelC* ppxlcRefMBA);

	// shape coding functions
	Void saveShapeMode();
	own Int* computeShapeSubBlkIndex (Int iSubBlkSize, Int iSrcSize);
	Int getContextUS (PixelC a, PixelC b, PixelC c, PixelC d, PixelC e, PixelC f, PixelC g, PixelC h);
	PixelC getRefValue (const PixelC* ppxlcRow, Int x_adr, Int y_adr, Int h_size, Int v_size);
	Void adaptiveUpSampleShape (const PixelC* rgpxlcSrc, PixelC* rgpxlcDst, Int h_size, Int v_size);
	Void downSampleShapeMCPred(const PixelC* ppxlcSrc,PixelC* ppxlcDst,Int iRate);
	Void upSampleShape (PixelC* ppxlcBYFrm,const PixelC* rgpxlcSrc, PixelC* rgpxlcDst);
	Void copyLeftTopBorderFromVOP (PixelC* ppxlcSrc, PixelC* ppxlcDst);
	Void subsampleLeftTopBorderFromVOP (PixelC* ppxlcSrc, PixelC* ppxlcDst);
	Void makeRightBottomBorder (PixelC* ppxlcSrc, Int iWidth);
	Int contextIntra (const PixelC* ppxlcSrc);
	Int contextIntraTranspose (const PixelC* ppxlcSrc);
	Int contextInter (const PixelC* ppxlcSrc, const PixelC* ppxlcPred);
	Int contextInterTranspose (const PixelC* ppxlcSrc, const PixelC* ppxlcPred);
	Void copyReconShapeToMbAndRef (PixelC* ppxlcDstMB, PixelC* ppxlcRefFrm, PixelC pxlcSrc);
	Void copyReconShapeToMbAndRef (PixelC* ppxlcDstMB, PixelC* ppxlcRefFrm, const PixelC* ppxlcSrc, Int iSrcWidth, Int iBorder);
	Void copyRefShapeToMb (PixelC* ppxlcDstMB, const PixelC* ppxlcSrc); //	Added for data partitioning mode By Toshiba(1998-1-16:DP+RVLC)
	Void copyReconShapeUVToRef (PixelC* ppxlcRefFrm, const PixelC* ppxlcSrc);
	CMotionVector findShapeMVP (const CMotionVector* pmv, const CMotionVector* pmvBY, 
								const CMBMode* pmbmd, Int iMBX, Int iMBY) const;
	Int m_iInverseCR;

	// B-VOP stuff
	Void findColocatedMB (Int iMBX, Int iMBY, const CMBMode*& pmbmdRef, const CMotionVector*& pmvRef);
	
	// motion compensation
	Void limitMVRangeToExtendedBBHalfPel (CoordI &x,CoordI &y,CRct *prct,Int iBlkSize);
	Void limitMVRangeToExtendedBBFullPel (CoordI &x,CoordI &y,CRct *prct,Int iBlkSize);
	Void motionCompMB (
		PixelC* ppxlcPredMB,
		const PixelC* ppxlcRefLeftTop,
		const CMotionVector* pmv, const CMBMode* pmbmd, 
		Int imbX, Int imbY,
		CoordI x, CoordI y,
		Bool bSkipNonOBMC,
		Bool bAlphaMB,
		CRct *prctMVLimit
	);
	Void motionComp (
		PixelC* ppxlcPred, // can be either Y or A
		const PixelC* ppxlcRefLeftTop,
		Int iSize, // either MB or BLOCK size
		CoordI xRef, CoordI yRef, // x + mvX, in half pel unit
		Int iRoundingControl,
		CRct *prctMVLimit
	);
	Void motionCompUV (
		PixelC* ppxlcPredMBU, PixelC* ppxlcPredMBV,
		const CVOPU8YUVBA* pvopcRef,
		CoordI x, CoordI y, 
		CoordI xRefUV, CoordI yRefUV, Int iRoundingControl,
		CRct *prctMVLimit
	);

// INTERLACE
	Void motionCompFieldUV (PixelC* ppxlcPredMBU, PixelC* ppxlcPredMBV,
							const CVOPU8YUVBA* pvopcRef,CoordI x, CoordI y, 
							CoordI xRefUV, CoordI yRefUV, Int iRefFieldSelect);
	Void motionCompYField ( PixelC* ppxlcPred, const PixelC* ppxlcRefLeftTop,
							CoordI xRef, CoordI yRef);	
	// new change 02-19-99
	Void motionCompDirectMode(CoordI x, CoordI y,  CMBMode *pmbmd, const CMotionVector *pmvRef,
                            CRct *prctMVLimitFwd, CRct *prctMVLimitBak, Int plane);
	Void motionCompOneBVOPReference(CVOPU8YUVBA *pvopcPred, MBType type, CoordI x, CoordI y,
                            const CMBMode *pmbmd, const CMotionVector *pmv, CRct *prctMVLimit);
// ~INTERLACE

	Void motionCompOverLap (
		PixelC* ppxlcPredMB, 
		const PixelC* ppxlcRefLeftTop,
		const CMotionVector* pmv, // motion vector
		const CMBMode* pmbmd, // macroblk mode	
		Int imbx, // current macroblk index
		Int imby, // current macroblk index
		CoordI x, // current coordinate system
		CoordI y, // current coordinate system
		CRct *prctMVLimit
	);
	Void motionCompBY (
		PixelC* ppxlcPred,
		const PixelC* ppxlcRefLeftTop,
		CoordI iXRef, CoordI iYRef
	);

	// B-VOP stuff
	Void motionCompInterp (
		const CMotionVector* pmvForward, const CMotionVector* pmvBackward, 
		CoordI x, CoordI y
	);

	Void bilnrMCVH (UInt* PredY, const PixelC* ppxliPrevYC, UInt* pMWght, UInt xlow, UInt xhigh, UInt ylow, UInt yhigh, Bool bAdd);
	Void bilnrMCV (UInt* PredY, const PixelC* ppxliPrevYC, UInt* pMWght, UInt xlow, UInt xhigh, UInt ylow, UInt yhigh, Bool bAdd);
	Void bilnrMCH (UInt* PredY, const PixelC* ppxliPrevYC, UInt* pMWght, UInt xlow, UInt xhigh, UInt ylow, UInt yhigh, Bool bAdd);
	Void bilnrMC (UInt* PredY, const PixelC* ppxliPrevYC, UInt* pMWght, UInt xlow, UInt xhigh, UInt ylow, UInt yhigh, Bool bAdd);
	Void assignPredToCurrQ (PixelC* ppxlcRefMBY, PixelC* ppxlcRefMBU, PixelC* ppxlcRefMBV);
	Void assignAlphaPredToCurrQ (PixelC* ppxlcRefMBA);

	Void copyFromRefToCurrQ ( // zero motion case
		const CVOPU8YUVBA* pvopcRef, // reference VOP
		CoordI x, CoordI y, 
		PixelC* ppxlcCurrQMBY, PixelC* ppxlcCurrQMBU, PixelC* ppxlcCurrQMBV,
		CRct *prctMVLimit
	); // for non-obmc mode
	Void copyFromRefToCurrQ_WithShape ( // zero motion case
		const CVOPU8YUVBA* pvopcRef, // reference VOP
		CoordI x, CoordI y, 
		PixelC* ppxlcCurrQMBY, PixelC* ppxlcCurrQMBU, PixelC* ppxlcCurrQMBV, PixelC* ppxlcCurrQMBBY
	); // for non-obmc mode
	Void copyAlphaFromRefToCurrQ (
		const CVOPU8YUVBA* pvopcRef,
		CoordI x, CoordI y, 
		PixelC* ppxlcCurrQMBA,
		CRct *prctMVLimit
	);

	// MC padding 
	Void mcPadCurrMB (
		PixelC* ppxlcRefMBY, 
		PixelC* ppxlcRefMBU, PixelC* ppxlcRefMBV,
		PixelC* ppxlcRefMBA 
	);
	Void mcPadCurr (
		PixelC *ppxlcTextureBase, // (uiStride X ???)
		const PixelC *ppxlcAlphaBase, // uiBlkSize X uiBlkSize
		UInt uiBlkSize, UInt uiStride
	);
	Void padNeighborTranspMBs (
		CoordI xb, CoordI yb,
		CMBMode* pmbmd,
		PixelC* ppxlcRefMBY, PixelC* ppxlcRefMBU, PixelC* ppxlcRefMBV,
		PixelC* ppxlcRefMBA
	);
	Void padCurrAndTopTranspMBFromNeighbor (
		CoordI xb, CoordI yb,
		CMBMode* pmbmd,
		PixelC* ppxlcRefMBY, PixelC* ppxlcRefMBU, PixelC* ppxlcRefMBV,
		PixelC* ppxlcRefMBA
	);
	Void mcPadLeftMB (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC* ppxlcRefMBA);
	Void mcPadTopMB (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC* ppxlcRefMBA);
	Void mcPadCurrMBFromLeft (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC* ppxlcRefMBA);
	Void mcPadCurrMBFromTop (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC* ppxlcRefMBA);
	Void mcSetTopMBGray (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC* ppxlcRefMBA);
	Void mcSetCurrMBGray (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC* ppxlcRefMBA);
	Void mcSetLeftMBGray (PixelC* ppxlcMBY, PixelC* ppxlcMBU, PixelC* ppxlcMBV, PixelC* ppxlcRefMBA);

	// Added for field based MC padding by Hyundai(1998-5-9)
        Void fieldBasedMCPadding (
                CMBMode* pmbmd,
                CVOPU8YUVBA* pvopcCurrQ
        );
        Void mcPadCurrAndNeighborsMBFields (
                Int     iMBX,
                Int     iMBY,
                CMBMode *pmbmd,
                PixelC* ppxlcRefMBY,
                PixelC* ppxlcRefMBU,
                PixelC* ppxlcRefMBV,
                PixelC* ppxlcRefMBBY,
                PixelC* ppxlcRefMBBUV,
				PixelC* ppxlcRefMBA
        );
        Void mcPadFieldsCurr (
                Int     iMBX,
                Int     iMBY,
                CMBMode *pmbmd,
                Int     mode,
                PixelC  *ppxlcCurrMB1,
                PixelC  *ppxlcCurrMB2,