umc_mpeg2_dec_mbfld.cpp

这是在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) 2003-2005 Intel Corporation. All Rights Reserved.
//
*/
#include "umc_mpeg2_dec_base.h"

using namespace UMC;

static short zero_memory[64*6] = {0};

Status MPEG2VideoDecoderBase::ReconstuctIntraFieldMB(int threadID)
{
  return ReconstructIntraMB(threadID, 6, 2);
}

Status MPEG2VideoDecoderBase::Macroblock_420_I_field(int threadID)
{
    int            macroblock_type;
    int            pitch_Y, pitch_UV;
    int            marker_bit;
    IppVideoContext*        video = &Video[threadID];

    // used when U & V not merged
    sSlice                  *pSlice = &Video[threadID].slice;
    sMacroblock             *pMacro = &Video[threadID].macroblock;
    int odd_pitch_y  =  0;
    int odd_pitch_uv =  0;

    pitch_Y   =  video->frame_buffer.Y_comp_pitch;
    pitch_UV  =  video->frame_buffer.U_comp_pitch;

    if(PictureHeader.picture_structure == BOTTOM_FIELD)
    {
        odd_pitch_y  =  pitch_Y;
        odd_pitch_uv =  pitch_UV;
    }
    pitch_Y   <<=  1;
    pitch_UV  <<=  1;

    pMacro->offset_l = ((pSlice->mb_row * pitch_Y  + pSlice->mb_col) << 4) + odd_pitch_y;
    pMacro->offset_c = ((pSlice->mb_row * pitch_UV + pSlice->mb_col) << 3) + odd_pitch_uv;

    DECODE_VLC(macroblock_type, video->bs, vlcMBType[PictureHeader.picture_coding_type - 1]);

    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];
    }

    if(PictureHeader.concealment_motion_vectors)
    {
        pMacro->prediction_type     = IPPVC_MC_FIELD;
        pMacro->motion_vector_count = 1;
        GET_1BIT(video->bs,pMacro->motion_vertical_field_select[0]);

        mv_decode(0, 0, threadID);
        pMacro->PMV[4] = pMacro->PMV[0];
        pMacro->PMV[5] = pMacro->PMV[1];

        GET_1BIT(video->bs,marker_bit);
        VM_ASSERT(marker_bit);
        pSlice->macroblock_motion_forward_prev  = 1;
        pSlice->macroblock_motion_backward_prev = 0;
    }


    return ReconstuctIntraFieldMB(threadID);

}//Macroblock_420_I_field


Status MPEG2VideoDecoderBase::Macroblock_420_P_field(int threadID)
{
  Status umcRes = UMC_OK;
  int        marker_bit;
  int        macroblock_intra;
  int        macroblock_type;
  int        field_motion_type;
  int        pitch_Y, pitch_UV;
  IppVideoContext*        video = &Video[threadID];
  sSlice                  *pSlice = &Video[threadID].slice;
  sMacroblock             *pMacro = &Video[threadID].macroblock;
  int odd_pitch_y  =  0;
  int odd_pitch_uv =  0;

  memset(pMacro->motion_vertical_field_select,0,sizeof(pMacro->motion_vertical_field_select)); // whats need?

  pitch_Y   =  video->frame_buffer.Y_comp_pitch;
  pitch_UV  =  video->frame_buffer.U_comp_pitch;

  if(PictureHeader.picture_structure == BOTTOM_FIELD)
  {
    odd_pitch_y  =  pitch_Y;
    odd_pitch_uv =  pitch_UV;
  }

  pitch_Y   <<=  1;
  pitch_UV  <<=  1;

  // skipped macroblocks
  if(pSlice->mb_address_increment > 1)
  {
    RESET_PMV(pMacro->PMV)

    skipped_macroblockP_field(threadID);
  }// skipped macroblocks

  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 + odd_pitch_y;
  pMacro->offset_c = pMacro->row_c * pitch_UV + pMacro->col_c + odd_pitch_uv;

  DECODE_VLC(macroblock_type, video->bs, vlcMBType[PictureHeader.picture_coding_type - 1]);

  pMacro->macroblock_motion_forward = macroblock_type & 0x08;
  pMacro->macroblock_motion_backward= macroblock_type & 0x04;
  macroblock_intra          = macroblock_type & 0x01;

  if(macroblock_intra)
  {
    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];
    }

    if(!PictureHeader.concealment_motion_vectors)
    {
      RESET_PMV(pMacro->PMV)
    }
    else
    {
      pMacro->prediction_type     = IPPVC_MC_FIELD;
      pMacro->motion_vector_count = 1;
      GET_1BIT(video->bs,pMacro->motion_vertical_field_select[0]);

      mv_decode(0, 0, threadID);
      pMacro->PMV[4] = pMacro->PMV[0];
      pMacro->PMV[5] = pMacro->PMV[1];

      GET_1BIT(video->bs,marker_bit);
      VM_ASSERT(marker_bit);
      pSlice->macroblock_motion_forward_prev  = 1;
      pSlice->macroblock_motion_backward_prev = 0;
    }

    return ReconstuctIntraFieldMB(threadID);

  }//if(macroblock_intra)

  pSlice->dct_dc_y_past  =
    pSlice->dct_dc_cb_past =
    pSlice->dct_dc_cr_past =
    PictureHeader.curr_reset_dc;

  field_motion_type = 0;
  if(pMacro->macroblock_motion_forward)
  {
    GET_TO9BITS(video->bs, 2, field_motion_type);
    assert(field_motion_type != 0);
  }
  else
  {
    pMacro->PMV[0] = 0; pMacro->PMV[1] = 0;
    pMacro->PMV[4] = 0; pMacro->PMV[5] = 0;

    pMacro->vector[0] = 0;
    pMacro->vector[1] = 0;
    pMacro->vector[4] = 0;
    pMacro->vector[5] = 0;
    pMacro->vector_luma[0] = 0;
    pMacro->vector_luma[1] = 0;
    pMacro->vector_luma[4] = 0;
    pMacro->vector_luma[5] = 0;
    pMacro->vector_chroma[0] = 0;
    pMacro->vector_chroma[1] = 0;
    pMacro->vector_chroma[4] = 0;
    pMacro->vector_chroma[5] = 0;
    pMacro->prediction_type = IPPVC_MC_FIELD;
    pMacro->motion_vertical_field_select[0] =
      pMacro->motion_vertical_field_select[2] = (PictureHeader.picture_structure == BOTTOM_FIELD);
    pMacro->motion_vector_count = 1;
  }

  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];
  }

  if(pMacro->macroblock_motion_forward)
  {
    pMacro->prediction_type     = IPPVC_MC_FIELD;
    pMacro->motion_vector_count = 1;
    if(field_motion_type == 2)
    {
      pMacro->prediction_type     = IPPVC_MC_16X8;
      pMacro->motion_vector_count = 2;
    }
    else if(field_motion_type == 3)
    {
      pMacro->prediction_type     = IPPVC_MC_DP;
      pMacro->motion_vector_count = 1;
    }

    if(pMacro->prediction_type == IPPVC_MC_FIELD)
    {
      GET_1BIT(video->bs,
        pMacro->motion_vertical_field_select[0]);
      mv_decode(0,0, threadID);
      pMacro->PMV[4] = pMacro->PMV[0];
      pMacro->PMV[5] = pMacro->PMV[1];
      pMacro->motion_vertical_field_select[2] = 0;
    }
    else if(pMacro->prediction_type  == IPPVC_MC_DP)
    {
      return Macroblock_420_DP_field(threadID, macroblock_type);
    }
    else
    {
      GET_1BIT(video->bs,
        pMacro->motion_vertical_field_select[0]);

      mv_decode(0,0, threadID);

      GET_1BIT(video->bs,
        pMacro->motion_vertical_field_select[2]);

      mv_decode(1,0, 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, 0);
    if (UMC_OK != umcRes) return umcRes;
  } else {
    memset(video->block.idct,0,64*6*sizeof(short)); // ???
    diff = zero_memory;
  }

  mc_mp2_420_field(diff, threadID);

  return UMC_OK;
}//Macroblock_420_P_field

Status MPEG2VideoDecoderBase::Macroblock_420_DP_field(int threadID,
                                                      int macroblock_type)
{
  IppVideoContext   *video = &Video[threadID];
  const sMacroblock *pMacro = &Video[threadID].macroblock;
  sSlice            *pSlice = &Video[threadID].slice;
  short             *diff = video->block.idct;
  const short *pvector = pMacro->vector;
  const short *pvector_chroma = pMacro->vector_chroma;
  const short *pvector_luma = pMacro->vector_luma;
  const Ipp8u *ref_Y_data, *ref_U_data, *ref_V_data;
  Ipp8u       *cur_Y_data, *cur_U_data, *cur_V_data;
  const Ipp8u *prev_Y;
  const Ipp8u *prev_U;
  const Ipp8u *prev_V;
  const Ipp8u *pbRef;
  const Ipp8u *pbRef0;
  const Ipp8u *pbRefV;
  const Ipp8u *pbRefV0;
  int          pitch_Y, pitch_UV;
  int          nMCType;
  int          nMCType0;
  int          nOffset;
  int          select_dmv_field;
  int          select_dmv_field_uv;
  int          odd_pitch_y  =  0;
  int          odd_pitch_uv =  0;
  Status       umcRes = UMC_OK;

  mv_decode_dp(threadID);

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

  if (macroblock_type & IPPVC_MB_PATTERN) {
    umcRes = ReconstuctInterMB(threadID, 0);
    if (UMC_OK != umcRes) return umcRes;