umc_vc1_dec_mv_com.cpp

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

                MVcount = MVTcount;
                xLuMV = xLuMVT;
                yLuMV = yLuMVT;
                pContext->m_pCurrMB->m_pBlocks[0].fieldFlag[0] = 0;
            }
            Derive4MV_Field(MVcount,X,Y,xLuMV,yLuMV);
    }
     pContext->m_pCurrMB->m_pBlocks[1].mv_s_polarity[0] = pContext->m_pCurrMB->m_pBlocks[0].mv_s_polarity[0];
     pContext->m_pCurrMB->m_pBlocks[2].mv_s_polarity[0] = pContext->m_pCurrMB->m_pBlocks[0].mv_s_polarity[0];
     pContext->m_pCurrMB->m_pBlocks[3].mv_s_polarity[0] = pContext->m_pCurrMB->m_pBlocks[0].mv_s_polarity[0];
     pContext->m_pCurrMB->m_pBlocks[1].mv_s_polarity[1] = pContext->m_pCurrMB->m_pBlocks[0].mv_s_polarity[0];
     pContext->m_pCurrMB->m_pBlocks[2].mv_s_polarity[1] = pContext->m_pCurrMB->m_pBlocks[0].mv_s_polarity[0];
     pContext->m_pCurrMB->m_pBlocks[3].mv_s_polarity[1] = pContext->m_pCurrMB->m_pBlocks[0].mv_s_polarity[0];

     pContext->m_pCurrMB->m_pBlocks[1].fieldFlag[0] =  pContext->m_pCurrMB->m_pBlocks[0].fieldFlag[0];
     pContext->m_pCurrMB->m_pBlocks[2].fieldFlag[0] =  pContext->m_pCurrMB->m_pBlocks[0].fieldFlag[0];
     pContext->m_pCurrMB->m_pBlocks[3].fieldFlag[0] =  pContext->m_pCurrMB->m_pBlocks[0].fieldFlag[0];
     pContext->m_pCurrMB->m_pBlocks[1].fieldFlag[1] =  pContext->m_pCurrMB->m_pBlocks[0].fieldFlag[0];
     pContext->m_pCurrMB->m_pBlocks[2].fieldFlag[1] =  pContext->m_pCurrMB->m_pBlocks[0].fieldFlag[0];
     pContext->m_pCurrMB->m_pBlocks[3].fieldFlag[1] =  pContext->m_pCurrMB->m_pBlocks[0].fieldFlag[0];

}

void Decode_BMVTYPE(VC1Context* pContext)
{
    Ipp32s value=0;
    VC1_GET_BITS(1, value);
    if (value)
    {
        VC1_GET_BITS(1, value);
        if (value)
        {
            pContext->m_pCurrMB->mbType=VC1_MB_1MV_INTER|VC1_MB_INTERP;
        }
        else
        {
            pContext->m_pCurrMB->mbType = (pContext->m_picLayerHeader->BFRACTION)?
                VC1_MB_1MV_INTER|VC1_MB_FORWARD:VC1_MB_1MV_INTER|VC1_MB_BACKWARD;
        }
    }
    else
    {
        pContext->m_pCurrMB->mbType=(pContext->m_picLayerHeader->BFRACTION)?
            VC1_MB_1MV_INTER|VC1_MB_BACKWARD:VC1_MB_1MV_INTER|VC1_MB_FORWARD;
    }
}

VC1Status MVRangeDecode(VC1Context* pContext)
{
    VC1PictureLayerHeader* picLayerHeader = pContext->m_picLayerHeader;

    if (pContext->m_seqLayerHeader->EXTENDED_MV == 1)
    {
        //Ipp32s MVRANGE;
        //0   256 128
        //10  512 256
        //110 2048 512
        //111 4096 1024

        VC1_GET_BITS(1, picLayerHeader->MVRANGE);

        if(picLayerHeader->MVRANGE)
        {
            VC1_GET_BITS(1, picLayerHeader->MVRANGE);
            if(picLayerHeader->MVRANGE)
            {
                VC1_GET_BITS(1, picLayerHeader->MVRANGE);
                picLayerHeader->MVRANGE += 1;
            }
            picLayerHeader->MVRANGE += 1;
        }
        picLayerHeader->m_pCurrMVRangetbl = &VC1_MVRangeTbl[picLayerHeader->MVRANGE];
    }
    else
    {
        picLayerHeader->m_pCurrMVRangetbl = &VC1_MVRangeTbl[0];
//#ifdef DXVA_SIM
        picLayerHeader->MVRANGE = 0;
//#endif
    }
    return VC1_OK;
}

VC1Status DMVRangeDecode(VC1Context* pContext)
{
    if(pContext->m_seqLayerHeader->EXTENDED_DMV == 1)
    {
        VC1_GET_BITS(1, pContext->m_picLayerHeader->DMVRANGE);
        if(pContext->m_picLayerHeader->DMVRANGE==0)
        {
            //binary code 0
            pContext->m_picLayerHeader->DMVRANGE = VC1_DMVRANGE_NONE;
        }
        else
        {
            VC1_GET_BITS(1, pContext->m_picLayerHeader->DMVRANGE);
            if(pContext->m_picLayerHeader->DMVRANGE==0)
            {
               //binary code 10
               pContext->m_picLayerHeader->DMVRANGE = VC1_DMVRANGE_HORIZONTAL_RANGE;
            }
            else
            {
                VC1_GET_BITS(1, pContext->m_picLayerHeader->DMVRANGE);
                if(pContext->m_picLayerHeader->DMVRANGE==0)
                {
                    //binary code 110
                    pContext->m_picLayerHeader->DMVRANGE = VC1_DMVRANGE_VERTICAL_RANGE;
                }
                else
                {
                    //binary code 111
                    pContext->m_picLayerHeader->DMVRANGE = VC1_DMVRANGE_HORIZONTAL_VERTICAL_RANGE;
                }
            }
        }
    }

    return VC1_OK;
}


void PullBack_PPred4MV(VC1SingletonMB* sMB, Ipp16s *pMVx, Ipp16s* pMVy, Ipp32s blk_num)
{
    Ipp32s Min=-28;
    Ipp32s X = *pMVx;
    Ipp32s Y = *pMVy;
    Ipp32s currMBXpos = sMB->m_currMBXpos<<6;
    Ipp32s currMBYpos = sMB->m_currMBYpos<<6;

    Ipp32u Xblk = ((blk_num&1) << 5);
    Ipp32u Yblk = ((blk_num&2) << 4);

    Ipp32s IX = currMBXpos + X + Xblk;
    Ipp32s IY = currMBYpos + Y + Yblk;

    Ipp32s Width  =(sMB->widthMB<<6) - 4;
    Ipp32s Height =(sMB->heightMB<<6) - 4;


    if (IX < Min)
    {
        X = Min - currMBXpos - Xblk;
    }
    else if (IX > Width)
    {
        X = Width - currMBXpos - Xblk;
    }

    if (IY < Min)
    {
        Y = Min - currMBYpos - Yblk;
    }
    else if (IY > Height)
    {
        Y = Height - currMBYpos - Yblk;
    }

    (*pMVx) = (Ipp16s)X;
    (*pMVy) = (Ipp16s)Y;
}

void Progressive1MVPrediction(VC1Context* pContext)
{
    VC1MVPredictors MVPred;
    VC1MB* pCurrMB = pContext->m_pCurrMB;
    VC1MB *pA = NULL, *pB = NULL, *pC = NULL;

    Ipp32u LeftTopRight = pCurrMB->LeftTopRightPositionFlag;
    Ipp32s width = pContext->m_pSingleMB->widthMB;

    memset(&MVPred,0,sizeof(VC1MVPredictors));

    if(LeftTopRight == VC1_COMMON_MB)
    {
        //all predictors are available
        pA = pCurrMB - width;
        pB = pCurrMB - width + 1;
        pC = pCurrMB - 1;

        MVPred.AMVPred[0] = &pA->m_pBlocks[2];
        MVPred.BMVPred[0] = &pB->m_pBlocks[2];
        MVPred.CMVPred[0] = &pC->m_pBlocks[1];
    }
    else if(VC1_IS_TOP_MB(LeftTopRight))
    {
        //A and B predictors are unavailable
        pC = pCurrMB - 1;

        MVPred.CMVPred[0] = &pC->m_pBlocks[1];
    }
    else if(VC1_IS_LEFT_MB(LeftTopRight))
    {
        //C predictor is unavailable
        pA = pCurrMB - width;
        pB = pCurrMB - width + 1;

        MVPred.AMVPred[0] = &pA->m_pBlocks[2];
        MVPred.BMVPred[0] = &pB->m_pBlocks[2];
    }
    else if(VC1_IS_RIGHT_MB(LeftTopRight))
    {
        //all predictors are available
        pA = pCurrMB - width;
        pB = pCurrMB - width - 1;
        pC = pCurrMB - 1;

        MVPred.AMVPred[0] = &pA->m_pBlocks[2];
        MVPred.BMVPred[0] = &pB->m_pBlocks[3];
        MVPred.CMVPred[0] = &pC->m_pBlocks[1];
    }
    else if(VC1_IS_TOP_RIGHT_MB(LeftTopRight))
    {
        pC = pCurrMB - 1;

        MVPred.CMVPred[0] = &pC->m_pBlocks[1];
    }
    memcpy(&pContext->MVPred,&MVPred,sizeof(VC1MVPredictors));
}


void Progressive4MVPrediction(VC1Context* pContext)
{
    VC1MVPredictors MVPred;
    VC1MB* pCurrMB = pContext->m_pCurrMB;
    VC1MB *pA = NULL, *pB0 = NULL,*pB1 = NULL, *pC = NULL;

    Ipp32u LeftTopRight = pCurrMB->LeftTopRightPositionFlag;
    Ipp32s width = pContext->m_pSingleMB->widthMB;

    memset(&MVPred,0,sizeof(VC1MVPredictors));

    if(LeftTopRight == VC1_COMMON_MB)
    {
        //all predictors are available
        pA  = pCurrMB - width;
        pB0 = pCurrMB - width - 1;
        pB1 = pCurrMB - width + 1;
        pC  = pCurrMB - 1;

        MVPred.AMVPred[0] = &pA->m_pBlocks[2];
        MVPred.BMVPred[0] = &pB0->m_pBlocks[3];
        MVPred.CMVPred[0] = &pC->m_pBlocks[1];
        MVPred.AMVPred[1] = &pA->m_pBlocks[3];
        MVPred.BMVPred[1] = &pB1->m_pBlocks[2];
        MVPred.CMVPred[2] = &pC->m_pBlocks[3];
    }
    else if(VC1_IS_TOP_MB(LeftTopRight))
    {
        pC = pCurrMB - 1;

        MVPred.CMVPred[0] = &pC->m_pBlocks[1];
        MVPred.CMVPred[2] = &pC->m_pBlocks[3];
    }
    else if(VC1_IS_LEFT_MB(LeftTopRight))
    {
        pA = pCurrMB - width;
        pB1 = pCurrMB - width + 1;

        MVPred.AMVPred[0] = &pA->m_pBlocks[2];
        MVPred.BMVPred[0] = &pA->m_pBlocks[3];
        MVPred.AMVPred[1] = &pA->m_pBlocks[3];
        MVPred.BMVPred[1] = &pB1->m_pBlocks[2];
    }
    else if (VC1_IS_RIGHT_MB(LeftTopRight))
    {
        pA = pCurrMB - width;
        pB0 = pCurrMB - width - 1;
        pC = pCurrMB - 1;

        MVPred.AMVPred[0] = &pA->m_pBlocks[2];
        MVPred.BMVPred[0] = &pB0->m_pBlocks[3];
        MVPred.CMVPred[0] = &pC->m_pBlocks[1];
        MVPred.AMVPred[1] = &pA->m_pBlocks[3];
        MVPred.BMVPred[1] = &pA->m_pBlocks[2];
        MVPred.CMVPred[2] = &pC->m_pBlocks[3];
    }
    else
    {
        if(VC1_IS_TOP_RIGHT_MB(LeftTopRight))
        {
            pC = pCurrMB - 1;

            MVPred.CMVPred[0] = &pC->m_pBlocks[1];
            MVPred.CMVPred[2] = &pC->m_pBlocks[3];
        }
        else if (VC1_IS_LEFT_RIGHT_MB(LeftTopRight))
        {
            pA = pCurrMB - width;

            MVPred.AMVPred[0] = &pA->m_pBlocks[2];
            MVPred.BMVPred[0] = &pA->m_pBlocks[3];
            MVPred.BMVPred[1] = &pA->m_pBlocks[2];
            MVPred.AMVPred[1] = &pA->m_pBlocks[3];
        }
    }

    MVPred.CMVPred[1] = &pCurrMB->m_pBlocks[0];
    MVPred.AMVPred[2] = &pCurrMB->m_pBlocks[0];
    MVPred.BMVPred[3] = &pCurrMB->m_pBlocks[0];

    MVPred.BMVPred[2] = &pCurrMB->m_pBlocks[1];
    MVPred.AMVPred[3] = &pCurrMB->m_pBlocks[1];

    MVPred.CMVPred[3] = &pCurrMB->m_pBlocks[2];

    memcpy(&pContext->MVPred,&MVPred,sizeof(VC1MVPredictors));
}

//void ApplyMVPrediction  ( VC1Context* pContext,
//                                 Ipp32s blk_num,
//                                 Ipp16s* pMVx, Ipp16s* pMVy,
//                                 Ipp16s dmv_x, Ipp16s dmv_y,
//                                 Ipp32s Backwards)
//{
//    const VC1MVRange *pMVRange = pContext->m_picLayerHeader->m_pCurrMVRangetbl;
//    Ipp16u RangeX, RangeY, YBias=0;
//    Ipp32s Count;
//    VC1MB *pMB = pContext->m_pCurrMB;
//    Ipp16s MVx, MVy;
//    RangeX = pMVRange->r_x;
//    RangeY = pMVRange->r_y;
//
//#ifdef VC1_DEBUG_ON
//    VM_Debug::GetInstance().vm_debug_frame(-1,VC1_MV,VM_STRING("PredictorX = %d, PredictorY = %d\n"),*pMVx,*pMVy);
//#endif
//
//    dmv_x = dmv_x + *pMVx;
//    dmv_y = dmv_y + *pMVy;
//
//#ifdef VC1_DEBUG_ON
////   VM_Debug::GetInstance().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
//
//    // (dmv_x + predictor_x) smod range_x
//    //MVx = ((DMV_X + RangeX) & (2 * RangeX - 1)) - RangeX;
//    MVx = ((dmv_x + RangeX) & ((RangeX << 1) - 1)) - RangeX;
//
//    // (dmv_y + predictor_y) smod range_y
//    //MVy = ((DMV_Y + RangeY - YBias) & (2 * RangeY - 1)) - RangeY + YBias;
//    MVy = ((dmv_y + RangeY - YBias) & ( (RangeY <<1) - 1)) - RangeY + YBias;
//
//    if((pMB->mbType&0x03) == VC1_MB_1MV_INTER)
//    {
//        for(Count = 0; Count < 4; Count++)
//        {
//            pMB->m_pBlocks[Count].mv[Backwards][0] = (Ipp16s)MVx;
//            pMB->m_pBlocks[Count].mv[Backwards][1] = (Ipp16s)MVy;
//        }
//    }
//    else if((pMB->mbType&0x03) == VC1_MB_2MV_INTER)
//    {
//        for(Count = 0; Count < 2; Count++)
//        {
//            pMB->m_pBlocks[Count+blk_num].mv[Backwards][0] = (Ipp16s)MVx;
//            pMB->m_pBlocks[Count+blk_num].mv[Backwards][1] = (Ipp16s)MVy;
//        }
//    }
//    else    /* 4MV */
//    {
//        pMB->m_pBlocks[blk_num].mv[Backwards][0] = (Ipp16s)MVx;
//        pMB->m_pBlocks[blk_num].mv[Backwards][1] = (Ipp16s)MVy;
//    }
//    *pMVx = MVx;
//    *pMVy = MVy;
//
//#ifdef VC1_DEBUG_ON
//    VM_Debug::GetInstance().vm_debug_frame(-1,VC1_MV,VM_STRING("ApplyPred : MV_X  = %d, MV_Y  = %d\n"),MVx, MVy);
//#endif
//}
#endif //UMC_ENABLE_VC1_VIDEO_DECODER