umc_h264_dec_bitstream.cpp

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

/*
//
//              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-2005 Intel Corporation. All Rights Reserved.
//
//
*/
#include "umc_h264_bitstream.h"
#include "vm_debug.h"
#include "vm_time.h"

#include "umc_h264_dec_coeff_token_map.h"
#include "umc_h264_dec_total_zero.h"
#include "umc_h264_dec_run_before.h"

namespace UMC
{

// this pretty table was designed to
// avoid coincidencies with any GPL code
static const
Ipp32u GetBitsMask[25] =
{
    0x0,
    0x01,       0x03,       0x07,       0x0f,
    0x01f,      0x03f,      0x07f,      0x0ff,
    0x01ff,     0x03ff,     0x07ff,     0x0fff,
    0x01fff,    0x03fff,    0x07fff,    0x0ffff,
    0x01ffff,   0x03ffff,   0x07ffff,   0x0fffff,
    0x01fffff,  0x03fffff,  0x07fffff,  0x0ffffff
};

// ---------------------------------------------------------------------------
//      H264Bitstream::GetState()
//        Obtains current position of the buffer pointer.  This is only
//        used to maintain the bitstream state when calling an assembly
//        routine that accesses the bitstream.
//        *pbs        : to be assigned with the new pointer value
//        *bitOffset    : to be assigned with the new bit offset
// ---------------------------------------------------------------------------

void H264Bitstream::GetState(Ipp8u** pbs,Ipp32u* bitOffset)
{
    *pbs       = (Ipp8u*)m_pbs;
    *bitOffset = m_bitOffset;

} // H264Bitstream::GetState()


// ---------------------------------------------------------------------------
//      H264Bitstream::UpdateState()
//        Advances buffer pointer with given number of bits.  This is only
//        used to maintain the bitstream state when calling an assembly
//        routine that accesses the bitstream.
//        nbits    : number of bits to advance
// ---------------------------------------------------------------------------

void H264Bitstream::UpdateState(const Ipp32u nbits)
{
    m_pbs       += (nbits + m_bitOffset) >> 3;
    m_bitOffset = (nbits + m_bitOffset) & 0x7;

} // H264Bitstream::UpdateState()


// ---------------------------------------------------------------------------
//  H264Bitstream::H264Bitstream()
//        H.264 bitstream constructor used in the decoder
// ---------------------------------------------------------------------------

H264Bitstream::H264Bitstream( Ipp8u* const    pb,
                              const Ipp32u    maxsize)
{
    Status  sts;
    m_pbsBase    = (Ipp32u*)pb;
    m_pbs        = (Ipp32u*)pb;
    m_bitOffset    = 31;
    m_maxBsSize    = maxsize;
    m_pbsRBSPBase = m_pbsBase;

    sts = InitTables();
    VM_ASSERT(sts == UMC_OK);

} // H264Bitstream::H264Bitstream()

// ---------------------------------------------------------------------------
//  H264Bitstream::H264Bitstream()
//        default constructor used in the decoder
// ---------------------------------------------------------------------------
H264Bitstream::H264Bitstream()
{
    Status  sts;
    m_pbsRBSPBase = m_pbsBase = 0;
    m_pbs       = 0;
    m_pbsBase   = 0;
    m_bitOffset = 0;
    m_maxBsSize    = 0;

    sts = InitTables();
    VM_ASSERT(sts == UMC_OK);

} // H264Bitstream::H264Bitstream()

// ---------------------------------------------------------------------------
//  H264Bitstream::~H264Bitstream()
// ---------------------------------------------------------------------------

H264Bitstream::~H264Bitstream()
{
    FreeTables();
} // H264Bitstream::~H264Bitstream()

Status H264Bitstream::FreeTables()
{
    int i;
    ////////////////////////////////////////////////////////////
    //Number Coeffs and Trailing Ones map tables free//////////
    ////////////////////////////////////////////////////////////

    for (i = 0; i <= 3; i++ )
    {
        if(m_tblCoeffToken[i])
        {
            ippiHuffmanTableFree_32s(m_tblCoeffToken[i]);
            m_tblCoeffToken[i] = NULL;
        }
    }
    ////////////////////////////////////////////////////////////
    /////////////////////TotalZeros tables free/////////////////
    ////////////////////////////////////////////////////////////

    for(i = 1; i <= 15; i++)
    {
        if(m_tblTotalZeros[i])
        {
            ippiHuffmanTableFree_32s(m_tblTotalZeros[i]);
            m_tblTotalZeros[i] = NULL;
        }
    }

    for(i = 1; i <= 3; i++)
    {
        if(m_tblTotalZerosCR[i])
        {
            ippiHuffmanTableFree_32s(m_tblTotalZerosCR[i]);
            m_tblTotalZerosCR[i] = NULL;
        }
    }

    ///////////////////////////
    ///Run Befores free////////
    ///////////////////////////
    for(i = 1; i <= 7; i++)
    {
        if(m_tblRunBefore[i])
        {
            ippiHuffmanTableFree_32s(m_tblRunBefore[i]);
            m_tblRunBefore[i] = NULL;
        }
    }
    m_tblRunBefore[8]  = NULL;
    m_tblRunBefore[9]  = NULL;
    m_tblRunBefore[10] = NULL;
    m_tblRunBefore[11] = NULL;
    m_tblRunBefore[12] = NULL;
    m_tblRunBefore[13] = NULL;
    m_tblRunBefore[14] = NULL;
    m_tblRunBefore[15] = NULL;

    return UMC_OK;
}

Status H264Bitstream::InitTables()
{
    IppStatus ippSts;

    ////////////////////////////////////////////////////////////
    //Number Coeffs and Trailing Ones map tables alloc/////////
    ////////////////////////////////////////////////////////////
    ippSts = ippiHuffmanRunLevelTableInitAlloc_32s(coeff_token_map_02, &m_tblCoeffToken[0]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanRunLevelTableInitAlloc_32s(coeff_token_map_24, &m_tblCoeffToken[1]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanRunLevelTableInitAlloc_32s(coeff_token_map_48, &m_tblCoeffToken[2]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanRunLevelTableInitAlloc_32s(coeff_token_map_cr, &m_tblCoeffToken[3]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ////////////////////////////////////////////////////////////
    /////////////////////TotalZeros tables alloc///////////////
    ////////////////////////////////////////////////////////////
    m_tblTotalZerosCR[0]  = NULL;
    m_tblTotalZeros[0]  = NULL;


    ippSts = ippiHuffmanTableInitAlloc_32s(total_zeros_map_cr1, &m_tblTotalZerosCR[1]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanTableInitAlloc_32s(total_zeros_map_cr2, &m_tblTotalZerosCR[2]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanTableInitAlloc_32s(total_zeros_map_cr3, &m_tblTotalZerosCR[3]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanTableInitAlloc_32s(total_zeros_map_1, &m_tblTotalZeros[1]);


    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanTableInitAlloc_32s(total_zeros_map_2, &m_tblTotalZeros[2]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanTableInitAlloc_32s(total_zeros_map_3, &m_tblTotalZeros[3]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanTableInitAlloc_32s(total_zeros_map_4, &m_tblTotalZeros[4]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanTableInitAlloc_32s(total_zeros_map_5, &m_tblTotalZeros[5]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanTableInitAlloc_32s(total_zeros_map_6, &m_tblTotalZeros[6]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanTableInitAlloc_32s(total_zeros_map_7, &m_tblTotalZeros[7]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanTableInitAlloc_32s(total_zeros_map_8, &m_tblTotalZeros[8]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanTableInitAlloc_32s(total_zeros_map_9, &m_tblTotalZeros[9]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanTableInitAlloc_32s(total_zeros_map_10, &m_tblTotalZeros[10]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanTableInitAlloc_32s(total_zeros_map_11, &m_tblTotalZeros[11]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanTableInitAlloc_32s(total_zeros_map_12, &m_tblTotalZeros[12]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanTableInitAlloc_32s(total_zeros_map_13, &m_tblTotalZeros[13]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanTableInitAlloc_32s(total_zeros_map_14, &m_tblTotalZeros[14]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanTableInitAlloc_32s(total_zeros_map_15, &m_tblTotalZeros[15]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ///////////////////////////
    ///Run Befores alloc///////
    ///////////////////////////
    m_tblRunBefore[0]  = NULL;


    ippSts = ippiHuffmanTableInitAlloc_32s(run_before_map_1, &m_tblRunBefore[1]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanTableInitAlloc_32s(run_before_map_2, &m_tblRunBefore[2]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanTableInitAlloc_32s(run_before_map_3, &m_tblRunBefore[3]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanTableInitAlloc_32s(run_before_map_4, &m_tblRunBefore[4]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanTableInitAlloc_32s(run_before_map_5, &m_tblRunBefore[5]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanTableInitAlloc_32s(run_before_map_6, &m_tblRunBefore[6]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    ippSts = ippiHuffmanTableInitAlloc_32s(run_before_map_6p, &m_tblRunBefore[7]);
    if(ippSts!=ippStsNoErr)
        return UMC_ALLOC;

    m_tblRunBefore[8]  = m_tblRunBefore[7];
    m_tblRunBefore[9]  = m_tblRunBefore[7];
    m_tblRunBefore[10] = m_tblRunBefore[7];
    m_tblRunBefore[11] = m_tblRunBefore[7];
    m_tblRunBefore[12] = m_tblRunBefore[7];
    m_tblRunBefore[13] = m_tblRunBefore[7];
    m_tblRunBefore[14] = m_tblRunBefore[7];
    m_tblRunBefore[15] = m_tblRunBefore[7];

    return UMC_OK;

} // H264Bitstream::H264Bitstream()



// ---------------------------------------------------------------------------
//  H264Bitstream::Reset()
//        reset bitstream; used in the decoder
// ---------------------------------------------------------------------------

void H264Bitstream::Reset( Ipp8u* const    pb, const Ipp32u maxsize)
{
    m_pbs       = (Ipp32u*)pb;
    m_pbsBase   = (Ipp32u*)pb;
    m_bitOffset = 31;
    m_maxBsSize    = maxsize;

    m_pbsRBSPBase = m_pbsBase;

} // H264Bitstream::Reset()

void H264Bitstream::Reset( Ipp8u* const    pb, Ipp32s offset, const Ipp32u maxsize)
{
    m_pbs       = (Ipp32u*)pb;
    m_pbsBase   = (Ipp32u*)pb;
    m_bitOffset = offset;
    m_maxBsSize    = maxsize;

    m_pbsRBSPBase = m_pbsBase;

} // H264Bitstream::Reset()


void H264Bitstream::RollbackCurrentNALU()
{
    ippiUngetBits32(m_pbs,m_bitOffset);
}
// ---------------------------------------------------------------------------
//  H264Bitstream::GetSCP()
//  Determine if next bistream symbol is a start code. If not,
//  do not change bitstream position and return false. If yes, advance
//  bitstream position to first symbol following SCP and return true.
//
//  A start code is:
//  * next 2 bytes are zero
//  * next non-zero byte is '01'
//  * may include extra stuffing zero bytes
// ---------------------------------------------------------------------------
Ipp32s H264Bitstream::GetSCP()
{
    Ipp32s code, code1,tmp;
    Ipp32u* ptr_state = m_pbs;
    Ipp32s  bit_state = m_bitOffset;
    VM_ASSERT(m_bitOffset >= 0 && m_bitOffset <= 31);