mpeg2_defs.h

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

/*//////////////////////////////////////////////////////////////////////////////
//
//                  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) 2002-2005 Intel Corporation. All Rights Reserved.
//
*/

#ifndef _MPEG2_DEFS_H_
#define _MPEG2_DEFS_H_

#include "ipp.h"
#include "vm_semaphore.h"
#include "vm_event.h"
#include "vm_thread.h"

#include "mpeg2_video_encoder.h"

#if defined(_DEBUG) || defined(MPEG2_ASSERT) || defined(MPEG2_DEBUG_CODE)
#define mpeg2_assert(value) \
if (!(value)) { \
  printf("######################################################\n"); \
  printf("%s: %d: Assertion failed: " #value "\n", __FILE__, __LINE__); \
  printf("######################################################\n"); \
  exit(1); \
}
#else
#define mpeg2_assert(value) 0
#endif

#define USE_EXTERN_CALC

#if 1
#define GET_TICKS      vm_time_get_tick()
#define GET_FREQUENCY  vm_time_get_frequency()
#else
#define GET_TICKS      ippGetCpuClocks()
#define GET_FREQUENCY  CPU_FREQUENCY
#endif

#define PICTURE_START_CODE 0x100L
#define SLICE_MIN_START    0x101L
#define SLICE_MAX_START    0x1AFL
#define USER_START_CODE    0x1B2L
#define SEQ_START_CODE     0x1B3L
#define EXT_START_CODE     0x1B5L
#define SEQ_END_CODE       0x1B7L
#define GOP_START_CODE     0x1B8L
#define ISO_END_CODE       0x1B9L
#define PACK_START_CODE    0x1BAL
#define SYSTEM_START_CODE  0x1BBL

/* picture_structure ISO/IEC 13818-2, 6.3.10 table 6-14 */
enum
{
  TOP_FIELD     = 1,
  BOTTOM_FIELD  = 2,
  FRAME_PICTURE = 3
};

/* macroblock type */
#define MB_INTRA    1
#define MB_PATTERN  2
#define MB_BACKWARD 4
#define MB_FORWARD  8
#define MB_QUANT    16

/* motion_type */
#define MC_FIELD 1
#define MC_FRAME 2
#define MC_16X8  2
#define MC_DMV   3

/* extension start code IDs */

#define SEQ_ID       1
#define DISP_ID      2
#define QUANT_ID     3
#define SEQSCAL_ID   5
#define PANSCAN_ID   7
#define CODING_ID    8
#define SPATSCAL_ID  9
#define TEMPSCAL_ID 10

/* input file type */
#define T_Y_U_V 0   // .y; .u; .v;
#define T_YUV   1   // .yuv
#define T_PPM   2   // .ppm

#define V_DC_Tbl Cr_DC_Tbl
#define U_DC_Tbl Cr_DC_Tbl

#define CALC_START_STOP_ROWS                       \
  if(threads)                                      \
  {                                                \
    start_y = threadSpec[numTh].start_row;         \
    if(encodeInfo.FieldPicture) start_y >>= 1;     \
    if (numTh < m_numThreads - 1) {                \
      stop_y = threadSpec[numTh + 1].start_row;    \
      if(encodeInfo.FieldPicture) stop_y >>= 1;    \
    } else {                                       \
      stop_y = YFrameVSize;                        \
    }                                              \
    if (encodeInfo.chroma_format == CHROMA420) {   \
      start_uv = (start_y >> 1);                   \
    } else {                                       \
      start_uv = start_y;                          \
    }                                              \
    k = (start_y*YFrameHSize)/(16*16);             \
  }                                                \
  else                                             \
  {                                                \
    start_y = start_uv = 0;                        \
    stop_y = YFrameVSize;                          \
    k = 0;                                         \
  }

#define SWAP_PTR(ptr0, ptr1) { \
  MB_prediction_info *tmp_ptr = ptr0; \
  ptr0 = ptr1; \
  ptr1 = tmp_ptr; \
}

#define SET_MOTION_VECTOR(vectorF, mv_x, mv_y) { \
  int x_l = mv_x; \
  int y_l = mv_y; \
  int ic = (BlkWidth_c  == 16) ? i : (i >> 1); \
  int jc = (BlkHeight_c == 16) ? j : (j >> 1); \
  int x_c = (BlkWidth_c  == 16) ? x_l : (x_l/2); \
  int y_c = (BlkHeight_c == 16) ? y_l : (y_l/2); \
  vectorF->x = x_l;              \
  vectorF->y = y_l;              \
  vectorF->mctype_l = ((x_l & 1) << 3) | ((y_l & 1) << 2); \
  vectorF->mctype_c = ((x_c & 1) << 3) | ((y_c & 1) << 2); \
  vectorF->offset_l = (i  + (x_l >> 1)) + (j  + (y_l >> 1)) * YFrameHSize; \
  vectorF->offset_c = (ic + (x_c >> 1)) + (jc + (y_c >> 1)) * UVFrameHSize; \
}

#define SET_FIELD_VECTOR(vectorF, mv_x, mv_y, field_select) { \
  int x_l = mv_x; \
  int y_l = mv_y; \
  int ic = (BlkWidth_c  == 16) ? i : (i >> 1); \
  int jc = (BlkHeight_c == 16) ? j : (j >> 1); \
  int x_c = (BlkWidth_c  == 16) ? x_l : (x_l/2); \
  int y_c = (BlkHeight_c == 16) ? y_l : (y_l/2); \
  vectorF->x = x_l;              \
  vectorF->y = y_l;              \
  vectorF->mctype_l = ((x_l & 1) << 3) | ((y_l & 1) << 2); \
  vectorF->mctype_c = ((x_c & 1) << 3) | ((y_c & 1) << 2); \
  vectorF->offset_l = (i  + (x_l >> 1)) + (j  + (y_l &~ 1) + field_select) * YFrameHSize; \
  vectorF->offset_c = (ic + (x_c >> 1)) + (jc + (y_c &~ 1) + field_select) * UVFrameHSize; \
}

#define OFF_Y    0
#define OFF_U  256
#define OFF_V  512

#define DCT_FRAME  0
#define DCT_FIELD  1

#define BlkWidth_l   16
#define BlkHeight_l  16
#define BlkStride_l  16
#define lFrameHSize  YFrameHSize
#define cFrameHSize  UVFrameHSize

#define func_getdiff_frame_l  ippiGetDiff16x16_8u16s_C1
#define func_getdiff_field_l  ippiGetDiff16x8_8u16s_C1
#define func_getdiffB_frame_l ippiGetDiff16x16B_8u16s_C1
#define func_getdiffB_field_l ippiGetDiff16x8B_8u16s_C1
#define func_mc_frame_l  ippiMC16x16_8u_C1
#define func_mc_field_l  ippiMC16x8_8u_C1
#define func_mcB_frame_l ippiMC16x16B_8u_C1
#define func_mcB_field_l ippiMC16x8B_8u_C1

#define PICTURE_STRUCTURE  picture_structure

typedef struct {
  int mb_type;
  int mc_type;
  int dct_type;
  int pred_type;
  Ipp32s var[4];
  Ipp32s mean[4];
  Ipp32s var_sum;
  Ipp16s *pDiff;
} MB_prediction_info;

#define indF 0
#define indB 1

#define VARMEAN_FRAME(pDiff, vardiff, meandiff, _vardiff)           \
  ippiVarMean8x8_16s32s_C1R(pDiff    , 32, &vardiff[0], &meandiff[0]); \
  ippiVarMean8x8_16s32s_C1R(pDiff+8  , 32, &vardiff[1], &meandiff[1]); \
  ippiVarMean8x8_16s32s_C1R(pDiff+128, 32, &vardiff[2], &meandiff[2]); \
  ippiVarMean8x8_16s32s_C1R(pDiff+136, 32, &vardiff[3], &meandiff[3]); \
  _vardiff = vardiff[0] + vardiff[1] + vardiff[2] + vardiff[3]

#define VARMEAN_FIELD(pDiff, vardiff, meandiff, _vardiff)           \
  ippiVarMean8x8_16s32s_C1R(pDiff   ,  64, &vardiff[0], &meandiff[0]); \
  ippiVarMean8x8_16s32s_C1R(pDiff+8 ,  64, &vardiff[1], &meandiff[1]); \
  ippiVarMean8x8_16s32s_C1R(pDiff+16,  64, &vardiff[2], &meandiff[2]); \
  ippiVarMean8x8_16s32s_C1R(pDiff+24,  64, &vardiff[3], &meandiff[3]); \
  _vardiff = vardiff[0] + vardiff[1] + vardiff[2] + vardiff[3]

#define VARMEAN_FRAME_Y(vardiff, meandiff, _vardiff)           \
  ippiVarMean8x8_8u32s_C1R(YBlock                , nYPitch, &vardiff[0], &meandiff[0]); \
  ippiVarMean8x8_8u32s_C1R(YBlock + 8            , nYPitch, &vardiff[1], &meandiff[1]); \
  ippiVarMean8x8_8u32s_C1R(YBlock + 8*nYPitch    , nYPitch, &vardiff[2], &meandiff[2]); \
  ippiVarMean8x8_8u32s_C1R(YBlock + 8*nYPitch + 8, nYPitch, &vardiff[3], &meandiff[3]); \
  _vardiff = vardiff[0] + vardiff[1] + vardiff[2] + vardiff[3]

#define VARMEAN_FIELD_Y(vardiff, meandiff, _vardiff)           \
  ippiVarMean8x8_8u32s_C1R(YBlock,               2*nYPitch, &vardiff[0], &meandiff[0]); \
  ippiVarMean8x8_8u32s_C1R(YBlock + 8,           2*nYPitch, &vardiff[1], &meandiff[1]); \
  ippiVarMean8x8_8u32s_C1R(YBlock + nYPitch,     2*nYPitch, &vardiff[2], &meandiff[2]); \
  ippiVarMean8x8_8u32s_C1R(YBlock + nYPitch + 8, 2*nYPitch, &vardiff[3], &meandiff[3]); \
  _vardiff = vardiff[0] + vardiff[1] + vardiff[2] + vardiff[3]

#define IF_GOOD_PRED(vardiff, meandiff) \
  if(vardiff[0] <= threadSpec[numTh].var_min && \
     vardiff[1] <= threadSpec[numTh].var_min && \
     vardiff[2] <= threadSpec[numTh].var_min && \
     vardiff[3] <= threadSpec[numTh].var_min)   \
    if(meandiff[0] < quantiser_scale_value &&   \
       meandiff[0] > -quantiser_scale_value)    \
      if(meandiff[1] < quantiser_scale_value && \
         meandiff[1] > -quantiser_scale_value)  \
        if(meandiff[2] < quantiser_scale_value &&   \
           meandiff[2] > -quantiser_scale_value)    \
          if(meandiff[3] < quantiser_scale_value && \
             meandiff[3] > -quantiser_scale_value)

#define GETDIFF_FRAME(X, C, pDiff, DIR)        \
  func_getdiff_frame_##C(                      \
    X##Block,                                  \
    n##X##Pitch,                               \
    X##RefFrame##DIR + vector##DIR.offset_##C, \
    C##FrameHSize,                             \
    pDiff + OFF_##X,                           \
    2*BlkStride_##C,                           \
    0, 0, vector##DIR.mctype_##C, 0)

#define GETDIFF_FRAME_FB(X, C, pDiff) \
  func_getdiffB_frame_##C(X##Block,   \
    n##X##Pitch,                      \
    X##RefFrameF + vectorF.offset_##C, \
    C##FrameHSize,                    \
    vectorF.mctype_##C,               \
    X##RefFrameB + vectorB.offset_##C,\
    C##FrameHSize,                    \
    vectorB.mctype_##C,               \
    pDiff + OFF_##X,                  \
    2*BlkStride_##C,                  \
    ippRndZero)

#define GETDIFF_FIELD(X, C, pDiff, DIR)      \
if (PICTURE_STRUCTURE == FRAME_PICTURE) {   \
  func_getdiff_field_##C(X##Block,        \
    2*n##X##Pitch,                        \
    X##RefFrame##DIR + vector##DIR##_top.offset_##C, \
    2*C##FrameHSize,                      \
    pDiff + OFF_##X,                      \
    4*BlkStride_##C,                      \
    0, 0, vector##DIR##_top.mctype_##C, 0);     \
                                          \
  func_getdiff_field_##C(X##Block + n##X##Pitch, \
    2*n##X##Pitch,                         \
    X##RefFrame##DIR + vector##DIR##_bottom.offset_##C, \
    2*C##FrameHSize,                       \
    pDiff + OFF_##X + BlkStride_##C,       \
    4*BlkStride_##C,                       \
    0, 0, vector##DIR##_bottom.mctype_##C, 0); \
} else {                                   \
  func_getdiff_field_##C(X##Block,         \
    n##X##Pitch,                           \
    X##RefFrame##DIR + vector##DIR##_top.offset_##C,    \
    C##FrameHSize,                                      \
    pDiff + OFF_##X,                                    \
    2*BlkStride_##C,                                    \
    0, 0, vector##DIR##_top.mctype_##C, 0);             \
                                                        \
  func_getdiff_field_##C(X##Block + (BlkHeight_##C/2)*n##X##Pitch, \
    n##X##Pitch,                                        \
    X##RefFrame##DIR + vector##DIR##_bottom.offset_##C, \
    C##FrameHSize,                                      \
    pDiff + OFF_##X + (BlkHeight_##C/2)*BlkStride_##C,  \
    2*BlkStride_##C,                                    \
    0, 0, vector##DIR##_bottom.mctype_##C, 0);          \
}

#define GETDIFF_FIELD_FB(X, C, pDiff)     \
if (PICTURE_STRUCTURE == FRAME_PICTURE) { \
  func_getdiffB_field_##C(X##Block,       \
    2*n##X##Pitch,                        \
    X##RefFrameF + vectorF_top.offset_##C,\
    2*C##FrameHSize,                      \
    vectorF_top.mctype_##C,               \
    X##RefFrameB + vectorB_top.offset_##C,\
    2*C##FrameHSize,                      \
    vectorB_top.mctype_##C,               \
    pDiff + OFF_##X,                      \
    4*BlkStride_##C,                      \
    ippRndZero);                          \
                                          \
  func_getdiffB_field_##C(X##Block + n##X##Pitch, \
    2*n##X##Pitch,                            \
    X##RefFrameF + vectorF_bottom.offset_##C,  \
    2*C##FrameHSize,                          \
    vectorF_bottom.mctype_##C,                 \
    X##RefFrameB + vectorB_bottom.offset_##C, \
    2*C##FrameHSize,                          \
    vectorB_bottom.mctype_##C,                \
    pDiff + OFF_##X + BlkStride_##C,          \
    4*BlkStride_##C,                          \
    ippRndZero);                              \
} else {                                      \
  func_getdiffB_field_##C(X##Block,       \
    n##X##Pitch,                        \
    X##RefFrameF + vectorF_top.offset_##C,\
    C##FrameHSize,                      \
    vectorF_top.mctype_##C,               \
    X##RefFrameB + vectorB_top.offset_##C,\
    C##FrameHSize,                      \
    vectorB_top.mctype_##C,               \
    pDiff + OFF_##X,                      \
    2*BlkStride_##C,                      \
    ippRndZero);                          \
                                          \
  func_getdiffB_field_##C(                   \
    X##Block + (BlkHeight_##C/2)*n##X##Pitch, \
    n##X##Pitch,                            \
    X##RefFrameF + vectorF_bottom.offset_##C,  \
    C##FrameHSize,                          \
    vectorF_bottom.mctype_##C,                 \