umc_vc1_dec_mb_bpic_adv.cpp

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

    for (blk_num=0;blk_num<VC1_NUM_OF_BLOCKS;blk_num++)
        pCurrMB->m_pBlocks[blk_num].blkType = (Ipp8u)pContext->m_picLayerHeader->TTFRM;
    return VC1_OK;
}
VC1Status MBLayer_InterlaceFrameBpicture_SKIP_DIRECT_Prediction(VC1Context* pContext)
{
    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;

    Ipp16s Xt,Yt, Xb, Yb;
    Ipp16s Xtopf,Ytopf,Xbottomf,Ybottomf;
    Ipp16s Xtopb,Ytopb,Xbottomb,Ybottomb;

    CalculateMV_Interlace(savedMV,savedMV+4, savedMV+8,savedMV+12,&Xt,&Yt,&Xb,&Yb);
    Scale_Direct_MV_Interlace(pContext->m_picLayerHeader,Xt,Yt,&Xtopf,&Ytopf,&Xtopb,&Ytopb);
    Scale_Direct_MV_Interlace(pContext->m_picLayerHeader,Xb,Yb,&Xbottomf,&Ybottomf,&Xbottomb,&Ybottomb);

    writeMV(pCurrMB,Xtopf,Ytopf,Xbottomf,Ybottomf,0);
    writeMV(pCurrMB,Xtopb,Ytopb,Xbottomb,Ybottomb,1);
    return VC1_OK;
}
static VC1Status MBLayer_InterlaceFrameBpicture_NONDIRECT_Decode(VC1Context* pContext)
{
    VC1MB* pCurrMB = pContext->m_pCurrMB;
    VC1SingletonMB* sMB = pContext->m_pSingleMB;
    VC1PictureLayerHeader* picLayerHeader = pContext->m_picLayerHeader;

    Ipp32s MVBP2 = 0;
    Ipp32s MVBP4 = 0;

    Ipp32s MVSW = 0;
    pCurrMB->MVSW = 0;
    Ipp32s i;
    Ipp32s ret = ippStsNoErr;

    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

    if((VC1_IS_MVFIELD(pCurrMB->mbType)) && (VC1_GET_PREDICT(pCurrMB->mbType)!=VC1_MB_INTERP))
    {
        //MVSW
        //If MVSW == 1, then it shall indicate that the MV type and
        //prediction type changes from forward to backward (or backward
        //to forward) in going from the top to the bottom field. If MVSW == 0,
        //then the prediction type shall not change in going from the top
        //to the bottom field.
        VC1_GET_BITS(1, MVSW);
        pCurrMB->MVSW = MVSW;
    }

    if(VC1_MB_Mode_PBPic_Transform_Table[sMB->MBMODEIndex]!= VC1_NO_CBP_TRANSFORM)
    {
        //CBPCY
        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;
    }


    if((VC1_IS_MVFIELD(pCurrMB->mbType)) &&(VC1_GET_PREDICT(pCurrMB->mbType)!=VC1_MB_INTERP)
        || (((VC1_GET_MBTYPE(pCurrMB->mbType) == VC1_MB_1MV_INTER)
                    && (VC1_GET_PREDICT(pCurrMB->mbType)==VC1_MB_INTERP))))
    {
        //2MVBP
        Ipp32s ret;
        ret = ippiDecodeHuffmanOne_1u32s(&pContext->m_bitstream.pBitstream,
                                        &pContext->m_bitstream.bitOffset,
                                        &MVBP2,
                                        picLayerHeader->m_pMV2BP);

        VM_ASSERT(ret == ippStsNoErr);
    }
    else if((VC1_IS_MVFIELD(pCurrMB->mbType))&& (pCurrMB->mbType&VC1_MB_INTERP))
    {
        //4MVBP
        Ipp32s ret;
        ret = ippiDecodeHuffmanOne_1u32s(&pContext->m_bitstream.pBitstream,
            &pContext->m_bitstream.bitOffset,
            &MVBP4,
            picLayerHeader->m_pMV4BP);

        VM_ASSERT(ret == ippStsNoErr);
    }


    //PredictInterlaceFrame1MV(pContext);

    switch (pCurrMB->mbType)
    {
    case(VC1_MB_1MV_INTER|VC1_MB_FORWARD):
        {
            pCurrMB->dmv_x[0][0] = 0;
            pCurrMB->dmv_y[0][0] = 0;
            if(VC1_MB_Mode_PBPic_MVPresent_Table[sMB->MBMODEIndex])
                DecodeMVDiff_Adv(pContext,&pCurrMB->dmv_x[0][0],&pCurrMB->dmv_y[0][0]);

        }
        break;

    case(VC1_MB_1MV_INTER|VC1_MB_BACKWARD):
        {
            pCurrMB->dmv_x[1][0] = 0;
            pCurrMB->dmv_y[1][0] = 0;

            if(VC1_MB_Mode_PBPic_MVPresent_Table[sMB->MBMODEIndex])
                DecodeMVDiff_Adv(pContext,&pCurrMB->dmv_x[1][0],&pCurrMB->dmv_y[1][0]);
        }
        break;

    case(VC1_MB_1MV_INTER|VC1_MB_INTERP):
        {
            pCurrMB->dmv_x[0][0] = 0;
            pCurrMB->dmv_y[0][0] = 0;
            pCurrMB->dmv_x[1][0] = 0;
            pCurrMB->dmv_y[1][0] = 0;


            if (MVBP2 & 2)
                DecodeMVDiff_Adv(pContext,&pCurrMB->dmv_x[0][0],&pCurrMB->dmv_y[0][0]);
            if (MVBP2 & 1)
                DecodeMVDiff_Adv(pContext,&pCurrMB->dmv_x[1][0],&pCurrMB->dmv_y[1][0]);
        }
        break;

    case(VC1_MB_2MV_INTER|VC1_MB_FORWARD):
        {


            pCurrMB->dmv_x[0][0] = 0;
            pCurrMB->dmv_y[0][0] = 0;
            pCurrMB->dmv_x[0][1] = 0;
            pCurrMB->dmv_y[0][1] = 0;

            if (MVBP2 & 2)
            {
                //calculate top field MV difference
                DecodeMVDiff_Adv(pContext,&pCurrMB->dmv_x[0][0],&pCurrMB->dmv_y[0][0]);
            }

            if (MVBP2 & 1)
            {

                //calculate botom field MV difference
                DecodeMVDiff_Adv(pContext,&pCurrMB->dmv_x[0][1],&pCurrMB->dmv_y[0][1]);
            }
        }
        break;

    case(VC1_MB_2MV_INTER|VC1_MB_BACKWARD):
        {
            pCurrMB->dmv_x[1][0] = 0;
            pCurrMB->dmv_y[1][0] = 0;
            pCurrMB->dmv_x[1][1] = 0;
            pCurrMB->dmv_y[1][1] = 0;

            if (MVBP2 & 2)
            {
                // calculate top field backward MV difference
                DecodeMVDiff_Adv(pContext,&pCurrMB->dmv_x[1][0],&pCurrMB->dmv_y[1][0]);
            }
            if (MVBP2 & 1)
            {
                // calculate bottom field backward MV difference
                DecodeMVDiff_Adv(pContext,&pCurrMB->dmv_x[1][1],&pCurrMB->dmv_y[1][1]);
            }

        }
        break;
    case(VC1_MB_2MV_INTER|VC1_MB_INTERP):
        {
            pCurrMB->dmv_x[0][0] = 0;
            pCurrMB->dmv_y[0][0] = 0;
            pCurrMB->dmv_x[0][1] = 0;
            pCurrMB->dmv_y[0][1] = 0;

            pCurrMB->dmv_x[1][0] = 0;
            pCurrMB->dmv_y[1][0] = 0;
            pCurrMB->dmv_x[1][1] = 0;
            pCurrMB->dmv_y[1][1] = 0;

            //calculate top field MV difference
            if (MVBP4 & 8)
            {
                // calculate top field forward MV difference
                DecodeMVDiff_Adv(pContext,&pCurrMB->dmv_x[0][0],&pCurrMB->dmv_y[0][0]);
            }
            if (MVBP4 & 4)
            {
                // calculate top field backward MV difference
                DecodeMVDiff_Adv(pContext,&pCurrMB->dmv_x[1][0],&pCurrMB->dmv_y[1][0]);
            }

            //calculate botom field MV difference
            if (MVBP4 & 2)
            {
                // calculate bottom field forward MV difference
                DecodeMVDiff_Adv(pContext,&pCurrMB->dmv_x[0][1],&pCurrMB->dmv_y[0][1]);
            }

            if (MVBP4 & 1)
            {
                // calculate bottom field backward MV difference
                DecodeMVDiff_Adv(pContext,&pCurrMB->dmv_x[1][1],&pCurrMB->dmv_y[1][1]);
            }
        }
        break;
    }

    return VC1_OK;
}
VC1Status MBLayer_InterlaceFrameBpicture_NONDIRECT_Prediction(VC1Context* pContext)
{
    VC1MB* pCurrMB = pContext->m_pCurrMB;
    VC1SingletonMB* sMB = pContext->m_pSingleMB;

    Ipp16s fX = 0, fY = 0;
    Ipp16s bX = 0, bY = 0;

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

            ApplyMVPredictionCalculate(pContext,&fX,&fY,pCurrMB->dmv_x[0][0],pCurrMB->dmv_y[0][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);
            ApplyMVPredictionCalculate(pContext,&fX,&fY,pCurrMB->dmv_x[1][0],pCurrMB->dmv_y[1][0]);
            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);
            ApplyMVPredictionCalculate(pContext,&fX,&fY,pCurrMB->dmv_x[0][0],pCurrMB->dmv_y[0][0]);
            writeMV(pCurrMB,fX,fY,fX,fY,0);
            ApplyMVPredictionCalculate(pContext,&bX,&bY,pCurrMB->dmv_x[1][0],pCurrMB->dmv_y[1][0]);
            writeMV(pCurrMB,bX,bY,bX,bY,1);
        }
        break;

    case(VC1_MB_2MV_INTER|VC1_MB_FORWARD):
        {

            Ipp16s pMVx[2] = {0,0}; //0 - top, 1 - bottom
            Ipp16s pMVy[2] = {0,0};

            if (pCurrMB->MVSW)
            {
                PredictInterlace2MV_Field_Adv(pCurrMB,
                                        pMVx,pMVy,0, 1, pContext->m_seqLayerHeader->widthMB);
                ApplyMVPredictionCalculate(pContext,&pMVx[0],&pMVy[0],pCurrMB->dmv_x[0][0],pCurrMB->dmv_y[0][0]);
                ApplyMVPredictionCalculate(pContext,&pMVx[1],&pMVy[1],pCurrMB->dmv_x[0][1],pCurrMB->dmv_y[0][1]);
                writeMV(pCurrMB,pMVx[0],pMVy[0],pMVx[0],pMVy[0],0);
                writeMV(pCurrMB,pMVx[1],pMVy[1],pMVx[1],pMVy[1],1);

            }
            else
            {
                PredictInterlace2MV_Field_Adv(pCurrMB,
                                        pMVx,pMVy,0, 0, pContext->m_seqLayerHeader->widthMB);
                ApplyMVPredictionCalculate(pContext,&pMVx[0],&pMVy[0],pCurrMB->dmv_x[0][0],pCurrMB->dmv_y[0][0]);
                ApplyMVPredictionCalculate(pContext,&pMVx[1],&pMVy[1],pCurrMB->dmv_x[0][1],pCurrMB->dmv_y[0][1]);
                writeMV(pCurrMB,pMVx[0],pMVy[0],pMVx[1],pMVy[1],0);
                PredictInterlace2MV_Field_Adv(pCurrMB,  pMVx,pMVy,1, 1, sMB->widthMB);
                writeMV(pCurrMB,pMVx[0],pMVy[0],pMVx[1],pMVy[1],1);
            }
        }
        break;

    case(VC1_MB_2MV_INTER|VC1_MB_BACKWARD):
        {
            Ipp16s pMVx[2] = {0,0}; //0 - top, 1 - bottom
            Ipp16s pMVy[2] = {0,0};

            if (pCurrMB->MVSW)
            {
                PredictInterlace2MV_Field_Adv(pCurrMB,
                                        pMVx,pMVy,1, 0, sMB->widthMB);

                ApplyMVPredictionCalculate(pContext,&pMVx[0],&pMVy[0],pCurrMB->dmv_x[1][0],pCurrMB->dmv_y[1][0]);
                ApplyMVPredictionCalculate(pContext,&pMVx[1],&pMVy[1],pCurrMB->dmv_x[1][1],pCurrMB->dmv_y[1][1]);
                writeMV(pCurrMB,pMVx[0],pMVy[0],pMVx[0],pMVy[0],1);
                writeMV(pCurrMB,pMVx[1],pMVy[1],pMVx[1],pMVy[1],0);

            }
            else
            {
                PredictInterlace2MV_Field_Adv(pCurrMB, pMVx,pMVy,1, 1, sMB->widthMB);


                ApplyMVPredictionCalculate(pContext,&pMVx[0],&pMVy[0],pCurrMB->dmv_x[1][0],pCurrMB->dmv_y[1][0]);
                ApplyMVPredictionCalculate(pContext,&pMVx[1],&pMVy[1],pCurrMB->dmv_x[1][1],pCurrMB->dmv_y[1][1]);
                writeMV(pCurrMB,pMVx[0],pMVy[0],pMVx[1],pMVy[1],1);
                PredictInterlace2MV_Field_Adv(pCurrMB, pMVx,pMVy,0, 0, sMB->widthMB);
                writeMV(pContext->m_pCurrMB,pMVx[0],pMVy[0],pMVx[1],pMVy[1],0);
            }
        }
        break;
    case(VC1_MB_2MV_INTER|VC1_MB_INTERP):
        {
            Ipp16s pMVx[2] = {0,0}; //0 - top, 1 - bottom
            Ipp16s pMVy[2] = {0,0};

            PredictInterlace2MV_Field_Adv(pCurrMB,
                                    pMVx,pMVy,1, 1, pContext->m_seqLayerHeader->widthMB);
            ApplyMVPredictionCalculate(pContext,&pMVx[0],&pMVy[0],pCurrMB->dmv_x[1][0],pCurrMB->dmv_y[1][0]);
            ApplyMVPredictionCalculate(pContext,&pMVx[1],&pMVy[1],pCurrMB->dmv_x[1][1],pCurrMB->dmv_y[1][1]);
            writeMV(pCurrMB,pMVx[0],pMVy[0],pMVx[1],pMVy[1],1);
            PredictInterlace2MV_Field_Adv(pCurrMB,
                                    pMVx,pMVy,0, 0, pContext->m_seqLayerHeader->widthMB);
            ApplyMVPredictionCalculate(pContext,&pMVx[0],&pMVy[0],pCurrMB->dmv_x[0][0],pCurrMB->dmv_y[0][0]);
            ApplyMVPredictionCalculate(pContext,&pMVx[1],&pMVy[1],pCurrMB->dmv_x[0][1],pCurrMB->dmv_y[0][1]);
            writeMV(pCurrMB,pMVx[0],pMVy[0],pMVx[1],pMVy[1],0);
        }
        break;
    }

    return VC1_OK;
}
static VC1Status MBLayer_InterlaceFrameBpicture_DIRECT_Decode(VC1Context* pContext)
{
    VC1SingletonMB* sMB = pContext->m_pSingleMB;
    VC1MB* pCurrMB = pContext->m_pCurrMB;
    Ipp32s blk_num;
    Ipp32s ret = ippStsNoErr;

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

    if(VC1_MB_Mode_PBPic_Transform_Table[sMB->MBMODEIndex]!= VC1_NO_CBP_TRANSFORM)
    {
        //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 VC1_OK;
}
VC1Status MBLayer_InterlaceFrameBpicture_DIRECT_Prediction(VC1Context* pContext)
{