umc_h264_dec_defs_dec.h

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

    T &operator [] (Ipp32s iIndex)
    {
        // need to increase array size
        if (0 > iIndex ||
            ((size_t) iIndex >= m_nItemCount &&
             false == Reallocate(iIndex)))
        {
            return m_Null;
        }

        return m_pArray[iIndex];
    }

    const T &operator [] (Ipp32s iIndex) const
    {
        // need to increase array size
        if (0 > iIndex ||
            (size_t) iIndex >= m_nItemCount)
        {
            return m_Null;
        }

        return m_pArray[iIndex];
    }

    size_t GetItemCount(void) const
    {
        return m_nItemCount;

    }

    // Reset object to initial state
    virtual
    void Reset(void)
    {
        if (m_pArray)
            memset(m_pArray, 0, sizeof(T) * m_nItemCount);
    }

protected:
    // Release object
    void Release(void)
    {
        if (m_pArray)
        {
            // we need to reset array before destruction
            Reset();

            delete [] m_pArray;
            m_pArray = NULL;
            m_nItemCount = 0;
        }
    }

    // Increase array size
    virtual
    bool Reallocate(size_t nCount)
    {
        T *pTemp;
        size_t nAllocated;

        if (m_nItemCount > nCount)
            return true;

        // allocate a little bit more
        nAllocated = IPP_MAX(nCount * 2, 4);
        pTemp = new T [nAllocated];
        if (NULL == pTemp)
            return false;
        // save array values
        if (m_pArray)
        {
            memcpy(pTemp, m_pArray, sizeof(T) * m_nItemCount);
            delete [] m_pArray;
        }
        // reset rest values
        memset(pTemp + m_nItemCount, 0, sizeof(T) * (nAllocated - m_nItemCount));

        // save values
        m_pArray = pTemp;
        m_nItemCount = nAllocated;

        return true;

    }

    T m_Null;                                                   // (T) NULL element
    T *m_pArray;                                                // (T *) pointer to array of items
    size_t m_nItemCount;                                        // (size_t) number of items in array

};

// Declaration of thread-unsafe array class of complex types types (like pointers)
template<class T>
class H264ItemArray : public H264Array<T *>
{
public:
    // Default constructor
    H264ItemArray(void)
    {

    }

    // Destructor
    virtual
    ~H264ItemArray(void)
    {
        // It was a beauty class. But some gcc compilers can't
        // parse inherited templates. We have to make this template look ugly.
        H264Array<T *>::Release();

    }

    // Allocate one more item
    T * &AllocateOneMore(void)
    {
        bool bOk = true;
        size_t i;

        while (bOk)
        {
            // find free space
            for (i = 0; i < H264Array<T *>::m_nItemCount; i += 1)
            {
                if (NULL == H264Array<T *>::m_pArray[i])
                {
                    H264Array<T *>::m_pArray[i] = new T();
                    if (NULL == H264Array<T *>::m_pArray[i])
                    {
                        return H264Array<T *>::m_Null;
                    }

                    return H264Array<T *>::m_pArray[i];
                }
            }

            Reallocate(i);
        }

        // illegal case. It must never hapend
        return H264Array<T *>::m_Null;

    }

    size_t GetItemCount(void) const
    {
        return H264Array<T *>::m_nItemCount;

    }

    // Reset object to initial state
    virtual
    void Reset(void)
    {
        if (H264Array<T *>::m_pArray)
        {
            size_t i;

            for (i = 0; i < H264Array<T *>::m_nItemCount; i += 1)
            {
                if (H264Array<T *>::m_pArray[i])
                    delete H264Array<T *>::m_pArray[i];
                H264Array<T *>::m_pArray[i] = NULL;
            }
        }

        H264Array<T *>::Reset();
    }

protected:
    // Increase array size
    virtual
    bool Reallocate(size_t nCount)
    {
        T **pTemp;
        size_t nAllocated;

        if (H264Array<T *>::m_nItemCount > nCount)
            return true;

        // allocate a little bit more
        nAllocated = IPP_MAX(nCount * 2, 4);
        pTemp = new T * [nAllocated];
        if (NULL == pTemp)
            return false;
        // save array values
        if (H264Array<T *>::m_pArray)
        {
            memcpy(pTemp, H264Array<T *>::m_pArray, sizeof(T *) * H264Array<T *>::m_nItemCount);
            delete [] H264Array<T *>::m_pArray;
        }
        // reset rest values
        memset(pTemp + H264Array<T *>::m_nItemCount,
               0,
               sizeof(T *) * (nAllocated - H264Array<T *>::m_nItemCount));

        // save values
        H264Array<T *>::m_pArray = pTemp;
        H264Array<T *>::m_nItemCount = nAllocated;

        return true;
    }
};


// Declaration of thread-unsafe array class of complex types types (like pointers)
template<class T>
class H264StructArray : public H264Array<T *>
{
public:
    // Default constructor
    H264StructArray(void)
    {

    }

    // Destructor
    virtual
    ~H264StructArray(void)
    {
        // It was a beauty class. But some gcc compilers can't
        // parse inherited templates. We have to make this template look ugly.
        H264Array<T *>::Release();

    }

    // Allocate one more item
    T * &AllocateOneMore(void)
    {
        bool bOk = true;
        size_t i;

        while (bOk)
        {
            // find free space
            for (i = 0; i < H264Array<T *>::m_nItemCount; i += 1)
            {
                if (NULL == H264Array<T *>::m_pArray[i])
                {
                    H264Array<T *>::m_pArray[i] = new T();
                    if (NULL == H264Array<T *>::m_pArray[i])
                    {
                        return H264Array<T *>::m_Null;
                    }

                    return H264Array<T *>::m_pArray[i];
                }
            }

            Reallocate(i);
        }

        // illegal case. It must never hapend
        return H264Array<T *>::m_Null;

    }

    size_t GetItemCount(void) const
    {
        return H264Array<T *>::m_nItemCount;
    }

    // Reset object to initial state
    virtual
    void Reset(void)
    {
        if (H264Array<T *>::m_pArray)
        {
            size_t i;

            for (i = 0; i < H264Array<T *>::m_nItemCount; i += 1)
            {
                if (H264Array<T *>::m_pArray[i])
                    delete H264Array<T *>::m_pArray[i];
            }

            memset(H264Array<T *>::m_pArray, 0, sizeof(T*) * H264Array<T *>::m_nItemCount);
            H264Array<T *>::m_nItemCount = 0;
        }
    }

protected:
    // Increase array size
    virtual
    bool Reallocate(size_t nCount)
    {
        T **pTemp;
        size_t nAllocated;

        if (H264Array<T *>::m_nItemCount > nCount)
            return true;

        // allocate a little bit more
        nAllocated = nCount + 1;
        pTemp = new T * [nAllocated];
        if (NULL == pTemp)
            return false;
        // save array values
        if (H264Array<T *>::m_pArray)
        {
            memcpy(pTemp, H264Array<T *>::m_pArray, sizeof(T *) * H264Array<T *>::m_nItemCount);
            delete [] H264Array<T *>::m_pArray;
        }

        // allocate rest values
        for (Ipp32u i = (Ipp32u)H264Array<T *>::m_nItemCount; i < nAllocated; i++)
        {
            pTemp[i] = new T();
        }

        // save values
        H264Array<T *>::m_pArray = pTemp;
        H264Array<T *>::m_nItemCount = nAllocated;

        return true;
    }
};

template<class T>
inline void swapValues(T & t1, T & t2)
{
    T temp = t1;
    t1 = t2;
    t2 = temp;
}

template<typename T>
inline void storeInformationInto8x8(T* info, T value)
{
    info[0] = value;
    info[1] = value;
    info[4] = value;
    info[5] = value;
}

template<typename T>
inline void storeStructInformationInto8x8(T* info, const T &value)
{
    info[0] = value;
    info[1] = value;
    info[4] = value;
    info[5] = value;
}

template<typename T>
inline void fill_n(T *first, size_t count, T val)
{   // copy _Val _Count times through [_First, ...)
    for (; 0 < count; --count, ++first)
        *first = val;
}

template<typename T>
inline void fill_struct_n(T *first, size_t count, const T& val)
{   // copy _Val _Count times through [_First, ...)
    for (; 0 < count; --count, ++first)
        *first = val;
}

class h264_exception
{
public:
    h264_exception(Ipp32s status = -1)
        : m_Status(status)
    {
    }

    virtual ~h264_exception()
    {
    }

    Ipp32s GetStatus() const
    {
        return m_Status;
    }

private:
    Ipp32s m_Status;
};


#pragma pack(1)

extern Ipp32s lock_failed;

class AutomaticUMCMutex
{
public:
    // Constructor
    AutomaticUMCMutex(UMC::Mutex &mutex)
        : m_Mutex(mutex)
    {
        Lock();
    }

    // Destructor
    ~AutomaticUMCMutex(void)
    {
        Unlock();
    }

    void Lock()
    {
        m_Mutex.Lock();
    }

    void Unlock()
    {
        m_Mutex.Unlock();
    }

protected:
    UMC::Mutex &m_Mutex;

private:
    AutomaticUMCMutex & operator = (AutomaticUMCMutex &)
    {
        return *this;
    }
};

#pragma pack()

} // end namespace UMC

#include "umc_h264_dec_ippwrap.h"

#endif // __UMC_H264_DEC_DEFS_DEC_H__
#endif // UMC_ENABLE_H264_VIDEO_DECODER