spritecache.cpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD 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 General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "stdafx.h"
#include "random_access_file_type.h"
#include "spriteloader/grf.hpp"
#include "spriteloader/makeindexed.h"
#include "gfx_func.h"
#include "error.h"
#include "error_func.h"
#include "strings_func.h"
#include "zoom_func.h"
#include "settings_type.h"
#include "blitter/factory.hpp"
#include "core/math_func.hpp"
#include "video/video_driver.hpp"
#include "spritecache.h"
#include "spritecache_internal.h"
 
#include "table/sprites.h"
#include "table/strings.h"
#include "table/palette_convert.h"
 
#include "safeguards.h"
 
/* Default of 4MB spritecache */
uint _sprite_cache_size = 4;
 
 
static std::vector<SpriteCache> _spritecache;
static std::vector<std::unique_ptr<SpriteFile>> _sprite_files;
 
static inline SpriteCache *GetSpriteCache(uint index)
{
  return &_spritecache[index];
}
 
SpriteCache *AllocateSpriteCache(uint index)
{
  if (index >= _spritecache.size()) {
    /* Add another 1024 items to the 'pool' */
    uint items = Align(index + 1, 1024);
 
    Debug(sprite, 4, "Increasing sprite cache to {} items ({} bytes)", items, items * sizeof(SpriteCache));
 
    _spritecache.resize(items);
  }
 
  return GetSpriteCache(index);
}
 
static SpriteFile *GetCachedSpriteFileByName(const std::string &filename)
{
  for (auto &f : _sprite_files) {
    if (f->GetFilename() == filename) {
      return f.get();
    }
  }
  return nullptr;
}
static SpriteFile *GetCachedSpriteFileByName(const std::string &filename) {…}
 
std::span<const std::unique_ptr<SpriteFile>> GetCachedSpriteFiles()
{
  return _sprite_files;
}
std::span<const std::unique_ptr<SpriteFile>> GetCachedSpriteFiles() {…}
 
SpriteFile &OpenCachedSpriteFile(const std::string &filename, Subdirectory subdir, bool palette_remap)
{
  SpriteFile *file = GetCachedSpriteFileByName(filename);
  if (file == nullptr) {
    file = _sprite_files.insert(std::end(_sprite_files), std::make_unique<SpriteFile>(filename, subdir, palette_remap))->get();
  } else {
    file->SeekToBegin();
  }
  return *file;
}
SpriteFile &OpenCachedSpriteFile(const std::string &filename, Subdirectory subdir, bool palette_remap) {…}
 
struct MemBlock {
  size_t size;
  uint8_t data[];
};
struct MemBlock {…};
 
static uint _sprite_lru_counter;
static MemBlock *_spritecache_ptr;
static uint _allocated_sprite_cache_size = 0;
static int _compact_cache_counter;
 
static void CompactSpriteCache();
 
bool SkipSpriteData(SpriteFile &file, uint8_t type, uint16_t num)
{
  if (type & 2) {
    file.SkipBytes(num);
  } else {
    while (num > 0) {
      int8_t i = file.ReadByte();
      if (i >= 0) {
        int size = (i == 0) ? 0x80 : i;
        if (size > num) return false;
        num -= size;
        file.SkipBytes(size);
      } else {
        i = -(i >> 3);
        num -= i;
        file.ReadByte();
      }
    }
  }
  return true;
}
bool SkipSpriteData(SpriteFile &file, uint8_t type, uint16_t num) {…}
 
/* Check if the given Sprite ID exists */
bool SpriteExists(SpriteID id)
{
  if (id >= _spritecache.size()) return false;
 
  /* Special case for Sprite ID zero -- its position is also 0... */
  if (id == 0) return true;
  return !(GetSpriteCache(id)->file_pos == 0 && GetSpriteCache(id)->file == nullptr);
}
 
SpriteType GetSpriteType(SpriteID sprite)
{
  if (!SpriteExists(sprite)) return SpriteType::Invalid;
  return GetSpriteCache(sprite)->type;
}
SpriteType GetSpriteType(SpriteID sprite) {…}
 
SpriteFile *GetOriginFile(SpriteID sprite)
{
  if (!SpriteExists(sprite)) return nullptr;
  return GetSpriteCache(sprite)->file;
}
SpriteFile *GetOriginFile(SpriteID sprite) {…}
 
uint32_t GetSpriteLocalID(SpriteID sprite)
{
  if (!SpriteExists(sprite)) return 0;
  return GetSpriteCache(sprite)->id;
}
uint32_t GetSpriteLocalID(SpriteID sprite) {…}
 
uint GetSpriteCountForFile(const std::string &filename, SpriteID begin, SpriteID end)
{
  SpriteFile *file = GetCachedSpriteFileByName(filename);
  if (file == nullptr) return 0;
 
  uint count = 0;
  for (SpriteID i = begin; i != end; i++) {
    if (SpriteExists(i)) {
      SpriteCache *sc = GetSpriteCache(i);
      if (sc->file == file) {
        count++;
        Debug(sprite, 4, "Sprite: {}", i);
      }
    }
  }
  return count;
}
uint GetSpriteCountForFile(const std::string &filename, SpriteID begin, SpriteID end) {…}
 
SpriteID GetMaxSpriteID()
{
  return static_cast<SpriteID>(_spritecache.size());
}
SpriteID GetMaxSpriteID() {…}
 
static bool ResizeSpriteIn(SpriteLoader::SpriteCollection &sprite, ZoomLevel src, ZoomLevel tgt)
{
  uint8_t scaled_1 = AdjustByZoom(1, src - tgt);
  const auto &src_sprite = sprite[src];
  auto &dest_sprite = sprite[tgt];
 
  /* Check for possible memory overflow. */
  if (src_sprite.width * scaled_1 > UINT16_MAX || src_sprite.height * scaled_1 > UINT16_MAX) return false;
 
  dest_sprite.width = src_sprite.width * scaled_1;
  dest_sprite.height = src_sprite.height * scaled_1;
  dest_sprite.x_offs = src_sprite.x_offs * scaled_1;
  dest_sprite.y_offs = src_sprite.y_offs * scaled_1;
  dest_sprite.colours = src_sprite.colours;
 
  dest_sprite.AllocateData(tgt, static_cast<size_t>(dest_sprite.width) * dest_sprite.height);
 
  SpriteLoader::CommonPixel *dst = dest_sprite.data;
  for (int y = 0; y < dest_sprite.height; y++) {
    const SpriteLoader::CommonPixel *src_ln = &src_sprite.data[y / scaled_1 * src_sprite.width];
    for (int x = 0; x < dest_sprite.width; x++) {
      *dst = src_ln[x / scaled_1];
      dst++;
    }
  }
 
  return true;
}
 
static void ResizeSpriteOut(SpriteLoader::SpriteCollection &sprite, ZoomLevel zoom)
{
  const auto &root_sprite = sprite.Root();
  const auto &src_sprite = sprite[zoom - 1];
  auto &dest_sprite = sprite[zoom];
 
  /* Algorithm based on 32bpp_Optimized::ResizeSprite() */
  dest_sprite.width = UnScaleByZoom(root_sprite.width, zoom);
  dest_sprite.height = UnScaleByZoom(root_sprite.height, zoom);
  dest_sprite.x_offs = UnScaleByZoom(root_sprite.x_offs, zoom);
  dest_sprite.y_offs = UnScaleByZoom(root_sprite.y_offs, zoom);
  dest_sprite.colours = root_sprite.colours;
 
  dest_sprite.AllocateData(zoom, static_cast<size_t>(dest_sprite.height) * dest_sprite.width);
 
  SpriteLoader::CommonPixel *dst = dest_sprite.data;
  const SpriteLoader::CommonPixel *src = src_sprite.data;
  [[maybe_unused]] const SpriteLoader::CommonPixel *src_end = src + src_sprite.height * src_sprite.width;
 
  for (uint y = 0; y < dest_sprite.height; y++) {
    const SpriteLoader::CommonPixel *src_ln = src + src_sprite.width;
    assert(src_ln <= src_end);
    for (uint x = 0; x < dest_sprite.width; x++) {
      assert(src < src_ln);
      if (src + 1 != src_ln && (src + 1)->a != 0) {
        *dst = *(src + 1);
      } else {
        *dst = *src;
      }
      dst++;
      src += 2;
    }
    src = src_ln + src_sprite.width;
  }
}
 
static bool PadSingleSprite(SpriteLoader::Sprite *sprite, ZoomLevel zoom, uint pad_left, uint pad_top, uint pad_right, uint pad_bottom)
{
  uint width  = sprite->width + pad_left + pad_right;
  uint height = sprite->height + pad_top + pad_bottom;
 
  if (width > UINT16_MAX || height > UINT16_MAX) return false;
 
  /* Copy source data and reallocate sprite memory. */
  size_t sprite_size = static_cast<size_t>(sprite->width) * sprite->height;
  std::vector<SpriteLoader::CommonPixel> src_data(sprite->data, sprite->data + sprite_size);
  sprite->AllocateData(zoom, static_cast<size_t>(width) * height);
 
  /* Copy with padding to destination. */
  SpriteLoader::CommonPixel *src = src_data.data();
  SpriteLoader::CommonPixel *data = sprite->data;
  for (uint y = 0; y < height; y++) {
    if (y < pad_top || pad_bottom + y >= height) {
      /* Top/bottom padding. */
      std::fill_n(data, width, SpriteLoader::CommonPixel{});
      data += width;
    } else {
      if (pad_left > 0) {
        /* Pad left. */
        std::fill_n(data, pad_left, SpriteLoader::CommonPixel{});
        data += pad_left;
      }
 
      /* Copy pixels. */
      std::copy_n(src, sprite->width, data);
      src += sprite->width;
      data += sprite->width;
 
      if (pad_right > 0) {
        /* Pad right. */
        std::fill_n(data, pad_right, SpriteLoader::CommonPixel{});
        data += pad_right;
      }
    }
  }
 
  /* Update sprite size. */
  sprite->width   = width;
  sprite->height  = height;
  sprite->x_offs -= pad_left;
  sprite->y_offs -= pad_top;
 
  return true;
}
 
static bool PadSprites(SpriteLoader::SpriteCollection &sprite, ZoomLevels sprite_avail, SpriteEncoder *encoder)
{
  /* Get minimum top left corner coordinates. */
  int min_xoffs = INT32_MAX;
  int min_yoffs = INT32_MAX;
  for (ZoomLevel zoom = ZoomLevel::Begin; zoom != ZoomLevel::End; zoom++) {
    if (sprite_avail.Test(zoom)) {
      min_xoffs = std::min(min_xoffs, ScaleByZoom(sprite[zoom].x_offs, zoom));
      min_yoffs = std::min(min_yoffs, ScaleByZoom(sprite[zoom].y_offs, zoom));
    }
  }
 
  /* Get maximum dimensions taking necessary padding at the top left into account. */
  int max_width  = INT32_MIN;
  int max_height = INT32_MIN;
  for (ZoomLevel zoom = ZoomLevel::Begin; zoom != ZoomLevel::End; zoom++) {
    if (sprite_avail.Test(zoom)) {
      max_width  = std::max(max_width, ScaleByZoom(sprite[zoom].width + sprite[zoom].x_offs - UnScaleByZoom(min_xoffs, zoom), zoom));
      max_height = std::max(max_height, ScaleByZoom(sprite[zoom].height + sprite[zoom].y_offs - UnScaleByZoom(min_yoffs, zoom), zoom));
    }
  }
 
  /* Align height and width if required to match the needs of the sprite encoder. */
  uint align = encoder->GetSpriteAlignment();
  if (align != 0) {
    max_width  = Align(max_width,  align);
    max_height = Align(max_height, align);
  }
 
  /* Pad sprites where needed. */
  for (ZoomLevel zoom = ZoomLevel::Begin; zoom != ZoomLevel::End; zoom++) {
    if (sprite_avail.Test(zoom)) {
      auto &cur_sprite = sprite[zoom];
      /* Scaling the sprite dimensions in the blitter is done with rounding up,
       * so a negative padding here is not an error. */
      int pad_left = std::max(0, cur_sprite.x_offs - UnScaleByZoom(min_xoffs, zoom));
      int pad_top = std::max(0, cur_sprite.y_offs - UnScaleByZoom(min_yoffs, zoom));
      int pad_right = std::max(0, UnScaleByZoom(max_width, zoom) - cur_sprite.width - pad_left);
      int pad_bottom = std::max(0, UnScaleByZoom(max_height, zoom) - cur_sprite.height - pad_top);
 
      if (pad_left > 0 || pad_right > 0 || pad_top > 0 || pad_bottom > 0) {
        if (!PadSingleSprite(&cur_sprite, zoom, pad_left, pad_top, pad_right, pad_bottom)) return false;
      }
    }
  }
 
  return true;
}
 
static bool ResizeSprites(SpriteLoader::SpriteCollection &sprite, ZoomLevels sprite_avail, SpriteEncoder *encoder)
{
  /* Create a fully zoomed image if it does not exist */
  ZoomLevel first_avail;
  for (ZoomLevel zoom = ZoomLevel::Min; zoom <= ZoomLevel::Max; ++zoom) {
    if (!sprite_avail.Test(zoom)) continue;
    first_avail = zoom;
    if (zoom != ZoomLevel::Min) {
      if (!ResizeSpriteIn(sprite, zoom, ZoomLevel::Min)) return false;
      sprite_avail.Set(ZoomLevel::Min);
    }
    break;
  }
 
  /* Pad sprites to make sizes match. */
  if (!PadSprites(sprite, sprite_avail, encoder)) return false;
 
  /* Create other missing zoom levels */
  for (ZoomLevel zoom = ZoomLevel::Begin; zoom != ZoomLevel::End; zoom++) {
    if (zoom == ZoomLevel::Min) continue;
 
    if (sprite_avail.Test(zoom)) {
      /* Check that size and offsets match the fully zoomed image. */
      [[maybe_unused]] const auto &root_sprite = sprite[ZoomLevel::Min];
      [[maybe_unused]] const auto &dest_sprite = sprite[zoom];
      assert(dest_sprite.width == UnScaleByZoom(root_sprite.width, zoom));
      assert(dest_sprite.height == UnScaleByZoom(root_sprite.height, zoom));
      assert(dest_sprite.x_offs == UnScaleByZoom(root_sprite.x_offs, zoom));
      assert(dest_sprite.y_offs == UnScaleByZoom(root_sprite.y_offs, zoom));
    } else {
      /* Zoom level is not available, or unusable, so create it */
      ResizeSpriteOut(sprite, zoom);
    }
  }
 
  /* Replace sprites with higher resolution than the desired maximum source resolution with scaled up sprites, if not already done. */
  if (first_avail < _settings_client.gui.sprite_zoom_min) {
    for (ZoomLevel zoom = std::min(ZoomLevel::Normal, _settings_client.gui.sprite_zoom_min); zoom > ZoomLevel::Min; --zoom) {
      ResizeSpriteIn(sprite, zoom, zoom - 1);
    }
  }
 
  return  true;
}
 
static void *ReadRecolourSprite(SpriteFile &file, size_t file_pos, uint num, SpriteAllocator &allocator)
{
  /* "Normal" recolour sprites are ALWAYS 257 bytes. Then there is a small
   * number of recolour sprites that are 17 bytes that only exist in DOS
   * GRFs which are the same as 257 byte recolour sprites, but with the last
   * 240 bytes zeroed.  */
  static const uint RECOLOUR_SPRITE_SIZE = 257;
  uint8_t *dest = allocator.Allocate<uint8_t>(std::max(RECOLOUR_SPRITE_SIZE, num));
 
  file.SeekTo(file_pos, SEEK_SET);
  if (file.NeedsPaletteRemap()) {
    uint8_t *dest_tmp = new uint8_t[std::max(RECOLOUR_SPRITE_SIZE, num)];
 
    /* Only a few recolour sprites are less than 257 bytes */
    if (num < RECOLOUR_SPRITE_SIZE) std::fill_n(dest_tmp, RECOLOUR_SPRITE_SIZE, 0);
    file.ReadBlock(dest_tmp, num);
 
    /* The data of index 0 is never used; "literal 00" according to the (New)GRF specs. */
    for (uint i = 1; i < RECOLOUR_SPRITE_SIZE; i++) {
      dest[i] = _palmap_w2d[dest_tmp[_palmap_d2w[i - 1] + 1]];
    }
    delete[] dest_tmp;
  } else {
    file.ReadBlock(dest, num);
  }
 
  return dest;
}
static void *ReadRecolourSprite(SpriteFile &file, size_t file_pos, uint num, SpriteAllocator &allocator) {…}
 
static void *ReadSprite(const SpriteCache *sc, SpriteID id, SpriteType sprite_type, SpriteAllocator &allocator, SpriteEncoder *encoder)
{
  /* Use current blitter if no other sprite encoder is given. */
  if (encoder == nullptr) encoder = BlitterFactory::GetCurrentBlitter();
 
  SpriteFile &file = *sc->file;
  size_t file_pos = sc->file_pos;
 
  assert(sprite_type != SpriteType::Recolour);
  assert(IsMapgenSpriteID(id) == (sprite_type == SpriteType::MapGen));
  assert(sc->type == sprite_type);
 
  Debug(sprite, 9, "Load sprite {}", id);
 
  SpriteLoader::SpriteCollection sprite;
  ZoomLevels sprite_avail;
  ZoomLevels avail_8bpp;
  ZoomLevels avail_32bpp;
 
  SpriteLoaderGrf sprite_loader(file.GetContainerVersion());
  if (sprite_type != SpriteType::MapGen && encoder->Is32BppSupported()) {
    /* Try for 32bpp sprites first. */
    sprite_avail = sprite_loader.LoadSprite(sprite, file, file_pos, sprite_type, true, sc->control_flags, avail_8bpp, avail_32bpp);
  }
  if (sprite_avail.None()) {
    sprite_avail = sprite_loader.LoadSprite(sprite, file, file_pos, sprite_type, false, sc->control_flags, avail_8bpp, avail_32bpp);
    if (sprite_type == SpriteType::Normal && avail_32bpp.Any() && !encoder->Is32BppSupported() && sprite_avail.None()) {
      /* No 8bpp available, try converting from 32bpp. */
      SpriteLoaderMakeIndexed make_indexed(sprite_loader);
      sprite_avail = make_indexed.LoadSprite(sprite, file, file_pos, sprite_type, true, sc->control_flags, sprite_avail, avail_32bpp);
    }
  }
 
  if (sprite_avail.None()) {
    if (sprite_type == SpriteType::MapGen) return nullptr;
    if (id == SPR_IMG_QUERY) UserError("Okay... something went horribly wrong. I couldn't load the fallback sprite. What should I do?");
    return (void*)GetRawSprite(SPR_IMG_QUERY, SpriteType::Normal, &allocator, encoder);
  }
 
  if (sprite_type == SpriteType::MapGen) {
    /* Ugly hack to work around the problem that the old landscape
     *  generator assumes that those sprites are stored uncompressed in
     *  the memory, and they are only read directly by the code, never
     *  send to the blitter. So do not send it to the blitter (which will
     *  result in a data array in the format the blitter likes most), but
     *  extract the data directly and store that as sprite.
     * Ugly: yes. Other solution: no. Blame the original author or
     *  something ;) The image should really have been a data-stream
     *  (so type = 0xFF basically). */
    const auto &root_sprite = sprite.Root();
    uint num = root_sprite.width * root_sprite.height;
 
    Sprite *s = allocator.Allocate<Sprite>(sizeof(*s) + num);
    s->width = root_sprite.width;
    s->height = root_sprite.height;
    s->x_offs = root_sprite.x_offs;
    s->y_offs = root_sprite.y_offs;
 
    SpriteLoader::CommonPixel *src = root_sprite.data;
    uint8_t *dest = reinterpret_cast<uint8_t *>(s->data);
    while (num-- > 0) {
      *dest++ = src->m;
      src++;
    }
 
    return s;
  }
 
  if (!ResizeSprites(sprite, sprite_avail, encoder)) {
    if (id == SPR_IMG_QUERY) UserError("Okay... something went horribly wrong. I couldn't resize the fallback sprite. What should I do?");
    return (void*)GetRawSprite(SPR_IMG_QUERY, SpriteType::Normal, &allocator, encoder);
  }
 
  if (sprite_type == SpriteType::Font && _font_zoom != ZoomLevel::Min) {
    /* Make ZoomLevel::Min be ZOOM_LVL_GUI */
    sprite[ZoomLevel::Min] = sprite[_font_zoom];
  }
 
  return encoder->Encode(sprite_type, sprite, allocator);
}
static void *ReadSprite(const SpriteCache *sc, SpriteID id, SpriteType sprite_type, SpriteAllocator &allocator, SpriteEncoder *encoder) {…}
 
struct GrfSpriteOffset {
  size_t file_pos;
  uint8_t control_flags;
};
struct GrfSpriteOffset {…};
 
static std::map<uint32_t, GrfSpriteOffset> _grf_sprite_offsets;
 
size_t GetGRFSpriteOffset(uint32_t id)
{
  return _grf_sprite_offsets.find(id) != _grf_sprite_offsets.end() ? _grf_sprite_offsets[id].file_pos : SIZE_MAX;
}
size_t GetGRFSpriteOffset(uint32_t id) {…}
 
void ReadGRFSpriteOffsets(SpriteFile &file)
{
  _grf_sprite_offsets.clear();
 
  if (file.GetContainerVersion() >= 2) {
    /* Seek to sprite section of the GRF. */
    size_t data_offset = file.ReadDword();
    size_t old_pos = file.GetPos();
    file.SeekTo(data_offset, SEEK_CUR);
 
    GrfSpriteOffset offset = { 0, 0 };
 
    /* Loop over all sprite section entries and store the file
     * offset for each newly encountered ID. */
    SpriteID id, prev_id = 0;
    while ((id = file.ReadDword()) != 0) {
      if (id != prev_id) {
        _grf_sprite_offsets[prev_id] = offset;
        offset.file_pos = file.GetPos() - 4;
        offset.control_flags = 0;
      }
      prev_id = id;
      uint length = file.ReadDword();
      if (length > 0) {
        SpriteComponents colour{file.ReadByte()};
        length--;
        if (length > 0) {
          uint8_t zoom = file.ReadByte();
          length--;
          if (colour != SpriteComponents{} && zoom == 0) { // ZoomLevel::Normal (normal zoom)
            SetBit(offset.control_flags, (colour != SpriteComponent::Palette) ? SCCF_ALLOW_ZOOM_MIN_1X_32BPP : SCCF_ALLOW_ZOOM_MIN_1X_PAL);
            SetBit(offset.control_flags, (colour != SpriteComponent::Palette) ? SCCF_ALLOW_ZOOM_MIN_2X_32BPP : SCCF_ALLOW_ZOOM_MIN_2X_PAL);
          }
          if (colour != SpriteComponents{} && zoom == 2) { // ZoomLevel::In2x (2x zoomed in)
            SetBit(offset.control_flags, (colour != SpriteComponent::Palette) ? SCCF_ALLOW_ZOOM_MIN_2X_32BPP : SCCF_ALLOW_ZOOM_MIN_2X_PAL);
          }
        }
      }
      file.SkipBytes(length);
    }
    if (prev_id != 0) _grf_sprite_offsets[prev_id] = offset;
 
    /* Continue processing the data section. */
    file.SeekTo(old_pos, SEEK_SET);
  }
}
void ReadGRFSpriteOffsets(SpriteFile &file) {…}
 
 
bool LoadNextSprite(SpriteID load_index, SpriteFile &file, uint file_sprite_id)
{
  size_t file_pos = file.GetPos();
 
  /* Read sprite header. */
  uint32_t num = file.GetContainerVersion() >= 2 ? file.ReadDword() : file.ReadWord();
  if (num == 0) return false;
  uint8_t grf_type = file.ReadByte();
 
  SpriteType type;
  void *data = nullptr;
  uint8_t control_flags = 0;
  if (grf_type == 0xFF) {
    /* Some NewGRF files have "empty" pseudo-sprites which are 1
     * byte long. Catch these so the sprites won't be displayed. */
    if (num == 1) {
      file.ReadByte();
      return false;
    }
    file_pos = file.GetPos();
    type = SpriteType::Recolour;
    file.SkipBytes(num);
  } else if (file.GetContainerVersion() >= 2 && grf_type == 0xFD) {
    if (num != 4) {
      /* Invalid sprite section include, ignore. */
      file.SkipBytes(num);
      return false;
    }
    /* It is not an error if no sprite with the provided ID is found in the sprite section. */
    auto iter = _grf_sprite_offsets.find(file.ReadDword());
    if (iter != _grf_sprite_offsets.end()) {
      file_pos = iter->second.file_pos;
      control_flags = iter->second.control_flags;
    } else {
      file_pos = SIZE_MAX;
    }
    type = SpriteType::Normal;
  } else {
    file.SkipBytes(7);
    type = SkipSpriteData(file, grf_type, num - 8) ? SpriteType::Normal : SpriteType::Invalid;
    /* Inline sprites are not supported for container version >= 2. */
    if (file.GetContainerVersion() >= 2) return false;
  }
 
  if (type == SpriteType::Invalid) return false;
 
  if (load_index >= MAX_SPRITES) {
    UserError("Tried to load too many sprites (#{}; max {})", load_index, MAX_SPRITES);
  }
 
  bool is_mapgen = IsMapgenSpriteID(load_index);
 
  if (is_mapgen) {
    if (type != SpriteType::Normal) UserError("Uhm, would you be so kind not to load a NewGRF that changes the type of the map generator sprites?");
    type = SpriteType::MapGen;
  }
 
  SpriteCache *sc = AllocateSpriteCache(load_index);
  sc->file = &file;
  sc->file_pos = file_pos;
  sc->length = num;
  sc->ptr = data;
  sc->lru = 0;
  sc->id = file_sprite_id;
  sc->type = type;
  sc->warned = false;
  sc->control_flags = control_flags;
 
  return true;
}
bool LoadNextSprite(SpriteID load_index, SpriteFile &file, uint file_sprite_id) {…}
 
 
void DupSprite(SpriteID old_spr, SpriteID new_spr)
{
  SpriteCache *scnew = AllocateSpriteCache(new_spr); // may reallocate: so put it first
  SpriteCache *scold = GetSpriteCache(old_spr);
 
  scnew->file = scold->file;
  scnew->file_pos = scold->file_pos;
  scnew->ptr = nullptr;
  scnew->id = scold->id;
  scnew->type = scold->type;
  scnew->warned = false;
  scnew->control_flags = scold->control_flags;
}
 
static const size_t S_FREE_MASK = sizeof(size_t) - 1;
 
/* to make sure nobody adds things to MemBlock without checking S_FREE_MASK first */
static_assert(sizeof(MemBlock) == sizeof(size_t));
/* make sure it's a power of two */
static_assert((sizeof(size_t) & (sizeof(size_t) - 1)) == 0);
 
static inline MemBlock *NextBlock(MemBlock *block)
{
  return (MemBlock*)((uint8_t*)block + (block->size & ~S_FREE_MASK));
}
 
static size_t GetSpriteCacheUsage()
{
  size_t tot_size = 0;
  MemBlock *s;
 
  for (s = _spritecache_ptr; s->size != 0; s = NextBlock(s)) {
    if (!(s->size & S_FREE_MASK)) tot_size += s->size;
  }
 
  return tot_size;
}
 
 
void IncreaseSpriteLRU()
{
  /* Increase all LRU values */
  if (_sprite_lru_counter > 16384) {
    Debug(sprite, 5, "Fixing lru {}, inuse={}", _sprite_lru_counter, GetSpriteCacheUsage());
 
    for (SpriteCache &sc : _spritecache) {
      if (sc.ptr != nullptr) {
        if (sc.lru >= 0) {
          sc.lru = -1;
        } else if (sc.lru != -32768) {
          sc.lru--;
        }
      }
    }
    _sprite_lru_counter = 0;
  }
 
  /* Compact sprite cache every now and then. */
  if (++_compact_cache_counter >= 740) {
    CompactSpriteCache();
    _compact_cache_counter = 0;
  }
}
 
static void CompactSpriteCache()
{
  MemBlock *s;
 
  Debug(sprite, 3, "Compacting sprite cache, inuse={}", GetSpriteCacheUsage());
 
  for (s = _spritecache_ptr; s->size != 0;) {
    if (s->size & S_FREE_MASK) {
      MemBlock *next = NextBlock(s);
      MemBlock temp;
      SpriteID i;
 
      /* Since free blocks are automatically coalesced, this should hold true. */
      assert(!(next->size & S_FREE_MASK));
 
      /* If the next block is the sentinel block, we can safely return */
      if (next->size == 0) break;
 
      /* Locate the sprite belonging to the next pointer. */
      for (i = 0; GetSpriteCache(i)->ptr != next->data; i++) {
        assert(i != _spritecache.size());
      }
 
      GetSpriteCache(i)->ptr = s->data; // Adjust sprite array entry
      /* Swap this and the next block */
      temp = *s;
      std::byte *p = reinterpret_cast<std::byte *>(next);
      std::move(p, &p[next->size], reinterpret_cast<std::byte *>(s));
      s = NextBlock(s);
      *s = temp;
 
      /* Coalesce free blocks */
      while (NextBlock(s)->size & S_FREE_MASK) {
        s->size += NextBlock(s)->size & ~S_FREE_MASK;
      }
    } else {
      s = NextBlock(s);
    }
  }
}
static void CompactSpriteCache() {…}
 
static void DeleteEntryFromSpriteCache(SpriteCache *item)
{
  /* Mark the block as free (the block must be in use) */
  MemBlock *s = static_cast<MemBlock *>(item->ptr) - 1;
  assert(!(s->size & S_FREE_MASK));
  s->size |= S_FREE_MASK;
  item->ptr = nullptr;
 
  /* And coalesce adjacent free blocks */
  for (s = _spritecache_ptr; s->size != 0; s = NextBlock(s)) {
    if (s->size & S_FREE_MASK) {
      while (NextBlock(s)->size & S_FREE_MASK) {
        s->size += NextBlock(s)->size & ~S_FREE_MASK;
      }
    }
  }
}
static void DeleteEntryFromSpriteCache(SpriteCache *item) {…}
 
static void DeleteEntryFromSpriteCache()
{
  Debug(sprite, 3, "DeleteEntryFromSpriteCache, inuse={}", GetSpriteCacheUsage());
 
  SpriteCache *best = nullptr;
  int cur_lru = 0xffff;
  for (SpriteCache &sc : _spritecache) {
    if (sc.ptr != nullptr && sc.lru < cur_lru) {
      cur_lru = sc.lru;
      best = &sc;
    }
  }
 
  /* Display an error message and die, in case we found no sprite at all.
   * This shouldn't really happen, unless all sprites are locked. */
  if (best == nullptr) FatalError("Out of sprite memory");
 
  DeleteEntryFromSpriteCache(best);
}
 
void *CacheSpriteAllocator::AllocatePtr(size_t mem_req)
{
  mem_req += sizeof(MemBlock);
 
  /* Align this to correct boundary. This also makes sure at least one
   * bit is not used, so we can use it for other things. */
  mem_req = Align(mem_req, S_FREE_MASK + 1);
 
  for (;;) {
    MemBlock *s;
 
    for (s = _spritecache_ptr; s->size != 0; s = NextBlock(s)) {
      if (s->size & S_FREE_MASK) {
        size_t cur_size = s->size & ~S_FREE_MASK;
 
        /* Is the block exactly the size we need or
         * big enough for an additional free block? */
        if (cur_size == mem_req ||
            cur_size >= mem_req + sizeof(MemBlock)) {
          /* Set size and in use */
          s->size = mem_req;
 
          /* Do we need to inject a free block too? */
          if (cur_size != mem_req) {
            NextBlock(s)->size = (cur_size - mem_req) | S_FREE_MASK;
          }
 
          return s->data;
        }
      }
    }
 
    /* Reached sentinel, but no block found yet. Delete some old entry. */
    DeleteEntryFromSpriteCache();
  }
}
void *CacheSpriteAllocator::AllocatePtr(size_t mem_req) {…}
 
void *UniquePtrSpriteAllocator::AllocatePtr(size_t size)
{
  this->data = std::make_unique<std::byte[]>(size);
  return this->data.get();
}
void *UniquePtrSpriteAllocator::AllocatePtr(size_t size) {…}
 
static void *HandleInvalidSpriteRequest(SpriteID sprite, SpriteType requested, SpriteCache *sc, SpriteAllocator *allocator)
{
  static const std::string_view sprite_types[] = {
    "normal",        // SpriteType::Normal
    "map generator", // SpriteType::MapGen
    "character",     // SpriteType::Font
    "recolour",      // SpriteType::Recolour
  };
 
  SpriteType available = sc->type;
  if (requested == SpriteType::Font && available == SpriteType::Normal) {
    if (sc->ptr == nullptr) sc->type = SpriteType::Font;
    return GetRawSprite(sprite, sc->type, allocator);
  }
 
  uint8_t warning_level = sc->warned ? 6 : 0;
  sc->warned = true;
  Debug(sprite, warning_level, "Tried to load {} sprite #{} as a {} sprite. Probable cause: NewGRF interference", sprite_types[static_cast<uint8_t>(available)], sprite, sprite_types[static_cast<uint8_t>(requested)]);
 
  switch (requested) {
    case SpriteType::Normal:
      if (sprite == SPR_IMG_QUERY) UserError("Uhm, would you be so kind not to load a NewGRF that makes the 'query' sprite a non-normal sprite?");
      [[fallthrough]];
    case SpriteType::Font:
      return GetRawSprite(SPR_IMG_QUERY, SpriteType::Normal, allocator);
    case SpriteType::Recolour:
      if (sprite == PALETTE_TO_DARK_BLUE) UserError("Uhm, would you be so kind not to load a NewGRF that makes the 'PALETTE_TO_DARK_BLUE' sprite a non-remap sprite?");
      return GetRawSprite(PALETTE_TO_DARK_BLUE, SpriteType::Recolour, allocator);
    case SpriteType::MapGen:
      /* this shouldn't happen, overriding of SpriteType::MapGen sprites is checked in LoadNextSprite()
       * (the only case the check fails is when these sprites weren't even loaded...) */
    default:
      NOT_REACHED();
  }
}
static void *HandleInvalidSpriteRequest(SpriteID sprite, SpriteType requested, SpriteCache *sc, SpriteAllocator *allocator) {…}
 
void *GetRawSprite(SpriteID sprite, SpriteType type, SpriteAllocator *allocator, SpriteEncoder *encoder)
{
  assert(type != SpriteType::MapGen || IsMapgenSpriteID(sprite));
  assert(type < SpriteType::Invalid);
 
  if (!SpriteExists(sprite)) {
    Debug(sprite, 1, "Tried to load non-existing sprite #{}. Probable cause: Wrong/missing NewGRFs", sprite);
 
    /* SPR_IMG_QUERY is a BIG FAT RED ? */
    sprite = SPR_IMG_QUERY;
  }
 
  SpriteCache *sc = GetSpriteCache(sprite);
 
  if (sc->type != type) return HandleInvalidSpriteRequest(sprite, type, sc, allocator);
 
  if (allocator == nullptr && encoder == nullptr) {
    /* Load sprite into/from spritecache */
    CacheSpriteAllocator cache_allocator;
 
    /* Update LRU */
    sc->lru = ++_sprite_lru_counter;
 
    /* Load the sprite, if it is not loaded, yet */
    if (sc->ptr == nullptr) {
      if (sc->type == SpriteType::Recolour) {
        sc->ptr = ReadRecolourSprite(*sc->file, sc->file_pos, sc->length, cache_allocator);
      } else {
        sc->ptr = ReadSprite(sc, sprite, type, cache_allocator, nullptr);
      }
    }
 
    return sc->ptr;
  } else {
    /* Do not use the spritecache, but a different allocator. */
    return ReadSprite(sc, sprite, type, *allocator, encoder);
  }
}
void *GetRawSprite(SpriteID sprite, SpriteType type, SpriteAllocator *allocator, SpriteEncoder *encoder) {…}
 
 
static void GfxInitSpriteCache()
{
  /* initialize sprite cache heap */
  int bpp = BlitterFactory::GetCurrentBlitter()->GetScreenDepth();
  uint target_size = (bpp > 0 ? _sprite_cache_size * bpp / 8 : 1) * 1024 * 1024;
 
  /* Remember 'target_size' from the previous allocation attempt, so we do not try to reach the target_size multiple times in case of failure. */
  static uint last_alloc_attempt = 0;
 
  if (_spritecache_ptr == nullptr || (_allocated_sprite_cache_size != target_size && target_size != last_alloc_attempt)) {
    delete[] reinterpret_cast<uint8_t *>(_spritecache_ptr);
 
    last_alloc_attempt = target_size;
    _allocated_sprite_cache_size = target_size;
 
    do {
      /* Try to allocate 50% more to make sure we do not allocate almost all available. */
      _spritecache_ptr = reinterpret_cast<MemBlock *>(new(std::nothrow) uint8_t[_allocated_sprite_cache_size + _allocated_sprite_cache_size / 2]);
 
      if (_spritecache_ptr != nullptr) {
        /* Allocation succeeded, but we wanted less. */
        delete[] reinterpret_cast<uint8_t *>(_spritecache_ptr);
        _spritecache_ptr = reinterpret_cast<MemBlock *>(new uint8_t[_allocated_sprite_cache_size]);
      } else if (_allocated_sprite_cache_size < 2 * 1024 * 1024) {
        UserError("Cannot allocate spritecache");
      } else {
        /* Try again to allocate half. */
        _allocated_sprite_cache_size >>= 1;
      }
    } while (_spritecache_ptr == nullptr);
 
    if (_allocated_sprite_cache_size != target_size) {
      Debug(misc, 0, "Not enough memory to allocate {} MiB of spritecache. Spritecache was reduced to {} MiB.", target_size / 1024 / 1024, _allocated_sprite_cache_size / 1024 / 1024);
 
      ErrorMessageData msg(GetEncodedString(STR_CONFIG_ERROR_OUT_OF_MEMORY), GetEncodedString(STR_CONFIG_ERROR_SPRITECACHE_TOO_BIG, target_size, _allocated_sprite_cache_size));
      ScheduleErrorMessage(msg);
    }
  }
 
  /* A big free block */
  _spritecache_ptr->size = (_allocated_sprite_cache_size - sizeof(MemBlock)) | S_FREE_MASK;
  /* Sentinel block (identified by size == 0) */
  NextBlock(_spritecache_ptr)->size = 0;
}
 
void GfxInitSpriteMem()
{
  GfxInitSpriteCache();
 
  /* Reset the spritecache 'pool' */
  _spritecache.clear();
  _spritecache.shrink_to_fit();
 
  _compact_cache_counter = 0;
  _sprite_files.clear();
}
 
void GfxClearSpriteCache()
{
  /* Clear sprite ptr for all cached items */
  for (SpriteCache &sc : _spritecache) {
    if (sc.ptr != nullptr) DeleteEntryFromSpriteCache(&sc);
  }
 
  VideoDriver::GetInstance()->ClearSystemSprites();
}
void GfxClearSpriteCache() {…}
 
void GfxClearFontSpriteCache()
{
  /* Clear sprite ptr for all cached font items */
  for (SpriteCache &sc : _spritecache) {
    if (sc.type == SpriteType::Font && sc.ptr != nullptr) DeleteEntryFromSpriteCache(&sc);
  }
}
void GfxClearFontSpriteCache() {…}
 
/* static */ SpriteCollMap<ReusableBuffer<SpriteLoader::CommonPixel>> SpriteLoader::Sprite::buffer;