umc_vc1_dec_mb_bpic_adv.cpp

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

        VM_ASSERT(ret == ippStsNoErr);

        //MQUANT
        if (picLayerHeader->m_PQuant_mode>=VC1_ALTPQUANT_MB_LEVEL)
        {
            GetMQUANT(pContext);
        }
        DecodeTransformInfo(pContext);
    } // not last (intra or inter)
    return VC1_OK;
}

VC1Status MBLayer_ProgressiveBpicture_NONDIRECT_AdvPrediction(VC1Context* pContext)
{
    Ipp16s X = 0, Y = 0;

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

    switch (pCurrMB->mbType)
    {
    case (VC1_MB_1MV_INTER|VC1_MB_FORWARD):
        Progressive1MVPrediction(pContext);
        CalculateProgressive1MV_B_Adv(pContext,&X,&Y,0);

        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);
            //VM_Debug::GetInstance().vm_debug_frame(-1,VC1_MV,VM_STRING("AnothPred : MV_X  = %d, MV_Y  = %d\n"),X, Y);


            if ((Ipp16u)X!=VC1_MVINTRA)
            {
                Scale_Direct_MV(picLayerHeader,X,Y,&Xf,&Yf,&Xb,&Yb);
                PullBack_PPred(pContext, &Xb,&Yb,-1);
            }
            //VM_Debug::GetInstance().vm_debug_frame(-1,VC1_MV,VM_STRING("AnothPred : MV_X  = %d, MV_Y  = %d\n"),Xb, Yb);

            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_Adv(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)
            {
                Scale_Direct_MV(picLayerHeader,X,Y,&Xf,&Yf,&Xb,&Yb);
                PullBack_PPred(pContext, &Xf,&Yf,-1);
            }

            //VM_Debug::GetInstance().vm_debug_frame(-1,VC1_MV,VM_STRING("AnothPred : MV_X  = %d, MV_Y  = %d\n"),Xf, Yf);

            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_Adv(pContext,&X,&Y,0);
        ApplyMVPrediction(pContext, 0, &X, &Y, pCurrMB->dmv_x[0][0], pCurrMB->dmv_y[0][0],0);

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

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

    for (i=0;i<VC1_NUM_OF_BLOCKS;i++)
        pCurrMB->m_pBlocks[i].blkType = (Ipp8u)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,
        picLayerHeader->m_pCurrCBPCYtbl);

    VM_ASSERT(ret == ippStsNoErr);

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

    DecodeTransformInfo(pContext);
    return VC1_OK;
}

VC1Status MBLayer_ProgressiveBpicture_DIRECT_AdvPrediction(VC1Context* pContext)
{
    Ipp32s i;
    VC1MB* pCurrMB = pContext->m_pCurrMB;
    VC1SingletonMB* sMB = pContext->m_pSingleMB;
    Ipp16s* savedMV = pContext->savedMV_Curr +
                (sMB->widthMB*sMB->m_currMBYpos + sMB->m_currMBXpos)*4*2;

    VC1PictureLayerHeader* picLayerHeader = pContext->m_picLayerHeader;

    Ipp16s X,Y,Xf,Yf,Xb,Yb;

    CalculateMV(savedMV,savedMV+4, &X, &Y);
    if ((Ipp16u)X!=VC1_MVINTRA)
    {
        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 const B_MB_DECODE B_MB_Dispatch_table[] = {
        (B_MB_DECODE)(MBLayer_ProgressiveBpicture_NONDIRECT_AdvDecode),
        (B_MB_DECODE)(MBLayer_ProgressiveBpicture_SKIP_NONDIRECT_AdvDecode),
};

//vc-1: Figure 25: Syntax diagram for macroblock layer bitstream in
//Progressive-coded B picture
VC1Status MBLayer_ProgressiveBpicture_Adv(VC1Context* pContext)
{
    VC1MB* pCurrMB = pContext->m_pCurrMB;
    VC1SingletonMB* sMB = pContext->m_pSingleMB;
    VC1PictureLayerHeader* picLayerHeader = pContext->m_picLayerHeader;
    Ipp32s DIRECTBBIT=0;
    Ipp32s SKIPMBBIT=0;
    Ipp32s blk_num;
    VC1Status vc1Res = VC1_OK;
    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);
    pCurrMB->FIELDTX = 0;
    // 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 = 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_AdvDecode(pContext);
    else
        MBLayer_ProgressiveBpicture_SKIP_DIRECT_AdvDecode(pContext);
    STATISTICS_END_TIME(m_timeStatistics->motion_vector_decoding_StartTime,
                        m_timeStatistics->motion_vector_decoding_EndTime,
                        m_timeStatistics->motion_vector_decoding_TotalTime);


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

    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;

    if(SKIPMBBIT == 0)
    {
        if(pCurrMB->IntraFlag)
            PDCPredictionTable[pContext->m_seqLayerHeader->DQUANT](pContext);

        sMB->ZigzagTable = AdvZigZagTables_PBProgressive_luma[sMB->ACPRED];
        if(pCurrMB->m_pBlocks[0].blkType & VC1_BLK_INTER)
        {
            //luma
            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;
                }
            }
            //chroma
            sMB->ZigzagTable = AdvZigZagTables_PBProgressive_chroma[sMB->ACPRED];

            for(blk_num; blk_num < VC1_NUM_OF_BLOCKS; blk_num++)
            {
                vc1Res = BLKLayer_Inter_Chroma_Adv(pContext, blk_num);
                if(vc1Res != VC1_OK)
                {
                    VM_ASSERT(0);
                    break;
                }
            }
        }
        else
        {
            for(blk_num = 0; blk_num < VC1_NUM_OF_LUMA; blk_num++)
            {
                //luma
                vc1Res = BLKLayer_Intra_Luma_Adv(pContext, blk_num, sMB->ACPRED);
                if(vc1Res != VC1_OK)
                {
                    VM_ASSERT(0);
                    break;
                }
            }

            //chroma
            sMB->ZigzagTable = AdvZigZagTables_PBProgressive_chroma[sMB->ACPRED];
            for(blk_num; blk_num < VC1_NUM_OF_BLOCKS; blk_num++)
            {
                vc1Res = BLKLayer_Intra_Chroma_Adv(pContext, blk_num, sMB->ACPRED);
                if(vc1Res != VC1_OK)
                {
                    VM_ASSERT(0);
                    break;
                }
            }
        }
    }

    return vc1Res;
}


static VC1Status MBLayer_InterlaceFrameBpicture_SKIP_NONDIRECT_Decode(VC1Context* pContext)
{
    Ipp32s i;
    VC1MB* pCurrMB = pContext->m_pCurrMB;
    pCurrMB->m_cbpBits = 0;
    pCurrMB->FIELDTX = 0;
    for (i=0;i<VC1_NUM_OF_BLOCKS;i++)
    {
        pCurrMB->m_pBlocks[i].blkType= VC1_BLK_INTER8X8;
    }

    Decode_InterlaceFrame_BMVTYPE(pContext); // FORWARD, BACKWARD OR INTER

    for (i=0;i<VC1_NUM_OF_BLOCKS;i++)
    {
        pCurrMB->m_pBlocks[i].blkType= VC1_BLK_INTER8X8;
    }
    return VC1_OK;
}

VC1Status MBLayer_InterlaceFrameBpicture_SKIP_NONDIRECT_Prediction(VC1Context* pContext)
{
    Ipp16s fX = 0, fY = 0, bX = 0, bY = 0;
    VC1MB* pCurrMB = pContext->m_pCurrMB;

    PredictInterlaceFrame1MV(pContext);
    switch (pCurrMB->mbType)
    {
    case(VC1_MB_1MV_INTER|VC1_MB_FORWARD):
        {
            CalculateInterlaceFrame1MV_B(&pContext->MVPred, &fX, &fY, &bX, &bY, 0);
            writeMV(pCurrMB,fX,fY,fX,fY,0);
            writeMV(pCurrMB,bX,bY,bX,bY,1);
        }
        break;

    case(VC1_MB_1MV_INTER|VC1_MB_BACKWARD):
        {
            CalculateInterlaceFrame1MV_B(&pContext->MVPred, &fX, &fY, &bX, &bY, 1);
            writeMV(pCurrMB,fX,fY,fX,fY,1);
            writeMV(pCurrMB,bX,bY,bX,bY,0);
      }
        break;

    case(VC1_MB_1MV_INTER|VC1_MB_INTERP):
        {
            CalculateInterlaceFrame1MV_B_Interpolate(&pContext->MVPred, &fX, &fY, &bX, &bY);
            writeMV(pCurrMB,fX,fY,fX,fY,0);
            writeMV(pCurrMB,bX,bY,bX,bY,1);

        }
        break;
    }
    return VC1_OK;

}

static VC1Status MBLayer_InterlaceFrameBpicture_SKIP_DIRECT_Decode(VC1Context* pContext)
{
    Ipp32s blk_num;
    VC1MB* pCurrMB = pContext->m_pCurrMB;

    pCurrMB->FIELDTX = 0;
    pCurrMB->m_cbpBits = 0;
    pCurrMB->mbType= VC1_MB_1MV_INTER|VC1_MB_DIRECT;