umc_mpeg2_dec_mb.cpp

audio-video-codecs.rar语音编解码器

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

    if (video->macroblock_motion_forward) {
      if (video->prediction_type == IPPVC_MC_DP) {
        mc_dualprime_frame_420(video);
      } else {
        mc_frame_forward_420(video);
        if (video->macroblock_motion_backward) {
          mc_frame_backward_add_420(video);
        }
      }
    } else {
      if (video->macroblock_motion_backward) {
        mc_frame_backward_420(video);
      } else {
        RESET_PMV(video->PMV)
        mc_frame_forward0_420(video);
      }
    }

    if (macroblock_type & IPPVC_MB_PATTERN) {
      RECONSTRUCT_INTER_MB_420(video->bs, dct_type);
    }
  }

  return UMC_OK;
}//DecodeSlice_FramePB_420

Status MPEG2VideoDecoderBase::DecodeSlice_FieldPB_420(IppVideoContext *video)
{
  Ipp32s macroblock_type;
  Ipp32s macroblock_address_increment;
  Ipp32s pitch_l = frame_buffer.Y_comp_pitch;
  Ipp32s pitch_c = frame_buffer.U_comp_pitch;

  video->prediction_type = IPPVC_MC_FIELD;

  video->dct_dc_past[0] =
  video->dct_dc_past[1] =
  video->dct_dc_past[2] =
    PictureHeader.curr_reset_dc;

  video->mb_row = video->slice_vertical_position - 1;
  video->mb_col = -1;

  video->row_l  = video->mb_row << 4;
  video->col_l  = video->mb_col << 4;

  video->row_c  = video->mb_row << ROW_CHROMA_SHIFT_420;
  video->col_c  = video->mb_col << 3;

  video->offset_l = 2 * video->row_l * pitch_l + video->col_l;
  video->offset_c = 2 * video->row_c * pitch_c + video->col_c;

  //odd_pitch = pitch for bottom field (odd strings)
  if(PictureHeader.picture_structure == BOTTOM_FIELD)
  {
    video->offset_l += pitch_l;
    video->offset_c += pitch_c;
  }

  for (;;) {
    if (GET_REMAINED_BYTES(video->bs) <= 0) {
      return UMC_ERR_INVALID_STREAM;
    }

    video->mb_col++;
    video->offset_l += 16;
    video->offset_c += 8;
    video->col_l += 16;
    video->col_c += 8;

    if (IS_NEXTBIT1(video->bs)) { // increment=1
      SKIP_BITS(video->bs, 1)
    } else {
      DECODE_MB_INCREMENT(video->bs, macroblock_address_increment);

      video->dct_dc_past[0] =
      video->dct_dc_past[1] =
      video->dct_dc_past[2] = PictureHeader.curr_reset_dc;

      // skipped macroblocks
      if (video->mb_col > 0)
      {
        Ipp32s pitch_l = frame_buffer.Y_comp_pitch * 2;
        Ipp32s pitch_c = frame_buffer.U_comp_pitch * 2;
        Ipp32s offset_l = video->offset_l;
        Ipp32s offset_c = video->offset_c;
        Ipp32s id_his_old, id_his_new;
        Ipp32s prev_index = frame_buffer.prev_index;

        if (PictureHeader.picture_coding_type == P_FRAME) {
          RESET_PMV(video->PMV)
          id_his_old = id_his_new = 1;
        } else {
          id_his_new = 0;
          video->prediction_type = IPPVC_MC_FIELD;
          COPY_PMV(video->vector, video->PMV);
          if (!video->macroblock_motion_backward) {
            if (!video->PMV[0] && !video->PMV[1]) {
              id_his_new = 4;
            }
          } else if (!video->macroblock_motion_forward) {
            if (!video->PMV[2] && !video->PMV[3]) {
              id_his_new = 5;
              prev_index = frame_buffer.next_index;
            }
          }
          id_his_old = id_his_new;
          if (sequenceHeader.b_curr_number == 1) id_his_old = -1; // first B frame
        }

        if (id_his_new) {
          Ipp32s curr_index = frame_buffer.curr_index;
          Ipp8u *ref_Y_data = frame_buffer.frame_p_c_n[prev_index].Y_comp_data;
          Ipp8u *ref_U_data = frame_buffer.frame_p_c_n[prev_index].U_comp_data;
          Ipp8u *ref_V_data = frame_buffer.frame_p_c_n[prev_index].V_comp_data;
          Ipp8u *cur_Y_data = frame_buffer.frame_p_c_n[curr_index].Y_comp_data;
          Ipp8u *cur_U_data = frame_buffer.frame_p_c_n[curr_index].U_comp_data;
          Ipp8u *cur_V_data = frame_buffer.frame_p_c_n[curr_index].V_comp_data;
#ifdef KEEP_HISTORY
          Ipp8u *ref_history = frame_buffer.frame_p_c_n[frame_buffer.ind_his_ref].frame_history;
          Ipp8u *curr_history = frame_buffer.frame_p_c_n[frame_buffer.ind_his_curr].frame_history;
          Ipp32s offset_his = video->mb_row*sequenceHeader.mb_width + video->mb_col;
          Ipp32s i;
          if (PictureHeader.picture_structure == BOTTOM_FIELD) {
            offset_his += (sequenceHeader.numMB >> 1);
          }
          for (i = 0; i < macroblock_address_increment; i++) {
            if (ref_history[offset_his] != id_his_old)
            {
              ippiCopy16x16_8u_C1R(ref_Y_data + offset_l, pitch_l, cur_Y_data + offset_l, pitch_l);
              COPY_CHROMA_MB_420(ref_U_data + offset_c, pitch_c, cur_U_data + offset_c, pitch_c);
              COPY_CHROMA_MB_420(ref_V_data + offset_c, pitch_c, cur_V_data + offset_c, pitch_c);
            }
            curr_history[offset_his] = id_his_new;
            offset_l += 16;
            offset_c += 8;
            offset_his++;
          }
#else
          IppiSize roi = {16*macroblock_address_increment, 16};
          ippiCopy_8u_C1R(ref_Y_data + offset_l, pitch_l, cur_Y_data + offset_l, pitch_l, roi);
          roi.height = 1 << ROW_CHROMA_SHIFT_420;
          roi.width >>= 1;
          ippiCopy_8u_C1R(ref_U_data + offset_c, pitch_c, cur_U_data + offset_c, pitch_c, roi);
          ippiCopy_8u_C1R(ref_V_data + offset_c, pitch_c, cur_V_data + offset_c, pitch_c, roi);
#endif
        } else {
          video->mb_address_increment = macroblock_address_increment + 1;
          if (video->macroblock_motion_forward && video->macroblock_motion_backward) {
            mc_mp2_420b_skip(video);
          } else {
            mc_mp2_420_skip(video);
          }
        }
      } // skipped macroblocks
      video->mb_col += macroblock_address_increment;
      video->col_l = video->mb_col << 4;
      video->col_c = video->mb_col << 3;
      video->offset_l += macroblock_address_increment << 4;
      video->offset_c += macroblock_address_increment << 3;
    }
    if (video->mb_col >= sequenceHeader.mb_width) {
      return UMC_ERR_INVALID_STREAM;
    }

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

    video->macroblock_motion_forward = macroblock_type & IPPVC_MB_FORWARD;
    video->macroblock_motion_backward= macroblock_type & IPPVC_MB_BACKWARD;

    if(macroblock_type & IPPVC_MB_INTRA)
    {
      if(macroblock_type & IPPVC_MB_QUANT)
      {
        DECODE_QUANTIZER_SCALE(video->bs, video->cur_q_scale);
      }

      if(!PictureHeader.concealment_motion_vectors)
      {
        RESET_PMV(video->PMV)
      }
      else
      {
        Ipp32s field_sel;
        Ipp32s code;

        video->prediction_type = IPPVC_MC_FIELD;
        GET_1BIT(video->bs, field_sel);

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

        GET_1BIT(video->bs, code);
      }

      RECONSTRUCT_INTRA_MB_420(video->bs, 2);
      continue;
    }//intra

    video->dct_dc_past[0] =
    video->dct_dc_past[1] =
    video->dct_dc_past[2] = PictureHeader.curr_reset_dc;

    if (video->macroblock_motion_forward || video->macroblock_motion_backward) {
      GET_TO9BITS(video->bs, 2, video->prediction_type);
    }

    if(macroblock_type & IPPVC_MB_QUANT) {
      DECODE_QUANTIZER_SCALE(video->bs, video->cur_q_scale);
    }

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

    if (video->macroblock_motion_forward) {
      if (video->prediction_type == IPPVC_MC_DP) {
        mc_dualprime_field_420(video);
      } else {
        mc_field_forward_420(video);
        if (video->macroblock_motion_backward) {
          mc_field_backward_add_420(video);
        }
      }
    } else {
      if (video->macroblock_motion_backward) {
        mc_field_backward_420(video);
      } else {
        RESET_PMV(video->PMV)
        mc_field_forward0_420(video);
      }
    }

    if (macroblock_type & IPPVC_MB_PATTERN) {
      RECONSTRUCT_INTER_MB_420(video->bs, 2);
    }
  }

  return UMC_OK;
}//DecodeSlice_FieldPB_420

#endif // UMC_ENABLE_MPEG2_VIDEO_DECODER