h263_enc_misc.cpp

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

            mBVOPfcodeBack ++;
    }
#endif
    mPlanes = (mIVOPdist == 1) ? 1 : (mBVOPdist == 0) ? 2 : 2 + mBVOPdist + 1;
    mSourceWidth = par->Width;
    mSourceHeight = par->Height;
    mSourceFormat = YUV_CHROMA_420;
    mExpandSize = 16;
    mExpandSizeA = (mExpandSize + 15) & (~15);
    mNumMacroBlockPerRow = (mSourceWidth + 15) / 16;
    mNumMacroBlockPerCol = (mSourceHeight + 15) / 16;
    mNumMacroBlockPerVOP = mNumMacroBlockPerRow * mNumMacroBlockPerCol;
    mStepLuma = mExpandSizeA * 2 + mNumMacroBlockPerRow * 16;
    mLumaPlaneSize = mStepLuma * (mExpandSizeA * 2 + mNumMacroBlockPerCol * 16);
    mStepChroma = (mExpandSizeA / 2) * 2 + mNumMacroBlockPerRow * 8;
    mChromaPlaneSize = mStepChroma * ((mExpandSizeA / 2) * 2 + mNumMacroBlockPerCol * 8);
    mSceneChangeThreshold = (mNumMacroBlockPerVOP * par->SceneChangeThreshold + 50) / 100;
    mIsInit = true;
    // buffers allocation
    mPtreY = new Ipp8u* [mPlanes];
    mPtreU = new Ipp8u* [mPlanes];
    mPtreV = new Ipp8u* [mPlanes];
    mPtrY = new Ipp8u* [mPlanes];
    mPtrU = new Ipp8u* [mPlanes];
    mPtrV = new Ipp8u* [mPlanes];
    for (i = 0; i < mPlanes; i ++) {
        if (mPtreY)
            mPtreY[i] = ippsMalloc_8u(mLumaPlaneSize);
        if (mPtreU)
            mPtreU[i] = ippsMalloc_8u(mChromaPlaneSize);
        if (mPtreV)
            mPtreV[i] = ippsMalloc_8u(mChromaPlaneSize);
    }
    mMBpos = ippsMalloc_32u(mNumMacroBlockPerVOP);
    mMBquant = ippsMalloc_8u(mNumMacroBlockPerVOP);
    mMBpredMV = (IppMotionVector*)ippsMalloc_8u(mNumMacroBlockPerVOP * sizeof(IppMotionVector));

    // init bitstream buffer
    if (par->bsBuffer && (par->bsBuffSize > 0)) {
        cBS.mBuffer = par->bsBuffer;
        cBS.mBuffSize = par->bsBuffSize;
        mbsAlloc = false;
    } else {
        cBS.mBuffSize = mSourceWidth * mSourceHeight;
        cBS.mBuffer = ippsMalloc_8u(cBS.mBuffSize);
        mbsAlloc = true;
    }
    cBS.mPtr = cBS.mBuffer;
    if (VOL.data_partitioned) {
        mBuffer_1 = ippsMalloc_8u(mSourceWidth * mSourceHeight >> 1);
        mBuffer_2 = ippsMalloc_8u(mSourceWidth * mSourceHeight >> 1);
    } else {
        mBuffer_1 = mBuffer_2 = NULL;
    }
    MBinfo = new h263_MacroBlock[mNumMacroBlockPerVOP];
//    mMEfastSADsize = (IPP_MAX(IPP_MAX(mPVOPsearchHor, mBVOPsearchHorForw), mBVOPsearchHorBack) * 2 + 1) * (IPP_MAX(IPP_MAX(mPVOPsearchVer, mBVOPsearchVerForw), mBVOPsearchVerBack) * 2 + 1);
    mMEfastSADsize = (mPVOPsearchHor * 2 + 1) * (mPVOPsearchVer * 2 + 1);
    mMEfastSAD = ippsMalloc_32s(mMEfastSADsize);
    if (!mPtreY || !mPtreU || !mPtreV || !mPtrY || !mPtrU || !mPtrV) {
        Close();
        ErrorMessage(VM_STRING("Not enough memory"));
        return H263_STS_ERR_NOMEM;
    }
    for (i = 0; i < mPlanes; i ++) {
        if (!mPtreY[i] || !mPtreU[i] || !mPtreV[i]) {
            Close();
            ErrorMessage(VM_STRING("Not enough memory"));
            return H263_STS_ERR_NOMEM;
        }
        mPtrY[i] = mPtreY[i] + mExpandSizeA + mExpandSizeA * mStepLuma;
        mPtrU[i] = mPtreU[i] + mExpandSizeA / 2 + (mExpandSizeA / 2) * mStepChroma;
        mPtrV[i] = mPtreV[i] + mExpandSizeA / 2 + (mExpandSizeA / 2) * mStepChroma;
    }
    if ((VOL.data_partitioned && (!mBuffer_1 || !mBuffer_2)) ||
        !cBS.mBuffer || !MBinfo || !mMEfastSAD ||
        (!mMBpredMV || !mMBquant || !mMBpos)) {
        Close();
        ErrorMessage(VM_STRING("Not enough memory"));
        return H263_STS_ERR_NOMEM;
    }
    {
        h263_MacroBlock *mbCurr = MBinfo;
        for (i = 0; i < mNumMacroBlockPerCol; i ++) {
            for (j = 0; j < mNumMacroBlockPerRow; j ++) {
                h263_MacroBlock *mbA = mbCurr - 1;
                h263_MacroBlock *mbB = mbCurr - 1 - mNumMacroBlockPerRow;
                h263_MacroBlock *mbC = mbCurr - mNumMacroBlockPerRow;
                mbCurr->block[0].predA = &mbA->block[1];
                mbCurr->block[0].predC = &mbC->block[2];
                mbCurr->block[1].predA = &mbCurr->block[0];
                mbCurr->block[1].predC = &mbC->block[3];
                mbCurr->block[2].predA = &mbA->block[3];
                mbCurr->block[2].predC = &mbCurr->block[0];
                mbCurr->block[3].predA = &mbCurr->block[2];
                mbCurr->block[3].predC = &mbCurr->block[1];
                mbCurr->block[4].predA = &mbA->block[4];
                mbCurr->block[4].predC = &mbC->block[4];
                mbCurr->block[5].predA = &mbA->block[5];
                mbCurr->block[5].predC = &mbC->block[5];
                mbCurr ++;
            }
        }

        for (j = 0; j < mNumMacroBlockPerRow; j ++) {
            h263_MacroBlock *mbCurr = &MBinfo[j];
            mbCurr->block[0].predC = NULL;
            mbCurr->block[1].predC = NULL;
            mbCurr->block[4].predC = NULL;
            mbCurr->block[5].predC = NULL;
        }

        for (i = 0; i < mNumMacroBlockPerCol; i ++) {
            h263_MacroBlock *mbCurr = &MBinfo[i*mNumMacroBlockPerRow];
            mbCurr->block[0].predA = NULL;
            mbCurr->block[2].predA = NULL;
            mbCurr->block[4].predA = NULL;
            mbCurr->block[5].predA = NULL;
        }
    }
    // setup frames
    if (mBVOPdist == 0) {
        mCurrPtrY = mPtrY[0];  mCurrPtrU = mPtrU[0];  mCurrPtrV = mPtrV[0];
        if (mIVOPdist > 1) {
            mForwPtrY = mPtrY[1];  mForwPtrU = mPtrU[1];  mForwPtrV = mPtrV[1];
        }
    } else {
        mCurrPtrY = mPtrY[0];  mCurrPtrU = mPtrU[0];  mCurrPtrV = mPtrV[0];
        mForwPtrY = mPtrY[1];  mForwPtrU = mPtrU[1];  mForwPtrV = mPtrV[1];
        mBackPtrY = mPtrY[0];  mBackPtrU = mPtrU[0];  mBackPtrV = mPtrV[0];
        mIndxBVOP = 2;
        mNumBVOP = 0;
    }
    // setup VOP time
    mVOPtime = mSyncTime = mSyncTimeB = 0;
    // calc length of macroblock_number code
    i = mNumMacroBlockPerVOP - 1;
    mMBNlength = 0;
    do {
        i >>= 1;
        mMBNlength ++;
    } while (i);
    return H263_STS_NOERR;
}



void ippVideoEncoderH263::ErrorMessage(const vm_char *msg)
{
    vm_debug_trace(4, __VM_STRING("H.263 encoder error: "));
    vm_debug_trace(4, msg);
    vm_debug_trace(4, __VM_STRING("\n"));
}

static void h263_ExpandFrameReplicate(Ipp8u *pSrcDstPlane, int frameWidth, int frameHeight, int expandPels, int step)
{
    Ipp8u   *pDst1, *pDst2, *pSrc1, *pSrc2;
    int     i, j;
    Ipp32u  t1, t2;

    pDst1 = pSrcDstPlane + step * expandPels;
    pDst2 = pDst1 + frameWidth + expandPels;
    if (expandPels == 8) {
        for (i = 0; i < frameHeight; i ++) {
            t1 = pDst1[8] + (pDst1[8] << 8);
            t2 = pDst2[-1] + (pDst2[-1] << 8);
            t1 = (t1 << 16) + t1;
            t2 = (t2 << 16) + t2;
            ((Ipp32u*)pDst1)[0] = t1;
            ((Ipp32u*)pDst1)[1] = t1;
            ((Ipp32u*)pDst2)[0] = t2;
            ((Ipp32u*)pDst2)[1] = t2;
            pDst1 += step;
            pDst2 += step;
        }
    } else if (expandPels == 16) {
        for (i = 0; i < frameHeight; i ++) {
            t1 = pDst1[16] + (pDst1[16] << 8);
            t2 = pDst2[-1] + (pDst2[-1] << 8);
            t1 = (t1 << 16) + t1;
            t2 = (t2 << 16) + t2;
            ((Ipp32u*)pDst1)[0] = t1;
            ((Ipp32u*)pDst1)[1] = t1;
            ((Ipp32u*)pDst1)[2] = t1;
            ((Ipp32u*)pDst1)[3] = t1;
            ((Ipp32u*)pDst2)[0] = t2;
            ((Ipp32u*)pDst2)[1] = t2;
            ((Ipp32u*)pDst2)[2] = t2;
            ((Ipp32u*)pDst2)[3] = t2;
            pDst1 += step;
            pDst2 += step;
        }
    } else {
        for (i = 0; i < frameHeight; i ++) {
            ippsSet_8u(pDst1[expandPels], pDst1, expandPels);
            ippsSet_8u(pDst2[-1], pDst2, expandPels);
            pDst1 += step;
            pDst2 += step;
        }
    }
    pDst1 = pSrcDstPlane;
    pSrc1 = pSrcDstPlane + expandPels * step;
    pDst2 = pSrc1 + frameHeight * step;
    pSrc2 = pDst2 - step;
    j = frameWidth + 2 * expandPels;
    for (i = 0; i < expandPels; i ++) {
        ippsCopy_8u(pSrc1, pDst1, j);
        ippsCopy_8u(pSrc2, pDst2, j);
        pDst1 += step;
        pDst2 += step;
    }
}


/*
//  padding frame: replication
*/
void ippVideoEncoderH263::ExpandFrame(Ipp8u *pY, Ipp8u *pU, Ipp8u *pV)
{
  if (mExpandSize) {
    int  wL, hL, wC, hC, es = (mExpandSize + 1) >> 1;

    wL = mNumMacroBlockPerRow * 16;
    hL = mNumMacroBlockPerCol * 16;
    wC = mSourceWidth >> 1;
    hC = mSourceHeight >> 1;

    h263_ExpandFrameReplicate(pY-mExpandSize*mStepLuma-mExpandSize, wL, hL, mExpandSize, mStepLuma);
    h263_ExpandFrameReplicate(pU-es*mStepChroma-es, wC, hC, es, mStepChroma);
    h263_ExpandFrameReplicate(pV-es*mStepChroma-es, wC, hC, es, mStepChroma);
  }
}


int ippVideoEncoderH263::GetFrameWriteInfo(Ipp8u **pY, Ipp8u **pU, Ipp8u **pV, int *stepLuma, int *stepChroma)
{
    if (!mIsInit)
        return H263_STS_ERR_NOTINIT;
    *pY = mCurrPtrY;
    *pU = mCurrPtrU;
    *pV = mCurrPtrV;
    *stepLuma = mStepLuma;
    *stepChroma = mStepChroma;
    return H263_STS_NOERR;
}

void ippVideoEncoderH263::OBMC_Macroblock(h263_MacroBlock *pMBinfo, IppMotionVector *mvCur, int colNum, int rowNum, IppiRect limitRectL, Ipp8u *pYr, int stepYr, Ipp8u *pYc, int stepYc)
{
  IppMotionVector mvOBMCL, mvOBMCU, mvOBMCR, mvOBMCB, *mvLeft, *mvUpper, *mvRight;
  int mbPerRow = mNumMacroBlockPerRow, dx, dy, rt;

  /* get Right MV */
  if (colNum == mNumMacroBlockPerRow - 1)
    mvRight = &mvCur[1];
//  else if ((pMBinfo[1].type & 0xC0) == 0x80) /* INTRA(_Q), no vector for B-part */
  else if (pMBinfo[1].type == IPPVC_MBTYPE_INTRA || pMBinfo[1].type == IPPVC_MBTYPE_INTRA_Q)
    mvRight = &mvCur[1];
  else
    mvRight = pMBinfo[1].mv;
  /* get Left MV */
  if (colNum == 0)
    mvLeft = mvCur - 1;
//  else if ((pMBinfo[-1].type & 0xC0) == 0x80)
  else if (pMBinfo[-1].type == IPPVC_MBTYPE_INTRA || pMBinfo[1].type == IPPVC_MBTYPE_INTRA_Q)
    mvLeft = mvCur - 1;
  else
    mvLeft = pMBinfo[-1].mv;
  /* get Upper MV */
  if (rowNum == 0)
    mvUpper = mvCur - 2;
//  else if ((pMBinfo[-mNumMacroBlockPerRow].type & 0xC0) == 0x80)
  else if (pMBinfo[-mNumMacroBlockPerRow].type == IPPVC_MBTYPE_INTRA || pMBinfo[-mNumMacroBlockPerRow].type == IPPVC_MBTYPE_INTRA_Q)
    mvUpper = mvCur - 2;
  else
    mvUpper = pMBinfo[-mNumMacroBlockPerRow].mv;

  dx = colNum * 16;
  dy = rowNum * 16;
  rt = VOP.vop_rounding_type;

  h263_LimitMV(&mvLeft[1], &mvOBMCL, &limitRectL, dx, dy, 8);
  h263_LimitMV(&mvUpper[2], &mvOBMCU, &limitRectL, dx, dy, 8);
  h263_LimitMV(&mvCur[1], &mvOBMCR, &limitRectL, dx, dy, 8);
  h263_LimitMV(&mvCur[2], &mvOBMCB, &limitRectL, dx, dy, 8);
  ippiOBMC8x8HP_MPEG4_8u_C1R(pYr, stepYr, pYc, stepYc, &mvCur[0], &mvOBMCL, &mvOBMCR, &mvOBMCU, &mvOBMCB, rt);
  h263_LimitMV(&mvCur[0], &mvOBMCL, &limitRectL, dx+8, dy, 8);
  h263_LimitMV(&mvUpper[3], &mvOBMCU, &limitRectL, dx+8, dy, 8);
  h263_LimitMV(&mvRight[0], &mvOBMCR, &limitRectL, dx+8, dy, 8);
  h263_LimitMV(&mvCur[3], &mvOBMCB, &limitRectL, dx+8, dy, 8);
  ippiOBMC8x8HP_MPEG4_8u_C1R(pYr+8, stepYr, pYc+8, stepYc, &mvCur[1], &mvOBMCL, &mvOBMCR, &mvOBMCU, &mvOBMCB, rt);
  h263_LimitMV(&mvLeft[3], &mvOBMCL, &limitRectL, dx, dy+8, 8);
  h263_LimitMV(&mvCur[0], &mvOBMCU, &limitRectL, dx, dy+8, 8);
  h263_LimitMV(&mvCur[3], &mvOBMCR, &limitRectL, dx, dy+8, 8);
  ippiOBMC8x8HP_MPEG4_8u_C1R(pYr+stepYr*8, stepYr, pYc+stepYc*8, stepYc, &mvCur[2], &mvOBMCL, &mvOBMCR, &mvOBMCU, &mvCur[2], rt);
  h263_LimitMV(&mvCur[2], &mvOBMCL, &limitRectL, dx+8, dy+8, 8);
  h263_LimitMV(&mvCur[1], &mvOBMCU, &limitRectL, dx+8, dy+8, 8);
  h263_LimitMV(&mvRight[2], &mvOBMCR, &limitRectL, dx+8, dy+8, 8);
  ippiOBMC8x8HP_MPEG4_8u_C1R(pYr+8+stepYr*8, stepYr, pYc+8+stepYc*8, stepYc, &mvCur[3], &mvOBMCL, &mvOBMCR, &mvOBMCU, &mvCur[3], rt);
}