mp4_enc_misc.cpp

audio-video-codecs.rar语音编解码器

        if (!mOptFlowPoints || !mOptFlowPtSts || !mOptFlowPatchDiff ||!mOptFlowMask)
            stsAlloc = ippStsMemAllocErr;
#else
        mp4_ClipR(VOL.no_of_sprite_warping_points, 1);
#endif
    } else {
        mWarpSpec = NULL;
        mGMCPredY = mGMCPredU = mGMCPredV = NULL;
#ifdef USE_CV_GME
        mPyramid[0] = mPyramid[1] = NULL;
#endif
    }
    if (!VOL.short_video_header) {
        ippiQuantInvIntraGetSize_MPEG4(&specSize);
        mQuantInvIntraSpec = (IppiQuantInvIntraSpec_MPEG4*)ippsMalloc_8u(specSize);
        ippiQuantInvInterGetSize_MPEG4(&specSize);
        mQuantInvInterSpec = (IppiQuantInvInterSpec_MPEG4*)ippsMalloc_8u(specSize);
        ippiQuantIntraGetSize_MPEG4(&specSize);
        mQuantIntraSpec = (IppiQuantIntraSpec_MPEG4*)ippsMalloc_8u(specSize);
        ippiQuantInterGetSize_MPEG4(&specSize);
        mQuantInterSpec = (IppiQuantInterSpec_MPEG4*)ippsMalloc_8u(specSize);
        if (!mQuantInvIntraSpec || !mQuantInvInterSpec || !mQuantIntraSpec || !mQuantInterSpec)
            stsAlloc = ippStsMemAllocErr;
        mMBpos = NULL;
        mMBquant = NULL;
        mMBpredMV = NULL;
    } else {
        mQuantInvIntraSpec = NULL;
        mQuantInvInterSpec = NULL;
        mQuantIntraSpec = NULL;
        mQuantInterSpec = NULL;
        mMBpos = ippsMalloc_32u(mNumMacroBlockPerVOP);
        mMBquant = ippsMalloc_8u(mNumMacroBlockPerVOP);
        mMBpredMV = (IppMotionVector*)ippsMalloc_8u(mNumMacroBlockPerVOP * sizeof(IppMotionVector));
        if (!mMBpos || !mMBquant || !mMBpredMV)
            stsAlloc = ippStsMemAllocErr;
    }
    intBuffSize = mSourceWidth * mSourceHeight;
    if (par->bsBuffer && (par->bsBuffSize > 0)) {
        cBS.Init(par->bsBuffer, par->bsBuffSize);
        mbsAlloc = false;
    } else {
        Ipp8u *buff = ippsMalloc_8u(intBuffSize);
        if (!buff)
            stsAlloc = ippStsMemAllocErr;
        cBS.Init(buff, intBuffSize);
        mbsAlloc = true;
    }
    mNumThreads = 1;
#ifdef _OMP_KARABAS
    mThreadingAlg = 1;
    if (par->RateControl == 2 || VOL.data_partitioned || (!VOL.short_video_header && mInsertResync))
        mThreadingAlg = 1;
    if (mThreadingAlg == 1)
        VOL.resync_marker_disable = 0;
    mNumThreads = numThreads;
    if (numThreads < 1) {
        mNumThreads = 1;
#ifdef _OPENMP
#pragma omp parallel
        {
#pragma omp master
            {
                mNumThreads = omp_get_num_threads();
            }
        }
#endif
    }
    if (mNumThreads > mNumMacroBlockPerCol)
        mNumThreads = mNumMacroBlockPerCol;
    if (VOL.short_video_header && mThreadingAlg == 1) {
        if (mNumThreads > VOP.num_gobs_in_vop)
            mNumThreads = VOP.num_gobs_in_vop;
    }
    MBinfoMT = (mp4_MacroBlockMT*)ippsMalloc_8u(mNumMacroBlockPerRow * mNumThreads * sizeof(mp4_MacroBlockMT));
    mSliceMT = new mp4_Slice[mNumThreads];
    mCurRowMT = new Ipp32s[mNumMacroBlockPerCol];
    if (!MBinfoMT || !mSliceMT || !mCurRowMT)
        stsAlloc = ippStsMemAllocErr;
    else
        ippsZero_8u((Ipp8u*)MBinfoMT, mNumMacroBlockPerRow * mNumThreads * sizeof(mp4_MacroBlockMT));
    if (mNumThreads > 1) {
        mBuffer = ippsMalloc_8u(intBuffSize * (mNumThreads - 1));
        if (!mBuffer)
            stsAlloc = ippStsMemAllocErr;
    }
#ifdef _OPENMP
    mLockMT = new omp_lock_t[mNumMacroBlockPerCol];
    if (mLockMT) {
        for (i = 0; i < mNumMacroBlockPerCol; i ++)
            omp_init_lock(mLockMT+i);
    } else
        stsAlloc = ippStsMemAllocErr;
#endif
#else
    numThreads = numThreads;  // disable warning : unreferenced formal parameter
#endif // _OMP_KARABAS
    if (VOL.data_partitioned) {
        mBuffer_1 = ippsMalloc_8u(intBuffSize * mNumThreads);
        mBuffer_2 = ippsMalloc_8u(intBuffSize * mNumThreads);
        if (!mBuffer_1 || !mBuffer_2)
            stsAlloc = ippStsMemAllocErr;
    } else {
        mBuffer_1 = mBuffer_2 = NULL;
    }
    MBinfo = new mp4_MacroBlock[mNumMacroBlockPerVOP];
    if (!MBinfo)
        stsAlloc = ippStsMemAllocErr;
    else
        ippsZero_8u((Ipp8u*)MBinfo, mNumMacroBlockPerVOP * sizeof(mp4_MacroBlock));
#ifdef USE_ME_SADBUFF
    if (mMEflags & ME_AUTO_RANGE)
        mMEfastSADsize = (63 * 2 + 1) * (63 * 2 + 1);
    else
        mMEfastSADsize = (IPP_MAX(IPP_MAX(mPVOPsearchHor, mBVOPsearchHorForw), mBVOPsearchHorBack) * 2 + 1) * (IPP_MAX(IPP_MAX(mPVOPsearchVer, mBVOPsearchVerForw), mBVOPsearchVerBack) * 2 + 1);
    mMEfastSADsize = (mMEfastSADsize + 3) & (~3);
    mMEfastSAD = ippsMalloc_32s(mMEfastSADsize * mNumThreads);
    if (!mMEfastSAD)
        stsAlloc = ippStsMemAllocErr;
#endif
    if (stsAlloc != ippStsNoErr) {
        Close();
        ErrorMessage(VM_STRING("Not enough memory"));
        return MP4_STS_ERR_NOMEM;
    }
    // setup quant matrix
    if (!VOL.short_video_header) {
        if (VOL.quant_type) {
            if (par->load_intra_quant_mat ) {
                for (i = 0; i < par->load_intra_quant_mat_len; i++)
                    VOL.intra_quant_mat[mp4_ZigZagScan[i]] = par->intra_quant_mat[i];
                j = par->intra_quant_mat[i-1];
                for (; i < 64; i++)
                    VOL.intra_quant_mat[mp4_ZigZagScan[i]] = (Ipp8u)j;
            } else
                ippsCopy_8u(mp4_DefaultIntraQuantMatrix, VOL.intra_quant_mat, 64);
            if (par->load_nonintra_quant_mat ) {
                for (i = 0; i < par->load_nonintra_quant_mat_len; i++)
                    VOL.nonintra_quant_mat[mp4_ZigZagScan[i]] = par->nonintra_quant_mat[i];
                j = par->nonintra_quant_mat[i-1];
                for (; i < 64; i++)
                    VOL.nonintra_quant_mat[mp4_ZigZagScan[i]] = (Ipp8u)j;
            } else
                ippsCopy_8u(mp4_DefaultNonIntraQuantMatrix, VOL.nonintra_quant_mat, 64);
        }
        ippiQuantInvIntraInit_MPEG4(VOL.quant_type ? VOL.intra_quant_mat : NULL, mQuantInvIntraSpec, 8);
        ippiQuantInvInterInit_MPEG4(VOL.quant_type ? VOL.nonintra_quant_mat : NULL, mQuantInvInterSpec, 8);
        ippiQuantIntraInit_MPEG4(VOL.quant_type ? VOL.intra_quant_mat : NULL, mQuantIntraSpec, 8);
        ippiQuantInterInit_MPEG4(VOL.quant_type ? VOL.nonintra_quant_mat : NULL, mQuantInterSpec, 8);
    }
    // setup info for DC AC prediction
    mDefDC = (Ipp16s)(1 << (VOL.bits_per_pixel + 2));
    if (!VOL.short_video_header) {
        mp4_MacroBlock *mbCurr = MBinfo;
        for (i = 0; i < mNumMacroBlockPerCol; i ++) {
            for (j = 0; j < mNumMacroBlockPerRow; j ++) {
                mp4_MacroBlock *mbA = mbCurr - 1;
                mp4_MacroBlock *mbB = mbCurr - 1 - mNumMacroBlockPerRow;
                mp4_MacroBlock *mbC = mbCurr - mNumMacroBlockPerRow;
                mbCurr->block[0].predA = &mbA->block[1];
                mbCurr->block[0].predB = &mbB->block[3];
                mbCurr->block[0].predC = &mbC->block[2];
                mbCurr->block[1].predA = &mbCurr->block[0];
                mbCurr->block[1].predB = &mbC->block[2];
                mbCurr->block[1].predC = &mbC->block[3];
                mbCurr->block[2].predA = &mbA->block[3];
                mbCurr->block[2].predB = &mbA->block[1];
                mbCurr->block[2].predC = &mbCurr->block[0];
                mbCurr->block[3].predA = &mbCurr->block[2];
                mbCurr->block[3].predB = &mbCurr->block[0];
                mbCurr->block[3].predC = &mbCurr->block[1];
                mbCurr->block[4].predA = &mbA->block[4];
                mbCurr->block[4].predB = &mbB->block[4];
                mbCurr->block[4].predC = &mbC->block[4];
                mbCurr->block[5].predA = &mbA->block[5];
                mbCurr->block[5].predB = &mbB->block[5];
                mbCurr->block[5].predC = &mbC->block[5];
                mbCurr ++;
            }
        }
        for (j = 0; j < mNumMacroBlockPerRow; j ++) {
            mp4_MacroBlock *mbCurr = &MBinfo[j];
            mbCurr->block[0].predB = mbCurr->block[0].predC = NULL;
            mbCurr->block[1].predB = mbCurr->block[1].predC = NULL;
            mbCurr->block[4].predB = mbCurr->block[4].predC = NULL;
            mbCurr->block[5].predB = mbCurr->block[5].predC = NULL;
        }
        for (i = 0; i < mNumMacroBlockPerCol; i ++) {
            mp4_MacroBlock *mbCurr = &MBinfo[i*mNumMacroBlockPerRow];
            mbCurr->block[0].predA = mbCurr->block[0].predB = NULL;
            mbCurr->block[2].predA = mbCurr->block[2].predB = NULL;
            mbCurr->block[4].predA = mbCurr->block[4].predB = NULL;
            mbCurr->block[5].predA = mbCurr->block[5].predB = NULL;
        }
    }
    // setup frames
    if (mBVOPdist == 0) {
        mFrameC = &mFrame[0];
        if (mIVOPdist > 1)
            mFrameF = &mFrame[1];
    } else {
        mFrameC = &mFrame[0];
        mFrameF = &mFrame[1];
        mFrameB = &mFrame[0];
        mIndxBVOP = 2;
        mNumBVOP = 0;
    }
    mFrameD = mFrameC;
    // setup RateControl vars
    mRateControl = par->RateControl;
    if (VOL.sprite_enable == MP4_SPRITE_STATIC)
        mRateControl = 0;
    mBitsEncodedTotal = 0;
    mBitRate = par->BitRate;
    if (mRateControl == 1) {
        mRC.Init(0, 0, 0, mBitRate, (Ipp64f)par->TimeResolution / par->TimeIncrement, mSourceWidth, mSourceHeight, VOL.short_video_header ? 3 : 1, 31);
        mQuantIVOP = mRC.GetQP(MP4_VOP_TYPE_I);
        mQuantPVOP = mRC.GetQP(MP4_VOP_TYPE_P);
        mQuantBVOP = mRC.GetQP(MP4_VOP_TYPE_B);
    } else if (mRateControl == 2) {
        mRC_MB.Init(mBitRate, (Ipp64f)par->TimeResolution / par->TimeIncrement, mSourceWidth, mSourceHeight, mNumMacroBlockPerRow, mNumMacroBlockPerCol, mIVOPdist, VOL.data_partitioned, VOL.short_video_header ? 3 : 1, 31);
        mQuantIVOP = mQuantPVOP = mQuantBVOP = mRC_MB.GetQP();
        mMEflags &= ~ME_4MV;
    } else {
        mQuantIVOP = par->quantIVOP;
        mQuantPVOP = par->quantPVOP;
        mQuantBVOP = par->quantBVOP;
    }
    // setup VOP time
    mVOPtime = mSyncTime = mSyncTimeB = 0;
    // calc length of macroblock_number code
    i = mNumMacroBlockPerVOP - 1;
    mMBNlength = 0;
    do {
        i >>= 1;
        mMBNlength ++;
    } while (i);
    // setup Slices
    mSlice.startRow = 0;
    mSlice.gob_number = 0;
    mSlice.numRow = mNumMacroBlockPerCol;
    mSlice.cBS_1.Init(mBuffer_1, intBuffSize);
    mSlice.cBS_2.Init(mBuffer_2, intBuffSize);
#ifdef USE_ME_SADBUFF
    mSlice.meBuff = mMEfastSAD;
#endif
#ifdef _OMP_KARABAS
    if (VOL.short_video_header)
        j = (VOP.num_gobs_in_vop / mNumThreads) * (VOP.num_macroblocks_in_gob / mNumMacroBlockPerRow);
    else
        j = mNumMacroBlockPerCol / mNumThreads;
    for (i = 0; i < mNumThreads; i ++) {
        mSliceMT[i].startRow = i * j;
        if (VOL.short_video_header)
            mSliceMT[i].gob_number = mSliceMT[i].startRow * mNumMacroBlockPerRow / VOP.num_macroblocks_in_gob;
        mSliceMT[i].numRow = (i < mNumThreads - 1) ? j : mNumMacroBlockPerCol - i * j;
        if (i != 0)
            mSliceMT[i].cBS.Init(mBuffer + (i - 1) * intBuffSize, intBuffSize);
        mSliceMT[i].cBS_1.Init(mBuffer_1 + i * intBuffSize, intBuffSize);
        mSliceMT[i].cBS_2.Init(mBuffer_2 + i * intBuffSize, intBuffSize);
#ifdef USE_ME_SADBUFF
        mSliceMT[i].meBuff = mMEfastSAD + mMEfastSADsize * i;
#endif
    }
#endif // _OM_KARABAS
    return MP4_STS_NOERR;
}

Ipp32s ippVideoEncoderMPEG4::SetFrameBasicSpriteWarpCoeffs(Ipp32s *du, Ipp32s *dv, Ipp32s bcf)
{
    Ipp32s  i;

    if (!mIsInit)
        return MP4_STS_ERR_NOTINIT;
    for (i = 0; i < VOL.no_of_sprite_warping_points; i ++) {
        if (du[i] < -16383 || du[i] > 16383 || dv[i] < -16383 || dv[i] > 16383) {
            ErrorMessage(VM_STRING("warping_mv_code must be between -16383 and 16383"));
            return MP4_STS_ERR_PARAM;
        }
        VOP.warping_mv_code_du[i] = du[i];
        VOP.warping_mv_code_dv[i] = dv[i];
    }
    if (VOL.sprite_brightness_change) {
        if (bcf < -112 || bcf > 1648) {
            ErrorMessage(VM_STRING("brightness_change_factor must be between -112 and 1648"));
            return MP4_STS_ERR_PARAM;
        }
        VOP.brightness_change_factor = bcf;
    }
    return MP4_STS_NOERR;
}

void ippVideoEncoderMPEG4::ErrorMessage(const vm_char *msg)
{
    vm_debug_trace(VM_DEBUG_INFO, __VM_STRING("MPEG-4 encoder error: "));
    vm_debug_trace(VM_DEBUG_INFO, msg);
    vm_debug_trace(VM_DEBUG_INFO, __VM_STRING("\n"));
}

static void mp4_ExpandFrameReplicate(Ipp8u *pSrcDstPlane, Ipp32s frameWidth, Ipp32s frameHeight, Ipp32s expandPels, Ipp32s step)
{
    Ipp8u   *pDst1, *pDst2, *pSrc1, *pSrc2;
    Ipp32s  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);