KisTileCompressor2 Class Reference

#include <kis_tile_compressor_2.h>

Inheritance diagram for KisTileCompressor2:

Public Member Functions
void	compressTileData (KisTileData *tileData, quint8 *buffer, qint32 bufferSize, qint32 &bytesWritten) override
bool	decompressTileData (quint8 *buffer, qint32 bufferSize, KisTileData *tileData) override
	KisTileCompressor2 ()
bool	readTile (QIODevice *io, KisTiledDataManager *dm) override
qint32	tileDataBufferSize (KisTileData *tileData) override
bool	writeTile (KisTileSP tile, KisPaintDeviceWriter &store) override
	~KisTileCompressor2 () override
Public Member Functions inherited from KisAbstractTileCompressor
	KisAbstractTileCompressor ()
virtual	~KisAbstractTileCompressor ()
Public Member Functions inherited from KisShared
bool	deref ()
bool	ref ()
int	refCount ()
QAtomicInt *	sharedWeakReference ()

Private Member Functions
QString	getHeader (KisTileSP tile, qint32 compressedSize)
qint32	maxHeaderLength ()
void	prepareStreamingBuffer (qint32 tileDataSize)
void	prepareWorkBuffers (qint32 tileDataSize)

Private Attributes
KisAbstractCompression *	m_compression
QByteArray	m_compressionBuffer
QByteArray	m_linearizationBuffer
QByteArray	m_streamingBuffer

Static Private Attributes
static const qint8	COMPRESSED_DATA_FLAG = 1
static const QString	m_compressionName = "LZF"
static const qint8	RAW_DATA_FLAG = 0

Additional Inherited Members
Protected Member Functions inherited from KisAbstractTileCompressor
qint32	pixelSize (KisTiledDataManager *dm)
qint32	xToCol (KisTiledDataManager *dm, qint32 x)
qint32	yToRow (KisTiledDataManager *dm, qint32 y)
Protected Member Functions inherited from KisShared
	KisShared ()
	~KisShared ()

Detailed Description

Definition at line 14 of file kis_tile_compressor_2.h.

Constructor & Destructor Documentation

KisTileCompressor2()

KisTileCompressor2::KisTileCompressor2

(

)

Definition at line 16 of file kis_tile_compressor_2.cpp.

{
    m_compression = new KisLzfCompression();
}

References m_compression.

~KisTileCompressor2()

KisTileCompressor2::~KisTileCompressor2 ( )

override

Definition at line 21 of file kis_tile_compressor_2.cpp.

{
    delete m_compression;
}

References m_compression.

Member Function Documentation

compressTileData()

void KisTileCompressor2::compressTileData ( KisTileData * tileData, quint8 * buffer, qint32 bufferSize, qint32 & bytesWritten )

overridevirtual

Compresses a tileData and writes it into the buffer. The buffer must be at least tileDataBufferSize() bytes long. Actual number of bytes written is returned using out-parameter bytesWritten

Parameters

tileData	an existing tile data. It should be created and acquired by the caller.
buffer	the buffer
bufferSize	the size of the buffer
bytesWritten	the number of written bytes

See also

tileDataBufferSize()

Implements KisAbstractTileCompressor.

Definition at line 105 of file kis_tile_compressor_2.cpp.

{
    const qint32 pixelSize = tileData->pixelSize();
    const qint32 tileDataSize = TILE_DATA_SIZE(pixelSize);
    qint32 compressedBytes;
 
    Q_UNUSED(bufferSize);
    Q_ASSERT(bufferSize >= tileDataSize + 1);
 
    prepareWorkBuffers(tileDataSize);
 
    KisAbstractCompression::linearizeColors(tileData->data(), (quint8*)m_linearizationBuffer.data(),
                                            tileDataSize, pixelSize);
 
    compressedBytes = m_compression->compress((quint8*)m_linearizationBuffer.data(), tileDataSize,
                                              (quint8*)m_compressionBuffer.data(), m_compressionBuffer.size());
 
    if(compressedBytes < tileDataSize) {
        buffer[0] = COMPRESSED_DATA_FLAG;
        memcpy(buffer + 1, m_compressionBuffer.data(), compressedBytes);
        bytesWritten = compressedBytes + 1;
    }
    else {
        buffer[0] = RAW_DATA_FLAG;
        memcpy(buffer + 1, tileData->data(), tileDataSize);
        bytesWritten = tileDataSize + 1;
    }
}

References KisAbstractCompression::compress(), COMPRESSED_DATA_FLAG, KisTileData::data(), KisAbstractCompression::linearizeColors(), m_compression, m_compressionBuffer, m_linearizationBuffer, KisTileData::pixelSize(), KisAbstractTileCompressor::pixelSize(), prepareWorkBuffers(), RAW_DATA_FLAG, and TILE_DATA_SIZE.

decompressTileData()

bool KisTileCompressor2::decompressTileData ( quint8 * buffer, qint32 bufferSize, KisTileData * tileData )

overridevirtual

Decompresses a tileData from a given buffer.

Parameters

buffer	the buffer
bufferSize	the size of the buffer
tileData	an existing tile data where the result will be written to. It should be created and acquired by the caller.

Implements KisAbstractTileCompressor.

Definition at line 137 of file kis_tile_compressor_2.cpp.

{
    const qint32 pixelSize = tileData->pixelSize();
    const qint32 tileDataSize = TILE_DATA_SIZE(pixelSize);
 
    if(buffer[0] == COMPRESSED_DATA_FLAG) {
        prepareWorkBuffers(tileDataSize);
 
        qint32 bytesWritten;
        bytesWritten = m_compression->decompress(buffer + 1, bufferSize - 1,
                                                 (quint8*)m_linearizationBuffer.data(), tileDataSize);
        if (bytesWritten == tileDataSize) {
            KisAbstractCompression::delinearizeColors((quint8*)m_linearizationBuffer.data(),
                                                      tileData->data(),
                                                      tileDataSize, pixelSize);
            return true;
        }
        return false;
    }
    else {
        memcpy(tileData->data(), buffer + 1, tileDataSize);
        return true;
    }
    return false;
 
}

References COMPRESSED_DATA_FLAG, KisTileData::data(), KisAbstractCompression::decompress(), KisAbstractCompression::delinearizeColors(), m_compression, m_linearizationBuffer, KisTileData::pixelSize(), KisAbstractTileCompressor::pixelSize(), prepareWorkBuffers(), and TILE_DATA_SIZE.

getHeader()

QString KisTileCompressor2::getHeader ( KisTileSP tile, qint32 compressedSize )

inlineprivate

Definition at line 180 of file kis_tile_compressor_2.cpp.

{
    qint32 x, y;
    qint32 width, height;
    tile->extent().getRect(&x, &y, &width, &height);
 
    return QString("%1,%2,%3,%4\n").arg(x).arg(y).arg(m_compressionName).arg(compressedSize);
}

References KisTile::extent(), and m_compressionName.

maxHeaderLength()

qint32 KisTileCompressor2::maxHeaderLength ( )

inlineprivate

Quite self describing

Definition at line 171 of file kis_tile_compressor_2.cpp.

{
    static const qint32 QINT32_LENGTH = 11;
    static const qint32 COMPRESSION_NAME_LENGTH = 5;
    static const qint32 SEPARATORS_LENGTH = 4;
 
    return 3 * QINT32_LENGTH + COMPRESSION_NAME_LENGTH + SEPARATORS_LENGTH;
}

prepareStreamingBuffer()

void KisTileCompressor2::prepareStreamingBuffer ( qint32 tileDataSize )

private

TODO: delete this buffer! It is better to use one of other two buffers to store streams

Definition at line 83 of file kis_tile_compressor_2.cpp.

{
    m_streamingBuffer.resize(tileDataSize + 1);
}

References m_streamingBuffer.

prepareWorkBuffers()

void KisTileCompressor2::prepareWorkBuffers ( qint32 tileDataSize )

private

Definition at line 92 of file kis_tile_compressor_2.cpp.

{
    const qint32 bufferSize = m_compression->outputBufferSize(tileDataSize);
 
    if (m_linearizationBuffer.size() < tileDataSize) {
        m_linearizationBuffer.resize(tileDataSize);
    }
 
    if (m_compressionBuffer.size() < bufferSize) {
        m_compressionBuffer.resize(bufferSize);
    }
}

References m_compression, m_compressionBuffer, m_linearizationBuffer, and KisAbstractCompression::outputBufferSize().

readTile()

bool KisTileCompressor2::readTile ( QIODevice * stream, KisTiledDataManager * dm )

overridevirtual

Decompresses the tile from the stream. Used by datamanager in load/save routines

See also

decompressTile()

Implements KisAbstractTileCompressor.

Definition at line 51 of file kis_tile_compressor_2.cpp.

{
    const qint32 tileDataSize = TILE_DATA_SIZE(pixelSize(dm));
    prepareStreamingBuffer(tileDataSize);
 
    QByteArray header = stream->readLine(maxHeaderLength());
 
    QList<QByteArray> headerItems = header.trimmed().split(',');
    if (headerItems.size() == 4) {
        qint32 x = headerItems.takeFirst().toInt();
        qint32 y = headerItems.takeFirst().toInt();
        QString compressionName = headerItems.takeFirst();
        qint32 dataSize = headerItems.takeFirst().toInt();
 
        Q_ASSERT(headerItems.isEmpty());
        Q_ASSERT(compressionName == m_compressionName);
 
        qint32 row = yToRow(dm, y);
        qint32 col = xToCol(dm, x);
 
        KisTileSP tile = dm->getTile(col, row, true);
 
        stream->read(m_streamingBuffer.data(), dataSize);
 
        tile->lockForWrite();
        bool res = decompressTileData((quint8*)m_streamingBuffer.data(), dataSize, tile->tileData());
        tile->unlockForWrite();
        return res;
    }
    return false;
}

References decompressTileData(), KisTiledDataManager::getTile(), KisTile::lockForWrite(), m_compressionName, m_streamingBuffer, maxHeaderLength(), KisAbstractTileCompressor::pixelSize(), prepareStreamingBuffer(), TILE_DATA_SIZE, KisTile::tileData(), KisTile::unlockForWrite(), KisAbstractTileCompressor::xToCol(), and KisAbstractTileCompressor::yToRow().

tileDataBufferSize()

qint32 KisTileCompressor2::tileDataBufferSize ( KisTileData * tileData )

overridevirtual

Return the number of bytes needed for compressing one tile

Implements KisAbstractTileCompressor.

Definition at line 166 of file kis_tile_compressor_2.cpp.

{
    return TILE_DATA_SIZE(tileData->pixelSize()) + 1;
}

References KisTileData::pixelSize(), and TILE_DATA_SIZE.

writeTile()

bool KisTileCompressor2::writeTile ( KisTileSP tile, KisPaintDeviceWriter & store )

overridevirtual

Compresses the tile and writes it into the stream. Used by datamanager in load/save routines

See also

compressTile()

Implements KisAbstractTileCompressor.

Definition at line 26 of file kis_tile_compressor_2.cpp.

{
    const qint32 tileDataSize = TILE_DATA_SIZE(tile->pixelSize());
    prepareStreamingBuffer(tileDataSize);
 
    qint32 bytesWritten;
 
    tile->lockForRead();
    compressTileData(tile->tileData(), (quint8*)m_streamingBuffer.data(),
                     m_streamingBuffer.size(), bytesWritten);
    tile->unlockForRead();
 
    QString header = getHeader(tile, bytesWritten);
    bool retval = true;
    retval = store.write(header.toLatin1());
    if (!retval) {
        warnFile << "Failed to write the tile header";
    }
    retval = store.write(m_streamingBuffer.data(), bytesWritten);
    if (!retval) {
        warnFile << "Failed to write the tile data";
    }
    return retval;
}

References compressTileData(), getHeader(), KisTile::lockForRead(), m_streamingBuffer, KisTile::pixelSize(), prepareStreamingBuffer(), TILE_DATA_SIZE, KisTile::tileData(), KisTile::unlockForRead(), warnFile, and KisPaintDeviceWriter::write().

Member Data Documentation

COMPRESSED_DATA_FLAG

const qint8 KisTileCompressor2::COMPRESSED_DATA_FLAG = 1

staticprivate

Definition at line 42 of file kis_tile_compressor_2.h.

m_compression

KisAbstractCompression* KisTileCompressor2::m_compression

private

Definition at line 48 of file kis_tile_compressor_2.h.

m_compressionBuffer

QByteArray KisTileCompressor2::m_compressionBuffer

private

Definition at line 46 of file kis_tile_compressor_2.h.

m_compressionName

const QString KisTileCompressor2::m_compressionName = "LZF"

staticprivate

Definition at line 49 of file kis_tile_compressor_2.h.

m_linearizationBuffer

QByteArray KisTileCompressor2::m_linearizationBuffer

private

Definition at line 45 of file kis_tile_compressor_2.h.

m_streamingBuffer

QByteArray KisTileCompressor2::m_streamingBuffer

private

Definition at line 47 of file kis_tile_compressor_2.h.

RAW_DATA_FLAG

const qint8 KisTileCompressor2::RAW_DATA_FLAG = 0

staticprivate

Definition at line 41 of file kis_tile_compressor_2.h.

---

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

• libs/image/tiles3/swap/kis_tile_compressor_2.h
• libs/image/tiles3/swap/kis_tile_compressor_2.cpp