umc_vc1_enc_common.h

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) 2007 Intel Corporation. All Rights Reserved.
//
//
//          VC-1 (VC1) encoder, common declarations
//
*/
#include "umc_defs.h"

#if defined (UMC_ENABLE_VC1_VIDEO_ENCODER)

#ifndef _ENCODER_VC1_COMMON
#define _ENCODER_VC1_COMMON

#include "ippvc.h"
#include "ippi.h"
#include "umc_vc1_common_defs.h"
#include "umc_vc1_enc_statistic.h"

#define GetMVPredictionB                \
    if (left)                           \
    {                                   \
        mvC_F = &mv1;                   \
        mvC_B = &mv4;                   \
        left->GetMV(mvC_F,1,true);      \
        left->GetMV(mvC_B,1,false);     \
    }                                   \
    if (top)                            \
    {                                   \
        mvA_F = &mv2;                   \
        mvA_B = &mv5;                   \
        top->GetMV(mvA_F,2,true);       \
        top->GetMV(mvA_B,2,false);      \
    }                                   \
    if (topRight)                       \
    {                                   \
        mvB_F = &mv3;                   \
        mvB_B = &mv6;                   \
        topRight->GetMV(mvB_F,2,true);  \
        topRight->GetMV(mvB_B,2,false); \
    }                                   \
    if (!topRight && topLeft)           \
    {                                   \
        mvB_F = &mv3;                   \
        mvB_B = &mv6;                   \
        topLeft->GetMV(mvB_F,3,true);   \
        topLeft->GetMV(mvB_B,3,false);  \
    }
 #define    GetMVPredictionP(forward)   \
    if (left)                           \
    {                                   \
        left->GetMV(&mv1,1,forward);    \
        mvC = &mv1;                     \
    }                                   \
    if (top)                            \
    {                                   \
        top->GetMV(&mv2,2,forward);     \
        mvA = &mv2;                     \
    }                                   \
    if (topRight)                       \
    {                                   \
        topRight->GetMV(&mv3,2,forward);\
        mvB = &mv3;                     \
    }                                   \
    else if(topLeft)                    \
    {                                   \
        topLeft->GetMV(&mv3,3,forward); \
        mvB = &mv3;                     \
    }


namespace UMC_VC1_ENCODER
{

 //-------------FORWARD-TRANSFORM-QUANTIZATION---------------------------

#ifndef _VC1_ENC_OWN_FUNCTIONS_

    #define _own_ippiTransformBlock8x8Fwd_VC1_16s_C1R      ippiTransform8x8Fwd_VC1_16s_C1IR
    #define _own_ippiTransformBlock4x8Fwd_VC1_16s_C1R      ippiTransform4x8Fwd_VC1_16s_C1IR
    #define _own_ippiTransformBlock8x4Fwd_VC1_16s_C1R      ippiTransform8x4Fwd_VC1_16s_C1IR
    #define _own_ippiTransformBlock4x4Fwd_VC1_16s_C1R      ippiTransform4x4Fwd_VC1_16s_C1IR

#endif // not _VC1_ENC_OWN_FUNCTIONS_



#ifndef _VC1_ENC_OWN_FUNCTIONS_

    #define _own_ippiQuantIntraUniform     ippiQuantIntraUniform_VC1_16s_C1IR
    #define _own_ippiQuantIntraNonUniform  ippiQuantIntraNonuniform_VC1_16s_C1IR
    #define _own_ippiQuantInterUniform     ippiQuantInterUniform_VC1_16s_C1IR
    #define _own_ippiQuantInterNonUniform  ippiQuantInterNonuniform_VC1_16s_C1IR

#endif // not _VC1_ENC_OWN_FUNCTIONS_


    inline IppStatus IntraTransformQuantUniform(Ipp16s* pSrcDst, Ipp32s srcDstStep,
                                                       Ipp32s DCQuant, Ipp32s doubleQuant)
    {
        IppStatus Sts = ippStsNoErr;

IPP_STAT_START_TIME(m_IppStat->IppStartTime);
        Sts = _own_ippiTransformBlock8x8Fwd_VC1_16s_C1R(pSrcDst,srcDstStep);
        VC1_ENC_IPP_CHECK(Sts);

        pSrcDst[0] = pSrcDst[0]/DCQuant;
        Sts =  _own_ippiQuantIntraUniform(pSrcDst, srcDstStep, doubleQuant);
IPP_STAT_END_TIME(m_IppStat->IppStartTime, m_IppStat->IppEndTime, m_IppStat->IppTotalTime);

        return Sts;
    }

    inline IppStatus IntraTransformQuantNonUniform(Ipp16s* pSrcDst, Ipp32s srcDstStep,
                                                          Ipp32s DCQuant, Ipp32s doubleQuant)
    {
        IppStatus Sts = ippStsNoErr;

IPP_STAT_START_TIME(m_IppStat->IppStartTime);
        Sts = _own_ippiTransformBlock8x8Fwd_VC1_16s_C1R(pSrcDst,srcDstStep);
        VC1_ENC_IPP_CHECK(Sts);

        pSrcDst[0] = pSrcDst[0]/DCQuant;
        Sts =  _own_ippiQuantIntraNonUniform(pSrcDst, srcDstStep, doubleQuant);
IPP_STAT_END_TIME(m_IppStat->IppStartTime, m_IppStat->IppEndTime, m_IppStat->IppTotalTime);

        return Sts;
    }

    inline IppStatus InterTransformQuantUniform(Ipp16s* pSrcDst, Ipp32s srcDstStep,
                                                Ipp32s TransformType, Ipp32s doubleQuant)
    {
        IppStatus Sts = ippStsNoErr;
        IppiSize roiSize = {8, 8};

IPP_STAT_START_TIME(m_IppStat->IppStartTime);
        switch (TransformType)
        {
            case VC1_ENC_8x8_TRANSFORM:
                Sts = _own_ippiTransformBlock8x8Fwd_VC1_16s_C1R(pSrcDst, srcDstStep);
                VC1_ENC_IPP_CHECK(Sts);
                Sts = _own_ippiQuantInterUniform(pSrcDst, srcDstStep, doubleQuant, roiSize);
                break;
            case VC1_ENC_4x8_TRANSFORM:
                roiSize.width  = 4;
                roiSize.height = 8;

                Sts =  _own_ippiTransformBlock4x8Fwd_VC1_16s_C1R(pSrcDst,srcDstStep);
                VC1_ENC_IPP_CHECK(Sts);
                Sts =  _own_ippiQuantInterUniform(pSrcDst, srcDstStep, doubleQuant, roiSize);
                VC1_ENC_IPP_CHECK(Sts);

                Sts =  _own_ippiTransformBlock4x8Fwd_VC1_16s_C1R(pSrcDst+4,srcDstStep);
                VC1_ENC_IPP_CHECK(Sts);
                Sts =  _own_ippiQuantInterUniform(pSrcDst + 4, srcDstStep, doubleQuant, roiSize);
                break;
            case VC1_ENC_8x4_TRANSFORM:
                roiSize.width  = 8;
                roiSize.height = 4;

                Sts = _own_ippiTransformBlock8x4Fwd_VC1_16s_C1R(pSrcDst,srcDstStep);
                VC1_ENC_IPP_CHECK(Sts);
                Sts = _own_ippiQuantInterUniform(pSrcDst, srcDstStep, doubleQuant, roiSize);
                VC1_ENC_IPP_CHECK(Sts);

                Sts = _own_ippiTransformBlock8x4Fwd_VC1_16s_C1R((Ipp16s*)((Ipp8u*)pSrcDst+4*srcDstStep),
                                                                                             srcDstStep);
                VC1_ENC_IPP_CHECK(Sts);
                Sts = _own_ippiQuantInterUniform((Ipp16s*)((Ipp8u*)pSrcDst+4*srcDstStep), srcDstStep, doubleQuant, roiSize);

                break;
            case VC1_ENC_4x4_TRANSFORM:
                roiSize.height = 4;
                roiSize.width  = 4;

                Sts = _own_ippiTransformBlock4x4Fwd_VC1_16s_C1R(pSrcDst,srcDstStep);
                VC1_ENC_IPP_CHECK(Sts);
                Sts = _own_ippiQuantInterUniform(pSrcDst, srcDstStep, doubleQuant, roiSize);
                VC1_ENC_IPP_CHECK(Sts);

                Sts = _own_ippiTransformBlock4x4Fwd_VC1_16s_C1R(pSrcDst + 4,srcDstStep);
                VC1_ENC_IPP_CHECK(Sts);
                Sts = _own_ippiQuantInterUniform(pSrcDst + 4, srcDstStep, doubleQuant, roiSize);
                VC1_ENC_IPP_CHECK(Sts);

                Sts = _own_ippiTransformBlock4x4Fwd_VC1_16s_C1R((Ipp16s*)((Ipp8u*)pSrcDst+4*srcDstStep),
                                                                                            srcDstStep);
                VC1_ENC_IPP_CHECK(Sts);
                Sts = _own_ippiQuantInterUniform((Ipp16s*)((Ipp8u*)pSrcDst+4*srcDstStep),
                                                                        srcDstStep, doubleQuant, roiSize);
                VC1_ENC_IPP_CHECK(Sts);

                Sts = _own_ippiTransformBlock4x4Fwd_VC1_16s_C1R((Ipp16s*)((Ipp8u*)pSrcDst+4*srcDstStep)+4,
                                                                                                srcDstStep);
                VC1_ENC_IPP_CHECK(Sts);
                Sts = _own_ippiQuantInterUniform((Ipp16s*)((Ipp8u*)pSrcDst+4*srcDstStep)+4, srcDstStep, doubleQuant, roiSize);
                break;
            default:
                return ippStsErr;
                break;
        }
IPP_STAT_END_TIME(m_IppStat->IppStartTime, m_IppStat->IppEndTime, m_IppStat->IppTotalTime);

        return Sts;
    }

    inline IppStatus InterTransformQuantNonUniform(Ipp16s* pSrcDst, Ipp32s srcDstStep,
                                                   Ipp32s TransformType, Ipp32s doubleQuant)
    {
        IppStatus Sts = ippStsNoErr;
        IppiSize roiSize = {8, 8};