KisFrameCacheStore Class Reference

#include <KisFrameCacheStore.h>

Inheritance diagram for KisFrameCacheStore:

Public Member Functions
void	forgetFrame (int frameId)
QRect	frameDirtyRect (int frameId) const
int	frameLevelOfDetail (int frameId) const
bool	hasFrame (int frameId) const
	KisFrameCacheStore ()
	KisFrameCacheStore (const QString &frameCachePath)
KisOpenGLUpdateInfoSP	loadFrame (int frameId, const KisOpenGLUpdateInfoBuilder &builder)
void	moveFrame (int srcFrameId, int dstFrameId)
	Private (const QString &frameCachePath)
void	saveFrame (int frameId, KisOpenGLUpdateInfoSP info, const QRect &imageBounds)
	~KisFrameCacheStore ()
Public Member Functions inherited from Private
	Private (KisCanvas2 *c)

Public Attributes
KisFrameDataSerializer::Frame	lastLoadedBaseFrame
FrameInfoSP	lastLoadedBaseFrameInfo
KisFrameDataSerializer::Frame	lastSavedFullFrame
int	lastSavedFullFrameId = -1
QMap< int, FrameInfoSP >	savedFrames
KisFrameDataSerializer	serializer
Public Attributes inherited from Private
KisCanvas2 *	canvas
int	displayedFrame
int	intendedFrame

Private Attributes
const QScopedPointer< Private >	m_d

Detailed Description

KisFrameCacheStore is a middle-level class for reading/writing animation frames on disk. Its main responsibilities:

1) Convert frames from KisOpenGLUpdateInfo format into a serializable KisFrameDataSerializer::Frame format.

2) Calculate differences between the frames and decide which frame will be a keyframe for other frames.

3) The keyframes will be used as a base for difference calculation and stored in a short in-memory cache to avoid fetching them from disk too often.

4) The in-memory cache of the keyframes is stored in serializable KisFrameDataSerializer::Frame format.

Definition at line 116 of file KisFrameCacheStore.cpp.

Constructor & Destructor Documentation

KisFrameCacheStore() [1/2]

KisFrameCacheStore::KisFrameCacheStore

(

)

Definition at line 136 of file KisFrameCacheStore.cpp.

    : KisFrameCacheStore(QString())
{
}

KisFrameCacheStore() [2/2]

KisFrameCacheStore::KisFrameCacheStore

(

const QString &

frameCachePath

)

Definition at line 141 of file KisFrameCacheStore.cpp.

    : m_d(new Private(frameCachePath))
{
}

~KisFrameCacheStore()

KisFrameCacheStore::~KisFrameCacheStore

(

)

Definition at line 147 of file KisFrameCacheStore.cpp.

{
}

Member Function Documentation

forgetFrame()

void KisFrameCacheStore::forgetFrame

(

int

frameId

)

Definition at line 345 of file KisFrameCacheStore.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_NOOP(m_d->savedFrames.contains(frameId));
 
    if (m_d->lastSavedFullFrameId == frameId) {
        m_d->lastSavedFullFrame = KisFrameDataSerializer::Frame();
        m_d->lastSavedFullFrameId = -1;
    }
 
    m_d->savedFrames.remove(frameId);
}

References KIS_SAFE_ASSERT_RECOVER_NOOP, and m_d.

frameDirtyRect()

QRect KisFrameCacheStore::frameDirtyRect

(

int

frameId

)

const

Definition at line 368 of file KisFrameCacheStore.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_d->savedFrames.contains(frameId), QRect());
    return m_d->savedFrames[frameId]->dirtyImageRect();
}

References KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and m_d.

frameLevelOfDetail()

int KisFrameCacheStore::frameLevelOfDetail

(

int

frameId

)

const

Definition at line 362 of file KisFrameCacheStore.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_d->savedFrames.contains(frameId), 0);
    return m_d->savedFrames[frameId]->levelOfDetail();
}

References KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and m_d.

hasFrame()

bool KisFrameCacheStore::hasFrame

(

int

frameId

)

const

Definition at line 357 of file KisFrameCacheStore.cpp.

{
    return m_d->savedFrames.contains(frameId);
}

References m_d.

loadFrame()

KisOpenGLUpdateInfoSP KisFrameCacheStore::loadFrame	(	int	frameId,
		const KisOpenGLUpdateInfoBuilder &	builder )

Definition at line 245 of file KisFrameCacheStore.cpp.

{
    KisOpenGLUpdateInfoSP info = new KisOpenGLUpdateInfo();
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_d->savedFrames.contains(frameId), info);
 
    FrameInfoSP frameInfo = m_d->savedFrames[frameId];
 
    info->assignDirtyImageRect(frameInfo->dirtyImageRect());
    info->assignLevelOfDetail(frameInfo->levelOfDetail());
 
    KisFrameDataSerializer::Frame frame;
 
    switch (frameInfo->type()) {
    case FrameFull:
        frame = m_d->serializer.loadFrame(frameInfo->frameDataId(), builder.textureInfoPool());
        m_d->lastLoadedBaseFrame = frame.clone();
        m_d->lastLoadedBaseFrameInfo = frameInfo;
        break;
    case FrameCopy: {
        FrameInfoSP baseFrameInfo = frameInfo->baseFrame();
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(baseFrameInfo, KisOpenGLUpdateInfoSP());
 
        if (baseFrameInfo == m_d->lastLoadedBaseFrameInfo) {
            frame = m_d->lastLoadedBaseFrame.clone();
        } else {
            frame = m_d->serializer.loadFrame(baseFrameInfo->frameDataId(), builder.textureInfoPool());
            m_d->lastLoadedBaseFrame = frame.clone();
            m_d->lastLoadedBaseFrameInfo = baseFrameInfo;
        }
        break;
    }
    case FrameDiff: {
        FrameInfoSP baseFrameInfo = frameInfo->baseFrame();
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(baseFrameInfo, KisOpenGLUpdateInfoSP());
 
        if (baseFrameInfo == m_d->lastLoadedBaseFrameInfo) {
            // noop
        } else {
            m_d->lastLoadedBaseFrame = m_d->serializer.loadFrame(baseFrameInfo->frameDataId(), builder.textureInfoPool());
            m_d->lastLoadedBaseFrameInfo = baseFrameInfo;
 
            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_d->lastLoadedBaseFrame.isValid(), KisOpenGLUpdateInfoSP());
        }
 
        const KisFrameDataSerializer::Frame &baseFrame = m_d->lastLoadedBaseFrame;
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(baseFrame.isValid(), KisOpenGLUpdateInfoSP());
 
        frame = m_d->serializer.loadFrame(frameInfo->frameDataId(), builder.textureInfoPool());
        KisFrameDataSerializer::addFrames(frame, baseFrame);
        break;
    }
    }
 
    for (auto it = frame.frameTiles.begin(); it != frame.frameTiles.end(); ++it) {
        KisFrameDataSerializer::FrameTile &tile = *it;
 
        QRect patchRect = tile.rect;
 
        if (frameInfo->levelOfDetail()) {
            patchRect = KisLodTransform::upscaledRect(patchRect, frameInfo->levelOfDetail());
        }
 
        const QRect fullSizeTileRect =
            builder.calculatePhysicalTileRect(tile.col, tile.row,
                                              frameInfo->imageBounds(),
                                              frameInfo->levelOfDetail());
 
        KisTextureTileUpdateInfoSP tileInfo(
            new KisTextureTileUpdateInfo(tile.col, tile.row,
                                         fullSizeTileRect, patchRect,
                                         frameInfo->imageBounds(),
                                         frameInfo->levelOfDetail(),
                                         builder.textureInfoPool()));
 
        tileInfo->putPixelData(std::move(tile.data), builder.destinationColorSpace());
 
        info->tileList << tileInfo;
    }
 
    return info;
}

References KisFrameDataSerializer::addFrames(), KisOpenGLUpdateInfo::assignDirtyImageRect(), KisOpenGLUpdateInfo::assignLevelOfDetail(), KisOpenGLUpdateInfoBuilder::calculatePhysicalTileRect(), KisFrameDataSerializer::Frame::clone(), KisFrameDataSerializer::FrameTile::col, KisFrameDataSerializer::FrameTile::data, KisOpenGLUpdateInfoBuilder::destinationColorSpace(), KisFrameDataSerializer::Frame::frameTiles, KisFrameDataSerializer::Frame::isValid(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_d, KisFrameDataSerializer::FrameTile::rect, KisFrameDataSerializer::FrameTile::row, KisOpenGLUpdateInfoBuilder::textureInfoPool(), KisOpenGLUpdateInfo::tileList, and KisLodTransformBase::upscaledRect().

moveFrame()

void KisFrameCacheStore::moveFrame	(	int	srcFrameId,
		int	dstFrameId )

Definition at line 327 of file KisFrameCacheStore.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(srcFrameId != dstFrameId);
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->savedFrames.contains(srcFrameId));
 
    KIS_SAFE_ASSERT_RECOVER(!m_d->savedFrames.contains(dstFrameId)) {
        m_d->savedFrames.remove(dstFrameId);
    }
 
    m_d->savedFrames.insert(dstFrameId, m_d->savedFrames[srcFrameId]);
    m_d->savedFrames.remove(srcFrameId);
 
    if (m_d->lastSavedFullFrameId == srcFrameId) {
        m_d->lastSavedFullFrameId = dstFrameId;
    }
}

References KIS_SAFE_ASSERT_RECOVER, KIS_SAFE_ASSERT_RECOVER_RETURN, and m_d.

Private()

KisFrameCacheStore::Private ( const QString & frameCachePath )

inline

Definition at line 118 of file KisFrameCacheStore.cpp.

        : serializer(frameCachePath)
    {
    }

saveFrame()

void KisFrameCacheStore::saveFrame	(	int	frameId,
		KisOpenGLUpdateInfoSP	info,
		const QRect &	imageBounds )

The full-copying code is disabled intentionally:

We should never remove user-visible data on basis of statistics. On smaller images, like 32x32 pixels, there might be really subtle changes that are important for the user. So we should use difference instead of dumb copying.

Definition at line 151 of file KisFrameCacheStore.cpp.

{
    int pixelSize = 0;
 
    Q_FOREACH (auto tile, info->tileList) {
#ifdef SANITY_CHECK
        if (!pixelSize) {
            pixelSize = tile->pixelSize();
        } else {
            KIS_SAFE_ASSERT_RECOVER_RETURN(pixelSize == tile->pixelSize());
        }
#else
        pixelSize = tile->pixelSize();
        break;
#endif
    }
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(pixelSize);
 
    // TODO: assert that dirty image rect is equal to the full image rect
    // TODO: assert tile color space coincides with the destination color space
 
    KisFrameDataSerializer::Frame frame;
    frame.pixelSize = pixelSize;
 
    for (auto it = info->tileList.begin(); it != info->tileList.end(); ++it) {
        KisFrameDataSerializer::FrameTile tile(KisTextureTileInfoPoolSP(0)); // TODO: fix the pool should never be null!
        tile.col = (*it)->tileCol();
        tile.row = (*it)->tileRow();
        tile.rect = (*it)->realPatchRect();
        tile.data = std::move((*it)->takePixelData());
 
        KIS_SAFE_ASSERT_RECOVER(tile.data.data()) { continue; }
 
        frame.frameTiles.push_back(std::move(tile));
    }
 
    FrameInfoSP frameInfo;
 
    if (m_d->lastSavedFullFrame.isValid()) {
        boost::optional<qreal> uniqueness = KisFrameDataSerializer::estimateFrameUniqueness(m_d->lastSavedFullFrame, frame, 0.01);
 
 
        if (uniqueness) {
 
#if 0
            if (*uniqueness == 0.0) {
                FrameInfoSP baseFrameInfo = m_d->savedFrames[m_d->lastSavedFullFrameId];
                frameInfo = toQShared(new FrameInfo(info->dirtyImageRect(),
                                                    imageBounds,
                                                    info->levelOfDetail(),
                                                    m_d->serializer,
                                                    baseFrameInfo));
 
            } else
#endif
            if (*uniqueness < 0.5) {
                FrameInfoSP baseFrameInfo = m_d->savedFrames[m_d->lastSavedFullFrameId];
 
                KisFrameDataSerializer::subtractFrames(frame, m_d->lastSavedFullFrame);
                frameInfo = toQShared(new FrameInfo(info->dirtyImageRect(),
                                                    imageBounds,
                                                    info->levelOfDetail(),
                                                    m_d->serializer,
                                                    baseFrameInfo,
                                                    frame));
            }
        }
    }
 
    if (!frameInfo) {
        frameInfo = toQShared(new FrameInfo(info->dirtyImageRect(),
                                            imageBounds,
                                            info->levelOfDetail(),
                                            m_d->serializer,
                                            frame));
    }
 
    m_d->savedFrames.insert(frameId, frameInfo);
 
    if (frameInfo->type() == FrameFull) {
        m_d->lastSavedFullFrame = std::move(frame);
        m_d->lastSavedFullFrameId = frameId;
    }
}

References KisFrameDataSerializer::FrameTile::col, KisFrameDataSerializer::FrameTile::data, DataBuffer::data(), KisOpenGLUpdateInfo::dirtyImageRect(), KisFrameDataSerializer::estimateFrameUniqueness(), KisFrameDataSerializer::Frame::frameTiles, KIS_SAFE_ASSERT_RECOVER, KIS_SAFE_ASSERT_RECOVER_RETURN, KisOpenGLUpdateInfo::levelOfDetail(), m_d, KisFrameDataSerializer::Frame::pixelSize, KisFrameDataSerializer::FrameTile::rect, KisFrameDataSerializer::FrameTile::row, KisFrameDataSerializer::subtractFrames(), KisOpenGLUpdateInfo::tileList, and toQShared().

Member Data Documentation

lastLoadedBaseFrame

KisFrameDataSerializer::Frame KisFrameCacheStore::lastLoadedBaseFrame

Definition at line 130 of file KisFrameCacheStore.cpp.

lastLoadedBaseFrameInfo

FrameInfoSP KisFrameCacheStore::lastLoadedBaseFrameInfo

Definition at line 131 of file KisFrameCacheStore.cpp.

lastSavedFullFrame

KisFrameDataSerializer::Frame KisFrameCacheStore::lastSavedFullFrame

Definition at line 127 of file KisFrameCacheStore.cpp.

lastSavedFullFrameId

int KisFrameCacheStore::lastSavedFullFrameId = -1

Definition at line 128 of file KisFrameCacheStore.cpp.

m_d

const QScopedPointer<Private> KisFrameCacheStore::m_d

private

Definition at line 60 of file KisFrameCacheStore.h.

savedFrames

QMap<int, FrameInfoSP> KisFrameCacheStore::savedFrames

Definition at line 133 of file KisFrameCacheStore.cpp.

serializer

KisFrameDataSerializer KisFrameCacheStore::serializer

Definition at line 125 of file KisFrameCacheStore.cpp.

---

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

• libs/ui/KisFrameCacheStore.cpp
• libs/ui/KisFrameCacheStore.h