umc_mpeg2_dec_mbfld.cpp

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

        {
            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(pMacro->macroblock_motion_forward)
        {
            if(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];
            }
            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);
            }

        }

        if(pMacro->macroblock_motion_backward)
        {
            if(pMacro->motion_vector_count == 1)
            {
                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);

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

        short* diff = video->block.idct;
        if (macroblock_type & IPPVC_MB_PATTERN) {
          umcRes = ReconstuctInterMB(threadID, 0);
          if (UMC_OK != umcRes) return umcRes;
        } else {
          diff = zero_memory;
        }


        //motion compensation
        if(pMacro->macroblock_motion_forward && pMacro->macroblock_motion_backward)
        {//bi_direction

            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;

            switch(pMacro->prediction_type)
            {
            case IPPVC_MC_FIELD:
                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 )* pitch_UV +
                         pMacro->vector_chroma[0] + pMacro->col_c +
                         pMacro->motion_vertical_field_select[0]*(pitch_UV>>1);

                offs2 = (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);

                offs1_y = ( pMacro->vector_luma[1] +pMacro->row_l )*pitch_Y +
                            pMacro->vector_luma[0] + pMacro->col_l+
                            pMacro->motion_vertical_field_select[0]*(pitch_Y>>1);

                offs2_y = ( 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);

                i = ippiMC16x16B_8u_C1( ref_Y_data1 + offs1_y,
                                        pitch_Y, flag1,
                                        ref_Y_data2  + offs2_y,
                                        pitch_Y, flag3,
                                        diff,32,
                                        cur_Y_data + pMacro->offset_l,
                                        pitch_Y, 0);
                VM_ASSERT(i == ippStsOk);

                i = ippiMC8x8B_8u_C1(    ref_U_data1 + offs1, pitch_UV, flag2,
                                        ref_U_data2 + offs2, pitch_UV, flag4,
                                        diff+256,16,
                                        cur_U_data + pMacro->offset_c,
                                        pitch_UV, 0);
                VM_ASSERT(i == ippStsOk);

                i = ippiMC8x8B_8u_C1(    ref_V_data1 + offs1, pitch_UV,flag2,
                                        ref_V_data2 + offs2, pitch_UV,flag4,
                                        diff+320,16,
                                        cur_V_data + pMacro->offset_c,
                                        pitch_UV, 0);
                VM_ASSERT(i == ippStsOk);

               break;
            case IPPVC_MC_16X8:
                for(r = 0; r < pMacro->motion_vector_count; r++)
                {
                    flag1 = ((pMacro->vector[4*r] & 1) << 3) | ((pMacro->vector[4*r + 1] & 1) << 2);
                    flag2 = ((pMacro->vector[4*r]/2 & 1) << 3) | ((pMacro->vector[4*r + 1]/2 & 1) << 2);

                    flag3 = ((pMacro->vector[4*r + 2] & 1) << 3) | ((pMacro->vector[4*r + 3] & 1) << 2);
                    flag4 = ((pMacro->vector[4*r + 2]/2 & 1) << 3) | ((pMacro->vector[4*r + 3]/2 & 1) << 2);

                    offs1 = (pMacro->vector_chroma[4*r + 1]  + pMacro->row_c + 4*r)* pitch_UV +
                                pMacro->vector_chroma[4*r] + pMacro->col_c +
                                pMacro->motion_vertical_field_select[2*r]*(pitch_UV>>1);

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

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

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

                    i = ippiMC16x8B_8u_C1(  ref_Y_data1 + offs1_y,
                                            pitch_Y, flag1,
                                            ref_Y_data2  + offs2_y,
                                            pitch_Y, flag3,
                                            diff+128*r,32,
                                            cur_Y_data + pMacro->offset_l  + shift_y[r],
                                            pitch_Y, 0);
                    VM_ASSERT(i == ippStsOk);

                    i = ippiMC8x4B_8u_C1(    ref_U_data1 + offs1, pitch_UV, flag2,
                                            ref_U_data2 + offs2, pitch_UV, flag4,
                                            diff+256+32*r,16,
                                            cur_U_data + pMacro->offset_c  + shift_uv[r],
                                            pitch_UV, 0);
                    VM_ASSERT(i == ippStsOk);

                    i = ippiMC8x4B_8u_C1(    ref_V_data1 + offs1, pitch_UV,flag2,
                                            ref_V_data2 + offs2, pitch_UV,flag4,
                                            diff+320+32*r,16,
                                            cur_V_data + pMacro->offset_c  + shift_uv[r],
                                            pitch_UV, 0);
                    VM_ASSERT(i == ippStsOk);
                }//for(r)
                break;
            }//switch(pMacro->prediction_type)

        }//bi_direction
        else   if(pMacro->macroblock_motion_forward)
        {
            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;

             switch(pMacro->prediction_type)
             {
             case IPPVC_MC_FIELD:
                offs = (pMacro->vector_chroma[1] + pMacro->row_c)* pitch_UV +
                        pMacro->vector_chroma[0] + pMacro->col_c +
                        pMacro->motion_vertical_field_select[0]*(pitch_UV>>1);

                offs1_y = ( pMacro->vector_luma[1]  + pMacro->row_l) * pitch_Y +
                            pMacro->vector_luma[0] + pMacro->col_l +
                            pMacro->motion_vertical_field_select[0]*(pitch_Y>>1);

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

                i = ippiMC16x16_8u_C1(  ref_Y_data + offs1_y, pitch_Y,
                                        diff,32,
                                        cur_Y_data +  pMacro->offset_l,
                                        pitch_Y, flag1, 0);
                VM_ASSERT(i == ippStsOk);


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

                i = ippiMC8x8_8u_C1(    ref_V_data + offs, pitch_UV,
                                        diff+320,16,
                                        cur_V_data +  pMacro->offset_c,
                                        pitch_UV, flag2, 0);
                VM_ASSERT(i == ippStsOk);

                break;
            case IPPVC_MC_16X8:
                for(r = 0; r < pMacro->motion_vector_count; r++)
                {
                    offs = (pMacro->vector_chroma[4*r + 1]  + pMacro->row_c  + 4 * r)* pitch_UV +
                            pMacro->vector_chroma[4*r] + pMacro->col_c
                            + pMacro->motion_vertical_field_select[2*r]*(pitch_UV>>1);

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

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

                    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)
                break;
          default:
              VM_ASSERT(0);
          }//switch(pMacro->prediction_type)
        }//single_direction forward
        else if(!pMacro->macroblock_motion_forward && pMacro->macroblock_motion_backward)
        {
            //single direction backward
            VM_ASSERT(pMacro->macroblock_motion_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;


            switch(pMacro->prediction_type)
            {
            case IPPVC_MC_FIELD:
                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);

                i = ippiMC16x16_8u_C1(    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,
                                        cur_Y_data + pMacro->offset_l,
                                        pitch_Y, flag1, 0);
                VM_ASSERT(i == ippStsOk);

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

                i = ippiMC8x8_8u_C1(    ref_V_data + offs, pitch_UV,
                                        diff+320,16,
                                        cur_V_data + pMacro->offset_c,
                                        pitch_UV, flag2, 0);
                VM_ASSERT(i == ippStsOk);

                break;
            case IPPVC_MC_16X8:
                for(r = 0; r < pMacro->motion_vector_count; r++)
                {

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

                    offs = (pMacro->vector_chroma[4*r + 3] + pMacro->row_c + 4*r)*pitch_UV +
                            pMacro->vector_chroma[4*r + 2] + pMacro->col_c +