umc_avs_dec_decompressor_mc.cpp

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

    m_chromaMCParams.sizeBlock = AVSChromaBlockSize[m_recCtx.m_pSeqHeader->chroma_format - 1]
                                                   [m_pMbInfo->divType];
    blockHeight = m_chromaMCParams.sizeBlock.height;

    switch (m_pMbInfo->divType)
    {
    case Div_16x16:
        CompensateMotionChromaUniDir(0, PredForward);
        break;

    case Div_16x8:
        CompensateMotionChromaUniDir(0, PredForward);

        m_chromaMCParams.pointBlockPos.y += blockHeight;
        m_chromaMCParams.pDst[0] += m_chromaMCParams.dstStep * blockHeight;
        m_chromaMCParams.pDst[1] += m_chromaMCParams.dstStep * blockHeight;
        CompensateMotionChromaUniDir(2, PredForward);
        break;

    case Div_8x16:
        CompensateMotionChromaUniDir(0, PredForward);

        m_chromaMCParams.pointBlockPos.x += 4;
        m_chromaMCParams.pDst[0] += 4;
        m_chromaMCParams.pDst[1] += 4;
        CompensateMotionChromaUniDir(1, PredForward);
        break;

    default:
        CompensateMotionChromaUniDir(0, PredForward);

        m_chromaMCParams.pointBlockPos.x += 4;
        m_chromaMCParams.pDst[0] += 4;
        m_chromaMCParams.pDst[1] += 4;
        CompensateMotionChromaUniDir(1, PredForward);

        m_chromaMCParams.pointBlockPos.x -= 4;
        m_chromaMCParams.pointBlockPos.y += blockHeight;
        m_chromaMCParams.pDst[0] += m_chromaMCParams.dstStep * blockHeight - 4;
        m_chromaMCParams.pDst[1] += m_chromaMCParams.dstStep * blockHeight - 4;
        CompensateMotionChromaUniDir(2, PredForward);

        m_chromaMCParams.pointBlockPos.x += 4;
        m_chromaMCParams.pDst[0] += 4;
        m_chromaMCParams.pDst[1] += 4;
        CompensateMotionChromaUniDir(3, PredForward);
        break;
    }

} // void AVSDecompressor::CompensateMotionChromaPMacroBlock(void)

#define COMPENSATE_MOTION_CHROMA(block_num) \
{ \
    eAVSPredType predType; \
    predType = (eAVSPredType) m_pMbInfo->predType[block_num]; \
    if (PredBiDir == predType) \
    { \
        CompensateMotionChromaBiDir(block_num); \
    } \
    else \
    { \
        CompensateMotionChromaUniDir(block_num, predType); \
    } \
}

void AVSDecompressor::CompensateMotionChromaBMacroBlock(void)
{
    Ipp32s blockHeight;

    // set pointer to the block's beginning
    m_chromaMCParams.pDst[0] = m_recCtx.m_pPlanes8u[1];
    m_chromaMCParams.pDst[1] = m_recCtx.m_pPlanes8u[2];
    m_chromaMCParams.dstStep = m_recCtx.m_iPitch;

    // set the initial block position
    m_chromaMCParams.pointBlockPos.x = m_recCtx.MbX * 8;
    m_chromaMCParams.pointBlockPos.y = m_recCtx.MbY * 8;

    // select block size
    m_chromaMCParams.sizeBlock = AVSChromaBlockSize[m_recCtx.m_pSeqHeader->chroma_format - 1]
                                                   [m_pMbInfo->divType];
    blockHeight = m_chromaMCParams.sizeBlock.height;

    switch (m_pMbInfo->divType)
    {
    case Div_16x16:
        COMPENSATE_MOTION_CHROMA(0);
        break;

    case Div_16x8:
        COMPENSATE_MOTION_CHROMA(0);

        m_chromaMCParams.pointBlockPos.y += blockHeight;
        m_chromaMCParams.pDst[0] += m_chromaMCParams.dstStep * blockHeight;
        m_chromaMCParams.pDst[1] += m_chromaMCParams.dstStep * blockHeight;
        COMPENSATE_MOTION_CHROMA(2);
        break;

    case Div_8x16:
        COMPENSATE_MOTION_CHROMA(0);

        m_chromaMCParams.pointBlockPos.x += 4;
        m_chromaMCParams.pDst[0] += 4;
        m_chromaMCParams.pDst[1] += 4;
        COMPENSATE_MOTION_CHROMA(1);
        break;

    default:
        COMPENSATE_MOTION_CHROMA(0);

        m_chromaMCParams.pointBlockPos.x += 4;
        m_chromaMCParams.pDst[0] += 4;
        m_chromaMCParams.pDst[1] += 4;
        COMPENSATE_MOTION_CHROMA(1);

        m_chromaMCParams.pointBlockPos.x -= 4;
        m_chromaMCParams.pointBlockPos.y += blockHeight;
        m_chromaMCParams.pDst[0] += m_chromaMCParams.dstStep * blockHeight - 4;
        m_chromaMCParams.pDst[1] += m_chromaMCParams.dstStep * blockHeight - 4;
        COMPENSATE_MOTION_CHROMA(2);

        m_chromaMCParams.pointBlockPos.x += 4;
        m_chromaMCParams.pDst[0] += 4;
        m_chromaMCParams.pDst[1] += 4;
        COMPENSATE_MOTION_CHROMA(3);
        break;
    }

} // void AVSDecompressor::CompensateMotionChromaBMacroBlock(void)

#define ippiInterpolateChromaBlock_AVS_8u_P2R \
    ippiInterpolateChromaBlock_H264_8u_P2R

void AVSDecompressor::CompensateMotionChromaUniDir(Ipp32s blockNum, eAVSPredType typePred)
{
    Ipp32s refIdx;

    // set the source
    {
        AVSPicture *pRef;

        refIdx = m_pMbInfo->refIdx[typePred - 1][blockNum];
        pRef = m_pRef[typePred - 1][refIdx];
        m_chromaMCParams.pSrc[0] = pRef->m_pPlanes8u[1];
        m_chromaMCParams.pSrc[1] = pRef->m_pPlanes8u[2];
        m_chromaMCParams.srcStep = pRef->m_iPitch;
    }

    // set the vector
    m_chromaMCParams.pointVector = m_pMbInfo->mv[typePred - 1][blockNum];

    // do compensation
    ippiInterpolateChromaBlock_AVS_8u_P2R(&m_chromaMCParams);

    // do weighting
    if (m_pMbInfo->weighting_prediction)
    {
        Ipp32s chroma_scale, chroma_shift;

        // get weighting parameters
        chroma_scale = m_recCtx.m_pSlcHeader->chroma_scale[typePred - 1][refIdx];
        chroma_shift = m_recCtx.m_pSlcHeader->chroma_shift[typePred - 1][refIdx];

        ippiWeightPrediction_AVS_8u_C1R(m_chromaMCParams.pDst[0],
                                        m_chromaMCParams.dstStep,
                                        m_chromaMCParams.pDst[0],
                                        m_chromaMCParams.dstStep,
                                        chroma_scale,
                                        chroma_shift,
                                        m_chromaMCParams.sizeBlock);
        ippiWeightPrediction_AVS_8u_C1R(m_chromaMCParams.pDst[1],
                                        m_chromaMCParams.dstStep,
                                        m_chromaMCParams.pDst[1],
                                        m_chromaMCParams.dstStep,
                                        chroma_scale,
                                        chroma_shift,
                                        m_chromaMCParams.sizeBlock);
    }

} // void AVSDecompressor::CompensateMotionChromaUniDir(Ipp32s blockNum, eAVSPredType typePred)

void AVSDecompressor::CompensateMotionChromaBiDir(Ipp32s blockNum)
{
    Ipp8u tempBlock[16 * 16 + 16];
    Ipp8u *(pFrw[2]), *(pBck[2]);
    Ipp32s stepFrw, stepBck;

    //
    // do forward motion compensation
    //

    // zero motion vector - simple reset pointers
    if (0 == m_pMbInfo->mv[AVS_FORWARD][blockNum].scalar)
    {
        Ipp32s refIdx;
        AVSPicture *pRef;

        refIdx = m_pMbInfo->refIdx[AVS_FORWARD][blockNum];
        pRef = m_pRef[AVS_FORWARD][refIdx];
        pFrw[0] = pRef->m_pPlanes8u[1];
        pFrw[1] = pRef->m_pPlanes8u[2];
        stepFrw = pRef->m_iPitch;

        // calculate offset to a corresponding place in the reference picture
        pFrw[0] += m_chromaMCParams.pDst[0] - m_pPlanes8u[1];
        pFrw[1] += m_chromaMCParams.pDst[1] - m_pPlanes8u[2];

        // do weighting
        if (m_pMbInfo->weighting_prediction)
        {
            Ipp32s chroma_scale, chroma_shift;

            // get weighting parameters
            chroma_scale = m_recCtx.m_pSlcHeader->chroma_scale[AVS_FORWARD][refIdx];
            chroma_shift = m_recCtx.m_pSlcHeader->chroma_shift[AVS_FORWARD][refIdx];

            ippiWeightPrediction_AVS_8u_C1R(pFrw[0],
                                            stepFrw,
                                            m_chromaMCParams.pDst[0],
                                            m_chromaMCParams.dstStep,
                                            chroma_scale,
                                            chroma_shift,
                                            m_chromaMCParams.sizeBlock);
            ippiWeightPrediction_AVS_8u_C1R(pFrw[1],
                                            stepFrw,
                                            m_chromaMCParams.pDst[1],
                                            m_chromaMCParams.dstStep,
                                            chroma_scale,
                                            chroma_shift,
                                            m_chromaMCParams.sizeBlock);

            // set the pointers to the blocks
            pFrw[0] = m_chromaMCParams.pDst[0];
            pFrw[1] = m_chromaMCParams.pDst[1];
            stepFrw = m_chromaMCParams.dstStep;
        }
    }
    // doing honest compensation
    else
    {
        pFrw[0] = m_chromaMCParams.pDst[0];
        pFrw[1] = m_chromaMCParams.pDst[1];
        stepFrw = m_chromaMCParams.dstStep;
        CompensateMotionChromaUniDir(blockNum, PredForward);
    }

    //
    // do backward motion compensation
    //

    // zero motion vector - simple reset pointers
    if (0 == m_pMbInfo->mv[AVS_BACKWARD][blockNum].scalar)
    {
        Ipp32s refIdx;
        AVSPicture *pRef;

        refIdx = m_pMbInfo->refIdx[AVS_BACKWARD][blockNum];
        pRef = m_pRef[AVS_BACKWARD][refIdx];
        pBck[0] = pRef->m_pPlanes8u[1];
        pBck[1] = pRef->m_pPlanes8u[2];
        stepBck = pRef->m_iPitch;

        // calculate offset to a corresponding place in the reference picture
        pBck[0] += m_chromaMCParams.pDst[0] - m_pPlanes8u[1];
        pBck[1] += m_chromaMCParams.pDst[1] - m_pPlanes8u[2];

        // do weighting
        if (m_pMbInfo->weighting_prediction)
        {
            Ipp32s chroma_scale, chroma_shift;

            // get weighting parameters
            chroma_scale = m_recCtx.m_pSlcHeader->chroma_scale[AVS_BACKWARD][refIdx];
            chroma_shift = m_recCtx.m_pSlcHeader->chroma_shift[AVS_BACKWARD][refIdx];

            ippiWeightPrediction_AVS_8u_C1R(pBck[0],
                                            stepBck,
                                            align_pointer<Ipp8u *> (tempBlock, 16),
                                            16,
                                            chroma_scale,
                                            chroma_shift,
                                            m_chromaMCParams.sizeBlock);
            ippiWeightPrediction_AVS_8u_C1R(pBck[1],
                                            stepBck,
                                            align_pointer<Ipp8u *> (tempBlock, 16) + 8,
                                            16,
                                            chroma_scale,
                                            chroma_shift,
                                            m_chromaMCParams.sizeBlock);

            // set the pointers to the blocks
            pBck[0] = align_pointer<Ipp8u *> (tempBlock, 16);
            pBck[1] = align_pointer<Ipp8u *> (tempBlock, 16) + 8;
            stepBck = 16;
        }
    }
    // doing honest compensation
    else
    {
        Ipp8u *(pDstPrev[2]);
        Ipp32s stepPrev;

        // change the destination pointer
        pDstPrev[0] = m_chromaMCParams.pDst[0];
        pDstPrev[1] = m_chromaMCParams.pDst[1];
        stepPrev = m_chromaMCParams.dstStep;
        m_chromaMCParams.pDst[0] = align_pointer<Ipp8u *> (tempBlock, 16);
        m_chromaMCParams.pDst[1] = align_pointer<Ipp8u *> (tempBlock, 16) + 8;
        m_chromaMCParams.dstStep = 16;

        pBck[0] = m_chromaMCParams.pDst[0];
        pBck[1] = m_chromaMCParams.pDst[1];
        stepBck = m_chromaMCParams.dstStep;
        CompensateMotionChromaUniDir(blockNum, PredBackward);

        // restore the destination pointer
        m_chromaMCParams.pDst[0] = pDstPrev[0];
        m_chromaMCParams.pDst[1] = pDstPrev[1];
        m_chromaMCParams.dstStep = stepPrev;
    }

    // get average from two directions
    ippiInterpolateBlock_H264_8u_P3P1R(pFrw[0],
                                       pBck[0],
                                       m_chromaMCParams.pDst[0],
                                       m_chromaMCParams.sizeBlock.width,
                                       m_chromaMCParams.sizeBlock.height,
                                       stepFrw,
                                       stepBck,
                                       m_chromaMCParams.dstStep);
    ippiInterpolateBlock_H264_8u_P3P1R(pFrw[1],
                                       pBck[1],
                                       m_chromaMCParams.pDst[1],
                                       m_chromaMCParams.sizeBlock.width,
                                       m_chromaMCParams.sizeBlock.height,
                                       stepFrw,
                                       stepBck,
                                       m_chromaMCParams.dstStep);


} // void AVSDecompressor::CompensateMotionChromaBiDir(Ipp32s blockNum)

} // namespace UMC

#endif // #if defined(UMC_ENABLE_AVS_VIDEO_DECODER)