mode.hpp

网络MPEG4IP流媒体开发源代码

	MVInfo	mvInfoBackward;					// motion search info
	Int	iSearchRangeForward;				// maximum search range for motion estimation
	Int	iSearchRangeBackward;				// maximum search range for motion estimation

	Bool bInterlace;						// interlace coding flag
	Bool bTopFieldFirst;					// Top field first
    Bool bAlternateScan;                    // Alternate Scan
	Int  iDirectModeRadius;					// Direct mode search radius (half luma pels)

	// for scalability
	Int iRefSelectCode;
	Int iLoadForShape; // load_forward_shape
	Int iLoadBakShape; // load_backward_shape
	Bool bShapeCodingType; // vop_shape_coding_type (0:intra, 1:inter): Added for error resilient mode by Toshiba(1997-11-14)
	SptXmitMode SpriteXmitMode;	// sprite transmit mode 

} VOPMode;



Class CMBMode // MacroBlock Mode
{
public:
	// Constructors
	~CMBMode ();
	CMBMode (); 
	CMBMode (const CMBMode& md);

	// Operations
	Void setCodedBlockPattern (BlockNum blkn, Bool bisCoded) 
								{m_rgbCodedBlockPattern[(UInt) blkn - 1] = bisCoded;}
	Void setCodedBlockPattern (const Bool* rgbblockNum);
	Void setMinError (BlockNum blkn, Int iminError)
								{m_rgfltMinErrors[(UInt) blkn - 1] = (Float) iminError;}
	Void setMinError (const Float* pfltminError);
	Void operator = (const CMBMode& md);

	// Attributes
	Bool getCodedBlockPattern (BlockNum blkn) const 
								{return m_rgbCodedBlockPattern[(UInt) blkn - 1];};
	Bool* getCodedBlockPattern () const {return m_rgbCodedBlockPattern;}
	Float getMinError (BlockNum blkn) const
									{return m_rgfltMinErrors[(UInt) blkn - 1];};
	Float* getMinError () const {return m_rgfltMinErrors;}

	// Some extra data member
	TransparentStatus m_rgTranspStatus [11]; 
		// indicating the transparency status of the MB, either ALL, PARTIAL, or NONE transparent
		// 0: 16x16,  1-4: 8x8
	Int m_rgNumNonTranspPixels [11]; // number of non-transparent pixels

	/*BBM// Added for Boundary by Hyundai(1998-5-9)
        TransparentStatus m_rgTranspStatusBBM [11];
        Bool m_bMerged [7];
	// End of Hyundai(1998-5-9)*/

	// Added for field based MC padding by Hyundai(1998-5-9)
	TransparentStatus m_rgFieldTranspStatus [5];
	Bool m_rgbFieldPadded[5];
	// End of Hyundai(1998-5-9)

	Bool m_bPadded;				// to see whether this all-transparent has been padded
	Bool m_bSkip;				// is the Macroblock skiped. = COD in H.263
	CODAlpha m_CODAlpha;		// alpha Macroblock coded status
	MBType m_mbType;			// macroblock type, DIRECT, FORWARD, BACKWARD, or INTERPOLATE
	DCTMode m_dctMd;			// is the Macroblock inter- or intra- coded
	ShapeMode m_shpmd;			//different context for the first MMR code
	Int m_intStepDelta;			// change of quantization stepsize = DQUANT in h.263
	Bool m_bhas4MVForward;		//whether the MB has four motion vectors (for forward vectors)
	Bool m_bhas4MVBackward;		//whether the MB has four motion vectors (for backward vectors)
	Bool m_bFieldMV;			// whether the MB is compensated by field motion vectors (for forward vectors) : yes=1
	Bool m_bForwardTop;			// TRUE iff Current Forward Top field MV references the BOTTOM field
	Bool m_bForwardBottom;		// TRUE iff Current Forward Bottom field MV references the BOTTOM field
	Bool m_bBackwardTop;		// TRUE iff Current Backward Top field MV references the BOTTOM field
	Bool m_bBackwardBottom;		// TRUE iff Current Backward Bottom field MV references the BOTTOM field
	Bool m_bFieldDCT;			// use field DCT or not : yes=1
	Bool m_bPerspectiveForward; //whether the MB uses forward perspective motion
	Bool m_bPerspectiveBackward;//whether the MB uses backward perspective motion
	Int m_stepSize;				//qp for texture
	Int m_stepSizeDelayed;		//qp delayed by 1 MB for intra_vlc_dc_thr switch
	Int m_stepSizeAlpha;		//qp for alpha
	IntraPredDirection m_preddir [10]; // horizonal or vertical
	Bool m_bACPrediction;		// use AC prediction or not
	Bool m_bACPredictionAlpha;  // alpha version of above
	Bool m_bInterShapeCoding;	//use predicted binary shape
	Bool m_bCodeDcAsAc;			//code Intra DC with Ac VLC
	Bool m_bCodeDcAsAcAlpha;	// alpha version of above
	Bool m_bColocatedMBSkip;	// for B-VOP, colocated MB skipped or not
	Int  m_iVideoPacketNumber;	//	Video Packet Number; added by Toshiba
	CVector m_vctDirectDeltaMV;	// delta vector for direct mode

private:
	Bool* m_rgbCodedBlockPattern; //for each block, 1 = some non-DC components are coded
	Float* m_rgfltMinErrors; //mininal prediction errors for each luminance block
};


Class CDirectModeData // to handle data for direct mode in B-VOP
{
public:
	// Constructor
	~CDirectModeData ();
	CDirectModeData ();

	// Attributes
	UInt numMB () const {return m_uiNumMB;}
	UInt numMBX () const {return m_uiNumMBX;}
	UInt numMBY () const {return m_uiNumMBY;}
	Bool inBound (UInt iMbIdx) const; // check whether the index is inbound
	Bool inBound (UInt idX, UInt idY) const; // check whether the index is inbound
	CMBMode** mbMode () const {return m_ppmbmd;}
	const CMBMode* mbMode (UInt iMbIdx) const 
		{assert (inBound (iMbIdx)); return m_ppmbmd [iMbIdx];}
	const CMBMode* mbMode (UInt idX, UInt idY) const 
		{assert (inBound (idX, idY)); return m_ppmbmd [idX + idY * m_uiNumMBX];}
	CMotionVector** mv () const {return m_prgmv;}
	const CMotionVector* mv (UInt iMbIdx) const 
		{assert (inBound (iMbIdx)); return m_prgmv [iMbIdx];}
	const CMotionVector* mv (UInt idX, UInt idY) const 
		{assert (inBound (idX, idY)); return m_prgmv [idX + idY * m_uiNumMBX];}

	// Operations
	Void reassign (UInt numMBX, UInt numMBY);
	Void assign (UInt imb, const CMBMode& mbmd, const CMotionVector* rgmv);

///////////////// implementation /////////////////

private:
	own CMBMode** m_ppmbmd;
	own CMotionVector** m_prgmv; // [m_uiNumMB][5]
	UInt m_uiNumMB, m_uiNumMBX, m_uiNumMBY;

	Void destroyMem ();

};

Class CStatistics
{
public:

	//constructor 
	CStatistics ();
	~CStatistics () {};

	//resultant
	Void print (Bool bVOPPrint = FALSE);
	CStatistics& operator = (const CStatistics& statSrc);

	//Operation
	Void operator += (const CStatistics& statSrc);
	Void reset ();
	UInt total ();
	UInt head ();

	//data members
	UInt nBitsHead;
	UInt nBitsY;
	UInt nBitsCr;
	UInt nBitsCb;
	UInt nBitsA;
	UInt nBitsShapeMode;
	UInt nBitsCOD;
	UInt nBitsCBPY;
	UInt nBitsMCBPC;
	UInt nBitsDQUANT;
	UInt nBitsMODB;
	UInt nBitsCBPB;
	UInt nBitsMBTYPE;
	UInt nBitsIntraPred;	//intra ac/dc switch
	UInt nBitsNoDCT;		//no. of DCT in sepr m-s-t mode
	UInt nBitsCODA;
	UInt nBitsCBPA;
	UInt nBitsMODBA;
	UInt nBitsCBPBA;
	UInt nBitsStuffing;
	UInt nSkipMB;
	UInt nInterMB;
	UInt nInter4VMB;
	UInt nIntraMB;
	UInt nDirectMB;
	UInt nForwardMB;
	UInt nBackwardMB;
	UInt nInterpolateMB;
	UInt nBitsInterlace;	// incl all interlaced info in MB header
	UInt nFieldForwardMB;
	UInt nFieldBackwardMB;
	UInt nFieldInterpolateMB;
	UInt nFieldDirectMB;
	UInt nFieldDCTMB;
	UInt nVOPs;				// VOP counter for normalizing statistics
	UInt nBitsMV;
	UInt nBitsShape;
	UInt nBitsTotal;
	Double dSNRY;
	Double dSNRU;
	Double dSNRV;
	Double dSNRA;
	UInt nQMB;
	UInt nQp;

private:
	UInt nBitsTexture;
};

Class CRCMode
{
public:

	//constructor 
	CRCMode () {};
	~CRCMode () {};

	//resultant
	UInt updateQuanStepsize ();	// Target bits and quantization level calculation
	Bool skipNextFrame () const {return m_skipNextFrame;}
	Bool firstFrame () const {return m_bfirstFrame;}
	UInt noCodedFrame () const {return m_Nc;}  // return the coded P frames

	//Operation
	Void resetSkipMode () {m_skipNextFrame = FALSE; m_bfirstFrame = TRUE;}
	Void resetFirstFrame () {m_bfirstFrame = FALSE;}
	Bool skipThisFrame ();
	Void reset (UInt uiFirstFrame, UInt uiLastFrame, UInt uiTemporalRate, 
				UInt uiBufferSize, Double mad, UInt uiBitsFirstFrame, Double dFrameHz);
	Void setMad (Double mad) {m_Ep = m_Ec; m_Ec = mad;}
	Void setQc (UInt QStep) {m_Qc = QStep;}
	Void updateRCModel (UInt uiBitsTotalCurr, UInt uiBitsHeadCurr);		// Update RD model

private:

	Void RCModelEstimator (UInt nWindowSize);	// Rate Control: RD model estimator

	Double m_X1;// 1st order coefficient
	Double m_X2;// 2nd order coefficient
	UInt m_Rs;	// bit rate for sequence. e.g. 24000 bits/sec	
	UInt m_Rf;	// bits used for the first frame, e.g. 10000 bits
	UInt m_Rc;	// bits used for the current frame after encoding
	UInt m_Rp;	// bits to be removed from the buffer per picture
	Double m_Ts;// number of seconds for the sequence, e.g. 10 sec
	Double m_Ec;// mean absolute difference for the current frame after motion compensation
	Double m_Ep;// mean absolute difference for the previous frame after motion compensation
	UInt m_Qc;	// quantization level used for the current frame
	UInt m_Qp;	// quantization level used for the previous frame
	UInt m_Nr;	// number of P frames remaining for encoding
	UInt m_Nc;	// number of P frames coded
	UInt m_Ns;	// distance between encoded frames
	Int m_Rr;	// number of bits remaining for encoding this sequence 
	UInt m_T;	// target bit to be used for the current frame
	UInt m_S;	// number of bits used for encoding the previous frame
	UInt m_Hc;	// header and motion vector bits used in the current frame
	UInt m_Hp;	// header and motion vector bits used in the previous frame
	UInt m_Bs;	// buffer size 
	Int m_B;	// current buffer level
	Bool m_skipNextFrame;						// TRUE if buffer is full
	Bool m_bfirstFrame;							// TRUE if this is the first frame
	UInt m_rgQp[RC_MAX_SLIDING_WINDOW];			// quantization levels for the past frames
	Double m_rgRp[RC_MAX_SLIDING_WINDOW];		// scaled encoding complexity used for the past frames;
	Bool m_rgRejected[RC_MAX_SLIDING_WINDOW];	// outliers
};

#endif	//__MODE_H