umc_avs_dec_decompressor_pred_inter.cpp

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

        {
            GET_NEIGHBOUR_MV(mvC, blockDistC,
                             m_pMbInfoTopRight, 2)
        }
        // get bottom-right block's vector of D macroblock
        else if (m_pMbInfoTopLeft)
        {
            GET_NEIGHBOUR_MV(mvC, blockDistC,
                             m_pMbInfoTopLeft, 3)
        }
    }

    //
    // calculate prediction for the current block
    //

    // step 1: available only one neighbour reference
    if (1 == availVectors)
    {
        m_mvPred = lastVector;
    }
    // step 3: perform full calculation
    else
    {
        Ipp32s blockDist;

        blockDist = m_blockDist[predType - 1][m_pMbInfo->refIdx[predType - 1][0]];
        GetMotionVectorPredictor(mvA, mvB, mvC,
                                 blockDist,
                                 blockDistA, blockDistB, blockDistC);
    }

} // void AVSDecompressor::GetMotionVectorPredictor16x16(eAVSPredType predType)

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

    //
    // step 1. select available neighbour vectors
    //

    mvA.scalar = 0;
    blockDistA = 1;
    if (m_pMbInfoLeft)
    {
        // get A block
        GET_NEIGHBOUR_MV(mvA, blockDistA,
                         m_pMbInfoLeft, blockNum + 1)
    }

    mvB.scalar = 0;
    blockDistB = 1;
    mvC.scalar = 0;
    blockDistC = 1;
    if (m_neighbours.pTop)
    {
        // get B macro
        GET_NEIGHBOUR_MV(mvB, blockDistB,
                         m_neighbours.pTop, (blockNum + 2) % 4)

        // get C block
        if (m_neighbours.pTopRight)
        {
            GET_NEIGHBOUR_MV(mvC, blockDistC,
                             m_neighbours.pTopRight, 2)
        }
        // get D block
        else if (m_neighbours.pTopLeft)
        {
            GET_NEIGHBOUR_MV(mvC, blockDistC,
                             m_neighbours.pTopLeft, (blockNum + 3) % 4)
        }
    }

    if (1 == availVectors)
    {
        m_mvPred = lastVector;
    }
    else
    {
        Ipp32s nearBlockNum = (blockNum >> 1) + 2;

        // step 2: if the nearest block has the same index,
        // then we just copy the corresponding vector from this block
        if ((m_neighbours.pNearest) &&
            (m_neighbours.pNearest->predType[nearBlockNum] & predType) &&
            (m_neighbours.pNearest->refIdx[predType - 1][nearBlockNum] ==
             m_pMbInfo->refIdx[predType - 1][blockNum]))
        {
            m_mvPred = m_neighbours.pNearest->mv[predType - 1][nearBlockNum];
        }
        // setp 3: perform full calculation
        else
        {
            Ipp32s blockDist;

            blockDist = m_blockDist[predType - 1][m_pMbInfo->refIdx[predType - 1][blockNum]];
            GetMotionVectorPredictor(mvA, mvB, mvC,
                                     blockDist,
                                     blockDistA, blockDistB, blockDistC);
        }
    }

} // void AVSDecompressor::GetMotionVectorPredictor16x8(eAVSPredType predType, Ipp32s blockNum)

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

    //
    // step 1. select available neighbour vectors
    //

    mvA.scalar = 0;
    blockDistA = 1;
    if (m_neighbours.pLeft)
    {
        // get A block
        GET_NEIGHBOUR_MV(mvA, blockDistA,
                         m_neighbours.pLeft, blockNum + 1)
    }

    mvB.scalar = 0;
    blockDistB = 1;
    mvC.scalar = 0;
    blockDistC = 1;
    if (m_pMbInfoTop)
    {
        // get B macro
        GET_NEIGHBOUR_MV(mvB, blockDistB,
                         m_pMbInfoTop, blockNum + 2)

        // get C block
        if (m_neighbours.pTopRight)
        {
            GET_NEIGHBOUR_MV(mvC, blockDistC,
                             m_neighbours.pTopRight, 3 - blockNum)
        }
        // get D block
        else if (m_neighbours.pTopLeft)
        {
            GET_NEIGHBOUR_MV(mvC, blockDistC,
                             m_neighbours.pTopLeft, 3 - blockNum)
        }
    }

    if (1 == availVectors)
    {
        m_mvPred = lastVector;
    }
    else
    {
        Ipp32s nearBlockNum = blockNum + 1;

        // step 2: if the nearest block has the same index,
        // then we just copy the corresponding vector from this block
        if ((m_neighbours.pNearest) &&
            (m_neighbours.pNearest->predType[nearBlockNum] & predType) &&
            (m_neighbours.pNearest->refIdx[predType - 1][nearBlockNum] ==
             m_pMbInfo->refIdx[predType - 1][blockNum]))
        {
            m_mvPred = m_neighbours.pNearest->mv[predType - 1][nearBlockNum];
        }
        // setp 3: perform full calculation
        else
        {
            Ipp32s blockDist;

            blockDist = m_blockDist[predType - 1][m_pMbInfo->refIdx[predType - 1][blockNum]];
            GetMotionVectorPredictor(mvA, mvB, mvC,
                                     blockDist,
                                     blockDistA, blockDistB, blockDistC);
        }
    }

} // void AVSDecompressor::GetMotionVectorPredictor8x16(eAVSPredType predType, Ipp32s blockNum)

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

    //
    // step 1. select available neighbour vectors
    //

    mvA.scalar = 0;
    blockDistA = 1;
    if (m_neighbours.pLeft)
    {
        // get A block
        GET_NEIGHBOUR_MV(mvA, blockDistA,
                         m_neighbours.pLeft, blockNum ^ 1)
    }

    mvB.scalar = 0;
    blockDistB = 1;
    mvC.scalar = 0;
    blockDistC = 1;
    if (m_neighbours.pTop)
    {
        // get B macro
        GET_NEIGHBOUR_MV(mvB, blockDistB,
                         m_neighbours.pTop, (blockNum + 2) % 4)

        // get C block
        if (m_neighbours.pTopRight)
        {
            GET_NEIGHBOUR_MV(mvC, blockDistC,
                             m_neighbours.pTopRight, 3 - blockNum)
        }
        // get D block
        else if (m_neighbours.pTopLeft)
        {
            GET_NEIGHBOUR_MV(mvC, blockDistC,
                             m_neighbours.pTopLeft, 3 - blockNum)
        }
    }

    if (1 == availVectors)
    {
        m_mvPred = lastVector;
    }
    else
    {
        Ipp32s blockDist;

        blockDist = m_blockDist[predType - 1][m_pMbInfo->refIdx[predType - 1][blockNum]];
        GetMotionVectorPredictor(mvA, mvB, mvC,
                                 blockDist,
                                 blockDistA, blockDistB, blockDistC);
    }

} // void AVSDecompressor::GetMotionVectorPredictor8x8(eAVSPredType predType, Ipp32s blockNum)

inline
Ipp32s ScaleValue(Ipp32s value, Ipp32s blockDist, Ipp32s otherBlockDist)
{
    Ipp32s signExtended = value >> 31;

    // get the absolute value
    value = (value ^ signExtended) - signExtended;

    // scale value
    value = ((value * blockDist) * (512 / otherBlockDist) + 256) >> 9;

    // restore the sign of the value
    value = (value + signExtended) ^ signExtended;

    return value;

} // Ipp32s ScaleValue(Ipp32s value, Ipp32s blockDist, Ipp32s otherBlockDist)

inline
Ipp32s AvsAbs(Ipp32s value)
{
    return (0 < value) ? (value) : (-value);

} // Ipp32s AvsAbs(Ipp32s value)

inline
Ipp32s VectorDistance(AVSMVector mvOne, AVSMVector mvTwo)
{
    Ipp32s dist;

    dist = AvsAbs(mvOne.vector.x - mvTwo.vector.x) +
           AvsAbs(mvOne.vector.y - mvTwo.vector.y);

    return dist;

} // Ipp32s VectorDistance(AVSMVector mvOne, AVSMVector mvTwo)

void AVSDecompressor::GetMotionVectorPredictor(AVSMVector mvA,
                                               AVSMVector mvB,
                                               AVSMVector mvC,
                                               Ipp32s blockDist,
                                               Ipp32s blockDistA,
                                               Ipp32s blockDistB,
                                               Ipp32s blockDistC)
{
    Ipp32s distAB, distBC, distCA;
    Ipp32s median;

    // scale motion vectors
    mvA.vector.x = (Ipp16s) ScaleValue(mvA.vector.x, blockDist, blockDistA);
    mvA.vector.y = (Ipp16s) ScaleValue(mvA.vector.y, blockDist, blockDistA);
    mvB.vector.x = (Ipp16s) ScaleValue(mvB.vector.x, blockDist, blockDistB);
    mvB.vector.y = (Ipp16s) ScaleValue(mvB.vector.y, blockDist, blockDistB);
    mvC.vector.x = (Ipp16s) ScaleValue(mvC.vector.x, blockDist, blockDistC);
    mvC.vector.y = (Ipp16s) ScaleValue(mvC.vector.y, blockDist, blockDistC);

    // get distance between vectors
    distAB = VectorDistance(mvA, mvB);
    distBC = VectorDistance(mvB, mvC);
    distCA = VectorDistance(mvC, mvA);

    // get the Median()
    median = distAB + distBC + distCA -
             IPP_MIN(distAB, IPP_MIN(distBC, distCA)) -
             IPP_MAX(distAB, IPP_MAX(distBC, distCA));

    if (distAB == median)
    {
        m_mvPred = mvC;
    }
    else if (distBC == median)
    {
        m_mvPred = mvA;
    }
    else
    {
        m_mvPred = mvB;
    }

} // void AVSDecompressor::GetMotionVectorPredictor(AVSMVector mvA,

} // namespace UMC

#endif // #if defined(UMC_ENABLE_AVS_VIDEO_DECODER)