KisAnimationFrameCache Class Reference

#include <kis_animation_frame_cache.h>

Inheritance diagram for KisAnimationFrameCache:

Classes
struct	Private

Public Types
enum	CacheStatus { Cached , Uncached }

Signals
void	changed ()

Public Member Functions
void	addConvertedFrameData (KisOpenGLUpdateInfoSP info, int time)
void	dropLowQualityFrames (const KisTimeSpan &range, const QRect &regionOfInterest, const QRect &minimalRect)
KisOpenGLUpdateInfoSP	fetchFrameData (int time, KisImageSP image, const KisRegion &requestedRegion) const
bool	framesHaveValidRoi (const KisTimeSpan &range, const QRect &regionOfInterest)
CacheStatus	frameStatus (int time) const
QImage	getFrame (int time)
KisImageWSP	image ()
	KisAnimationFrameCache (KisOpenGLImageTexturesSP textures)
bool	shouldUploadNewFrame (int newTime, int oldTime) const
bool	tryGlueSameFrames (const KisTimeSpan &range)
bool	uploadFrame (int time)
	~KisAnimationFrameCache () override
Public Member Functions inherited from KisShared
bool	deref ()
bool	ref ()
int	refCount ()
QAtomicInt *	sharedWeakReference ()

Static Public Member Functions
static const KisAnimationFrameCacheSP	cacheForImage (KisImageWSP image)
static const QList< KisAnimationFrameCache * >	caches ()
static KisAnimationFrameCacheSP	getFrameCache (KisOpenGLImageTexturesSP textures)

Private Slots
void	framesChanged (const KisTimeSpan &range, const QRect &rect)
void	slotConfigChanged ()

Private Attributes
QScopedPointer< Private >	m_d

Additional Inherited Members
Protected Member Functions inherited from KisShared
	KisShared ()
	~KisShared ()

Detailed Description

Definition at line 28 of file kis_animation_frame_cache.h.

Member Enumeration Documentation

CacheStatus

enum KisAnimationFrameCache::CacheStatus

Enumerator
Cached
Uncached

Definition at line 46 of file kis_animation_frame_cache.h.

                     {
        Cached,
        Uncached,
    };

Constructor & Destructor Documentation

KisAnimationFrameCache()

KisAnimationFrameCache::KisAnimationFrameCache

(

KisOpenGLImageTexturesSP

textures

)

Definition at line 212 of file kis_animation_frame_cache.cpp.

    : m_d(new Private(textures))
{
    // create swapping backend
    slotConfigChanged();
 
    connect(m_d->image->animationInterface(), SIGNAL(sigFramesChanged(KisTimeSpan,QRect)), this, SLOT(framesChanged(KisTimeSpan,QRect)));
    connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
}

References connect(), framesChanged(), KisConfigNotifier::instance(), m_d, and slotConfigChanged().

~KisAnimationFrameCache()

KisAnimationFrameCache::~KisAnimationFrameCache ( )

override

Definition at line 222 of file kis_animation_frame_cache.cpp.

{
    Private::caches.remove(m_d->textures);
}

References KisAnimationFrameCache::Private::caches, and m_d.

Member Function Documentation

addConvertedFrameData()

void KisAnimationFrameCache::addConvertedFrameData	(	KisOpenGLUpdateInfoSP	info,
		int	time )

Definition at line 432 of file kis_animation_frame_cache.cpp.

{
    const KisTimeSpan identicalRange =
        KisTimeSpan::calculateIdenticalFramesRecursive(m_d->image->root(), time);
 
    m_d->addFrame(info, identicalRange);
 
    Q_EMIT changed();
}

References KisTimeSpan::calculateIdenticalFramesRecursive(), changed(), and m_d.

cacheForImage()

const KisAnimationFrameCacheSP KisAnimationFrameCache::cacheForImage ( KisImageWSP image )

static

Definition at line 204 of file kis_animation_frame_cache.cpp.

{
    auto it = std::find_if(Private::caches.begin(), Private::caches.end(),
                           [image] (KisAnimationFrameCache *cache) { return cache->image() == image; });
 
    return it != Private::caches.end() ? *it : nullptr;
}

References KisAnimationFrameCache::Private::caches, and image().

caches()

const QList< KisAnimationFrameCache * > KisAnimationFrameCache::caches ( )

static

Definition at line 199 of file kis_animation_frame_cache.cpp.

{
    return Private::caches.values();
}

References KisAnimationFrameCache::Private::caches.

changed

void KisAnimationFrameCache::changed ( )

signal

dropLowQualityFrames()

void KisAnimationFrameCache::dropLowQualityFrames	(	const KisTimeSpan &	range,
		const QRect &	regionOfInterest,
		const QRect &	minimalRect )

Drops all the frames with worse level of detail values than the current desired level of detail.

Definition at line 442 of file kis_animation_frame_cache.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(!range.isInfinite());
    if (m_d->newFrames.isEmpty()) return;
 
    auto it = m_d->newFrames.upperBound(range.start());
 
    // the vector is guaranteed to be non-empty,
    // so decrementing iterator is safe
    if (it != m_d->newFrames.begin()) it--;
 
    while (it != m_d->newFrames.end() && it.key() <= range.end()) {
        const int frameId = it.key();
        const int frameLength = it.value();
 
        if (frameId + frameLength - 1 < range.start()) {
            ++it;
            continue;
        }
 
        const QRect frameRect = m_d->swapper->frameDirtyRect(frameId);
        const int frameLod = m_d->swapper->frameLevelOfDetail(frameId);
 
        if (frameLod > m_d->effectiveLevelOfDetail(regionOfInterest) || !frameRect.contains(minimalRect)) {
            m_d->swapper->forgetFrame(frameId);
            it = m_d->newFrames.erase(it);
        } else {
            ++it;
        }
    }
}

References KisTimeSpan::end(), KisTimeSpan::isInfinite(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, and KisTimeSpan::start().

fetchFrameData()

KisOpenGLUpdateInfoSP KisAnimationFrameCache::fetchFrameData	(	int	time,
		KisImageSP	image,
		const KisRegion &	requestedRegion ) const

Definition at line 405 of file kis_animation_frame_cache.cpp.

{
    if (time != image->animationInterface()->currentTime()) {
        qWarning() << "WARNING: KisAnimationFrameCache::frameReady image's time doesn't coincide with the requested time!";
        qWarning() << "    "  << ppVar(image->animationInterface()->currentTime()) << ppVar(time);
    }
 
    // the frames are always generated at full scale
    KIS_SAFE_ASSERT_RECOVER_NOOP(image->currentLevelOfDetail() == 0);
 
    const int lod = m_d->effectiveLevelOfDetail(requestedRegion.boundingRect());
 
    KisOpenGLUpdateInfoSP totalInfo;
 
    Q_FOREACH (const QRect &rc, requestedRegion.rects()) {
        KisOpenGLUpdateInfoSP info = m_d->fetchFrameDataImpl(image, rc, lod);
        if (!totalInfo) {
            totalInfo = info;
        } else {
            const bool result = totalInfo->tryMergeWith(*info);
            KIS_SAFE_ASSERT_RECOVER_NOOP(result);
        }
    }
 
    return totalInfo;
}

References KisImage::animationInterface(), KisRegion::boundingRect(), KisImage::currentLevelOfDetail(), KisImageAnimationInterface::currentTime(), image(), KIS_SAFE_ASSERT_RECOVER_NOOP, m_d, ppVar, KisRegion::rects(), and KisOpenGLUpdateInfo::tryMergeWith().

framesChanged

void KisAnimationFrameCache::framesChanged ( const KisTimeSpan & range, const QRect & rect )

privateslot

Definition at line 362 of file kis_animation_frame_cache.cpp.

{
    Q_UNUSED(rect);
 
    if (!range.isValid()) return;
 
    bool cacheChanged = m_d->invalidate(range);
 
    if (cacheChanged) {
        Q_EMIT changed();
    }
}

References changed(), KisTimeSpan::isValid(), and m_d.

framesHaveValidRoi()

bool KisAnimationFrameCache::framesHaveValidRoi	(	const KisTimeSpan &	range,
		const QRect &	regionOfInterest )

Definition at line 474 of file kis_animation_frame_cache.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!range.isInfinite(), false);
    if (m_d->newFrames.isEmpty()) return false;
 
    auto it = m_d->newFrames.upperBound(range.start());
 
    if (it != m_d->newFrames.begin()) it--;
 
    int expectedNextFrameStart = it.key();
 
    while (it.key() <= range.end()) {
        const int frameId = it.key();
        const int frameLength = it.value();
 
        if (frameId + frameLength - 1 < range.start()) {
            expectedNextFrameStart = frameId + frameLength;
            ++it;
            continue;
        }
 
        if (expectedNextFrameStart != frameId) {
            KIS_SAFE_ASSERT_RECOVER_NOOP(expectedNextFrameStart < frameId);
            return false;
        }
 
        if (!m_d->swapper->frameDirtyRect(frameId).contains(regionOfInterest)) {
            return false;
        }
 
        expectedNextFrameStart = frameId + frameLength;
        ++it;
    }
 
    return true;
}

References KisTimeSpan::end(), KisTimeSpan::isInfinite(), KIS_SAFE_ASSERT_RECOVER_NOOP, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_d, and KisTimeSpan::start().

frameStatus()

KisAnimationFrameCache::CacheStatus KisAnimationFrameCache::frameStatus

(

int

time

)

const

Definition at line 254 of file kis_animation_frame_cache.cpp.

{
    return m_d->hasFrame(time) ? Cached : Uncached;
}

References Cached, m_d, and Uncached.

getFrame()

QImage KisAnimationFrameCache::getFrame

(

int

time

)

getFrameCache()

KisAnimationFrameCacheSP KisAnimationFrameCache::getFrameCache ( KisOpenGLImageTexturesSP textures )

static

Definition at line 184 of file kis_animation_frame_cache.cpp.

{
    KisAnimationFrameCache *cache;
 
    Private::CachesMap::iterator it = Private::caches.find(textures);
    if (it == Private::caches.end()) {
        cache = new KisAnimationFrameCache(textures);
        Private::caches.insert(textures, cache);
    } else {
        cache = it.value();
    }
 
    return cache;
}

References KisAnimationFrameCache::Private::caches, and KisAnimationFrameCache().

image()

KisImageWSP KisAnimationFrameCache::image

(

)

Definition at line 357 of file kis_animation_frame_cache.cpp.

{
    return m_d->image;
}

References m_d.

shouldUploadNewFrame()

bool KisAnimationFrameCache::shouldUploadNewFrame	(	int	newTime,
		int	oldTime ) const

Definition at line 243 of file kis_animation_frame_cache.cpp.

{
    if (oldTime < 0) return true;
 
    const int oldKeyframeStart = m_d->getFrameIdAtTime(oldTime);
    if (oldKeyframeStart < 0) return true;
 
    const int oldKeyFrameLength = m_d->newFrames[oldKeyframeStart];
    return !(newTime >= oldKeyframeStart && (newTime < oldKeyframeStart + oldKeyFrameLength || oldKeyFrameLength == -1));
}

References m_d.

slotConfigChanged

void KisAnimationFrameCache::slotConfigChanged ( )

privateslot

Definition at line 375 of file kis_animation_frame_cache.cpp.

{
    m_d->newFrames.clear();
 
    KisImageConfig cfg(true);
 
    if (cfg.useOnDiskAnimationCacheSwapping()) {
        m_d->swapper.reset(new KisFrameCacheSwapper(m_d->textures->updateInfoBuilder(), cfg.swapDir()));
    } else {
        m_d->swapper.reset(new KisInMemoryFrameCacheSwapper());
    }
 
    m_d->frameSizeLimit = cfg.useAnimationCacheFrameSizeLimit() ? cfg.animationCacheFrameSizeLimit() : 0;
    Q_EMIT changed();
}

References KisImageConfig::animationCacheFrameSizeLimit(), changed(), m_d, KisImageConfig::swapDir(), KisImageConfig::useAnimationCacheFrameSizeLimit(), and KisImageConfig::useOnDiskAnimationCacheSwapping().

tryGlueSameFrames()

bool KisAnimationFrameCache::tryGlueSameFrames

(

const KisTimeSpan &

range

)

Definition at line 326 of file kis_animation_frame_cache.cpp.

{
    struct FramesGluer : FramesGluerBase
    {
        KisAbstractFrameCacheSwapper *swapper {nullptr};
 
        FramesGluer(KisAbstractFrameCacheSwapper *_swapper, QMap<int, int> &_frames)
            : FramesGluerBase(_frames)
            , swapper(_swapper)
        {}
 
        void moveFrame(int oldStart, int newStart) override {
            swapper->moveFrame(oldStart, newStart);
        }
 
        void forgetFrame(int start) override{
            swapper->forgetFrame(start);
        }
    };
 
    FramesGluer gluer(m_d->swapper.data(), m_d->newFrames);
 
    const bool cacheChanged = gluer.glueFrames(range);
 
    if (cacheChanged) {
        Q_EMIT changed();
    }
 
    return cacheChanged;
}

References changed(), m_d, and FramesGluerBase::moveFrame().

uploadFrame()

bool KisAnimationFrameCache::uploadFrame

(

int

time

)

Definition at line 227 of file kis_animation_frame_cache.cpp.

{
    KisOpenGLUpdateInfoSP info = m_d->getFrame(time);
 
    if (!info) {
        // Do nothing!
        //
        // Previously we were trying to start cache regeneration in this point,
        // but it caused even bigger slowdowns when scrubbing
    } else {
        m_d->textures->recalculateCache(info, false);
    }
 
    return bool(info);
}

References m_d.

Member Data Documentation

m_d

QScopedPointer<Private> KisAnimationFrameCache::m_d

private

Definition at line 74 of file kis_animation_frame_cache.h.

---

The documentation for this class was generated from the following files:

• libs/ui/kis_animation_frame_cache.h
• libs/ui/kis_animation_frame_cache.cpp