predictmv.c

adi bf533视频编码程序

#include "ippdefs.h"

//added by gary;
#include "ippVideoEncoderMPEG4.h"

//#include "global.h"
extern    double mPSNR_Y,mPSNR_U,mPSNR_V;
extern    int     mSourceFormat;          // 4:2:0, 4:2:2, 4:4:4, ...
extern    int     mSourceWidth;           // width
extern    int     mSourceHeight;          // height
extern    int     mExpandSize;
extern    int     mNumMacroBlockPerRow;
extern    int     mNumMacroBlockPerCol;
	
extern    int     mStepLuma;
extern    int     mStepChroma;
	
extern    int     mLumaPlaneSize;
extern    int     mChromaPlaneSize;
extern    int     mPlanes;

extern    int    VideoEncoder_mIsInit;
extern    int     mExpandSizeA;
extern    int     VideoEncoder_mError;
extern    Ipp8u  **mPtrY, **mPtrU, **mPtrV;
//extern    Ipp8u  **mPtreY, **mPtreU, **mPtreV;

extern    Ipp8u     *mCurrPtrY, *mCurrPtrU, *mCurrPtrV;
extern    Ipp8u     *mForwPtrY, *mForwPtrU, *mForwPtrV;
extern    Ipp8u     *mBackPtrY, *mBackPtrU, *mBackPtrV;
//extern    int        mNumOfFrames;
extern    unsigned int        VideoEncoderMPEG4_mFrameCount;
//extern	int     mQuantIVOP, mQuantPVOP, mQuantBVOP, mQuantSVOP;
extern	int     mQuantIVOP, mQuantPVOP;						// ----no bvop, no svop;

//extern    int     mIVOPdist, mPVOPdist, mBVOPdist;		__070613_2__no_bvop
extern    int     mIVOPdist, mPVOPdist;
extern    int     mPVOPsearchHor, mPVOPsearchVer;
//extern    int     mBVOPsearchHorForw, mBVOPsearchVerForw;	__070613_2__no_bvop
//extern    int     mBVOPsearchHorBack, mBVOPsearchVerBack;	__070613_2__no_bvop
extern    int     mPVOPfcodeForw;
//extern    int     mBVOPfcodeForw;		__070613_2__no_bvop
//extern   int     mBVOPfcodeBack;		__070613_2__no_bvop
extern    Ipp16s  mDefDC;
//extern    int     mMEaccuracy;		----no use;
//extern    int     mMEalgorithm;		----no use;
//extern    Ipp32s  *mMEfastSAD;		//----since no fastSAD, commented;

//extern    int     mMEfastSADsize;		//----since no fastSAD, commented;

//extern    int     mMEthrSAD16x16;		----no use;
//extern 	  int	  mMEthrSAD8x8;		----no use;
//extern 	  int	  mMEthr4MV;		----no 4mv;
extern 	  int     mMEthrIntra;

extern    int     mCalcPSNR;
extern    int     mVOPtime;
//extern    int     mIndxBVOP, mTRB, mTRD;		__070613_2__no_bvop

/*************************		----redefine;	commented by gary
struct IppMotionVector
{
  Ipp16s  dx;
  Ipp16s  dy;
} ;
*************************/

/*************************		----redefine;	commented by gary
// MacroBlock Info
struct mp4_MacroBlock {
    int         type;
    int         not_coded;
    int         quant;
    int        *predQuantC[6];
    int        *predQuantA[6];
    Ipp16s     *predDcA[6];
    Ipp16s     *predDcB[6];
    Ipp16s     *predDcC[6];
    Ipp16s     *predAcA[6];
    Ipp16s     *predAcC[6];
    Ipp16s      dct_acA[6][8];
    Ipp16s      dct_acC[6][8];
    Ipp16s      dct_dc[6];
  struct  IppMotionVector mv[4];
};
**************************/

static inline Ipp16s mp4_Median(Ipp16s a, Ipp16s b, Ipp16s c)
{
    if (a > b) {
        Ipp16s  t = a; a = b; b = t;
    }
    return (b <= c) ? b : (c >= a) ? c : a;
}


// used for short_viseo_header
/***************************
void PredictMV(struct mp4_MacroBlock *MBcurr, int i, int j, struct IppMotionVector *mvPred)
{
    struct  IppMotionVector *mvLeft;
	struct  IppMotionVector *mvTop;
	struct  IppMotionVector *mvRight;

    mvLeft  = MBcurr[-1].mv;
    mvTop   = MBcurr[-mNumMacroBlockPerRow].mv;
    mvRight = MBcurr[-mNumMacroBlockPerRow+1].mv;
    // block 0
    if (i == 0 && j == 0) {
        mvPred[0].dx = mvPred[0].dy = 0;
    } else if (j == 0) {
        mvPred[0].dx = mp4_Median(0, mvTop[0].dx, mvRight[0].dx);
        mvPred[0].dy = mp4_Median(0, mvTop[0].dy, mvRight[0].dy);
    } else if (i == 0) {
        mvPred[0] = mvLeft[0];
    } else if (j == mNumMacroBlockPerRow - 1) {
        mvPred[0].dx = mp4_Median(0, mvLeft[0].dx, mvTop[0].dx);
        mvPred[0].dy = mp4_Median(0, mvLeft[0].dy, mvTop[0].dy);
    } else {
        mvPred[0].dx = mp4_Median(mvLeft[0].dx, mvTop[0].dx, mvRight[0].dx);
        mvPred[0].dy = mp4_Median(mvLeft[0].dy, mvTop[0].dy, mvRight[0].dy);
    }
}
*****************************/

/*****************************
void Predict1MV(struct mp4_MacroBlock *MBcurr, int i, int j, struct IppMotionVector *mvPred)
{
   struct  IppMotionVector *mvLeft;
	struct  IppMotionVector *mvTop;
	struct  IppMotionVector *mvRight;
 //IppMotionVector *mvRight,*mvTop,*mvLeft;
    mvLeft  = MBcurr[-1].mv;
    mvTop   = MBcurr[-mNumMacroBlockPerRow].mv;
    mvRight = MBcurr[-mNumMacroBlockPerRow+1].mv;
    if (i == 0 && j == 0) {
        mvPred[0].dx = mvPred[0].dy = 0;
    } else if (j == 0) {
        mvPred[0].dx = mp4_Median(0, mvTop[2].dx, mvRight[2].dx);
        mvPred[0].dy = mp4_Median(0, mvTop[2].dy, mvRight[2].dy);
    } else if (i == 0) {
        mvPred[0] = mvLeft[1];
    } else if (j == mNumMacroBlockPerRow - 1) {
        mvPred[0].dx = mp4_Median(0, mvLeft[1].dx, mvTop[2].dx);
        mvPred[0].dy = mp4_Median(0, mvLeft[1].dy, mvTop[2].dy);
    } else {
        mvPred[0].dx = mp4_Median(mvLeft[1].dx, mvTop[2].dx, mvRight[2].dx);
        mvPred[0].dy = mp4_Median(mvLeft[1].dy, mvTop[2].dy, mvRight[2].dy);
    }
}
*****************************/
/****************************
void Predict1MV(struct mp4_MacroBlock *MBcurr, int i, int j, struct IppMotionVector *mvPred)
{
	struct  IppMotionVector mvLeft;
	struct  IppMotionVector mvTop;
	struct  IppMotionVector mvRight;
	//IppMotionVector *mvRight,*mvTop,*mvLeft;
	mvLeft  = MBcurr[-1].mv;
	mvTop   = MBcurr[-mNumMacroBlockPerRow].mv;
	mvRight = MBcurr[-mNumMacroBlockPerRow+1].mv;
	if (i == 0 && j == 0) {
	    mvPred[0].dx = mvPred[0].dy = 0;
	} else if (j == 0) {
	    mvPred[0].dx = mp4_Median(0, mvTop.dx, mvRight.dx);
	    mvPred[0].dy = mp4_Median(0, mvTop.dy, mvRight.dy);
	} else if (i == 0) {
	    mvPred[0] = mvLeft;
	} else if (j == mNumMacroBlockPerRow - 1) {
	    mvPred[0].dx = mp4_Median(0, mvLeft.dx, mvTop.dx);
	    mvPred[0].dy = mp4_Median(0, mvLeft.dy, mvTop.dy);
	} else {
	    mvPred[0].dx = mp4_Median(mvLeft.dx, mvTop.dx, mvRight.dx);
	    mvPred[0].dy = mp4_Median(mvLeft.dy, mvTop.dy, mvRight.dy);
	}
}
*****************************/

/****************************
void Predict1MV(struct IppMotionVector *refmv, int i, int j, struct IppMotionVector *mvPred)
{
	struct  IppMotionVector mvLeft;
	struct  IppMotionVector mvTop;
	struct  IppMotionVector mvRight;
	//IppMotionVector *mvRight,*mvTop,*mvLeft;
	mvLeft  = refmv[-1];
	mvTop   = refmv[0];
	mvRight = refmv[1];
	if (i == 0 && j == 0) {
	    mvPred[0].dx = mvPred[0].dy = 0;
	} else if (j == 0) {
	    mvPred[0].dx = mp4_Median(0, mvTop.dx, mvRight.dx);
	    mvPred[0].dy = mp4_Median(0, mvTop.dy, mvRight.dy);
	} else if (i == 0) {
	    mvPred[0] = mvLeft;
	} else if (j == mNumMacroBlockPerRow - 1) {
	    mvPred[0].dx = mp4_Median(0, mvLeft.dx, mvTop.dx);
	    mvPred[0].dy = mp4_Median(0, mvLeft.dy, mvTop.dy);
	} else {
	    mvPred[0].dx = mp4_Median(mvLeft.dx, mvTop.dx, mvRight.dx);
	    mvPred[0].dy = mp4_Median(mvLeft.dy, mvTop.dy, mvRight.dy);
	}
}
****************************/


/*****************************/
void Predict1MV(struct IppMotionVector *refmv, int i, struct IppMotionVector *mvPred)
{
	if(i==0) {
	    *mvPred = refmv[-1];
	    return;
	}
    mvPred->dx = mp4_Median(refmv[-1].dx, refmv[0].dx, refmv[1].dx);
    mvPred->dy = mp4_Median(refmv[-1].dy, refmv[0].dy, refmv[1].dy);
}
/*****************************/

/*****************************
void Predict3MV( struct mp4_MacroBlock *MBcurr, int i, int j,struct IppMotionVector *mvPred, struct IppMotionVector *mvCurr)
{
    struct  IppMotionVector *mvLeft;
	struct  IppMotionVector *mvTop;
	struct  IppMotionVector *mvRight;
    mvLeft  = MBcurr[-1].mv;
    mvTop   = MBcurr[-mNumMacroBlockPerRow].mv;
    mvRight = MBcurr[-mNumMacroBlockPerRow+1].mv;
    // block 1
    if (i == 0) {
        mvPred[1] = mvCurr[0];
    } else if (j == mNumMacroBlockPerRow - 1) {
        mvPred[1].dx = mp4_Median(0, mvCurr[0].dx, mvTop[3].dx);
        mvPred[1].dy = mp4_Median(0, mvCurr[0].dy, mvTop[3].dy);
    } else {
        mvPred[1].dx = mp4_Median(mvCurr[0].dx, mvTop[3].dx, mvRight[2].dx);
        mvPred[1].dy = mp4_Median(mvCurr[0].dy, mvTop[3].dy, mvRight[2].dy);
    }
    // block 2
    if (j == 0) {
        mvPred[2].dx = mp4_Median(0, mvCurr[0].dx, mvCurr[1].dx);
        mvPred[2].dy = mp4_Median(0, mvCurr[0].dy, mvCurr[1].dy);
    } else {
        mvPred[2].dx = mp4_Median(mvLeft[3].dx, mvCurr[0].dx, mvCurr[1].dx);
        mvPred[2].dy = mp4_Median(mvLeft[3].dy, mvCurr[0].dy, mvCurr[1].dy);
    }
    // block 3
    mvPred[3].dx = mp4_Median(mvCurr[2].dx, mvCurr[0].dx, mvCurr[1].dx);
    mvPred[3].dy = mp4_Median(mvCurr[2].dy, mvCurr[0].dy, mvCurr[1].dy);
}
*****************************/