umc_avs_dec_decompressor_dec_i.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_sequence_header.h"
#include "umc_avs_picture_header.h"
#include "umc_avs_dec_bit_stream.h"
#include "umc_avs_dec_mb_info.h"
#include "umc_avs_dec_tables.h"

namespace UMC
{

void AVSDecompressor::DecodeIMacroBlocksRow(void)
{
    MbMax = m_decCtx.MbIndex + m_decCtx.MbWidth;

    // we can use MbIndex either from decoding and reconstructing contexts
    MbIndex = m_decCtx.MbIndex;

    PrepareNeighbours(&m_decCtx);
    PrepareDecoding();
    // set coeffs buffers
    m_pWriteCoeffs = m_decCtx.m_pCoeffs;

    do
    {
        ResetMacroblock();

        // decode next macroblock
        DecodeIMacroBlockType();
        DecodeIMacroBlock();

        MbIndex += 1;
        AdvanceNeighbours();
        AdvanceDecoding();

    } while (MbIndex < MbMax);

    // update context
    FinalizeDecoding();

} // void AVSDecompressor::DecodeIMacroBlocksRow(void)

void AVSDecompressor::DecodeIMacroBlockType(void)
{
    // set default parameters for I macroblock
    m_pMbInfo->MbType = I_8x8;
    m_pMbInfo->MbCBP = AVS_CBP_UNKNOWN;
    m_pMbInfo->QP = m_decCtx.PreviousQP;

} // void AVSDecompressor::DecodeIMacroBlockType(void)

void AVSDecompressor::DecodeIMacroBlock(void)
{
    Ipp32s i;

    // decode luminance prediction modes
    for (i = 0; i < 4; i += 1)
    {
        // get prediction mode for each block
        pred_mode_flag[i] = (Ipp8u) GetBit(&m_decCtx.m_stream);
        if (0 == pred_mode_flag[i])
        {
            intra_luma_pred_mode[i] = (Ipp8s) GetBits(&m_decCtx.m_stream, 2);
        }
    }

    // restore prediction modes
    {
        AVS_MB_INFO *pLeft = m_pMbInfoLeft, *pTop = m_pMbInfoTop;

        // we can predict modes only from I macroblock(s)
        if ((pLeft) &&
            (I_8x8 != pLeft->MbType))
            pLeft = NULL;
        if ((pTop) &&
            (I_8x8 != pTop->MbType))
            pTop = NULL;

        SpecifyIntraPredModeISlice(pLeft, pTop, 0);
        SpecifyIntraPredModeISlice(m_pMbInfo, pTop, 1);
        SpecifyIntraPredModeISlice(pLeft, m_pMbInfo, 2);
        SpecifyIntraPredModeISlice(m_pMbInfo, m_pMbInfo, 3);
    }

    // decode chrominance prediction mode(s)
    m_pMbInfo->IntraChromaPredMode[0] = (IppIntraChromaPredMode_H264) GetUE(&m_decCtx.m_stream);
    if (AVS_CHROMA_422_FORMAT == m_decCtx.m_pSeqHeader->chroma_format)
    {
        m_pMbInfo->IntraChromaPredMode[1] = (IppIntraChromaPredMode_H264) GetUE(&m_decCtx.m_stream);
    }

    if (AVS_CBP_UNKNOWN == m_pMbInfo->MbCBP)
    {
        Ipp32u uTemp;
        Ipp32s mb_qp_delta = 0;

        // decode coded block pattern
        uTemp = GetUE(&m_decCtx.m_stream);
        // error handling
        if (63 < uTemp)
            throw (int) 0;
        m_pMbInfo->MbCBP = CBPOfMacroblock[AVS_INTRA][uTemp];
        if (AVS_CHROMA_422_FORMAT == m_decCtx.m_pSeqHeader->chroma_format)
        {
            uTemp = GetUE(&m_decCtx.m_stream);
            m_pMbInfo->MbCBP |= uTemp << 6;
        }

        // decode quantization parameter
        if ((m_pMbInfo->MbCBP) &&
            (0 == m_decCtx.FixedQP))
        {
            mb_qp_delta = GetSE(&m_decCtx.m_stream);
            if (63 < mb_qp_delta + 32)
                throw (int) 0;
            m_pMbInfo->QP += mb_qp_delta;
            m_decCtx.PreviousQP += mb_qp_delta;
        }
    }

    // decode blocks coefficients
    {
        Ipp32u uBlockMask = 1;

        // decode luminance blocks
        for (i = 0; i < 4; i += 1, uBlockMask += uBlockMask)
        {
            if (m_pMbInfo->MbCBP & uBlockMask)
            {
                Ipp32s iNumCoeffs;

                ippiDecodeLumaBlockIntra_AVS_1u16s(&m_decCtx.m_stream.src,
                                                   &m_decCtx.m_stream.offset,
                                                   &iNumCoeffs,
                                                   m_pWriteCoeffs,
                                                   m_decCtx.ScanType);
                m_pMbInfo->NumCoeffs[i] = (Ipp8u) iNumCoeffs;
                m_pWriteCoeffs += 64;
            }
        }

        // decode chrominance blocks
        for (; i < m_decCtx.iNumberOfBlocks; i += 1, uBlockMask += uBlockMask)
        {
            if (m_pMbInfo->MbCBP & uBlockMask)
            {
                Ipp32s iNumCoeffs;

                ippiDecodeChromaBlock_AVS_1u16s(&m_decCtx.m_stream.src,
                                                &m_decCtx.m_stream.offset,
                                                &iNumCoeffs,
                                                m_pWriteCoeffs,
                                                m_decCtx.ScanType);
                m_pMbInfo->NumCoeffs[i] = (Ipp8u) iNumCoeffs;
                m_pWriteCoeffs += 64;
            }
        }
    }

} // void AVSDecompressor::DecodeIMacroBlock(void)

} // namespace UMC

#endif // #if defined(UMC_ENABLE_AVS_VIDEO_DECODER)