umc_h264_sd_inlines.h

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) 2003-2007 Intel Corporation. All Rights Reserved.
//
//
*/
#include "umc_defs.h"
#if defined (UMC_ENABLE_H264_VIDEO_DECODER)

#ifndef __UMC_H264_SEGMENT_DECODER_INLINES_H
#define __UMC_H264_SEGMENT_DECODER_INLINES_H

using namespace UMC_H264_DECODER;

namespace UMC
{
//
// Class to incapsulate functions, implementing common decoding functional.
//

inline
Ipp32u BIT_CHECK(const Ipp32u value, Ipp32s n)
{
    return (Ipp32u)((value & mask_bit[n]) >> n);
}

inline
Ipp32u IsLeftBlockExist(Ipp32s iCBP, Ipp32s iBlock)
{
    return (((Ipp32u) -(iCBP & iLeftBlockMask[iBlock])) >> 31);

} // Ipp32u IsLeftBlockExist(Ipp32s iCBP, Ipp32s iBlock)

inline
Ipp32u IsTopBlockExist(Ipp32s iCBP, Ipp32s iBlock)
{
    return (((Ipp32u) -(iCBP & iTopBlockMask[iBlock])) >> 31);
} // Ipp32u IsTopBlockExist(Ipp32s iCBP, Ipp32s iBlock)


// Get context functions
inline
Ipp32u H264SegmentDecoder::GetDCBlocksLumaContext()
{
    bool use_above = m_cur_mb.CurrentBlockNeighbours.mb_above.mb_num>=0;
    bool use_left = m_cur_mb.CurrentBlockNeighbours.mbs_left[0].mb_num>=0;
    Ipp32u above_coeffs=use_above?
        m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mb_above.mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mb_above.block_num]:0;
    Ipp32u left_coeffs=use_left?
        m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mbs_left[0].mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mbs_left[0].block_num]:0;
    if(use_above && use_left) return (above_coeffs+left_coeffs+1)/2;
    else if (use_above ) return above_coeffs;
    else if (use_left) return left_coeffs;
    else return 0;
}

// an universal function for an every case of the live
inline
Ipp32u H264SegmentDecoder::GetBlocksLumaContext(Ipp32s x,Ipp32s y)
{
    bool use_above = y || m_cur_mb.CurrentBlockNeighbours.mb_above.mb_num>=0;
    bool use_left = x || m_cur_mb.CurrentBlockNeighbours.mbs_left[y].mb_num>=0;
    Ipp8u above_coeffs=0;
    if (use_above) above_coeffs= y==0?
        m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mb_above.mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mb_above.block_num+x]:
        m_mbinfo.MacroblockCoeffsInfo[m_CurMBAddr].numCoeff[y*4+x-4];
    Ipp8u left_coeffs=0;
    if (use_left)left_coeffs = x==0?
        m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mbs_left[y].mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mbs_left[y].block_num]:
        m_mbinfo.MacroblockCoeffsInfo[m_CurMBAddr].numCoeff[y*4+x-1];

    if(use_above && use_left) return (above_coeffs+left_coeffs+1)/2;
    else if (use_above ) return above_coeffs;
    else if (use_left) return left_coeffs;
    else return 0;
}

// a function for the first luma block in a macroblock
inline
Ipp32s H264SegmentDecoder::GetBlocksLumaContextExternal(void)
{
    bool use_above = m_cur_mb.CurrentBlockNeighbours.mb_above.mb_num >= 0;
    bool use_left = m_cur_mb.CurrentBlockNeighbours.mbs_left[0].mb_num >= 0;
    Ipp32s above_coeffs, left_coeffs;

    if (use_above && use_left)
    {
        above_coeffs = m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mb_above.mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mb_above.block_num];
        left_coeffs = m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mbs_left[0].mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mbs_left[0].block_num];

        return (above_coeffs + left_coeffs + 1) / 2;
    }
    else if (use_above)
    {
        above_coeffs = m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mb_above.mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mb_above.block_num];

        return above_coeffs;
    }
    else if (use_left)
    {
        left_coeffs = m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mbs_left[0].mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mbs_left[0].block_num];

        return left_coeffs;
    }
    else
        return 0;

} // Ipp32s GetBlocksLumaContextExternal(void)

// a function for a block on the upper edge of a macroblock,
// but not for the first block
inline
Ipp32s H264SegmentDecoder::GetBlocksLumaContextTop(Ipp32s x, Ipp32s left_coeffs)
{
    bool use_above = m_cur_mb.CurrentBlockNeighbours.mb_above.mb_num >= 0;
    Ipp32s above_coeffs;

    if (use_above)
    {
        above_coeffs = m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mb_above.mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mb_above.block_num + x];
        return (above_coeffs + left_coeffs + 1) / 2;
    }
    else
        return left_coeffs;

} // Ipp32s GetBlocksLumaContextTop(Ipp32s x, Ipp32s left_coeffs)

// a function for a block on the left edge of a macroblock,
// but not for the first block
inline
Ipp32u H264SegmentDecoder::GetBlocksLumaContextLeft(Ipp32s y, Ipp32s above_coeffs)
{
    bool use_left = m_cur_mb.CurrentBlockNeighbours.mbs_left[y].mb_num >= 0;
    Ipp32s left_coeffs;

    if (use_left)
    {
        left_coeffs = m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mbs_left[y].mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mbs_left[y].block_num];
        return (above_coeffs + left_coeffs + 1) / 2;
    }
    else
        return above_coeffs;

} // Ipp32u GetBlocksLumaContextLeft(Ipp32s y, Ipp32s above_coeffs)

// a function for any internal block of a macroblock
inline
Ipp32u H264SegmentDecoder::GetBlocksLumaContextInternal(Ipp32s x, Ipp32s y, Ipp8u *pNumCoeffsArray)
{
    return (pNumCoeffsArray[y * 4 + x - 1] +
            pNumCoeffsArray[(y - 1) * 4 + x] + 1) / 2;

} // Ipp32u GetBlocksLumaContextInternal(Ipp32s x, Ipp32s y, Ipp8u *pNumCoeffsArray)

// an universal function for an every case of the live
inline
Ipp32u H264SegmentDecoder::GetBlocksChromaContextBMEH(Ipp32s x,Ipp32s y,Ipp32s component)
{
    Ipp8u above_coeffs=0;
    Ipp8u left_coeffs=0;
    bool use_above;
    bool use_left;
    if (component)
    {
        use_above = y || m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[1].mb_num>=0;
        use_left = x || m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[1][y].mb_num>=0;
        if (use_above)
            above_coeffs=y==0?
                m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[1].mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[1].block_num+x]:
                m_mbinfo.MacroblockCoeffsInfo[m_CurMBAddr].numCoeff[y*2+x-2+20];
        if (use_left)
            left_coeffs=x==0?
                m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[1][y].mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[1][y].block_num]:
                m_mbinfo.MacroblockCoeffsInfo[m_CurMBAddr].numCoeff[y*2+x-1+20];
    }
    else
    {
        use_above = y || m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[0].mb_num>=0;
        use_left = x || m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[0][y].mb_num>=0;
        if (use_above)
            above_coeffs=y==0?
                m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[0].mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[0].block_num+x]:
                m_mbinfo.MacroblockCoeffsInfo[m_CurMBAddr].numCoeff[y*2+x-2+16];
        if (use_left)
            left_coeffs=x==0?
                m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[0][y].mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[0][y].block_num]:
                m_mbinfo.MacroblockCoeffsInfo[m_CurMBAddr].numCoeff[y*2+x-1+16];
    }

    if(use_above && use_left) return (above_coeffs+left_coeffs+1)/2;
    else if (use_above ) return above_coeffs;
    else if (use_left) return left_coeffs;
    else return 0;
}

// a function for the first block in a macroblock
inline
Ipp32s H264SegmentDecoder::GetBlocksChromaContextBMEHExternal(Ipp32s iComponent)
{
    bool use_above = m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[iComponent].mb_num >= 0;
    bool use_left = m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[iComponent][0].mb_num >= 0;
    Ipp32s above_coeffs, left_coeffs;

    if (use_above && use_left)
    {
        above_coeffs = m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[iComponent].mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[iComponent].block_num];
        left_coeffs = m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[iComponent][0].mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[iComponent][0].block_num];
        return (above_coeffs + left_coeffs + 1) / 2;
    }
    else if (use_above)
    {
        above_coeffs = m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[iComponent].mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[iComponent].block_num];
        return above_coeffs;
    }
    else if (use_left)
    {
        left_coeffs = m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[iComponent][0].mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[iComponent][0].block_num];
        return left_coeffs;
    }
    else
        return 0;

} // Ipp32s GetBlocksChromaContextBMEHExternal(Ipp32s iComponent)

// a function for a block on the upper edge of a macroblock,
// but not for the first block
inline
Ipp32s H264SegmentDecoder::GetBlocksChromaContextBMEHTop(Ipp32s x, Ipp32s left_coeffs, Ipp32s iComponent)
{
    bool use_above = m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[iComponent].mb_num >= 0;
    Ipp32s above_coeffs;

    if (use_above)
    {
        above_coeffs = m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[iComponent].mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[iComponent].block_num + x];
        return (above_coeffs + left_coeffs + 1) / 2;
    }
    else
        return left_coeffs;

} // Ipp32s GetBlocksChromaContextBMEHTop(Ipp32s x, Ipp32s left_coeffs, Ipp32s iComponent)

// a function for a block on the left edge of a macroblock,
// but not for the first block
inline
Ipp32s H264SegmentDecoder::GetBlocksChromaContextBMEHLeft(Ipp32s y, Ipp32s above_coeffs, Ipp32s iComponent)
{
    bool use_left = m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[iComponent][0].mb_num >= 0;
    Ipp32s left_coeffs;

    if (use_left)
    {
        left_coeffs = m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[iComponent][y].mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[iComponent][y].block_num];
        return (above_coeffs + left_coeffs + 1) / 2;
    }
    else
        return above_coeffs;

} // Ipp32s GetBlocksChromaContextBMEHLeft(Ipp32s y, Ipp32s above_coeffs, Ipp32s iComponent)

// a function for any internal block of a macroblock
inline
Ipp32s H264SegmentDecoder::GetBlocksChromaContextBMEHInternal(Ipp32s x, Ipp32s y, Ipp8u *pNumCoeffsArray)
{
    return (pNumCoeffsArray[y * 2 + x - 1] +
            pNumCoeffsArray[(y - 1) * 2 + x] + 1) / 2;

} // Ipp32s GetBlocksChromaContextBMEHInternal(Ipp32s x, Ipp32s y, Ipp8u *pNumCoeffsArray)

inline
Ipp32u H264SegmentDecoder::GetBlocksChromaContextH2(Ipp32s x,Ipp32s y,Ipp32s component)
{
    Ipp8u above_coeffs=0;
    Ipp8u left_coeffs=0;
    bool use_above;
    bool use_left;
    if (component)
    {
        use_above = y || m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[1].mb_num>=0;
        use_left = x || m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[1][y].mb_num>=0;
        if (use_above)
            above_coeffs=y==0?
            m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[1].mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[1].block_num+x]:
        m_mbinfo.MacroblockCoeffsInfo[m_CurMBAddr].numCoeff[y*2+x-2+24];
        if (use_left)
            left_coeffs=x==0?
            m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[1][y].mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[1][y].block_num]:
        m_mbinfo.MacroblockCoeffsInfo[m_CurMBAddr].numCoeff[y*2+x-1+24];
    }
    else
    {
        use_above = y || m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[0].mb_num>=0;
        use_left = x || m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[0][y].mb_num>=0;
        if (use_above)
            above_coeffs=y==0?
            m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[0].mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[0].block_num+x]:
        m_mbinfo.MacroblockCoeffsInfo[m_CurMBAddr].numCoeff[y*2+x-2+16];
        if (use_left)
            left_coeffs=x==0?
            m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[0][y].mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[0][y].block_num]:
        m_mbinfo.MacroblockCoeffsInfo[m_CurMBAddr].numCoeff[y*2+x-1+16];
    }

    if(use_above && use_left) return (above_coeffs+left_coeffs+1)/2;
    else if (use_above ) return above_coeffs;
    else if (use_left) return left_coeffs;
    else return 0;
}

inline
Ipp32u H264SegmentDecoder::GetBlocksChromaContextH4(Ipp32s x,Ipp32s y,Ipp32s component)
{
    Ipp8u above_coeffs=0;
    Ipp8u left_coeffs=0;
    bool use_above;
bool use_left;
    if (component)
    {
        use_above = y || m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[1].mb_num>=0;
        use_left = x || m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[1][y].mb_num>=0;
        if (use_above)
            above_coeffs=y==0?
            m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[1].mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[1].block_num+x]:
        m_mbinfo.MacroblockCoeffsInfo[m_CurMBAddr].numCoeff[y*4+x-4+32];
        if (use_left)
            left_coeffs=x==0?
            m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[1][y].mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[1][y].block_num]:
        m_mbinfo.MacroblockCoeffsInfo[m_CurMBAddr].numCoeff[y*4+x-1+32];
    }
    else
    {
        use_above = y || m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[0].mb_num>=0;
        use_left = x || m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[0][y].mb_num>=0;
        if (use_above)
            above_coeffs=y==0?
            m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[0].mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mb_above_chroma[0].block_num+x]:
        m_mbinfo.MacroblockCoeffsInfo[m_CurMBAddr].numCoeff[y*4+x-4+16];
        if (use_left)
            left_coeffs=x==0?
            m_mbinfo.MacroblockCoeffsInfo[m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[0][y].mb_num].numCoeff[m_cur_mb.CurrentBlockNeighbours.mbs_left_chroma[0][y].block_num]:
        m_mbinfo.MacroblockCoeffsInfo[m_CurMBAddr].numCoeff[y*4+x-1+16];
    }

    if(use_above && use_left) return (above_coeffs+left_coeffs+1)/2;
    else if (use_above ) return above_coeffs;
    else if (use_left) return left_coeffs;
    else return 0;
}

inline
void H264SegmentDecoder::GetLeftLocationForCurrentMBLumaNonMBAFF(H264DecoderBlockLocation *Block)
{
    //luma
    if (BLOCK_IS_ON_LEFT_EDGE(Block->block_num))
    {
        Block->block_num+=3;
        Block->mb_num=m_cur_mb.CurrentMacroblockNeighbours.mb_A;
    }
    else
    {
        Block->block_num--;
        Block->mb_num=m_CurMBAddr;
    }

    return;

} // void H264SegmentDecoder::GetLeftLocationForCurrentMBLumaNonMBAFF(H264DecoderBlockLocation *Block)

inline
void H264SegmentDecoder::GetTopLocationForCurrentMBLumaNonMBAFF(H264DecoderBlockLocation *Block)
{
    //luma
    if (BLOCK_IS_ON_TOP_EDGE(Block->block_num))
    {
        Block->block_num+=12;
        Block->mb_num  = m_cur_mb.CurrentMacroblockNeighbours.mb_B;
    }
    else
    {
        Block->block_num-=4;
        Block->mb_num = m_CurMBAddr;
    }

    return;

} // void H264SegmentDecoder::GetTopLocationForCurrentMBLumaNonMBAFF(H264DecoderBlockLocation *Block)

inline
void H264SegmentDecoder::GetTopLeftLocationForCurrentMBLumaNonMBAFF(H264DecoderBlockLocation *Block)
{
    //luma
    if (BLOCK_IS_ON_LEFT_EDGE(Block->block_num) && BLOCK_IS_ON_TOP_EDGE(Block->block_num))
    {
        Block->block_num+=15;
        Block->mb_num = m_cur_mb.CurrentMacroblockNeighbours.mb_D;
    }
    else if (BLOCK_IS_ON_LEFT_EDGE(Block->block_num))
    {
        Block->block_num--;
        Block->mb_num = m_cur_mb.CurrentMacroblockNeighbours.mb_A;
    }
    else if ( BLOCK_IS_ON_TOP_EDGE(Block->block_num))
    {
        Block->block_num+=11;
        Block->mb_num = m_cur_mb.CurrentMacroblockNeighbours.mb_B;
    }
    else
    {
        Block->block_num-=5;
        Block->mb_num = m_CurMBAddr;
    }

    return;

} // void H264SegmentDecoder::GetTopLeftLocationForCurrentMBLumaNonMBAFF(H264DecoderBlockLocation *Block)

inline
void H264SegmentDecoder::GetTopRightLocationForCurrentMBLumaNonMBAFF(H264DecoderBlockLocation *Block)
{
    //luma
    if (Block->block_num==3)
    {
        Block->block_num+=9;
        Block->mb_num = m_cur_mb.CurrentMacroblockNeighbours.mb_C;
    }
    else if ( BLOCK_IS_ON_TOP_EDGE(Block->block_num))
    {
        Block->block_num+=13;
        Block->mb_num = m_cur_mb.CurrentMacroblockNeighbours.mb_B;