ippvideoencodermpeg4_misc.cpp

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

/* ///////////////////////////////////////////////////////////////////////
//
//               INTEL CORPORATION PROPRIETARY INFORMATION
//  This software is supplied under the terms of a license agreement or
//  nondisclosure agreement with Intel Corporation and may not be copied
//  or disclosed except in accordance with the terms of that agreement.
//        Copyright (c) 2003-2005 Intel Corporation. All Rights Reserved.
//
//  Description:    class ippVideoEncoderMPEG4
//
*/

#include "ippvideoencodermpeg4.hpp"



ippVideoEncoderMPEG4::ippVideoEncoderMPEG4(mp4_Param *par)
{
    Init(par);
}


ippVideoEncoderMPEG4::~ippVideoEncoderMPEG4()
{
    Close();
}


void ippVideoEncoderMPEG4::Close()
{
    if (mIsInit) {
        // free
        if (MBinfo)
            delete [] MBinfo;
        if (mbsAlloc && cBS.mBuffer)
            ippsFree(cBS.mBuffer);
        if (mBuffer_1)
            ippsFree(mBuffer_1);
        if (mBuffer_2)
            ippsFree(mBuffer_2);
        if (mMEfastSAD)
            ippsFree(mMEfastSAD);
        if (mQuantInvIntraSpec)
            ippsFree(mQuantInvIntraSpec);
        if (mQuantInvInterSpec)
            ippsFree(mQuantInvInterSpec);
        if (mQuantIntraSpec)
            ippsFree(mQuantIntraSpec);
        if (mQuantInterSpec)
            ippsFree(mQuantInterSpec);
        if (mWarpSpec)
            ippsFree(mWarpSpec);
        if (mGMCPredY)
            ippsFree(mGMCPredY);
        if (mMBpos)
            ippsFree(mMBpos);
        if (mMBquant)
            ippsFree(mMBquant);
        if (mMBpredMV)
            ippsFree(mMBpredMV);
        if (mFrame) {
            for (int i = 0; i < mPlanes; i ++) {
                if (mFrame[i].ap)
                    ippsFree(mFrame[i].ap);
            }
            delete [] mFrame;
        }
    }
    mIsInit = false;
}


int ippVideoEncoderMPEG4::Init(mp4_Param *par)
{
    int  i, j, specSize;

    // check parameters correctness
    if (par->Width < 1 || par->Width > 8191) {
        ErrorMessage(VM_STRING("Width must be between 1 and 8191"));
        return MP4_STS_ERR_PARAM;
    }
    if (par->Width & 1) {
        ErrorMessage(VM_STRING("Width must be a even"));
        return MP4_STS_ERR_PARAM;
    }
    if (par->Height < 1 || par->Height > 8191) {
        ErrorMessage(VM_STRING("Height must be between 1 and 8191"));
        return MP4_STS_ERR_PARAM;
    }
    if (par->Height & 1) {
        ErrorMessage(VM_STRING("Height must be a even"));
        return MP4_STS_ERR_PARAM;
    }
    if (par->quantIVOP < 1 || par->quantIVOP > 31) {
        ErrorMessage(VM_STRING("quantIVOP must be between 1 and 31"));
        return MP4_STS_ERR_PARAM;
    }
    if (par->quantPVOP < 1 || par->quantPVOP > 31) {
        ErrorMessage(VM_STRING("quantPVOP must be between 1 and 31"));
        return MP4_STS_ERR_PARAM;
    }
    if (par->quantBVOP < 1 || par->quantBVOP > 31) {
        ErrorMessage(VM_STRING("quantBVOP must be between 1 and 31"));
        return MP4_STS_ERR_PARAM;
    }
    if (par->IVOPdist < 1) {
        ErrorMessage(VM_STRING("IVOPdist must be positive"));
        return MP4_STS_ERR_PARAM;
    }
    if (par->padType < 0 || par->padType > 2) {
        ErrorMessage(VM_STRING("padType must be between 0 and 2"));
        return MP4_STS_ERR_PARAM;
    }
    if (par->BitRate <= 0) {
        ErrorMessage(VM_STRING("BitRate must be positive"));
        return MP4_STS_ERR_PARAM;
    }
    if (par->SceneChangeThreshold < 0) {
        ErrorMessage(VM_STRING("SceneChangeThreshold must be >= 0"));
        return MP4_STS_ERR_PARAM;
    }
    if (par->short_video_header) {
        if (par->TimeResolution != 30000) {
            ErrorMessage(VM_STRING("TimeResolution must be equal 30000 for short_video_header"));
            return MP4_STS_ERR_PARAM;
        }
        if ((par->TimeIncrement % 1001) || par->TimeIncrement < 1001 || par->TimeIncrement > 256 * 1001) {
            ErrorMessage(VM_STRING("TimeIncrement must be one from i*1001 (i=1,256) for short_video_header"));
            return MP4_STS_ERR_PARAM;
        }
        if (par->PVOPsearchWidth < 1 || par->PVOPsearchWidth > 15) {
            ErrorMessage(VM_STRING("PVOPsearchWidth must be between 1 and 15 for short_video_header"));
            return MP4_STS_ERR_PARAM;
        }
        if (par->PVOPsearchHeight < 1 || par->PVOPsearchHeight > 15) {
            ErrorMessage(VM_STRING("PVOPsearchHeight must be between 1 and 15 for short_video_header"));
            return MP4_STS_ERR_PARAM;
        }
    } else {
        if (par->TimeResolution < 1) {
            ErrorMessage(VM_STRING("TimeResolution must be positive"));
            return MP4_STS_ERR_PARAM;
        }
        if (par->TimeIncrement < 1) {
            ErrorMessage(VM_STRING("TimeIncrement must be positive"));
            return MP4_STS_ERR_PARAM;
        }
        if (par->BVOPdist < 0) {
            ErrorMessage(VM_STRING("BVOPdist must be >= 0"));
            return MP4_STS_ERR_PARAM;
        }
        if (par->PVOPsearchWidth < 1 || par->PVOPsearchWidth > IPP_MIN(1023, par->Width)) {
            ErrorMessage(VM_STRING("PVOPsearchWidth must be between 1 and MIN(1023, Width)"));
            return MP4_STS_ERR_PARAM;
        }
        if (par->PVOPsearchHeight < 1 || par->PVOPsearchHeight > IPP_MIN(1023, par->Height)) {
            ErrorMessage(VM_STRING("PVOPsearchWidth must be between 1 and MIN(1023, Height)"));
            return MP4_STS_ERR_PARAM;
        }
        if (par->BVOPsearchWidthForw < 1 || par->BVOPsearchWidthForw > IPP_MIN(1023, par->Width)) {
            ErrorMessage(VM_STRING("BVOPsearchWidthForw must be between 1 and MIN(1023, Width)"));
            return MP4_STS_ERR_PARAM;
        }
        if (par->BVOPsearchHeightForw < 1 || par->BVOPsearchHeightForw > IPP_MIN(1023, par->Height)) {
            ErrorMessage(VM_STRING("BVOPsearchWidthForw must be between 1 and MIN(1023, Height)"));
            return MP4_STS_ERR_PARAM;
        }
        if (par->BVOPsearchWidthBack < 1 || par->BVOPsearchWidthBack > IPP_MIN(1023, par->Width)) {
            ErrorMessage(VM_STRING("BVOPsearchWidthBack must be between 1 and MIN(1023, Width)"));
            return MP4_STS_ERR_PARAM;
        }
        if (par->BVOPsearchHeightBack < 1 || par->BVOPsearchHeightBack > IPP_MIN(1023, par->Height)) {
            ErrorMessage(VM_STRING("BVOPsearchWidthBack must be between 1 and MIN(1023, Height)"));
            return MP4_STS_ERR_PARAM;
        }
        if (par->resync && par->VideoPacketLenght <= 0) {
            ErrorMessage(VM_STRING("VideoPacketLenght must be positive"));
            return MP4_STS_ERR_PARAM;
        }
        if (par->data_partitioned && par->interlaced) {
            ErrorMessage(VM_STRING("data_partitioned VOP can't be interlaced"));
            return MP4_STS_ERR_PARAM;
        }
        if (par->data_partitioned && par->RateControl == 2) {
            ErrorMessage(VM_STRING("CBR control is not implemented for data_partitioned VOP"));
            par->RateControl = 1;
        }
        if (par->sprite_enable == MP4_SPRITE_STATIC) {
            if (par->no_of_sprite_warping_points < 0 || par->no_of_sprite_warping_points > 4) {
                ErrorMessage(VM_STRING("no_of_sprite_warping_points must be between 0 and 4 for Basic Sprites"));
                return MP4_STS_ERR_PARAM;
            }
        }
        if (par->sprite_enable == MP4_SPRITE_GMC) {
            if (par->no_of_sprite_warping_points < 0 || par->no_of_sprite_warping_points > 3) {
                ErrorMessage(VM_STRING("no_of_sprite_warping_points must be between 0 and 3 for GMC"));
                return MP4_STS_ERR_PARAM;
            }
        }
        if (par->sprite_enable == MP4_SPRITE_STATIC || par->sprite_enable == MP4_SPRITE_GMC) {
            if (par->sprite_warping_accuracy < 0 || par->sprite_warping_accuracy > 3) {
                ErrorMessage(VM_STRING("sprite_warping_accuracy must be between 0 and 3"));
                return MP4_STS_ERR_PARAM;
            }
        }
        if (par->sprite_enable == 1) {
            if (par->sprite_left_coordinate < -4096 || par->sprite_left_coordinate > 4095) {
                ErrorMessage(VM_STRING("sprite_left_coordinate must be between -4096 and 4095"));
                return MP4_STS_ERR_PARAM;
            }
            if (par->sprite_left_coordinate & 1) {
                ErrorMessage(VM_STRING("sprite_left_coordinate must be even"));
                return MP4_STS_ERR_PARAM;
            }
            if (par->sprite_top_coordinate < -4096 || par->sprite_top_coordinate > 4095) {
                ErrorMessage(VM_STRING("sprite_top_coordinate must be between -4096 and 4095"));
                return MP4_STS_ERR_PARAM;
            }
            if (par->sprite_top_coordinate & 1) {
                ErrorMessage(VM_STRING("sprite_top_coordinate must be even"));
                return MP4_STS_ERR_PARAM;
            }
            if (par->sprite_width < 1 || par->sprite_width > 8191) {
                ErrorMessage(VM_STRING("sprite_width must be between 1 and 8191"));
                return MP4_STS_ERR_PARAM;
            }
            if (par->sprite_height < 1 || par->sprite_height > 8191) {
                ErrorMessage(VM_STRING("sprite_height must be between 1 and 8191"));
                return MP4_STS_ERR_PARAM;
            }
        }
    }
    Close();
    mNumOfFrames = par->NumOfFrames;
    mNumOfFrames = -1;
    mPadType = par->padType;
    mIVOPdist = par->IVOPdist;
    mBVOPdist = par->BVOPdist;
    if (VOL.sprite_enable == MP4_SPRITE_STATIC)
        mBVOPdist = 0;
    if (mBVOPdist >= mIVOPdist)
        mBVOPdist = mIVOPdist - 1;
    if (mIVOPdist % (mBVOPdist + 1) != 0)
        mIVOPdist = (mIVOPdist + mBVOPdist) / (mBVOPdist + 1) * (mBVOPdist + 1);
    if (mIVOPdist == 1) {
        mBVOPdist = 0;
    }
    mMEalgorithm = par->MEalgorithm;
    mMEaccuracy = par->MEaccuracy;
    mMEfastHP = 0;  // using fast algorithm for halfpel MVs (faster but with lower PSNR and compression)
    mME4mv = par->ME4mv;
    mCalcPSNR = par->calcPSNR;
    mRoundingControl = par->RoundingControl & 1;
    mInsertGOV = par->insertGOV;
    GOV.closed_gov = mBVOPdist == 0 ? 1 : 0;
    mRepeatHeaders = par->repeatHeaders;
    mFrameCount = 0;
    mLastIVOP = -mIVOPdist;
    // setup MPEG-4 headers variables
    memset(&VOS, 0, sizeof(VOS));
    memset(&VO, 0, sizeof(VO));
    memset(&VOL, 0, sizeof(VOL));
    memset(&GOV, 0, sizeof(GOV));
    memset(&VOP, 0, sizeof(VOP));
    VOS.profile_and_level_indication = 1;
    VO.is_visual_object_identifier = 1;
    VO.visual_object_verid = 1;
    VO.visual_object_priority = 1;
    VO.visual_object_type = MP4_VISUAL_OBJECT_TYPE_VIDEO;
    VO.video_signal_type = 0;
    //f VO.video_format;
    //f VO.video_range;
    //f VO.colour_description;
    //f VO.colour_primaries;
    //f VO.transfer_characteristics;
    //f VO.matrix_coefficients;
    VOL.short_video_header = par->short_video_header;
    VOL.random_accessible_vol = mIVOPdist == 1;
    VOL.video_object_type_indication = 0; //MP4_VIDEO_OBJECT_TYPE_SIMPLE;
    VOL.is_object_layer_identifier = 1;
    VOL.video_object_layer_verid = 1;
    VOL.video_object_layer_priority = 1;
    VOL.aspect_ratio_info = MP4_ASPECT_RATIO_1_1;
    //f VOL.par_width
    //f VOL.par_height
    VOL.vol_control_parameters = 0;
    //f VOL.chroma_format;
    //f VOL.low_delay;
    //f VOL.vbv_parameters;
    //f VOL.first_half_bit_rate;
    //f VOL.latter_half_bit_rate;
    //f VOL.first_half_vbv_buffer_size;
    //f VOL.latter_half_vbv_buffer_size;
    //f VOL.first_half_vbv_occupancy;
    //f VOL.latter_half_vbv_occupancy;
    VOL.video_object_layer_shape = MP4_SHAPE_TYPE_RECTANGULAR;
    //f VOL.video_object_layer_shape_extension
    VOL.vop_time_increment_resolution = par->TimeResolution;
    VOL.fixed_vop_rate = (par->TimeResolution > par->TimeIncrement) ? 1 : 0;
    VOL.fixed_vop_time_increment = par->TimeIncrement;
    VOL.vop_time_increment_resolution_bits = 1;
    i = VOL.vop_time_increment_resolution - 1;
    while (i >> VOL.vop_time_increment_resolution_bits)
        VOL.vop_time_increment_resolution_bits ++;
    VOL.video_object_layer_width = par->Width;
    VOL.video_object_layer_height = par->Height;
    VOL.interlaced = par->interlaced;
    VOL.obmc_disable = par->obmc_disable;
    VOL.sprite_enable = par->sprite_enable;
    VOL.sprite_width = par->sprite_width;
    VOL.sprite_height = par->sprite_height;
    VOL.sprite_left_coordinate = par->sprite_left_coordinate;
    VOL.sprite_top_coordinate = par->sprite_left_coordinate;
    VOL.no_of_sprite_warping_points = par->no_of_sprite_warping_points;
    VOL.sprite_warping_accuracy = par->sprite_warping_accuracy;
    VOL.sprite_brightness_change = VOL.sprite_enable == MP4_SPRITE_GMC ? 0 : par->sprite_brightness_change;
    VOL.low_latency_sprite_enable = 0;
    VOL.sadct_disable = 1;
    VOL.not_8_bit = 0;
    VOL.quant_precision = 5;
    VOL.bits_per_pixel = 8;
    //f VOL.no_gray_quant_update;
    //f VOL.composition_method;
    //f VOL.linear_composition;
    VOL.quant_type = par->quant_type;
    VOL.load_intra_quant_mat = par->load_intra_quant_mat;
    VOL.load_intra_quant_mat_len = par->load_intra_quant_mat_len;
    VOL.load_nonintra_quant_mat = par->load_nonintra_quant_mat;
    VOL.load_nonintra_quant_mat_len = par->load_nonintra_quant_mat_len;