umc_vc1_dec_task_store.cpp

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

                                    ExpandFrame_Field(m_pDescriptorQueue[qID]->m_pContext,
                                                     &m_pDescriptorQueue[qID]->m_pContext->m_frmBuff.m_pFrames[m_pDescriptorQueue[qID]->m_pContext->m_frmBuff.m_iCurrIndex],
                                                      m_pDescriptorQueue[qID]->m_pContext->m_InitPicLayer->BottomField);
                                //}




                                if ((*m_pAdditionalQueue[qID])[i+1]->m_pSlice->m_picLayerHeader->PTYPE == VC1_P_FRAME)
                                {
                                    for (count = i+1; count < m_pTasksInQueue[qID];count++)
                                    {
                                        if (((*m_pCommonQueue[qID])[count]->m_eTasktype > VC1Decode)&&
                                            m_pDescriptorQueue[qID]->m_bIsReferenceReady)
                                        {
                                            (*m_pAdditionalQueue[qID])[count]->m_bIsReady = true;
                                        }
                                        (*m_pAdditionalQueue[qID])[count]->m_isFieldReady = true;
                                    }
                                }
                                // B frame. MVcalculate is a sequence task
                                else if ((*m_pAdditionalQueue[qID])[i+1]->m_pSlice->m_picLayerHeader->PTYPE == VC1_B_FRAME)
                                {
                                    for (count = i+1; count < m_pTasksInQueue[qID];count++)
                                    {
                                        if ((( (*m_pCommonQueue[qID])[count]->m_eTasktype > VC1Decode)&&
                                            ((*m_pCommonQueue[qID])[count])->m_pSlice->is_NewInSlice)&&
                                            m_pDescriptorQueue[qID]->m_bIsReferenceReady)
                                        {
                                            (*m_pAdditionalQueue[qID])[count]->m_bIsReady = true;
                                        }
                                        (*m_pAdditionalQueue[qID])[count]->m_isFieldReady = true;
                                    }
                                }
                            }
                        }
                        --m_pDescriptorQueue[qID]->m_iActiveTasksInFirstField;
                        (*m_pAdditionalQueue[qID])[i]->m_bDone = true;
                        break;
                    default:
                        VM_ASSERT(0);
                    }
                    //printf("complete %d task \n", i);
STATISTIC_PARAL_ENTRY(pTask,pTask->m_eTasktype,VC1AddPerfomrd);

                    (*m_pAdditionalQueue[qID])[i]->m_bInProgress = false;

STATISTICS_END_TIME(m_timeStatistics->AddPerfomed_StartTime,
                    m_timeStatistics->AddPerfomed_EndTime,
                    m_timeStatistics->AddPerfomed_TotalTime);
                    guard.Unlock();
                    WakeUP();
                    //pMainVC1Decoder->StartAllThreadDecoders();
                    return true;
        }
    }
    bool VC1TaskStore::CreateDSQueue(VC1Context* pContext)
    {
        Ipp32u i;
        for (i = 0; i < m_iNumFramesProcessing; i++)
        {
            m_pDescriptorQueue[i] = new VC1FrameDescriptor(m_pMemoryAllocator);
            if (!m_pDescriptorQueue[i])
                return false;
            m_pDescriptorQueue[i]->Init(i,
                                        pContext,
                                        this);

        }
        m_pPrefDS =  m_pDescriptorQueue[0];
        return true;
    }

    void VC1TaskStore::ResetDSQueue()
    {
        Ipp32u i;
        for (i = 0; i < m_iNumFramesProcessing; i++)
            m_pDescriptorQueue[i]->Reset();
        m_lNextFrameCounter = 1;
        m_lNextRefFrameCounter = 1;

    }
    inline bool VC1TaskStore::IsPerfomedDS()
    {
        Ipp32u i;
        for (i = 0; i < m_iNumFramesProcessing; i++)
        {
            if ((m_pDescriptorQueue[i]->m_bIsReadyToDisplay)&&
                (m_lNextFrameCounter == m_pDescriptorQueue[i]->m_iFrameCounter))
                return true;
        }
        return false;
    }
    bool VC1TaskStore::IsProcessingDS()
    {
        //AutomaticMutex guard(m_mDSGuard);
        Ipp32u i;
        for (i = 0; i < m_iNumFramesProcessing; i++)
        {
            if (!m_pDescriptorQueue[i]->m_bIsReadyToLoad)
                return true;
        }
        return false;
    }

    VC1FrameDescriptor* VC1TaskStore::GetLastDS()
    {
        //AutomaticMutex guard(m_mDSGuard);
        Ipp32u i;
        VC1FrameDescriptor* pCurrDescriptor = m_pDescriptorQueue[0];
        for (i = 0; i < m_iNumFramesProcessing-1; i++)
        {
            if (pCurrDescriptor->m_iFrameCounter < m_pDescriptorQueue[i+1]->m_iFrameCounter)
                pCurrDescriptor = m_pDescriptorQueue[i+1];

        }
        return pCurrDescriptor;
    }
    VC1FrameDescriptor* VC1TaskStore::GetFirstDS()
    {
        Ipp32u i;
        for (i = 0; i < m_iNumFramesProcessing; i++)
        {
            if (m_pDescriptorQueue[i]->m_iFrameCounter == m_lNextFrameCounter)
                return m_pDescriptorQueue[i];

        }
        return NULL;
    }
    //bool VC1TaskStore::GetReadySkippedDS(VC1FrameDescriptor** 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 = 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;
    //            FreeFirstReference();
    //            return true;
    //        }
    //    }
    //    *pDS = NULL;
    //    return false;
    //}
    void VC1TaskStore::CreateOutBuffersQueue()
    {
        Ipp32u i;
        for(i = 0; i < m_iNumFramesProcessing+2; i++)
        {
            m_pOutFrameQueue[i] = new VC1FrameIndexProc;
        }
    }
    void VC1TaskStore::OpenNextFrames(VC1FrameDescriptor* pDS,VC1FrameDescriptor** pPrevDS,Ipp32s* CurrRefDst, Ipp32s* CurBDst)
    {
        Ipp32u i = 0;
        bool isReadyReference = ((pDS->m_pContext->m_picLayerHeader->PTYPE != VC1_B_FRAME)&&
                                 (pDS->m_pContext->m_picLayerHeader->PTYPE != VC1_BI_FRAME))?(true):(false);

        if (isReadyReference)
            --(*CurrRefDst);
        else
            --(*CurBDst);

        *pPrevDS = NULL;

        // Swap frames to decode according to priorities
        ippsCopy_32s(m_pDSIndicate,m_pDSIndicateSwap,m_iNumFramesProcessing);
        ippsCopy_32s(m_pDSIndicateSwap+1,m_pDSIndicate,m_iNumFramesProcessing-1);
        m_pDSIndicate[m_iNumFramesProcessing-1] = m_pDSIndicateSwap[0];

        m_pPrefDS = GetPreferedDS();
        //if  (!VC1_IS_REFERENCE(m_pPrefDS->m_pContext->m_picLayerHeader->PTYPE))
        //    GetNextRefDS(&m_pPrefDS);



        for (i = 0; i < m_iNumFramesProcessing; i++)
        {
            if (m_pDescriptorQueue[i]->m_bIsReadyToProcess)
            {
                if (isReadyReference)
                {
                    --(m_pDescriptorQueue[i]->m_iRefFramesDst);
                    if ((0 == m_pDescriptorQueue[i]->m_iRefFramesDst)&&
                        ((!m_pDescriptorQueue[i]->m_pContext->m_bIntensityCompensation&&
                          !pDS->m_pContext->m_seqLayerHeader->RANGERED)||
                         (0 == m_pDescriptorQueue[i]->m_iBFramesDst)))
                    {
                        WakeTasksInAlienQueue(m_pDescriptorQueue[i],pPrevDS);
                    }
                }
                else // only for BAD case of intensity compensation
                {
                    --(m_pDescriptorQueue[i]->m_iBFramesDst);
                    if ((0 == m_pDescriptorQueue[i]->m_iBFramesDst)&&
                        (0 == m_pDescriptorQueue[i]->m_iRefFramesDst)&&
                        ((m_pDescriptorQueue[i]->m_pContext->m_bIntensityCompensation)||
                         m_pDescriptorQueue[i]->m_pContext->m_seqLayerHeader->RANGERED))
                    {
                        WakeTasksInAlienQueue(m_pDescriptorQueue[i],pPrevDS);
                    }
                }
            }
            else if ((m_pDescriptorQueue[i]->m_bIsSkippedFrame)&&
                       (pDS->m_iSelfID != i))
            {
                if (isReadyReference)
                {
                    --(m_pDescriptorQueue[i]->m_iRefFramesDst);
                    if (0 == m_pDescriptorQueue[i]->m_iRefFramesDst)
                        m_pDescriptorQueue[i]->m_bIsReferenceReady = true;

                }
                if (m_pDescriptorQueue[i]->m_bIsReferenceReady)
                    //(m_pDescriptorQueue[i]->m_bIsBReady))
                {
                    m_pDescriptorQueue[i]->m_bIsReadyToDisplay = true;
                }
            }
        }
    }

    void VC1TaskStore::SetDstForFrameAdv(VC1FrameDescriptor* pDS, Ipp32s* CurrRefDst, Ipp32s* CurBDst)
    {
        bool isFrameReference = ((pDS->m_pContext->m_picLayerHeader->PTYPE != VC1_B_FRAME)&&
                                 (pDS->m_pContext->m_picLayerHeader->PTYPE != VC1_BI_FRAME)&&
                                 (!pDS->isSpecialBSkipFrame()))?(true):(false);

        pDS->m_iRefFramesDst = *CurrRefDst;
        pDS->m_iBFramesDst = *CurBDst;

        if ((0 == pDS->m_iRefFramesDst)&&
            ((!pDS->m_pContext->m_bIntensityCompensation)||
             (0 == pDS->m_iBFramesDst)))
        {
            pDS->m_bIsReferenceReady = true;
            if ((pDS->m_pContext->m_bIntensityCompensation)&&
                (pDS->m_pContext->m_picLayerHeader->PTYPE == VC1_P_FRAME)&&
                (0 == pDS->m_iBFramesDst))
            {
                VC1CompensateFrame(pDS->m_pContext,NULL);
            }

        }
        else
            pDS->m_bIsReferenceReady = false;

        if (((pDS->m_pContext->m_InitPicLayer->PTYPE == VC1_I_FRAME)&&
            (pDS->m_pContext->m_picLayerHeader->PTypeField2 == VC1_I_FRAME))||
            ((pDS->m_pContext->m_InitPicLayer->PTYPE == VC1_BI_FRAME)&&
            (pDS->m_pContext->m_picLayerHeader->PTypeField2 == VC1_BI_FRAME)))
            pDS->m_bIsReferenceReady = true;

        if ((pDS->m_bIsSkippedFrame)&&(pDS->m_bIsReferenceReady))
        {
            pDS->m_bIsReadyToDisplay = true;
        }

        if (pDS->m_pContext->m_bNeedToUseCompBuffer)
            m_bNeedToCompField = true;
        else if (VC1_IS_REFERENCE(pDS->m_pContext->m_picLayerHeader->PTYPE))
            m_bNeedToCompField = false;

        if (isFrameReference)
            ++(*CurrRefDst);
        else
            ++(*CurBDst);

        if (pDS->m_pContext->m_picLayerHeader->PTYPE != VC1_SKIPPED_FRAME)
            pDS->m_bIsReadyToProcess = true;
        else
            pDS->m_bIsReadyToProcess = false;

    }
    void VC1TaskStore::SetDstForFrame(VC1FrameDescriptor* pDS, Ipp32s* CurrRefDst, Ipp32s* CurBDst)
    {
        bool i