Public Types
enum	RegenerationRequestResult { RequestSuccessful = 0 , RequestRejected , RequestPostponed }

enum	State { NotWaitingForAnything , WaitingForIdle , WaitingForFrame , BetweenFrames }

Public Member Functions
QString	debugStateToString (State newState)

void	enterState (State newState)

void	generateIfIdle ()

	Private (KisAnimationCachePopulator _q, KisPart _part)

RegenerationRequestResult	regenerate (KisAnimationFrameCacheSP cache, int frame)

void	timerTimeout ()

RegenerationRequestResult	tryRequestGeneration ()

RegenerationRequestResult	tryRequestGeneration (KisAnimationFrameCacheSP cache, KisTimeSpan skipRange, int priorityFrame)

Public Attributes
bool	calculateAnimationCacheInBackground = true

int	idleCounter

KisPart *	part

QStack< QPair< KisImageWSP, int > >	priorityFrames

KisAnimationCachePopulator *	q

KisAsyncAnimationCacheRenderer	regenerator

State	state

QTimer	timer

Static Public Attributes
static const int	BETWEEN_FRAMES_INTERVAL = 10

static const int	IDLE_CHECK_INTERVAL = 500

static const int	IDLE_COUNT_THRESHOLD = 4

Detailed Description

Definition at line 36 of file kis_animation_cache_populator.cpp.

Member Enumeration Documentation

◆ RegenerationRequestResult

enum KisAnimationCachePopulator::Private::RegenerationRequestResult

Enumerator
RequestSuccessful
RequestRejected
RequestPostponed

Definition at line 63 of file kis_animation_cache_populator.cpp.

                                   {
        RequestSuccessful = 0,
        RequestRejected,
        RequestPostponed
    };

◆ State

enum KisAnimationCachePopulator::Private::State

Enumerator
NotWaitingForAnything
WaitingForIdle
WaitingForFrame
BetweenFrames

Definition at line 55 of file kis_animation_cache_populator.cpp.

               {
        NotWaitingForAnything,
        WaitingForIdle,
        WaitingForFrame,
        BetweenFrames
    };

Constructor & Destructor Documentation

◆ Private()

KisAnimationCachePopulator::Private::Private	(	KisAnimationCachePopulator *	_q,
		KisPart *	_part )

inline

Definition at line 69 of file kis_animation_cache_populator.cpp.

        : q(_q),
          part(_part),
          idleCounter(0),
          priorityFrames(),
          state(WaitingForIdle)
    {
        timer.setSingleShot(true);
    }

References timer.

Member Function Documentation

◆ debugStateToString()

QString KisAnimationCachePopulator::Private::debugStateToString ( State newState )

inline

Definition at line 282 of file kis_animation_cache_populator.cpp.

                                               {
        QString str = "<unknown>";
 
        switch (newState) {
        case WaitingForIdle:
            str = "WaitingForIdle";
            break;
        case WaitingForFrame:
            str = "WaitingForFrame";
            break;
        case NotWaitingForAnything:
            str = "NotWaitingForAnything";
            break;
        case BetweenFrames:
            str = "BetweenFrames";
            break;
        }
 
        return str;
    }

References BetweenFrames, NotWaitingForAnything, WaitingForFrame, and WaitingForIdle.

◆ enterState()

void KisAnimationCachePopulator::Private::enterState ( State newState )

inline

Definition at line 303 of file kis_animation_cache_populator.cpp.

    {
        //ENTER_FUNCTION() << debugStateToString(state) << "->" << debugStateToString(newState);
 
        state = newState;
        int timerTimeout = -1;
 
        switch (state) {
        case WaitingForIdle:
            timerTimeout = IDLE_CHECK_INTERVAL;
            break;
        case WaitingForFrame:
            // the timeout is handled by the regenerator now
            timerTimeout = -1;
            break;
        case NotWaitingForAnything:
            // frame conversion cannot be cancelled,
            // so there is no timeout
            timerTimeout = -1;
            break;
        case BetweenFrames:
            timerTimeout = BETWEEN_FRAMES_INTERVAL;
            break;
        }
 
        if (timerTimeout >= 0) {
            timer.start(timerTimeout);
        } else {
            timer.stop();
        }
    }

References BETWEEN_FRAMES_INTERVAL, BetweenFrames, IDLE_CHECK_INTERVAL, NotWaitingForAnything, state, timer, timerTimeout(), WaitingForFrame, and WaitingForIdle.

◆ generateIfIdle()

void KisAnimationCachePopulator::Private::generateIfIdle ( )

inline

Definition at line 94 of file kis_animation_cache_populator.cpp.

    {
        if (part->idleWatcher()->isIdle()) {
            idleCounter++;
 
            if (idleCounter >= IDLE_COUNT_THRESHOLD) {
                RegenerationRequestResult result = tryRequestGeneration();
 
                if (result == RequestPostponed) {
                    enterState(WaitingForIdle);
                } else if (result == RequestRejected) {
                    enterState(NotWaitingForAnything);
                }
 
                return;
            }
        } else {
            idleCounter = 0;
        }
 
        enterState(WaitingForIdle);
    }

References enterState(), IDLE_COUNT_THRESHOLD, idleCounter, KisPart::idleWatcher, KisIdleWatcher::isIdle(), NotWaitingForAnything, part, RequestPostponed, RequestRejected, tryRequestGeneration(), and WaitingForIdle.

◆ regenerate()

RegenerationRequestResult KisAnimationCachePopulator::Private::regenerate	(	KisAnimationFrameCacheSP	cache,
		int	frame )

inline

We should enter the state before the frame is requested. Otherwise the signal may come earlier than we enter it.

Definition at line 253 of file kis_animation_cache_populator.cpp.

    {
        if (state == WaitingForFrame) {
            // Already busy, deny request
            return RequestRejected;
        }
 
        KisLockFrameGenerationLock lock(cache->image()->animationInterface(), std::try_to_lock);
 
        if (!lock.owns_lock()) {
            return RequestPostponed;
        }
 
        enterState(WaitingForFrame);
 
        regenerator.setFrameCache(cache);
 
        // if we ever decide to add ROI to background cache
        // regeneration, it should be added here :)
        regenerator.startFrameRegeneration(cache->image(), frame, KisAsyncAnimationRendererBase::Cancellable, std::move(lock));
 
        return RequestSuccessful;
    }

References KisImage::animationInterface(), KisAsyncAnimationRendererBase::Cancellable, enterState(), KisAnimationFrameCache::image(), regenerator, RequestPostponed, RequestRejected, RequestSuccessful, KisAsyncAnimationCacheRenderer::setFrameCache(), KisAsyncAnimationRendererBase::startFrameRegeneration(), state, and WaitingForFrame.

◆ timerTimeout()

void KisAnimationCachePopulator::Private::timerTimeout ( )

inline

Definition at line 79 of file kis_animation_cache_populator.cpp.

                        {
        switch (state) {
        case WaitingForIdle:
        case BetweenFrames:
            generateIfIdle();
            break;
        case WaitingForFrame:
            KIS_ASSERT_RECOVER_NOOP(0 && "WaitingForFrame cannot have a timeout. Just skip this message and report a bug");
            break;
        case NotWaitingForAnything:
            KIS_ASSERT_RECOVER_NOOP(0 && "NotWaitingForAnything cannot have a timeout. Just skip this message and report a bug");
            break;
        }
    }

References BetweenFrames, generateIfIdle(), KIS_ASSERT_RECOVER_NOOP, NotWaitingForAnything, state, WaitingForFrame, and WaitingForIdle.

◆ tryRequestGeneration() [1/2]

RegenerationRequestResult KisAnimationCachePopulator::Private::tryRequestGeneration ( )

inline

We have just upgraded the image pointer to the strong pointer, let's check if it is still valid.

It may happen that the view (and the canvas) of this image has already been removed. Hence the cache does not exist anymore. So we should just skip this stinking image.

The frame got cached in the meantime, so skip its recalculation

Definition at line 118 of file kis_animation_cache_populator.cpp.

    {
        while (!priorityFrames.isEmpty()) {
            KisImageSP image = priorityFrames.top().first;
            const int priorityFrame = priorityFrames.top().second;
            priorityFrames.pop();
 
            if (!image) continue;
 
            if (!image->animationInterface()->hasAnimation()) continue;
            if (image->animationInterface()->backgroundFrameGenerationBlocked()) continue;
 
            KisAnimationFrameCacheSP cache = KisAnimationFrameCache::cacheForImage(image);
            if (!cache) {
                // a small sanity check that our guess it right...
                QList<QPointer<KisView>> views = KisPart::instance()->views();
                auto it = std::find_if(views.constBegin(), views.constEnd(),
                                       [image] (QPointer<KisView> view) {
                                           return view && KisImageSP(view->image()) == image;
                                       });
                const bool foundExistingViewForImage = it != views.constEnd();
 
                KIS_SAFE_ASSERT_RECOVER(!foundExistingViewForImage) {
                    priorityFrames.erase(
                        std::remove_if(priorityFrames.begin(), priorityFrames.end(),
                                       [image] (auto requestPair) {
                                           return KisImageSP(requestPair.first) == image;
                                       }), priorityFrames.end());
                }
 
                continue;
            }
 
            if (cache->frameStatus(priorityFrame) == KisAnimationFrameCache::Cached) {
                continue;
            }
 
            RegenerationRequestResult result =
                tryRequestGeneration(cache, KisTimeSpan(), priorityFrame);
            if (result == RequestSuccessful) return result;
        }
 
        // Prioritize the active document
        KisAnimationFrameCacheSP activeDocumentCache = KisAnimationFrameCacheSP(0);
 
        KisMainWindow *activeWindow = part->currentMainwindow();
        if (activeWindow && activeWindow->activeView()) {
            KisCanvas2 *activeCanvas = activeWindow->activeView()->canvasBase();
 
            if (activeCanvas && activeCanvas->frameCache() &&
                activeCanvas->image()->animationInterface()->hasAnimation()) {
 
                activeDocumentCache = activeCanvas->frameCache();
 
                // Let's skip frames affected by changes to the active node (on the active document)
                // This avoids constant invalidation and regeneration while drawing
                KisNodeSP activeNode = activeCanvas->viewManager()->nodeManager()->activeNode();
                KisTimeSpan skipRange;
                if (activeNode) {
                    const int currentTime = activeCanvas->currentImage()->animationInterface()->currentUITime();
 
                    if (!activeNode->keyframeChannels().isEmpty()) {
                        Q_FOREACH (const KisKeyframeChannel *channel, activeNode->keyframeChannels()) {
                            skipRange |= channel->affectedFrames(currentTime);
                        }
                    } else {
                        skipRange = KisTimeSpan::infinite(0);
                    }
                }
 
                RegenerationRequestResult result =
                    tryRequestGeneration(activeDocumentCache, skipRange, -1);
                if (result == RequestSuccessful) return result;
            }
        }
 
        QList<KisAnimationFrameCache*> caches = KisAnimationFrameCache::caches();
        KisAnimationFrameCache *cache;
        Q_FOREACH (cache, caches) {
            if (cache == activeDocumentCache.data()) {
                // We already handled this one...
                continue;
            }
 
            if (!cache->image()->animationInterface()->hasAnimation()) {
                // This image is not animated
                continue;
            }
 
            RegenerationRequestResult result =
                tryRequestGeneration(cache, KisTimeSpan(), -1);
            if (result == RequestSuccessful) return result;
        }
 
        return RequestRejected;
    }

References KisNodeManager::activeNode(), KisMainWindow::activeView, KisKeyframeChannel::affectedFrames(), KisImage::animationInterface(), KisImageAnimationInterface::backgroundFrameGenerationBlocked(), KisAnimationFrameCache::Cached, KisAnimationFrameCache::cacheForImage(), KisAnimationFrameCache::caches(), KisCanvas2::currentImage(), KisPart::currentMainwindow(), KisImageAnimationInterface::currentUITime(), KisSharedPtr< T >::data(), KisCanvas2::frameCache, KisAnimationFrameCache::frameStatus(), KisImageAnimationInterface::hasAnimation(), KisAnimationFrameCache::image(), KisCanvas2::image(), KisTimeSpan::infinite(), KisPart::instance(), KisBaseNode::keyframeChannels, KIS_SAFE_ASSERT_RECOVER, KisViewManager::nodeManager(), part, priorityFrames, RequestRejected, RequestSuccessful, tryRequestGeneration(), KisCanvas2::viewManager(), and KisPart::views.

◆ tryRequestGeneration() [2/2]

RegenerationRequestResult KisAnimationCachePopulator::Private::tryRequestGeneration	(	KisAnimationFrameCacheSP	cache,
		KisTimeSpan	skipRange,
		int	priorityFrame )

inline

Definition at line 227 of file kis_animation_cache_populator.cpp.

    {
        KisImageSP image = cache->image();
        if (!image) return RequestRejected;
 
        KisImageAnimationInterface *animation = image->animationInterface();
 
        if (animation->backgroundFrameGenerationBlocked()) {
            return RequestPostponed;
        }
 
        // the higher levels of code should have caught the case when
        // the image is not animated
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(animation->hasAnimation(), RequestRejected);
 
        KisTimeSpan currentRange = animation->documentPlaybackRange();
 
        const int frame = priorityFrame >= 0 ? priorityFrame : KisAsyncAnimationCacheRenderDialog::calcFirstDirtyFrame(cache, currentRange, skipRange);
 
        if (frame >= 0) {
            return regenerate(cache, frame);
        }
 
        return RequestRejected;
    }