umc_h264_dec_ippwrap.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) 2003-2007 Intel Corporation. All Rights Reserved.
//
//
*/
#include "umc_defs.h"
#if defined (UMC_ENABLE_H264_VIDEO_DECODER)

#ifndef __UMC_H264_DEC_IPP_WRAP_H
#define __UMC_H264_DEC_IPP_WRAP_H

#include "ippi.h"
#include "umc_h264_dec_ipplevel.h"
#include "vm_debug.h"
#include "umc_h264_dec_defs_dec.h"

namespace UMC
{
#pragma warning(disable: 4100)

    inline void SetPlane(Ipp8u val, Ipp8u* pDst, Ipp32s len)
    {
        ippsSet_8u(val, pDst, len);
    }

    inline void CopyPlane(const Ipp8u *pSrc, Ipp8u *pDst, Ipp32s len)
    {
        ippsCopy_8u(pSrc, pDst, len);
    }

    inline IppStatus DecodeCAVLCChromaDcCoeffs_H264(Ipp32u **ppBitStream,
                                                    Ipp32s *pOffset,
                                                    Ipp16s *pNumCoeff,
                                                    Ipp16s **ppDstCoeffs,
                                                    const Ipp32s *pTblCoeffToken,
                                                    const Ipp32s **ppTblTotalZerosCR,
                                                    const Ipp32s **ppTblRunBefore)
    {
        return ippiDecodeCAVLCChromaDcCoeffs_H264_1u16s(ppBitStream,
                                                        pOffset,
                                                        pNumCoeff,
                                                        ppDstCoeffs,
                                                        pTblCoeffToken,
                                                        ppTblTotalZerosCR,
                                                        ppTblRunBefore);
    }

    inline IppStatus DecodeCAVLCChromaDcCoeffs422_H264(Ipp32u **ppBitStream,
                                                       Ipp32s *pOffset,
                                                       Ipp16s *pNumCoeff,
                                                       Ipp16s **ppDstCoeffs,
                                                       const Ipp32s *pTblCoeffToken,
                                                       const Ipp32s **ppTblTotalZerosCR,
                                                       const Ipp32s **ppTblRunBefore)
    {
        return ippiDecodeCAVLCChroma422DcCoeffs_H264_1u16s(ppBitStream,
                                                            pOffset,
                                                            pNumCoeff,
                                                            ppDstCoeffs,
                                                            pTblCoeffToken,
                                                            ppTblTotalZerosCR,
                                                            ppTblRunBefore);
    }

    inline IppStatus DecodeCAVLCCoeffs_H264(Ipp32u **ppBitStream,
                                            Ipp32s *pOffset,
                                            Ipp16s *pNumCoeff,
                                            Ipp16s **ppDstCoeffs,
                                            Ipp32u uVLCSelect,
                                            Ipp16s uMaxNumCoeff,
                                            const Ipp32s **ppTblCoeffToken,
                                            const Ipp32s **ppTblTotalZeros,
                                            const Ipp32s **ppTblRunBefore,
                                            const Ipp32s *pScanMatrix)
    {
        return ippiDecodeCAVLCCoeffs_H264_1u16s(ppBitStream,
                                                pOffset,
                                                pNumCoeff,
                                                ppDstCoeffs,
                                                uVLCSelect,
                                                uMaxNumCoeff,
                                                ppTblCoeffToken,
                                                ppTblTotalZeros,
                                                ppTblRunBefore,
                                                pScanMatrix);
    }

    inline IppStatus SetPlane(Ipp8u value, Ipp8u* pDst, Ipp32s dstStep,
                              IppiSize roiSize )
    {
        return ippiSet_8u_C1R(value, pDst, dstStep,
                              roiSize);
    }

    inline IppStatus ExpandPlane(Ipp8u *StartPtr,
                                 Ipp32u uFrameWidth,
                                 Ipp32u uFrameHeight,
                                 Ipp32u uPitch,
                                 Ipp32u uPels,
                                 IppvcFrameFieldFlag uFrameFieldFlag)
    {
        return ippiExpandPlane_H264_8u_C1R(StartPtr,
                                           uFrameWidth,
                                           uFrameHeight,
                                           uPitch,
                                           uPels,
                                           uFrameFieldFlag);
    }

    inline IppStatus BiDirWeightBlock(const Ipp8u *pSrc1,
                                      const Ipp8u *pSrc2,
                                      Ipp8u *pDst,
                                      Ipp32u nSrcPitch1,
                                      Ipp32u nSrcPitch2,
                                      Ipp32u nDstPitch,
                                      Ipp32u ulog2wd,
                                      Ipp32s iWeight1,
                                      Ipp32s iOffset1,
                                      Ipp32s iWeight2,
                                      Ipp32s iOffset2,
                                      IppiSize roi,
                                      Ipp32s bit_depth = 8)
    {
        return ippiBiDirWeightBlock_H264_8u_P3P1R(pSrc1, pSrc2, pDst, nSrcPitch1, nSrcPitch2,
            nDstPitch, ulog2wd, iWeight1, iOffset1, iWeight2, iOffset2, roi);
    }

    inline IppStatus BiDirWeightBlockImplicit(const Ipp8u *pSrc1,
                                              const Ipp8u *pSrc2,
                                              Ipp8u *pDst,
                                              Ipp32u nSrcPitch1,
                                              Ipp32u nSrcPitch2,
                                              Ipp32u nDstPitch,
                                              Ipp32s iWeight1,
                                              Ipp32s iWeight2,
                                              IppiSize roi,
                                              Ipp32s bit_depth = 8)
    {
        return ippiBiDirWeightBlockImplicit_H264_8u_P3P1R(pSrc1,
                                                          pSrc2,
                                                          pDst,
                                                          nSrcPitch1,
                                                          nSrcPitch2,
                                                          nDstPitch,
                                                          iWeight1,
                                                          iWeight2,
                                                          roi);
    }

    inline IppStatus InterpolateBlock(Ipp8u *pSrc1,
                                      Ipp8u *pSrc2,
                                      Ipp8u *pDst,
                                      Ipp32u uWidth,
                                      Ipp32u uHeight,
                                      Ipp32s iPitchSrc1,
                                      Ipp32s iPitchSrc2,
                                      Ipp32s iPitchDst,
                                      Ipp32s bit_depth = 8)
    {
        return ippiInterpolateBlock_H264_8u_P3P1R(pSrc1,pSrc2,
                                                  pDst,
                                                  uWidth,
                                                  uHeight,
                                                  iPitchSrc1,
                                                  iPitchSrc2,
                                                  iPitchDst);
    }

    inline IppStatus UniDirWeightBlock(Ipp8u *pSrcDst,
                                       Ipp32u srcDstStep,
                                       Ipp32u ulog2wd,
                                       Ipp32s iWeight,
                                       Ipp32s iOffset,
                                       IppiSize roi,
                                       Ipp32s bit_depth = 8)
    {
        return ippiUniDirWeightBlock_H264_8u_C1R(pSrcDst, srcDstStep,
                                                 ulog2wd, iWeight,
                                                 iOffset, roi);
    }

    inline IppStatus ReconstructLumaIntraHalfMB(Ipp16s **ppSrcCoeff,
                                                Ipp8u *pSrcDstYPlane,
                                                Ipp32s srcdstYStep,
                                                IppIntra4x4PredMode_H264 *pMBIntraTypes,
                                                Ipp32u cbp4x2,
                                                Ipp32s QP,
                                                Ipp8u edgeType,
                                                Ipp32s bit_depth = 8)
    {
        return ippiReconstructLumaIntraHalfMB_H264_16s8u_C1R(ppSrcCoeff,
                                                             pSrcDstYPlane,
                                                             srcdstYStep,
                                                             pMBIntraTypes,
                                                             cbp4x2,
                                                             QP,
                                                             edgeType);
    }

    inline IppStatus ReconstructLumaInter8x8MB(Ipp16s **ppSrcDstCoeff,
                                               Ipp8u *pSrcDstYPlane,
                                               Ipp32u srcdstYStep,
                                               Ipp32u cbp8x8,
                                               Ipp32s QP,
                                               Ipp16s *pQuantTable,
                                               Ipp8u bypass_flag,
                                               Ipp32s bit_depth = 8)
    {
        return ippiReconstructLumaInter8x8MB_H264_16s8u_C1R(ppSrcDstCoeff,
                                                            pSrcDstYPlane,
                                                            srcdstYStep,
                                                            cbp8x8,
                                                            QP,
                                                            pQuantTable,
                                                            bypass_flag);
    }

    inline IppStatus ReconstructLumaInter4x4MB(Ipp16s **ppSrcDstCoeff,
                                               Ipp8u *pSrcDstYPlane,
                                               Ipp32u srcdstYStep,
                                               Ipp32u cbp4x4,
                                               Ipp32s QP,
                                               Ipp16s *pQuantTable,
                                               Ipp8u bypass_flag,
                                               Ipp32s bit_depth = 8)
    {