umc_mpeg2_dec_mbfld.cpp

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

  } else {
    diff = zero_memory;
  }

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

  //odd_pitch = pitch for bottom field (odd strings)
  if(PictureHeader.picture_structure == BOTTOM_FIELD)
  {
    odd_pitch_y  =  pitch_Y;
    odd_pitch_uv =  pitch_UV;
  }
  pitch_Y *= 2;
  pitch_UV *= 2;

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

  /* case IPPVC_MC_DP: */
  prev_Y = video->frame_buffer.frame_p_c_n[video->frame_buffer.prev_index].Y_comp_data;
  prev_U = video->frame_buffer.frame_p_c_n[video->frame_buffer.prev_index].U_comp_data;
  prev_V = video->frame_buffer.frame_p_c_n[video->frame_buffer.prev_index].V_comp_data;

  if(PictureHeader.field_buffer_index)
  {
    ref_Y_data  = cur_Y_data;
    ref_U_data  = cur_U_data;
    ref_V_data  = cur_V_data;
  }//if(PictureHeader.field_buffer_index)
  else {
    ref_Y_data = prev_Y;
    ref_U_data = prev_U;
    ref_V_data = prev_V;
  }

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

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

  if (BOTTOM_FIELD == PictureHeader.picture_structure)
    select_dmv_field = 0;
  else
    select_dmv_field = pitch_Y >> 1;

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

  // compensate block
  ippiMC16x16B_8u_C1(pbRef, pitch_Y, nMCType,
    pbRef0, pitch_Y, nMCType0,
    diff, 32,
    cur_Y_data + pMacro->offset_l, pitch_Y,
    0);

  //
  // Dual prime compensation on U & V plane
  //
  {
    // create first vector for block(s)
    nOffset = (pvector_chroma[1] + pMacro->row_c) * pitch_UV +
      pvector_chroma[0] + pMacro->col_c + odd_pitch_uv;
    pbRef = prev_U + nOffset;
    pbRefV = prev_V + nOffset;
    nMCType = ((pvector[0] / 2 & 1) << 3) + ((pvector[1] / 2 & 1) << 2);

    if (BOTTOM_FIELD == PictureHeader.picture_structure)
      select_dmv_field_uv = 0;
    else
      select_dmv_field_uv = pitch_UV >> 1;

    // create second vector for block(s)
    nOffset = (pvector_chroma[5] + pMacro->row_c) * pitch_UV +
      pvector_chroma[4] + pMacro->col_c + select_dmv_field_uv;
    pbRef0 = ref_U_data + nOffset;
    pbRefV0 = ref_V_data + nOffset;
    nMCType0 = ((pvector[4] / 2 & 1) << 3) + ((pvector[5] / 2 & 1) << 2);

    // compensate block(s)
    ippiMC8x8B_8u_C1(pbRef, pitch_UV, nMCType,
      pbRef0, pitch_UV, nMCType0,
      diff + 256, 16,
      cur_U_data + pMacro->offset_c, pitch_UV,
      0);

    ippiMC8x8B_8u_C1(pbRefV, pitch_UV, nMCType,
      pbRefV0, pitch_UV, nMCType0,
      diff + 320, 16,
      cur_V_data + pMacro->offset_c, pitch_UV,
      0);
  }

  return umcRes;
}

void MPEG2VideoDecoderBase::skipped_macroblockP_field(/*int num, */int threadID)
{
    IppVideoContext*        video  = &Video[threadID];
    sSlice                 *pSlice = &Video[threadID].slice;
    sMacroblock            *pMacro = &Video[threadID].macroblock;
    int  y_plain_index, ref_y_plain_index;
    int  u_plain_index, ref_u_plain_index;
    int odd_pitch_y = 0, odd_pitch_uv = 0;

    unsigned int pitch_y, pitch_uv, pitch_y_2, pitch_uv_2;
    Ipp8u *ref_Y_data, *ref_U_data, *ref_V_data;
    IppiSize roiy, roiuv;

    if(PictureHeader.picture_structure == BOTTOM_FIELD)
    {
        odd_pitch_y  =  video->frame_buffer.Y_comp_pitch;
        odd_pitch_uv =  video->frame_buffer.U_comp_pitch;
    }

    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;

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

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


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

    pitch_y_2  = pitch_y  << 1;
    pitch_uv_2 = pitch_uv << 1;

    y_plain_index = pMacro->row_l * pitch_y_2  + pMacro->col_l + odd_pitch_y;
    u_plain_index = pMacro->row_c * pitch_uv_2 + pMacro->col_c + odd_pitch_uv;
    ref_y_plain_index = y_plain_index;
    ref_u_plain_index = u_plain_index;

     ippiCopy_8u_C1R(&(ref_Y_data[ref_y_plain_index]),
                    pitch_y_2,
                    &video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].Y_comp_data[y_plain_index],
                    pitch_y_2,
                    roiy);
     ippiCopy_8u_C1R(&(ref_U_data[ref_u_plain_index]),
                    pitch_uv_2,
                    &video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].U_comp_data[u_plain_index],
                    pitch_uv_2,
                    roiuv);
     ippiCopy_8u_C1R(&(ref_V_data[ref_u_plain_index]),
                    pitch_uv_2,
                    &video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].V_comp_data[u_plain_index],
                    pitch_uv_2,
                    roiuv);

}

Status MPEG2VideoDecoderBase::Macroblock_420_B_field(int threadID)
{
    Status  umcRes = UMC_OK;
    int        marker_bit;
    int        r, i;

    int        macroblock_intra;
    int        macroblock_type;
    int        field_motion_type;


    int        pitch_Y, pitch_UV;

    Ipp8u   *ref_Y_data, *ref_U_data, *ref_V_data;
    Ipp8u   *ref_Y_data1, *ref_U_data1, *ref_V_data1;
    Ipp8u   *ref_Y_data2, *ref_U_data2, *ref_V_data2;
    int     flag1, flag2,flag3,flag4;
    int     offs1, offs2, offs1_y, offs2_y;
    int     offs;

    IppVideoContext*        video = &Video[threadID];
    Ipp8u                   *cur_Y_data, *cur_U_data;
    Ipp8u                   *cur_V_data = 0;
    sSlice                  *pSlice = &Video[threadID].slice;
    sMacroblock             *pMacro = &Video[threadID].macroblock;
    int odd_pitch_y  =  0;
    int odd_pitch_uv =  0;
    int shift_uv[2];
    int shift_y[2];

    shift_uv[0]= shift_uv[1]= 0;
    shift_y[0] = shift_y[1] = 0;

    memset(pMacro->motion_vertical_field_select,0,sizeof(pMacro->motion_vertical_field_select));

    odd_pitch_y =  0;
    odd_pitch_uv = 0;

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

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

    //odd_pitch = pitch for bottom field (odd strings)
    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)
    {
        pMacro->macroblock_motion_forward  =  pSlice->macroblock_motion_forward_prev;
        pMacro->macroblock_motion_backward =  pSlice->macroblock_motion_backward_prev;

        skipped_macroblockB_field(threadID);

        pMacro->macroblock_motion_forward    = 0;
        pMacro->macroblock_motion_backward    = 0;

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

        umcRes =  ReconstuctIntraFieldMB(threadID);

    }//if(macroblock_intra)
    else
    {
        pSlice->dct_dc_y_past  =
        pSlice->dct_dc_cb_past =
        pSlice->dct_dc_cr_past = PictureHeader.curr_reset_dc;

        GET_TO9BITS(video->bs, 2, field_motion_type);

        pMacro->motion_vector_count     = 1;
        pMacro->prediction_type         = IPPVC_MC_FIELD;

        if(field_motion_type == 2)
        {
            pMacro->prediction_type     = IPPVC_MC_16X8;
            pMacro->motion_vector_count = 2;
            shift_y[1]                  = (pitch_Y>>1)<<4;
            shift_uv[1]                 = (pitch_UV>>1)<<3;
        }

        if(macroblock_type & 0x10)