umc_vc1_dec_task_store.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) 2004-2007 Intel Corporation. All Rights Reserved.
//
//
//          VC-1 (VC1) decoder, Task processing base on H264
//
*/
#include "umc_defs.h"
#if defined (UMC_ENABLE_VC1_VIDEO_DECODER)

#ifndef __UMC_UMC_VC1_DEC_TASK_STORE_H_
#define __UMC_UMC_VC1_DEC_TASK_STORE_H_

#include "umc_vc1_dec_task.h"
#include "umc_vc1_common_defs.h"
#include "umc_vc1_dec_frame_descr.h"
#include "vm_types.h"
#include "umc_event.h"
#include "umc_vc1_dec_job.h"
#include "umc_automatic_mutex.h"
#include "umc_vc1_dec_skipping.h"



namespace UMC
{
    typedef enum
    {
        VC1_HD_STREAM = 0,
        VC1_MD_STREAM = 1,
        VC1_SD_STREAM = 2
    } VC1_STREAM_DEFINITION;
    // Declaration of thread-unsafe array class of simple types
    template<class T>
    class VC1Array
    {
    public:
        // Default constructor
        VC1Array(void)
        {
            m_Null = 0;
            m_pArray = NULL;
            m_nItemCount = 0;
        }

        // Destructor
        virtual
            ~VC1Array(void)
        {
            Release();

        }

        // Initialize array
        bool Init(size_t nInitialCount)
        {
            if (false == Reallocate(nInitialCount))
                return false;

            return true;

        }

        // Index operator
        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];

        }

        size_t GetItemCount(void)
        {
            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;
                m_pArray = NULL;
            }
            // 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 VC1ItemArray : public VC1Array <T *>
    {
    public:
        // Default constructor
        VC1ItemArray(void)
        {

        }

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

        }

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

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

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

                Reallocate(i);
            }

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

        }

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

        }

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

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

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

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

            if (VC1Array<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 valueso=
            if (VC1Array<T *>::m_pArray)
            {
                memcpy(pTemp, VC1Array<T *>::m_pArray, sizeof(T *) * VC1Array<T *>::m_nItemCount);
                delete [] VC1Array<T *>::m_pArray;
                VC1Array<T *>::m_pArray = NULL;
            }
            // reset rest values
            memset(pTemp + VC1Array<T *>::m_nItemCount,
                0,
                sizeof(T *) * (nAllocated - VC1Array<T *>::m_nItemCount));

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

            return true;
        }
    };
    template<class T>
    class VC1Mem_elem
    {
    public:
        VC1Mem_elem(T* _pStart, Ipp32s _MBStartRow, Ipp32u _MBRows):pStart(_pStart),
            MBStartRow(_MBStartRow),
            MBRows(_MBRows),
            busy(false)
        {
        };

        VC1Mem_elem(T* _pStart,Ipp32u _MBRows):pStart(_pStart),
            MBStartRow(-1),
            MBRows(_MBRows),
            busy(false)
        {
        };
        ~VC1Mem_elem()