comic_tiles.c

Go to the documentation of this file.

 
/* Compile the tile reader only where the ra8_mem tile cache and the JOF atlas
 * reader/producer are on the include path (tiling comic apps + the host test
 * build). Otherwise empty. */
#if __has_include("ra8_tile_cache.h") && __has_include("jof.h")
 
#include "comic_tiles.h"
 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "jof.h"
#include "jof_produce.h"
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_tile_cache.h"

static const char* const s_tag = "comic_tiles";

typedef struct {
  const uint8_t* d;   
  size_t         n;   
  size_t         off; 
} comic_tiles_pull_t;

RA8_INTERNAL static ra8_err_t internal_mem_pull(void* ctx, uint8_t* buf, size_t cap, size_t* got)
{
  comic_tiles_pull_t* p      = (comic_tiles_pull_t*)ctx;
  const size_t        remain = p->n - p->off;
  const size_t        k      = (cap < remain) ? cap : remain;
  if (k > 0U) {
    (void)memcpy(buf, &p->d[p->off], k);
  }
  p->off += k;
  *got = k;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_tile_decode(void*                 ctx,
                                                   const ra8_tile_key_t* key,
                                                   uint8_t*              cell,
                                                   uint32_t              cell_bytes,
                                                   uint16_t*             out_w,
                                                   uint16_t*             out_h)
{
  comic_tile_reader_t* r   = (comic_tile_reader_t*)ctx;
  const ra8_err_t      err = jof_read_tile(jof_memstore_pread,
                                           &r->store,
                                           &r->info,
                                           key->tile_x,
                                           key->tile_y,
                                           r->scratch,
                                           r->scratch_cap,
                                           cell,
                                           cell_bytes,
                                           out_w,
                                           out_h);
  if (err == k_ra8_err_invalid_size) {
    return k_ra8_err_no_mem; /* tile exceeds the cell / scratch budget */
  }
  return err;
}
 
ra8_err_t comic_tiles_footprint(const uint8_t* enc,
                                size_t         len,
                                uint16_t*      out_w,
                                uint16_t*      out_h,
                                uint64_t*      out_decoded_bytes)
{
  RA8_CHECK_NULL_PTR(enc, s_tag, "footprint: null enc");
  RA8_CHECK_NULL_PTR(out_w, s_tag, "footprint: null out_w");
  RA8_CHECK_NULL_PTR(out_h, s_tag, "footprint: null out_h");
  RA8_CHECK_NULL_PTR(out_decoded_bytes, s_tag, "footprint: null out_decoded_bytes");
  if (len == 0U) {
    return k_ra8_err_invalid_size;
  }
  uint16_t        w   = 0U;
  uint16_t        h   = 0U;
  const ra8_err_t err = jof_probe_dims(enc, len, &w, &h);
  if (err != k_ra8_ok) {
    return err;
  }
  *out_w             = w;
  *out_h             = h;
  *out_decoded_bytes = (uint64_t)w * (uint64_t)h * (uint64_t)k_comic_tiles_decoded_bpp;
  return k_ra8_ok;
}
 
bool comic_tiles_over_budget(uint64_t decoded_bytes, uint64_t budget_bytes)
{
  return (budget_bytes != 0U) && (decoded_bytes > budget_bytes);
}
 
ra8_err_t comic_tiles_init(comic_tile_reader_t*        r,
                           const ra8_tile_cache_cfg_t* storage,
                           uint8_t*                    scratch,
                           uint32_t                    scratch_cap)
{
  RA8_CHECK_NULL_PTR(r, s_tag, "init: null r");
  RA8_CHECK_NULL_PTR(storage, s_tag, "init: null storage");
  (void)memset(r, 0, sizeof(*r));
  r->scratch               = scratch;
  r->scratch_cap           = (scratch != nullptr) ? scratch_cap : 0U;
  ra8_tile_cache_cfg_t cfg = *storage;
  cfg.decode               = internal_tile_decode;
  cfg.decode_ctx           = r;
  return ra8_tile_cache_init(&r->cache, &cfg);
}

RA8_INTERNAL static ra8_err_t internal_import_args_ok(const comic_tile_reader_t*      r,
                                                      const uint8_t*                  enc,
                                                      const comic_tiles_import_cfg_t* cfg)
{
  RA8_CHECK_NULL_PTR(r, s_tag, "import: null r");
  RA8_CHECK_NULL_PTR(enc, s_tag, "import: null enc");
  RA8_CHECK_NULL_PTR(cfg, s_tag, "import: null cfg");
  RA8_CHECK_NULL_PTR(cfg->work, s_tag, "import: null work");
  RA8_CHECK_NULL_PTR(cfg->atlas, s_tag, "import: null atlas");
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_transcode(comic_tile_reader_t*            r,
                                                 const uint8_t*                  enc,
                                                 size_t                          enc_len,
                                                 const comic_tiles_import_cfg_t* cfg)
{
  r->store = (jof_memstore_t){.buf = cfg->atlas, .cap = cfg->atlas_cap, .len = 0U};
  comic_tiles_pull_t      pull = {.d = enc, .n = enc_len, .off = 0U};
  const jof_produce_cfg_t pcfg = {
    .pull          = internal_mem_pull,
    .pull_ctx      = &pull,
    .sink          = jof_memstore_sink,
    .sink_ctx      = &r->store,
    .tile_w        = cfg->tile_w,
    .tile_h        = cfg->tile_h,
    .codec         = cfg->codec,
    .max_width     = cfg->max_width,
    .max_height    = cfg->max_height,
    .work          = cfg->work,
    .work_cap      = cfg->work_cap,
    .webp_work     = cfg->webp_work,
    .webp_work_cap = cfg->webp_work_cap,
  };
  jof_info_t      produced = {};
  const ra8_err_t perr     = jof_produce(&pcfg, &produced);
  if (perr != k_ra8_ok) {
    return perr;
  }
  return jof_parse(jof_memstore_pread, &r->store, (uint64_t)r->store.len, &r->info);
}
 
ra8_err_t comic_tiles_import(comic_tile_reader_t*            r,
                             const uint8_t*                  enc,
                             size_t                          enc_len,
                             const comic_tiles_import_cfg_t* cfg)
{
  const ra8_err_t nz = internal_import_args_ok(r, enc, cfg);
  if (nz != k_ra8_ok) {
    return nz;
  }
  if (enc_len == 0U) {
    return k_ra8_err_invalid_size;
  }
  r->bound            = false; /* invalidate first: any error leaves no bound page */
  const ra8_err_t err = internal_transcode(r, enc, enc_len, cfg);
  if (err != k_ra8_ok) {
    return err;
  }
  r->epoch += 1U;
  r->bound = true;
  return k_ra8_ok;
}
 
ra8_err_t comic_tiles_info(const comic_tile_reader_t* r, jof_info_t* out_info)
{
  RA8_CHECK_NULL_PTR(r, s_tag, "info: null r");
  RA8_CHECK_NULL_PTR(out_info, s_tag, "info: null out_info");
  if (!r->bound) {
    return k_ra8_err_invalid_state;
  }
  *out_info = r->info;
  return k_ra8_ok;
}
 
ra8_err_t
comic_tiles_tile(comic_tile_reader_t* r, uint16_t tile_x, uint16_t tile_y, ra8_tile_t* out_tile)
{
  RA8_CHECK_NULL_PTR(r, s_tag, "tile: null r");
  RA8_CHECK_NULL_PTR(out_tile, s_tag, "tile: null out_tile");
  if (!r->bound) {
    return k_ra8_err_invalid_state;
  }
  if (tile_x >= r->info.tile_cols) {
    return k_ra8_err_out_of_range;
  }
  if (tile_y >= r->info.tile_rows) {
    return k_ra8_err_out_of_range;
  }
  const ra8_tile_key_t key = {.image_id = r->epoch,
                              .tile_x   = tile_x,
                              .tile_y   = tile_y,
                              .zoom     = 0U,
                              .reserved = 0U};
  return ra8_tile_cache_get(&r->cache, &key, out_tile);
}
 
ra8_err_t comic_tiles_release(comic_tile_reader_t* r, const uint8_t* pixels)
{
  RA8_CHECK_NULL_PTR(r, s_tag, "release: null r");
  RA8_CHECK_NULL_PTR(pixels, s_tag, "release: null pixels");
  return ra8_tile_cache_put(&r->cache, pixels);
}
 
#else
/* ra8_mem tile cache / JOF atlas reader not on the include path for this app:
 * the comic tile reader is unused here (the whole-decode path stands alone). A
 * single typedef keeps the translation unit non-empty. */
typedef int comic_tiles_unused_translation_unit_t;
#endif /* __has_include("ra8_tile_cache.h") && __has_include("jof.h") */