Classes
struct	Frame

Public Types
typedef QMap< KisOpenGLImageTexturesSP, KisAnimationFrameCache * >	CachesMap

Public Member Functions
void	addFrame (KisOpenGLUpdateInfoSP info, const KisTimeSpan &range)

int	effectiveLevelOfDetail (const QRect &rc) const

KisOpenGLUpdateInfoSP	fetchFrameDataImpl (KisImageSP image, const QRect &requestedRect, int lod)

KisOpenGLUpdateInfoSP	getFrame (int time)

int	getFrameIdAtTime (int time) const

bool	hasFrame (int time) const

bool	invalidate (const KisTimeSpan &range)

	Private (KisOpenGLImageTexturesSP _textures)

	~Private ()

Public Attributes
int	frameSizeLimit = 777

KisImageWSP	image

QMap< int, int >	newFrames

QScopedPointer< KisAbstractFrameCacheSwapper >	swapper

KisOpenGLImageTexturesSP	textures

Static Public Attributes
static CachesMap	caches

Detailed Description

Definition at line 33 of file kis_animation_frame_cache.cpp.

Member Typedef Documentation

◆ CachesMap

typedef QMap<KisOpenGLImageTexturesSP, KisAnimationFrameCache*> KisAnimationFrameCache::Private::CachesMap

Definition at line 178 of file kis_animation_frame_cache.cpp.

Constructor & Destructor Documentation

◆ Private()

KisAnimationFrameCache::Private::Private ( KisOpenGLImageTexturesSP _textures )

inline

Definition at line 35 of file kis_animation_frame_cache.cpp.

        : textures(_textures)
    {
        image = textures->image();
    }

References image, KisOpenGLImageTextures::image(), and textures.

◆ ~Private()

KisAnimationFrameCache::Private::~Private ( )

inline

Definition at line 41 of file kis_animation_frame_cache.cpp.

42 {

43 }

Member Function Documentation

◆ addFrame()

void KisAnimationFrameCache::Private::addFrame	(	KisOpenGLUpdateInfoSP	info,
		const KisTimeSpan &	range )

inline

Definition at line 103 of file kis_animation_frame_cache.cpp.

    {
        invalidate(range);
 
        const int length = range.isInfinite() ? -1 : range.end() - range.start() + 1;
        newFrames.insert(range.start(), length);
        swapper->saveFrame(range.start(), info, image->bounds());
    }

References KisImage::bounds(), KisTimeSpan::end(), image, invalidate(), KisTimeSpan::isInfinite(), length(), newFrames, KisTimeSpan::start(), and swapper.

◆ effectiveLevelOfDetail()

int KisAnimationFrameCache::Private::effectiveLevelOfDetail ( const QRect & rc ) const

inline

Definition at line 166 of file kis_animation_frame_cache.cpp.

                                                      {
        if (!frameSizeLimit) return 0;
 
        const int maxDimension = KisAlgebra2D::maxDimension(rc);
 
        const qreal minLod = -std::log2(qreal(frameSizeLimit) / maxDimension);
        const int lodLimit = qMax(0, qCeil(minLod));
        return lodLimit;
    }

References frameSizeLimit, and KisAlgebra2D::maxDimension().

◆ fetchFrameDataImpl()

KisOpenGLUpdateInfoSP KisAnimationFrameCache::Private::fetchFrameDataImpl	(	KisImageSP	image,
		const QRect &	requestedRect,
		int	lod )

Definition at line 391 of file kis_animation_frame_cache.cpp.

{
    if (lod > 0) {
        KisPaintDeviceSP tempDevice = new KisPaintDevice(image->projection()->colorSpace());
        tempDevice->prepareClone(image->projection());
        image->projection()->generateLodCloneDevice(tempDevice, image->projection()->extent(), lod);
 
        const QRect fetchRect = KisLodTransform::alignedRect(requestedRect, lod);
        return textures->updateInfoBuilder().buildUpdateInfo(fetchRect, tempDevice, image->bounds(), lod, true);
    } else {
        return textures->updateCache(requestedRect, image);
    }
}

References KisLodTransformBase::alignedRect(), KisImage::bounds(), KisOpenGLUpdateInfoBuilder::buildUpdateInfo(), KisPaintDevice::colorSpace(), KisPaintDevice::extent(), KisPaintDevice::generateLodCloneDevice(), image, KisPaintDevice::prepareClone(), KisImage::projection(), textures, KisOpenGLImageTextures::updateCache(), and KisOpenGLImageTextures::updateInfoBuilder().

◆ getFrame()

KisOpenGLUpdateInfoSP KisAnimationFrameCache::Private::getFrame ( int time )

inline

Definition at line 97 of file kis_animation_frame_cache.cpp.

    {
        const int frameId = getFrameIdAtTime(time);
        return frameId >= 0 ? swapper->loadFrame(frameId) : 0;
    }

References getFrameIdAtTime(), and swapper.

◆ getFrameIdAtTime()

int KisAnimationFrameCache::Private::getFrameIdAtTime ( int time ) const

inline

Definition at line 65 of file kis_animation_frame_cache.cpp.

    {
        if (newFrames.isEmpty()) return -1;
 
        auto it = newFrames.upperBound(time);
 
        if (it != newFrames.constBegin()) it--;
 
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(it != newFrames.constEnd(), 0);
        const int start = it.key();
        const int length = it.value();
 
        bool foundFrameValid = false;
 
        if (length == -1) {
            if (start <= time) {
                foundFrameValid = true;
            }
        } else {
            int end = start + length - 1;
            if (start <= time && time <= end) {
                foundFrameValid = true;
            }
        }
 
        return foundFrameValid ? start : -1;
    }

References KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, length(), and newFrames.

◆ hasFrame()

bool KisAnimationFrameCache::Private::hasFrame ( int time ) const

inline

Definition at line 93 of file kis_animation_frame_cache.cpp.

                                  {
        return getFrameIdAtTime(time) >= 0;
    }

References getFrameIdAtTime().

◆ invalidate()

bool KisAnimationFrameCache::Private::invalidate ( const KisTimeSpan & range )

inline

Invalidate any cached frames within the given time range.

Parameters

range

Returns: true if frames were invalidated, false if nothing was changed

Definition at line 117 of file kis_animation_frame_cache.cpp.

    {
        if (newFrames.isEmpty()) return false;
 
        bool cacheChanged = false;
 
        auto it = newFrames.lowerBound(range.start());
        if (it.key() != range.start() && it != newFrames.begin()) it--;
 
        while (it != newFrames.end()) {
            const int start = it.key();
            const int length = it.value();
            const bool frameIsInfinite = (length == -1);
            const int end = start + length - 1;
 
            if (start >= range.start()) {
                if (!range.isInfinite() && start > range.end()) {
                    break;
                }
 
                if (!range.isInfinite() && (frameIsInfinite || end > range.end())) {
                    // Reinsert with a later start
                    int newStart = range.end() + 1;
                    int newLength = frameIsInfinite ? -1 : (end - newStart + 1);
 
                    newFrames.insert(newStart, newLength);
                    swapper->moveFrame(start, newStart);
                } else {
                    swapper->forgetFrame(start);
                }
 
                it = newFrames.erase(it);
 
                cacheChanged = true;
                continue;
 
            } else if (frameIsInfinite || end >= range.start()) {
                const int newEnd = range.start() - 1;
                *it = newEnd - start + 1;
 
                cacheChanged = true;
            }
 
            it++;
        }
 
        return cacheChanged;
    }