#include <kis_tiled_data_manager.h>

Inheritance diagram for KisTiledDataManager:

Public Member Functions
void	bitBlt (KisTiledDataManager *srcDM, const QRect &rect)

void	bitBltOldData (KisTiledDataManager *srcDM, const QRect &rect)

void	bitBltRough (KisTiledDataManager *srcDM, const QRect &rect)

void	bitBltRoughOldData (KisTiledDataManager *srcDM, const QRect &rect)

void	clear ()

void	clear (qint32 x, qint32 y, qint32 w, qint32 h, const quint8 *clearPixel)

void	clear (qint32 x, qint32 y, qint32 w, qint32 h, quint8 clearValue)

void	clear (QRect clearRect, const quint8 *clearPixel)

void	clear (QRect clearRect, quint8 clearValue)

void	commit ()

void	debugPrintInfo ()

const quint8 *	defaultPixel () const

QRect	extent () const

void	extent (qint32 &x, qint32 &y, qint32 &w, qint32 &h) const

KisMementoSP	getMemento ()

KisTileSP	getOldTile (qint32 col, qint32 row)

KisTileSP	getOldTile (qint32 col, qint32 row, bool &existingTile)

KisTileSP	getReadOnlyTileLazy (qint32 col, qint32 row, bool &existingTile)

KisTileSP	getTile (qint32 col, qint32 row, bool writable)

void	getTilesPair (qint32 col, qint32 row, bool writable, KisTileSP tile, KisTileSP oldTile)

bool	hasCurrentMemento () const

	KisTiledDataManager (const KisTiledDataManager &dm)

	KisTiledDataManager (quint32 pixelSize, const quint8 *defPixel)

qint32	numContiguousColumns (qint32 x, qint32 minY, qint32 maxY) const

qint32	numContiguousRows (qint32 y, qint32 minX, qint32 maxX) const

KisTiledDataManager &	operator= (const KisTiledDataManager &dm)

void	purgeHistory (KisMementoSP oldestMemento)

void	readBytes (quint8 *bytes, qint32 x, qint32 y, qint32 w, qint32 h, qint32 dataRowStride=-1) const

QVector< quint8 * >	readPlanarBytes (QVector< qint32 > channelsizes, qint32 x, qint32 y, qint32 w, qint32 h) const

KisRegion	region () const

void	rollback (KisMementoSP memento)

void	rollforward (KisMementoSP memento)

qint32	rowStride (qint32 x, qint32 y) const

void	setDefaultPixel (const quint8 *defPixel)

void	setExtent (qint32 x, qint32 y, qint32 w, qint32 h)

void	setExtent (QRect newRect)

void	setPixel (qint32 x, qint32 y, const quint8 *data)

void	writeBytes (const quint8 *bytes, qint32 x, qint32 y, qint32 w, qint32 h, qint32 dataRowStride=-1)

void	writePlanarBytes (QVector< quint8 * > planes, QVector< qint32 > channelsizes, qint32 x, qint32 y, qint32 w, qint32 h)

virtual	~KisTiledDataManager ()

Public Member Functions inherited from KisShared
bool	deref ()

bool	ref ()

int	refCount ()

QAtomicInt *	sharedWeakReference ()

Static Public Member Functions
static void	releaseInternalPools ()

Protected Member Functions
quint32	pixelSize () const

void	purge (const QRect &area)

bool	read (QIODevice *stream)

bool	write (KisPaintDeviceWriter &store)

Protected Member Functions inherited from KisShared
	KisShared ()

	~KisShared ()

Private Member Functions
template<bool useOldSrcData>
void	bitBltImpl (KisTiledDataManager *srcDM, const QRect &rect)

template<bool useOldSrcData>
void	bitBltRoughImpl (KisTiledDataManager *srcDM, const QRect &rect)

qint32	divideRoundDown (qint32 x, const qint32 y) const

quint8 *	duplicatePixel (qint32 num, const quint8 *pixel)

bool	processTilesHeader (QIODevice *stream, quint32 &numTiles)

void	readBytesBody (quint8 *data, qint32 x, qint32 y, qint32 width, qint32 height, qint32 dataRowStride=-1) const

QVector< quint8 * >	readPlanarBytesBody (QVector< qint32 > channelsizes, qint32 x, qint32 y, qint32 w, qint32 h) const

void	recalculateExtent ()

void	setDefaultPixelImpl (const quint8 *defPixel)

void	writeBytesBody (const quint8 *data, qint32 x, qint32 y, qint32 width, qint32 height, qint32 dataRowStride=-1)

template<bool allChannelsPresent>
void	writePlanarBytesBody (QVector< quint8 * > planes, QVector< qint32 > channelsizes, qint32 x, qint32 y, qint32 w, qint32 h)

bool	writeTilesHeader (KisPaintDeviceWriter &store, quint32 numTiles)

qint32	xToCol (qint32 x) const

qint32	yToRow (qint32 y) const

Private Attributes
quint8 *	m_defaultPixel

KisTiledExtentManager	m_extentManager

KisTileHashTable *	m_hashTable

QReadWriteLock	m_lock

KisMementoManager *	m_mementoManager

qint32	m_pixelSize

Static Private Attributes
static const qint32	CURRENT_VERSION = 2

static const qint32	LEGACY_VERSION = 1

Friends
class	KisAbstractTileCompressor

class	KisBaseIterator

class	KisRandomAccessor2

class	KisStressJob

class	KisTileDataWrapper

class	KisTiledIterator

class	KisTiledRandomAccessor

Detailed Description

KisTiledDataManager implements the interface that KisDataManager defines

The interface definition is enforced by KisDataManager calling all the methods which must also be defined in KisTiledDataManager. It is not allowed to change the interface as other datamanagers may also rely on the same interface.

Storing undo/redo data
Offering ordered and unordered iterators over rects of pixels
(eventually) efficiently loading and saving data in a format that may allow deferred loading.

A datamanager knows nothing about the type of pixel data except how many quint8's a single pixel takes.

Definition at line 55 of file kis_tiled_data_manager.h.

Constructor & Destructor Documentation

◆ KisTiledDataManager() [1/2]

KisTiledDataManager::KisTiledDataManager	(	quint32	pixelSize,
		const quint8 *	defPixel )

Definition at line 33 of file kis_tiled_data_manager.cc.

{
    /* See comment in destructor for details */
    m_mementoManager = new KisMementoManager();
    m_hashTable = new KisTileHashTable(m_mementoManager);
 
    m_pixelSize = pixelSize;
    m_defaultPixel = new quint8[m_pixelSize];
    setDefaultPixel(defaultPixel);
}

References defaultPixel(), m_defaultPixel, m_hashTable, m_mementoManager, m_pixelSize, pixelSize(), and setDefaultPixel().

◆ ~KisTiledDataManager()

KisTiledDataManager::~KisTiledDataManager ( )

virtual

Here is an explanation why we use hash table and The Memento Manager dynamically allocated We need to destroy them in that very order. The reason is that when hash table destroying all her child tiles they all cry about it to The Memento Manager using a pointer. So The Memento Manager should be alive during that destruction. We could use shared pointers instead, but they create too much overhead.

Definition at line 69 of file kis_tiled_data_manager.cc.

{
    delete m_hashTable;
    delete m_mementoManager;
 
    delete[] m_defaultPixel;
}

References m_defaultPixel, m_hashTable, and m_mementoManager.

◆ KisTiledDataManager() [2/2]

KisTiledDataManager::KisTiledDataManager ( const KisTiledDataManager & dm )

We won't call setDefaultTileData here, as defaultTileDatas has already been made shared in m_hashTable(dm->m_hashTable)

Definition at line 45 of file kis_tiled_data_manager.cc.

    : KisShared()
{
    /* See comment in destructor for details */
 
    /* We do not clone the history of the device, there is no usecase for it */
    m_mementoManager = new KisMementoManager();
 
    KisTileData *defaultTileData = dm.m_hashTable->refAndFetchDefaultTileData();
    m_mementoManager->setDefaultTileData(defaultTileData);
    defaultTileData->deref();
 
    m_hashTable = new KisTileHashTable(*dm.m_hashTable, m_mementoManager);
 
    m_pixelSize = dm.m_pixelSize;
    m_defaultPixel = new quint8[m_pixelSize];
    memcpy(m_defaultPixel, dm.m_defaultPixel, m_pixelSize);
    recalculateExtent();
}

References KisTileData::deref(), m_defaultPixel, m_hashTable, m_mementoManager, m_pixelSize, recalculateExtent(), KisTileHashTableTraits< T >::refAndFetchDefaultTileData(), and KisMementoManager::setDefaultTileData().

Member Function Documentation

◆ bitBlt()

void KisTiledDataManager::bitBlt	(	KisTiledDataManager *	srcDM,
		const QRect &	rect )

Clones rect from another datamanager. The cloned area will be shared between both datamanagers as much as possible using copy-on-write. Parts of the rect that cannot be shared (cross tiles) are deep-copied,

Definition at line 560 of file kis_tiled_data_manager.cc.

{
    bitBltImpl<false>(srcDM, rect);
}

◆ bitBltImpl()

template<bool useOldSrcData>

void KisTiledDataManager::bitBltImpl	(	KisTiledDataManager *	srcDM,
		const QRect &	rect )

private

Definition at line 433 of file kis_tiled_data_manager.cc.

{
    if (rect.isEmpty()) return;
 
    const qint32 pixelSize = this->pixelSize();
    const bool defaultPixelsCoincide =
        !memcmp(srcDM->defaultPixel(), m_defaultPixel, pixelSize);
 
    const quint32 rowStride = KisTileData::WIDTH * pixelSize;
 
    qint32 firstColumn = xToCol(rect.left());
    qint32 lastColumn = xToCol(rect.right());
 
    qint32 firstRow = yToRow(rect.top());
    qint32 lastRow = yToRow(rect.bottom());
 
    for (qint32 row = firstRow; row <= lastRow; ++row) {
        for (qint32 column = firstColumn; column <= lastColumn; ++column) {
 
            bool srcTileExists = false;
 
            // this is the only variation in the template
            KisTileSP srcTile = useOldSrcData ?
                srcDM->getOldTile(column, row, srcTileExists) :
                srcDM->getReadOnlyTileLazy(column, row, srcTileExists);
 
            QRect tileRect(column*KisTileData::WIDTH, row*KisTileData::HEIGHT,
                           KisTileData::WIDTH, KisTileData::HEIGHT);
            QRect cloneTileRect = rect & tileRect;
 
            if (cloneTileRect == tileRect) {
                 // Clone whole tile
                 const bool wasDeleted =
                     m_hashTable->deleteTile(column, row);
 
                 if (srcTileExists || !defaultPixelsCoincide) {
                     srcTile->lockForRead();
                     KisTileData *td = srcTile->tileData();
                     KisTileSP clonedTile = KisTileSP(new KisTile(column, row, td, m_mementoManager));
                     srcTile->unlockForRead();
 
                     m_hashTable->addTile(clonedTile);
 
                     if (!wasDeleted) {
                         m_extentManager.notifyTileAdded(column, row);
                     }
                 } else if (wasDeleted) {
                     m_extentManager.notifyTileRemoved(column, row);
                 }
 
            } else {
                const qint32 lineSize = cloneTileRect.width() * pixelSize;
                qint32 rowsRemaining = cloneTileRect.height();
 
                KisTileDataWrapper tw(this,
                                      cloneTileRect.left(),
                                      cloneTileRect.top(),
                                      KisTileDataWrapper::WRITE);
                srcTile->lockForRead();
                // We suppose that the shift in both tiles is the same
                const quint8* srcTileIt = srcTile->data() + tw.offset();
                quint8* dstTileIt = tw.data();
 
                while (rowsRemaining > 0) {
                    memcpy(dstTileIt, srcTileIt, lineSize);
                    srcTileIt += rowStride;
                    dstTileIt += rowStride;
                    rowsRemaining--;
                }
 
                srcTile->unlockForRead();
            }
        }
    }
}

References KisTileHashTableTraits< T >::addTile(), KisTile::data(), KisTileDataWrapper::data(), defaultPixel(), KisTileHashTableTraits< T >::deleteTile(), getOldTile(), getReadOnlyTileLazy(), KisTileData::HEIGHT, KisTile::lockForRead(), m_defaultPixel, m_extentManager, m_hashTable, m_mementoManager, KisTiledExtentManager::notifyTileAdded(), KisTiledExtentManager::notifyTileRemoved(), KisTileDataWrapper::offset(), pixelSize(), rowStride(), KisTile::tileData(), KisTile::unlockForRead(), KisTileData::WIDTH, KisTileDataWrapper::WRITE, xToCol(), and yToRow().

◆ bitBltOldData()

void KisTiledDataManager::bitBltOldData	(	KisTiledDataManager *	srcDM,
		const QRect &	rect )

The same as bitBlt(), but reads old data

Definition at line 565 of file kis_tiled_data_manager.cc.

{
    bitBltImpl<true>(srcDM, rect);
}

◆ bitBltRough()

void KisTiledDataManager::bitBltRough	(	KisTiledDataManager *	srcDM,
		const QRect &	rect )

Clones rect from another datamanager in a rough and fast way. All the tiles touched by rect will be shared, between both managers, that means it will copy a bigger area than was requested. This method is supposed to be used for bitBlt'ing into temporary paint devices.

Definition at line 570 of file kis_tiled_data_manager.cc.

{
    bitBltRoughImpl<false>(srcDM, rect);
}

◆ bitBltRoughImpl()

template<bool useOldSrcData>

void KisTiledDataManager::bitBltRoughImpl	(	KisTiledDataManager *	srcDM,
		const QRect &	rect )

private

We are cloning whole tiles here so let's not be so boring to check any borders :)

Definition at line 510 of file kis_tiled_data_manager.cc.

{
    if (rect.isEmpty()) return;
 
    const qint32 pixelSize = this->pixelSize();
    const bool defaultPixelsCoincide =
        !memcmp(srcDM->defaultPixel(), m_defaultPixel, pixelSize);
 
    qint32 firstColumn = xToCol(rect.left());
    qint32 lastColumn = xToCol(rect.right());
 
    qint32 firstRow = yToRow(rect.top());
    qint32 lastRow = yToRow(rect.bottom());
 
    for (qint32 row = firstRow; row <= lastRow; ++row) {
        for (qint32 column = firstColumn; column <= lastColumn; ++column) {
 
            bool srcTileExists = false;
 
            // this is the only variation in the template
            KisTileSP srcTile = useOldSrcData ?
                srcDM->getOldTile(column, row, srcTileExists) :
                srcDM->getReadOnlyTileLazy(column, row, srcTileExists);
 
            const bool wasDeleted =
                m_hashTable->deleteTile(column, row);
 
            if (srcTileExists || !defaultPixelsCoincide) {
                srcTile->lockForRead();
                KisTileData *td = srcTile->tileData();
                KisTileSP clonedTile = KisTileSP(new KisTile(column, row, td, m_mementoManager));
                srcTile->unlockForRead();
 
                m_hashTable->addTile(clonedTile);
 
                if (!wasDeleted) {
                    m_extentManager.notifyTileAdded(column, row);
                }
            } else if (wasDeleted) {
                m_extentManager.notifyTileRemoved(column, row);
            }
        }
    }
}

References KisTileHashTableTraits< T >::addTile(), defaultPixel(), KisTileHashTableTraits< T >::deleteTile(), getOldTile(), getReadOnlyTileLazy(), KisTile::lockForRead(), m_defaultPixel, m_extentManager, m_hashTable, m_mementoManager, KisTiledExtentManager::notifyTileAdded(), KisTiledExtentManager::notifyTileRemoved(), pixelSize(), KisTile::tileData(), KisTile::unlockForRead(), xToCol(), and yToRow().

◆ bitBltRoughOldData()

void KisTiledDataManager::bitBltRoughOldData	(	KisTiledDataManager *	srcDM,
		const QRect &	rect )

The same as bitBltRough(), but reads old data

Definition at line 575 of file kis_tiled_data_manager.cc.

{
    bitBltRoughImpl<true>(srcDM, rect);
}

◆ clear() [1/5]

void KisTiledDataManager::clear ( )

Definition at line 425 of file kis_tiled_data_manager.cc.

{
    m_hashTable->clear();
    m_extentManager.clear();
}

References KisTileHashTableTraits< T >::clear(), KisTiledExtentManager::clear(), m_extentManager, and m_hashTable.

◆ clear() [2/5]

void KisTiledDataManager::clear	(	qint32	x,
		qint32	y,
		qint32	w,
		qint32	h,
		const quint8 *	clearPixel )

Definition at line 416 of file kis_tiled_data_manager.cc.

{
    clear(QRect(x, y, w, h), clearPixel);
}

References clear().

◆ clear() [3/5]

void KisTiledDataManager::clear	(	qint32	x,
		qint32	y,
		qint32	w,
		qint32	h,
		quint8	clearValue )

Definition at line 420 of file kis_tiled_data_manager.cc.

{
    clear(QRect(x, y, w, h), clearValue);
}

References clear().

◆ clear() [4/5]

void KisTiledDataManager::clear	(	QRect	clearRect,
		const quint8 *	clearPixel )

Definition at line 309 of file kis_tiled_data_manager.cc.

{
    if (clearPixel == 0)
        clearPixel = m_defaultPixel;
 
    if (clearRect.isEmpty())
        return;
 
    const qint32 pixelSize = this->pixelSize();
 
    bool pixelBytesAreDefault = !memcmp(clearPixel, m_defaultPixel, pixelSize);
 
    bool pixelBytesAreTheSame = true;
    for (qint32 i = 0; i < pixelSize; ++i) {
        if (clearPixel[i] != clearPixel[0]) {
            pixelBytesAreTheSame = false;
            break;
        }
    }
 
    if (pixelBytesAreDefault) {
        clearRect &= m_extentManager.extent();
    }
 
    qint32 firstColumn = xToCol(clearRect.left());
    qint32 lastColumn = xToCol(clearRect.right());
 
    qint32 firstRow = yToRow(clearRect.top());
    qint32 lastRow = yToRow(clearRect.bottom());
 
    const quint32 rowStride = KisTileData::WIDTH * pixelSize;
 
    // Generate one row
    quint8 *clearPixelData = 0;
    quint32 maxRunLength = qMin(clearRect.width(), KisTileData::WIDTH);
    clearPixelData = duplicatePixel(maxRunLength, clearPixel);
 
    KisTileData *td = 0;
    if (!pixelBytesAreDefault &&
        clearRect.width() >= KisTileData::WIDTH &&
        clearRect.height() >= KisTileData::HEIGHT) {
 
        td = KisTileDataStore::instance()->createDefaultTileData(pixelSize, clearPixel);
        td->acquire();
    }
 
    for (qint32 row = firstRow; row <= lastRow; ++row) {
        for (qint32 column = firstColumn; column <= lastColumn; ++column) {
 
            QRect tileRect(column*KisTileData::WIDTH, row*KisTileData::HEIGHT,
                           KisTileData::WIDTH, KisTileData::HEIGHT);
            QRect clearTileRect = clearRect & tileRect;
 
            if (clearTileRect == tileRect) {
                 // Clear whole tile
                 const bool wasDeleted =
                     m_hashTable->deleteTile(column, row);
 
                 if (wasDeleted) {
                     m_extentManager.notifyTileRemoved(column, row);
                 }
 
 
                 if (!pixelBytesAreDefault) {
                     KisTileSP clearedTile = KisTileSP(new KisTile(column, row, td, m_mementoManager));
                     m_hashTable->addTile(clearedTile);
                     m_extentManager.notifyTileAdded(column, row);
                 }
            } else {
                const qint32 lineSize = clearTileRect.width() * pixelSize;
                qint32 rowsRemaining = clearTileRect.height();
 
                KisTileDataWrapper tw(this,
                                      clearTileRect.left(),
                                      clearTileRect.top(),
                                      KisTileDataWrapper::WRITE);
                quint8* tileIt = tw.data();
 
                if (pixelBytesAreTheSame) {
                    while (rowsRemaining > 0) {
                        memset(tileIt, *clearPixelData, lineSize);
                        tileIt += rowStride;
                        rowsRemaining--;
                    }
                } else {
                    while (rowsRemaining > 0) {
                        memcpy(tileIt, clearPixelData, lineSize);
                        tileIt += rowStride;
                        rowsRemaining--;
                    }
                }
            }
        }
    }
 
    if (td) td->release();
    delete[] clearPixelData;
}

References KisTileData::acquire(), KisTileHashTableTraits< T >::addTile(), KisTileDataStore::createDefaultTileData(), KisTileDataWrapper::data(), KisTileHashTableTraits< T >::deleteTile(), duplicatePixel(), KisTiledExtentManager::extent(), KisTileData::HEIGHT, KisTileDataStore::instance(), m_defaultPixel, m_extentManager, m_hashTable, m_mementoManager, KisTiledExtentManager::notifyTileAdded(), KisTiledExtentManager::notifyTileRemoved(), pixelSize(), KisTileData::release(), rowStride(), KisTileData::WIDTH, KisTileDataWrapper::WRITE, xToCol(), and yToRow().

◆ clear() [5/5]

void KisTiledDataManager::clear	(	QRect	clearRect,
		quint8	clearValue )

Definition at line 408 of file kis_tiled_data_manager.cc.

{
    quint8 *buf = new quint8[pixelSize()];
    memset(buf, clearValue, pixelSize());
    clear(clearRect, buf);
    delete[] buf;
}

References clear(), and pixelSize().

◆ commit()

void KisTiledDataManager::commit ( )

inline

Finishes having already started transaction

Definition at line 144 of file kis_tiled_data_manager.h.

                  {
        QWriteLocker locker(&m_lock);
 
        KisMementoSP memento = m_mementoManager->currentMemento();
        if(memento) {
            memento->saveNewDefaultPixel(m_defaultPixel, m_pixelSize);
        }
 
        m_mementoManager->commit();
    }

References KisMemento::saveNewDefaultPixel().

◆ debugPrintInfo()

void KisTiledDataManager::debugPrintInfo ( )

inline

Definition at line 399 of file kis_tiled_data_manager.h.

                          {
        m_mementoManager->debugPrintInfo();
    }

References KisMementoManager::debugPrintInfo().

◆ defaultPixel()

const quint8 * KisTiledDataManager::defaultPixel ( ) const

inline

Definition at line 81 of file kis_tiled_data_manager.h.

                                       {
        return m_defaultPixel;
    }

◆ divideRoundDown()

qint32 KisTiledDataManager::divideRoundDown	(	qint32	x,
		const qint32	y ) const

inlineprivate

Equivalent to the following: -(( -x + (y-1) ) / y)

Definition at line 363 of file kis_tiled_data_manager.h.

    {
        return x >= 0 ? x / y : -(((-x - 1) / y) + 1);
    }

◆ duplicatePixel()

quint8 * KisTiledDataManager::duplicatePixel	(	qint32	num,
		const quint8 *	pixel )

private

Definition at line 296 of file kis_tiled_data_manager.cc.

{
    const qint32 pixelSize = this->pixelSize();
    /* FIXME:  Make a fun filling here */
    quint8 *dstBuf = new quint8[num * pixelSize];
    quint8 *dstIt = dstBuf;
    for (qint32 i = 0; i < num; i++) {
        memcpy(dstIt, pixel, pixelSize);
        dstIt += pixelSize;
    }
    return dstBuf;
}

References pixelSize().

◆ extent() [1/2]

QRect KisTiledDataManager::extent ( ) const

Definition at line 658 of file kis_tiled_data_manager.cc.

{
    return m_extentManager.extent();
}

References KisTiledExtentManager::extent(), and m_extentManager.

◆ extent() [2/2]

void KisTiledDataManager::extent	(	qint32 &	x,
		qint32 &	y,
		qint32 &	w,
		qint32 &	h ) const

Definition at line 652 of file kis_tiled_data_manager.cc.

{
    QRect rect = extent();
    rect.getRect(&x, &y, &w, &h);
}

References extent().

◆ getMemento()

KisMementoSP KisTiledDataManager::getMemento ( )

inline

Definition at line 134 of file kis_tiled_data_manager.h.

                              {
        QWriteLocker locker(&m_lock);
        KisMementoSP memento = m_mementoManager->getMemento();
        memento->saveOldDefaultPixel(m_defaultPixel, m_pixelSize);
        return memento;
    }

References KisMemento::saveOldDefaultPixel().

◆ getOldTile() [1/2]

KisTileSP KisTiledDataManager::getOldTile	(	qint32	col,
		qint32	row )

inline

Definition at line 129 of file kis_tiled_data_manager.h.

                                                        {
        bool unused;
        return getOldTile(col, row, unused);
    }

◆ getOldTile() [2/2]

KisTileSP KisTiledDataManager::getOldTile	(	qint32	col,
		qint32	row,
		bool &	existingTile )

inline

Definition at line 124 of file kis_tiled_data_manager.h.

                                                                            {
        KisTileSP tile = m_mementoManager->getCommittedTile(col, row, existingTile);
        return tile ? tile : getReadOnlyTileLazy(col, row, existingTile);
    }

◆ getReadOnlyTileLazy()

KisTileSP KisTiledDataManager::getReadOnlyTileLazy	(	qint32	col,
		qint32	row,
		bool &	existingTile )

inline

Definition at line 120 of file kis_tiled_data_manager.h.

                                                                                     {
        return m_hashTable->getReadOnlyTileLazy(col, row, existingTile);
    }

◆ getTile()

KisTileSP KisTiledDataManager::getTile	(	qint32	col,
		qint32	row,
		bool	writable )

inline

Definition at line 105 of file kis_tiled_data_manager.h.

                                                                    {
        if (writable) {
            bool newTile;
            KisTileSP tile = m_hashTable->getTileLazy(col, row, newTile);
            if (newTile) {
                m_extentManager.notifyTileAdded(col, row);
            }
            return tile;
 
        } else {
            bool unused;
            return m_hashTable->getReadOnlyTileLazy(col, row, unused);
        }
    }

References newTile().

◆ getTilesPair()

void KisTiledDataManager::getTilesPair	(	qint32	col,
		qint32	row,
		bool	writable,
		KisTileSP *	tile,
		KisTileSP *	oldTile )

inline

Every iterator fetches both types of tiles all the time: old and new. For projection devices these tiles are always the same, but doing two distinct calls makes double pressure on the read-write lock in the hash table.

Merging two calls into one allows us to avoid additional tile fetch from the hash table and therefore reduce waiting time.

Definition at line 94 of file kis_tiled_data_manager.h.

                                                                                                         {
        *tile = getTile(col, row, writable);
 
        bool unused;
        *oldTile = m_mementoManager->getCommittedTile(col, row, unused);
 
        if (!*oldTile) {
            *oldTile = *tile;
        }
    }

◆ hasCurrentMemento()

bool KisTiledDataManager::hasCurrentMemento ( ) const

inline

Definition at line 177 of file kis_tiled_data_manager.h.

                                   {
        return m_mementoManager->hasCurrentMemento();
        //return true;
    }

◆ numContiguousColumns()

qint32 KisTiledDataManager::numContiguousColumns	(	qint32	x,
		qint32	minY,
		qint32	maxY ) const

Get the number of contiguous columns starting at x, valid for all values of y between minY and maxY.

Definition at line 739 of file kis_tiled_data_manager.cc.

{
    qint32 numColumns;
 
    Q_UNUSED(minY);
    Q_UNUSED(maxY);
 
    if (x >= 0) {
        numColumns = KisTileData::WIDTH - (x % KisTileData::WIDTH);
    } else {
        numColumns = ((-x - 1) % KisTileData::WIDTH) + 1;
    }
 
    return numColumns;
}

References KisTileData::WIDTH.

◆ numContiguousRows()

qint32 KisTiledDataManager::numContiguousRows	(	qint32	y,
		qint32	minX,
		qint32	maxX ) const

Get the number of contiguous rows starting at y, valid for all values of x between minX and maxX.

Definition at line 755 of file kis_tiled_data_manager.cc.

{
    qint32 numRows;
 
    Q_UNUSED(minX);
    Q_UNUSED(maxX);
 
    if (y >= 0) {
        numRows = KisTileData::HEIGHT - (y % KisTileData::HEIGHT);
    } else {
        numRows = ((-y - 1) % KisTileData::HEIGHT) + 1;
    }
 
    return numRows;
}

References KisTileData::HEIGHT.

◆ operator=()

KisTiledDataManager & KisTiledDataManager::operator= ( const KisTiledDataManager & dm )

◆ pixelSize()

quint32 KisTiledDataManager::pixelSize ( ) const

inlineprotected

Definition at line 204 of file kis_tiled_data_manager.h.

                                     {
        return m_pixelSize;
    }

◆ processTilesHeader()

bool KisTiledDataManager::processTilesHeader	(	QIODevice *	stream,
		quint32 &	numTiles )

private

We assume that there is only one version of this header possible. In case we invent something new, it'll be quite easy to modify the behavior

Definition at line 209 of file kis_tiled_data_manager.cc.

{
    const qint32 maxLineLength = 25;
    const qint32 totalNumTests = 4;
    bool foundDataMark = false;
    qint32 testsPassed = 0;
 
    QString keyword;
    qint32 value;
 
    while(!foundDataMark && stream->canReadLine()) {
        takeOneLine(stream, maxLineLength, keyword, value);
 
        if (keyword == "TILEWIDTH") {
            if(value != KisTileData::WIDTH)
                goto wrongString;
        }
        else if (keyword == "TILEHEIGHT") {
            if(value != KisTileData::HEIGHT)
                goto wrongString;
        }
        else if (keyword == "PIXELSIZE") {
            if((quint32)value != pixelSize())
                goto wrongString;
        }
        else if (keyword == "DATA") {
            numTiles = value;
            foundDataMark = true;
        }
        else {
            goto wrongString;
        }
 
        testsPassed++;
    }
 
    if(testsPassed != totalNumTests) {
        warnTiles << "Not enough fields of tiles header present"
                  << testsPassed << "of" << totalNumTests;
    }
 
    return testsPassed == totalNumTests;
 
wrongString:
    warnTiles << "Wrong string in tiles header:" << keyword << value;
    return false;
}

References KisTileData::HEIGHT, pixelSize(), takeOneLine, value(), warnTiles, and KisTileData::WIDTH.

◆ purge()

void KisTiledDataManager::purge ( const QRect & area )

protected

Definition at line 263 of file kis_tiled_data_manager.cc.

{
    QList<KisTileSP> tilesToDelete;
    {
        const qint32 tileDataSize = KisTileData::HEIGHT * KisTileData::WIDTH * pixelSize();
        KisTileData *tileData = m_hashTable->refAndFetchDefaultTileData();
        tileData->blockSwapping();
        const quint8 *defaultData = tileData->data();
 
        KisTileHashTableConstIterator iter(m_hashTable);
        KisTileSP tile;
 
        while ((tile = iter.tile())) {
            if (tile->extent().intersects(area)) {
                tile->lockForRead();
                if(memcmp(defaultData, tile->data(), tileDataSize) == 0) {
                    tilesToDelete.push_back(tile);
                }
                tile->unlockForRead();
            }
            iter.next();
        }
 
        tileData->unblockSwapping();
        tileData->deref();
    }
    Q_FOREACH (KisTileSP tile, tilesToDelete) {
        if (m_hashTable->deleteTile(tile)) {
            m_extentManager.notifyTileRemoved(tile->col(), tile->row());
        }
    }
}

References KisTileData::blockSwapping(), KisTile::col(), KisTile::data(), KisTileData::data(), KisTileHashTableTraits< T >::deleteTile(), KisTileData::deref(), KisTile::extent(), KisTileData::HEIGHT, KisTile::lockForRead(), m_extentManager, m_hashTable, KisTileHashTableIteratorTraits< T, LockerType >::next(), KisTiledExtentManager::notifyTileRemoved(), pixelSize(), KisTileHashTableTraits< T >::refAndFetchDefaultTileData(), KisTile::row(), KisTileHashTableIteratorTraits< T, LockerType >::tile(), KisTileData::unblockSwapping(), KisTile::unlockForRead(), and KisTileData::WIDTH.

◆ purgeHistory()

void KisTiledDataManager::purgeHistory ( KisMementoSP oldestMemento )

inline

Removes all the history that precedes the revision pointed by oldestMemento. That is after calling to purgeHistory(someMemento) you won't be able to do rollback(someMemento) anymore.

Definition at line 188 of file kis_tiled_data_manager.h.

                                                  {
        QWriteLocker locker(&m_lock);
        m_mementoManager->purgeHistory(oldestMemento);
    }

◆ read()

bool KisTiledDataManager::read ( QIODevice * stream )

protected

Definition at line 133 of file kis_tiled_data_manager.cc.

{
    clear();
 
    QWriteLocker locker(&m_lock);
    KisMementoSP nothing = m_mementoManager->getMemento();
 
    if (!stream) {
        m_mementoManager->commit();
        return false;
    }
 
    const qint32 maxLineLength = 79; // Legacy magic
    QByteArray line = stream->readLine(maxLineLength);
    line = line.trimmed();
 
    quint32 numTiles;
    qint32 tilesVersion = LEGACY_VERSION;
 
    if (line[0] == 'V') {
        QList<QByteArray> lineItems = line.split(' ');
 
        QString keyword = lineItems.takeFirst();
        Q_ASSERT(keyword == "VERSION");
 
        tilesVersion = lineItems.takeFirst().toInt();
 
        if(!processTilesHeader(stream, numTiles))
            return false;
    }
    else {
        numTiles = line.toUInt();
    }
 
    KisAbstractTileCompressorSP compressor =
        KisTileCompressorFactory::create(tilesVersion);
 
    bool readSuccess = true;
    for (quint32 i = 0; i < numTiles; i++) {
        if (!compressor->readTile(stream, this)) {
            readSuccess = false;
        }
    }
 
    m_mementoManager->commit();
    return readSuccess;
}

References clear(), KisMementoManager::commit(), KisTileCompressorFactory::create(), KisMementoManager::getMemento(), LEGACY_VERSION, m_lock, m_mementoManager, and processTilesHeader().

◆ readBytes()

void KisTiledDataManager::readBytes	(	quint8 *	bytes,
		qint32	x,
		qint32	y,
		qint32	w,
		qint32	h,
		qint32	dataRowStride = -1 ) const

Copy the bytes in the specified rect to a vector. The caller is responsible for managing the vector.

Parameters

bytes	the bytes
x	x of top left corner
y	y of top left corner
w	width
h	height
dataRowStride	is the step (in bytes) which should be added to `bytes` pointer to get to the next row

Definition at line 694 of file kis_tiled_data_manager.cc.

{
    QReadLocker locker(&m_lock);
    // Actual bytes reading/writing is done in private header
    readBytesBody(data, x, y, width, height, dataRowStride);
}

References m_lock, and readBytesBody().

◆ readBytesBody()

void KisTiledDataManager::readBytesBody	(	quint8 *	data,
		qint32	x,
		qint32	y,
		qint32	width,
		qint32	height,
		qint32	dataRowStride = -1 ) const

private

Definition at line 78 of file kis_tiled_data_manager_p.h.

{
    if (!data) return;
 
    width  = width < 0  ? 0 : width;
    height = height < 0 ? 0 : height;
 
    qint32 dataY = 0;
    qint32 imageY = y;
    qint32 rowsRemaining = height;
    const qint32 pixelSize = this->pixelSize();
 
    if (dataRowStride <= 0) {
        dataRowStride = pixelSize * width;
    }
 
    while (rowsRemaining > 0) {
 
        qint32 dataX = 0;
        qint32 imageX = x;
        qint32 columnsRemaining = width;
        qint32 numContiguousImageRows = numContiguousRows(imageY, imageX,
                                                          imageX + width - 1);
 
        qint32 rowsToWork = qMin(numContiguousImageRows, rowsRemaining);
 
        while (columnsRemaining > 0) {
 
            qint32 numContiguousImageColumns = numContiguousColumns(imageX, imageY,
                                                                    imageY + rowsToWork - 1);
 
            qint32 columnsToWork = qMin(numContiguousImageColumns,
                                        columnsRemaining);
 
            // XXX: Ugly const cast because of the old pixelPtr design copied from tiles1.
            KisTileDataWrapper tw(const_cast<KisTiledDataManager*>(this), imageX, imageY, KisTileDataWrapper::READ);
            quint8 *tileIt = tw.data();
 
 
            const qint32 tileRowStride = rowStride(imageX, imageY);
 
            quint8 *dataIt = data +
                    dataX * pixelSize + dataY * dataRowStride;
 
            const qint32 lineSize = columnsToWork * pixelSize;
 
            for (qint32 row = 0; row < rowsToWork; row++) {
                memcpy(dataIt, tileIt, lineSize);
                tileIt += tileRowStride;
                dataIt += dataRowStride;
            }
 
            imageX += columnsToWork;
            dataX += columnsToWork;
            columnsRemaining -= columnsToWork;
        }
 
        imageY += rowsToWork;
        dataY += rowsToWork;
        rowsRemaining -= rowsToWork;
    }
}

References KisTileDataWrapper::data(), numContiguousColumns(), numContiguousRows(), pixelSize(), KisTileDataWrapper::READ, and rowStride().

◆ readPlanarBytes()

QVector< quint8 * > KisTiledDataManager::readPlanarBytes	(	QVector< qint32 >	channelsizes,
		qint32	x,
		qint32	y,
		qint32	w,
		qint32	h ) const

Copy the bytes in the paint device into a vector of arrays of bytes, where the number of arrays is the number of channels in the paint device. If the specified area is larger than the paint device's extent, the default pixel will be read.

Definition at line 705 of file kis_tiled_data_manager.cc.

{
    QReadLocker locker(&m_lock);
    // Actual bytes reading/writing is done in private header
    return readPlanarBytesBody(channelSizes, x, y, width, height);
}

References m_lock, and readPlanarBytesBody().

◆ readPlanarBytesBody()

QVector< quint8 * > KisTiledDataManager::readPlanarBytesBody	(	QVector< qint32 >	channelsizes,
		qint32	x,
		qint32	y,
		qint32	w,
		qint32	h ) const

private

Definition at line 229 of file kis_tiled_data_manager_p.h.

{
    Q_ASSERT(channelSizes.size() > 0);
 
    width  = width < 0  ? 0 : width;
    height = height < 0 ? 0 : height;
 
    const qint32 numChannels = channelSizes.size();
    const qint32 pixelSize = this->pixelSize();
 
    QVector<quint8*> planes;
    forEachChannel(i, channelSize) {
        planes.append(new quint8[width * height * channelSize]);
    }
 
    qint32 dataY = 0;
    qint32 imageY = y;
    qint32 rowsRemaining = height;
 
    while (rowsRemaining > 0) {
 
        qint32 dataX = 0;
        qint32 imageX = x;
        qint32 columnsRemaining = width;
        qint32 numContiguousImageRows = numContiguousRows(imageY, imageX,
                                                          imageX + width - 1);
 
        qint32 rowsToWork = qMin(numContiguousImageRows, rowsRemaining);
 
        while (columnsRemaining > 0) {
 
            qint32 numContiguousImageColumns =
                    numContiguousColumns(imageX, imageY,
                                         imageY + rowsToWork - 1);
            qint32 columnsToWork = qMin(numContiguousImageColumns,
                                        columnsRemaining);
 
            const qint32 dataIdx = dataX + dataY * width;
            const qint32 tileRowStride = rowStride(imageX, imageY) -
                    columnsToWork * pixelSize;
 
            // XXX: Ugly const cast because of the old pixelPtr design copied from tiles1.
            KisTileDataWrapper tw(const_cast<KisTiledDataManager*>(this), imageX, imageY,
                                  KisTileDataWrapper::READ);
            quint8 *tileItStart = tw.data();
 
 
            forEachChannel(i, channelSize) {
                quint8* planeIt = planes[i] + dataIdx * channelSize;
                qint32 dataStride = (width - columnsToWork) * channelSize;
                quint8* tileIt = tileItStart;
 
                for (qint32 row = 0; row < rowsToWork; row++) {
                    for (int col = 0; col < columnsToWork; col++) {
                        memcpy(planeIt, tileIt, channelSize);
                        tileIt += pixelSize;
                        planeIt += channelSize;
                    }
 
                    tileIt += tileRowStride;
                    planeIt += dataStride;
                }
                tileItStart += channelSize;
            }
 
            imageX += columnsToWork;
            dataX += columnsToWork;
            columnsRemaining -= columnsToWork;
        }
 
 
        imageY += rowsToWork;
        dataY += rowsToWork;
        rowsRemaining -= rowsToWork;
    }
    return planes;
}

References KisTileDataWrapper::data(), forEachChannel, numContiguousColumns(), numContiguousRows(), pixelSize(), KisTileDataWrapper::READ, and rowStride().

◆ recalculateExtent()

void KisTiledDataManager::recalculateExtent ( )

private

Definition at line 635 of file kis_tiled_data_manager.cc.

{
    QVector<QPoint> indexes;
 
    {
        KisTileHashTableConstIterator iter(m_hashTable);
        KisTileSP tile;
 
        while ((tile = iter.tile())) {
            indexes << QPoint(tile->col(), tile->row());
            iter.next();
        }
    }
 
    m_extentManager.replaceTileStats(indexes);
}

References KisTile::col(), m_extentManager, m_hashTable, KisTileHashTableIteratorTraits< T, LockerType >::next(), KisTiledExtentManager::replaceTileStats(), KisTile::row(), and KisTileHashTableIteratorTraits< T, LockerType >::tile().

◆ region()

KisRegion KisTiledDataManager::region ( ) const

Definition at line 663 of file kis_tiled_data_manager.cc.

{
    QVector<QRect> rects;
 
    KisTileHashTableConstIterator iter(m_hashTable);
    KisTileSP tile;
 
    while ((tile = iter.tile())) {
        rects << tile->extent();
        iter.next();
    }
 
    return KisRegion(std::move(rects));
}

References KisTile::extent(), m_hashTable, KisTileHashTableIteratorTraits< T, LockerType >::next(), and KisTileHashTableIteratorTraits< T, LockerType >::tile().

◆ releaseInternalPools()

void KisTiledDataManager::releaseInternalPools ( )

static

Definition at line 779 of file kis_tiled_data_manager.cc.

{
    KisTileData::releaseInternalPools();
}

References KisTileData::releaseInternalPools().

◆ rollback()

void KisTiledDataManager::rollback ( KisMementoSP memento )

inline

Definition at line 155 of file kis_tiled_data_manager.h.

                                        {
        commit();
 
        QWriteLocker locker(&m_lock);
        m_mementoManager->rollback(m_hashTable, memento);
        const quint8 *defaultPixel = memento->oldDefaultPixel();
        if(memcmp(m_defaultPixel, defaultPixel, m_pixelSize)) {
            setDefaultPixelImpl(defaultPixel);
        }
        recalculateExtent();
    }

References KisMemento::oldDefaultPixel().

◆ rollforward()

void KisTiledDataManager::rollforward ( KisMementoSP memento )

inline

Definition at line 166 of file kis_tiled_data_manager.h.

                                           {
        commit();
 
        QWriteLocker locker(&m_lock);
        m_mementoManager->rollforward(m_hashTable, memento);
        const quint8 *defaultPixel = memento->newDefaultPixel();
        if(memcmp(m_defaultPixel, defaultPixel, m_pixelSize)) {
            setDefaultPixelImpl(defaultPixel);
        }
        recalculateExtent();
    }

References KisMemento::newDefaultPixel().

◆ rowStride()

qint32 KisTiledDataManager::rowStride	(	qint32	x,
		qint32	y ) const

Get the row stride at pixel (x, y). This is the number of bytes to add to a pointer to pixel (x, y) to access (x, y + 1).

Definition at line 771 of file kis_tiled_data_manager.cc.

{
    Q_UNUSED(x);
    Q_UNUSED(y);
 
    return KisTileData::WIDTH * pixelSize();
}

References pixelSize(), and KisTileData::WIDTH.

◆ setDefaultPixel()

void KisTiledDataManager::setDefaultPixel ( const quint8 * defPixel )

Definition at line 85 of file kis_tiled_data_manager.cc.

{
    QWriteLocker locker(&m_lock);
    setDefaultPixelImpl(defaultPixel);
}

References defaultPixel(), m_lock, and setDefaultPixelImpl().

◆ setDefaultPixelImpl()

void KisTiledDataManager::setDefaultPixelImpl ( const quint8 * defPixel )

private

Definition at line 91 of file kis_tiled_data_manager.cc.

{
    KisTileData *td = KisTileDataStore::instance()->createDefaultTileData(pixelSize(), defaultPixel);
    m_hashTable->setDefaultTileData(td);
    m_mementoManager->setDefaultTileData(td);
 
    memcpy(m_defaultPixel, defaultPixel, pixelSize());
}

References KisTileDataStore::createDefaultTileData(), defaultPixel(), KisTileDataStore::instance(), m_defaultPixel, m_hashTable, m_mementoManager, pixelSize(), KisMementoManager::setDefaultTileData(), and KisTileHashTableTraits< T >::setDefaultTileData().

◆ setExtent() [1/2]

void KisTiledDataManager::setExtent	(	qint32	x,
		qint32	y,
		qint32	w,
		qint32	h )

Definition at line 580 of file kis_tiled_data_manager.cc.

{
    setExtent(QRect(x, y, w, h));
}

References setExtent().

◆ setExtent() [2/2]

void KisTiledDataManager::setExtent ( QRect newRect )

Definition at line 585 of file kis_tiled_data_manager.cc.

{
    QRect oldRect = extent();
    newRect = newRect.normalized();
 
    // Do nothing if the desired size is bigger than we currently are:
    // that is handled by the autoextending automatically
    if (newRect.contains(oldRect)) return;
 
    KisTileSP tile;
    QRect tileRect;
    {
        KisTileHashTableIterator iter(m_hashTable);
 
        while (!iter.isDone()) {
            tile = iter.tile();
 
            tileRect = tile->extent();
            if (newRect.contains(tileRect)) {
                //do nothing
                iter.next();
            } else if (newRect.intersects(tileRect)) {
                QRect intersection = newRect & tileRect;
                intersection.translate(- tileRect.topLeft());
 
                const qint32 pixelSize = this->pixelSize();
 
                tile->lockForWrite();
                quint8* data = tile->data();
                quint8* ptr;
 
                /* FIXME: make it faster */
                for (int y = 0; y < KisTileData::HEIGHT; y++) {
                    for (int x = 0; x < KisTileData::WIDTH; x++) {
                        if (!intersection.contains(x, y)) {
                            ptr = data + pixelSize * (y * KisTileData::WIDTH + x);
                            memcpy(ptr, m_defaultPixel, pixelSize);
                        }
                    }
                }
                tile->unlockForWrite();
                iter.next();
            } else {
                m_extentManager.notifyTileRemoved(tile->col(), tile->row());
                iter.deleteCurrent();
            }
        }
    }
}

References KisTile::col(), KisTile::data(), KisTileHashTableIteratorTraits< T, LockerType >::deleteCurrent(), KisTile::extent(), extent(), KisTileData::HEIGHT, KisTileHashTableIteratorTraits< T, LockerType >::isDone(), KisTile::lockForWrite(), m_defaultPixel, m_extentManager, m_hashTable, KisTileHashTableIteratorTraits< T, LockerType >::next(), KisTiledExtentManager::notifyTileRemoved(), pixelSize(), KisTile::row(), KisTileHashTableIteratorTraits< T, LockerType >::tile(), KisTile::unlockForWrite(), and KisTileData::WIDTH.

◆ setPixel()

void KisTiledDataManager::setPixel	(	qint32	x,
		qint32	y,
		const quint8 *	data )

write the specified data to x, y. There is no checking on pixelSize!

Definition at line 678 of file kis_tiled_data_manager.cc.

{
    KisTileDataWrapper tw(this, x, y, KisTileDataWrapper::WRITE);
    memcpy(tw.data(), data, pixelSize());
}

References KisTileDataWrapper::data(), pixelSize(), and KisTileDataWrapper::WRITE.

◆ write()

bool KisTiledDataManager::write ( KisPaintDeviceWriter & store )

protected

Reads and writes the tiles

Definition at line 100 of file kis_tiled_data_manager.cc.

{
    QReadLocker locker(&m_lock);
 
    bool retval = true;
 
    if(CURRENT_VERSION == LEGACY_VERSION) {
        char str[80];
        sprintf(str, "%d\n", m_hashTable->numTiles());
        retval = store.write(str, strlen(str));
    }
    else {
        retval = writeTilesHeader(store, m_hashTable->numTiles());
    }
 
 
    KisTileHashTableConstIterator iter(m_hashTable);
    KisTileSP tile;
 
    KisAbstractTileCompressorSP compressor =
        KisTileCompressorFactory::create(CURRENT_VERSION);
 
    while ((tile = iter.tile())) {
        retval = compressor->writeTile(tile, store);
        if (!retval) {
            warnFile << "Failed to write tile";
            break;
        }
        iter.next();
    }
 
    return retval;
}

References KisTileCompressorFactory::create(), CURRENT_VERSION, LEGACY_VERSION, m_hashTable, m_lock, KisTileHashTableIteratorTraits< T, LockerType >::next(), KisTileHashTableTraits< T >::numTiles(), KisTileHashTableIteratorTraits< T, LockerType >::tile(), warnFile, KisPaintDeviceWriter::write(), and writeTilesHeader().

◆ writeBytes()

void KisTiledDataManager::writeBytes	(	const quint8 *	bytes,
		qint32	x,
		qint32	y,
		qint32	w,
		qint32	h,
		qint32	dataRowStride = -1 )

Copy the bytes in the vector to the specified rect. If there are bytes left in the vector after filling the rect, they will be ignored. If there are not enough bytes, the rest of the rect will be filled with the default value given (by default, 0);

Parameters

bytes	the bytes
x	x of top left corner
y	y of top left corner
w	width
h	height
dataRowStride	is the step (in bytes) which should be added to `bytes` pointer to get to the next row

Definition at line 684 of file kis_tiled_data_manager.cc.

{
    QWriteLocker locker(&m_lock);
    // Actual bytes reading/writing is done in private header
    writeBytesBody(data, x, y, width, height, dataRowStride);
}

References m_lock, and writeBytesBody().

◆ writeBytesBody()

void KisTiledDataManager::writeBytesBody	(	const quint8 *	data,
		qint32	x,
		qint32	y,
		qint32	width,
		qint32	height,
		qint32	dataRowStride = -1 )

private

Definition at line 11 of file kis_tiled_data_manager_p.h.

{
    if (!data) return;
 
    width  = width < 0  ? 0 : width;
    height = height < 0 ? 0 : height;
 
    qint32 dataY = 0;
    qint32 imageY = y;
    qint32 rowsRemaining = height;
    const qint32 pixelSize = this->pixelSize();
 
    if (dataRowStride <= 0) {
        dataRowStride = pixelSize * width;
    }
 
    while (rowsRemaining > 0) {
 
        qint32 dataX = 0;
        qint32 imageX = x;
        qint32 columnsRemaining = width;
        qint32 numContiguousImageRows = numContiguousRows(imageY, imageX,
                                                          imageX + width - 1);
 
        qint32 rowsToWork = qMin(numContiguousImageRows, rowsRemaining);
 
        while (columnsRemaining > 0) {
 
            qint32 numContiguousImageColumns =
                    numContiguousColumns(imageX, imageY,
                                         imageY + rowsToWork - 1);
 
            qint32 columnsToWork = qMin(numContiguousImageColumns,
                                        columnsRemaining);
 
            KisTileDataWrapper tw(this, imageX, imageY, KisTileDataWrapper::WRITE);
            quint8 *tileIt = tw.data();
 
 
            const qint32 tileRowStride = rowStride(imageX, imageY);
 
            const quint8 *dataIt = data +
                    dataX * pixelSize + dataY * dataRowStride;
 
            const qint32 lineSize = columnsToWork * pixelSize;
 
            for (qint32 row = 0; row < rowsToWork; row++) {
                memcpy(tileIt, dataIt, lineSize);
                tileIt += tileRowStride;
                dataIt += dataRowStride;
            }
 
            imageX += columnsToWork;
            dataX += columnsToWork;
            columnsRemaining -= columnsToWork;
        }
 
        imageY += rowsToWork;
        dataY += rowsToWork;
        rowsRemaining -= rowsToWork;
    }
}

References KisTileDataWrapper::data(), numContiguousColumns(), numContiguousRows(), pixelSize(), rowStride(), and KisTileDataWrapper::WRITE.

◆ writePlanarBytes()

void KisTiledDataManager::writePlanarBytes	(	QVector< quint8 * >	planes,
		QVector< qint32 >	channelsizes,
		qint32	x,
		qint32	y,
		qint32	w,
		qint32	h )

Write the data in the separate arrays to the channels. If there are less vectors than channels, the remaining channels will not be copied. If any of the arrays points to 0, the channel in that location will not be touched. If the specified area is larger than the paint device, the paint device will be extended. There are no guards: if the area covers more pixels than there are bytes in the arrays, krita will happily fill your paint device with areas of memory you never wanted to be read. Krita may also crash.

Definition at line 715 of file kis_tiled_data_manager.cc.

{
    QWriteLocker locker(&m_lock);
    // Actual bytes reading/writing is done in private header
 
    bool allChannelsPresent = true;
 
    Q_FOREACH (const quint8* plane, planes) {
        if (!plane) {
            allChannelsPresent = false;
            break;
        }
    }
 
    if (allChannelsPresent) {
        writePlanarBytesBody<true>(planes, channelSizes, x, y, width, height);
    } else {
        writePlanarBytesBody<false>(planes, channelSizes, x, y, width, height);
    }
}

References m_lock.

◆ writePlanarBytesBody()

template<bool allChannelsPresent>

void KisTiledDataManager::writePlanarBytesBody	(	QVector< quint8 * >	planes,
		QVector< qint32 >	channelsizes,
		qint32	x,
		qint32	y,
		qint32	w,
		qint32	h )

private

Definition at line 151 of file kis_tiled_data_manager_p.h.

{
    Q_ASSERT(planes.size() == channelSizes.size());
    Q_ASSERT(planes.size() > 0);
 
    width  = width < 0  ? 0 : width;
    height = height < 0 ? 0 : height;
 
    const qint32 numChannels = planes.size();
    const qint32 pixelSize = this->pixelSize();
 
    qint32 dataY = 0;
    qint32 imageY = y;
    qint32 rowsRemaining = height;
 
    while (rowsRemaining > 0) {
 
        qint32 dataX = 0;
        qint32 imageX = x;
        qint32 columnsRemaining = width;
        qint32 numContiguousImageRows = numContiguousRows(imageY, imageX,
                                                          imageX + width - 1);
 
        qint32 rowsToWork = qMin(numContiguousImageRows, rowsRemaining);
 
        while (columnsRemaining > 0) {
 
            qint32 numContiguousImageColumns =
                    numContiguousColumns(imageX, imageY,
                                         imageY + rowsToWork - 1);
            qint32 columnsToWork = qMin(numContiguousImageColumns,
                                        columnsRemaining);
 
            const qint32 dataIdx = dataX + dataY * width;
            const qint32 tileRowStride = rowStride(imageX, imageY) -
                    columnsToWork * pixelSize;
 
            KisTileDataWrapper tw(this, imageX, imageY,
                                  KisTileDataWrapper::WRITE);
            quint8 *tileItStart = tw.data();
 
 
            forEachChannel(i, channelSize) {
                if (allChannelsPresent || planes[i]) {
                    const quint8* planeIt = planes[i] + dataIdx * channelSize;
                    qint32 dataStride = (width - columnsToWork) * channelSize;
                    quint8* tileIt = tileItStart;
 
                    for (qint32 row = 0; row < rowsToWork; row++) {
                        for (int col = 0; col < columnsToWork; col++) {
                            memcpy(tileIt, planeIt, channelSize);
                            tileIt += pixelSize;
                            planeIt += channelSize;
                        }
 
                        tileIt += tileRowStride;
                        planeIt += dataStride;
                    }
                }
 
                tileItStart += channelSize;
            }
 
            imageX += columnsToWork;
            dataX += columnsToWork;
            columnsRemaining -= columnsToWork;
        }
 
 
        imageY += rowsToWork;
        dataY += rowsToWork;
        rowsRemaining -= rowsToWork;
    }
}

References KisTileDataWrapper::data(), forEachChannel, numContiguousColumns(), numContiguousRows(), pixelSize(), rowStride(), and KisTileDataWrapper::WRITE.

◆ writeTilesHeader()

bool KisTiledDataManager::writeTilesHeader	(	KisPaintDeviceWriter &	store,
		quint32	numTiles )

private

Definition at line 181 of file kis_tiled_data_manager.cc.

{
    QString buffer;
 
    buffer = QString("VERSION %1\n"
                     "TILEWIDTH %2\n"
                     "TILEHEIGHT %3\n"
                     "PIXELSIZE %4\n"
                     "DATA %5\n")
        .arg(CURRENT_VERSION)
        .arg(KisTileData::WIDTH)
        .arg(KisTileData::HEIGHT)
        .arg(pixelSize())
        .arg(numTiles);
 
    return store.write(buffer.toLatin1());
}

References CURRENT_VERSION, KisTileData::HEIGHT, pixelSize(), KisTileData::WIDTH, and KisPaintDeviceWriter::write().

◆ xToCol()

qint32 KisTiledDataManager::xToCol ( qint32 x ) const

inlineprivate

Definition at line 348 of file kis_tiled_data_manager.h.

    {
        return divideRoundDown(x, KisTileData::WIDTH);
    }

References KisTileData::WIDTH.

◆ yToRow()

qint32 KisTiledDataManager::yToRow ( qint32 y ) const

inlineprivate

Definition at line 352 of file kis_tiled_data_manager.h.

    {
        return divideRoundDown(y, KisTileData::HEIGHT);
    }

References KisTileData::HEIGHT.

Friends And Related Symbol Documentation

◆ KisAbstractTileCompressor

friend class KisAbstractTileCompressor

friend

Definition at line 346 of file kis_tiled_data_manager.h.

◆ KisBaseIterator

friend class KisBaseIterator

friend

Definition at line 74 of file kis_tiled_data_manager.h.

◆ KisRandomAccessor2

friend class KisRandomAccessor2

friend

Definition at line 76 of file kis_tiled_data_manager.h.

◆ KisStressJob

friend class KisStressJob

friend

Definition at line 77 of file kis_tiled_data_manager.h.

◆ KisTileDataWrapper

friend class KisTileDataWrapper

friend

Definition at line 347 of file kis_tiled_data_manager.h.

◆ KisTiledIterator

friend class KisTiledIterator

friend

Definition at line 73 of file kis_tiled_data_manager.h.

◆ KisTiledRandomAccessor

friend class KisTiledRandomAccessor

friend

Definition at line 75 of file kis_tiled_data_manager.h.

Member Data Documentation

◆ CURRENT_VERSION

const qint32 KisTiledDataManager::CURRENT_VERSION = 2

staticprivate

Definition at line 59 of file kis_tiled_data_manager.h.

◆ LEGACY_VERSION

const qint32 KisTiledDataManager::LEGACY_VERSION = 1

staticprivate

Definition at line 58 of file kis_tiled_data_manager.h.

◆ m_defaultPixel

quint8* KisTiledDataManager::m_defaultPixel

private

Definition at line 337 of file kis_tiled_data_manager.h.

◆ m_extentManager

KisTiledExtentManager KisTiledDataManager::m_extentManager

private

Definition at line 339 of file kis_tiled_data_manager.h.

◆ m_hashTable

KisTileHashTable* KisTiledDataManager::m_hashTable

private

Definition at line 335 of file kis_tiled_data_manager.h.

◆ m_lock

QReadWriteLock KisTiledDataManager::m_lock

mutableprivate

Definition at line 341 of file kis_tiled_data_manager.h.

◆ m_mementoManager

KisMementoManager* KisTiledDataManager::m_mementoManager

private

Definition at line 336 of file kis_tiled_data_manager.h.

◆ m_pixelSize

qint32 KisTiledDataManager::m_pixelSize

private

Definition at line 338 of file kis_tiled_data_manager.h.

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

libs/image/tiles3/kis_tiled_data_manager.h
libs/image/tiles3/kis_tiled_data_manager.cc
libs/image/tiles3/kis_tiled_data_manager_p.h

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ KisTiledDataManager() [1/2]

◆ ~KisTiledDataManager()

◆ KisTiledDataManager() [2/2]

Member Function Documentation

◆ bitBlt()

◆ bitBltImpl()

◆ bitBltOldData()

◆ bitBltRough()

◆ bitBltRoughImpl()

◆ bitBltRoughOldData()

◆ clear() [1/5]

◆ clear() [2/5]

◆ clear() [3/5]

◆ clear() [4/5]

◆ clear() [5/5]

◆ commit()

◆ debugPrintInfo()

◆ defaultPixel()

◆ divideRoundDown()

◆ duplicatePixel()

◆ extent() [1/2]

◆ extent() [2/2]

◆ getMemento()

◆ getOldTile() [1/2]

◆ getOldTile() [2/2]

◆ getReadOnlyTileLazy()

◆ getTile()

◆ getTilesPair()

◆ hasCurrentMemento()

◆ numContiguousColumns()

◆ numContiguousRows()

◆ operator=()

◆ pixelSize()

◆ processTilesHeader()

◆ purge()

◆ purgeHistory()

◆ read()

◆ readBytes()

◆ readBytesBody()

◆ readPlanarBytes()

◆ readPlanarBytesBody()

◆ recalculateExtent()

◆ region()

◆ releaseInternalPools()

◆ rollback()

◆ rollforward()

◆ rowStride()

◆ setDefaultPixel()

◆ setDefaultPixelImpl()

◆ setExtent() [1/2]

◆ setExtent() [2/2]

◆ setPixel()

◆ write()

◆ writeBytes()

◆ writeBytesBody()

◆ writePlanarBytes()

◆ writePlanarBytesBody()

◆ writeTilesHeader()

◆ xToCol()

◆ yToRow()

Friends And Related Symbol Documentation

◆ KisAbstractTileCompressor

◆ KisBaseIterator

◆ KisRandomAccessor2

◆ KisStressJob

◆ KisTileDataWrapper

◆ KisTiledIterator

◆ KisTiledRandomAccessor

Member Data Documentation

◆ CURRENT_VERSION

◆ LEGACY_VERSION