mp4_enc_misc.cpp

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

/* ///////////////////////////////////////////////////////////////////////
//
//               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-2007 Intel Corporation. All Rights Reserved.
//
//  Description:    class ippVideoEncoderMPEG4
//
*/

#include "umc_defs.h"

#if defined (UMC_ENABLE_MPEG4_VIDEO_ENCODER)

#include <math.h>
#include "mp4_enc.hpp"

namespace MPEG4_ENC
{

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);
#ifdef USE_ME_SADBUFF
        if (mMEfastSAD)
            ippsFree(mMEfastSAD);
#endif
        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 (Ipp32s i = 0; i < mPlanes; i ++) {
            //    if (mFrame[i].ap)
            //        ippsFree(mFrame[i].ap);
            //}
            delete [] mFrame;
        }
#ifdef USE_CV_GME
        if (mPyramid[0]) {
            if (mPyramid[0]->pState) {
                ippiPyramidLayerDownFree_8u_C1R((IppiPyramidDownState_8u_C1R*)mPyramid[0]->pState);
                for (Ipp32s i = 1; i <= mPyramid[0]->level; i ++) {
                    if (mPyramid[0]->pImage[i])
                        ippiFree(mPyramid[0]->pImage[i]);
                }
            }
            ippiPyramidFree(mPyramid[0]);
        }
        if (mPyramid[1]) {
            if (mPyramid[1]->pState) {
                ippiPyramidLayerDownFree_8u_C1R((IppiPyramidDownState_8u_C1R*)mPyramid[1]->pState);
                for (Ipp32s i = 1; i <= mPyramid[1]->level; i ++) {
                    if (mPyramid[1]->pImage[i])
                        ippiFree(mPyramid[1]->pImage[i]);
                }
            }
            ippiPyramidFree(mPyramid[1]);
        }
        if (mOptFlowState)
            ippiOpticalFlowPyrLKFree_8u_C1R(mOptFlowState);
        if (mOptFlowPoints)
            ippFree(mOptFlowPoints);
        if (mOptFlowPtSts)
            ippFree(mOptFlowPtSts);
        if (mOptFlowPatchDiff)
            ippFree(mOptFlowPatchDiff);
        if (mOptFlowMask)
            ippFree(mOptFlowMask);
#endif
#ifdef _OMP_KARABAS
        if (mSliceMT)
            delete [] mSliceMT;
        if (MBinfoMT)
            ippsFree(MBinfoMT);
        if (mCurRowMT)
            delete [] mCurRowMT;
        if (mBuffer)
            ippsFree(mBuffer);
#ifdef _OPENMP
        if (mLockMT) {
            for (Ipp32s i = 0; i < mNumMacroBlockPerCol; i ++)
                omp_destroy_lock(mLockMT+i);
        }
        delete [] mLockMT;
#endif
#endif // _OMP_KARABAS
    }
    mIsInit = false;
}

Ipp32s ippVideoEncoderMPEG4::Init(mp4_Param *par, int numThreads)
{
    Ipp32s  i, j, specSize, intBuffSize;
    IppStatus stsAlloc = ippStsNoErr, stsPyr;

    // 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->RateControl == 0) {
        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->RateControl != 0 && 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;
        }
    } else {
        if (par->TimeResolution < 1 || par->TimeResolution > 65536) {
            ErrorMessage(VM_STRING("TimeResolution must be between 1 and 65536"));
            return MP4_STS_ERR_PARAM;
        }
        if (par->TimeIncrement < 1 || par->TimeIncrement > 65536) {
            ErrorMessage(VM_STRING("TimeIncrement must be between 1 and 65536"));
            return MP4_STS_ERR_PARAM;
        }
        if (par->BVOPdist < 0) {
            ErrorMessage(VM_STRING("BVOPdist must be >= 0"));
            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->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 == MP4_SPRITE_STATIC) {
            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();
    ippsZero_8u((Ipp8u*)this, sizeof(ippVideoEncoderMPEG4));
    mNumOfFrames = par->NumOfFrames;
    mNumOfFrames = -1;
    mPadType = par->padType;
    mIVOPdist = par->IVOPdist;
    mBVOPdist = par->BVOPdist;
    if (par->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;
    mMEflags = ME_USE_MVWEIGHT | ME_USE_MANYPRED | ME_SUBPEL_FINE /*| RD_MODE_DECISION | RD_TRELLIS*/;
    mMEmethod = par->MEalgorithm & 15;
    if (par->MEaccuracy == 2)
        mMEflags |= ME_HP;
    else if (par->MEaccuracy == 4)
        mMEflags |= ME_QP;
    if (par->ME4mv)
        mMEflags |= ME_4MV;
    if (par->MEalgorithm & ME_HP_FAST)
        mMEflags |= ME_HP_FAST;
    if (par->MEalgorithm & ME_CHROMA)
        mMEflags |= ME_CHROMA;
    if (par->MEalgorithm & RD_MODE_DECISION)
        mMEflags |= RD_MODE_DECISION;
    if (par->MEalgorithm & RD_TRELLIS)
        mMEflags |= RD_TRELLIS;
    mReconstructAlways = 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 = par->profile_and_level;
    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;