umc_vc1_dec_task_store.h

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

        {
        };

        T* pStart;
        Ipp32s                   MBStartRow;
        Ipp32u                   MBRows;
        bool                     busy;
    };

    class VC1VideoDecoder;
    class VC1TaskStore: public VC1Skipping::VC1SkipMaster
    {
    public:

        VC1TaskStore(MemoryAllocator *pMemoryAllocator);

        virtual  ~VC1TaskStore();



        bool     Init(Ipp32u iConsumerNumber,
                      Ipp32u iMaxFramesInParallel,
                      VC1VideoDecoder* pVC1Decoder);

        void Reset();

        bool AddSampleTask(VC1Task* _pTask, Ipp32u qID);
        void DistributeTasks(Ipp32u qID);
        bool GetNextTask(VC1FrameDescriptor **pFrameDS,
                         VC1Task **pTask,
                         Ipp32u qID);
        bool GetNextTaskMainThread(VC1FrameDescriptor **pFrameDS,
                                   VC1Task** pTask,
                                   Ipp32u qID);

        // pipeline for Dual CPU cases.
        bool GetNextTaskDualCPU(VC1FrameDescriptor **pFrameDS,
                                  VC1Task **pTask,
                                  Ipp32u qID);

        // pipeline for 4-CPU cases, high-defenition streams.
        bool GetNextTaskManyCPU_HD(VC1FrameDescriptor **pFrameDS,
                                   VC1Task **pTask,
                                   Ipp32u qID);

        // pipeline for 4-CPU cases, medium/small-defenition streams.
        bool GetNextTaskManyCPU_MD(VC1FrameDescriptor **pFrameDS,
                                   VC1Task **pTask,
                                   Ipp32u qID);

        bool AddPerfomedTask(VC1Task* pTask, VC1FrameDescriptor *pFrameDS);
        void SetFrameSettings(Ipp32u _frame_settings) {frame_settings = _frame_settings;}
        void ResetQueue(Ipp32u qID);

        VC1PictureLayerHeader* GetFirstInSecondField(Ipp32u qID);

        bool CreateDSQueue(VC1Context* pContext);


        void ResetDSQueue();

        template <class Descriptor>
        void GetReadyDS(Descriptor** pDS)
        {
            //AutomaticMutex guard(m_mDSGuard);

            Ipp32u i;
            for (i = 0; i < m_iNumFramesProcessing; i++)
            {
                if (m_pDescriptorQueue[i]->m_bIsReadyToLoad)
                {
                    m_pDescriptorQueue[i]->m_bIsReadyToLoad  = false;
                    m_pDescriptorQueue[i]->m_iActiveTasksInFirstField = 0;
                    *pDS = (Descriptor*)m_pDescriptorQueue[i];
                    ++m_iNumDSActiveinQueue;
                    return;
                }
            }
            *pDS = NULL;
        }

        //bool GetPerformedDS(VC1FrameDescriptor** pDS);
        template <class Descriptor>
        bool GetPerformedDS(Descriptor** pDS)
        {
            Ipp32u i;
            for (i = 0; i < m_iNumFramesProcessing; i++)
            {
                if (m_pDescriptorQueue[i]->m_bIsReadyToDisplay)
                {
                    if ((m_lNextFrameCounter == m_pDescriptorQueue[i]->m_iFrameCounter)&&
                        (!m_pDescriptorQueue[i]->m_bIsSkippedFrame))
                    {
                        m_pDescriptorQueue[i]->m_bIsReadyToDisplay = false;
                        m_pDescriptorQueue[i]->m_bIsReadyToLoad = true;
                        --m_iNumDSActiveinQueue;
                        ++m_lNextFrameCounter;
                        *pDS = (Descriptor*)m_pDescriptorQueue[i];
                        if (VC1_IS_REFERENCE(m_pDescriptorQueue[i]->m_pContext->m_InitPicLayer->PTYPE))
                            FreeFirstReference();
                        else if (!(*pDS)->IsNeedToDelayBFrame())
                            FreeBFrame(m_pDescriptorQueue[i]->m_pContext->m_frmBuff.m_iCurrIndex);
                        return true;
                    }
                }
            }
            *pDS = NULL;
            return false;
        }
        void ResetPerformedDS(VC1FrameDescriptor* pDS)
        {
            pDS->m_bIsReadyToDisplay = false;
            pDS->m_bIsReadyToLoad = true;
            --m_iNumDSActiveinQueue;
            Ipp32u i;
            for (i = 0; i < m_iNumFramesProcessing; i++)
            {
                if (!m_pDescriptorQueue[i]->m_bIsReadyToLoad)
                    ++m_pDescriptorQueue[i]->m_iFrameCounter;
            }
            ++m_lNextFrameCounter;
        }

        void AddInvalidPerformedDS(VC1FrameDescriptor* pDS)
        {
            pDS->m_bIsReadyToProcess = false;
            pDS->m_bIsReadyToDisplay = true;
            pDS->m_bIsValidFrame = false;
        }
        void AddPerformedDS(VC1FrameDescriptor* pDS)
        {
            pDS->m_bIsReadyToProcess = false;
            pDS->m_bIsReadyToDisplay = true;
        }
        inline bool IsPerfomedDS();
        bool IsProcessingDS();
        VC1FrameDescriptor* GetLastDS();
        VC1FrameDescriptor* GetFirstDS();

        template <class Descriptor>
        bool GetReadySkippedDS(Descriptor** pDS)
        {
            Ipp32u i;
            for (i = 0; i < m_iNumFramesProcessing; i++)
            {
                if ((m_pDescriptorQueue[i]->m_bIsReferenceReady)&&
                    (m_pDescriptorQueue[i]->m_bIsSkippedFrame)&&
                    //(m_pDescriptorQueue[i]->m_bIsBReady)&&
                    (m_lNextFrameCounter == m_pDescriptorQueue[i]->m_iFrameCounter))
                {
                    *pDS = (Descriptor*)m_pDescriptorQueue[i];
                    m_pDescriptorQueue[i]->m_bIsReadyToDisplay = false;
                    m_pDescriptorQueue[i]->m_bIsReadyToLoad = true;
                    m_pDescriptorQueue[i]->m_bIsSkippedFrame = false;
                    --m_iNumDSActiveinQueue;
                    ++m_lNextFrameCounter;
                    if (!m_pDescriptorQueue[i]->m_bIsSpecialBSkipFrame)
                        FreeFirstReference();
                    else
                        FreeBFrame(m_pDescriptorQueue[i]->m_pContext->m_frmBuff.m_iCurrIndex);
                    return true;
                }
            }
            *pDS = NULL;
            return false;
        }
        Ipp32u GetProcFramesNumber() { return m_iNumDSActiveinQueue; }
        void OpenNextFrames(VC1FrameDescriptor* pDS,VC1FrameDescriptor** pPrevDS,Ipp32s* CurrRefDst, Ipp32s* CurBDst);
        void SetDstForFrameAdv (VC1FrameDescriptor* pDS, Ipp32s* CurrRefDst, Ipp32s* CurBDst);
        void SetDstForFrame    (VC1FrameDescriptor* pDS, Ipp32s* CurrRefDst, Ipp32s* CurBDst);

        // threads wake up
        inline void WakeUP() {for (Ipp32u i=1; i<m_iConsumerNumber;i++) m_eWaiting[i]->Set(); }
        void WakeTasksInAlienQueue(VC1FrameDescriptor* pDS, VC1FrameDescriptor** pPrevDS);
        void WakeTasksInAlienQueue(VC1FrameDescriptor* pDS);
        void CompensateDSInQueue(VC1FrameDescriptor* pDS);

        void CreateOutBuffersQueue();
        Ipp32s GetInternalIndex(); // for B/BI frames
        Ipp32s GetRefInternalIndex(); // for I/P/Skipped frames
        Ipp32s GetPrevIndex();
        Ipp32s GetNextIndex();
        Ipp32s GetDisplayIndex();
        void   FreeIndexQueue();
        void FreeFirstReference();
        void FreeBFrame(Ipp32u Index);

        void StartDecoding() {m_bIsNeedToDecode = true;}
        void StopDecoding() {m_bIsNeedToDecode = false;}

        void ResetDS(VC1FrameDescriptor* pDS)
        {
            pDS->m_bIsReadyToLoad = true;
            pDS->m_bIsReadyToDisplay = false;
            --m_iNumDSActiveinQueue;
        }
        bool CreateTaskQueues();
        void ReleaseTaskQueues();

        void SetDefinition(VC1SequenceLayerHeader*    seqLayerHeader);

    private:

        class VC1FrameIndexProc
        {
        public:
            VC1FrameIndexProc(): m_bIsBusy(false),
                m_lRefCounter(1)
            {
            };
            bool        m_bIsBusy;
            Ipp64u      m_lRefCounter;
        };

        inline VC1FrameDescriptor* GetPreferedDS()
        {
            VC1FrameDescriptor* pCurrDescriptor = m_pDescriptorQueue[0];
            Ipp32u i;
            for (i = 0; i < m_iNumFramesProcessing; i++)
            {
                if (m_pDescriptorQueue[i]->m_bIsReadyToProcess)
                {
                    pCurrDescriptor = m_pDescriptorQueue[i];
                    break;
                }
            }
            for (i = 0; i < m_iNumFramesProcessing; i++)
            {
                if ((m_pDescriptorQueue[i]->m_bIsReadyToProcess)&&
                    (m_pDescriptorQueue[i]->m_iFrameCounter < pCurrDescriptor->m_iFrameCounter))
                    pCurrDescriptor = m_pDescriptorQueue[i];
            }
            return pCurrDescriptor;
        };

        VC1ItemArray<VC1Task>** m_pCommonQueue;
        VC1ItemArray<VC1Task>** m_pAdditionalQueue;

        Ipp32u m_iConsumerNumber;
        Ipp32u* m_pTasksInQueue;
        Ipp32u m_iCurrentTaskID;
        Ipp32u* m_pSlicesInQueue;



        VC1ItemArray<VC1FrameDescriptor> m_pDescriptorQueue;
        VC1ItemArray<VC1FrameIndexProc> m_pOutFrameQueue;
        VC1ItemArray<Event> m_eWaiting;


        Ipp32u m_iNumFramesProcessing;
        Ipp32u m_iNumDSActiveinQueue;

        Ipp32u m_iNumRefFrames;
        Ipp32u m_iNumProcFrames;
        vm_mutex m_mDSGuard;


        vm_mutex** m_pGuardGet;
        vm_mutex** m_pGuardAdd;
        Ipp32u frame_settings;
        VC1VideoDecoder* pMainVC1Decoder;
        Ipp64u m_lNextFrameCounter;
        Ipp64u m_lNextRefFrameCounter;
        Ipp64u m_lFirstRefFrameCounter;
        Ipp32u m_iNumDecodeRefFrames;
        VC1FrameDescriptor* m_pPrefDS;
        Ipp32s* m_pDSIndicate;
        Ipp32s* m_pDSIndicateSwap;
        bool   m_bNeedToCompField;
        Ipp32s m_iICompFieldIndex;
        bool   m_bIsNeedToDecode;
        VC1_STREAM_DEFINITION m_eStreamDef;

        MemoryAllocator*           m_pMemoryAllocator; // (MemoryAllocator*) pointer to memory allocator
        // performance mode of decoder
    };
}

#endif //__umc_umc_vc1_dec_task_store_H__
#endif //UMC_ENABLE_VC1_VIDEO_DECODER