AssetTable.hpp

#pragma once
 
#include <score_plugin_gfx_export.h>
 
#include <ossia/detail/hash_map.hpp>
 
#include <QImage>
 
#include <cstddef>
#include <cstdint>
#include <list>
#include <memory>
#include <mutex>
#include <string>
#include <vector>
 
namespace Gfx
{
 
class SCORE_PLUGIN_GFX_EXPORT AssetTable
{
public:
  struct DecodedAsset
  {
    QImage image;
    std::shared_ptr<const std::vector<uint8_t>> bytes;
    std::string mime_type;
    int64_t refcount{0};
    // Approximate storage cost. Computed at stage() time; the
    // allocator may report a different value but this is the number
    // the LRU trim budgets against.
    std::size_t byte_size{0};
  };
 
  // For byte-range hashing use `ossia::hash_bytes` from
  // `ossia/detail/hash.hpp` — it's the canonical rapidhash-tiered
  // dispatcher that produces stable `content_hash` values across
  // the codebase. Parsers call it directly when stamping
  // `texture_source::content_hash` / `buffer_resource::content_hash`.
 
  AssetTable() = default;
  AssetTable(const AssetTable&) = delete;
  AssetTable& operator=(const AssetTable&) = delete;
  ~AssetTable() = default;
 
  void stage(uint64_t content_hash, QImage image);
  void stage(
      uint64_t content_hash, std::shared_ptr<const std::vector<uint8_t>> bytes,
      std::string mime_type = {});
 
  std::shared_ptr<const DecodedAsset> acquire(uint64_t content_hash);
 
  std::shared_ptr<const DecodedAsset> peek(uint64_t content_hash) const;
 
  void release(uint64_t content_hash);
 
  std::size_t trim(std::size_t max_bytes_budget);
 
  void maybeAutoTrim(
      float utilization, float high_watermark = 0.80f,
      float target = 0.60f);
 
  std::size_t size() const noexcept;
  std::size_t totalBytes() const noexcept;
  std::size_t coldCount() const noexcept;
 
private:
  struct Slot;  // forward
 
  // Linked list of cold entries, newest at head. std::list for
  // stable iterators under concurrent erase.
  using LruList = std::list<uint64_t>;
 
  struct Slot
  {
    std::shared_ptr<DecodedAsset> asset;
    LruList::iterator lru_it;   // valid only when refcount == 0
    bool in_lru{false};
  };
 
  void evictOne() noexcept;   // Pops the LRU tail. Caller holds m_mutex.
 
  mutable std::mutex m_mutex;
  ossia::hash_map<uint64_t, Slot> m_entries;
  LruList m_lru;              // cold entries, newest at front
  std::size_t m_total_bytes{0};
  std::size_t m_cold_bytes{0};
};
 
} // namespace Gfx