Method notifyFrameRendered

Engine/OutputSchedulerThread.cpp:1548–1731

#endif // ifndef NATRON_PLAYBACK_USES_THREAD_POOL

void
OutputSchedulerThread::notifyFrameRendered(int frame,
                                           ViewIdx viewIndex,
                                           const std::vector<ViewIdx>& viewsToRender,
                                           const RenderStatsPtr& stats,
                                           SchedulingPolicyEnum policy)
{
    assert(viewsToRender.size() > 0);

    bool isLastView = viewIndex == viewsToRender[viewsToRender.size() - 1] || viewIndex == -1;

    // Report render stats if desired
    boost::shared_ptr<OutputEffectInstance> effect = _imp->outputEffect.lock();
    if (stats) {
        double timeSpentForFrame;
        std::map<NodePtr, NodeRenderStats > statResults = stats->getStats(&timeSpentForFrame);
        if ( !statResults.empty() ) {
            effect->reportStats(frame, viewIndex, timeSpentForFrame, statResults);
        }
    }


    bool isBackground = appPTR->isBackground();
    boost::shared_ptr<OutputSchedulerThreadStartArgs> runArgs = _imp->runArgs.lock();
    assert(runArgs);

    // If FFA all parallel renders call render on the Writer in their own thread,
    // otherwise the OutputSchedulerThread thread calls the render of the Writer.
    U64 nbTotalFrames;
    U64 nbFramesRendered;
    //bool renderingIsFinished = false;
    if (policy == eSchedulingPolicyFFA) {
        QMutexLocker l(&_imp->renderFinishedMutex);
        if (isLastView) {
            ++_imp->nFramesRendered;
        }
        nbTotalFrames = std::ceil( (double)(runArgs->lastFrame - runArgs->firstFrame + 1) / runArgs->frameStep );
        nbFramesRendered = _imp->nFramesRendered;


        if (_imp->nFramesRendered == nbTotalFrames) {
            _imp->renderFinished = true;
            l.unlock();

            // Notify the scheduler rendering is finished by append a fake frame to the buffer
            {
                QMutexLocker bufLocker (&_imp->bufMutex);
                _imp->appendBufferedFrame( 0, viewIndex, RenderStatsPtr(), boost::shared_ptr<BufferableObject>() );
                _imp->bufEmptyCondition.wakeOne();
            }
        } else {
            l.unlock();

#ifndef NATRON_SCHEDULER_SPAWN_THREADS_WITH_TIMER

#ifndef NATRON_PLAYBACK_USES_THREAD_POOL
            ///////////
            /////Now set the appropriate number of threads to render.