ippvideoencodermpeg4_misc.cpp

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

    //f VOL.quant_mat_grayscale;
    VOL.quarter_sample = mMEaccuracy > 2;
    VOL.complexity_estimation_disable = 1;
    //f VOL.ComplexityEstimation;
    VOL.resync_marker_disable = !par->resync;
    mVideoPacketLength = par->VideoPacketLenght;
    VOL.data_partitioned = par->data_partitioned;
    VOL.reversible_vlc = (VOL.data_partitioned) ? par->reversible_vlc : 0;
    VOL.newpred_enable = 0;
    //f VOL.requested_upstream_message_type;
    //f VOL.newpred_segment_type;
    VOL.reduced_resolution_vop_enable = 0;
    VOL.scalability = 0;
    //f VOL.ScalabilityParameters;
    VOP.vop_time_increment = 0;
    VOP.intra_dc_vlc_thr = 0; //par->intra_dc_vlc_thr;
    if (VOL.data_partitioned)
        VOL.interlaced = 0;
    if (VOL.interlaced) {
        VOP.top_field_first = par->top_field_first;
        VOP.alternate_vertical_scan_flag = par->alternate_vertical_scan_flag;
        mInterlacedME = par->interlacedME;
    } else {
        mInterlacedME = 1;  // frame predicted
    }
    mInterlacedME = 1;  // in this version only frame prediction implemented
    VOP.vop_rounding_type = 0;
    mPVOPsearchHor = par->PVOPsearchWidth;
    mPVOPsearchVer = par->PVOPsearchHeight;
    // calc vop_fcode_forward for PVOPs
    i = IPP_MAX(mPVOPsearchHor, mPVOPsearchVer);
    j = i << 1;
    mPVOPfcodeForw = 1;
    while (j > ((16 << mPVOPfcodeForw) - 1))
        mPVOPfcodeForw ++;
    if (VOL.short_video_header) {
        mBVOPdist = 0;
        VO.colour_primaries = 1;
        VO.transfer_characteristics = 1;
        VO.matrix_coefficients = 6;
        VOL.quant_precision  = 5;
        VOL.video_object_layer_shape = MP4_SHAPE_TYPE_RECTANGULAR;
        VOL.obmc_disable     = 1;
        VOL.quant_type       = 0;
        VOL.resync_marker_disable = 1;
        VOL.data_partitioned = 0;
        VOL.reversible_vlc = 0;
        VOL.interlaced = 0;
        VOL.complexity_estimation_disable = 1;
        VOL.scalability = 0;
        VOL.not_8_bit = 0;
        VOL.bits_per_pixel = 8;
        VOP.vop_rounding_type = 0;
        VOP.vop_fcode_forward = 1;
        VOP.vop_coded = 1;
        VOP.split_screen_indicator = 0;
        VOP.document_camera_indicator = 0;
        VOP.full_picture_freeze_release = 0;
        if (par->Width == 128 && par->Height == 96) {
            VOP.source_format = 1;
            VOP.num_gobs_in_vop = 6;
            VOP.num_macroblocks_in_gob = 8;
        } else if (par->Width == 176 && par->Height == 144) {
            VOP.source_format = 2;
            VOP.num_gobs_in_vop = 9;
            VOP.num_macroblocks_in_gob = 11;
        } else if (par->Width == 352 && par->Height == 288) {
            VOP.source_format = 3;
            VOP.num_gobs_in_vop = 18;
            VOP.num_macroblocks_in_gob = 22;
        } else if (par->Width == 704 && par->Height == 576) {
            VOP.source_format = 4;
            VOP.num_gobs_in_vop = 18;
            VOP.num_macroblocks_in_gob = 88;
        } else if (par->Width == 1408 && par->Height == 1152) {
            VOP.source_format = 5;
            VOP.num_gobs_in_vop = 18;
            VOP.num_macroblocks_in_gob = 352;
        } else {
            ErrorMessage(VM_STRING("Size of picture is incompatible with short_video_header"));
            return MP4_STS_ERR_PARAM;
        }
        VOP.temporal_reference_increment = VOL.fixed_vop_time_increment / 1001;
        VOP.gob_resync = par->resync;
        VOL.quarter_sample = 0;
        if (mMEaccuracy > 2)
            mMEaccuracy = 2;
        mBVOPsearchHorForw = mBVOPsearchVerForw = mBVOPsearchHorBack = mBVOPsearchVerBack = 0;
        mRoundingControl = 0;
        mInsertGOV = 0;
        mRepeatHeaders = 0;
        mME4mv = 0;
    } else {
        mBVOPsearchHorForw = par->BVOPsearchWidthForw;
        mBVOPsearchVerForw = par->BVOPsearchHeightForw;
        mBVOPsearchHorBack = par->BVOPsearchWidthBack;
        mBVOPsearchVerBack = par->BVOPsearchHeightBack;
        // calc vop_fcode_forward for BVOPs
        i = IPP_MAX(mBVOPsearchHorForw, mBVOPsearchVerForw);
        j = i << 1;
        mBVOPfcodeForw = 1;
        while (j > ((16 << mBVOPfcodeForw) - 1))
            mBVOPfcodeForw ++;
        // calc vop_fcode_backward for BVOPs
        i = IPP_MAX(mBVOPsearchHorBack, mBVOPsearchHorBack);
        j = i << 1;
        mBVOPfcodeBack = 1;
        while (j > ((16 << mBVOPfcodeBack) - 1))
            mBVOPfcodeBack ++;
        if (VOL.quarter_sample) {
            mPVOPfcodeForw ++;
            mBVOPfcodeForw ++;
            mBVOPfcodeBack ++;
            VO.visual_object_verid = 2;
            VOL.video_object_layer_verid = 2;
        }
        if (VOL.sprite_enable == MP4_SPRITE_GMC)
            VOL.video_object_layer_verid = 2;
    }
    if (VOL.sprite_enable == MP4_SPRITE_STATIC) {
        mPlanes = 1;
        mSourceWidth = par->sprite_width;
        mSourceHeight = par->sprite_height;
    } else {
        mPlanes = (mIVOPdist == 1) ? 1 : (mBVOPdist == 0) ? 2 : 2 + mBVOPdist + 1;
        mSourceWidth = par->Width;
        mSourceHeight = par->Height;
    }
    VOP.warping_mv_code_du[0] = VOP.warping_mv_code_du[1] = VOP.warping_mv_code_du[2] = VOP.warping_mv_code_du[3] = 0;
    VOP.warping_mv_code_dv[0] = VOP.warping_mv_code_dv[1] = VOP.warping_mv_code_dv[2] = VOP.warping_mv_code_dv[3] = 0;
    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
    mFrame = new mp4_Frame [mPlanes];
    if (mFrame) {
        for (i = 0; i < mPlanes; i ++) {
            mFrame[i].ap = ippsMalloc_8u(mLumaPlaneSize + mChromaPlaneSize + mChromaPlaneSize);
            mFrame[i].pY = mFrame[i].ap + mExpandSizeA + mExpandSizeA * mStepLuma;
            mFrame[i].pU = mFrame[i].ap + mLumaPlaneSize + mExpandSizeA / 2 + (mExpandSizeA / 2) * mStepChroma;
            mFrame[i].pV = mFrame[i].ap + mLumaPlaneSize + mChromaPlaneSize + mExpandSizeA / 2 + (mExpandSizeA / 2) * mStepChroma;
        }
    }
    if (VOL.sprite_enable == MP4_SPRITE_GMC) {
        ippiWarpGetSize_MPEG4(&specSize);
        mWarpSpec = (IppiWarpSpec_MPEG4*)ippsMalloc_8u(specSize);
        mGMCPredY = ippsMalloc_8u(3*16*16*mNumMacroBlockPerRow >> 1);
        mGMCPredU = mGMCPredY + 16*16*mNumMacroBlockPerRow;
        mGMCPredV = mGMCPredU + 8*8*mNumMacroBlockPerRow;
    } else {
        mWarpSpec = NULL;
        mGMCPredY = mGMCPredU = mGMCPredV = NULL;
    }
    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);
        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));
    }
    // 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 mp4_MacroBlock[mNumMacroBlockPerVOP];
    mMEfastSADsize = (IPP_MAX(IPP_MAX(mPVOPsearchHor, mBVOPsearchHorForw), mBVOPsearchHorBack) * 2 + 1) * (IPP_MAX(IPP_MAX(mPVOPsearchVer, mBVOPsearchVerForw), mBVOPsearchVerBack) * 2 + 1);
    mMEfastSAD = ippsMalloc_32s(mMEfastSADsize);
    if (!mFrame) {
        for (i = 0; i < mPlanes; i ++) {
            mFrame[i].ap = ippsMalloc_8u(mLumaPlaneSize + mChromaPlaneSize + mChromaPlaneSize);
        }
    }
    if (!mFrame || !cBS.mBuffer || !MBinfo || !mMEfastSAD) {
        Close();
        ErrorMessage(VM_STRING("Not enough memory"));
        return MP4_STS_ERR_NOMEM;
    }
    for (i = 0; i < mPlanes; i ++) {
        if (!mFrame[i].ap) {
            Close();
            ErrorMessage(VM_STRING("Not enough memory"));
            return MP4_STS_ERR_NOMEM;
        }
    }
    if ((VOL.data_partitioned && (!mBuffer_1 || !mBuffer_2)) ||
        (VOL.sprite_enable == MP4_SPRITE_GMC && (!mWarpSpec || !mGMCPredY)) ||
        (!VOL.short_video_header && (!mQuantInterSpec || !mQuantIntraSpec || !mQuantInvInterSpec || !mQuantInvIntraSpec)) ||
        (VOL.short_video_header && (!mMBpredMV || !mMBquant || !mMBpos))) {
        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[mZigZagScan[i]] = par->intra_quant_mat[i];
                j = par->intra_quant_mat[i-1];
                for (; i < 64; i++)
                    VOL.intra_quant_mat[mZigZagScan[i]] = (Ipp8u)j;
            } else
                ippsCopy_8u(mDefaultIntraQuantMatrix, 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[mZigZagScan[i]] = par->nonintra_quant_mat[i];
                j = par->nonintra_quant_mat[i-1];
                for (; i < 64; i++)
                    VOL.nonintra_quant_mat[mZigZagScan[i]] = (Ipp8u)j;
            } else
                ippsCopy_8u(mDefaultNonIntraQuantMatrix, 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;
    }
    // setup RateControl vars
    mRateControl = par->RateControl;
    if (VOL.sprite_enable == MP4_SPRITE_STATIC)
        mRateControl = 0;
    mBitsEncodedTotal = 0;
    if (mRateControl) {
        mBitRate = par->BitRate;
        mBitsDesiredFrame = (Ipp32s)((Ipp64s)mBitRate * par->TimeIncrement / par->TimeResolution);
        mBitsDesiredTotal = 0;
        mQuantIVOP = mQuantPVOP = mSourceWidth * mSourceHeight  / mBitsDesiredFrame >> 1;
        mQuantBVOP = mQuantPVOP * 3 >> 1;
        mp4_Clip(mQuantIVOP, VOL.short_video_header ? 3 : 2, 31);
        mp4_Clip(mQuantPVOP, VOL.short_video_header ? 3 : 2, 31);
        mp4_Clip(mQuantBVOP, 2, 31);
        mRCqh = -1; mRCqs = 0; mRCbf = 0;
        if (mRateControl == 2)
            mME4mv = 0;
    } else {
        mQuantIVOP = par->quantIVOP;