cm_tiled_check.c

Go to the documentation of this file.

 
#include "cm_tiled_check.h"
 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "comic.h"
#include "comic_large_fixture.h"
#include "comic_tiles.h"
#include "jof.h"
#include "jof_produce.h"
#include "ra8_err.h"
#include "ra8_tile_cache.h"

typedef enum : uint32_t {
  k_ct_tile       = 256U,                                  
  k_ct_bpp_gray   = 1U,                                    
  k_ct_cell_bytes = k_ct_tile * k_ct_tile * k_ct_bpp_gray, 
  k_ct_cells      = 8U,                                    
  k_ct_buckets    = 16U,                                   
  k_ct_budget     = 2U * 1024U * 1024U,                    
  k_ct_pagebuf    = 64U * 1024U,                           
  k_ct_work       = 2U * 1024U * 1024U,                    
  k_ct_atlas      = 2U * 1024U * 1024U,                    
  k_ct_scratch    = 96U * 1024U,                           
  k_ct_page_cap   = 4U,                                    
  k_ct_name_cap   = 64U,                                   
  k_ct_fnv_offset = 2166136261U,                           
  k_ct_fnv_prime  = 16777619U,                             
} cm_tiled_cfg_t;

typedef struct {
  const uint8_t* d; 
  size_t         n; 
} cm_ct_blob_t;

[[gnu::section(".sdram_data")]] static uint8_t s_ct_pagebuf[k_ct_pagebuf];
[[gnu::section(".sdram_data")]] static uint8_t s_ct_work[k_ct_work];
[[gnu::section(".sdram_data")]] static uint8_t s_ct_atlas[k_ct_atlas];
[[gnu::section(
  ".sdram_data")]] static uint8_t s_ct_cells[(size_t)k_ct_cells * (size_t)k_ct_cell_bytes];
[[gnu::section(".sdram_data")]] static uint8_t s_ct_scratch[k_ct_scratch];
[[gnu::section(".sdram_data")]] static comic_page_t s_ct_pages[k_ct_page_cap];
[[gnu::section(".sdram_data")]] static char s_ct_names[k_ct_name_cap];
[[gnu::section(".sdram_data")]] static comic_t s_ct_comic;
[[gnu::section(".sdram_data")]] static comic_tile_reader_t s_ct_reader;
static ra8_tile_key_t s_ct_keys[k_ct_cells];
static ra8_tile_dims_t s_ct_dims[k_ct_cells];
static ra8_keycache_cell_t s_ct_meta[k_ct_cells];
static int32_t s_ct_buckets[k_ct_buckets];
static cm_ct_blob_t s_ct_blob;

// cppcheck-suppress constParameterCallback -- ctx is pinned by the comic_read_fn vtable signature
static size_t cm_ct_read(void* ctx, uint64_t off, void* buf, size_t len)
{
  const cm_ct_blob_t* s = (const cm_ct_blob_t*)ctx;
  if ((s == nullptr) || (buf == nullptr) || (off >= (uint64_t)s->n)) {
    return 0U;
  }
  const uint64_t avail = (uint64_t)s->n - off;
  const size_t   k     = (len > (size_t)avail) ? (size_t)avail : len;
  (void)memcpy(buf, &s->d[off], k);
  return k;
}

static uint32_t cm_ct_fnv(uint32_t h, const uint8_t* p, size_t n)
{
  for (size_t i = 0U; i < n; ++i) {
    h = (h ^ (uint32_t)p[i]) * (uint32_t)k_ct_fnv_prime;
  }
  return h;
}

static bool cm_ct_open(size_t* out_got)
{
  s_ct_blob.d = k_comic_large_cbz;
  s_ct_blob.n = (size_t)k_comic_large_cbz_len;
  if (comic_open(&s_ct_comic,
                 cm_ct_read,
                 &s_ct_blob,
                 (uint64_t)k_comic_large_cbz_len,
                 s_ct_pages,
                 (uint32_t)k_ct_page_cap,
                 s_ct_names,
                 (uint32_t)k_ct_name_cap) != k_ra8_ok) {
    return false;
  }
  if (comic_page_count(&s_ct_comic) == 0U) {
    return false;
  }
  *out_got = 0U;
  return comic_page_read(&s_ct_comic, 0U, s_ct_pagebuf, sizeof s_ct_pagebuf, out_got) == k_ra8_ok;
}

static bool cm_ct_hash_tiles(const jof_info_t* info, uint32_t* out_crc)
{
  uint32_t crc = (uint32_t)k_ct_fnv_offset;
  for (uint16_t ty = 0U; ty < info->tile_rows; ++ty) {
    for (uint16_t tx = 0U; tx < info->tile_cols; ++tx) {
      ra8_tile_t tile = {};
      if (comic_tiles_tile(&s_ct_reader, tx, ty, &tile) != k_ra8_ok) {
        return false;
      }
      const size_t n = (size_t)tile.width * (size_t)tile.height * (size_t)info->bpp;
      crc            = cm_ct_fnv(crc, tile.pixels, n);
      if (comic_tiles_release(&s_ct_reader, tile.pixels) != k_ra8_ok) {
        return false;
      }
    }
  }
  *out_crc = crc;
  return true;
}

static ra8_tile_cache_cfg_t cm_ct_cache_cfg(void)
{
  return (ra8_tile_cache_cfg_t){
    .cell_mem     = s_ct_cells,
    .cell_bytes   = (uint32_t)k_ct_cell_bytes,
    .cell_count   = (uint32_t)k_ct_cells,
    .meta         = s_ct_meta,
    .keys         = s_ct_keys,
    .dims         = s_ct_dims,
    .buckets      = s_ct_buckets,
    .bucket_count = (uint32_t)k_ct_buckets,
    .decode       = nullptr,
    .decode_ctx   = nullptr,
  };
}
 
cm_tiled_result_t cm_comic_tiled_selfcheck(void)
{
  cm_tiled_result_t r   = {};
  size_t            got = 0U;
  if (!cm_ct_open(&got)) {
    return r;
  }
  uint16_t w   = 0U;
  uint16_t h   = 0U;
  uint64_t dec = 0U;
  if (comic_tiles_footprint(s_ct_pagebuf, got, &w, &h, &dec) != k_ra8_ok) {
    (void)comic_close(&s_ct_comic);
    return r;
  }
  if (!comic_tiles_over_budget(dec, (uint64_t)k_ct_budget)) {
    (void)comic_close(&s_ct_comic);
    return r; /* fixture must be oversized; a fit page is not the case under test */
  }
  ra8_tile_cache_cfg_t storage = cm_ct_cache_cfg();
  if (comic_tiles_init(&s_ct_reader, &storage, s_ct_scratch, (uint32_t)k_ct_scratch) != k_ra8_ok) {
    (void)comic_close(&s_ct_comic);
    return r;
  }
  const comic_tiles_import_cfg_t cfg = {
    .tile_w        = (uint16_t)k_ct_tile,
    .tile_h        = (uint16_t)k_ct_tile,
    .codec         = (uint8_t)k_jof_codec_deflate,
    .max_width     = (uint16_t)k_comic_large_w,
    .max_height    = (uint16_t)k_comic_large_h,
    .work          = s_ct_work,
    .work_cap      = sizeof s_ct_work,
    .webp_work     = nullptr,
    .webp_work_cap = 0U,
    .atlas         = s_ct_atlas,
    .atlas_cap     = sizeof s_ct_atlas,
  };
  if (comic_tiles_import(&s_ct_reader, s_ct_pagebuf, got, &cfg) != k_ra8_ok) {
    (void)comic_close(&s_ct_comic);
    return r;
  }
  jof_info_t info = {};
  if (comic_tiles_info(&s_ct_reader, &info) != k_ra8_ok) {
    (void)comic_close(&s_ct_comic);
    return r;
  }
  uint32_t crc = 0U;
  r.ok         = cm_ct_hash_tiles(&info, &crc);
  r.w          = (uint32_t)info.width;
  r.h          = (uint32_t)info.height;
  r.tiles      = info.tile_count;
  r.crc        = r.ok ? crc : 0U;
  (void)comic_close(&s_ct_comic);
  return r;
}