umc_mpeg2_dec_mb.cpp

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

  Ipp8u *cur_Y_data = video->frame_buffer.frame_p_c_n[curr_index].Y_comp_data;
  Ipp8u *cur_U_data = video->frame_buffer.frame_p_c_n[curr_index].U_comp_data;
  Ipp8u *cur_V_data = video->frame_buffer.frame_p_c_n[curr_index].V_comp_data;
  pMacro->blkCurrYUV[0] = cur_Y_data + pMacro->offset_l;
  pMacro->blkCurrYUV[1] = cur_U_data + pMacro->offset_c;
  pMacro->blkCurrYUV[2] = cur_V_data + pMacro->offset_c;

  if (pMacro->macroblock_motion_forward && pMacro->macroblock_motion_backward) {
    mc_mp2_420b_frame(zero_memory, threadID);
  } else {
#ifdef KEEP_HISTORY
    if (!(macroblock_type & IPPVC_MB_PATTERN)) {
      if (PictureHeader.picture_coding_type == B_FRAME) {
        int id_his = 0;
        if (!pMacro->macroblock_motion_backward) {
          if (!pMacro->vector[0] && !pMacro->vector[1]) id_his = 2;
        } else {
          if (!pMacro->vector[2] && !pMacro->vector[3]) id_his = 3;
        }
        if (id_his) {
          unsigned char *ref_history = video->frame_buffer.frame_p_c_n[video->frame_buffer.ind_his_ref].frame_history;
          unsigned char *curr_history = video->frame_buffer.frame_p_c_n[video->frame_buffer.ind_his_curr].frame_history;
          int offset_his = pSlice->mb_row*sequenceHeader.mb_width + pSlice->mb_col;
          curr_history[offset_his] = id_his;
          if (sequenceHeader.b_curr_number > 1) { // try skip
            if (ref_history[offset_his] == id_his) {
              return umcRes;
            }
          }
        }
      }
    }
#endif /* KEEP_HISTORY */
    mc_mp2_420_frame_zero(threadID);
  }

  if (macroblock_type & IPPVC_MB_PATTERN) {
    IppVideoContext*        video = &Video[threadID];
    int                     code;
    sSlice  *pSlice   = &Video[threadID].slice;
    int blk;
    int curr_index = video->frame_buffer.curr_index;
    Ipp8u *cur_Y_data = video->frame_buffer.frame_p_c_n[curr_index].Y_comp_data;
    Ipp8u *cur_U_data = video->frame_buffer.frame_p_c_n[curr_index].U_comp_data;
    Ipp8u *cur_V_data = video->frame_buffer.frame_p_c_n[curr_index].V_comp_data;
    Ipp8u* yuv[3] = {
      cur_Y_data + pMacro->offset_l,
      cur_U_data + pMacro->offset_c,
      cur_V_data + pMacro->offset_c
    };
    int *pitch = blkPitches[dct_type];
    int *offsets = blkOffsets[dct_type];

    DECODE_VLC(code, video->bs, vlcMBPattern);

    for (blk = 0; blk < 6; blk++) {
      if (code & 32) {
        int chromaFlag = blk >> 2;
        int cc = chromaFlag + (blk & chromaFlag);
        ippiDecodeInter8x8IDCTAdd_MPEG2_1u8u(
          &video->bs_curr_ptr,
          &video->bs_bit_offset,
          decodeInterSpec,
          pSlice->cur_q_scale,
          yuv[cc] + offsets[blk],
          pitch[chromaFlag]);
      }
      code += code;
    }
  }

  return umcRes;
}//Macroblock_420_frame

Status MPEG2VideoDecoderBase::Macroblock_420_DP(int threadID,
                                                int macroblock_type)
{
  IppVideoContext *video = &Video[threadID];
  sMacroblock     *pMacro = &Video[threadID].macroblock;
  sPictureHeader  *pPic = &PictureHeader;
  sSlice          *pSlice = &Video[threadID].slice;
  int dct_type = 0;
  Status umcRes;

  if(macroblock_type & 0x02) {
    GET_1BIT(video->bs,dct_type);
  }

  if(macroblock_type & 0x10)
  {
    GET_TO9BITS(video->bs, 5, pSlice->quantizer_scale)
    if(pSlice->quantizer_scale < 1)
        return UMC_BAD_STREAM;
    pSlice->cur_q_scale = q_scale[PictureHeader.q_scale_type][pSlice->quantizer_scale];
  }

  mv_decode_dp(threadID);

  pSlice->macroblock_motion_forward_prev = pMacro->macroblock_motion_forward;
  pSlice->macroblock_motion_backward_prev = pMacro->macroblock_motion_backward;

  short* diff = video->block.idct;
  if (macroblock_type & IPPVC_MB_PATTERN) {
    umcRes = ReconstuctInterMB(threadID, dct_type);
    if (UMC_OK != umcRes) return umcRes;
  } else {
    diff = zero_memory;
  }

  unsigned int        pitch_Y, pitch_UV;
  unsigned int        pitch_Y_2;
  unsigned int        pitch_UV_2;
  Ipp8u               *ref_Y_data, *ref_U_data, *ref_V_data;
  Ipp8u               *cur_Y_data, *cur_U_data, *cur_V_data;
  vm_byte *pbRef;
  vm_byte *pbRef0;
  vm_byte *pbRef1;
  vm_var32 nMCType;
  vm_var32 nMCType0;
  vm_var32 nMCType1;
  size_t nOffset;

  pitch_Y    = video->frame_buffer.Y_comp_pitch;
  pitch_UV   = video->frame_buffer.U_comp_pitch;
  pitch_Y_2  = pitch_Y << 1;
  pitch_UV_2 = pitch_UV << 1;

  ref_Y_data = video->frame_buffer.frame_p_c_n[video->frame_buffer.prev_index].Y_comp_data;
  cur_Y_data = video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].Y_comp_data;
  ref_U_data = video->frame_buffer.frame_p_c_n[video->frame_buffer.prev_index].U_comp_data;
  cur_U_data = video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].U_comp_data;
  ref_V_data = video->frame_buffer.frame_p_c_n[video->frame_buffer.prev_index].V_comp_data;
  cur_V_data = video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].V_comp_data;

  pMacro->row_l = pSlice->mb_row << 4;
  pMacro->col_l = pSlice->mb_col << 4;
  pMacro->row_c = pSlice->mb_row << 3;
  pMacro->col_c = pSlice->mb_col << 3;

  pMacro->offset_l = pMacro->row_l * pitch_Y  + pMacro->col_l;
  pMacro->offset_c = pMacro->row_c * pitch_UV + pMacro->col_c;
  cur_Y_data += pMacro->offset_l;
  cur_U_data += pMacro->offset_c;
  cur_V_data += pMacro->offset_c;

  //
  // Dual prime compensation on Y plane
  //

  // create first vector for block
  nOffset = (pMacro->vector_luma[1] + (pMacro->row_l>>1)) * pitch_Y * 2 +
    pMacro->vector_luma[0] + pMacro->col_l;
  if ((0 > (signed) nOffset) ||
    (pitch_Y * sequenceHeader.mb_height*16 < nOffset))
    return UMC_WRN_NOT_CRITICAL_BAD_FORMAT;
  pbRef = ref_Y_data + nOffset;
  nMCType = ((pMacro->vector[0] & 1) << 3) | ((pMacro->vector[1] & 1) << 2);

  // create second vector for upper halfblock
  nOffset = (pMacro->vector_luma[5] + (pMacro->row_l>>1)) *  pitch_Y * 2 +
    pMacro->vector_luma[4] + pMacro->col_l;
  if ((0 > (signed) nOffset) ||
    (pitch_Y * sequenceHeader.mb_height*16 < nOffset))
    return UMC_WRN_NOT_CRITICAL_BAD_FORMAT;
  pbRef0 = ref_Y_data + nOffset;
  nMCType0 = ((pMacro->vector[4] & 1) << 3) | ((pMacro->vector[5] & 1) << 2);

  // create second vector for lower halfblock
  nOffset = (pMacro->vector_luma[7] + (pMacro->row_l>>1)) * pitch_Y * 2 +
    pMacro->vector_luma[6] + pMacro->col_l;
  if ((0 > (signed) nOffset) ||
    (pitch_Y * sequenceHeader.mb_height*16 < nOffset))
    return UMC_WRN_NOT_CRITICAL_BAD_FORMAT;
  pbRef1 = ref_Y_data + nOffset;
  nMCType1 = ((pMacro->vector[6] & 1) << 3) | ((pMacro->vector[7] & 1) << 2);

  // compensate upper halfblock
  ippiMC16x8B_8u_C1(pbRef, pitch_Y * 2, nMCType,
    pbRef0 + pitch_Y, pitch_Y * 2, nMCType0,
    diff, 64,
    cur_Y_data, pitch_Y * 2,
    0);

  // compensate lower halfblock
  ippiMC16x8B_8u_C1(pbRef + pitch_Y, pitch_Y * 2, nMCType,
    pbRef1, pitch_Y * 2, nMCType1,
    diff + 16, 64,
    cur_Y_data + pitch_Y, pitch_Y * 2,
    0);

  //
  // Dual prime compensation on U & V plane
  //
  {
    vm_byte *pbRefV;
    vm_byte *pbRefV0;
    vm_byte *pbRefV1;

    // create first vector for block
    nOffset = (pMacro->vector_chroma[1] + (pMacro->row_c>>1)) * pitch_UV * 2 +
      pMacro->vector_chroma[0] + pMacro->col_c;
    if (0 > (signed) nOffset)
      return UMC_WRN_NOT_CRITICAL_BAD_FORMAT;
    pbRef = ref_U_data + nOffset;
    pbRefV = ref_V_data + nOffset;
    nMCType = ((pMacro->vector[0] / 2 & 1) << 3) |
      ((pMacro->vector[1] / 2 & 1) << 2);

    // create second vector for upper halfblock
    nOffset = (pMacro->vector_chroma[5] + (pMacro->row_c>>1)) * pitch_UV * 2 +
      pMacro->vector_chroma[4] + pMacro->col_c;
    if (0 > (signed) nOffset)
      return UMC_WRN_NOT_CRITICAL_BAD_FORMAT;
    pbRef0 = ref_U_data + nOffset;
    pbRefV0 = ref_V_data + nOffset;
    nMCType0 = ((pMacro->vector[4] / 2 & 1) << 3) |
      ((pMacro->vector[5] / 2 & 1) << 2);

    // create second vector for upper halfblock
    nOffset = (pMacro->vector_chroma[7] + (pMacro->row_c>>1)) * pitch_UV * 2 +
      pMacro->vector_chroma[6] + pMacro->col_c;
    if (0 > (signed) nOffset)
      return UMC_WRN_NOT_CRITICAL_BAD_FORMAT;
    pbRef1 = ref_U_data + nOffset;
    pbRefV1 = ref_V_data + nOffset;
    nMCType1 = ((pMacro->vector[6] / 2 & 1) << 3) |
      ((pMacro->vector[7] / 2 & 1) << 2);

    // compensate upper halfblock(s)
    ippiMC8x4B_8u_C1(pbRef, pitch_UV * 2, nMCType,
      pbRef0 + pitch_UV, pitch_UV * 2, nMCType0,
      diff + 256, 32,
      cur_U_data, pitch_UV * 2,
      0);

    ippiMC8x4B_8u_C1(pbRefV, pitch_UV * 2, nMCType,
      pbRefV0 + pitch_UV, pitch_UV * 2, nMCType0,
      diff + 320, 32,
      cur_V_data, pitch_UV * 2,
      0);

    // compensate lower halfblock(s)
    ippiMC8x4B_8u_C1(pbRef + pitch_UV, pitch_UV * 2, nMCType,
      pbRef1, pitch_UV * 2, nMCType1,
      diff + 256 + 8, 32,
      cur_U_data + pitch_UV, pitch_UV * 2,
      0);

    ippiMC8x4B_8u_C1(pbRefV + pitch_UV, pitch_UV * 2, nMCType,
      pbRefV1, pitch_UV * 2, nMCType1,
      diff + 320 + 8, 32,
      cur_V_data + pitch_UV, pitch_UV * 2,
      0);
  }

  return UMC_OK;
}

void MPEG2VideoDecoderBase::skipped_macroblockP_frame(int threadID)
{
  IppVideoContext* video = &Video[threadID];
  sSlice                   *pSlice = &Video[threadID].slice;
  sMacroblock              *pMacro = &Video[threadID].macroblock;
  int  y_plain_index;
  int  u_plain_index;

  int  ind = video->frame_buffer.prev_index;

  unsigned int pitch_y, pitch_uv;
  IppiSize roiy, roiuv;

  pMacro->row_l  = pSlice->mb_row_prev << 4;
  pMacro->col_l  = pSlice->mb_col_prev << 4;
  roiy.height = 16;
  roiy.width  = 16*pSlice->mb_address_increment-16;


  roiuv.height = 8;
  pMacro->row_c  = pSlice->mb_row_prev << 3;
  pMacro->col_c  = pSlice->mb_col_prev << 3;
  roiuv.width  = 8*pSlice->mb_address_increment-8;

  pitch_y   = video->frame_buffer.Y_comp_pitch;
  pitch_uv  = video->frame_buffer.U_comp_pitch;

  y_plain_index = pMacro->row_l * pitch_y + pMacro->col_l;
  u_plain_index = pMacro->row_c * pitch_uv + pMacro->col_c;

  ippiCopy_8u_C1R(&video->frame_buffer.frame_p_c_n[ind].Y_comp_data[y_plain_index],
    pitch_y,
    &video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].Y_comp_data[y_plain_index],
    pitch_y,
    roiy);
  ippiCopy_8u_C1R(&video->frame_buffer.frame_p_c_n[ind].U_comp_data[u_plain_index],
    pitch_uv,
    &video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].U_comp_data[u_plain_index],
    pitch_uv,
    roiuv);

  ippiCopy_8u_C1R(&video->frame_buffer.frame_p_c_n[ind].V_comp_data[u_plain_index],
    pitch_uv,
    &video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].V_comp_data[u_plain_index],
    pitch_uv,
      roiuv);
}

void MPEG2VideoDecoderBase::skipped_macroblockB_frame(/*int start, int end,*/ int threadID)
{
  IppVideoContext  *video  = &Video[threadID];
  sMacroblock      *pMacro = &Video[threadID].macroblock;
  sSlice           *pSlice = &Video[threadID].slice;
  int i;
  pMacro->shift_y[0] = pMacro->shift_y[1] = 0;
  pMacro->shift_uv[0]= pMacro->shift_uv[1]= 0;


  pSlice->macroblock_motion_forward_prev  =  pMacro->macroblock_motion_forward;
  pSlice->macroblock_motion_backward_prev =  pMacro->macroblock_motion_backward;
  COPY_PMV(pMacro->vector, pMacro->PMV)

  pMacro->prediction_type = IPPVC_MC_FRAME;

  pMacro->row_l  = pSlice->mb_row_prev << 4;
  pMacro->col_l  = pSlice->mb_col_prev << 4;
  switch(sequenceHeader.chroma_format)
  {
  case CHROMA_420:
    for(i = 0; i < pSlice->mb_address_increment-1; i++)
    {
      pMacro->row_c  = pMacro->row_l >> 1;
      pMacro->col_c = pMacro->col_l >> 1;

      pMacro->offset_l = pMacro->row_l * video->frame_buffer.Y_comp_pitch + pMacro->col_l;
      pMacro->offset_c = pMacro->row_c * video->frame_buffer.U_comp_pitch + pMacro->col_c;
      int curr_index = video->frame_buffer.curr_index;
      Ipp8u *cur_Y_data = video->frame_buffer.frame_p_c_n[curr_index].Y_comp_data;
      Ipp8u *cur_U_data = video->frame_buffer.frame_p_c_n[curr_index].U_comp_data;
      Ipp8u *cur_V_data = video->frame_buffer.frame_p_c_n[curr_index].V_comp_data;
      pMacro->blkCurrYUV[0] = cur_Y_data + pMacro->offset_l;
      pMacro->blkCurrYUV[1] = cur_U_data + pMacro->offset_c;
      pMacro->blkCurrYUV[2] = cur_V_data + pMacro->offset_c;

      if (pMacro->macroblock_motion_forward && pMacro->macroblock_motion_backward) {
        mc_mp2_420b_frame(zero_memory, threadID);
      } else {
        mc_mp2_420_frame_zero(threadID);
      }

      pMacro->col_l += 16;
      if(pMacro->col_l >= sequenceHeader.mb_width*16) {
        pMacro->col_l = 0;
        pMacro->row_l += 16;
      }
    }
    break;
  case CHROMA_422:
    //memset(video->block.idct,0, 64*8*sizeof(short));
    pMacro->row_c  = pMacro->row_l;
    pMacro->col_c  = pMacro->col_l >> 1;
    pMacro->offset_l = pMacro->row_l * video->frame_buffer.Y_comp_pitch + pMacro->col_l;
    pMacro->offset_c = pMacro->row_c * video->frame_buffer.U_comp_pitch + pMacro->col_c;
    mc_mp2_422(zero_memory, threadID);
    break;
  case CHROMA_444:
    //memset(video->block.idct,0, 64*12*sizeof(short));
    pMacro->row_c  = pMacro->row_l;
    pMacro->col_c  = pMacro->col_l;
    pMacro->offset_l = pMacro->row_l * video->frame_buffer.Y_comp_pitch + pMacro->col_l;
    pMacro->offset_c = pMacro->row_c * video->frame_buffer.U_comp_pitch + pMacro->col_c;
    mc_mp2_444(zero_memory, threadID);
    break;
  default:
    break;
  }
}