umc_mpeg1_dec.cpp

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

                             width2,
                             flag2c,
                             0);

          ippiMC8x8_8u_C1( video->frame_buffer.frame_p_c_n[video->frame_buffer.next_index].V_comp_data + offset_c + off_bc,
                             width2,
                             zero_memory,
                             16,
                             video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].V_comp_data  + offset_c,
                             width2,
                             flag2c,
                             0);

          pMacro->col_l += 16;
          if(pMacro->col_l >= sequenceHeader.mb_width * 16) {
            pMacro->row_l += 16;
            pMacro->row_c += 8;
            if(pMacro->row_l >= sequenceHeader.mb_height * 16)
              return UMC_BAD_STREAM;
            offset_l = pMacro->row_l * width;
            offset_c = pMacro->row_c * width2;
            pMacro->col_l = 0;
          } else {
            offset_l += 16;
            offset_c += 8;
          }
        }
    }

    return UMC_OK;
}

Status MPEG2VideoDecoderBase::BlockIntraLuma_mpeg1(int threadID, Ipp8u* pDst)
{
    IppVideoContext *video = &Video[threadID];
    sSlice          *pSlice = &Video[threadID].slice;
    int             ret;
    int             flag = (PictureHeader.picture_coding_type & D_PICTURE);

    ret = ippiDecodeIntra8x8IDCT_MPEG1_1u8u(&video->bs_curr_ptr,
                                            &video->bs_bit_offset,
                                            decodeIntraSpec,
                                            pSlice->quantizer_scale,
                                            flag,
                                            &(pSlice->dct_dc_y_past),
                                            pDst,
                                            video->frame_buffer.Y_comp_pitch);
    if(ret)
      return UMC_BAD_STREAM;

    return UMC_OK;
}

Status MPEG2VideoDecoderBase::BlockIntraChroma_mpeg1(int threadID, Ipp8u* pDst, short* dc_past)
{
    IppVideoContext *video = &Video[threadID];
    sSlice          *pSlice = &Video[threadID].slice;
    int             ret;
    int             flag = (PictureHeader.picture_coding_type & D_PICTURE);

    ret = ippiDecodeIntra8x8IDCT_MPEG1_1u8u(&video->bs_curr_ptr,
                                            &video->bs_bit_offset,
                                            decodeIntraSpec,
                                            pSlice->quantizer_scale,
                                            1 | flag,
                                            dc_past,
                                            pDst,
                                            video->frame_buffer.U_comp_pitch);
    if(ret)
      return UMC_BAD_STREAM;

    return UMC_OK;
}


Status MPEG2VideoDecoderBase::Macroblock_mpeg1(int threadID)
{
    IppVideoContext *video  = &Video[threadID];
    sMacroblock     *pMacro = &Video[threadID].macroblock;
    sSlice          *pSlice = &Video[threadID].slice;
    int              pitch_l = video->frame_buffer.Y_comp_pitch;
    int              pitch_c = video->frame_buffer.U_comp_pitch;
    int              coded_block_pattern = 0;
    int              end_of_macroblock;
    int              macroblock_type ;
    int              macroblock_quant;
    int              macroblock_pattern;
    int              macroblock_intra;

    pMacro->prediction_type = IPPVC_MC_FRAME;

    if(pSlice->mb_address_increment > 1)
    {
      if (PictureHeader.picture_coding_type == P_PICTURE) {
        pMacro->PMV[0] = 0;
        pMacro->PMV[1] = 0;
        skipped_macroblockP_mpeg1(threadID);
      } else {
        pMacro->macroblock_motion_forward  = pSlice->macroblock_motion_forward_prev;
        pMacro->macroblock_motion_backward = pSlice->macroblock_motion_backward_prev;
        pMacro->vector[0] = pMacro->PMV[0];
        pMacro->vector[1] = pMacro->PMV[1];
        pMacro->vector[2] = pMacro->PMV[2];
        pMacro->vector[3] = pMacro->PMV[3];

        skipped_macroblockB_mpeg1(threadID);

        pMacro->macroblock_motion_forward  = 0;
        pMacro->macroblock_motion_backward = 0;
      }
    }// skipped macroblocks

    if(PictureHeader.picture_coding_type != D_PICTURE)
    {
        DECODE_VLC(macroblock_type, video->bs, vlcMBType[PictureHeader.picture_coding_type - 1]);
        macroblock_quant          = macroblock_type & 0x10;
        pMacro->macroblock_motion_forward = macroblock_type & 0x08;
        pMacro->macroblock_motion_backward= macroblock_type & 0x04;
        macroblock_pattern        = macroblock_type & 0x02;
        macroblock_intra          = macroblock_type & 0x01;
    }
    else//D picture
    {
        GET_1BIT(video->bs,macroblock_type);
        VM_ASSERT(macroblock_type == 1);
        macroblock_intra           = 1;
        macroblock_quant           = 0;
        pMacro->macroblock_motion_forward = 0;
        pMacro->macroblock_motion_backward= 0;
        macroblock_pattern        = 0;
    }//switch(PictureHeader.picture_coding_type)

    if(macroblock_quant)
    {
        GET_TO9BITS(video->bs, 5, pSlice->quantizer_scale);
        VM_ASSERT(pSlice->quantizer_scale >= 1);
    }

    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;

////////////////////Intra/////////////////////
    if(macroblock_intra)
    {
        int offset_l, offset_c;
        offset_l = pMacro->row_l * pitch_l + pMacro->col_l;
        offset_c = pMacro->row_c * pitch_c + pMacro->col_c;

        pMacro->PMV[0] = 0;
        pMacro->PMV[1] = 0;
        pMacro->PMV[2] = 0;
        pMacro->PMV[3] = 0;

        BlockIntraLuma_mpeg1( threadID, video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].Y_comp_data+offset_l);
        BlockIntraLuma_mpeg1( threadID, video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].Y_comp_data+offset_l+8);
        BlockIntraLuma_mpeg1( threadID, video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].Y_comp_data+offset_l + 8 * pitch_l);
        BlockIntraLuma_mpeg1( threadID, video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].Y_comp_data+offset_l + 8 * pitch_l+8);
        BlockIntraChroma_mpeg1( threadID, video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].U_comp_data + offset_c,&(pSlice->dct_dc_cb_past));
        BlockIntraChroma_mpeg1( threadID, video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].V_comp_data + offset_c,&(pSlice->dct_dc_cr_past));

        if(PictureHeader.picture_coding_type == D_PICTURE)
        {
            GET_1BIT(video->bs,end_of_macroblock);
            VM_ASSERT(end_of_macroblock);
            if(!end_of_macroblock)
              return UMC_BAD_STREAM;
        }
    }
    else
    {
        pSlice->dct_dc_y_past  = 1024;
        pSlice->dct_dc_cb_past = 1024;
        pSlice->dct_dc_cr_past = 1024;
        if(PictureHeader.picture_coding_type == B_PICTURE)
        {
          // probaly done
            pSlice->macroblock_motion_forward_prev   = pMacro->macroblock_motion_forward;
            pSlice->macroblock_motion_backward_prev  = pMacro->macroblock_motion_backward;
        }
    ////////////////////////Non Intra////////////////////
        //motion vector calculation
        //forward vector
        if(!pMacro->macroblock_motion_forward)
        {
            if(PictureHeader.picture_coding_type == B_PICTURE)
            {
                pMacro->vector[0] = pMacro->PMV[0];
                pMacro->vector[1] = pMacro->PMV[1];
            }
            else {
                pMacro->vector[0] = pMacro->PMV[0] = 0;
                pMacro->vector[1] = pMacro->PMV[1] = 0;
            }
        }
        else
        {
          if(PictureHeader.full_pel_forward_vector)
            mv_decode_full_pel(0, threadID);
          else
            mv_decode(0, 0, threadID);
        }

        //backward vector
        if(!pMacro->macroblock_motion_backward)
        {
            if(PictureHeader.picture_coding_type == B_PICTURE)
            {
                pMacro->vector[2] = pMacro->PMV[2];
                pMacro->vector[3] = pMacro->PMV[3];
            }
        }
        else
        {
          if(PictureHeader.full_pel_backward_vector)
            mv_decode_full_pel(1, threadID);
          else
            mv_decode(0, 1, threadID);
        }

        pMacro->PMV[0] = pMacro->vector[0];
        pMacro->PMV[1] = pMacro->vector[1];
        pMacro->PMV[2] = pMacro->vector[2];
        pMacro->PMV[3] = pMacro->vector[3];
        pSlice->macroblock_motion_forward_prev = pMacro->macroblock_motion_forward;
        pSlice->macroblock_motion_backward_prev = pMacro->macroblock_motion_backward;

        if(macroblock_pattern)
        {
            DECODE_VLC(coded_block_pattern, video->bs, vlcMBPattern);
        }

        pMacro->offset_l = (pSlice->mb_row*pitch_l + pSlice->mb_col) << 4;
        pMacro->offset_c = (pSlice->mb_row*pitch_c + pSlice->mb_col) << 3;
        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);
        }

        int blk;
        for (blk = 0; blk < 6; blk++) {
          if (coded_block_pattern & 32) {
            int chromaFlag = blk >> 2;
            int cc = chromaFlag + (blk & chromaFlag);

            ippiDecodeInter8x8IDCTAdd_MPEG1_1u8u(
              &video->bs_curr_ptr,
              &video->bs_bit_offset,
              decodeInterSpec,
              pSlice->quantizer_scale,
              pMacro->blkCurrYUV[cc] + blkOffsets[0][blk],
              blkPitches[0][chromaFlag]);
          }
          coded_block_pattern += coded_block_pattern;
        }

    }
    return UMC_OK;
}