umc_vc1_dec_mb_bpic_adv.cpp

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

            }


        }
        break;
    case (VC1_MB_1MV_INTER|VC1_MB_BACKWARD):
        {
#ifdef VC1_DEBUG_ON
            VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV_FIELD,VM_STRING("predictor_flag = %d\n"), pCurrMB->predictor_flag[0]);
#endif
            CalculateField1MVTwoReferenceBPic(pContext,&X,&Y,1,&pCurrMB->predictor_flag[0]);
            ApplyMVPredictionCalculateTwoReference(pContext->m_picLayerHeader,&X,&Y,pCurrMB->dmv_x[1][0],pCurrMB->dmv_y[1][0],pCurrMB->predictor_flag[0]);
            writeMV_w_predict(pContext,X,Y,X,Y,1,pCurrMB->predictor_flag[0]);

            // calculate backward MVs
            {
                Ipp16s Xbtop = 0;
                Ipp16s Ybtop = 0;
#ifdef VC1_DEBUG_ON
                VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV_FIELD,VM_STRING("predictor_flag = %d\n"), pCurrMB->predictor_flag[1]);
#endif
                CalculateField1MVTwoReferenceBPic(pContext, &Xbtop, &Ybtop,0,&pCurrMB->predictor_flag[1]);
                writeMV_w_predict(pContext,Xbtop,Ybtop,Xbtop,Ybtop,0,pCurrMB->predictor_flag[1]);
            }
#ifdef VC1_DEBUG_ON
            VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV_FIELD,VM_STRING("\n\n"));
#endif
        }
        break;
    case (VC1_MB_4MV_INTER|VC1_MB_BACKWARD):
        {
            // need to fill forward population
            Ipp32s blk_num;
#ifdef VC1_DEBUG_ON
            VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV_FIELD,VM_STRING("predictor_flag = %d\n"), pCurrMB->predictor_flag[0]);
#endif
            CalculateField1MVTwoReferenceBPic(pContext,&X,&Y,0,&pCurrMB->predictor_flag[0]);

            pCurrMB->m_pBlocks[0].mv[0][0] = X;
            pCurrMB->m_pBlocks[0].mv[0][1] = Y;
            pCurrMB->m_pBlocks[0].mv_s_polarity[0] = 1 - pCurrMB->predictor_flag[0];

#ifdef VC1_DEBUG_ON
            VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV_FIELD,
                                                                VM_STRING("\n\n"));
#endif

            for( blk_num = 1;  blk_num < VC1_NUM_OF_LUMA;  blk_num++)
            {
                pCurrMB->m_pBlocks[blk_num].fieldFlag[0] = pCurrMB->fieldFlag[0];

                pCurrMB->m_pBlocks[blk_num].mv[0][0] = X;
                pCurrMB->m_pBlocks[blk_num].mv[0][1] = Y;
                pCurrMB->m_pBlocks[blk_num].mv_s_polarity[0] = 1 - pCurrMB->predictor_flag[0];
            }
        }
        break;
    case(VC1_MB_1MV_INTER|VC1_MB_INTERP):
        {
#ifdef VC1_DEBUG_ON
            VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV_FIELD,VM_STRING("predictor_flag = %d\n"), pCurrMB->predictor_flag[0]);
#endif
            CalculateField1MVTwoReferenceBPic(pContext,&X,&Y,0,&pCurrMB->predictor_flag[0]);
            ApplyMVPredictionCalculateTwoReference(pContext->m_picLayerHeader,&X,&Y,pCurrMB->dmv_x[0][0],pCurrMB->dmv_y[0][0],pCurrMB->predictor_flag[0]);
            writeMV_w_predict(pContext,X,Y,X,Y,0,pCurrMB->predictor_flag[0]);

#ifdef VC1_DEBUG_ON
            VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV_FIELD,VM_STRING("\n\n"));
            VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV_FIELD,VM_STRING("predictor_flag = %d\n"), pCurrMB->predictor_flag[1]);
#endif

            CalculateField1MVTwoReferenceBPic(pContext,&X,&Y,1,&pCurrMB->predictor_flag[1]);
            ApplyMVPredictionCalculateTwoReference(pContext->m_picLayerHeader,&X,&Y,pCurrMB->dmv_x[1][0],pCurrMB->dmv_y[1][0],pCurrMB->predictor_flag[1]);
            writeMV_w_predict(pContext,X,Y,X,Y,1,pCurrMB->predictor_flag[1]);
#ifdef VC1_DEBUG_ON
            VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV_FIELD,VM_STRING("\n\n"));
#endif
        }
        break;
    }

    return vc1Res;
}
VC1Status MBLayer_InterlaceFieldBpicture_DIRECT_Prediction(VC1Context* pContext)
{
    VC1Status vc1Res = VC1_OK;
    Ipp16s X,Y,Xf,Yf,Xb,Yb;
    VC1SingletonMB* sMB = pContext->m_pSingleMB;
    VC1MB* pCurrMB = pContext->m_pCurrMB;
    Ipp16s* savedMV = pContext->savedMV_Curr
        + (sMB->widthMB*sMB->m_currMBYpos + sMB->m_currMBXpos)*4*2*2;

    CalculateMV_InterlaceField(pContext,savedMV,savedMV+4, &X, &Y);
    Scale_Direct_MV(pContext->m_picLayerHeader,X,Y,&Xf,&Yf,&Xb,&Yb);
    writeMV(pCurrMB,Xf,Yf,0,0,0);
#ifdef VC1_DEBUG_ON
    VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV_FIELD,(VM_STRING("CurrFlag1 = %d\n")), pCurrMB->fieldFlag[0]);
    VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV_FIELD,(VM_STRING("IX = %d IY = %d\n")), Xf, Yf);
#endif

    writeMV(pCurrMB,Xb,Yb,0,0,1);

#ifdef VC1_DEBUG_ON
   VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV_FIELD,(VM_STRING("CurrFlag1 = %d\n")), pCurrMB->fieldFlag[1]);
   VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV_FIELD,(VM_STRING("IX = %d IY = %d\n")), Xb, Yb);
#endif
    return vc1Res;
}



VC1Status MBLayer_InterlaceFieldBpicture_DIRECT_Decode(VC1Context* pContext)
{
    VC1MB* pCurrMB = pContext->m_pCurrMB;
    VC1SingletonMB* sMB = pContext->m_pSingleMB;
    VC1PictureLayerHeader* picLayerHeader = pContext->m_picLayerHeader;

    VC1Status vc1Res = VC1_OK;
    Ipp32s blk_num = 0;
    Ipp32s ret = ippStsNoErr;

    for (blk_num=0;blk_num<VC1_NUM_OF_BLOCKS;blk_num++)
        pCurrMB->m_pBlocks[blk_num].blkType = (Ipp8u)picLayerHeader->TTFRM;

     CalculateIntraFlag(pContext);


    if(VC1_MB_Mode_PBFieldPic_CBPPresent_Table[sMB->MBMODEIndex])
    {
        //CBPCY
        ret = ippiDecodeHuffmanOne_1u32s(&pContext->m_bitstream.pBitstream,
            &pContext->m_bitstream.bitOffset,
            &pCurrMB->m_cbpBits,
            pContext->m_picLayerHeader->m_pCurrCBPCYtbl);

        VM_ASSERT(ret == ippStsNoErr);
    }
    else
    {
        pCurrMB->m_cbpBits = 0;
    }
    return vc1Res;
}
VC1Status MBLayer_Field_InterlacedBpicture (VC1Context* pContext)
{
    VC1Status vc1Res = VC1_OK;
    VC1MB* pCurrMB = pContext->m_pCurrMB;
    VC1SingletonMB* sMB = pContext->m_pSingleMB;
    VC1PictureLayerHeader* picLayerHeader = pContext->m_picLayerHeader;

    Ipp32s FORWARDBIT;
    Ipp32s blk_num;

    Ipp32u currFieldMBYpos;
    Ipp32u currFieldMBXpos;
    Ipp32u ACPRED = 0;

#ifdef VC1_DEBUG_ON
     VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_POSITION,
                                                            VM_STRING("\t\t\tX: %d, Y: %d\n"),
                                                            sMB->m_currMBXpos, sMB->m_currMBYpos);
#endif

    for (blk_num=0;blk_num<VC1_NUM_OF_BLOCKS;blk_num++)
    {
        pCurrMB->m_pBlocks[blk_num].fieldFlag[0] = picLayerHeader->BottomField;
        pCurrMB->m_pBlocks[blk_num].fieldFlag[1] = picLayerHeader->BottomField;
    }

    pCurrMB->fieldFlag[0] = picLayerHeader->BottomField;
    pCurrMB->fieldFlag[1] = picLayerHeader->BottomField;
    currFieldMBYpos = sMB->m_currMBYpos;
    currFieldMBXpos = sMB->m_currMBXpos;


    if (picLayerHeader->CurrField)
        currFieldMBYpos -= sMB->heightMB/2;

    //Y
    pCurrMB->currYPitch = sMB->currYPitch;
    pCurrMB->currYPlane = sMB->currYPlane + 2*pCurrMB->currYPitch*currFieldMBYpos*VC1_PIXEL_IN_LUMA
                    + currFieldMBXpos*VC1_PIXEL_IN_LUMA;

    //U
    pCurrMB->currUPitch = sMB->currUPitch;
    pCurrMB->currUPlane = sMB->currUPlane + 2*pCurrMB->currUPitch*currFieldMBYpos*VC1_PIXEL_IN_CHROMA
                    + currFieldMBXpos*VC1_PIXEL_IN_CHROMA;
    //V
    pCurrMB->currVPitch = sMB->currVPitch;
    pCurrMB->currVPlane = sMB->currVPlane + 2*pCurrMB->currVPitch*currFieldMBYpos*VC1_PIXEL_IN_CHROMA
                    + currFieldMBXpos*VC1_PIXEL_IN_CHROMA;

   pCurrMB->currYPlane = pCurrMB->currYPlane + pCurrMB->currYPitch * picLayerHeader->BottomField;
   pCurrMB->currUPlane = pCurrMB->currUPlane + pCurrMB->currUPitch * picLayerHeader->BottomField;
   pCurrMB->currVPlane = pCurrMB->currVPlane + pCurrMB->currVPitch * picLayerHeader->BottomField;

   pCurrMB->currYPitch *=2;
   pCurrMB->currUPitch *=2;
   pCurrMB->currVPitch *=2;

    memset(pContext->m_pBlock, 0, sizeof(Ipp16s)*8*8*VC1_NUM_OF_BLOCKS);

    pCurrMB->LeftTopRightPositionFlag = CalculateLeftTopRightPositionFlag(sMB);

    Set_MQuant_Field(pContext);
    pCurrMB->FIELDTX = 0;

    {
        Ipp32s ret;
        ret = ippiDecodeHuffmanOne_1u32s (  &pContext->m_bitstream.pBitstream,
                                            &pContext->m_bitstream.bitOffset,
                                            &sMB->MBMODEIndex,
                                            picLayerHeader->m_pMBMode);
        VM_ASSERT(ret == ippStsNoErr);
    }

    pCurrMB->mbType = VC1_MB_Mode_PBFieldPic_MBtype_Table[sMB->MBMODEIndex];

    if(pCurrMB->mbType == VC1_MB_INTRA)
    {
        //INTRA
        //  VM_Debug::GetInstance().vm_debug_frame(-1,VC1_MV,VM_STRING("Interlace Intra B\n"));

        for(blk_num = 0; blk_num < VC1_NUM_OF_BLOCKS; blk_num++)
        {
            pCurrMB->m_pBlocks[blk_num].blkType = VC1_BLK_INTRA;
        }

        CalculateIntraFlag(pContext);

        if (picLayerHeader->m_DQuantFRM)
            Set_Alt_MQUANT(pContext);

        VC1_GET_BITS(1, ACPRED);

        if(VC1_MB_Mode_PBFieldPic_CBPPresent_Table[sMB->MBMODEIndex] != 0)
        {
            //CBPCY decoding
            Ipp32s ret;
            ret = ippiDecodeHuffmanOne_1u32s(&pContext->m_bitstream.pBitstream,
                                            &pContext->m_bitstream.bitOffset,
                                            &pCurrMB->m_cbpBits,
                                            picLayerHeader->m_pCurrCBPCYtbl);

            VM_ASSERT(ret == ippStsNoErr);
        }
        else
            pCurrMB->m_cbpBits = 0;

        CalculateIntraFlag(pContext);


        PDCPredictionTable[pContext->m_seqLayerHeader->DQUANT](pContext);
        sMB->ZigzagTable = AdvZigZagTables_PBField_luma[ACPRED];

        for(blk_num = 0; blk_num < VC1_NUM_OF_LUMA; blk_num++)
        {
           vc1Res = BLKLayer_Intra_Luma_Adv(pContext, blk_num, ACPRED);
           if(vc1Res != VC1_OK)
           {
              VM_ASSERT(0);
               break;
           }
        }

        sMB->ZigzagTable = AdvZigZagTables_PBField_chroma[ACPRED];

       for(blk_num; blk_num < VC1_NUM_OF_BLOCKS; blk_num++)
       {
           //all MB inter
           vc1Res = BLKLayer_Intra_Chroma_Adv(pContext, blk_num, ACPRED);
           if(vc1Res != VC1_OK)
           {
               VM_ASSERT(0);
               break;
           }
       }
    }
    else
    {
        //inter
        {
            if(VC1_IS_BITPLANE_RAW_MODE(&picLayerHeader->FORWARDMB))
            {
                VC1_GET_BITS(1, FORWARDBIT);
            }
            else {
                FORWARDBIT = picLayerHeader->FORWARDMB.m_databits
                    [sMB->widthMB * sMB->slice_currMBYpos +
                    sMB->m_currMBXpos];
            }
        }


        if(!FORWARDBIT)
        {
            if( VC1_GET_MBTYPE(pCurrMB->mbType) == VC1_MB_4MV_INTER)
            {
                pCurrMB->mbType = (Ipp8u)(pCurrMB->mbType | VC1_MB_BACKWARD);
            }
            else
            {
                Decode_InterlaceField_BMVTYPE(pContext);
            }

            if(VC1_GET_PREDICT(pCurrMB->mbType) == VC1_MB_INTERP)
            {
                VC1_GET_BITS(1, sMB->INTERPMVP);
            }
        }
        else
        {
            pCurrMB->mbType = (Ipp8u)(pCurrMB->mbType | VC1_MB_FORWARD);
        }

        STATISTICS_START_TIME(m_timeStatistics->motion_vector_decoding_StartTime);
        if(pCurrMB->mbType == (VC1_MB_DIRECT|VC1_MB_1MV_INTER) ||
           pCurrMB->mbType == (VC1_MB_DIRECT|VC1_MB_4MV_INTER))
        {
            MBLayer_InterlaceFieldBpicture_DIRECT_Decode(pContext);
            pCurrMB->SkipAndDirectFlag = 1;
        }
        else
        {
            MBLayer_InterlaceFieldBpicture_NONDIRECT_Decode(pContext);
            pCurrMB->SkipAndDirectFlag = 0;
        }
        STATISTICS_END_TIME(m_timeStatistics->motion_vector_decoding_StartTime,
                        m_timeStatistics->motion_vector_decoding_EndTime,
                        m_timeStatistics->motion_vector_decoding_TotalTime);

        if((picLayerHeader->m_DQuantFRM == 1) && (pCurrMB->m_cbpBits!=0))
            Set_Alt_MQUANT(pContext);

        DecodeTransformInfo(pContext);
        CalculateIntraFlag(pContext);
        sMB->ZigzagTable = AdvZigZagTables_PBField_luma[ACPRED];

        for(blk_num = 0; blk_num < VC1_NUM_OF_LUMA; blk_num++)
        {
           vc1Res = BLKLayer_Inter_Luma_Adv(pContext, blk_num);
           if(vc1Res != VC1_OK)
           {
               VM_ASSERT(0);
               break;
           }
        }

        sMB->ZigzagTable = AdvZigZagTables_PBField_chroma[ACPRED];

       for(blk_num; blk_num < VC1_NUM_OF_BLOCKS; blk_num++)
       {
           //all MB inter
           vc1Res = BLKLayer_Inter_Chroma_Adv(pContext, blk_num);
           if(vc1Res != VC1_OK)
           {
               VM_ASSERT(0);
               break;
           }
       }
    }
    AssignCodedBlockPattern(pCurrMB,sMB);

    return vc1Res;
}
#endif //UMC_ENABLE_VC1_VIDEO_DECODER