mpeg2_defs.h

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

    X##RefFrameB + vectorB_bottom.offset_##C, \
    C##FrameHSize,                          \
    vectorB_bottom.mctype_##C,                \
    pDiff + OFF_##X + (BlkHeight_##C/2)*BlkStride_##C,          \
    2*BlkStride_##C,                          \
    ippRndZero);                              \
}

#define MC_FRAME_F(X, C, pDiff)       \
  func_mc_frame_##C(                  \
    X##RefFrameF + vectorF.offset_##C, \
    C##FrameHSize,                    \
    pDiff + OFF_##X,                  \
    2*BlkStride_##C,                  \
    X##BlockRef,                      \
    C##FrameHSize,                    \
    vectorF.mctype_##C,                \
    (IppRoundMode)0 )

#define MC_FIELD_F(X, C, pDiff)           \
if (PICTURE_STRUCTURE == FRAME_PICTURE) {   \
  func_mc_field_##C(                      \
    X##RefFrameF + vectorF_top.offset_##C, \
    2*C##FrameHSize,                      \
    pDiff + OFF_##X,                      \
    4*BlkStride_##C,                      \
    X##BlockRef,                          \
    2*C##FrameHSize,                      \
    vectorF_top.mctype_##C,                \
    (IppRoundMode)0 );                    \
                                          \
  func_mc_field_##C(                         \
    X##RefFrameF + vectorF_bottom.offset_##C, \
    2*C##FrameHSize,                         \
    pDiff + OFF_##X + BlkStride_##C,         \
    4*BlkStride_##C,                         \
    X##BlockRef + C##FrameHSize,             \
    2*C##FrameHSize,                         \
    vectorF_bottom.mctype_##C,                \
    (IppRoundMode)0 );                       \
} else {                                    \
  func_mc_field_##C(                      \
    X##RefFrameF + vectorF_top.offset_##C, \
    C##FrameHSize,                      \
    pDiff + OFF_##X,                      \
    2*BlkStride_##C,                      \
    X##BlockRef,                          \
    C##FrameHSize,                      \
    vectorF_top.mctype_##C,                \
    (IppRoundMode)0 );                    \
                                          \
  func_mc_field_##C(                         \
    X##RefFrameF + vectorF_bottom.offset_##C, \
    C##FrameHSize,                         \
    pDiff + OFF_##X + (BlkHeight_##C/2)*BlkStride_##C,  \
    2*BlkStride_##C,                         \
    X##BlockRef + (BlkHeight_##C/2)*C##FrameHSize, \
    C##FrameHSize,                         \
    vectorF_bottom.mctype_##C,                \
    (IppRoundMode)0 );                       \
}

#define ME_FRAME(DIR, vardiff_res, pDiff, dct_type)            \
{                                                              \
  Ipp32s vardiff_tmp[4], meandiff_tmp[4], _vardiff;            \
                                                               \
  pRef = YRefFrame##DIR + cur_offset;                          \
                                                               \
  me##DIR##_bound_left = i - encodeInfo.pMotionData[B_count].SearchWidth##DIR;   \
  if (me##DIR##_bound_left < 0)                                                  \
  {                                                                              \
    me##DIR##_bound_left = 0;                                                    \
  }                                                                              \
  me##DIR##_bound_right = i + encodeInfo.pMotionData[B_count].SearchWidth##DIR;  \
  if (me##DIR##_bound_right > YFrameHSize - 16) {                                \
    me##DIR##_bound_right = YFrameHSize - 16;                                    \
  }                                                                              \
  me##DIR##_bound_top = j - encodeInfo.pMotionData[B_count].SearchHeight##DIR;   \
  if( me##DIR##_bound_top < 0 )                                                  \
  {                                                                              \
    me##DIR##_bound_top = 0;                                                     \
  }                                                                              \
  me##DIR##_bound_bottom = j + encodeInfo.pMotionData[B_count].SearchHeight##DIR;\
  if (me##DIR##_bound_bottom > YFrameVSize - 16) {                               \
    me##DIR##_bound_bottom = YFrameVSize - 16;                                   \
  }                                                                              \
  me##DIR##_bound_left -= i;                                   \
  me##DIR##_bound_right -= i;                                  \
  me##DIR##_bound_top -= j;                                    \
  me##DIR##_bound_bottom -= j;                                 \
                                                               \
  vardiff_res = MotionEstimation_Frame( pRef,                  \
    YFrameHSize,                                               \
    YBlock,                                                    \
    nYPitch,                                                   \
    mean_frm,                                                  \
    curr->var,                                                 \
    curr->mean,                                                \
    me##DIR##_bound_left,                                      \
    me##DIR##_bound_right,                                     \
    me##DIR##_bound_top,                                       \
    me##DIR##_bound_bottom,                                    \
    threadSpec[numTh].PMV[0][ind##DIR],                        \
    (j != start_y) ? pMBInfo[k - (Y_width>>4)].MV[0][ind##DIR] \
                   : MV_ZERO,                                  \
    &vector##DIR,                                              \
    &threadSpec[numTh],                                        \
    i, j,                                                      \
    &pMBInfo[k].mv_field_sel[0][ind##DIR],                     \
    NULL);                                                     \
                                                               \
  dct_type = DCT_FRAME;                                        \
  if (!curr_frame_dct) {                                       \
    GETDIFF_FRAME(Y, l, pDiff, DIR);                           \
                                                               \
    VARMEAN_FIELD(pDiff, vardiff_tmp, meandiff_tmp, _vardiff); \
                                                               \
    if (_vardiff < vardiff_res) {                              \
      vardiff_res = _vardiff;                                  \
      dct_type = DCT_FIELD;                                    \
    }                                                          \
  }                                                            \
}

#define ME_FIELD(DIR, vardiff_fld, pDiff, dct_type)              \
{                                                                \
  Ipp32s vardiff_tmp[4], meandiff_tmp[4], _vardiff;              \
                                                                 \
  if (PICTURE_STRUCTURE == FRAME_PICTURE) {                      \
    vardiff_fld = MotionEstimation_Field( pRef,                  \
      2*Y_width,                                                 \
      YBlock,                                                    \
      2*nYPitch,                                                 \
      mean_fld,                                                  \
      curr->var,                                                 \
      curr->mean,                                                \
      me##DIR##_bound_left,                                      \
      me##DIR##_bound_right,                                     \
      (me##DIR##_bound_top + 1) >> 1,                            \
      me##DIR##_bound_bottom >> 1,                               \
      threadSpec[numTh].PMV[0][ind##DIR],                        \
      (j != start_y) ? pMBInfo[k - (Y_width>>4)].MV[0][ind##DIR] \
                     : MV_ZERO,                                  \
      &vector##DIR##_top,                                        \
      &threadSpec[numTh],                                         \
      i, j,                                                      \
      &pMBInfo[k].mv_field_sel[0][ind##DIR],                     \
      NULL);                                                     \
                                                                 \
    vardiff_fld += MotionEstimation_Field( pRef,                 \
      2*Y_width,                                                 \
      YBlock + nYPitch,                                          \
      2*nYPitch,                                                 \
      mean_fld + 2,                                              \
      curr->var + 2,                                             \
      curr->mean + 2,                                            \
      me##DIR##_bound_left,                                      \
      me##DIR##_bound_right,                                     \
      (me##DIR##_bound_top + 1) >> 1,                            \
      me##DIR##_bound_bottom >> 1,                               \
      threadSpec[numTh].PMV[1][ind##DIR],                        \
      (j != start_y) ? pMBInfo[k - (Y_width>>4)].MV[1][ind##DIR] \
                     : MV_ZERO,                                  \
      &vector##DIR##_bottom,                                     \
      &threadSpec[numTh],                                        \
      i, j,                                                      \
      &pMBInfo[k].mv_field_sel[1][ind##DIR],                     \
      NULL);                                                     \
                                                                 \
    GETDIFF_FIELD(Y, l, pDiff, DIR);                             \
                                                                 \
    VARMEAN_FRAME(pDiff, vardiff_tmp, meandiff_tmp, _vardiff);   \
                                                                 \
    dct_type = DCT_FIELD;                                        \
    if(_vardiff <= vardiff_fld) {                                \
      dct_type = DCT_FRAME;                                      \
      vardiff_fld = _vardiff;                                    \
    }                                                            \
  } else {                                                       \
    vardiff_fld = MotionEstimation_FieldPict(pRef,               \
      Y_width,                                                   \
      YBlock,                                                    \
      nYPitch,                                                   \
      mean_fld,                                                  \
      curr->var,                                                 \
      curr->mean,                                                \
      me##DIR##_bound_left,                                      \
      me##DIR##_bound_right,                                     \
      me##DIR##_bound_top,                                       \
      me##DIR##_bound_bottom,                                    \
      threadSpec[numTh].PMV[0][ind##DIR],                        \
      (j != start_y) ? pMBInfo[k - (Y_width>>4)].MV[0][ind##DIR] \
                     : MV_ZERO,                                  \
      &(vector##DIR##_top),                                      \
      &threadSpec[numTh],                                        \
      i, j,                                                      \
      &pMBInfo[k].mv_field_sel[0][ind##DIR],                     \
      NULL);                                                     \
                                                                 \
    vardiff_fld += MotionEstimation_FieldPict(pRef + 8*Y_width,  \
      Y_width,                                                   \
      YBlock + 8*nYPitch,                                        \
      nYPitch,                                                   \
      mean_fld + 2,                                              \
      curr->var + 2,                                             \
      curr->mean + 2,                                            \
      me##DIR##_bound_left,                                      \
      me##DIR##_bound_right,                                     \
      me##DIR##_bound_top,                                       \
      me##DIR##_bound_bottom,                                    \
      threadSpec[numTh].PMV[1][ind##DIR],                        \
      (j != start_y) ? pMBInfo[k - (Y_width>>4)].MV[1][ind##DIR] \
                     : MV_ZERO,                                  \
      &(vector##DIR##_bottom),                                   \
      &threadSpec[numTh],                                        \
      i, j + 8,                                                  \
      &pMBInfo[k].mv_field_sel[1][ind##DIR],                     \
      NULL);                                                     \
                                                                 \
    GETDIFF_FIELD(Y, l, pDiff, DIR);                             \
    dct_type = DCT_FRAME;                                        \
  }                                                              \
}

/*********************************************************/

#ifdef _BIG_ENDIAN_
#define BSWAP(x) (x)
#else // Little endian
#define BSWAP(x) (unsigned int)(((x) << 24) + (((x)&0xff00) << 8) + (((x) >> 8)&0xff00) + ((x) >> 24))
#endif

#define ippiPutBits(pBitStream,offset,val,len) \
 { \
    Ipp32s tmpcnt; \
    Ipp32u r_tmp; \
    mpeg2_assert((offset) >= 0 && (offset) <= 32);\
    mpeg2_assert((len) > 0 && (len) < 32); \
    mpeg2_assert(((val) & (-1 << (len))) == 0);\
    \
    tmpcnt = (offset) - (len); \
    if(tmpcnt < 0) \
    { \
      r_tmp = (pBitStream)[0] | ((val) >> (-tmpcnt)); \
      (pBitStream)[0] = BSWAP(r_tmp); \
      (pBitStream)++; \
      (pBitStream)[0] = (val) << (32 + tmpcnt); \
      (offset) = 32 + tmpcnt; \
    } \
    else \
    { \
      (pBitStream)[0] |= (val) << tmpcnt; \
      (offset) = tmpcnt; \
    } \
}

#define FLUSH_BITSTREAM(pBitStream, offset)   \
  if (offset != 32) {                         \
    (pBitStream)[0] = BSWAP((pBitStream)[0]); \
    (pBitStream)++;                           \
    offset &= ~7;                              \
  }

#define CHECK_BUFFER \
  if ((Ipp8u*)threadSpec[numTh].current_pointer > (Ipp8u*)threadSpec[numTh].start_pointer + thread_buffer_size - 200) { \
    /*mpeg2_assert(0);*/ \
    /*flushBuffer();*/ \
    if ((Ipp8u*)threadSpec[numTh].current_pointer >= (Ipp8u*)threadSpec[numTh].start_pointer + thread_buffer_size) { \
      /*mpeg2_assert(0);*/ \
    } \
  }

#define PUT_BITS_THREAD(nTh, VAL, NBITS) \
  ippiPutBits(threadSpec[nTh].current_pointer, \
              threadSpec[nTh].bit_offset, \
              VAL, NBITS)

#define PUT_BITS_TH(VAL, NBITS) \
  PUT_BITS_THREAD(numTh, VAL, NBITS)

#define PUT_BITS(VAL, NBITS) \
  PUT_BITS_THREAD(0, VAL, NBITS)

#define PUT_ALIGNMENT(nTh) \
  threadSpec[nTh].bit_offset &= ~7;

#define PUT_START_CODE_TH(th,scode) { \
  Ipp32u code1, code2; \
  int off = threadSpec[th].bit_offset &~ 7; \
  code1 = threadSpec[th].current_pointer[0]; \
  code2 = 0; \
  if(off > 0) code1 |= (scode) >> (32-off); \
  if(off < 32) code2 = (scode) << off; \
  threadSpec[th].current_pointer[0] = BSWAP(code1); \
  threadSpec[th].current_pointer++; \
  threadSpec[th].current_pointer[0] = code2; \
  threadSpec[th].bit_offset = off; \
}

#define PUT_START_CODE(scode) PUT_START_CODE_TH(0,scode)

#define PUT_BLOCK_PATTERN(CodedBlockPattern) \
if (CodedBlockPattern) { \
  int extra_bits = block_count - 6; \
  int cbp6 = (CodedBlockPattern >> extra_bits) & 63; \
  PUT_BITS_TH(CBP_VLC_Tbl[cbp6].code, CBP_VLC_Tbl[cbp6].len); \
  if (extra_bits) { \
    PUT_BITS_TH(CodedBlockPattern & ((1 << extra_bits) - 1), extra_bits); \
  } \
}

#define PUT_MB_TYPE(PictureType, MOTION_TYPE, FIELD) \
{ \
  int mb_type = MOTION_TYPE; \
  \
  if (CodedBlockPattern) mb_type |= MB_PATTERN; \
  \
  PUT_BITS_TH(mbtypetab[PictureType - 1][mb_type].code, \
              mbtypetab[PictureType - 1][mb_type].len); \
  \
  if (picture_structure != FRAME_PICTURE) { \
    /* (3 - x) is: MC_FRAME -> MC_FIELD, MC_FIELD -> MC_16X8 */ \
    PUT_BITS_TH(3 - pMBInfo[k].prediction_type, 2); \
  } else \
  if (!curr_frame_dct || MC_##FIELD == MC_FIELD) { \
    if (MOTION_TYPE) { \
      PUT_BITS_TH(pMBInfo[k].prediction_type, 2); \
    } \
    if (CodedBlockPattern) { \
      PUT_BITS_TH(pMBInfo[k].dct_type, 1); \
    } \
  } \
}

#endif //_MPEG2_DEFS_H_