umc_vc1_dec_mb_bpic.cpp

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

        ApplyMVPrediction(pContext, 0, &X, &Y, pCurrMB->dmv_x[0][0], pCurrMB->dmv_y[0][0], 0);
        // backward MV can be used for MV Prediction, so it should be calculated
        {
            Ipp32s i;
            Ipp16s X,Y,Xf,Yf,Xb=0,Yb=0;
            Ipp16s* savedMV = pContext->savedMV_Curr +
                (sMB->widthMB*sMB->m_currMBYpos + sMB->m_currMBXpos)*4*2;

            CalculateMV(savedMV, savedMV+4,&X, &Y);
            if ((Ipp16u)X!=VC1_MVINTRA)
            {
                PullBack_BDirect(pContext,  &X, &Y);
                Scale_Direct_MV(picLayerHeader,X,Y,&Xf,&Yf,&Xb,&Yb);
                PullBack_PPred(pContext, &Xb,&Yb,-1);//_MAYBE_ mismatch number of parameters
            }
            for (i=0;i<4;i++)
            {
                pCurrMB->m_pBlocks[i].mv[1][0]=Xb;
                pCurrMB->m_pBlocks[i].mv[1][1]=Yb;
            }
        }
        break;
    case (VC1_MB_1MV_INTER|VC1_MB_BACKWARD):

        Progressive1MVPrediction(pContext);
        CalculateProgressive1MV_B(pContext,&X,&Y,1);
        ApplyMVPrediction(pContext, 0, &X, &Y, pCurrMB->dmv_x[1][0], pCurrMB->dmv_y[1][0],1);
        // forward MV can be used for MV Prediction, so it should be calculated
        {
            Ipp32s i;
            Ipp16s X,Y,Xf=0,Yf=0,Xb=0,Yb=0;
            Ipp16s* savedMV = pContext->savedMV_Curr
                + (sMB->widthMB*sMB->m_currMBYpos+ sMB->m_currMBXpos)*4*2;

            CalculateMV(savedMV, savedMV+4,&X, &Y);
            if ((Ipp16u)X!=VC1_MVINTRA)
            {
                PullBack_BDirect(pContext,  &X, &Y);
                Scale_Direct_MV(picLayerHeader,X,Y,&Xf,&Yf,&Xb,&Yb);
                PullBack_PPred(pContext, &Xf,&Yf,-1);//_MAYBE_ mismatch number of parameters
            }
            for (i=0;i<4;i++)
            {
                pCurrMB->m_pBlocks[i].mv[0][0]=Xf;
                pCurrMB->m_pBlocks[i].mv[0][1]=Yf;
            }
        }
        break;
    case (VC1_MB_1MV_INTER|VC1_MB_INTERP):
        Progressive1MVPrediction(pContext);
        CalculateProgressive1MV_B(pContext,&X,&Y,0);
        ApplyMVPrediction(pContext, 0, &X, &Y, pCurrMB->dmv_x[0][0], pCurrMB->dmv_y[0][0], 0);

        Progressive1MVPrediction(pContext);
        CalculateProgressive1MV_B(pContext,&X,&Y,1);
        ApplyMVPrediction(pContext, 0, &X, &Y, pCurrMB->dmv_x[1][0], pCurrMB->dmv_y[1][0], 1);
        break;
    }

    return VC1_OK;
}
VC1Status MBLayer_ProgressiveBpicture_DIRECT_Prediction(VC1Context* pContext)
{
    Ipp32u i;
    Ipp16s* savedMV = pContext->savedMV_Curr +
        (pContext->m_seqLayerHeader->widthMB*pContext->m_pSingleMB->m_currMBYpos
                + pContext->m_pSingleMB->m_currMBXpos)*4*2;
    Ipp16s X,Y,Xf,Yf,Xb,Yb;

    VC1MB* pCurrMB = pContext->m_pCurrMB;
    VC1PictureLayerHeader* picLayerHeader = pContext->m_picLayerHeader;

    CalculateMV(savedMV,savedMV+4, &X, &Y);
    if ((Ipp16u)X!=VC1_MVINTRA)
    {
        PullBack_BDirect(pContext,  &X, &Y);
        Scale_Direct_MV(picLayerHeader,X,Y,&Xf,&Yf,&Xb,&Yb);
        PullBack_PPred(pContext, &Xf,&Yf,-1);//_MAYBE_ mismatch number of parameters
        PullBack_PPred(pContext, &Xb,&Yb,-1);//_MAYBE_ mismatch number of parameters
    }
    else
    {
        Xf=0;
        Yf=0;
        Xb=0;
        Yb=0;
    }
    for (i=0;i<4;i++)
    {
        pCurrMB->m_pBlocks[i].mv[0][0]=Xf;
        pCurrMB->m_pBlocks[i].mv[0][1]=Yf;
        pCurrMB->m_pBlocks[i].mv[1][0]=Xb;
        pCurrMB->m_pBlocks[i].mv[1][1]=Yb;
    }
    return VC1_OK;
}

static VC1Status MBLayer_ProgressiveBpicture_DIRECT_Decode(VC1Context* pContext)
{
    Ipp32s i;
    Ipp32s ret = ippStsNoErr;
    VC1MB* pCurrMB = pContext->m_pCurrMB;
    VC1PictureLayerHeader* picLayerHeader = pContext->m_picLayerHeader;

    for (i=0;i<VC1_NUM_OF_BLOCKS;i++)
        pCurrMB->m_pBlocks[i].blkType = (Ipp8u)pContext->m_picLayerHeader->TTFRM;
    pCurrMB->mbType=(VC1_MB_1MV_INTER|VC1_MB_DIRECT);
    //CBPCY
    ret = ippiDecodeHuffmanOne_1u32s(&pContext->m_bitstream.pBitstream,
        &pContext->m_bitstream.bitOffset,
        &pCurrMB->m_cbpBits,
        pContext->m_picLayerHeader->m_pCurrCBPCYtbl);

    VM_ASSERT(ret == ippStsNoErr);

    //MQUANT
    if (picLayerHeader->m_PQuant_mode>=VC1_ALTPQUANT_MB_LEVEL)
        GetMQUANT(pContext);

    //TTMB
    DecodeTransformInfo(pContext);
    return VC1_OK;
}

static const B_MB_DECODE B_MB_Dispatch_table[] = {
        (B_MB_DECODE)(MBLayer_ProgressiveBpicture_NONDIRECT_Decode),
        (B_MB_DECODE)(MBLayer_ProgressiveBpicture_SKIP_NONDIRECT_Decode)
};

//vc-1: Figure 25: Syntax diagram for macroblock layer bitstream in
//Progressive-coded B picture
VC1Status MBLayer_ProgressiveBpicture(VC1Context* pContext)
{
    Ipp32s DIRECTBBIT=0;
    Ipp32s SKIPMBBIT=0;
    Ipp32s i;
    VC1Status vc1Res = VC1_OK;

    VC1SingletonMB* sMB = pContext->m_pSingleMB;
    VC1MB* pCurrMB = pContext->m_pCurrMB;
    VC1PictureLayerHeader* picLayerHeader = pContext->m_picLayerHeader;

    pCurrMB->Overlap =0;

    pCurrMB->m_cbpBits = 0;
    sMB->m_ubNumFirstCodedBlk = 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

    pCurrMB->LeftTopRightPositionFlag = CalculateLeftTopRightPositionFlag(sMB);

    Set_MQuant(pContext);
    // DIRECTBBIT
    if(VC1_IS_BITPLANE_RAW_MODE(&picLayerHeader->m_DirectMB))
    {
        VC1_GET_BITS(1, DIRECTBBIT);
    }
    else
    {
        DIRECTBBIT = picLayerHeader->m_DirectMB.m_databits
            [sMB->widthMB*sMB->m_currMBYpos + sMB->m_currMBXpos];
    }
    // SKIPMBBIT
    if(VC1_IS_BITPLANE_RAW_MODE((&picLayerHeader->SKIPMB)))
    {
        VC1_GET_BITS(1, SKIPMBBIT);
    }
    else
    {
        SKIPMBBIT = pContext->m_picLayerHeader->SKIPMB.m_databits
            [sMB->widthMB*sMB->m_currMBYpos + sMB->m_currMBXpos];
    }

    pCurrMB->SkipAndDirectFlag = (Ipp8u)(DIRECTBBIT+(SKIPMBBIT<<1));

    STATISTICS_START_TIME(m_timeStatistics->motion_vector_decoding_StartTime);
    if (!DIRECTBBIT)
        B_MB_Dispatch_table[SKIPMBBIT](pContext);
    else if (!SKIPMBBIT)
        MBLayer_ProgressiveBpicture_DIRECT_Decode(pContext);
    else
        MBLayer_ProgressiveBpicture_SKIP_DIRECT_Decode(pContext);
    STATISTICS_END_TIME(m_timeStatistics->motion_vector_decoding_StartTime,
        m_timeStatistics->motion_vector_decoding_EndTime,
        m_timeStatistics->motion_vector_decoding_TotalTime);

    CalculateIntraFlag(pContext);

      //Y
    pCurrMB->currYPitch = sMB->currYPitch;
    pCurrMB->currYPlane = sMB->currYPlane + pCurrMB->currYPitch * sMB->m_currMBYpos*VC1_PIXEL_IN_LUMA
                                                                 + sMB->m_currMBXpos * VC1_PIXEL_IN_LUMA;

    //U
    pCurrMB->currUPitch = sMB->currUPitch;
    pCurrMB->currUPlane = sMB->currUPlane   + pCurrMB->currUPitch * sMB->m_currMBYpos * VC1_PIXEL_IN_CHROMA
                                                                + sMB->m_currMBXpos*VC1_PIXEL_IN_CHROMA;

    //V
    pCurrMB->currVPitch = sMB->currVPitch;
    pCurrMB->currVPlane = sMB->currVPlane + pCurrMB->currVPitch * sMB->m_currMBYpos*VC1_PIXEL_IN_CHROMA
                                                                + sMB->m_currMBXpos*VC1_PIXEL_IN_CHROMA;

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

    if(SKIPMBBIT == 0)
    {

        sMB->ZigzagTable = ZigZagTables_PB_luma[sMB->ACPRED];

        if(!pCurrMB->IntraFlag)
        {
            for(i = 0; i < VC1_NUM_OF_LUMA; i++)
            {
                //luma
                vc1Res = BLKLayer_Inter_Luma(pContext, i);
                if(vc1Res != VC1_OK)
                {
                    VM_ASSERT(0);
                    break;
                }
            }
            //chroma
            sMB->ZigzagTable = ZigZagTables_PB_chroma[sMB->ACPRED];

            for(i; i < VC1_NUM_OF_BLOCKS; i++)
            {
                vc1Res = BLKLayer_Inter_Chroma(pContext, i);
                if(vc1Res != VC1_OK)
                {
                    VM_ASSERT(0);
                    break;
                }
            }
        }
        else
        {
            PDCPredictionTable[pContext->m_seqLayerHeader->DQUANT](pContext);
            for(i = 0; i < VC1_NUM_OF_LUMA; i++)
            {
                vc1Res = BLKLayer_Intra_Luma(pContext, i, 128, sMB->ACPRED);
                if(vc1Res != VC1_OK)
                {
                    VM_ASSERT(0);
                    break;
                }
            }
            //chroma
            sMB->ZigzagTable = ZigZagTables_PB_chroma[sMB->ACPRED];

            for(i; i < VC1_NUM_OF_BLOCKS; i++)
            {
                vc1Res = BLKLayer_Intra_Chroma(pContext, i, 128, sMB->ACPRED);
                if(vc1Res != VC1_OK)
                {
                    VM_ASSERT(0);
                    break;
                }
            }
        }
    }

    return vc1Res;

}

#endif //UMC_ENABLE_VC1_VIDEO_DECODER