File indexing completed on 2024-05-26 04:28:04

 /*
  *  copyright (c) 2006,2010 Cyrille Berger <cberger@cberger.net>
  *
  *  SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include "kis_random_accessor.h"
 
 
 #include <kis_debug.h>
 
 
 const quint32 KisRandomAccessor2::CACHESIZE = 4; // Define the number of tiles we keep in cache
 
 KisRandomAccessor2::KisRandomAccessor2(KisTiledDataManager *ktm, qint32 offsetX, qint32 offsetY, bool writable, KisIteratorCompleteListener *completeListener) :
         m_ktm(ktm),
         m_tilesCache(new KisTileInfo*[CACHESIZE]),
         m_tilesCacheSize(0),
         m_pixelSize(m_ktm->pixelSize()),
         m_data(0),
         m_oldData(0),
         m_writable(writable),
         m_lastX(0),
         m_lastY(0),
         m_offsetX(offsetX),
         m_offsetY(offsetY),
         m_completeListener(completeListener)
 {
     Q_ASSERT(ktm != 0);
 }
 
 KisRandomAccessor2::~KisRandomAccessor2()
 {
     for (uint i = 0; i < m_tilesCacheSize; i++) {
         unlockTile(m_tilesCache[i]->tile);
         unlockOldTile(m_tilesCache[i]->oldtile);
         delete m_tilesCache[i];
     }
     delete [] m_tilesCache;
 
     if (m_writable && m_completeListener) {
         m_completeListener->notifyWritableIteratorCompleted();
     }
 }
 
 void KisRandomAccessor2::moveTo(qint32 x, qint32 y)
 {
     m_lastX = x;
     m_lastY = y;
 
     x -= m_offsetX;
     y -= m_offsetY;
 
     // Look in the cache if the tile if the data is available
     for (uint i = 0; i < m_tilesCacheSize; i++) {
         if (x >= m_tilesCache[i]->area_x1 && x <= m_tilesCache[i]->area_x2 &&
                 y >= m_tilesCache[i]->area_y1 && y <= m_tilesCache[i]->area_y2) {
             KisTileInfo* kti = m_tilesCache[i];
             quint32 offset = x - kti->area_x1 + (y - kti->area_y1) * KisTileData::WIDTH;
             offset *= m_pixelSize;
             m_data = kti->data + offset;
             m_oldData = kti->oldData + offset;
             if (i > 0) {
                 memmove(m_tilesCache + 1, m_tilesCache, i * sizeof(KisTileInfo*));
                 m_tilesCache[0] = kti;
             }
             return;
         }
     }
     // The tile wasn't in cache
     if (m_tilesCacheSize == KisRandomAccessor2::CACHESIZE) { // Remove last element of cache
         unlockTile(m_tilesCache[CACHESIZE-1]->tile);
         unlockOldTile(m_tilesCache[CACHESIZE-1]->oldtile);
         delete m_tilesCache[CACHESIZE-1];
     } else {
         m_tilesCacheSize++;
     }
     quint32 col = xToCol(x);
     quint32 row = yToRow(y);
     KisTileInfo* kti = fetchTileData(col, row);
     quint32 offset = x - kti->area_x1 + (y - kti->area_y1) * KisTileData::WIDTH;
     offset *= m_pixelSize;
     m_data = kti->data + offset;
     m_oldData = kti->oldData + offset;
     memmove(m_tilesCache + 1, m_tilesCache, (KisRandomAccessor2::CACHESIZE - 1) * sizeof(KisTileInfo*));
     m_tilesCache[0] = kti;
 }
 
 
 quint8* KisRandomAccessor2::rawData()
 {
     return m_data;
 }
 
 
 const quint8* KisRandomAccessor2::oldRawData() const
 {
 #ifdef DEBUG
     if (!m_ktm->hasCurrentMemento()) warnTiles << "Accessing oldRawData() when no transaction is in progress.";
 #endif
     return m_oldData;
 }
 
 const quint8* KisRandomAccessor2::rawDataConst() const
 {
     return m_data;
 }
 
 KisRandomAccessor2::KisTileInfo* KisRandomAccessor2::fetchTileData(qint32 col, qint32 row)
 {
     KisTileInfo* kti = new KisTileInfo;
 
     m_ktm->getTilesPair(col, row, m_writable, &kti->tile, &kti->oldtile);
 
     lockTile(kti->tile);
     kti->data = kti->tile->data();
 
     lockOldTile(kti->oldtile);
     kti->oldData = kti->oldtile->data();
 
     kti->area_x1 = col * KisTileData::HEIGHT;
     kti->area_y1 = row * KisTileData::WIDTH;
     kti->area_x2 = kti->area_x1 + KisTileData::HEIGHT - 1;
     kti->area_y2 = kti->area_y1 + KisTileData::WIDTH - 1;
 
     return kti;
 }
 
 qint32 KisRandomAccessor2::numContiguousColumns(qint32 x) const
 {
     return m_ktm->numContiguousColumns(x - m_offsetX, 0, 0);
 }
 
 qint32 KisRandomAccessor2::numContiguousRows(qint32 y) const
 {
     return m_ktm->numContiguousRows(y - m_offsetY, 0, 0);
 }
 
 qint32 KisRandomAccessor2::rowStride(qint32 x, qint32 y) const
 {
     return m_ktm->rowStride(x - m_offsetX, y - m_offsetY);
 }
 
 qint32 KisRandomAccessor2::x() const
 {
     return m_lastX;
 }
 
 qint32 KisRandomAccessor2::y() const
 {
     return m_lastY;
 }