umc_vc1_dec_mv_adv.cpp

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

    x = PullBack_PredMV(&x,(sMB->m_currMBXpos<<6), -60,(sMB->widthMB<<6)-4);
    y = PullBack_PredMV(&y,(sMB->m_currMBYpos<<6), -60,(sMB->heightMB<<6)-4);
    //VM_Debug::GetInstance(VC1DebugRoutine).vm_debug_frame(-1,VC1_BFRAMES,
    //VM_STRING("1.predict MV (%d,%d), back = %d\n"),x,y,Back);
    *pPredMVx=x;
    *pPredMVy=y;
}

void CalculateProgressive4MV_Adv(VC1Context* pContext,
                                Ipp16s *pPredMVx,Ipp16s *pPredMVy,
                                Ipp32s blk_num)
{
    Ipp16s x,y;
    VC1MVPredictors* MVPred = &pContext->MVPred;

    GetPredictProgressiveMV(MVPred->AMVPred[blk_num],
                            MVPred->BMVPred[blk_num],
                            MVPred->CMVPred[blk_num],
                            &x,&y,0);
    PullBack_PPred4MV(pContext->m_pSingleMB,&x,&y, blk_num);
    HybridMV(pContext,MVPred->AMVPred[blk_num],MVPred->CMVPred[blk_num], &x,&y,0);
    *pPredMVx=x;
    *pPredMVy=y;
}

void CalculateInterlaceFrame1MV_P(VC1MVPredictors* MVPredictors,
                              Ipp16s *pPredMVx,Ipp16s *pPredMVy)
{
    VC1MVPredictors MVPred;

    Ipp32u validPredictors = 0;
    Ipp16s MV_px[] = {0,0,0};
    Ipp16s MV_py[] = {0,0,0};

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

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

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

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

    //computing frame predictors
    if (validPredictors > 1)
    {
        // 2 or 3 predictors are available
        *pPredMVx = (Ipp16s)median3(MV_px);
        *pPredMVy = (Ipp16s)median3(MV_py);
    }
    else
    {
        // 1 or 0 predictor is available
        *pPredMVx = MV_px[0]+MV_px[1]+MV_px[2];
        *pPredMVy = MV_py[0]+MV_py[1]+MV_py[2];
    }
}

void CalculateInterlaceFrame1MV_B(VC1MVPredictors* MVPredictors,
                                    Ipp16s *f_x,Ipp16s *f_y,
                                    Ipp16s *b_x,Ipp16s *b_y,
                                    Ipp32u back)
{
    VC1MVPredictors MVPred;
    Ipp32u f_back = back;
    Ipp32u b_back = 1 - back;
    Ipp32u same = 0;
    Ipp32u opposite = 0;

    //Ipp32u validPredictors = 0;
    Ipp16s f_MV_px[] = {0,0,0};
    Ipp16s f_MV_py[] = {0,0,0};

    Ipp16s b_MV_px[] = {0,0,0};
    Ipp16s b_MV_py[] = {0,0,0};

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

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

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

    if(MVPred.AMVPred[0])
    {
        if(MVPred.FieldMB[0][0])
        {
            f_MV_px[0] = (MVPred.AMVPred[0]->mv[f_back][0]
                                + MVPred.AMVPred[0]->mv_bottom[f_back][0] + 1)>>1;
            f_MV_py[0] = (MVPred.AMVPred[0]->mv[f_back][1]
                                + MVPred.AMVPred[0]->mv_bottom[f_back][1] + 1)>>1;
        }
        else
        {
            f_MV_px[0] = MVPred.AMVPred[0]->mv[f_back][0];
            f_MV_py[0] = MVPred.AMVPred[0]->mv[f_back][1];
        }

        //validPredictors++;

        b_MV_px[0] = MVPred.AMVPred[0]->mv[b_back][0];
        b_MV_py[0] = MVPred.AMVPred[0]->mv[b_back][1];

        //classifying candidate mv
        if(b_MV_py[0] & 4)
        {
            MV_px_oppField[opposite] = b_MV_px[0];
            MV_py_oppField[opposite] = b_MV_py[0];
            ++opposite;
        }
        else
        {
            MV_px_sameField[same] = b_MV_px[0];
            MV_py_sameField[same] = b_MV_py[0];
            ++same;
        }
    }

    if(MVPred.BMVPred[0])
    {
        if(MVPred.FieldMB[0][1])
        {
            f_MV_px[1] = (MVPred.BMVPred[0]->mv[f_back][0]
                            + MVPred.BMVPred[0]->mv_bottom[f_back][0] + 1)>>1;
            f_MV_py[1] = (MVPred.BMVPred[0]->mv[f_back][1]
                            + MVPred.BMVPred[0]->mv_bottom[f_back][1] + 1)>>1;
        }
        else
        {
            f_MV_px[1] = MVPred.BMVPred[0]->mv[f_back][0];
            f_MV_py[1] = MVPred.BMVPred[0]->mv[f_back][1];
        }

        //validPredictors++;

        b_MV_px[1] = MVPred.BMVPred[0]->mv[b_back][0];
        b_MV_py[1] = MVPred.BMVPred[0]->mv[b_back][1];

        //classifying candidate mv
        if(b_MV_py[1] & 4)
        {
            MV_px_oppField[opposite] = b_MV_px[1];
            MV_py_oppField[opposite] = b_MV_py[1];
            ++opposite;
        }
        else
        {
            MV_px_sameField[same] = b_MV_px[1];
            MV_py_sameField[same] = b_MV_py[1];
            ++same;
        }
    }

    if(MVPred.CMVPred[0])
    {
        if(MVPred.FieldMB[0][2])
        {
            f_MV_px[2] = (MVPred.CMVPred[0]->mv[f_back][0]
                                    + MVPred.CMVPred[0]->mv_bottom[f_back][0] + 1)>>1;
            f_MV_py[2] = (MVPred.CMVPred[0]->mv[f_back][1]
                                    + MVPred.CMVPred[0]->mv_bottom[f_back][1] + 1)>>1;
        }
        else
        {
            f_MV_px[2] = MVPred.CMVPred[0]->mv[f_back][0];
            f_MV_py[2] = MVPred.CMVPred[0]->mv[f_back][1];
        }
        //validPredictors++;
        b_MV_px[2] = MVPred.CMVPred[0]->mv[b_back][0];
        b_MV_py[2] = MVPred.CMVPred[0]->mv[b_back][1];

        //classifying candidate mv
        if(b_MV_py[2] & 4)
        {
            MV_px_oppField[opposite] = b_MV_px[2];
            MV_py_oppField[opposite] = b_MV_py[2];
            ++opposite;
        }
        else
        {
            MV_px_sameField[same] = b_MV_px[2];
            MV_py_sameField[same] = b_MV_py[2];
            ++same;
        }
    }

    //computing frame predictors
    if (same + opposite > 1)
    {
        // 2 or 3 predictors are available
        *f_x = (Ipp16s)median3(f_MV_px);
        *f_y = (Ipp16s)median3(f_MV_py);
    }
    else
    {
        // 1 or 0 predictor is available
        *f_x = f_MV_px[0]+f_MV_px[1]+f_MV_px[2];
        *f_y = f_MV_py[0]+f_MV_py[1]+f_MV_py[2];
    }

    //computation of Field MV predictors from candidate mv
    //3 predictors are available
    if((same == 3) || (opposite == 3))
    {
        *b_x = (Ipp16s)median3(b_MV_px);
        *b_y = (Ipp16s)median3(b_MV_py);
    }
    else if(same >= opposite)
    {
        *b_x = MV_px_sameField[0];
        *b_y = MV_py_sameField[0];
    }
    else
    {
        *b_x = MV_px_oppField[0];
        *b_y = MV_py_oppField[0];
    }
}

void CalculateInterlaceFrame1MV_B_Interpolate(VC1MVPredictors* MVPredictors,
                                              Ipp16s *f_x,Ipp16s *f_y,
                                              Ipp16s *b_x,Ipp16s *b_y)
{
    VC1MVPredictors MVPred;

    Ipp32u validPredictors = 0;
    Ipp16s f_MV_px[] = {0,0,0};
    Ipp16s f_MV_py[] = {0,0,0};

    Ipp16s b_MV_px[] = {0,0,0};
    Ipp16s b_MV_py[] = {0,0,0};

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

    if(MVPred.AMVPred[0])
    {
        if(MVPred.FieldMB[0][0])
        {
            f_MV_px[0] = (MVPred.AMVPred[0]->mv[0][0]
                                + MVPred.AMVPred[0]->mv_bottom[0][0] + 1)>>1;
            f_MV_py[0] = (MVPred.AMVPred[0]->mv[0][1]
                                + MVPred.AMVPred[0]->mv_bottom[0][1] + 1)>>1;

            b_MV_px[0] = (MVPred.AMVPred[0]->mv[1][0]
                                + MVPred.AMVPred[0]->mv_bottom[1][0] + 1)>>1;
            b_MV_py[0] = (MVPred.AMVPred[0]->mv[1][1]
                                + MVPred.AMVPred[0]->mv_bottom[1][1] + 1)>>1;
        }
        else
        {
            f_MV_px[0] = MVPred.AMVPred[0]->mv[0][0];
            f_MV_py[0] = MVPred.AMVPred[0]->mv[0][1];
            b_MV_px[0] = MVPred.AMVPred[0]->mv[1][0];
            b_MV_py[0] = MVPred.AMVPred[0]->mv[1][1];
        }

        validPredictors++;
    }

    if(MVPred.BMVPred[0])
    {
        if(MVPred.FieldMB[0][1])
        {
            f_MV_px[1] = (MVPred.BMVPred[0]->mv[0][0]
                            + MVPred.BMVPred[0]->mv_bottom[0][0] + 1)>>1;
            f_MV_py[1] = (MVPred.BMVPred[0]->mv[0][1]
                            + MVPred.BMVPred[0]->mv_bottom[0][1] + 1)>>1;
            b_MV_px[1] = (MVPred.BMVPred[0]->mv[1][0]
                            + MVPred.BMVPred[0]->mv_bottom[1][0] + 1)>>1;
            b_MV_py[1] = (MVPred.BMVPred[0]->mv[1][1]
                            + MVPred.BMVPred[0]->mv_bottom[1][1] + 1)>>1;
        }
        else
        {
            f_MV_px[1] = MVPred.BMVPred[0]->mv[0][0];
            f_MV_py[1] = MVPred.BMVPred[0]->mv[0][1];
            b_MV_px[1] = MVPred.BMVPred[0]->mv[1][0];
            b_MV_py[1] = MVPred.BMVPred[0]->mv[1][1];
        }

        validPredictors++;
    }

    if(MVPred.CMVPred[0])
    {
        if(MVPred.FieldMB[0][2])
        {
            f_MV_px[2] = (MVPred.CMVPred[0]->mv[0][0]
                                    + MVPred.CMVPred[0]->mv_bottom[0][0] + 1)>>1;
            f_MV_py[2] = (MVPred.CMVPred[0]->mv[0][1]
                                    + MVPred.CMVPred[0]->mv_bottom[0][1] + 1)>>1;
            b_MV_px[2] = (MVPred.CMVPred[0]->mv[1][0]
                                    + MVPred.CMVPred[0]->mv_bottom[1][0] + 1)>>1;
            b_MV_py[2] = (MVPred.CMVPred[0]->mv[1][1]
                                    + MVPred.CMVPred[0]->mv_bottom[1][1] + 1)>>1;
        }
        else
        {
            f_MV_px[2] = MVPred.CMVPred[0]->mv[0][0];
            f_MV_py[2] = MVPred.CMVPred[0]->mv[0][1];
            b_MV_px[2] = MVPred.CMVPred[0]->mv[1][0];
            b_MV_py[2] = MVPred.CMVPred[0]->mv[1][1];
        }
        validPredictors++;
    }

    //computing frame predictors
    if (validPredictors > 1)
    {
        // 2 or 3 predictors are available
        *f_x = (Ipp16s)median3(f_MV_px);
        *f_y = (Ipp16s)median3(f_MV_py);

        *b_x = (Ipp16s)median3(b_MV_px);
        *b_y = (Ipp16s)median3(b_MV_py);
    }
    else
    {
        // 1 or 0 predictor is available
        *f_x = f_MV_px[0]+f_MV_px[1]+f_MV_px[2];
        *f_y = f_MV_py[0]+f_MV_py[1]+f_MV_py[2];

        *b_x = b_MV_px[0]+b_MV_px[1]+b_MV_px[2];
        *b_y = b_MV_py[0]+b_MV_py[1]+b_MV_py[2];
    }
}

void Calculate4MVFrame_Adv(VC1MVPredictors* MVPredictors,
                              Ipp16s *pPredMVx,Ipp16s *pPredMVy,
                              Ipp32u blk_num)
{
   VC1MVPredictors MVPred;

    Ipp32u validPredictors = 0;
    Ipp16s MV_px[] = {0,0,0};
    Ipp16s MV_py[] = {0,0,0};

    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] + MVPred.AMVPred[blk_num]->mv_bottom[0][0] + 1)>>1;
            MV_py[0] = (MVPred.AMVPred[blk_num]->mv[0][1] + MVPred.AMVPred[blk_num]->mv_bottom[0][1] + 1)>>1;
        }
        else