umc_avs_dec_decompressor_pred_inter_direct.cpp

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

/*
//
//              INTEL CORPORATION PROPRIETARY INFORMATION
//  This software is supplied under the terms of a license  agreement or
//  nondisclosure agreement with Intel Corporation and may not be copied
//  or disclosed except in  accordance  with the terms of that agreement.
//    Copyright (c) 2007 Intel Corporation. All Rights Reserved.
//
//
*/

#include "umc_defs.h"
#if defined(UMC_ENABLE_AVS_VIDEO_DECODER)

#include "umc_avs_dec_decompressor.h"
#include "umc_avs_picture_header.h"
#include "umc_avs_dec_mb_info.h"
#include "umc_avs_dec_pic.h"

namespace UMC
{

void AVSDecompressor::ReconstructMotionVectorsBSliceDirect(void)
{
    AVS_MB_INFO *pMbInfo;
    Ipp32s refBw;

    // get backward reference index
    refBw = m_pMbInfo->refIdx[AVS_BACKWARD][0];
    // get the corresponding block
    pMbInfo = m_pRef[AVS_BACKWARD][refBw]->m_pMbInfo + MbIndex;

    if ((Div_16x16 == pMbInfo->divType) ||
        (I_8x8 == pMbInfo->MbType))
    {
        // reconstruct the motion vector...
        ReconstructDirectMotionVector(0);

        // ... and clone it
        m_pMbInfo->mv[AVS_FORWARD][1] = m_pMbInfo->mv[AVS_FORWARD][0];
        m_pMbInfo->mv[AVS_FORWARD][2] = m_pMbInfo->mv[AVS_FORWARD][0];
        m_pMbInfo->mv[AVS_FORWARD][3] = m_pMbInfo->mv[AVS_FORWARD][0];
        m_pMbInfo->mv[AVS_BACKWARD][1] = m_pMbInfo->mv[AVS_BACKWARD][0];
        m_pMbInfo->mv[AVS_BACKWARD][2] = m_pMbInfo->mv[AVS_BACKWARD][0];
        m_pMbInfo->mv[AVS_BACKWARD][3] = m_pMbInfo->mv[AVS_BACKWARD][0];
    }
    else if (Div_16x8 == pMbInfo->divType)
    {
        // reconstruct the motion vector...
        ReconstructDirectMotionVector(0);

        // ... and clone it
        m_pMbInfo->mv[AVS_FORWARD][1] = m_pMbInfo->mv[AVS_FORWARD][0];
        m_pMbInfo->mv[AVS_BACKWARD][1] = m_pMbInfo->mv[AVS_BACKWARD][0];

        // reconstruct the motion vector...
        ReconstructDirectMotionVector(2);

        // ... and clone it
        m_pMbInfo->mv[AVS_FORWARD][3] = m_pMbInfo->mv[AVS_FORWARD][2];
        m_pMbInfo->mv[AVS_BACKWARD][3] = m_pMbInfo->mv[AVS_BACKWARD][2];

        // correct type division type
        m_pMbInfo->divType = Div_16x8;
    }
    else if (Div_8x16 == pMbInfo->divType)
    {
        // reconstruct the motion vector...
        ReconstructDirectMotionVector(0);

        // ... and clone it
        m_pMbInfo->mv[AVS_FORWARD][2] = m_pMbInfo->mv[AVS_FORWARD][0];
        m_pMbInfo->mv[AVS_BACKWARD][2] = m_pMbInfo->mv[AVS_BACKWARD][0];

        // reconstruct the motion vector...
        ReconstructDirectMotionVector(1);

        // ... and clone it
        m_pMbInfo->mv[AVS_FORWARD][3] = m_pMbInfo->mv[AVS_FORWARD][1];
        m_pMbInfo->mv[AVS_BACKWARD][3] = m_pMbInfo->mv[AVS_BACKWARD][1];

        // correct type division type
        m_pMbInfo->divType = Div_8x16;
    }
    else
    {
        // reconstruct the motion vectors
        ReconstructDirectMotionVector(0);
        ReconstructDirectMotionVector(1);
        ReconstructDirectMotionVector(2);
        ReconstructDirectMotionVector(3);

        // correct type division type
        m_pMbInfo->divType = Div_8x8;
    }

} // void AVSDecompressor::ReconstructMotionVectorsBSliceDirect(void)

void AVSDecompressor::ReconstructDirectMotionVector(Ipp32s blockNum)
{
    Ipp32s refBw;

    // get backward reference index
    refBw = m_pMbInfo->refIdx[AVS_BACKWARD][blockNum];

    // check the type of a corresponding block in the backward reference picture
    if (I_8x8 == m_pRef[AVS_BACKWARD][refBw]->m_pMbInfo[MbIndex].MbType)
    {
        // we must use the reference picture #1
        m_pMbInfo->refIdx[AVS_FORWARD][blockNum] = 0;
        m_pMbInfo->refIdx[AVS_BACKWARD][blockNum] = 0;

        // calculate the forward motion vector
        GetMotionVectorPredictor16x16(PredForward);
        m_pMbInfo->mv[AVS_FORWARD][blockNum] = m_mvPred;

        // calculate the backward motion vector
        GetMotionVectorPredictor16x16(PredBackward);
        m_pMbInfo->mv[AVS_BACKWARD][blockNum] = m_mvPred;
    }
    else
    {
        Ipp32s BlockDistanceFw, BlockDistanceBw;
        Ipp32s DistanceIndexFw, DistanceIndexBw;
        Ipp32s BlockDistanceRef;
        Ipp32s DistanceIndexRef;
        AVSMVector mvRef;

        //
        // FIRST STEP
        //

        // frame coding
        if (m_decCtx.m_pPicHeader->picture_structure)
        {
            AVSPicture *pRef;
            AVS_MB_INFO *pMbInfo;
            Ipp32s refIdx;

            // get reference motion vector and distance index
            pRef = m_pRef[AVS_BACKWARD][0];
            pMbInfo = pRef->m_pMbInfo + MbIndex;
            mvRef = pMbInfo->mv[AVS_FORWARD][blockNum];
            refIdx = pMbInfo->refIdx[AVS_FORWARD][blockNum];
            DistanceIndexRef = pRef->m_distIdx[refIdx];

            // get distances
            DistanceIndexFw = m_pRef[AVS_FORWARD][0]->m_picHeader.picture_distance * 2;
            DistanceIndexBw = m_pRef[AVS_BACKWARD][0]->m_picHeader.picture_distance * 2;

            BlockDistanceFw = m_blockDist[AVS_FORWARD][0];
            BlockDistanceBw = m_blockDist[AVS_BACKWARD][0];

        }
        // field coding
        else
        {
            AVS_MB_INFO *pMbInfo;

            // get reference motion vector and distance index
            pMbInfo = m_pRef[AVS_BACKWARD][0]->m_pMbInfo + MbIndex;
            mvRef = pMbInfo->mv[AVS_FORWARD][blockNum];
            DistanceIndexRef = pMbInfo->refIdx[AVS_FORWARD][blockNum];

            // get forward distances
            {
                Ipp32s DistanceIndexFw0, DistanceIndexFw1;

                DistanceIndexFw0 = m_pRef[AVS_FORWARD][0]->m_picHeader.picture_distance;
                DistanceIndexFw1 = m_pRef[AVS_FORWARD][1]->m_picHeader.picture_distance;

                if (DistanceIndexFw0 == DistanceIndexRef)
                {
                    DistanceIndexFw = DistanceIndexFw0;
                }
                else
                {
                    DistanceIndexFw = DistanceIndexFw1;
                    m_pMbInfo->refIdx[AVS_FORWARD][blockNum] = 1;
                }
            }

            // get backward distances
            if (0 == m_decCtx.isSecondField)
            {
                DistanceIndexBw = m_pRef[AVS_BACKWARD][0]->m_picHeader.picture_distance;
            }
            else
            {
                DistanceIndexBw = m_pRef[AVS_BACKWARD][1]->m_picHeader.picture_distance;
                m_pMbInfo->refIdx[AVS_BACKWARD][blockNum] = 1;
            }
        }

        //
        // SECOND STEP
        //
        {
            Ipp32s DistanceIndexCur;

            BlockDistanceRef = IPP_MAX(1, (DistanceIndexBw - DistanceIndexRef + 512) % 512);
            DistanceIndexCur = m_decCtx.m_pPicHeader->picture_distance * 2;

            BlockDistanceFw = (DistanceIndexCur - DistanceIndexFw + 512) % 512;
            BlockDistanceBw = (DistanceIndexBw - DistanceIndexCur + 512) % 512;

            // current picture is a frame
            if (m_decCtx.m_pPicHeader->picture_structure)
            {
                // but backward reference is a field pair
                if (0 == m_pRef[AVS_BACKWARD][0]->m_picHeader.picture_structure)
                {
                    mvRef.vector.y *= 2;
                }
            }
            // current picture is a field
            else
            {
                // but backward reference is a frame
                if (1 == m_pRef[AVS_BACKWARD][0]->m_picHeader.picture_structure)
                {
                    mvRef.vector.y /= 2;
                }
            }
        }

        //
        // THIRD STEP
        //
        {
            AVSMVector mvFw, mvBw;

            if (0 > mvRef.vector.x)
            {
                mvFw.vector.x = (Ipp16s) -(((16384 / BlockDistanceRef) *
                                            (1 - mvRef.vector.x * BlockDistanceFw) - 1) >> 14);
                mvBw.vector.x = (Ipp16s) (((16384 / BlockDistanceRef) *
                                           (1 - mvRef.vector.x * BlockDistanceBw) - 1) >> 14);
            }
            else
            {
                mvFw.vector.x = (Ipp16s) (((16384 / BlockDistanceRef) *
                                           (1 + mvRef.vector.x * BlockDistanceFw) - 1) >> 14);
                mvBw.vector.x = (Ipp16s) -(((16384 / BlockDistanceRef) *
                                            (1 + mvRef.vector.x * BlockDistanceBw) - 1) >> 14);
            }

            if (0 > mvRef.vector.y)
            {
                mvFw.vector.y = (Ipp16s) -(((16384 / BlockDistanceRef) *
                                            (1 - mvRef.vector.y * BlockDistanceFw) - 1) >> 14);
                mvBw.vector.y = (Ipp16s) (((16384 / BlockDistanceRef) *
                                           (1 - mvRef.vector.y * BlockDistanceBw) - 1) >> 14);
            }
            else
            {
                mvFw.vector.y = (Ipp16s) (((16384 / BlockDistanceRef) *
                                           (1 + mvRef.vector.y * BlockDistanceFw) - 1) >> 14);
                mvBw.vector.y = (Ipp16s) -(((16384 / BlockDistanceRef) *
                                            (1 + mvRef.vector.y * BlockDistanceBw) - 1) >> 14);
            }

            m_pMbInfo->mv[AVS_FORWARD][blockNum] = mvFw;
            m_pMbInfo->mv[AVS_BACKWARD][blockNum] = mvBw;
        }
    }

    // set the prediction type
    m_pMbInfo->predType[blockNum] = PredBiDir;

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

} // namespace UMC

#endif // #if defined(UMC_ENABLE_AVS_VIDEO_DECODER)