umc_vc1_dec_mv_adv.cpp

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

                {
                    MV_px_sameField[0][SameTopField] = MV_px[0][2];
                    MV_py_sameField[0][SameTopField] = MV_py[0][2];
                    ++SameTopField;
                }

                //classifying bottom candidate mv
                if(MV_py[1][2] & 4)
                {
                    MV_px_oppField[1][OppositeBottomField] = MV_px[1][2];
                    MV_py_oppField[1][OppositeBottomField] = MV_py[1][2];
                    ++OppositeBottomField;
                }
                else
                {
                    MV_px_sameField[1][SameBottomField] = MV_px[1][2];
                    MV_py_sameField[1][SameBottomField] = MV_py[1][2];
                    ++SameBottomField;
                }
            }
        }
        else
        {
            //this block is last in row
            pC=(pCurrMB - widthMB -1);
            if(!pC->IntraFlag)
            {
                switch(VC1_GET_MBTYPE(pC->mbType))
                {
                case VC1_MB_1MV_INTER:
                    {
                        //top field
                        MV_px[0][2] = pC->m_pBlocks[0].mv[backTop][0];
                        MV_py[0][2] = pC->m_pBlocks[0].mv[backTop][1];

                        //bottom field
                        MV_px[1][2] = pC->m_pBlocks[0].mv[backBottom][0];
                        MV_py[1][2] = pC->m_pBlocks[0].mv[backBottom][1];
                    }
                    break;
                case VC1_MB_2MV_INTER:
                    {
                        //top field
                        //add the top field mv
                        MV_px[0][2] = pC->m_pBlocks[0].mv[backTop][0];
                        MV_py[0][2] = pC->m_pBlocks[0].mv[backTop][1];

                        //bottom field
                        MV_px[1][2] = pC->m_pBlocks[0].mv_bottom[backBottom][0];
                        MV_py[1][2] = pC->m_pBlocks[0].mv_bottom[backBottom][1];
                    }
                    break;
                case VC1_MB_4MV_INTER:
                    {
                        //top field
                        //add the bottom right block mv
                        MV_px[0][2] = pC->m_pBlocks[3].mv[backTop][0];
                        MV_py[0][2] = pC->m_pBlocks[3].mv[backTop][1];

                        //bottom field
                        MV_px[1][2] = pC->m_pBlocks[3].mv[backBottom][0];
                        MV_py[1][2] = pC->m_pBlocks[3].mv[backBottom][1];
                    }
                    break;
                case VC1_MB_4MV_FIELD_INTER:
                    {
                        //top field
                        //add the top right field mv
                        MV_px[0][2] = pC->m_pBlocks[1].mv[backTop][0];
                        MV_py[0][2] = pC->m_pBlocks[1].mv[backTop][1];

                        //bottom field
                        MV_px[1][2] = pC->m_pBlocks[1].mv_bottom[backBottom][0];
                        MV_py[1][2] = pC->m_pBlocks[1].mv_bottom[backBottom][1];
                    }
                    break;
                default:
                    pC=NULL;
                    break;
                }
                //classifying top candidate mv
                if(MV_py[0][2] & 4)
                {
                    MV_px_oppField[0][OppositeTopField] = MV_px[0][2];
                    MV_py_oppField[0][OppositeTopField] = MV_py[0][2];
                    ++OppositeTopField;
                }
                else
                {
                    MV_px_sameField[0][SameTopField] = MV_px[0][2];
                    MV_py_sameField[0][SameTopField] = MV_py[0][2];
                    ++SameTopField;
                }

                //classifying bottom candidate mv
                if(MV_py[1][2] & 4)
                {
                    MV_px_oppField[1][OppositeBottomField] = MV_px[1][2];
                    MV_py_oppField[1][OppositeBottomField] = MV_py[1][2];
                    ++OppositeBottomField;
                }
                else
                {
                    MV_px_sameField[1][SameBottomField] = MV_px[1][2];
                    MV_py_sameField[1][SameBottomField] = MV_py[1][2];
                    ++SameBottomField;
                }
            }
        }
    }

    //computation of Field MV predictors from candidate mv
    //3 or 2 predictors are available
    if((SameTopField == 3) || (OppositeTopField == 3))
    {
        pPredMVx[0] = (Ipp16s)median3(MV_px[0]);
        pPredMVy[0] = (Ipp16s)median3(MV_py[0]);
    }
    else if(SameTopField >= OppositeTopField)
    {
        pPredMVx[0] = MV_px_sameField[0][0];
        pPredMVy[0] = MV_py_sameField[0][0];
    }
    else
    {
        pPredMVx[0] = MV_px_oppField[0][0];
        pPredMVy[0] = MV_py_oppField[0][0];
    }

    //computation of Field MV predictors from candidate mv
    //3 or 2 predictors are available
    if((SameBottomField == 3) || (OppositeBottomField == 3))
    {
        pPredMVx[1] = (Ipp16s)median3(MV_px[1]);
        pPredMVy[1] = (Ipp16s)median3(MV_py[1]);
    }
    else if(SameBottomField >= OppositeBottomField)
    {
        pPredMVx[1] = MV_px_sameField[1][0];
        pPredMVy[1] = MV_py_sameField[1][0];
    }
    else
    {
        pPredMVx[1] = MV_px_oppField[1][0];
        pPredMVy[1] = MV_py_oppField[1][0];
    }
}

void CalculateInterlace4MV_TopField_Adv(VC1MVPredictors* MVPredictors,
                                      Ipp16s *pPredMVx,Ipp16s *pPredMVy,
                                      Ipp32u blk_num)
{
    Ipp32u validPredictorsOppositeField = 0;
    Ipp32u validPredictorsSameField = 0;

    Ipp16s MV_px[3] = {0,0,0}; //first index - top/bottom
    Ipp16s MV_py[3] = {0,0,0}; //second - A,B,C predictors

    Ipp16s MV_px_sameField[3] = {0,0,0};
    Ipp16s MV_py_sameField[3] = {0,0,0};

    Ipp16s MV_px_oppField[3] = {0,0,0};
    Ipp16s MV_py_oppField[3] = {0,0,0};

    VC1MVPredictors MVPred;

    memcpy(&MVPred,MVPredictors,sizeof(VC1MVPredictors));

    if(MVPred.AMVPred[blk_num])
    {
        MV_px[0] = MVPred.AMVPred[blk_num]->mv[0][0];
        MV_py[0] = MVPred.AMVPred[blk_num]->mv[0][1];
        //classifying top candidate mv
        if(MV_py[0] & 4)
        {
            MV_px_oppField[validPredictorsOppositeField] = MV_px[0];
            MV_py_oppField[validPredictorsOppositeField] = MV_py[0];
            ++validPredictorsOppositeField;
        }
        else
        {
            MV_px_sameField[validPredictorsSameField] = MV_px[0];
            MV_py_sameField[validPredictorsSameField] = MV_py[0];
            ++validPredictorsSameField;
        }
    }

    if(MVPred.BMVPred[blk_num])
    {
        MV_px[1] = MVPred.BMVPred[blk_num]->mv[0][0];
        MV_py[1] = MVPred.BMVPred[blk_num]->mv[0][1];
        //classifying top candidate mv
        if(MV_py[1] & 4)
        {
            MV_px_oppField[validPredictorsOppositeField] = MV_px[1];
            MV_py_oppField[validPredictorsOppositeField] = MV_py[1];
            ++validPredictorsOppositeField;
        }
        else
        {
            MV_px_sameField[validPredictorsSameField] = MV_px[1];
            MV_py_sameField[validPredictorsSameField] = MV_py[1];
            ++validPredictorsSameField;
        }
    }


    if(MVPred.CMVPred[blk_num])
    {
        MV_px[2] = MVPred.CMVPred[blk_num]->mv[0][0];
        MV_py[2] = MVPred.CMVPred[blk_num]->mv[0][1];
        //classifying top candidate mv
        if(MV_py[2] & 4)
        {
            MV_px_oppField[validPredictorsOppositeField] = MV_px[2];
            MV_py_oppField[validPredictorsOppositeField] = MV_py[2];
            ++validPredictorsOppositeField;
        }
        else
        {
            MV_px_sameField[validPredictorsSameField] = MV_px[2];
            MV_py_sameField[validPredictorsSameField] = MV_py[2];
            ++validPredictorsSameField;
        }
    }

    //computation of top Field MV predictors from candidate mv
    //3 or 2 predictors are available
    if((validPredictorsSameField == 3) || (validPredictorsOppositeField == 3))
    {
        *pPredMVx = (Ipp16s)median3(MV_px);
        *pPredMVy = (Ipp16s)median3(MV_py);
    }
    else if(validPredictorsSameField >= validPredictorsOppositeField)
    {
        *pPredMVx = MV_px_sameField[0];
        *pPredMVy = MV_py_sameField[0];
    }
    else
    {
        *pPredMVx = MV_px_oppField[0];
        *pPredMVy = MV_py_oppField[0];
    }
 }

void CalculateInterlace4MV_BottomField_Adv(VC1MVPredictors* MVPredictors,
                                      Ipp16s *pPredMVx,Ipp16s *pPredMVy,
                                      Ipp32u blk_num)
{
    Ipp32u validPredictorsOppositeField = 0;
    Ipp32u validPredictorsSameField = 0;

    Ipp16s MV_px[3] = {0,0,0}; //first index - top/bottom
    Ipp16s MV_py[3] = {0,0,0}; //second - A,B,C predictors

    Ipp16s MV_px_sameField[3] = {0,0,0};
    Ipp16s MV_py_sameField[3] = {0,0,0};

    Ipp16s MV_px_oppField[3] = {0,0,0};
    Ipp16s MV_py_oppField[3] = {0,0,0};

    VC1MVPredictors MVPred;

    memcpy(&MVPred,MVPredictors,sizeof(VC1MVPredictors));

    if(MVPred.AMVPred[blk_num])
    {
        if(!MVPred.FieldMB[blk_num][0])
        {
            MV_px[0] = MVPred.AMVPred[blk_num]->mv[0][0];
            MV_py[0] = MVPred.AMVPred[blk_num]->mv[0][1];
        }
        else
        {
            MV_px[0] = MVPred.AMVPred[blk_num]->mv_bottom[0][0];
            MV_py[0] = MVPred.AMVPred[blk_num]->mv_bottom[0][1];
        }

        //classifying top candidate mv
        if(MV_py[0] & 4)
        {
            MV_px_oppField[validPredictorsOppositeField] = MV_px[0];
            MV_py_oppField[validPredictorsOppositeField] = MV_py[0];
            ++validPredictorsOppositeField;
        }
        else
        {
            MV_px_sameField[validPredictorsSameField] = MV_px[0];
            MV_py_sameField[validPredictorsSameField] = MV_py[0];
            ++validPredictorsSameField;
        }
    }

    if(MVPred.BMVPred[blk_num])
    {
        if(!MVPred.FieldMB[blk_num][1])
        {
            MV_px[1] = MVPred.BMVPred[blk_num]->mv[0][0];
            MV_py[1] = MVPred.BMVPred[blk_num]->mv[0][1];
        }
        else
        {
            MV_px[1] = MVPred.BMVPred[blk_num]->mv_bottom[0][0];
            MV_py[1] = MVPred.BMVPred[blk_num]->mv_bottom[0][1];
        }

        //classifying top candidate mv
        if(MV_py[1] & 4)
        {
            MV_px_oppField[validPredictorsOppositeField] = MV_px[1];
            MV_py_oppField[validPredictorsOppositeField] = MV_py[1];
            ++validPredictorsOppositeField;
        }
        else
        {
            MV_px_sameField[validPredictorsSameField] = MV_px[1];
            MV_py_sameField[validPredictorsSameField] = MV_py[1];
            ++validPredictorsSameField;
        }
    }


    if(MVPred.CMVPred[blk_num])
    {
        if(!MVPred.FieldMB[blk_num][2])
        {
            MV_px[2] = MVPred.CMVPred[blk_num]->mv[0][0];
            MV_py[2] = MVPred.CMVPred[blk_num]->mv[0][1];
        }
        else
        {
            MV_px[2] = MVPred.CMVPred[blk_num]->mv_bottom[0][0];
            MV_py[2] = MVPred.CMVPred[blk_num]->mv_bottom[0][1];

        }

        //classifying top candidate mv
        if(MV_py[2] & 4)
        {
            MV_px_oppField[validPredictorsOppositeField] = MV_px[2];
            MV_py_oppField[validPredictorsOppositeField] = MV_py[2];
            ++validPredictorsOppositeField;
        }
        else
        {
            MV_px_sameField[validPredictorsSameField] = MV_px[2];
            MV_py_sameField[validPredictorsSameField] = MV_py[2];
            ++validPredictorsSameField;
        }
    }

    //computation of top Field MV predictors from candidate mv
    //3 or 2 predictors are available
    if((validPredictorsSameField == 3) || (validPredictorsOppositeField == 3))
    {
        *pPredMVx = (Ipp16s)median3(MV_px);
        *pPredMVy = (Ipp16s)median3(MV_py);
    }
    else if(validPredictorsSameField >= validPredictorsOppositeField)
    {
        *pPredMVx = MV_px_sameField[0];
        *pPredMVy = MV_py_sameField[0];
    }
    else
    {
        *pPredMVx = MV_px_oppField[0];
        *pPredMVy = MV_py_oppField[0];
    }
 }

void DecodeMVDiff_Adv(VC1Context* pContext,Ipp16s* pdmv_x, Ipp16s* pdmv_y)
{
    IppStatus ret;
    Ipp32s index;
    Ipp16s dmv_x = 0;
    Ipp16s dmv_y = 0;
    Ipp32s sign;
    Ipp32s val;
    VC1PictureLayerHeader* picHeader = pContext->m_picLayerHeader;

    const Ipp8u offset_table[2][9] = { {0, 1, 2, 4, 8, 16, 32, 64, 128},
                                       {0, 1, 3, 7, 15, 31, 63, 127, 255}};
    const Ipp8u* curr_offset;

#ifdef UMC_STREAM_ANALYZER