TileCache.h

Go to the documentation of this file.

/*
 *    Copyright (C) 2016-2026 Grok Image Compression Inc.
 *
 *    This source code is free software: you can redistribute it and/or  modify
 *    it under the terms of the GNU Affero General Public License, version 3,
 *    as published by the Free Software Foundation.
 *
 *    This source code is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU Affero General Public License for more details.
 *
 *    You should have received a copy of the GNU Affero General Public License
 *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#pragma once
 
#include <vector>
#include <list>
#include <algorithm>
 
namespace grk
{

struct TileCacheEntry
{
  explicit TileCacheEntry(ITileProcessor* p) : processor(p), dirty_(true) {}
  TileCacheEntry() : TileCacheEntry(nullptr) {}
  ~TileCacheEntry()
  {
    delete processor;
  }
 
  ITileProcessor* processor;
  bool dirty_;
};

class TileCache
{
public:
  TileCache() : strategy_(GRK_TILE_CACHE_NONE), initialized_(false), maxActiveTiles_(0) {}
 
  ~TileCache()
  {
    for(auto* entry : cache_)
    {
      delete entry;
    }
  }
 
  void init(uint16_t numTiles)
  {
    if(initialized_)
    {
      return; // Prevent reinitialization
    }
    initialized_ = true;
 
    // Initialize cache array with nullptrs
    cache_.resize(numTiles, nullptr);
  }
 
  bool empty() const
  {
    return cache_.empty();
  }
 
  void setStrategy(uint32_t strategy)
  {
    strategy_ = strategy;
  }
 
  uint32_t getStrategy() const
  {
    return strategy_;
  }

  void setMaxActiveTiles(uint16_t maxActive)
  {
    maxActiveTiles_ = maxActive;
  }
 
  uint16_t getMaxActiveTiles() const
  {
    return maxActiveTiles_;
  }
 
  void setTruncated(void)
  {
    for(auto* entry : cache_)
    {
      if(!entry || !entry->processor)
        continue;
      entry->processor->setTruncated();
    }
  }
 
  void setDirty(bool dirty)
  {
    for(auto* entry : cache_)
    {
      if(!entry)
        continue;
      entry->dirty_ = dirty;
    }
  }
 
  void setDirty(uint16_t tileIndex, bool dirty)
  {
    if(tileIndex >= cache_.size())
      return;
    if(cache_[tileIndex])
    {
      cache_[tileIndex]->dirty_ = dirty;
    }
  }
 
  bool isDirty(uint16_t tileIndex)
  {
    if(tileIndex >= cache_.size())
      return false;
    return cache_[tileIndex] ? cache_[tileIndex]->dirty_ : false;
  }
 
  TileCacheEntry* put(uint16_t tile_index, ITileProcessor* processor)
  {
    if(tile_index >= cache_.size())
    {
      delete processor;
      grklog.warn("Failed to put tile processor for tile %d because tile index is out of bounds",
                  tile_index);
      return nullptr;
    }
    if(!cache_[tile_index])
    {
      cache_[tile_index] = new TileCacheEntry(processor);
    }
    else
    {
      if(cache_[tile_index]->processor)
        delete cache_[tile_index]->processor;
      cache_[tile_index]->processor = processor;
    }
 
    // LRU: promote this tile and evict if over limit
    promoteLRU(tile_index);
    evictLRU();
 
    return cache_[tile_index];
  }
 
  TileCacheEntry* get(uint16_t tile_index)
  {
    if(tile_index >= cache_.size())
      return nullptr;
 
    // LRU: promote on access
    if(cache_[tile_index] && cache_[tile_index]->processor)
      promoteLRU(tile_index);
 
    return cache_[tile_index];
  }
 
  void release(uint16_t tileIndex)
  {
    if(cache_[tileIndex] && cache_[tileIndex]->processor)
      cache_[tileIndex]->processor->release(strategy_);
  }

  void releaseForSwath(uint16_t tileIndex)
  {
    if(tileIndex >= cache_.size())
      return;
    if(cache_[tileIndex] && cache_[tileIndex]->processor)
      cache_[tileIndex]->processor->releaseForSwath();
  }
 
  void resetSOTParsing()
  {
    for(auto* entry : cache_)
    {
      if(!entry || !entry->processor)
        continue;
      // Skip tiles that are already decompressed or have cached SOT info
      if(entry->processor->isBestEffortDecompressed() || entry->processor->getImage())
        continue;
      entry->processor->resetSOTParsing();
    }
  }
 
  bool allSlatedSOTMarkersParsed(const std::set<uint16_t>& tilesSlatedForDecompression)
  {
    return std::all_of(tilesSlatedForDecompression.begin(), tilesSlatedForDecompression.end(),
                       [this](uint16_t tileId) {
                         if(tileId >= cache_.size())
                           return false;
                         auto* entry = cache_[tileId];
                         return entry && entry->processor &&
                                entry->processor->allSOTMarkersParsed();
                       });
  }
 
  bool setProgressionState(grk_progression_state state)
  {
    if(!state.single_tile)
      return false;
 
    auto cached = get(state.tile_index);
    if(!cached || !cached->processor)
      return false;
 
    uint16_t maxlayer = 0;
    for(uint8_t r = 0; r < state.num_resolutions; ++r)
    {
      maxlayer = std::max(maxlayer, state.layers_per_resolution[r]);
    }
    if(maxlayer != cached->processor->getTCP()->layersToDecompress_)
    {
      cached->dirty_ = true;
      cached->processor->getTCP()->layersToDecompress_ = maxlayer;
    }
 
    return true;
  }
 
  grk_progression_state getProgressionState(uint16_t tileIndex)
  {
    auto cached = get(tileIndex);
    if(!cached)
      return {};
 
    return cached->processor->getProgressionState();
  }
 
private:
  void promoteLRU(uint16_t tileIndex)
  {
    if(maxActiveTiles_ == 0)
      return; // LRU disabled
 
    // Remove existing entry if present
    lruList_.remove(tileIndex);
    lruList_.push_front(tileIndex);
  }

  void evictLRU()
  {
    if(maxActiveTiles_ == 0)
      return; // LRU disabled
 
    while(lruList_.size() > maxActiveTiles_)
    {
      uint16_t victim = lruList_.back();
      lruList_.pop_back();
 
      if(victim < cache_.size() && cache_[victim] && cache_[victim]->processor)
      {
        cache_[victim]->processor->release(GRK_TILE_CACHE_LRU);
      }
    }
  }
 
  std::vector<TileCacheEntry*> cache_; // Array of cache entries
  std::list<uint16_t> lruList_; // Front = MRU, back = LRU (tile indices with active data)
  uint32_t strategy_; // Cache strategy
  bool initialized_; // Flag to prevent reinitialization
  uint16_t maxActiveTiles_; // Max tiles with decompressed data (0 = unlimited)
};
 
} // namespace grk