umc_vc1_dec_mb_ppic_adv.cpp

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

    }

    return VC1_OK;

}

static VC1Status MBLayer_InterlacePpicture2MV(VC1Context* pContext)
{
    Ipp16s dmv_x =0;
    Ipp16s dmv_y =0;

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

    Ipp16s dmv_x_bottom =0;
    Ipp16s dmv_y_bottom =0;

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

    Ipp32s blk_num;
    Ipp32s BlkMVP;
    //VM_Debug::GetInstance().vm_debug_frame(-1,VC1_MV,VM_STRING("Interlace 2 MV\n"));

    BlkMVP = ((0 != ( (1 << 3) & pCurrMB->MVBP) ) ? 1 : 0);
    if (BlkMVP)
        DecodeMVDiff_Adv(pContext,&dmv_x,&dmv_y);
    else
    {
        dmv_x =0;
        dmv_y =0;
    }

    BlkMVP = ((0 != ( (1 << 1) & pCurrMB->MVBP) ) ? 1 : 0);

    if (BlkMVP)
        DecodeMVDiff_Adv(pContext,&dmv_x_bottom,&dmv_y_bottom);
    else
    {
        dmv_x_bottom = 0;
        dmv_y_bottom = 0;
    }
    PredictInterlace2MV_Field_Adv(pCurrMB, pMVx,pMVy,0, 0, sMB->widthMB);


    ApplyMVPredictionCalculate(pContext,&pMVx[0],&pMVy[0],dmv_x,dmv_y);
    ApplyMVPredictionCalculate(pContext,&pMVx[1],&pMVy[1],dmv_x_bottom,dmv_y_bottom);

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

        pCurrMB->m_pBlocks[blk_num].mv_bottom[0][0] = pMVx[1];
        pCurrMB->m_pBlocks[blk_num].mv_bottom[0][1] = pMVy[1];
    }

    return VC1_OK;
}

static VC1Status MBLayer_InterlacePpicture4MVField(VC1Context* pContext)
{
    Ipp16s dmv_x[4] = {0};
    Ipp16s dmv_y[4] = {0};
    Ipp32s blk_num;

    Ipp32s BlkMVP;
    Ipp16s X = 0;
    Ipp16s Y = 0;

    VC1MB* pCurrMB = pContext->m_pCurrMB;

    //VM_Debug::GetInstance().vm_debug_frame(-1,VC1_MV,VM_STRING("Interlace 4 MV Field\n"));

    for(blk_num = 0;  blk_num < VC1_NUM_OF_LUMA;  blk_num++)
    {
        BlkMVP = ((0 != ( (1 << (3 - blk_num)) & pCurrMB->MVBP) ) ? 1 : 0);

        if (BlkMVP)
        {
           DecodeMVDiff_Adv(pContext,&dmv_x[blk_num],&dmv_y[blk_num]);
        }
  }

    PredictInterlace4MVField_Adv(pContext);

    for(blk_num = 0;  blk_num < 2;  blk_num++)
    {

        CalculateInterlace4MV_TopField_Adv(&pContext->MVPred,&X, &Y, blk_num);

        ApplyMVPredictionCalculate(pContext,&X,&Y,dmv_x[blk_num],dmv_y[blk_num]);

        pCurrMB->m_pBlocks[blk_num].mv[0][0] = X;
        pCurrMB->m_pBlocks[blk_num].mv[0][1] = Y;
    }

    for(blk_num;  blk_num < VC1_NUM_OF_LUMA;  blk_num++)
    {
        CalculateInterlace4MV_BottomField_Adv(&pContext->MVPred,&X, &Y, blk_num);

        ApplyMVPredictionCalculate(pContext,&X,&Y,dmv_x[blk_num],dmv_y[blk_num]);

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

        pCurrMB->m_pBlocks[blk_num].mv_bottom[0][0] = X;
        pCurrMB->m_pBlocks[blk_num].mv_bottom[0][1] = Y;

        pCurrMB->m_pBlocks[blk_num - 2].mv_bottom[0][0] = X;
        pCurrMB->m_pBlocks[blk_num - 2].mv_bottom[0][1] = Y;
     }
    return VC1_OK;
}

static VC1Status MBLayer_InterlacePpicture4MV(VC1Context* pContext)
{
    Ipp16s dmv_x = 0;
    Ipp16s dmv_y = 0;
    Ipp32s blk_num;

    Ipp32s BlkMVP;

    Ipp16s X = 0;
    Ipp16s Y = 0;
    VC1MB* pCurrMB = pContext->m_pCurrMB;

    //VM_Debug::GetInstance().vm_debug_frame(-1,VC1_MV,VM_STRING("Interlace 4 MV\n"));

    PredictInterlace4MVFrame_Adv(pContext);
    for( blk_num = 0;  blk_num < VC1_NUM_OF_LUMA; blk_num++)
    {
        BlkMVP = ((0 != ( (1 << (3 - blk_num)) & pCurrMB->MVBP) ) ? 1 : 0);
        if (BlkMVP)
        {
            DecodeMVDiff_Adv(pContext,&dmv_x,&dmv_y);

        } else
        {
            dmv_x = 0;
            dmv_y = 0;
        }

        Calculate4MVFrame_Adv(&pContext->MVPred,&X,&Y,blk_num);
        ApplyMVPredictionCalculate(pContext, &X, &Y, dmv_x, dmv_y);

        pCurrMB->m_pBlocks[blk_num].mv[0][0] = X;
        pCurrMB->m_pBlocks[blk_num].mv[0][1] = Y;
    }
    // for correct Direct MB B frames
    pCurrMB->m_pBlocks[0].mv_bottom[0][0] = pCurrMB->m_pBlocks[2].mv[0][0];
    pCurrMB->m_pBlocks[0].mv_bottom[0][1] = pCurrMB->m_pBlocks[2].mv[0][1];
    return VC1_OK;
}

static VC1Status MBLayer_InterlaceFieldPpicture1MV(VC1Context* pContext)
{
    Ipp16s dmv_x = 0;
    Ipp16s dmv_y = 0;

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

    Ipp32s blk_num;
    Ipp16s X =0;
    Ipp16s Y = 0;
    Ipp8u predictor_flag = 0;

    //VM_Debug::GetInstance().vm_debug_frame(-1,VC1_MV,VM_STRING("Interlace 1 MV\n"));
    Field1MVPrediction(pContext);

    if (0 == picLayerHeader->NUMREF)
    {
        predictor_flag = (Ipp8u)(1 - picLayerHeader->REFFIELD);

        if(VC1_MB_Mode_PBFieldPic_MVData_Table[pContext->m_pSingleMB->MBMODEIndex])
              DecodeMVDiff_Adv(pContext,&dmv_x,&dmv_y);

#ifdef VC1_DEBUG_ON
        VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV_FIELD,VM_STRING("predictor_flag = %d\n"), predictor_flag);
#endif
        CalculateField1MVOneReferencePPic(pContext, &X, &Y);
        ApplyMVPredictionCalculateOneReference(picLayerHeader,&X,&Y,dmv_x,dmv_y,predictor_flag);
    }
    else
    {
        if(VC1_MB_Mode_PBFieldPic_MVData_Table[pContext->m_pSingleMB->MBMODEIndex])
            predictor_flag = DecodeMVDiff_TwoReferenceField_Adv(pContext,&dmv_x,&dmv_y);
#ifdef VC1_DEBUG_ON
        VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV_FIELD,VM_STRING("predictor_flag = %d\n"), predictor_flag);
#endif
        CalculateField1MVTwoReferencePPic(pContext, &X, &Y, &predictor_flag);
        ApplyMVPredictionCalculateTwoReference(picLayerHeader,&X,&Y,dmv_x,dmv_y,predictor_flag);
    }


    for( blk_num = 0;  blk_num < VC1_NUM_OF_LUMA;  blk_num++)
    {
        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 - predictor_flag;
        pCurrMB->m_pBlocks[blk_num].fieldFlag[0] = pCurrMB->fieldFlag[0];
        pCurrMB->m_pBlocks[blk_num].fieldFlag[1] = pCurrMB->fieldFlag[1];
    }

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

}
static VC1Status MBLayer_InterlaceFieldPpicture4MV(VC1Context* pContext)
{
    Ipp16s dmv_x = 0;
    Ipp16s dmv_y = 0;
    Ipp32s blk_num;
    Ipp16s X =0;
    Ipp16s Y = 0;
    Ipp8u predictor_flag = 0;
    VC1MB* pCurrMB = pContext->m_pCurrMB;
    VC1PictureLayerHeader* picLayerHeader = pContext->m_picLayerHeader;

    Ipp32s BlkMVP;
    //VM_Debug::GetInstance().vm_debug_frame(-1,VC1_MV,VM_STRING("Interlace 1 MV\n"));
    if (0 == picLayerHeader->NUMREF && 0 == picLayerHeader->REFFIELD)
    {
            predictor_flag = 1;
    }


    Field4MVPrediction(pContext);
    for( blk_num = 0;  blk_num < VC1_NUM_OF_LUMA;  blk_num++)
    {
        BlkMVP = ((0 != ( (1 << (3 - blk_num)) & pCurrMB->MVBP) ) ? 1 : 0);
        if (0 == picLayerHeader->NUMREF)
        {
            if (BlkMVP)
                DecodeMVDiff_Adv(pContext,&dmv_x,&dmv_y);
            else
            {
                dmv_x = 0;
                dmv_y = 0;
            }

#ifdef VC1_DEBUG_ON
            VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV_FIELD,VM_STRING("predictor_flag = %d\n"),predictor_flag);
#endif
            CalculateField4MVOneReferencePPic(pContext,&X,&Y,blk_num);
            ApplyMVPredictionCalculateOneReference(picLayerHeader,&X,&Y,dmv_x,dmv_y,predictor_flag);
        }
        else
        {
            predictor_flag = 0;
            if (BlkMVP)
                predictor_flag = DecodeMVDiff_TwoReferenceField_Adv(pContext,&dmv_x,&dmv_y);
            else
            {
                dmv_x = 0;
                dmv_y = 0;
            }

#ifdef VC1_DEBUG_ON
            VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV_FIELD,VM_STRING("predictor_flag = %d\n"),predictor_flag);
#endif
            CalculateField4MVTwoReferencePPic(pContext, &X,&Y,blk_num,&predictor_flag);
            ApplyMVPredictionCalculateTwoReference(picLayerHeader,&X,&Y,dmv_x,dmv_y,predictor_flag);
        }

        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 - predictor_flag;

#ifdef VC1_DEBUG_ON
        VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV_FIELD,VM_STRING("\n\n"));
#endif
    }
    return VC1_OK;
}
//Progressive-coded P picture MB
VC1Status MBLayer_ProgressivePpicture_Adv(VC1Context* pContext)
{
    Ipp32s SKIPMBBIT;
    VC1MB* pCurrMB = pContext->m_pCurrMB;
    VC1SingletonMB* sMB = pContext->m_pSingleMB;
    VC1PictureLayerHeader* picLayerHeader = pContext->m_picLayerHeader;

    Ipp32s blk_num;
    VC1Status vc1Res=VC1_OK;

    //for smoothing
    pCurrMB->Overlap = (Ipp8u)pContext->m_seqLayerHeader->OVERLAP;
    if(picLayerHeader->PQUANT < 9)
           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);

    //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)*VC1_PIXEL_IN_BLOCK*VC1_PIXEL_IN_BLOCK*VC1_NUM_OF_BLOCKS);
    pCurrMB->FIELDTX = 0;

    for(blk_num = 0; blk_num < VC1_NUM_OF_BLOCKS; blk_num++)
        pCurrMB->m_pBlocks[blk_num].mv_s_polarity[0] = 0;

    pCurrMB->mbType = VC1_MB_1MV_INTER | VC1_MB_FORWARD;
    if(picLayerHeader->MVMODE == VC1_MVMODE_MIXED_MV)
    {
        Ipp32s MVMODEBIT;
        //is a 1-bit field present in P frame macroblocks
        //if the frame level field MVTYPEMB (see section 3.2.1.21)
        //indicates that the raw mode is used. If MVMODEBIT = 0
        //then the macroblock is coded in 1MV mode and if
        //MVMODEBIT = 1 then the macroblock is coded in 4MV mode.
        if (VC1_IS_BITPLANE_RAW_MODE(&picLayerHeader->MVTYPEMB))
        {
            VC1_GET_BITS(1, MVMODEBIT);