umc_vc1_dec_task_store.cpp

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

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

                (*m_pAdditionalQueue[j])[i] = pAddTask;
            }
        }
        return true;

    }
    void VC1TaskStore::ReleaseTaskQueues()
    {
        Ipp32u i,j;
        for (j=0; j < m_iNumFramesProcessing; j++)
        {
            for (i=0; i < VC1SLICEINPARAL; i++)
            {
                // main queue
               if ((*m_pCommonQueue[j])[i])
               {
                   if ((*m_pCommonQueue[j])[i]->m_pSlice)
                   {
                       ippsFree((*m_pCommonQueue[j])[i]->m_pSlice);
                       (*m_pCommonQueue[j])[i]->m_pSlice = NULL;
                   }
               }

               // add queue
                   if ((*m_pAdditionalQueue[j])[i])
                   {
                       if ((*m_pAdditionalQueue[j])[i]->m_pSlice)
                       {
                           ippsFree((*m_pAdditionalQueue[j])[i]->m_pSlice);
                           (*m_pAdditionalQueue[j])[i]->m_pSlice = NULL;
                       }
                   }

            }
        }
    }


    bool VC1TaskStore::AddSampleTask(VC1Task* _pTask, Ipp32u qID)
    {
        Ipp32u widthMB = m_pDescriptorQueue[qID]->m_pContext->m_seqLayerHeader->widthMB;

        static Ipp32u task_counter=0;
        Ipp16u curMBrow = _pTask->m_pSlice->MBStartRow;
        if (0 == curMBrow)
        {
            //m_pCommonQueue[qID]->Reset();
            //m_pAdditionalQueue[qID]->Reset();
            m_pTasksInQueue[qID] = 0;
            m_pSlicesInQueue[qID] = 0;
        }


        bool isFirstSlieceDecodeTask = true;
        //VM_ASSERT(qID < m_iConsumerNumber);

        while (curMBrow  < _pTask->m_pSlice->MBEndRow)
        {
            //VC1Task* pTask = new VC1Task(_pTask->m_iThreadNumber,m_pTasksInQueue[qID]);
            //pTask->m_pSlice = (SliceParams*)ippsMalloc_8u(sizeof(SliceParams));
            VC1Task* pTask = (*m_pCommonQueue[qID])[m_pTasksInQueue[qID]];
            pTask->m_bDone = false;
            pTask->m_bInProgress = false;
            pTask->m_bIsReady = false;
            pTask->m_eTasktype = VC1Decode;
            pTask->m_isFirstInSecondSlice = false;
            pTask->m_isFieldReady = false;

            memset(pTask->m_pSlice, 0, sizeof(SliceParams));

            _pTask->m_pSlice->is_NewInSlice = isFirstSlieceDecodeTask;

            if (isFirstSlieceDecodeTask)
            {
                if (m_pSlicesInQueue[qID] < VC1SLICEINPARAL)
                    pTask->m_bIsReady = true;

                isFirstSlieceDecodeTask = false;

                if (_pTask->m_isFirstInSecondSlice)
                {
                    m_pDescriptorQueue[qID]->m_iActiveTasksInFirstField = m_pTasksInQueue[qID] - 1;
                    pTask->m_isFirstInSecondSlice = _pTask->m_isFirstInSecondSlice;
                }
            }

            pTask->m_isFieldReady = _pTask->m_isFieldReady;

            *pTask->m_pSlice = *_pTask->m_pSlice;
            pTask->m_pSlice->MBStartRow = curMBrow;
            pTask->m_pSlice->MBEndRow = curMBrow + VC1MBQUANT;
            pTask->m_pSlice->MBRowsToDecode = VC1MBQUANT;
            pTask->pMulti = &VC1TaskProcessor::VC1Decoding;


            if ((pTask->m_pSlice->MBRowsToDecode + pTask->m_pSlice->MBStartRow) > _pTask->m_pSlice->MBEndRow)
            {
                pTask->m_pSlice->MBEndRow = _pTask->m_pSlice->MBEndRow;
                pTask->m_pSlice->MBRowsToDecode = pTask->m_pSlice->MBEndRow - pTask->m_pSlice->MBStartRow;
            }
            (*m_pCommonQueue[qID])[m_pTasksInQueue[qID]] = pTask;
            (*m_pCommonQueue[qID])[m_pTasksInQueue[qID]]->m_pBlock = m_pDescriptorQueue[qID]->m_pDiffMem + widthMB*pTask->m_pSlice->MBStartRow*8*8*6;
            (*m_pCommonQueue[qID])[m_pTasksInQueue[qID]]->m_pSlice->is_LastInSlice = false;
            ++m_pTasksInQueue[qID];
            curMBrow += VC1MBQUANT;
            ++m_iCurrentTaskID;
        }
        (*m_pCommonQueue[qID])[m_pTasksInQueue[qID]-1]->m_pSlice->is_LastInSlice = true;
        ++m_pSlicesInQueue[qID];
        return true;
    }
    void VC1TaskStore::DistributeTasks(Ipp32u qID)
    {
        Ipp32u widthMB = m_pDescriptorQueue[qID]->m_pContext->m_seqLayerHeader->widthMB;
        //AutomaticMutex guard(*m_pGuardGet[0]);
        for (Ipp32u i = 0; i < m_pTasksInQueue[qID]; i++)
        {
            //VC1Task* pTask = new VC1Task(0,(*m_pCommonQueue[qID])[i]->m_iTaskID);
            //pTask->m_pSlice = (SliceParams*)ippsMalloc_8u(sizeof(SliceParams));
            VC1Task* pTask = (*m_pAdditionalQueue[qID])[i];
            pTask->m_bDone = false;
            pTask->m_bInProgress = false;
            pTask->m_bIsReady = false;
            pTask->m_isFirstInSecondSlice = false;
            pTask->m_isFieldReady = false;

            memset(pTask->m_pSlice, 0, sizeof(SliceParams));
            *(pTask->m_pSlice) = *((*m_pCommonQueue[qID])[i]->m_pSlice);

            pTask->m_isFirstInSecondSlice = (*m_pCommonQueue[qID])[i]->m_isFirstInSecondSlice;


            if (pTask->m_pSlice->is_NewInSlice)
                pTask->m_pSlice->iPrevDblkStartPos = -1;
            else
                pTask->m_pSlice->iPrevDblkStartPos = (*m_pCommonQueue[qID])[i-1]->m_pSlice->MBStartRow-1;
            if (i > 0)
            {
                if ((*m_pCommonQueue[qID])[(i-1)]->m_pSlice->is_NewInSlice)
                {
                    pTask->m_pSlice->iPrevDblkStartPos += 1;
                }
            }

            (*m_pAdditionalQueue[qID])[i] = pTask;
            (*m_pAdditionalQueue[qID])[i]->m_pBlock = (*m_pCommonQueue[qID])[i]->m_pBlock;
            (*m_pAdditionalQueue[qID])[i]->m_pPredBlock = m_pDescriptorQueue[qID]->m_pPred+ widthMB*pTask->m_pSlice->MBStartRow*8*8*6;
            (*m_pAdditionalQueue[qID])[i]->m_isFieldReady = (*m_pCommonQueue[qID])[i]->m_isFieldReady;
            (*m_pAdditionalQueue[qID])[i]->m_isFirstInSecondSlice = (*m_pCommonQueue[qID])[i]->m_isFirstInSecondSlice;

            switch((*m_pCommonQueue[qID])[i]->m_pSlice->m_picLayerHeader->PTYPE)
            {
            case VC1_B_FRAME:
                (*m_pAdditionalQueue[qID])[i]->pMulti = &VC1TaskProcessor::VC1MVCalculation;
                (*m_pAdditionalQueue[qID])[i]->m_eTasktype = VC1MVCalculate;
                break;
            case VC1_P_FRAME:
                (*m_pAdditionalQueue[qID])[i]->pMulti = &VC1TaskProcessor::VC1MotionCompensation;
                (*m_pAdditionalQueue[qID])[i]->m_eTasktype = VC1MC;
                break;
            case VC1_I_FRAME:
            case VC1_BI_FRAME:
                (*m_pAdditionalQueue[qID])[i]->pMulti = &VC1TaskProcessor::VC1PrepPlane;
                (*m_pAdditionalQueue[qID])[i]->m_eTasktype = VC1PreparePlane;
                break;
            default:
                break;
            }
            ++m_iCurrentTaskID;
        }
    }

    bool VC1TaskStore::GetNextTask(VC1FrameDescriptor **pFrameDS, VC1Task** pTask, Ipp32u qID)
    {
        if (m_iConsumerNumber <= 2)
        {
                // intensity compensation and H/W accelerator are special cases
                if (pMainVC1Decoder->m_pContext->m_bIntensityCompensation)
                {
                    return GetNextTaskManyCPU_HD(pFrameDS,pTask,qID);
                }
                else
                    return GetNextTaskDualCPU(pFrameDS,pTask,qID);
        }
        else if (m_iConsumerNumber <= 4)
        {
            if ((m_eStreamDef == VC1_HD_STREAM)||(m_eStreamDef == VC1_SD_STREAM))
            {
                return GetNextTaskManyCPU_HD(pFrameDS,pTask,qID);
            }
            else
                return GetNextTaskManyCPU_MD(pFrameDS,pTask,qID);
        }
        else
            return GetNextTaskManyCPU_HD(pFrameDS,pTask,qID);

    }
    bool VC1TaskStore::GetNextTaskDualCPU(VC1FrameDescriptor **pFrameDS, VC1Task** pTask, Ipp32u qID)
    {
STATISTICS_START_TIME(m_timeStatistics->GetNextTask_StartTime);

        Ipp32u curFrame = qID;
        Ipp32u frameCount;
        Ipp32u i;
        for (Ipp32u count = 0; count < m_iNumFramesProcessing; count++) // for 2-core CPU
        {
            frameCount = m_pDSIndicate[curFrame];
STATISTICS_START_TIME(m_timeStatistics->GetNextTask_StartTime);
            {
            AutomaticMutex guard(*m_pGuardGet[frameCount]);

            //find in own queue
            if (m_pDescriptorQueue[frameCount]->m_bIsReadyToProcess)
            {
                *pFrameDS = m_pDescriptorQueue[frameCount];
                // find in main queue
                for (i =0; i < m_pTasksInQueue[frameCount];i++ )
                {
                    if (((*m_pCommonQueue[frameCount])[i]->m_bDone == false) &&
                        ((*m_pCommonQueue[frameCount])[i]->m_bInProgress == false)&&
                        ((*m_pCommonQueue[frameCount])[i]->m_bIsReady == true) )
                    {
                        *pTask = (*m_pCommonQueue[frameCount])[i];
                        (*m_pCommonQueue[frameCount])[i]->m_bInProgress = true;
                        (*m_pCommonQueue[frameCount])[i]->m_bIsReady = true;

 STATISTIC_PARAL_ENTRY(pTask,pTask->m_eTasktype,VC1GetTask);
STATISTICS_END_TIME(m_timeStatistics->GetNextTask_StartTime,
                    m_timeStatistics->GetNextTask_EndTime,
                    m_timeStatistics->GetNextTask_TotalTime);
                            return true;
                    } else
                    if (((*m_pAdditionalQueue[frameCount])[i]->m_bDone == false) &&
                        ((*m_pAdditionalQueue[frameCount])[i]->m_bInProgress == false)&&
                        ((*m_pAdditionalQueue[frameCount])[i]->m_bIsReady == true) )
                    {
                                *pTask = (*m_pAdditionalQueue[frameCount])[i];
                                (*m_pAdditionalQueue[frameCount])[i]->m_bInProgress = true;
                                (*m_pAdditionalQueue[frameCount])[i]->m_bIsReady = true;

STATISTIC_PARAL_ENTRY(pTask,pTask->m_eTasktype,VC1AddPerfomrd);
STATISTICS_END_TIME(m_timeStatistics->GetNextTask_StartTime,
                    m_timeStatistics->GetNextTask_EndTime,
                    m_timeStatistics->GetNextTask_TotalTime);
                        return true;
                        }
                    }
                for (i =0; i < m_pTasksInQueue[frameCount];i++ )
                {
                    if (((*m_pCommonQueue[frameCount])[i]->m_bDone == false)||
                        ((*m_pAdditionalQueue[frameCount])[i]->m_bDone == false) )
                        break;
                }
                if ((i == m_pTasksInQueue[frameCount])&&
                    (i>0) ) // to check skip frames
                {
                    m_pDescriptorQueue[frameCount]->m_bIsReadyToProcess = false;
                    m_pDescriptorQueue[frameCount]->m_bIsReadyToDisplay = true;
                    *pTask = NULL;
                    return true;
                }
            }
            guard.Unlock();
            }

            ++curFrame;
            if (curFrame == m_iNumFramesProcessing)
                curFrame = 0;

        }
        STATISTICS_END_TIME(m_timeStatistics->GetNextTask_StartTime,
                            m_timeStatistics->GetNextTask_EndTime,
                            m_timeStatistics->GetNextTask_TotalTime);

        //return false;
        if (0 != qID) // main thread should check ready FrameDS permanentley
        {
            if (m_bIsNeedToDecode)
            {
                m_eWaiting[qID]->Reset(); //!!!!!!
                m_eWaiting[qID]->Wait();
                *pTask = NULL;
                return true;
            }