umc_vc1_dec_task_store.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) 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)

#include "umc_vc1_dec_task_store.h"
#include "umc_vc1_dec_task.h"
#include "umc_vc1_common_defs.h"
#include "umc_vc1_dec_time_statistics.h"
#include "umc_vc1_dec_intens_comp_tbl.h"
#include "umc_vc1_video_decoder.h"



typedef void (*ExpandIntens)(VC1Context* pContext, Frame* pFrame);

static const ExpandIntens ExpandIntens_table[] =
             {
               (ExpandIntens)(ExpandFrame_Adv),
               (ExpandIntens)(ExpandFrame_Interlace),
               (ExpandIntens)(ExpandFrame_Interlace)
             };

namespace UMC
{
    VC1TaskStore::VC1TaskStore(MemoryAllocator *pMemoryAllocator):m_iConsumerNumber(0),
                                                                  m_pTasksInQueue(NULL),
                                                                  m_iCurrentTaskID(0),
                                                                  m_pSlicesInQueue(NULL),
                                                                  m_iNumFramesProcessing(0),
                                                                  m_iNumDSActiveinQueue(0),
                                                                  pMainVC1Decoder(NULL),
                                                                  m_lNextFrameCounter(1),
                                                                  m_lNextRefFrameCounter(1),
                                                                  m_lFirstRefFrameCounter(1),
                                                                  m_iNumDecodeRefFrames(0),
                                                                  m_pPrefDS(NULL),
                                                                  m_pDSIndicate(NULL),
                                                                  m_pDSIndicateSwap(NULL),
                                                                  m_bNeedToCompField(false),
                                                                  m_iICompFieldIndex(0),
                                                                  m_bIsNeedToDecode(true),
                                                                  m_eStreamDef(VC1_HD_STREAM)
    {
        vm_mutex_set_invalid(&m_mDSGuard);
        m_pMemoryAllocator = pMemoryAllocator;
    }

    VC1TaskStore::~VC1TaskStore()
    {
        Ipp32u i;
        ReleaseTaskQueues();
        for (i = 0; i < m_iNumFramesProcessing; i++)
        {
            m_pCommonQueue[i]->Reset();
            m_pAdditionalQueue[i]->Reset();
        }
        for (i=0;i < m_iNumFramesProcessing; i++)
        {
            if (m_pCommonQueue[i])
            {
                delete m_pCommonQueue[i];
                m_pCommonQueue[i] = NULL;
            }
            if (m_pAdditionalQueue[i])
            {
                delete m_pAdditionalQueue[i];
                m_pAdditionalQueue[i] = NULL;
            }
            if (vm_mutex_is_valid(m_pGuardGet[i]))
                vm_mutex_destroy(m_pGuardGet[i]);
            if (m_pGuardGet[i])
                delete m_pGuardGet[i];
            if (vm_mutex_is_valid(m_pGuardAdd[i]))
                vm_mutex_destroy(m_pGuardAdd[i]);
            if (m_pGuardAdd[i])
                delete m_pGuardAdd[i];


        }
        delete m_pCommonQueue;
        delete m_pAdditionalQueue;
        delete m_pGuardGet;
        delete m_pGuardAdd;
        if (m_pDSIndicate)
        {
            ippsFree(m_pDSIndicate);
            m_pDSIndicate = NULL;
        }
        if (m_pDSIndicateSwap)
        {
            ippsFree(m_pDSIndicateSwap);
            m_pDSIndicateSwap = NULL;
        }

        if (m_pTasksInQueue)
        {
            ippsFree(m_pTasksInQueue);
            m_pTasksInQueue = NULL;
        }
        if (m_pSlicesInQueue)
        {
            ippsFree(m_pSlicesInQueue);
            m_pSlicesInQueue = NULL;
        }

        if (vm_mutex_is_valid(&m_mDSGuard))
            vm_mutex_destroy(&m_mDSGuard);

    }

   bool VC1TaskStore::Init(Ipp32u iConsumerNumber,
                           Ipp32u iMaxFramesInParallel,
                           VC1VideoDecoder* pVC1Decoder)
    {
        Ipp32u i;
        m_iNumDSActiveinQueue = 0;
        m_iICompFieldIndex   =  iMaxFramesInParallel + VC1NUMREFFRAMES -1;
        pMainVC1Decoder = pVC1Decoder;
        m_iConsumerNumber = iConsumerNumber;
        m_iNumFramesProcessing = iMaxFramesInParallel;

        m_pDSIndicate = (Ipp32s*)ippsMalloc_8u(m_iNumFramesProcessing*sizeof(Ipp32s));
        m_pDSIndicateSwap = (Ipp32s*)ippsMalloc_8u(m_iNumFramesProcessing*sizeof(Ipp32s));
        m_pCommonQueue = new VC1ItemArray<VC1Task> *[m_iNumFramesProcessing];
        if (NULL == m_pCommonQueue)
            return false;
        m_pAdditionalQueue = new VC1ItemArray<VC1Task> *[m_iNumFramesProcessing];
        if (NULL == m_pAdditionalQueue)
            return false;

        m_pGuardGet = new vm_mutex *[m_iNumFramesProcessing];
        m_pGuardAdd = new vm_mutex *[m_iNumFramesProcessing];

        for (i = 0; i < m_iNumFramesProcessing; i++)
        {
            m_pDSIndicate[i] = i;
            m_pCommonQueue[i] = new VC1ItemArray<VC1Task>;
            if (NULL ==  m_pCommonQueue[i])
                return false;
            m_pAdditionalQueue[i] = new VC1ItemArray<VC1Task>;
            if (NULL ==  m_pAdditionalQueue[i])
                return false;

            m_pCommonQueue[i]->Init(8);
            m_pAdditionalQueue[i]->Init(8);

            m_pGuardGet[i] = new vm_mutex;
            m_pGuardAdd[i] = new vm_mutex;


           vm_mutex_set_invalid(m_pGuardGet[i]);
           vm_mutex_set_invalid(m_pGuardAdd[i]);
           if (VM_OK != vm_mutex_init(m_pGuardGet[i]))
               return false;
           if (VM_OK != vm_mutex_init(m_pGuardAdd[i]))
                    return false;
        }


        m_pTasksInQueue = (Ipp32u*)ippsMalloc_8u(m_iNumFramesProcessing*sizeof(Ipp32u));
        if (NULL == m_pTasksInQueue)
            return false;
        memset(m_pTasksInQueue,0,m_iNumFramesProcessing*sizeof(Ipp32u));

        m_pSlicesInQueue = (Ipp32u*)ippsMalloc_8u(m_iNumFramesProcessing*sizeof(Ipp32u));
        if (NULL == m_pSlicesInQueue)
            return false;
        memset(m_pSlicesInQueue,0,m_iNumFramesProcessing*sizeof(Ipp32u));

        CreateTaskQueues();

        if (0 == vm_mutex_is_valid(&m_mDSGuard))
        {
            if (VM_OK != vm_mutex_init(&m_mDSGuard))
                return false;
        }
        // initilaize event(s)
        for (i = 0; i < iConsumerNumber; i += 1)
        {
            if (NULL == m_eWaiting[i])
            {
                if (false == m_eWaiting.AllocateOneMore())
                    return false;
                if (UMC_OK != m_eWaiting[i]->Init(0, 0))
                    return false;
            }
        }
        return true;
    }

    void VC1TaskStore::SetDefinition(VC1SequenceLayerHeader*    seqLayerHeader)
    {
        if ((seqLayerHeader->heightMB*seqLayerHeader->widthMB*16*16) > (1280*720) )
        {
            m_eStreamDef = VC1_HD_STREAM;
        }
        else if ((seqLayerHeader->heightMB*seqLayerHeader->widthMB*16*16) > (320*240))
        {
            m_eStreamDef = VC1_MD_STREAM;
        }
        else
            m_eStreamDef = VC1_SD_STREAM;


    }
    void VC1TaskStore::Reset()
    {
        //memset(m_pTasksInQueue,0,m_iNumFramesProcessing*sizeof(Ipp32u));
        //memset(m_pSlicesInQueue,0,m_iNumFramesProcessing*sizeof(Ipp32u));
        //m_iCurrentTaskID = 0;
        m_iNumDecodeRefFrames = 0;
        m_lNextRefFrameCounter = 1;
        m_lFirstRefFrameCounter = 1;
        //m_iCurrentTaskID = 0;
        //m_iNumFramesProcessing = 0;
        //m_iNumDSActiveinQueue = 0;
        //m_lNextFrameCounter = 1 ;
        //m_iNumDecodeRefFrames = 0;
        //m_bNeedToCompField = false;
        //m_iICompFieldIndex = 0;
        //m_bIsNeedToDecode = true;

        //ReleaseTaskQueues();
        //for (Ipp32u i = 0; i < m_iNumFramesProcessing; i++)
        //{
        //    m_pCommonQueue[i]->Reset();
        //    m_pAdditionalQueue[i]->Reset();
        //}

        for (Ipp32u i = 0; i < m_iConsumerNumber; i += 1)
        {
            Event *pEvent = m_eWaiting[i];

            if (pEvent)
                pEvent->Reset();
        }

    }

    void VC1TaskStore::ResetQueue(Ipp32u qID)
    {
        m_pCommonQueue[qID]->Reset();
        m_pAdditionalQueue[qID]->Reset();
        // need to reset m_iTasksInQueue - for every queue
    }
    VC1PictureLayerHeader* VC1TaskStore::GetFirstInSecondField(Ipp32u qID)
    {
        for (Ipp32u i = 0; i < m_pTasksInQueue[qID]; i += 1)
        {
            if ((*m_pCommonQueue[qID])[i]->m_isFirstInSecondSlice)
                return (*m_pCommonQueue[qID])[i]->m_pSlice->m_picLayerHeader;
        }
        return NULL;
    }
    bool VC1TaskStore::CreateTaskQueues()
    {
        Ipp32u i,j;
        for (j=0; j < m_iNumFramesProcessing; j++)
        {
            for (i=0; i < VC1SLICEINPARAL; i++)
            {
                // main queue
                VC1Task* pMainTask = new VC1Task(0,i);
                if (!pMainTask)
                    return false;
                pMainTask->m_pSlice = (SliceParams*)ippsMalloc_8u(sizeof(SliceParams));

                if (!pMainTask->m_pSlice)
                    return false;
                memset(pMainTask->m_pSlice, 0, sizeof(SliceParams));

                (*m_pCommonQueue[j])[i] = pMainTask;

                VC1Task* pAddTask = new VC1Task(0,i);
                if (!pAddTask)
                    return false;
                pAddTask->m_pSlice = (SliceParams*)ippsMalloc_8u(sizeof(SliceParams));