umc_vc1_dec_mv_adv.cpp

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

/* /////////////////////////////////////////////////////////////////////////////
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//          Copyright(c) 2004-2007 Intel Corporation. All Rights Reserved.
//
//
//          VC-1 (VC1) MV decoding
//
*/

#include "umc_defs.h"

#if defined (UMC_ENABLE_VC1_VIDEO_DECODER)

#include "umc_vc1_dec_seq.h"
#include "umc_vc1_dec_debug.h"
#include "umc_vc1_common_mvdiff_tbl.h"

void save_MV_InterlaceField(VC1Context* pContext)
{
    Ipp32s blk_num = 0;
    VC1MB* pCurrMB = pContext->m_pCurrMB;
    VC1SingletonMB* sMB = pContext->m_pSingleMB;

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

      pContext->savedMV[(sMB->widthMB * sMB->m_currMBYpos + sMB->m_currMBXpos)*4*2*2 +blk_num]
                                                            = pCurrMB->m_pBlocks[blk_num].mv[0][0];
      pContext->savedMV[(sMB->widthMB * sMB->m_currMBYpos + sMB->m_currMBXpos)*4*2*2 + blk_num + 4]
                                                            = pCurrMB->m_pBlocks[blk_num].mv[0][1];
      pContext->savedMVSamePolarity[(sMB->widthMB * sMB->m_currMBYpos + sMB->m_currMBXpos)*4 +blk_num]
                                                            = pCurrMB->m_pBlocks[blk_num].mv_s_polarity[0];
    }
}

void save_MV_InterlaceFrame(VC1Context* pContext)
{
    Ipp32s blk_num = 0;
    VC1SingletonMB* sMB = pContext->m_pSingleMB;
    VC1MB* pCurrMB = pContext->m_pCurrMB;

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

        pContext->savedMV[(sMB->widthMB * sMB->m_currMBYpos + sMB->m_currMBXpos)*4*2*2 +blk_num]
                                                                = pCurrMB->m_pBlocks[blk_num].mv[0][0];
        pContext->savedMV[(sMB->widthMB * sMB->m_currMBYpos + sMB->m_currMBXpos)*4*2*2 +blk_num+4]
                                                                = pCurrMB->m_pBlocks[blk_num].mv[0][1];
        pContext->savedMV[(sMB->widthMB * sMB->m_currMBYpos + sMB->m_currMBXpos)*4*2*2 +blk_num+8]
                                                                = pCurrMB->m_pBlocks[blk_num].mv_bottom[0][0];
        pContext->savedMV[(sMB->widthMB * sMB->m_currMBYpos + sMB->m_currMBXpos)*4*2*2 +blk_num+12]
                                                                = pCurrMB->m_pBlocks[blk_num].mv_bottom[0][1];
    }
}
void ApplyMVPredictionCalculate( VC1Context* pContext,
                                Ipp16s* pMVx,
                                Ipp16s* pMVy,
                                Ipp32s dmv_x,
                                Ipp32s dmv_y)
{
    const VC1MVRange *pMVRange = pContext->m_picLayerHeader->m_pCurrMVRangetbl;
    Ipp32s RangeX, RangeY;
    Ipp32s DMV_X, DMV_Y;
    Ipp32s PredictorX, PredictorY;
    Ipp16s MVx, MVy;

    RangeX = pMVRange->r_x;
    RangeY = pMVRange->r_y;

    DMV_X = dmv_x;
    DMV_Y = dmv_y;

    PredictorX = *pMVx;
    PredictorY = *pMVy;
#ifdef VC1_DEBUG_ON
    VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV,
        VM_STRING("DMV_X  = %d, DMV_Y  = %d, PredictorX = %d, PredictorY = %d\n"),
        DMV_X, DMV_Y, PredictorX,PredictorY);
#endif
    DMV_X += PredictorX;
    DMV_Y += PredictorY;
#ifdef VC1_DEBUG_ON
    VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV,
        VM_STRING("DMV_X  = %d, DMV_Y  = %d, RangeX = %d, RangeY = %d\n"),
        DMV_X, DMV_Y, RangeX,RangeY);
#endif
    MVx = (Ipp16s)( ((DMV_X + RangeX) & ( (RangeX << 1) - 1)) - RangeX );
    MVy = (Ipp16s)( ((DMV_Y + RangeY) & ( (RangeY << 1) - 1)) - RangeY);

    *pMVx = MVx;
    *pMVy = MVy;
#ifdef VC1_DEBUG_ON
    VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV,
        VM_STRING("ApplyPred : MV_X  = %d, MV_Y  = %d\n"),MVx, MVy);
#endif
}


void ApplyMVPredictionCalculateOneReference( VC1PictureLayerHeader* picLayerHeader,
                                             Ipp16s* pMVx, Ipp16s* pMVy,
                                             Ipp32s dmv_x,  Ipp32s dmv_y, Ipp8u same_polatity)
{
    const VC1MVRange *pMVRange = picLayerHeader->m_pCurrMVRangetbl;
    Ipp32s RangeX, RangeY;
    Ipp32s DMV_X, DMV_Y;
    Ipp32s PredictorX, PredictorY;
    Ipp16s MVx, MVy;

    RangeX = pMVRange->r_x;
    RangeY = pMVRange->r_y;

    DMV_X = dmv_x;
    DMV_Y = dmv_y;

    PredictorX = *pMVx;
    PredictorY = *pMVy;

    if (picLayerHeader->MVMODE==VC1_MVMODE_HPELBI_1MV
        || picLayerHeader->MVMODE==VC1_MVMODE_HPEL_1MV)
    {
        RangeX  = RangeX << 1;
        RangeY  = RangeY << 1;
    }

    if (picLayerHeader->NUMREF == 1)
    {
        RangeY  = RangeY >> 1;
    }

    #ifdef VC1_DEBUG_ON
    VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV,
        VM_STRING("DMV_X  = %d, DMV_Y  = %d, PredictorX = %d, PredictorY = %d\n"),
        DMV_X, DMV_Y, PredictorX,PredictorY);
    #endif
    DMV_X += PredictorX;
    DMV_Y += PredictorY;
    #ifdef VC1_DEBUG_ON
    VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV,
        VM_STRING("DMV_X  = %d, DMV_Y  = %d, RangeX = %d, RangeY = %d\n"),
        DMV_X, DMV_Y, RangeX,RangeY);
    #endif

    //MVx = (Ipp16s)( ((DMV_X + RangeX) & (2 * RangeX - 1)) - RangeX );
    //MVy = (Ipp16s)( ((DMV_Y + RangeY) & (2 * RangeY - 1)) - RangeY);
    MVx = (Ipp16s)( ((DMV_X + RangeX) & ( (RangeX << 1) - 1)) - RangeX );
    MVy = (Ipp16s)( ((DMV_Y + RangeY) & ( (RangeY << 1) - 1)) - RangeY);

    if ( same_polatity && (picLayerHeader->BottomField))
        //MVy = (Ipp16s)( ( ((DMV_Y + RangeY - 1) & (2 * RangeY - 1)) - RangeY )+1);
        MVy = (Ipp16s)( ( ((DMV_Y + RangeY - 1) & ( (RangeY << 1) - 1)) - RangeY )+1);

    *pMVx = MVx;
    *pMVy = MVy;
#ifdef VC1_DEBUG_ON
    VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV,
        VM_STRING("ApplyPred : MV_X  = %d, MV_Y  = %d\n"),MVx, MVy);
#endif
}

void ApplyMVPredictionCalculateTwoReference( VC1PictureLayerHeader* picLayerHeader,
                                             Ipp16s* pMVx,
                                             Ipp16s* pMVy,
                                             Ipp32s dmv_x,
                                             Ipp32s dmv_y,
                                             Ipp8u same_polatity)
{
    const VC1MVRange *pMVRange = picLayerHeader->m_pCurrMVRangetbl;
    Ipp32s RangeX, RangeY;
    Ipp32s DMV_X, DMV_Y;
    Ipp32s PredictorX, PredictorY;
    Ipp16s MVx, MVy;

    RangeX = pMVRange->r_x;
    RangeY = pMVRange->r_y;

    DMV_X = dmv_x;
    DMV_Y = dmv_y;

    PredictorX = *pMVx;
    PredictorY = *pMVy;


    if (picLayerHeader->MVMODE==VC1_MVMODE_HPELBI_1MV
        || picLayerHeader->MVMODE==VC1_MVMODE_HPEL_1MV)
    {
        RangeX  = RangeX << 1;
        RangeY  = RangeY << 1;
    }

    if (picLayerHeader->NUMREF == 1)
    {
        RangeY  = RangeY >> 1;
    }

#ifdef VC1_DEBUG_ON
    VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV,
        VM_STRING("DMV_X  = %d, DMV_Y  = %d, PredictorX = %d, PredictorY = %d\n"),
        DMV_X, DMV_Y, PredictorX,PredictorY);
#endif
    DMV_X += PredictorX;
    DMV_Y += PredictorY;
#ifdef VC1_DEBUG_ON
    VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV,
        VM_STRING("DMV_X  = %d, DMV_Y  = %d, RangeX = %d, RangeY = %d\n"),
        DMV_X, DMV_Y, RangeX,RangeY);
#endif

    MVx = (Ipp16s)( ((DMV_X + RangeX) & ((RangeX << 1) - 1)) - RangeX );
    MVy = (Ipp16s)( ((DMV_Y + RangeY) & ((RangeY << 1) - 1)) - RangeY);

    if ( same_polatity && (picLayerHeader->BottomField))
        MVy = (Ipp16s)( ( ((DMV_Y - 1 + RangeY ) & ((RangeY << 1) - 1)) - RangeY )+1);

    *pMVx = MVx;
    *pMVy = MVy;
#ifdef VC1_DEBUG_ON
    VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_MV,
        VM_STRING("ApplyPred : MV_X  = %d, MV_Y  = %d\n"),MVx, MVy);
#endif
}

void CropLumaPullBack_Adv(VC1Context* pContext, Ipp16s* xMV, Ipp16s* yMV)
{
    Ipp32s X = *xMV;
    Ipp32s Y = *yMV;
    Ipp32s xNum;
    Ipp32s yNum;
    Ipp32s IX = pContext->m_pSingleMB->m_currMBXpos;
    Ipp32s IY = pContext->m_pSingleMB->m_currMBYpos;

    Ipp32s Width  = (2*(pContext->m_seqLayerHeader->MAX_CODED_WIDTH+1));
    Ipp32s Height = (2*(pContext->m_seqLayerHeader->MAX_CODED_HEIGHT+1) >> 1);

    xNum = (IX<<4) + (X >> 2);
    yNum = (IY<<3) + (Y >> 3);

    if (xNum < -17)
    {
        X -= ((xNum +17) << 2);
    }
    else if (xNum > Width)
    {
        X -= ((xNum -Width) << 2);

    }

    if (yNum < -18)
    {
        Y -= ((yNum+18) << 3);
    }
    else if (yNum > Height+1)
    {
        Y -= ((yNum-Height-1) << 3);
    }

    (*xMV) = (Ipp16s)X;
    (*yMV) = (Ipp16s)Y;

}
void CropLumaPullBackField_Adv(VC1Context* pContext, Ipp16s* xMV, Ipp16s* yMV)
{
    Ipp32s X = *xMV;
    Ipp32s Y = *yMV;
    Ipp32s xNum;
    Ipp32s yNum;
    Ipp32s IX = pContext->m_pSingleMB->m_currMBXpos;
    Ipp32s IY = pContext->m_pSingleMB->m_currMBYpos;

    Ipp32s Width  = ((pContext->m_seqLayerHeader->MAX_CODED_WIDTH+1) << 1);
    Ipp32s Height = (pContext->m_seqLayerHeader->MAX_CODED_HEIGHT+1);


    if (pContext->m_picLayerHeader->CurrField)
        IY  -= (pContext->m_seqLayerHeader->heightMB >> 1);

    IY = IY << 1;
    Y  = Y << 1;

    xNum = (IX<<4) + (X >> 2);
    yNum = (IY<<3) + (Y >> 3);

    if (xNum < -17)
    {
        X -= 4*(xNum +17);
    }
    else if (xNum > Width)
    {
        X -= 4*(xNum -Width);
    }

    if (yNum < -18)
    {
        Y -= 8*(yNum+18);
    }
    else if (yNum > Height+1)
    {
        Y -= 8*(yNum-Height-1);
    }
    Y = Y >> 1;

    (*xMV) = (Ipp16s)X;
    (*yMV) = (Ipp16s)Y;

}
void CropChromaPullBack_Adv(VC1Context* pContext, Ipp16s* xMV, Ipp16s* yMV)
{
    Ipp32s X = *xMV;
    Ipp32s Y = *yMV;
    Ipp32s XPos;
    Ipp32s YPos;
    Ipp32s IX = pContext->m_pSingleMB->m_currMBXpos;
    Ipp32s IY = pContext->m_pSingleMB->m_currMBYpos;

    Ipp32s Width  = (pContext->m_seqLayerHeader->MAX_CODED_WIDTH+1);
    Ipp32s Height = ((pContext->m_seqLayerHeader->MAX_CODED_HEIGHT+1) >> 1);


    Ipp32s MinY = -8;
    Ipp32s MaxY = Height;

    if (pContext->m_picLayerHeader->CurrField)
        IY  -= (pContext->m_pSingleMB->heightMB >> 1);

    if (pContext->m_picLayerHeader->FCM == VC1_FieldInterlace)
    {
        --MinY;
        ++MaxY;
        IY = IY << 1;
        Y  = Y  << 1;
    }

    XPos = (IX<<3) + (X >> 2);
    YPos = (IY<<2) + (Y >> 3);

    if (XPos < -8)
    {
        X -= 4*(XPos+8);
    }
    else if (XPos > Width)
    {
        X -= ((XPos-Width) << 2);
    }

    if (YPos < -8)
    {
        Y -= 8*(YPos+8);
    }
    else if (YPos > Height)
    {
        Y -= ((YPos-Height) << 3);
    }

    if (pContext->m_picLayerHeader->FCM == VC1_FieldInterlace)
    {
       Y = Y >> 1;
    }
    *xMV = (Ipp16s)X;
    *yMV = (Ipp16s)Y;

    pContext->m_pCurrMB->m_pBlocks[4].mv[0][0] = *xMV;
    pContext->m_pCurrMB->m_pBlocks[4].mv[0][1] = *yMV;
    pContext->m_pCurrMB->m_pBlocks[5].mv[0][0] = *xMV;
    pContext->m_pCurrMB->m_pBlocks[5].mv[0][1] = *yMV;
}

void CalculateProgressive1MV_B_Adv  (VC1Context* pContext,
                                Ipp16s *pPredMVx,Ipp16s *pPredMVy,
                                Ipp32s Back)
{
    Ipp16s x=0,y=0;

    VC1SingletonMB* sMB = pContext->m_pSingleMB;
    VC1MVPredictors* MVPred = &pContext->MVPred;

    GetPredictProgressiveMV(MVPred->AMVPred[0],
                            MVPred->BMVPred[0],
                            MVPred->CMVPred[0],
                            &x,&y,Back);

#ifdef VC1_DEBUG_ON
    VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_BFRAMES,
        VM_STRING("predict MV (%d,%d), back = %d\n"),x,y,Back);
#endif