ippvideoencodermpeg4_vop.cpp

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

    IppMotionVector *mvLeft, *mvTop, *mvRight;

    mvLeft  = MBcurr[-1].mv;
    mvTop   = MBcurr[-mNumMacroBlockPerRow].mv;
    mvRight = MBcurr[-mNumMacroBlockPerRow+1].mv;
    if (VOP.gob_resync)
        i = (VOP.source_format <= 3) ? 0 : (i & ((VOP.source_format == 4) ? 1 : 3));
    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 ippVideoEncoderMPEG4::Predict1MV(mp4_MacroBlock *MBcurr, int i, int j, IppMotionVector *mvPred)
{
    IppMotionVector *mvLeft, *mvTop, *mvRight;

    // block 0
    mvLeft  = MBcurr[-1].mv;
    mvTop   = MBcurr[-mNumMacroBlockPerRow].mv;
    mvRight = MBcurr[-mNumMacroBlockPerRow+1].mv;
    if (VOL.resync_marker_disable) {
        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);
        }
    } else {
        int   validLeft, validTop, validRight;

        if (j > 0)
            validLeft = MBcurr[-1].validPredInter;
        else
            validLeft = 0;
        if (i > 0)
            validTop = MBcurr[-mNumMacroBlockPerRow].validPredInter;
        else
            validTop = 0;
        if ((i > 0) && (j < mNumMacroBlockPerRow - 1))
            validRight = MBcurr[-mNumMacroBlockPerRow+1].validPredInter;
        else
            validRight = 0;
        switch ((validLeft << 2) | (validTop << 1) | validRight) {
        case 7:
            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);
            break;
        case 6:
            mvPred[0].dx = mp4_Median(mvLeft[1].dx, mvTop[2].dx, 0);
            mvPred[0].dy = mp4_Median(mvLeft[1].dy, mvTop[2].dy, 0);
            break;
        case 5:
            mvPred[0].dx = mp4_Median(mvLeft[1].dx, 0, mvRight[2].dx);
            mvPred[0].dy = mp4_Median(mvLeft[1].dy, 0, mvRight[2].dy);
            break;
        case 4:
            mvPred[0] = mvLeft[1];
            break;
        case 3:
            mvPred[0].dx = mp4_Median(0, mvTop[2].dx, mvRight[2].dx);
            mvPred[0].dy = mp4_Median(0, mvTop[2].dy, mvRight[2].dy);
            break;
        case 2:
            mvPred[0] = mvTop[2];
            break;
        case 1:
            mvPred[0] = mvRight[2];
            break;
        default:
            mvPred[0].dx = mvPred[0].dy = 0;
            break;
        }
    }
}


void ippVideoEncoderMPEG4::Predict3MV(mp4_MacroBlock *MBcurr, int i, int j, IppMotionVector *mvPred, IppMotionVector *mvCurr)
{
    IppMotionVector *mvLeft, *mvTop, *mvRight;

    mvLeft  = MBcurr[-1].mv;
    mvTop   = MBcurr[-mNumMacroBlockPerRow].mv;
    mvRight = MBcurr[-mNumMacroBlockPerRow+1].mv;
    if (VOL.resync_marker_disable) {
        // block 1
        if (i == 0) {
            mvPred[1] = mvCurr[0];
        } else if (j == mNumMacroBlockPerRow - 1) {
            mvPred[1].dx = mp4_Median(mvCurr[0].dx, mvTop[3].dx, 0);
            mvPred[1].dy = mp4_Median(mvCurr[0].dy, mvTop[3].dy, 0);
        } 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);
    } else {
        int   validLeft, validTop, validRight;

        if (j > 0)
            validLeft = MBcurr[-1].validPredInter;
        else
            validLeft = 0;
        if (i > 0)
            validTop = MBcurr[-mNumMacroBlockPerRow].validPredInter;
        else
            validTop = 0;
        if ((i > 0) && (j < mNumMacroBlockPerRow - 1))
            validRight = MBcurr[-mNumMacroBlockPerRow+1].validPredInter;
        else
            validRight = 0;
        // block 1
        switch ((validTop << 1) | validRight) {
        case 3:
            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);
            break;
        case 2:
            mvPred[1].dx = mp4_Median(mvCurr[0].dx, mvTop[3].dx, 0);
            mvPred[1].dy = mp4_Median(mvCurr[0].dy, mvTop[3].dy, 0);
            break;
        case 1:
            mvPred[1].dx = mp4_Median(mvCurr[0].dx, 0, mvRight[2].dx);
            mvPred[1].dy = mp4_Median(mvCurr[0].dy, 0, mvRight[2].dy);
            break;
        default:
            mvPred[1] = mvCurr[0];
            break;
        }
        // block 2
        if (validLeft) {
            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);
        } else {
            mvPred[2].dx = mp4_Median(0, mvCurr[0].dx, mvCurr[1].dx);
            mvPred[2].dy = mp4_Median(0, 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);
    }
}


void ippVideoEncoderMPEG4::EncodeMV(IppMotionVector *mv, int fcode, int mbType)
{
    int  i, nMV = (mbType == IPPVC_MBTYPE_INTER4V) ? 4 : 1;

    for (i = 0; i < nMV; i ++) {
        if (fcode == 1) {
            cBS.PutBits(mVLC_MVD_TB12[mv[i].dx+32].code, mVLC_MVD_TB12[mv[i].dx+32].len);
            cBS.PutBits(mVLC_MVD_TB12[mv[i].dy+32].code, mVLC_MVD_TB12[mv[i].dy+32].len);
        } else {
            int f, a, b;

            f = fcode - 1;
            if (mv[i].dx == 0) {
                cBS.PutBits(mVLC_MVD_TB12[32].code, mVLC_MVD_TB12[32].len);
            } else {
                if (mv[i].dx > 0) {
                    a = ((mv[i].dx - 1) >> f) + 1;
                    b = mv[i].dx - 1 - ((a - 1) << f);
                } else {
                    a = ((-mv[i].dx - 1) >> f) + 1;
                    b = -mv[i].dx - 1 - ((a - 1) << f);
                    a = -a;
                }
                cBS.PutBits(mVLC_MVD_TB12[a+32].code, mVLC_MVD_TB12[a+32].len);
                cBS.PutBits(b, f);
            }
            if (mv[i].dy == 0) {
                cBS.PutBits(mVLC_MVD_TB12[32].code, mVLC_MVD_TB12[32].len);
            } else {
                if (mv[i].dy > 0) {
                    a = ((mv[i].dy - 1) >> f) + 1;
                    b = mv[i].dy - 1 - ((a - 1) << f);
                } else {
                    a = ((-mv[i].dy - 1) >> f) + 1;
                    b = -mv[i].dy - 1 - ((a - 1) << f);
                    a = -a;
                }
                cBS.PutBits(mVLC_MVD_TB12[a+32].code, mVLC_MVD_TB12[a+32].len);
                cBS.PutBits(b, f);
            }
        }
    }
}


inline void ippVideoEncoderMPEG4::EncodeMCBPC_I(int mbtype, int mcbpc)
{
    if (mbtype == IPPVC_MBTYPE_INTRA) {
        if (mcbpc == 0)
            cBS.PutBit(1);
        else
            cBS.PutBits(mcbpc, 3);
    } else {
        if (mcbpc == 0)
            cBS.PutBits(1, 4);
        else
            cBS.PutBits(mcbpc, 6);
    }
}


inline void ippVideoEncoderMPEG4::EncodeCBPY_I(int pat)
{
    cBS.PutBits(mVLC_CBPY_TB8[pat].code, mVLC_CBPY_TB8[pat].len);
}


inline void ippVideoEncoderMPEG4::EncodeMCBPC_P(int mbtype, int pat)
{
    cBS.PutBits(mVLC_MCBPC_TB7[mbtype*4+pat].code, mVLC_MCBPC_TB7[mbtype*4+pat].len);
}


inline void ippVideoEncoderMPEG4::EncodeCBPY_P(int mbtype, int pat)
{
    if (mbtype <= IPPVC_MBTYPE_INTER4V)
        pat = 15 - pat;
    cBS.PutBits(mVLC_CBPY_TB8[pat].code, mVLC_CBPY_TB8[pat].len);
}


void ippVideoEncoderMPEG4::PredictIntraDCAC(mp4_MacroBlock *MBcurr, Ipp16s *dcCurr, int quant, int *predictDir, int predAC, int *pSum0, int *pSum1, int *nzCount)
{
    int         predDir, dc, k, zC, zA, predQuantA, predQuantC, dcScaler, sum0 = 0, sum1 = 0, i;
    Ipp16s      dcA, dcB, dcC, dcP;
    Ipp16s      *predAcA, *predAcC;
    mp4_Block   *bCurr;

    for (i = 0; i < 6; i ++) {
        bCurr = &MBcurr->block[i];
        dcScaler = i < 4 ? mp4_DCScalerLuma_[quant] : mp4_DCScalerChroma_[quant];
        dcA = bCurr->predA ? (bCurr->predA->validPredIntra ? bCurr->predA->dct_dc : mDefDC) : mDefDC;
        dcB = bCurr->predB ? (bCurr->predB->validPredIntra ? bCurr->predB->dct_dc : mDefDC) : mDefDC;
        dcC = bCurr->predC ? (bCurr->predC->validPredIntra ? bCurr->predC->dct_dc : mDefDC) : mDefDC;
        if (mp4_Abs(dcA - dcB) < mp4_Abs(dcB - dcC)) {
            predDir = IPPVC_SCAN_HORIZONTAL;
            dcP = dcC;
        } else {
            predDir = IPPVC_SCAN_VERTICAL;
            dcP = dcA;
        }
        dc = bCurr->dct_dcq = *dcCurr;
        *dcCurr = (Ipp16s)(dc - mp4_DivIntraDC(dcP, dcScaler));
        // correct nzCount
        if (dc == 0 && *dcCurr != 0)
            nzCount[i] ++;
        else if (dc != 0 && *dcCurr == 0)
            nzCount[i] --;
        bCurr->dct_dc = (Ipp16s)(dc * dcScaler);
        zC = zA = 0;
        for (k = 1; k < 8; k ++) {
            bCurr->dct_acC[k] = dcCurr[k];
            if (dcCurr[k])
                zC = 1;
            bCurr->dct_acA[k] = dcCurr[k*8];
            if (dcCurr[k*8])
                zA = 1;
        }
        bCurr->dct_acC[0] = (Ipp16s)zC;
        bCurr->dct_acA[0] = (Ipp16s)zA;
        if (predAC) {
            predAcA = bCurr->predA ? (bCurr->predA->validPredIntra ? bCurr->predA->dct_acA : NULL) : NULL;
            predAcC = bCurr->predC ? (bCurr->predC->validPredIntra ? bCurr->predC->dct_acC : NULL) : NULL;
            if (predDir == IPPVC_SCAN_HORIZONTAL && predAcC) {
                if (predAcC[0]) {
                    predQuantC = bCurr->predC->quant;
                    if (predQuantC == bCurr->quant)
                        for (k = 1; k < 8; k ++) {
                            sum0 += mp4_Abs(dcCurr[k]);
                            dcCurr[k] = (Ipp16s)(dcCurr[k] - predAcC[k]);
                            sum1 += mp4_Abs(dcCurr[k]);
                        }
                    else
                        for (k = 1; k < 8; k ++) {
                            sum0 += mp4_Abs(dcCurr[k]);
                            dcCurr[k] = (Ipp16s)(dcCurr[k] - mp4_DivIntraAC(predAcC[k] * predQuantC, bCurr->quant));
                            sum1 += mp4_Abs(dcCurr[k]);
                        }
                }
            } else if (predDir == IPPVC_SCAN_VERTICAL && predAcA) {
                if (predAcA[0]) {
                    predQuantA = bCurr->predA->quant;
                    if (predQuantA == bCurr->quant)
                        for (k = 1; k < 8; k ++) {
                            sum0 += mp4_Abs(dcCurr[k*8]);
                            dcCurr[k*8] = (Ipp16s)(dcCurr[k*8] - predAcA[k]);
                            sum1 += mp4_Abs(dcCurr[k*8]);
                        }
                    else
                        for (k = 1; k < 8; k ++) {
                            sum0 += mp4_Abs(dcCurr[k*8]);
                            dcCurr[k*8] = (Ipp16s)(dcCurr[k*8] - mp4_DivIntraAC(predAcA[k] * predQuantA, bCurr->quant));
                            sum1 += mp4_Abs(dcCurr[k*8]);
                        }
                }
            }
        } else
            predDir = IPPVC_SCAN_ZIGZAG;
        predictDir[i] = predDir;
        dcCurr += 64;
    }