umc_mpeg2_dec_mbfld.cpp

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

                            pMacro->motion_vertical_field_select[2*r+1]*(pitch_UV>>1);

                    offs1_y = ( pMacro->vector_luma[4*r + 3]  + pMacro->row_l + 8*r)*pitch_Y +
                                pMacro->vector_luma[4*r + 2] + pMacro->col_l +
                                pMacro->motion_vertical_field_select[2*r+1]*(pitch_Y>>1);

                    i = ippiMC16x8_8u_C1(    ref_Y_data + offs1_y, pitch_Y,
                                            diff+128*r,32,
                                            cur_Y_data + pMacro->offset_l  + shift_y[r],
                                            pitch_Y, flag1, 0);
                    VM_ASSERT(i == ippStsOk);

                    i = ippiMC8x4_8u_C1(    ref_U_data + offs, pitch_UV,
                                            diff+256+32*r,16,
                                            cur_U_data + pMacro->offset_c + shift_uv[r],
                                            pitch_UV, flag2, 0);
                    VM_ASSERT(i == ippStsOk);

                    i = ippiMC8x4_8u_C1(    ref_V_data + offs, pitch_UV,
                                            diff+320+32*r,16,
                                            cur_V_data + pMacro->offset_c + shift_uv[r],
                                            pitch_UV, flag2, 0);
                    VM_ASSERT(i == ippStsOk);
                }//for(r)
            }//switch(pMacro->prediction_type)
        } //single_direction backward
    }

    return umcRes;

}//Macroblock_420_B_field


void MPEG2VideoDecoderBase::skipped_macroblockB_field(int threadID)
{
    IppVideoContext*        video = &Video[threadID];
    sSlice                  *pSlice = &Video[threadID].slice;
    sMacroblock             *pMacro = &Video[threadID].macroblock;
    short *diff = zero_memory;
    int shift_y[2], shift_uv[2];

    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 pitch_y        = video->frame_buffer.Y_comp_pitch;
    int pitch_uv       = video->frame_buffer.U_comp_pitch;
    int ptc_uv, ptc_y;
    int flag1, flag2;
    int offs;
    int flag3, flag4;
    int offs1;
    int offs2;
    int i;
    int odd_pitch_y;
    int odd_pitch_uv;
    IppStatus ret;

    //odd_pitch = pitch for bottom field (odd strings)
    if(PictureHeader.picture_structure == BOTTOM_FIELD)
    {
        odd_pitch_y  =  pitch_y;
        odd_pitch_uv =  pitch_uv;
        pMacro->motion_vertical_field_select[0] = 1;
        pMacro->motion_vertical_field_select[1] = 1;
        pMacro->motion_vertical_field_select[2] = 1;
        pMacro->motion_vertical_field_select[3] = 1;
    }
    else {
        odd_pitch_y = 0;
        odd_pitch_uv = 0;
        pMacro->motion_vertical_field_select[0] = 0;
        pMacro->motion_vertical_field_select[1] = 0;
        pMacro->motion_vertical_field_select[2] = 0;
        pMacro->motion_vertical_field_select[3] = 0;
    }

    ptc_uv = pitch_uv<<1;
    ptc_y  = pitch_y<<1;

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

    pMacro->row_l  = pSlice->mb_row_prev << 4;
    pMacro->col_l  = pSlice->mb_col_prev << 4;

    COPY_PMV(pMacro->vector, pMacro->PMV)

    pMacro->prediction_type = IPPVC_MC_FIELD;

    switch(sequenceHeader.chroma_format)
    {
    case CHROMA_420:
        pMacro->row_c  = pSlice->mb_row_prev << 3;
        pMacro->col_c  = pSlice->mb_col_prev << 3;
        pMacro->offset_l = pMacro->row_l * ptc_y  + pMacro->col_l;
        pMacro->offset_c = pMacro->row_c * ptc_uv + pMacro->col_c;
        //bi_direction
        if(pMacro->macroblock_motion_forward && pMacro->macroblock_motion_backward)
        {
            ref_Y_data1 = video->frame_buffer.frame_p_c_n[video->frame_buffer.prev_index].Y_comp_data;
            ref_U_data1 = video->frame_buffer.frame_p_c_n[video->frame_buffer.prev_index].U_comp_data;
            ref_V_data1 = video->frame_buffer.frame_p_c_n[video->frame_buffer.prev_index].V_comp_data;

            ref_Y_data2 = video->frame_buffer.frame_p_c_n[video->frame_buffer.next_index].Y_comp_data;
            ref_U_data2 = video->frame_buffer.frame_p_c_n[video->frame_buffer.next_index].U_comp_data;
            ref_V_data2 = video->frame_buffer.frame_p_c_n[video->frame_buffer.next_index].V_comp_data;

            pMacro->vector_luma[1] = (pMacro->vector[1] >> 1) << 1;
            pMacro->vector_luma[0] = pMacro->vector[0] >> 1;
            pMacro->vector_luma[3] = (pMacro->vector[3] >> 1) << 1;
            pMacro->vector_luma[2] = pMacro->vector[2] >> 1;

            pMacro->vector_chroma[1] = ((pMacro->vector[1]/2)>>1) << 1;//down
            pMacro->vector_chroma[0] = (pMacro->vector[0]/2) >> 1;//right
            pMacro->vector_chroma[3] = ((pMacro->vector[3]/2)>>1) << 1;//down
            pMacro->vector_chroma[2] = (pMacro->vector[2]/2)>>1;//right

            flag1 = ((pMacro->vector[0] & 1) << 3) | ((pMacro->vector[1] & 1) << 2);
            flag2 = ((pMacro->vector[0]/2 & 1) << 3) |
                    ((pMacro->vector[1]/2 & 1) << 2);
            flag3 = ((pMacro->vector[2] & 1) << 3) | ((pMacro->vector[3] & 1) << 2);
            flag4 = ((pMacro->vector[2]/2 & 1) << 3) |
                    ((pMacro->vector[3]/2 & 1) << 2);

            offs1 = (pMacro->vector_chroma[1]  + pMacro->row_c)*ptc_uv + pMacro->motion_vertical_field_select[0]* pitch_uv +
                        pMacro->vector_chroma[0] + pMacro->col_c;

            offs2 = (pMacro->vector_chroma[3]  + pMacro->row_c)*ptc_uv + pMacro->motion_vertical_field_select[1]* pitch_uv +
                        pMacro->vector_chroma[2] + pMacro->col_c;

            if(offs1 < 0 || offs2 < 0)
                return;
            for(i=0; i<pSlice->mb_address_increment-1; i+=1){
            ret = ippiMC16x16B_8u_C1( 16*i + ref_Y_data1 +
                                    (pMacro->vector_luma[1]+pMacro->row_l)*ptc_y
                                    + pMacro->motion_vertical_field_select[0]*pitch_y +
                                    pMacro->vector_luma[0] + pMacro->col_l,
                                    ptc_y,
                                    flag1,
                                    16*i + ref_Y_data2  +
                                    (pMacro->vector_luma[3]
                                    + pMacro->row_l)*ptc_y
                                    + pMacro->motion_vertical_field_select[1]*pitch_y +
                                    pMacro->vector_luma[2] + pMacro->col_l,
                                    ptc_y,
                                    flag3,
                                    diff,32,
                                    16*i + video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].Y_comp_data + pMacro->offset_l
                                    + odd_pitch_y,
                                    ptc_y, 0);
            VM_ASSERT(ret == ippStsOk);
            ret = ippiMC8x8B_8u_C1( 8*i + ref_U_data1 + offs1, ptc_uv, flag2,
                                    ref_U_data2 + offs2, ptc_uv, flag4,
                                    diff+256,16,
                                    8*i + video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].U_comp_data + pMacro->offset_c
                                        + odd_pitch_uv,
                                    ptc_uv, 0);
            VM_ASSERT(ret == ippStsOk);
            ret = ippiMC8x8B_8u_C1( 8*i + ref_V_data1 + offs1, ptc_uv,flag2,
                                    ref_V_data2 + offs2, ptc_uv,flag4,
                                    diff+320,16,
                                    8*i + video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].V_comp_data + pMacro->offset_c
                                        + odd_pitch_uv,
                                    ptc_uv, 0);
            VM_ASSERT(ret == ippStsOk);
            }

        }
        else   if(pMacro->macroblock_motion_forward /*||  PictureHeader.picture_coding_type == P_FRAME*/)
        {
            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;

            if(PictureHeader.picture_coding_type == P_FRAME && PictureHeader.field_buffer_index)
            {
                if(PictureHeader.picture_structure == BOTTOM_FIELD)
                {
                    if(!pMacro->motion_vertical_field_select[0])
                    {
                        ref_Y_data  = video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].Y_comp_data;
                        ref_U_data  = video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].U_comp_data;
                        ref_V_data  = video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].V_comp_data;
                    }
                }
                else
                {
                    if(pMacro->motion_vertical_field_select[0])
                    {
                        ref_Y_data  = video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].Y_comp_data;
                        ref_U_data  = video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].U_comp_data;
                        ref_V_data  = video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].V_comp_data;
                    }
                }
            }//if(PictureHeader.picture_coding_type == P_FRAME && PictureHeader.field_buffer_index)

            pMacro->vector_luma[1] = (pMacro->vector[1] >> 1) << 1;
            pMacro->vector_luma[0] = pMacro->vector[0] >> 1;

            pMacro->vector_chroma[1] = ((pMacro->vector[1]/2)>>1) << 1;//down
            pMacro->vector_chroma[0] = (pMacro->vector[0]/2)>>1;//right

            offs = (pMacro->vector_chroma[1]  + pMacro->row_c)*ptc_uv + pMacro->motion_vertical_field_select[0]* pitch_uv +
                        pMacro->vector_chroma[0] + pMacro->col_c;

            flag1 = ((pMacro->vector[0] & 1) << 3) | ((pMacro->vector[1] & 1) << 2);
            flag2 = ((pMacro->vector[0]/2 & 1) << 3) | ((pMacro->vector[1]/2 & 1) << 2);


            for(i=0; i<pSlice->mb_address_increment-1; i+=1){
            if(offs < 0)
                return;
            ret = ippiMC16x16_8u_C1( 16*i + ref_Y_data +
                                    (pMacro->vector_luma[1]  + pMacro->row_l)*ptc_y+ pMacro->motion_vertical_field_select[0] * pitch_y +
                                    pMacro->vector_luma[0] + pMacro->col_l,
                                    ptc_y,
                                    diff,32,
                                    16*i + video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].Y_comp_data + pMacro->offset_l + odd_pitch_y,
                                    ptc_y, flag1, 0);
            VM_ASSERT(ret == ippStsOk);


            ret = ippiMC8x8_8u_C1(  8*i + ref_U_data + offs, ptc_uv,
                                    diff+256,16,
                                    8*i + video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].U_comp_data + pMacro->offset_c + odd_pitch_uv,
                                    ptc_uv, flag2, 0);
            VM_ASSERT(ret == ippStsOk);
            ret = ippiMC8x8_8u_C1(  8*i + ref_V_data + offs, ptc_uv,
                                    diff+320,16,
                                    8*i + video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].V_comp_data + pMacro->offset_c + odd_pitch_uv,
                                    ptc_uv, flag2, 0);
            VM_ASSERT(ret == ippStsOk);
            }
        }
        else if(/*!pMacro->macroblock_motion_forward &&*/ pMacro->macroblock_motion_backward)
        {
            int pitch_Y = pitch_y <<1;
            int pitch_UV = pitch_uv << 1;
            unsigned char *cur_Y_data = video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].Y_comp_data;
            unsigned char *cur_U_data = video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].U_comp_data;
            unsigned char *cur_V_data = video->frame_buffer.frame_p_c_n[video->frame_buffer.curr_index].V_comp_data;
            //single direction backward

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

            flag1 = ((pMacro->vector[2] & 1) << 3) | ((pMacro->vector[3] & 1) << 2);
            flag2 = ((pMacro->vector[2]/2 & 1) << 3) | ((pMacro->vector[3]/2 & 1) << 2);

            offs = (pMacro->vector_chroma[3] + pMacro->row_c)*pitch_UV +
                        pMacro->vector_chroma[2] + pMacro->col_c  +
                        pMacro->motion_vertical_field_select[1]*(pitch_UV>>1);

            for(i=0; i<pSlice->mb_address_increment-1; i+=1){
            ret = ippiMC16x16_8u_C1( 16*i + ref_Y_data +
                                    (pMacro->vector_luma[3] + pMacro->row_l)*pitch_Y +
                                    pMacro->vector_luma[2] + pMacro->col_l +
                                    pMacro->motion_vertical_field_select[1]*(pitch_Y>>1),
                                    pitch_Y,
                                    diff,32,
                                    16*i + cur_Y_data + pMacro->offset_l + odd_pitch_y,
                                    pitch_Y, flag1, 0);
            VM_ASSERT(ret == ippStsOk);

            ret = ippiMC8x8_8u_C1(  8*i + ref_U_data + offs, pitch_UV,
                                    diff+256,16,
                                    8*i + cur_U_data + pMacro->offset_c + odd_pitch_uv,
                                    pitch_UV, flag2, 0);
            VM_ASSERT(ret == ippStsOk);

            ret = ippiMC8x8_8u_C1(  8*i + ref_V_data + offs, pitch_UV,
                                    diff+320,16,
                                    8*i + cur_V_data + pMacro->offset_c + odd_pitch_uv,
                                    pitch_UV, flag2, 0);
            VM_ASSERT(ret == ippStsOk);
            }
        } //single_direction backward

        break;
    case CHROMA_422:
        for(i=0; i<pSlice->mb_address_increment-1; i+=1){
          pMacro->row_c  = pMacro->row_l;
          pMacro->col_c  = pMacro->col_l >> 1;
          pMacro->offset_l = pMacro->row_l * video->frame_buffer.Y_comp_pitch*2 + pMacro->col_l;
          pMacro->offset_c = pMacro->row_c * video->frame_buffer.U_comp_pitch*2 + pMacro->col_c;
          mc_mp2_422(zero_memory, threadID);
          pMacro->col_l += 16;
        }
        break;
     case CHROMA_444:
        for(i=0; i<pSlice->mb_address_increment-1; i+=1){
          pMacro->row_c  = pMacro->row_l;
          pMacro->col_c  = pMacro->col_l;
          pMacro->offset_l = pMacro->row_l * video->frame_buffer.Y_comp_pitch*2 + pMacro->col_l;
          pMacro->offset_c = pMacro->row_c * video->frame_buffer.U_comp_pitch*2 + pMacro->col_c;
          mc_mp2_444(zero_memory, threadID);
          pMacro->col_l += 16;
        }
        break;
     default:
         VM_ASSERT(0);
         break;
    }
}