umc_avs_dec_decompressor_pred_inter.cpp

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

        m_pMbInfo->mv[AVS_FORWARD][2] = mvTemp;
    }

    // get the motion vector prediction & reconstruct motion vector
    if (pPredType[1] & PredForward)
    {
        AVSMVector mvTemp;

        AVS_PREPARE_NEIGHBOURS_8x16_1
        GetMotionVectorPredictor8x16(PredForward, 1);
        mvTemp = mv_diff[numMV++] + m_mvPred;
        m_pMbInfo->mv[AVS_FORWARD][1] = mvTemp;
        m_pMbInfo->mv[AVS_FORWARD][3] = mvTemp;
    }

    if (PredForward != pPredType[0])
    {
        AVSMVector mvTemp;

        // reconstruct the backward motion vector
        if (PredBackward == pPredType[0])
        {
            AVS_PREPARE_NEIGHBOURS_8x16_0
            GetMotionVectorPredictor8x16(PredBackward, 0);
            mvTemp = mv_diff[numMV++] + m_mvPred;
        }
        // create the symmetrical backward motion vector
        else
        {
            AVSMVector mvFrw;
            Ipp32s DistanceMul;

            mvFrw = m_pMbInfo->mv[AVS_FORWARD][0];
            DistanceMul = m_blockDist[AVS_BACKWARD][0] * (512 / m_blockDist[AVS_FORWARD][0]);
            mvTemp.vector.x = (Ipp16s) -((mvFrw.vector.x * DistanceMul + 256) >> 9);
            mvTemp.vector.y = (Ipp16s) -((mvFrw.vector.y * DistanceMul + 256) >> 9);

            // correct prediction type
            pPredType[0] = PredBiDir;
            pPredType[2] = PredBiDir;
        }

        m_pMbInfo->mv[AVS_BACKWARD][0] = mvTemp;
        m_pMbInfo->mv[AVS_BACKWARD][2] = mvTemp;
    }

    if (PredForward != pPredType[1])
    {
        AVSMVector mvTemp;

        // reconstruct the backward motion vector
        if (PredBackward == pPredType[1])
        {
            AVS_PREPARE_NEIGHBOURS_8x16_1
            GetMotionVectorPredictor8x16(PredBackward, 1);
            mvTemp = mv_diff[numMV++] + m_mvPred;
        }
        // create the symmetrical backward motion vector
        else
        {
            AVSMVector mvFrw;
            Ipp32s DistanceMul;

            mvFrw = m_pMbInfo->mv[AVS_FORWARD][1];
            DistanceMul = m_blockDist[AVS_BACKWARD][0] * (512 / m_blockDist[AVS_FORWARD][0]);
            mvTemp.vector.x = (Ipp16s) -((mvFrw.vector.x * DistanceMul + 256) >> 9);
            mvTemp.vector.y = (Ipp16s) -((mvFrw.vector.y * DistanceMul + 256) >> 9);

            // correct prediction type
            pPredType[1] = PredBiDir;
            pPredType[3] = PredBiDir;
        }

        m_pMbInfo->mv[AVS_BACKWARD][1] = mvTemp;
        m_pMbInfo->mv[AVS_BACKWARD][3] = mvTemp;
    }

} // void AVSDecompressor::ReconstructMotionVectorsBSlice8x16(void)

#define AVS_PREPARE_NEIGHBOURS_8x8_0 \
    m_neighbours.pLeft = m_pMbInfoLeft; \
    m_neighbours.pTop = m_pMbInfoTop; \
    m_neighbours.pTopRight = m_pMbInfoTop; \
    m_neighbours.pTopLeft = NULL;

#define AVS_PREPARE_NEIGHBOURS_8x8_1 \
    m_neighbours.pLeft = m_pMbInfo; \
    m_neighbours.pTop = m_pMbInfoTop; \
    m_neighbours.pTopRight = m_pMbInfoTopRight; \
    m_neighbours.pTopLeft = m_pMbInfoTop;

#define AVS_PREPARE_NEIGHBOURS_8x8_2 \
    m_neighbours.pLeft = m_pMbInfoLeft; \
    m_neighbours.pTop = m_pMbInfo; \
    m_neighbours.pTopRight = m_pMbInfo; \
    m_neighbours.pTopLeft = NULL;

#define AVS_PREPARE_NEIGHBOURS_8x8_3 \
    m_neighbours.pLeft = m_pMbInfo; \
    m_neighbours.pTop = m_pMbInfo; \
    m_neighbours.pTopRight = NULL; \
    m_neighbours.pTopLeft = m_pMbInfo;

void AVSDecompressor::ReconstructMotionVectorsBSlice8x8(void)
{
    Ipp8u *pPredType = m_pMbInfo->predType;
    Ipp32s numMV;

    numMV = 0;

    // get the motion vector prediction & reconstruct motion vector
    if (PredDirect == pPredType[0])
    {
        ReconstructDirectMotionVector(0);
    }
    else if (pPredType[0] & PredForward)
    {
        AVSMVector mvTemp;

        AVS_PREPARE_NEIGHBOURS_8x8_0
        GetMotionVectorPredictor8x8(PredForward, 0);
        mvTemp = mv_diff[numMV++] + m_mvPred;
        m_pMbInfo->mv[AVS_FORWARD][0] = mvTemp;
    }

    // get the motion vector prediction & reconstruct motion vector
    if (PredDirect == pPredType[1])
    {
        ReconstructDirectMotionVector(1);
    }
    else if (pPredType[1] & PredForward)
    {
        AVSMVector mvTemp;

        AVS_PREPARE_NEIGHBOURS_8x8_1
        GetMotionVectorPredictor8x8(PredForward, 1);
        mvTemp = mv_diff[numMV++] + m_mvPred;
        m_pMbInfo->mv[AVS_FORWARD][1] = mvTemp;
    }

    // get the motion vector prediction & reconstruct motion vector
    if (PredDirect == pPredType[2])
    {
        ReconstructDirectMotionVector(2);
    }
    else if (pPredType[2] & PredForward)
    {
        AVSMVector mvTemp;

        AVS_PREPARE_NEIGHBOURS_8x8_2
        GetMotionVectorPredictor8x8(PredForward, 2);
        mvTemp = mv_diff[numMV++] + m_mvPred;
        m_pMbInfo->mv[AVS_FORWARD][2] = mvTemp;
    }

    // get the motion vector prediction & reconstruct motion vector
    if (PredDirect == pPredType[3])
    {
        ReconstructDirectMotionVector(3);
    }
    else if (pPredType[3] & PredForward)
    {
        AVSMVector mvTemp;

        AVS_PREPARE_NEIGHBOURS_8x8_3
        GetMotionVectorPredictor8x8(PredForward, 3);
        mvTemp = mv_diff[numMV++] + m_mvPred;
        m_pMbInfo->mv[AVS_FORWARD][3] = mvTemp;
    }

    {
        AVSMVector mvTemp;

        // reconstruct the backward motion vector
        if (PredBackward == pPredType[0])
        {
            AVS_PREPARE_NEIGHBOURS_8x8_0
            GetMotionVectorPredictor8x8(PredBackward, 0);
            mvTemp = mv_diff[numMV++] + m_mvPred;
            m_pMbInfo->mv[AVS_BACKWARD][0] = mvTemp;
        }
        // create the symmetrical backward motion vector
        else if (PredSym == pPredType[0])
        {
            AVSMVector mvFrw;
            Ipp32s DistanceMul;

            mvFrw = m_pMbInfo->mv[AVS_FORWARD][0];
            DistanceMul = m_blockDist[AVS_BACKWARD][0] * (512 / m_blockDist[AVS_FORWARD][0]);
            mvTemp.vector.x = (Ipp16s) -((mvFrw.vector.x * DistanceMul + 256) >> 9);
            mvTemp.vector.y = (Ipp16s) -((mvFrw.vector.y * DistanceMul + 256) >> 9);
            m_pMbInfo->mv[AVS_BACKWARD][0] = mvTemp;

            // correct prediction type
            pPredType[0] = PredBiDir;
        }
    }

    {
        AVSMVector mvTemp;

        // reconstruct the backward motion vector
        if (PredBackward == pPredType[1])
        {
            AVS_PREPARE_NEIGHBOURS_8x8_1
            GetMotionVectorPredictor8x8(PredBackward, 1);
            mvTemp = mv_diff[numMV++] + m_mvPred;
            m_pMbInfo->mv[AVS_BACKWARD][1] = mvTemp;
        }
        // create the symmetrical backward motion vector
        else if (PredSym == pPredType[1])
        {
            AVSMVector mvFrw;
            Ipp32s DistanceMul;

            mvFrw = m_pMbInfo->mv[AVS_FORWARD][1];
            DistanceMul = m_blockDist[AVS_BACKWARD][0] * (512 / m_blockDist[AVS_FORWARD][0]);
            mvTemp.vector.x = (Ipp16s) -((mvFrw.vector.x * DistanceMul + 256) >> 9);
            mvTemp.vector.y = (Ipp16s) -((mvFrw.vector.y * DistanceMul + 256) >> 9);
            m_pMbInfo->mv[AVS_BACKWARD][1] = mvTemp;

            // correct prediction type
            pPredType[1] = PredBiDir;
        }
    }

    {
        AVSMVector mvTemp;

        // reconstruct the backward motion vector
        if (PredBackward == pPredType[2])
        {
            AVS_PREPARE_NEIGHBOURS_8x8_2
            GetMotionVectorPredictor8x8(PredBackward, 2);
            mvTemp = mv_diff[numMV++] + m_mvPred;
            m_pMbInfo->mv[AVS_BACKWARD][2] = mvTemp;
        }
        // create the symmetrical backward motion vector
        else if (PredSym == pPredType[2])
        {
            AVSMVector mvFrw;
            Ipp32s DistanceMul;

            mvFrw = m_pMbInfo->mv[AVS_FORWARD][2];
            DistanceMul = m_blockDist[AVS_BACKWARD][0] * (512 / m_blockDist[AVS_FORWARD][0]);
            mvTemp.vector.x = (Ipp16s) -((mvFrw.vector.x * DistanceMul + 256) >> 9);
            mvTemp.vector.y = (Ipp16s) -((mvFrw.vector.y * DistanceMul + 256) >> 9);
            m_pMbInfo->mv[AVS_BACKWARD][2] = mvTemp;

            // correct prediction type
            pPredType[2] = PredBiDir;
        }
    }

    {
        AVSMVector mvTemp;

        // reconstruct the backward motion vector
        if (PredBackward == pPredType[3])
        {
            AVS_PREPARE_NEIGHBOURS_8x8_3
            GetMotionVectorPredictor8x8(PredBackward, 3);
            mvTemp = mv_diff[numMV++] + m_mvPred;
            m_pMbInfo->mv[AVS_BACKWARD][3] = mvTemp;
        }
        // create the symmetrical backward motion vector
        else if (PredSym == pPredType[3])
        {
            AVSMVector mvFrw;
            Ipp32s DistanceMul;

            mvFrw = m_pMbInfo->mv[AVS_FORWARD][3];
            DistanceMul = m_blockDist[AVS_BACKWARD][0] * (512 / m_blockDist[AVS_FORWARD][0]);
            mvTemp.vector.x = (Ipp16s) -((mvFrw.vector.x * DistanceMul + 256) >> 9);
            mvTemp.vector.y = (Ipp16s) -((mvFrw.vector.y * DistanceMul + 256) >> 9);
            m_pMbInfo->mv[AVS_BACKWARD][3] = mvTemp;

            // correct prediction type
            pPredType[3] = PredBiDir;
        }
    }

} // void AVSDecompressor::ReconstructMotionVectorsBSlice8x8(void)

#define GET_NEIGHBOUR_MV(vector, dist, neighbour_info, block_num) \
    if ((neighbour_info)->predType[block_num] & predType) \
    { \
        /* get the block reference index */ \
        Ipp32s ind = (neighbour_info)->refIdx[predType - 1][block_num]; \
        /* copy the vector */ \
        vector = (neighbour_info)->mv[predType - 1][block_num]; \
        lastVector = vector; \
        /* get the distance to the reference pixture */ \
        dist = m_blockDist[predType - 1][ind]; \
        availVectors += 1; \
    }

void AVSDecompressor::GetMotionVectorPredictor16x16(eAVSPredType predType)
{
    AVSMVector lastVector = {0, 0};
    Ipp32u availVectors = 0;
    AVSMVector mvA, mvB, mvC;
    Ipp32s blockDistA, blockDistB, blockDistC;

    //
    // select available neighbour vectors
    //

    mvA.scalar = 0;
    blockDistA = 1;
    if (m_pMbInfoLeft)
    {
        // get top-right block's vector of A macroblock
        GET_NEIGHBOUR_MV(mvA, blockDistA,
                         m_pMbInfoLeft, 1)
    }

    mvB.scalar = 0;
    blockDistB = 1;
    mvC.scalar = 0;
    blockDistC = 1;
    if (m_pMbInfoTop)
    {
        // get bottom-left block's vector of B macroblock
        GET_NEIGHBOUR_MV(mvB, blockDistB,
                         m_pMbInfoTop, 2)

        // get bottom-left block's vector of C macroblock
        if (m_pMbInfoTopRight)