h263dec.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) 2005-2007 Intel Corporation. All Rights Reserved.
//
//  Description:    H.263++ header.
//
*/

#ifndef _H263DEC_H_
#define _H263DEC_H_

#ifdef __cplusplus
extern "C" {
#endif

//#ifdef __INTEL_COMPILER
//#include <emmintrin.h>
//#define USE_INTRINSIC
//#else
#undef USE_INTRINSIC
//#endif

#define h263_Div2(a) ((a) >= 0 ? ((a) >> 1) : (((a)+1) >> 1))
#define h263_Div2Round(a) (((a) >> 1) | ((a) & 1))
#define h263_DivRoundInf(a, b) ((a) < 0 ? (((a) - ((b) >> 1)) / (b)) : (((a) + ((b) >> 1)) / (b)))

__INLINE Ipp16s h263_Median(Ipp16s a, Ipp16s b, Ipp16s c)
{
    if (a > b) {
        Ipp16s  t = a; a = b; b = t;
    }
    return (Ipp16s)((b <= c) ? b : (c >= a) ? c : a);
}

__INLINE void h263_ComputeChromaMV(const IppMotionVector *mvLuma, IppMotionVector *mvChroma)
{
    mvChroma->dx = (Ipp16s)h263_Div2Round(mvLuma->dx);
    mvChroma->dy = (Ipp16s)h263_Div2Round(mvLuma->dy);
}

__INLINE void h263_ComputeChroma4MV(const IppMotionVector mvLuma[4], IppMotionVector *mvChroma)
{
    Ipp32s  dx, dy, cdx, cdy, adx, ady;

    dx = mvLuma[0].dx + mvLuma[1].dx + mvLuma[2].dx + mvLuma[3].dx;
    dy = mvLuma[0].dy + mvLuma[1].dy + mvLuma[2].dy + mvLuma[3].dy;
    adx = abs(dx);
    ady = abs(dy);
    cdx = h263_cCbCrMvRound16[adx & 15] + (adx >> 4) * 2;
    cdy = h263_cCbCrMvRound16[ady & 15] + (ady >> 4) * 2;
    mvChroma->dx = (Ipp16s)((dx >= 0) ? cdx : -cdx);
    mvChroma->dy = (Ipp16s)((dy >= 0) ? cdy : -cdy);
}


#define limitMV(dx, xmin, xmax, mvd) \
{                                    \
    if ((dx) < (xmin))               \
        mvd = (Ipp16s)(xmin);        \
    else if ((dx) >= (xmax))         \
        mvd = (Ipp16s)(xmax);        \
    else                             \
        mvd = (Ipp16s)(dx);          \
}

__INLINE void h263_LimitMV(const IppMotionVector *pSrcMV, IppMotionVector *pDstMV, const IppiRect *limitRect, Ipp32s x, Ipp32s y, Ipp32s size)
{
    limitMV(pSrcMV->dx, (limitRect->x - x) << 1, (limitRect->x - x + limitRect->width  - size) << 1, pDstMV->dx);
    limitMV(pSrcMV->dy, (limitRect->y - y) << 1, (limitRect->y - y + limitRect->height - size) << 1, pDstMV->dy);
}

__INLINE void h263_Limit4MV(const IppMotionVector *pSrcMV, IppMotionVector *pDstMV, const IppiRect *limitRect, Ipp32s x, Ipp32s y, Ipp32s size)
{
    h263_LimitMV(&pSrcMV[0], &pDstMV[0], limitRect, x       , y,        size);
    h263_LimitMV(&pSrcMV[1], &pDstMV[1], limitRect, x + size, y,        size);
    h263_LimitMV(&pSrcMV[2], &pDstMV[2], limitRect, x       , y + size, size);
    h263_LimitMV(&pSrcMV[3], &pDstMV[3], limitRect, x + size, y + size, size);
}

__INLINE void h263_LimitFMV(const IppMotionVector *pSrcMV, IppMotionVector *pDstMV, const IppiRect *limitRect, Ipp32s x, Ipp32s y, Ipp32s size)
{
    limitMV(pSrcMV->dx, (limitRect->x - x) << 1, (limitRect->x - x + limitRect->width  - size) << 1, pDstMV->dx);
    limitMV(pSrcMV->dy << 1, (limitRect->y - y) << 1, (limitRect->y - y + limitRect->height - size) << 1, pDstMV->dy);
    pDstMV->dy >>= 1;
}

#define reconstructMV(mv, mvdx, mvdy, leftlim, rightlim) \
{ \
  Ipp32s dx, dy; \
  dx = (mv)->dx + (mvdx); \
  if (dx < (leftlim)) \
    dx += 64; \
  else if (dx > (rightlim)) \
    dx -= 64; \
  (mv)->dx = (Ipp16s)dx; \
  dy = (mv)->dy + (mvdy); \
  if (dy < (leftlim)) \
    dy += 64; \
  else if (dy > (rightlim)) \
    dy -= 64; \
  (mv)->dy = (Ipp16s)dy; \
}

#define H263_MV_OFF_HP(dx, dy, step) \
    (((dx) >> 1) + (step) * ((dy) >> 1))

#define H263_MV_ACC_HP(dx, dy) \
    ((((dy) & 1) << 1) + ((dx) & 1))

#define H263_MV_OFF_QP(dx, dy, step) \
    (((dx) >> 2) + (step) * ((dy) >> 2))

#define H263_MV_ACC_QP(dx, dy) \
    ((((dy) & 3) << 2) + ((dx) & 3))

#define h263_Copy8x8HP_8u(pSrc, srcStep, pDst, dstStep, mv, rc) \
    ippiCopy8x8HP_8u_C1R(pSrc + H263_MV_OFF_HP((mv)->dx, (mv)->dy, srcStep), srcStep, pDst, dstStep, H263_MV_ACC_HP((mv)->dx, (mv)->dy), rc)

#define h263_Copy16x16HP_8u(pSrc, srcStep, pDst, dstStep, mv, rc) \
    ippiCopy16x16HP_8u_C1R(pSrc + H263_MV_OFF_HP((mv)->dx, (mv)->dy, srcStep), srcStep, pDst, dstStep, H263_MV_ACC_HP((mv)->dx, (mv)->dy), rc)

#define h263_Add8x8HP_16s8u(pSrc, srcStep, pResid, pDst, dstStep, mv, rc) \
    ippiAdd8x8HP_16s8u_C1RS(pResid, 16, pSrc + H263_MV_OFF_HP((mv)->dx, (mv)->dy, srcStep), srcStep, pDst, dstStep, H263_MV_ACC_HP((mv)->dx, (mv)->dy), rc)

#define h263_Add8x8_16s8u(pSrcDst, pResid, srcDstStep) \
    ippiAdd8x8_16s8u_C1IRS(pResid, 16, pSrcDst, srcDstStep)

#define h263_AddBackPredPB_8u(pSrc, srcStep, roi, pSrcDst, srcDstStep, mv) \
  ippiAddBackPredPB_H263_8u_C1R(pSrc, srcStep, roi, pSrcDst, srcDstStep, H263_MV_ACC_HP((mv)->dx, (mv)->dy));

#define h263_UpdateQuant(pInfo, quant) \
{ \
    quant += h263_dquant[h263_GetBits9(pInfo, 2)]; \
    h263_CLIP(quant, 1, 31); \
}

#define h263_UpdateQuant_B(pInfo, quant) \
if (h263_GetBit(pInfo) != 0) { \
    quant += (h263_GetBit(pInfo) == 0) ? -2 : 2; \
    h263_CLIP(quant, 1, 31); \
}

__INLINE void h263_Set8x8_8u(Ipp8u *p, Ipp32s step, Ipp8u v)
{
#ifdef USE_INTRINSIC
    __m64 _p_v = _mm_set1_pi8(v);
    *(__m64*)p = _p_v;
    *(__m64*)(p+step) = _p_v;
    p += 2 * step;
    *(__m64*)p = _p_v;
    *(__m64*)(p+step) = _p_v;
    p += 2 * step;
    *(__m64*)p = _p_v;
    *(__m64*)(p+step) = _p_v;
    p += 2 * step;
    *(__m64*)p = _p_v;
    *(__m64*)(p+step) = _p_v;
    _mm_empty();
#else
    Ipp32u val;

    val = v + (v <<  8);
    val += val << 16;
    ((Ipp32u*)p)[0] = val; ((Ipp32u*)p)[1] = val; p += step;
    ((Ipp32u*)p)[0] = val; ((Ipp32u*)p)[1] = val; p += step;
    ((Ipp32u*)p)[0] = val; ((Ipp32u*)p)[1] = val; p += step;
    ((Ipp32u*)p)[0] = val; ((Ipp32u*)p)[1] = val; p += step;
    ((Ipp32u*)p)[0] = val; ((Ipp32u*)p)[1] = val; p += step;
    ((Ipp32u*)p)[0] = val; ((Ipp32u*)p)[1] = val; p += step;
    ((Ipp32u*)p)[0] = val; ((Ipp32u*)p)[1] = val; p += step;
    ((Ipp32u*)p)[0] = val; ((Ipp32u*)p)[1] = val;
#endif
}

__INLINE void h263_Set16x16_8u(Ipp8u *p, Ipp32s step, Ipp8u val)
{
    Ipp32s i, j;

    for (i = 0; i < 16; i ++) {
        for (j = 0; j < 16; j ++)
            p[j] = val;
        p += step;
    }
}

#ifdef USE_INTRINSIC

#define h263_Zero4MV(mv) \
    memset(mv, 0, 4 * sizeof(IppMotionVector));

#define h263_Zero64_16s(pDst) \
{ \
    __m128i _p_val = _mm_setzero_si128(); \
    ((__m128i*)(pDst))[0] = _p_val; \
    ((__m128i*)(pDst))[1] = _p_val; \
    ((__m128i*)(pDst))[2] = _p_val; \
    ((__m128i*)(pDst))[3] = _p_val; \
    ((__m128i*)(pDst))[4] = _p_val; \
    ((__m128i*)(pDst))[5] = _p_val; \
    ((__m128i*)(pDst))[6] = _p_val; \
    ((__m128i*)(pDst))[7] = _p_val; \
}

#define h263_Set64_16s(val, pDst) \
{ \
    __m128i _p_val = _mm_set1_epi16((Ipp16s)(val)); \
    ((__m128i*)(pDst))[0] = _p_val; \
    ((__m128i*)(pDst))[1] = _p_val; \
    ((__m128i*)(pDst))[2] = _p_val; \
    ((__m128i*)(pDst))[3] = _p_val; \
    ((__m128i*)(pDst))[4] = _p_val; \
    ((__m128i*)(pDst))[5] = _p_val; \
    ((__m128i*)(pDst))[6] = _p_val; \
    ((__m128i*)(pDst))[7] = _p_val; \
}

#else

#define h263_Zero4MV(mv) \
    (mv)[0].dx = (mv)[0].dy = (mv)[1].dx = (mv)[1].dy = (mv)[2].dx = (mv)[2].dy = (mv)[3].dx = (mv)[3].dy = 0

#define h263_Zero64_16s(pDst) \
{ \
    Ipp32s  i; \
    for (i = 0; i < 16; i += 4) {\
        ((Ipp64u*)(pDst))[i] = 0; \
        ((Ipp64u*)(pDst))[i+1] = 0; \
        ((Ipp64u*)(pDst))[i+2] = 0; \
        ((Ipp64u*)(pDst))[i+3] = 0; \
    } \
}

#define h263_Set64_16s(val, pDst) \
{ \
    Ipp32s  i; \
    Ipp32u  v; \
    v = ((val) << 16) + (Ipp16u)(val); \
    for (i = 0; i < 32; i += 8) { \
        ((Ipp32u*)(pDst))[i] = v; \
        ((Ipp32u*)(pDst))[i+1] = v; \
        ((Ipp32u*)(pDst))[i+2] = v; \
        ((Ipp32u*)(pDst))[i+3] = v; \
        ((Ipp32u*)(pDst))[i+4] = v; \
        ((Ipp32u*)(pDst))[i+5] = v; \
        ((Ipp32u*)(pDst))[i+6] = v; \
        ((Ipp32u*)(pDst))[i+7] = v; \
    } \
}

#endif

#define h263_MC_HP(pat, pRef, stepRef, pCur, stepCur, coeffMB, mv, rc) \
{ \
    if (pat) { \
        h263_Add8x8HP_16s8u(pRef, stepRef, coeffMB, pCur, stepCur, mv, rc); \
    } else { \