KisFrameDataSerializer Class Reference

#include <KisFrameDataSerializer.h>

Inheritance diagram for KisFrameDataSerializer:

Classes
struct	Frame
struct	FrameTile

Public Member Functions
QString	fileNameForFrame (int frameId)
QString	filePathForFrame (int frameId)
void	forgetFrame (int frameId)
int	generateFrameId ()
quint8 *	getCompressionBuffer (int size)
bool	hasFrame (int frameId) const
	KisFrameDataSerializer ()
	KisFrameDataSerializer (const QString &frameCachePath)
Frame	loadFrame (int frameId, KisTextureTileInfoPoolSP pool)
void	moveFrame (int srcFrameId, int dstFrameId)
	Private (const QString &frameCachePath)
int	saveFrame (const Frame &frame)
QString	subfolderNameForFrame (int frameId)
	~KisFrameDataSerializer ()
Public Member Functions inherited from Private
	Private (KisCanvas2 *c)

Static Public Member Functions
static void	addFrames (Frame &dst, const Frame &src)
static boost::optional< qreal >	estimateFrameUniqueness (const Frame &lhs, const Frame &rhs, qreal portion)
static bool	subtractFrames (Frame &dst, const Frame &src)

Public Attributes
QByteArray	compressionBuffer
QTemporaryDir	framesDir
QDir	framesDirObject
int	nextFrameId = 0
Public Attributes inherited from Private
KisCanvas2 *	canvas
int	displayedFrame
int	intendedFrame

Static Private Member Functions
template<template< typename U > class OpPolicy>
static bool	processFrames (KisFrameDataSerializer::Frame &dst, const KisFrameDataSerializer::Frame &src)

Private Attributes
const QScopedPointer< Private >	m_d

Detailed Description

KisFrameDataSerializer is the lowest level class for storing frame data on disk. Its responsibilities are simple:

1) Accept low-level frame data object (KisFrameDataSerializer::Frame), which contains raw data in it (the data may be not a pixel data, but a preprocessed pixel differences)

2) Compress this data and save it on disk

Definition at line 15 of file KisFrameDataSerializer.cpp.

Constructor & Destructor Documentation

KisFrameDataSerializer() [1/2]

KisFrameDataSerializer::KisFrameDataSerializer

(

)

Definition at line 64 of file KisFrameDataSerializer.cpp.

    : KisFrameDataSerializer(QString())
{
}

KisFrameDataSerializer() [2/2]

KisFrameDataSerializer::KisFrameDataSerializer

(

const QString &

frameCachePath

)

Definition at line 69 of file KisFrameDataSerializer.cpp.

    : m_d(new Private(frameCachePath))
{
}

~KisFrameDataSerializer()

KisFrameDataSerializer::~KisFrameDataSerializer

(

)

Definition at line 74 of file KisFrameDataSerializer.cpp.

{
}

Member Function Documentation

addFrames()

void KisFrameDataSerializer::addFrames ( KisFrameDataSerializer::Frame & dst, const Frame & src )

static

Definition at line 345 of file KisFrameDataSerializer.cpp.

{
    // TODO: don't spend time on calculation of "framesAreSame" in this case
    (void) processFrames<std::plus>(dst, src);
}

References void().

estimateFrameUniqueness()

boost::optional< qreal > KisFrameDataSerializer::estimateFrameUniqueness ( const Frame & lhs, const Frame & rhs, qreal portion )

static

Definition at line 247 of file KisFrameDataSerializer.cpp.

{
    if (lhs.pixelSize != rhs.pixelSize) return boost::none;
    if (lhs.frameTiles.size() != rhs.frameTiles.size()) return boost::none;
 
    const int pixelSize = lhs.pixelSize;
    int numSampledPixels = 0;
    int numUniquePixels = 0;
    const int sampleStep = portion > 0.0 ? qMax(1, qRound(1.0 / portion)) : 0;
 
    for (int i = 0; i < int(lhs.frameTiles.size()); i++) {
        const FrameTile &lhsTile = lhs.frameTiles[i];
        const FrameTile &rhsTile = rhs.frameTiles[i];
 
        if (lhsTile.col != rhsTile.col ||
            lhsTile.row != rhsTile.row ||
            lhsTile.rect != rhsTile.rect) {
 
            return boost::none;
        }
 
        if (sampleStep > 0) {
            const int numPixels = lhsTile.rect.width() * lhsTile.rect.height();
 
            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(lhsTile.data.data(), boost::none);
            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(rhsTile.data.data(), boost::none);
 
            for (int j = 0; j < numPixels; j += sampleStep) {
                quint8 *lhsDataPtr = lhsTile.data.data() + j * pixelSize;
                quint8 *rhsDataPtr = rhsTile.data.data() + j * pixelSize;
 
                if (std::memcmp(lhsDataPtr, rhsDataPtr, pixelSize) != 0) {
                    numUniquePixels++;
                }
                numSampledPixels++;
            }
        }
    }
 
    return numSampledPixels > 0 ? qreal(numUniquePixels) / numSampledPixels : 1.0;
}

References KisFrameDataSerializer::FrameTile::col, KisFrameDataSerializer::FrameTile::data, DataBuffer::data(), KisFrameDataSerializer::Frame::frameTiles, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, KisFrameDataSerializer::Frame::pixelSize, KisFrameDataSerializer::FrameTile::rect, and KisFrameDataSerializer::FrameTile::row.

fileNameForFrame()

QString KisFrameDataSerializer::fileNameForFrame ( int frameId )

inline

Definition at line 34 of file KisFrameDataSerializer.cpp.

                                          {
        return QString("frame_%1").arg(frameId);
    }

filePathForFrame()

QString KisFrameDataSerializer::filePathForFrame ( int frameId )

inline

Definition at line 38 of file KisFrameDataSerializer.cpp.

    {
        return framesDirObject.filePath(
                    subfolderNameForFrame(frameId) + '/' +
                    fileNameForFrame(frameId));
    }

forgetFrame()

void KisFrameDataSerializer::forgetFrame

(

int

frameId

)

Definition at line 241 of file KisFrameDataSerializer.cpp.

{
    const QString framePath = m_d->filePathForFrame(frameId);
    QFile::remove(framePath);
}

References m_d.

generateFrameId()

int KisFrameDataSerializer::generateFrameId ( )

inline

Definition at line 45 of file KisFrameDataSerializer.cpp.

                          {
        // TODO: handle wrapping and range compression
        return nextFrameId++;
    }

getCompressionBuffer()

quint8 * KisFrameDataSerializer::getCompressionBuffer ( int size )

inline

Definition at line 50 of file KisFrameDataSerializer.cpp.

                                           {
        if (compressionBuffer.size() < size) {
            compressionBuffer.resize(size);
        }
        return reinterpret_cast<quint8*>(compressionBuffer.data());
    }

hasFrame()

bool KisFrameDataSerializer::hasFrame

(

int

frameId

)

const

Definition at line 235 of file KisFrameDataSerializer.cpp.

{
    const QString framePath = m_d->filePathForFrame(frameId);
    return QFileInfo(framePath).exists();
}

References m_d.

loadFrame()

KisFrameDataSerializer::Frame KisFrameDataSerializer::loadFrame	(	int	frameId,
		KisTextureTileInfoPoolSP	pool )

Definition at line 141 of file KisFrameDataSerializer.cpp.

{
    KisLzfCompression compression;
 
    QElapsedTimer loadingTime;
    loadingTime.start();
 
    int loadedFrameId = -1;
    KisFrameDataSerializer::Frame frame;
 
    qint64 compressionTime = 0;
 
    const QString framePath = m_d->filePathForFrame(frameId);
 
    QFile file(framePath);
    KIS_SAFE_ASSERT_RECOVER_NOOP(file.exists());
    if (!file.open(QFile::ReadOnly)) return frame;
 
    QDataStream stream(&file);
 
    int numTiles = 0;
 
    stream >> loadedFrameId;
    stream >> frame.pixelSize;
    stream >> numTiles;
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(loadedFrameId == frameId, KisFrameDataSerializer::Frame());
 
 
 
    for (int i = 0; i < numTiles; i++) {
        FrameTile tile(pool);
        stream >> tile.col;
        stream >> tile.row;
        stream >> tile.rect;
 
        const int frameByteSize = frame.pixelSize * tile.rect.width() * tile.rect.height();
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(frameByteSize <= pool->chunkSize(frame.pixelSize),
                                             KisFrameDataSerializer::Frame());
 
        bool isCompressed = false;
        int inputSize = -1;
 
        stream >> isCompressed;
        stream >> inputSize;
 
        if (isCompressed) {
            const int maxBufferSize = compression.outputBufferSize(inputSize);
            quint8 *buffer = m_d->getCompressionBuffer(maxBufferSize);
            stream.readRawData((char*)buffer, inputSize);
 
            tile.data.allocate(frame.pixelSize);
 
            QElapsedTimer compTime;
            compTime.start();
 
            const int decompressedSize =
                compression.decompress(buffer, inputSize, tile.data.data(), frameByteSize);
 
            compressionTime += compTime.nsecsElapsed();
 
            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(frameByteSize == decompressedSize,
                                                 KisFrameDataSerializer::Frame());
 
        } else {
            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(frameByteSize == inputSize,
                                                 KisFrameDataSerializer::Frame());
 
            tile.data.allocate(frame.pixelSize);
            stream.readRawData((char*)tile.data.data(), inputSize);
        }
 
        frame.frameTiles.push_back(std::move(tile));
    }
 
    Q_UNUSED(compressionTime);
 
    file.close();
 
    return frame;
}

References DataBuffer::allocate(), KisFrameDataSerializer::FrameTile::col, KisFrameDataSerializer::FrameTile::data, DataBuffer::data(), KisLzfCompression::decompress(), KisFrameDataSerializer::Frame::frameTiles, KIS_SAFE_ASSERT_RECOVER_NOOP, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_d, KisLzfCompression::outputBufferSize(), KisFrameDataSerializer::Frame::pixelSize, KisFrameDataSerializer::FrameTile::rect, and KisFrameDataSerializer::FrameTile::row.

moveFrame()

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

Definition at line 222 of file KisFrameDataSerializer.cpp.

{
    const QString srcFramePath = m_d->filePathForFrame(srcFrameId);
    const QString dstFramePath = m_d->filePathForFrame(dstFrameId);
    KIS_SAFE_ASSERT_RECOVER_RETURN(QFileInfo(srcFramePath).exists());
 
    KIS_SAFE_ASSERT_RECOVER(!QFileInfo(dstFramePath).exists()) {
        QFile::remove(dstFramePath);
    }
 
    QFile::rename(srcFramePath, dstFramePath);
}

References KIS_SAFE_ASSERT_RECOVER, KIS_SAFE_ASSERT_RECOVER_RETURN, and m_d.

Private()

KisFrameDataSerializer::Private ( const QString & frameCachePath )

inline

Definition at line 17 of file KisFrameDataSerializer.cpp.

        : framesDir(
              (!frameCachePath.isEmpty() && QTemporaryDir(frameCachePath + "/KritaFrameCacheXXXXXX").isValid()
               ? frameCachePath
               : QDir::tempPath())
              + "/KritaFrameCacheXXXXXX")
    {
        framesDirObject = QDir(framesDir.path());
        framesDirObject.makeAbsolute();
    }

processFrames()

template<template< typename U > class OpPolicy>

bool KisFrameDataSerializer::processFrames ( KisFrameDataSerializer::Frame & dst, const KisFrameDataSerializer::Frame & src )

staticprivate

Definition at line 311 of file KisFrameDataSerializer.cpp.

{
    bool framesAreSame = true;
 
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(estimateFrameUniqueness(src, dst, 0.0), false);
 
    for (int i = 0; i < int(src.frameTiles.size()); i++) {
        const FrameTile &srcTile = src.frameTiles[i];
        FrameTile &dstTile = dst.frameTiles[i];
 
        const int numBytes = srcTile.rect.width() * srcTile.rect.height() * src.pixelSize;
        const int numQWords = numBytes / 8;
 
        const quint64 *srcDataPtr = reinterpret_cast<const quint64*>(srcTile.data.data());
        quint64 *dstDataPtr = reinterpret_cast<quint64*>(dstTile.data.data());
 
        framesAreSame &= processData<OpPolicy>(dstDataPtr, srcDataPtr, numQWords);
 
 
        const int tailBytes = numBytes % 8;
        const quint8 *srcTailDataPtr = srcTile.data.data() + numBytes - tailBytes;
        quint8 *dstTailDataPtr = dstTile.data.data() + numBytes - tailBytes;
 
        framesAreSame &= processData<OpPolicy>(dstTailDataPtr, srcTailDataPtr, tailBytes);
    }
 
    return framesAreSame;
}

References KisFrameDataSerializer::FrameTile::data, DataBuffer::data(), estimateFrameUniqueness(), KisFrameDataSerializer::Frame::frameTiles, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and KisFrameDataSerializer::FrameTile::rect.

saveFrame()

int KisFrameDataSerializer::saveFrame

(

const Frame &

frame

)

Definition at line 78 of file KisFrameDataSerializer.cpp.

{
    KisLzfCompression compression;
 
    const int frameId = m_d->generateFrameId();
 
    const QString frameSubfolder = m_d->subfolderNameForFrame(frameId);
 
    if (!m_d->framesDirObject.exists(frameSubfolder)) {
        m_d->framesDirObject.mkpath(frameSubfolder);
    }
 
    const QString frameRelativePath = frameSubfolder + '/' + m_d->fileNameForFrame(frameId);
 
    if (m_d->framesDirObject.exists(frameRelativePath)) {
        qWarning() << "WARNING: overwriting existing frame file!" << frameRelativePath;
        forgetFrame(frameId);
    }
 
    const QString frameFilePath = m_d->framesDirObject.filePath(frameRelativePath);
 
    QFile file(frameFilePath);
    file.open(QFile::WriteOnly);
 
    QDataStream stream(&file);
    stream << frameId;
    stream << frame.pixelSize;
 
    stream << int(frame.frameTiles.size());
 
    for (int i = 0; i < int(frame.frameTiles.size()); i++) {
        const FrameTile &tile = frame.frameTiles[i];
 
        stream << tile.col;
        stream << tile.row;
        stream << tile.rect;
 
        const int frameByteSize = frame.pixelSize * tile.rect.width() * tile.rect.height();
        const int maxBufferSize = compression.outputBufferSize(frameByteSize);
        quint8 *buffer = m_d->getCompressionBuffer(maxBufferSize);
 
        const int compressedSize =
            compression.compress(tile.data.data(), frameByteSize, buffer, maxBufferSize);
 
        //ENTER_FUNCTION() << ppVar(compressedSize) << ppVar(frameByteSize);
 
        const bool isCompressed = compressedSize < frameByteSize;
        stream << isCompressed;
 
        if (isCompressed) {
            stream << compressedSize;
            stream.writeRawData((char*)buffer, compressedSize);
        } else {
            stream << frameByteSize;
            stream.writeRawData((char*)tile.data.data(), frameByteSize);
        }
    }
 
    file.close();
 
    return frameId;
}

References KisFrameDataSerializer::FrameTile::col, KisLzfCompression::compress(), KisFrameDataSerializer::FrameTile::data, DataBuffer::data(), forgetFrame(), KisFrameDataSerializer::Frame::frameTiles, m_d, KisLzfCompression::outputBufferSize(), KisFrameDataSerializer::Frame::pixelSize, KisFrameDataSerializer::FrameTile::rect, and KisFrameDataSerializer::FrameTile::row.

subfolderNameForFrame()

QString KisFrameDataSerializer::subfolderNameForFrame ( int frameId )

inline

Definition at line 28 of file KisFrameDataSerializer.cpp.

    {
        const int subfolderIndex = frameId & 0xff00;
        return QString::number(subfolderIndex);
    }

subtractFrames()

bool KisFrameDataSerializer::subtractFrames ( KisFrameDataSerializer::Frame & dst, const Frame & src )

static

Definition at line 340 of file KisFrameDataSerializer.cpp.

{
    return processFrames<std::minus>(dst, src);
}

Member Data Documentation

compressionBuffer

QByteArray KisFrameDataSerializer::compressionBuffer

Definition at line 61 of file KisFrameDataSerializer.cpp.

framesDir

QTemporaryDir KisFrameDataSerializer::framesDir

Definition at line 57 of file KisFrameDataSerializer.cpp.

framesDirObject

QDir KisFrameDataSerializer::framesDirObject

Definition at line 58 of file KisFrameDataSerializer.cpp.

m_d

const QScopedPointer<Private> KisFrameDataSerializer::m_d

private

Definition at line 122 of file KisFrameDataSerializer.h.

nextFrameId

int KisFrameDataSerializer::nextFrameId = 0

Definition at line 59 of file KisFrameDataSerializer.cpp.

---

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

• libs/ui/KisFrameDataSerializer.cpp
• libs/ui/KisFrameDataSerializer.h