umc_mpeg2_dec_mb422.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"

#pragma warning(disable: 4244)

using namespace UMC;

Status MPEG2VideoDecoderBase::BlockInterLuma(int coded_block_pattern, int offset, int pitch, int threadID)
{
    IppVideoContext *video = &Video[threadID];
    sSlice          *pSlice = &Video[threadID].slice;
    int             i, ret;

    if(coded_block_pattern)
    {
        memset(video->block.dq, 0, 64*sizeof(Ipp16s));
        ret = _mp2_ReconstructDCTBlock_MPEG2_32s(&video->bs_curr_ptr,
                                                &video->bs_bit_offset,
                                                decodeInterSpec->scanMatrix,
                                                pSlice->cur_q_scale,
                                                decodeInterSpec->quantMatrix,
                                                video->block.dq,
                                                &i);
        if(ret)
            return UMC_BAD_STREAM;

        ippiDCT8x8Inv_16s_C1R( video->block.dq, video->block.idct+offset, pitch);

    }
    else
    {
        Ipp16s* pDst = video->block.idct+offset;
        int dStep = pitch>>1;
        memset(pDst,0,16);
        memset(pDst+dStep,0,16);
        memset(pDst+2*dStep,0,16);
        memset(pDst+3*dStep,0,16);
        memset(pDst+4*dStep,0,16);
        memset(pDst+5*dStep,0,16);
        memset(pDst+6*dStep,0,16);
        memset(pDst+7*dStep,0,16);
    }

    return UMC_OK;

}

Status MPEG2VideoDecoderBase::BlockInterChroma(int coded_block_pattern, int offset, int pitch, int threadID)
{
    IppVideoContext* video = &Video[threadID];
    sSlice           *pSlice = &Video[threadID].slice;
    int             i, ret;

    if(coded_block_pattern)
    {
        memset(video->block.dq, 0, 64*sizeof(Ipp16s));
        ret = _mp2_ReconstructDCTBlock_MPEG2_32s(&video->bs_curr_ptr,
                                                &video->bs_bit_offset,
                                                decodeInterSpec->scanMatrix,
                                                pSlice->cur_q_scale,
                                                decodeInterSpec->quantMatrix,
                                                video->block.dq,
                                                &i);
        if(ret)
            return UMC_BAD_STREAM;

        ippiDCT8x8Inv_16s_C1R( video->block.dq, video->block.idct + offset, pitch);

    }
    else
    {
        Ipp16s* pDst = video->block.idct+offset;
        int dStep = pitch>>1;
        memset(pDst,0,16);
        memset(pDst+dStep,0,16);
        memset(pDst+2*dStep,0,16);
        memset(pDst+3*dStep,0,16);
        memset(pDst+4*dStep,0,16);
        memset(pDst+5*dStep,0,16);
        memset(pDst+6*dStep,0,16);
        memset(pDst+7*dStep,0,16);
    }

    return UMC_OK;

}

Status MPEG2VideoDecoderBase::Macroblock_422(int threadID)
{

    sSlice                   *pSlice = &Video[threadID].slice;
    sMacroblock               *pMacro = &Video[threadID].macroblock;
    IppVideoContext* video = &Video[threadID];
    int        marker_bit;

    int        macroblock_type;
    int        macroblock_pattern = 0;
    int        macroblock_intra;
    int        frame_motion_type;
    int        field_motion_type;

    int        coded_block_pattern   = 0;
    int        coded_block_pattern_1 = 0;

    int        pitch_Y, pitch_UV;
    unsigned int        dct_type = 0;

    pMacro->shift_y[0] = pMacro->shift_y[1] = 0;
    pMacro->shift_uv[0]= pMacro->shift_uv[1]= 0;
    pMacro->odd_pitch_y =  0;
    pMacro->odd_pitch_uv = 0;

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

    if(PictureHeader.picture_structure != IPPVC_FRAME_PICTURE)
    {
        //odd_pitch = pitch for bottom field (odd strings)
        if(PictureHeader.picture_structure == BOTTOM_FIELD)
        {
            pMacro->odd_pitch_y =  video->frame_buffer.Y_comp_pitch;
            pMacro->odd_pitch_uv =  video->frame_buffer.U_comp_pitch;

        }
        pitch_Y   =  video->frame_buffer.Y_comp_pitch  * 2;
        pitch_UV  =  video->frame_buffer.U_comp_pitch * 2;
    }
    else
    {
        pitch_Y   =  video->frame_buffer.Y_comp_pitch;
        pitch_UV  =  video->frame_buffer.U_comp_pitch;
    }

    // skipped macroblocks
    if(pSlice->mb_address_increment > 1)
    {
        if(PictureHeader.picture_coding_type == P_FRAME)
        {
            pMacro->PMV[0] = 0; pMacro->PMV[1] = 0;
            pMacro->PMV[2] = 0; pMacro->PMV[3] = 0;
            pMacro->PMV[4] = 0; pMacro->PMV[5] = 0;
            pMacro->PMV[6] = 0; pMacro->PMV[7] = 0;
        }
        else
        {
            VM_ASSERT(PictureHeader.picture_coding_type == B_FRAME);
            pMacro->macroblock_motion_forward  =  pSlice->macroblock_motion_forward_prev;
            pMacro->macroblock_motion_backward =  pSlice->macroblock_motion_backward_prev;

            memset(pMacro,0,sizeof(sMacroblock));
        }
    }// skipped macroblocks
    memset(video->block.idct,0,64*8*sizeof(short));

    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;

    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_pattern        = macroblock_type & 0x02;
    macroblock_intra          = macroblock_type & 0x01;

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

    field_motion_type = 0;
    frame_motion_type = 0;
    if(pMacro->macroblock_motion_forward || pMacro->macroblock_motion_backward)
    {
        if(PictureHeader.picture_structure == IPPVC_FRAME_PICTURE)
        {
            if(!PictureHeader.frame_pred_frame_dct)
                GET_TO9BITS(video->bs, 2, frame_motion_type);
        }
        else
        {
            GET_TO9BITS(video->bs, 2, field_motion_type);
        }
    }
    if(PictureHeader.picture_structure == IPPVC_FRAME_PICTURE)
    {//1
        if(!PictureHeader.frame_pred_frame_dct)
        {//2
            switch(frame_motion_type)
            {//3
            case 1:
                pMacro->prediction_type     = IPPVC_MC_FIELD;
                pMacro->motion_vector_count = 2;
                pMacro->shift_y[1]                     = pMacro->offset_field_y[1];
                pMacro->shift_uv[1]                    = pMacro->offset_field_uv[1];
                break;
            case 2:
                pMacro->prediction_type     = IPPVC_MC_FRAME;
                pMacro->motion_vector_count = 1;
                break;
            default:
                pMacro->prediction_type         = IPPVC_MC_FRAME;
                pMacro->motion_vector_count     = 1;
                break;
            }//-3
            if(macroblock_intra || macroblock_pattern)
                GET_1BIT(video->bs,dct_type);
        }//-2
        else
        {//4
            pMacro->prediction_type         = IPPVC_MC_FRAME;
            pMacro->motion_vector_count     = 1;
        }//-4
    }//-1
    else
    {
        switch(field_motion_type)
        {
        case 1:
            pMacro->prediction_type     = IPPVC_MC_FIELD;
            pMacro->motion_vector_count = 1;
            break;
        case 2:
            pMacro->prediction_type     = IPPVC_MC_16X8;
            pMacro->motion_vector_count = 2;

            pMacro->shift_y[1]                 = pMacro->offset_field_y[1]  << 4;
            pMacro->shift_uv[1]                = pMacro->offset_field_uv[1] << 4;
            break;
        default:
            pMacro->prediction_type     = IPPVC_MC_FIELD;
            pMacro->motion_vector_count = 1;
            break;
        }
    }//PictureHeader.picture_structure == FIELD_PICTURE

    if(macroblock_intra)
    {
        if(!PictureHeader.concealment_motion_vectors)
        {
            pMacro->PMV[0] = 0; pMacro->PMV[1] = 0;
            pMacro->PMV[2] = 0; pMacro->PMV[3] = 0;
            pMacro->PMV[4] = 0; pMacro->PMV[5] = 0;
            pMacro->PMV[6] = 0; pMacro->PMV[7] = 0;
        }
        else
        {
            if(PictureHeader.picture_structure == IPPVC_FRAME_PICTURE)
            {
                pMacro->prediction_type     = IPPVC_MC_FRAME;
                pMacro->motion_vector_count = 1;
            }
            else
            {
                pMacro->prediction_type     = IPPVC_MC_FIELD;
                pMacro->motion_vector_count = 1;
            }
        }
    } else {
        pSlice->dct_dc_y_past  =
        pSlice->dct_dc_cb_past =
        pSlice->dct_dc_cr_past = PictureHeader.curr_reset_dc;
    }

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

    if(macroblock_type & 0x10)
    {
        GET_TO9BITS(video->bs, 5, pSlice->quantizer_scale);
        VM_ASSERT(pSlice->quantizer_scale >= 1 /*&& pSlice->quantizer_scale <= 31*/);
    }

    if(pMacro->macroblock_motion_forward || (macroblock_intra && PictureHeader.concealment_motion_vectors))
    {
        if(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];
        }
        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);

        }
    }
    else
    {
        if(!macroblock_intra && !pMacro->macroblock_motion_forward
            && PictureHeader.picture_coding_type == P_FRAME)
        {
            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;
        }
    }
    if(pMacro->macroblock_motion_backward)
    {
        if(pMacro->motion_vector_count == 1)
        {
            if(pMacro->prediction_type == IPPVC_MC_FIELD)
                GET_1BIT(video->bs,pMacro->motion_vertical_field_select[1]);
            mv_decode(0,1, threadID);
            pMacro->PMV[6] = pMacro->PMV[2];
            pMacro->PMV[7] = pMacro->PMV[3];
        }
        else
        {
            GET_1BIT(video->bs,pMacro->motion_vertical_field_select[1]);
            mv_decode(0,1, threadID);
            GET_1BIT(video->bs,pMacro->motion_vertical_field_select[3]);
            mv_decode(1,1, threadID);
        }
    }
    else
    {
        pMacro->PMV[2] = 0; pMacro->PMV[3] = 0;
        pMacro->PMV[6] = 0; pMacro->PMV[7] = 0;

        pMacro->vector[2] = 0;
        pMacro->vector[3] = 0;
        pMacro->vector[6] = 0;
        pMacro->vector[7] = 0;
    }

    pSlice->motion_vertical_field_select_prev[0] = pMacro->motion_vertical_field_select[0];
    pSlice->motion_vertical_field_select_prev[1] = pMacro->motion_vertical_field_select[1];
    pSlice->motion_vertical_field_select_prev[2] = pMacro->motion_vertical_field_select[2];
    pSlice->motion_vertical_field_select_prev[3] = pMacro->motion_vertical_field_select[3];



    if(macroblock_intra)
    {
        if(PictureHeader.concealment_motion_vectors)
        {
            GET_1BIT(video->bs,marker_bit);
            VM_ASSERT(marker_bit);
            pSlice->macroblock_motion_forward_prev  = 1;
            pSlice->macroblock_motion_backward_prev = 0;
        }

        ReconstructIntraMB(threadID, 8, dct_type);
    }//if(pMacro->macroblock_intra)
    else
    {

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

            VM_ASSERT(coded_block_pattern || sequenceHeader.chroma_format != CHROMA_420);
            GET_TO9BITS(video->bs, 2, coded_block_pattern_1);
            coded_block_pattern = (coded_block_pattern << 2) |  coded_block_pattern_1;

            if(!dct_type)
            {
                BlockInterLuma(coded_block_pattern & 0x80, 0  , 32, threadID);
                BlockInterLuma(coded_block_pattern & 0x40, 8  , 32, threadID);
                BlockInterLuma(coded_block_pattern & 0x20, 128, 32, threadID);
                BlockInterLuma(coded_block_pattern & 0x10, 136, 32, threadID);
                BlockInterChroma(coded_block_pattern & 0x08, 256, 16, threadID);
                BlockInterChroma(coded_block_pattern & 0x04, 384, 16, threadID);
                BlockInterChroma(coded_block_pattern & 0x02, 320, 16, threadID);
                BlockInterChroma(coded_block_pattern & 0x01, 448, 16, threadID);
            }
            else
            {
                BlockInterLuma( coded_block_pattern & 0x80, 0 , 64, threadID);
                BlockInterLuma( coded_block_pattern & 0x40, 8 , 64, threadID);
                BlockInterLuma( coded_block_pattern & 0x20, 16, 64, threadID);
                BlockInterLuma( coded_block_pattern & 0x10, 24, 64, threadID);
                BlockInterChroma( coded_block_pattern & 0x08, 256, 32, threadID);
                BlockInterChroma( coded_block_pattern & 0x04, 384, 32, threadID);
                BlockInterChroma( coded_block_pattern & 0x02, 264, 32, threadID);
                BlockInterChroma( coded_block_pattern & 0x01, 392, 32, threadID);
            }
        }
        else
            memset(video->block.idct,0,64*8*sizeof(short));

        //motion compensation
        mc_mp2_422(video->block.idct, threadID);
    }

    return UMC_OK;

}//Macroblock_422


Status MPEG2VideoDecoderBase::Macroblock_444(int /*threadID*/)
{
    return UMC_BAD_STREAM;
}