umc_vc1_enc_common.h

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

        {
            case VC1_ENC_8x8_TRANSFORM:
                Sts = _own_ippiQuantInvInterNonUniform_VC1_16s_C1IR(pSrc, srcStep, pDst, dstStep,
                    doubleQuant, roiSize, &dstSize);
                VC1_ENC_IPP_CHECK(Sts);
                Sts = Sts = ippiTransform8x8Inv_VC1_16s_C1IR(pDst, dstStep, dstSize);
                break;
            case VC1_ENC_4x8_TRANSFORM:
                roiSize.width  = 4;
                roiSize.height = 8;

                Sts = _own_ippiQuantInvInterNonUniform_VC1_16s_C1IR(pSrc, srcStep, pDst, dstStep,
                    doubleQuant, roiSize, &dstSize);
                VC1_ENC_IPP_CHECK(Sts);
                Sts = ippiTransform4x8Inv_VC1_16s_C1IR(pDst, dstStep, dstSize);
                VC1_ENC_IPP_CHECK(Sts);

                Sts =_own_ippiQuantInvInterNonUniform_VC1_16s_C1IR(pSrc + 4, srcStep,
                    pDst + 4, dstStep, doubleQuant, roiSize, &dstSize);
                VC1_ENC_IPP_CHECK(Sts);
                Sts = Sts = ippiTransform4x8Inv_VC1_16s_C1IR(pDst + 4, dstStep, dstSize);
                break;
            case VC1_ENC_8x4_TRANSFORM:
                roiSize.width  = 8;
                roiSize.height = 4;

                Sts = _own_ippiQuantInvInterNonUniform_VC1_16s_C1IR(pSrc, srcStep, pDst, dstStep,
                    doubleQuant, roiSize, &dstSize);
                VC1_ENC_IPP_CHECK(Sts);
                Sts = ippiTransform8x4Inv_VC1_16s_C1IR(pDst,dstStep,dstSize);
                VC1_ENC_IPP_CHECK(Sts);

                Sts = _own_ippiQuantInvInterNonUniform_VC1_16s_C1IR((Ipp16s*)((Ipp8u*)pSrc + 4*srcStep), srcStep,
                    (Ipp16s*)((Ipp8u*)pDst + 4*dstStep) , dstStep, doubleQuant, roiSize, &dstSize);
                VC1_ENC_IPP_CHECK(Sts);
                Sts = ippiTransform8x4Inv_VC1_16s_C1IR((Ipp16s*)((Ipp8u*)pDst + 4*dstStep),dstStep,dstSize);
                break;
            case VC1_ENC_4x4_TRANSFORM:
                roiSize.height = 4;
                roiSize.width  = 4;

                Sts = _own_ippiQuantInvInterNonUniform_VC1_16s_C1IR(pSrc, srcStep,
                    pDst, dstStep, doubleQuant, roiSize, &dstSize);
                VC1_ENC_IPP_CHECK(Sts);
                Sts = ippiTransform4x4Inv_VC1_16s_C1IR(pDst,dstStep,dstSize);
                VC1_ENC_IPP_CHECK(Sts);

                Sts = _own_ippiQuantInvInterNonUniform_VC1_16s_C1IR(pSrc + 4, srcStep,
                    pDst + 4, dstStep, doubleQuant, roiSize, &dstSize);
                VC1_ENC_IPP_CHECK(Sts);
                Sts = ippiTransform4x4Inv_VC1_16s_C1IR(pDst+4,dstStep,dstSize);
                VC1_ENC_IPP_CHECK(Sts);

                Sts = _own_ippiQuantInvInterNonUniform_VC1_16s_C1IR((Ipp16s*)((Ipp8u*)pSrc+4*srcStep), srcStep,
                    (Ipp16s*)((Ipp8u*)pDst+4*dstStep), dstStep,  doubleQuant, roiSize, &dstSize);
                VC1_ENC_IPP_CHECK(Sts);
                Sts = ippiTransform4x4Inv_VC1_16s_C1IR((Ipp16s*)((Ipp8u*)pDst + 4*dstStep),dstStep, dstSize);
                VC1_ENC_IPP_CHECK(Sts);

                Sts = _own_ippiQuantInvInterNonUniform_VC1_16s_C1IR((Ipp16s*)((Ipp8u*)pSrc + 4*srcStep)+4, srcStep,
                    (Ipp16s*)((Ipp8u*)pDst + 4*dstStep)+4, dstStep, doubleQuant, roiSize, &dstSize);
                VC1_ENC_IPP_CHECK(Sts);
                Sts = ippiTransform4x4Inv_VC1_16s_C1IR((Ipp16s*)((Ipp8u*)pDst + 4*dstStep)+4,dstStep, dstSize);
                break;
            default:
                return ippStsErr;
                break;
        }

IPP_STAT_END_TIME(m_IppStat->IppStartTime, m_IppStat->IppEndTime, m_IppStat->IppTotalTime);
        return Sts;
    }

    typedef IppStatus (*IntraInvTransformQuantFunction)  (Ipp16s* pSrc, Ipp32s srcStep,
                                                       Ipp16s* pDst, Ipp32s dstStep,
                                                       Ipp32s DCQuant, Ipp32s doubleQuant);
    typedef IppStatus (*InterInvTransformQuantFunction)  (Ipp16s* pSrc, Ipp32s srcStep,
                                                       Ipp16s* pDst, Ipp32s dstStep,
                                                       Ipp32s doubleQuant, Ipp32s TransformType);


#ifndef _VC1_ENC_OWN_FUNCTIONS_
    #define _own_FilterDeblockingLuma_VerEdge_VC1_8u_C1IR     ippiFilterDeblockingLuma_VerEdge_VC1_8u_C1IR
    #define _own_FilterDeblockingChroma_VerEdge_VC1_8u_C1IR   ippiFilterDeblockingChroma_VerEdge_VC1_8u_C1IR
    #define _own_FilterDeblockingLuma_HorEdge_VC1_8u_C1IR     ippiFilterDeblockingLuma_HorEdge_VC1_8u_C1IR
    #define _own_FilterDeblockingChroma_HorEdge_VC1_8u_C1IR   ippiFilterDeblockingChroma_HorEdge_VC1_8u_C1IR
#endif // not _VC1_ENC_OWN_FUNCTIONS_

    ///////////////////

    typedef void        (*CalculateCromaFunction)(sCoordinate LumaMV, sCoordinate * pChroma);

    Ipp8u               Get_CBPCY(Ipp8u MBPatternCur, Ipp8u CBPCYTop, Ipp8u CBPCYLeft, Ipp8u CBPCYULeft);
    //eDirection          GetDCPredDirectionSM(Ipp16s dcA, Ipp16s dcB, Ipp16s dcC);

 //---BEGIN------------------------Copy block, MB functions-----------------------------------------------

#ifndef _VC1_ENC_OWN_FUNCTIONS_
    #define _own_Copy8x8_16x16_8u16s ippiConvert_8u16s_C1R
#endif
 //---END------------------------Copy block, MB functions-----------------------------------------------


    //void                Diff_1x7_16s(Ipp16s* pSrcDst, Ipp16s step, const Ipp16s* pDst);
    //void                Diff_7x1_16s(Ipp16s* pSrc, const Ipp16s* pDst);
    Ipp32s              SumSqDiff_1x7_16s(Ipp16s* pSrc, Ipp16s step, Ipp16s* pPred);
    Ipp32s              SumSqDiff_7x1_16s(Ipp16s* pSrc, Ipp16s* pPred);
    //Ipp32u              GetNumZeros(Ipp16s* pSrc, Ipp32u srcStep, bool bIntra);
    //Ipp32u              GetNumZeros(Ipp16s* pSrc, Ipp32u srcStep);

    Ipp8u               GetMode( Ipp8u &run,  Ipp16s &level, const Ipp8u *pTableDR, const Ipp8u *pTableDL, bool& sign);
    //bool                GetRLCode(Ipp32s run, Ipp32s level, IppVCHuffmanSpec_32s *pTable, Ipp32s &code, Ipp32s &len);
    //Ipp8u               GetLength_16s(Ipp16s value);
    //Ipp8u               Zigzag( Ipp16s*                pBlock,
    //                        Ipp32u                 blockStep,
    //                        bool                   bIntra,
    //                        const Ipp8u*           pScanMatrix,
    //                        Ipp8u*                 pRuns,
    //                        Ipp16s*                pLevels);

    void                Diff8x8 (const Ipp16s* pSrc1, Ipp32s src1Step,
                            const Ipp16s* pSrc2, Ipp32s src2Step,
                            const Ipp8u*  pCoeff,Ipp32s coefStep,
                            Ipp16s* pDst, Ipp32s dstStep);

 //---BEGIN------------------------Add constant to block-----------------------------------------------
#ifndef _VC1_ENC_OWN_FUNCTIONS_
    #define _own_Diff8x8C_16s ippiSubC_16s_C1IRSfs
    #define _own_Add8x8C_16s  ippiAddC_16s_C1IRSfs
#endif
 //---End------------------------Add constant to block-----------------------------------------------


//---Begin------------------------Get difference-----------------------------------------------
#ifndef _VC1_ENC_OWN_FUNCTIONS_
    #define _own_Diff8x8_8u16s    ippiGetDiff8x8_8u16s_C1
    #define _own_Diff16x16_8u16s  ippiGetDiff16x16_8u16s_C1
#endif

//---End------------------------Get difference-----------------------------------------------

//---Begin---------------------Motion compensation-----------------------------------------------
#ifndef _VC1_ENC_OWN_FUNCTIONS_
    #define _own_Add16x16_8u16s    ippiMC16x16_8u_C1
    #define _own_Add8x8_8u16s      ippiMC8x8_8u_C1
#endif


//---End---------------------Motion compensation-----------------------------------------------


    //void                Copy8x8_16s(Ipp16s*  pSrc, Ipp32u   srcStep,
    //                        Ipp16s*  pDst, Ipp32u   dstStep);
    //void                Copy16x16_16s( Ipp16s*  pSrc, Ipp32u   srcStep,
    //                        Ipp16s*  pDst, Ipp32u   dstStep);

    Ipp16s median3(Ipp16s a, Ipp16s b, Ipp16s c);
    void PredictMV(sCoordinate* predA,sCoordinate* predB,sCoordinate* predC, sCoordinate* res);

    inline Ipp16s VC1abs(Ipp16s value);
    void ScalePredict(sCoordinate * MV, Ipp32s x,Ipp32s y,sCoordinate MVPredMin, sCoordinate MVPredMax);
    //Ipp32s FullSearch(const Ipp8u* pSrc, Ipp32u srcStep, const Ipp8u* pPred, Ipp32u predStep, sCoordinate Min, sCoordinate Max,sCoordinate * MV);
    //Ipp32s SumBlock16x16(const Ipp8u* pSrc, Ipp32u srcStep);
    //Ipp32s SumBlockDiff16x16(const Ipp8u* pSrc1, Ipp32u srcStep1,const Ipp8u* pSrc2, Ipp32u srcStep2);
    //Ipp32s SumBlockDiffBPred16x16(const Ipp8u* pSrc, Ipp32u srcStep,const Ipp8u* pPred1, Ipp32u predStep1,
    //                                                            const Ipp8u* pPred2, Ipp32u predStep2);
    void  GetMVDirectHalf  (Ipp16s x, Ipp16s y, Ipp32s scaleFactor, sCoordinate * mvF, sCoordinate *mvB);
    void  GetMVDirectQuarter(Ipp16s x, Ipp16s y, Ipp32s scaleFactor, sCoordinate * mvF, sCoordinate *mvB);
    void  GetChromaMV   (sCoordinate LumaMV, sCoordinate * pChroma);
    void  GetChromaMVFast(sCoordinate LumaMV, sCoordinate * pChroma);

    void GetIntQuarterMV(sCoordinate MV,sCoordinate *pMVInt, sCoordinate *pMVIntQuarter);
    //void GetQMV(sCoordinate *pMV,sCoordinate MVInt, sCoordinate MVIntQuarter);

    //void GetBlockType(Ipp16s* pBlock, Ipp32s step, Ipp8u Quant, eTransformType& type);
    //bool GetMBTSType(Ipp16s** ppBlock, Ipp32u* pStep, Ipp8u Quant , eTransformType* pTypes);

    //Ipp8u GetBlockPattern(Ipp16s* pSrc, Ipp32u srcStep);

    Ipp8u HybridPrediction(     sCoordinate * mvPred,
                                const sCoordinate * MV,
                                const sCoordinate * mvA,
                                const sCoordinate * mvC);

//--Begin----------Interpolation---------------

#ifndef _VC1_ENC_OWN_FUNCTIONS_

#if defined (_WIN32_WCE) && defined (_M_IX86) && defined (__stdcall)
  #define _IPP_STDCALL_CDECL
  #undef __stdcall
#endif

    typedef IppStatus  ( __STDCALL *InterpolateFunction)  (const IppVCInterpolate_8u* pParam);

#if defined (_IPP_STDCALL_CDECL)
  #undef  _IPP_STDCALL_CDECL
  #define __stdcall __cdecl
#endif
    #define _own_ippiInterpolateQPBicubic_VC1_8u_C1R  ippiInterpolateQPBicubic_VC1_8u_C1R
    #define _own_ippiInterpolateQPBilinear_VC1_8u_C1R ippiInterpolateQPBilinear_VC1_8u_C1R
#endif

    inline void SetInterpolationParamsSrc(IppVCInterpolate_8u* pInterpolation, Ipp8u* pSrc, Ipp32u step, const sCoordinate* mvInt, const sCoordinate* mvQuarter)
    {
        pInterpolation->pSrc = pSrc + mvInt->x + mvInt->y*(Ipp32s)step;
        pInterpolation->dx   = mvQuarter -> x;
        pInterpolation->dy   = mvQuarter -> y;
    }
//--End------------Interpolation---------------

}
#endif
#endif // defined (UMC_ENABLE_VC1_VIDEO_ENCODER)