umc_vc1_dec_mb_ppic_adv.cpp

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

                    VM_ASSERT(ret == ippStsNoErr);

                    pCurrMB->MVBP = (((pCurrMB->MVBP & 2) << 2) | ((pCurrMB->MVBP & 1) << 1));


                    STATISTICS_START_TIME(m_timeStatistics->motion_vector_decoding_StartTime);

                    MBLayer_InterlacePpicture2MV(pContext);

                    STATISTICS_END_TIME(m_timeStatistics->motion_vector_decoding_StartTime,
                        m_timeStatistics->motion_vector_decoding_EndTime,
                        m_timeStatistics->motion_vector_decoding_TotalTime);
                }
                break;
            case VC1_MB_4MV_INTER:
                {
                    Ipp32s ret;
                    ret = ippiDecodeHuffmanOne_1u32s(&pContext->m_bitstream.pBitstream,
                        &pContext->m_bitstream.bitOffset,
                        &pCurrMB->MVBP,
                        picLayerHeader->m_pMV4BP);

                    VM_ASSERT(ret == ippStsNoErr);

                    STATISTICS_START_TIME(m_timeStatistics->motion_vector_decoding_StartTime);

                    MBLayer_InterlacePpicture4MV(pContext);

                    STATISTICS_END_TIME(m_timeStatistics->motion_vector_decoding_StartTime,
                        m_timeStatistics->motion_vector_decoding_EndTime,
                        m_timeStatistics->motion_vector_decoding_TotalTime);
                }
                break;
            case VC1_MB_4MV_FIELD_INTER:
                {
                    Ipp32s ret;
                    ret = ippiDecodeHuffmanOne_1u32s(&pContext->m_bitstream.pBitstream,
                        &pContext->m_bitstream.bitOffset,
                        &pCurrMB->MVBP,
                        picLayerHeader->m_pMV4BP);

                    VM_ASSERT(ret == ippStsNoErr);

                    STATISTICS_START_TIME(m_timeStatistics->motion_vector_decoding_StartTime);

                    MBLayer_InterlacePpicture4MVField(pContext);

                    STATISTICS_END_TIME(m_timeStatistics->motion_vector_decoding_StartTime,
                        m_timeStatistics->motion_vector_decoding_EndTime,
                        m_timeStatistics->motion_vector_decoding_TotalTime);
                }
                break;
            case VC1_MB_1MV_INTER:
                {
                    STATISTICS_START_TIME(m_timeStatistics->motion_vector_decoding_StartTime);

                    MBLayer_InterlacePpicture1MV(pContext);

                    STATISTICS_END_TIME(m_timeStatistics->motion_vector_decoding_StartTime,
                        m_timeStatistics->motion_vector_decoding_EndTime,
                        m_timeStatistics->motion_vector_decoding_TotalTime);
                }
                break;
            default:
                VM_ASSERT(0);
                break;
            }

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


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

            DecodeTransformInfo(pContext);
            CalculateIntraFlag(pContext);

            sMB->ZigzagTable = AdvZigZagTables_PBInterlace_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_PBInterlace_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;
                }
            }
       }

    }//SKIPBIT
    AssignCodedBlockPattern(pCurrMB,sMB);

    return vc1Res;
}

VC1Status MBLayer_Field_InterlacedPpicture(VC1Context* pContext)
{
    Ipp32s blk_num;
    VC1Status vc1Res=VC1_OK;
    VC1MB* pCurrMB = pContext->m_pCurrMB;
    VC1SingletonMB* sMB = pContext->m_pSingleMB;
    VC1PictureLayerHeader* picLayerHeader = pContext->m_picLayerHeader;

    Ipp32u currFieldMBYpos;
    Ipp32u currFieldMBXpos;
    Ipp32u ACPRED = 0;

    //for smoothing
    pCurrMB->Overlap = (Ipp8u)pContext->m_seqLayerHeader->OVERLAP;
    if(picLayerHeader->PQUANT < 9)
           pCurrMB->Overlap = 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 - picLayerHeader->CurrField*sMB->heightMB/2);
#endif

    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];
    pCurrMB->fieldFlag[0] = picLayerHeader->BottomField;
    pCurrMB->fieldFlag[1] = picLayerHeader->BottomField;
    memset(pContext->m_pBlock, 0, sizeof(Ipp16s)*8*8*VC1_NUM_OF_BLOCKS);

    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;

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

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

        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;

        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 intra
            vc1Res = BLKLayer_Intra_Chroma_Adv(pContext, blk_num,ACPRED);
            if(vc1Res != VC1_OK)
            {
                VM_ASSERT(0);
                break;
            }
        }
    }
    else
    {
        //inter

        pCurrMB->mbType |= VC1_MB_FORWARD;

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

       CalculateIntraFlag(pContext);


        if(VC1_GET_MBTYPE(pCurrMB->mbType) == VC1_MB_1MV_INTER)
        {
            STATISTICS_START_TIME(m_timeStatistics->motion_vector_decoding_StartTime);

            MBLayer_InterlaceFieldPpicture1MV(pContext);

            STATISTICS_END_TIME(m_timeStatistics->motion_vector_decoding_StartTime,
                m_timeStatistics->motion_vector_decoding_EndTime,
                m_timeStatistics->motion_vector_decoding_TotalTime);
        }
        else
        {
            //4MV
            Ipp32s ret;
            ret = ippiDecodeHuffmanOne_1u32s(&pContext->m_bitstream.pBitstream,
                                            &pContext->m_bitstream.bitOffset,
                                            &pCurrMB->MVBP,
                                            picLayerHeader->m_pMV4BP);
            VM_ASSERT(ret == ippStsNoErr);

            STATISTICS_START_TIME(m_timeStatistics->motion_vector_decoding_StartTime);

            MBLayer_InterlaceFieldPpicture4MV(pContext);

            STATISTICS_END_TIME(m_timeStatistics->motion_vector_decoding_StartTime,
                m_timeStatistics->motion_vector_decoding_EndTime,
                m_timeStatistics->motion_vector_decoding_TotalTime);
        }

        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;

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

        DecodeTransformInfo(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_VC_VIDEO1_DECODER