epub_img_tiles.c

Go to the documentation of this file.

 
/* Compile the binder only where the ra8_mem tile cache and the atlas reader
 * are on the include path (reflow / ra8_mem consumers and the host test
 * build). Otherwise empty. */
#if __has_include("ra8_tile_cache.h") && __has_include("jof.h")
 
#include "epub_img_tiles.h"
 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "epub.h"
#include "epub_entry.h"
#include "jof.h"
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_tile_cache.h"

static const char* const s_tag = "epub_img_tiles";
 
/* ---------------------------------------------------------------------------
 * Small helpers.
 * ---------------------------------------------------------------------------
 */

RA8_INTERNAL
static int32_t internal_find(const epub_tile_binder_t* binder, uint32_t image_id)
{
  for (uint8_t i = 0U; i < binder->source_count; ++i) {
    if (binder->sources[i].image_id == image_id) {
      return (int32_t)i;
    }
  }
  return -1;
}

RA8_INTERNAL
static ra8_err_t
internal_entry_pread(void* ctx, uint64_t offset, uint8_t* buf, size_t len, size_t* got)
{
  const epub_tile_source_t* src = (const epub_tile_source_t*)ctx;
  return epub_entry_pread(src->book, src->path, offset, buf, len, got);
}

RA8_INTERNAL
static ra8_err_t internal_measure_entry(epub_book_t* book, const char* path, uint64_t* out_size)
{
  epub_entry_reader_t reader = {};
  ra8_err_t           err    = epub_entry_open(book, path, &reader, out_size);
  if (err != k_ra8_ok) {
    return err;
  }
  err = epub_entry_close(&reader);
  return err;
}
 
/* ---------------------------------------------------------------------------
 * Tile decode-on-miss.
 * ---------------------------------------------------------------------------
 */

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)
{
  epub_tile_binder_t* binder = (epub_tile_binder_t*)ctx;
  const int32_t       si     = internal_find(binder, key->image_id);
  if (si < 0) {
    return k_ra8_err_not_found; /* GCOVR_EXCL_LINE -- get() rejects unregistered ids before cache */
  }
  epub_tile_source_t* src   = &binder->sources[si];
  const jof_pread_fn  pread = (src->book != nullptr) ? internal_entry_pread : src->pread;
  void*               pctx  = (src->book != nullptr) ? (void*)src : src->pread_ctx;
  const ra8_err_t     err   = jof_read_tile(pread,
                                            pctx,
                                            &src->info,
                                            key->tile_x,
                                            key->tile_y,
                                            binder->scratch,
                                            binder->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;
}
 
/* ---------------------------------------------------------------------------
 * Public API -- tile binder.
 * ---------------------------------------------------------------------------
 */
 
ra8_err_t epub_tile_binder_init(epub_tile_binder_t*         binder,
                                const ra8_tile_cache_cfg_t* storage,
                                uint8_t*                    scratch,
                                uint32_t                    scratch_cap)
{
  RA8_CHECK_NULL_PTR(binder, s_tag, "binder must not be nullptr");
  RA8_CHECK_NULL_PTR(storage, s_tag, "storage must not be nullptr");
  (void)memset(binder, 0, sizeof(*binder));
  binder->scratch          = scratch;
  binder->scratch_cap      = (scratch != nullptr) ? scratch_cap : 0U;
  ra8_tile_cache_cfg_t cfg = *storage;
  cfg.decode               = internal_tile_decode;
  cfg.decode_ctx           = binder;
  return ra8_tile_cache_init(&binder->cache, &cfg);
}

RA8_INTERNAL
static ra8_err_t internal_check_slot(const epub_tile_binder_t* binder, uint32_t image_id)
{
  if (binder->source_count >= (uint8_t)k_epub_tile_max_sources) {
    return k_ra8_err_no_mem;
  }
  if (internal_find(binder, image_id) >= 0) {
    return k_ra8_err_invalid_arg;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_fill_book_source(epub_tile_source_t* src,
                                           epub_book_t*        book,
                                           const char*         path,
                                           size_t              plen,
                                           uint32_t            image_id)
{
  src->book     = book;
  src->image_id = image_id;
  (void)memcpy(src->path, path, plen + 1U);
  ra8_err_t err = internal_measure_entry(book, path, &src->total_size);
  if (err == k_ra8_ok) {
    err = jof_parse(internal_entry_pread, src, src->total_size, &src->info);
  }
  if (err != k_ra8_ok) {
    (void)memset(src, 0, sizeof(*src));
  }
  return err;
}
 
ra8_err_t epub_tile_binder_add(epub_tile_binder_t* binder,
                               epub_book_t*        book,
                               const char*         path,
                               uint32_t            image_id)
{
  RA8_CHECK_NULL_PTR(binder, s_tag, "binder must not be nullptr");
  RA8_CHECK_NULL_PTR(book, s_tag, "book must not be nullptr");
  RA8_CHECK_NULL_PTR(path, s_tag, "path must not be nullptr");
  const size_t plen = strlen(path);
  if ((plen == 0U) || (plen >= (size_t)k_epub_max_path_len)) {
    return k_ra8_err_invalid_arg;
  }
  ra8_err_t err = internal_check_slot(binder, image_id);
  if (err != k_ra8_ok) {
    return err;
  }
  epub_tile_source_t* src = &binder->sources[binder->source_count];
  (void)memset(src, 0, sizeof(*src));
  err = internal_fill_book_source(src, book, path, plen, image_id);
  if (err != k_ra8_ok) {
    return err;
  }
  binder->source_count++;
  return k_ra8_ok;
}
 
ra8_err_t epub_tile_binder_add_ext(epub_tile_binder_t* binder,
                                   jof_pread_fn        pread,
                                   void*               pread_ctx,
                                   uint64_t            total_size,
                                   uint32_t            image_id)
{
  RA8_CHECK_NULL_PTR(binder, s_tag, "binder must not be nullptr");
  RA8_CHECK_NULL_PTR(pread, s_tag, "pread must not be nullptr");
  ra8_err_t err = internal_check_slot(binder, image_id);
  if (err != k_ra8_ok) {
    return err;
  }
  epub_tile_source_t* src = &binder->sources[binder->source_count];
  (void)memset(src, 0, sizeof(*src));
  src->pread      = pread;
  src->pread_ctx  = pread_ctx;
  src->total_size = total_size;
  src->image_id   = image_id;
  err             = jof_parse(pread, pread_ctx, total_size, &src->info);
  if (err != k_ra8_ok) {
    (void)memset(src, 0, sizeof(*src));
    return err;
  }
  binder->source_count++;
  return k_ra8_ok;
}
 
ra8_err_t
epub_tile_binder_info(const epub_tile_binder_t* binder, uint32_t image_id, jof_info_t* out_info)
{
  RA8_CHECK_NULL_PTR(binder, s_tag, "binder must not be nullptr");
  RA8_CHECK_NULL_PTR(out_info, s_tag, "out_info must not be nullptr");
  const int32_t si = internal_find(binder, image_id);
  if (si < 0) {
    return k_ra8_err_not_found;
  }
  *out_info = binder->sources[si].info;
  return k_ra8_ok;
}
 
ra8_err_t epub_tile_binder_get(epub_tile_binder_t* binder,
                               uint32_t            image_id,
                               uint16_t            tile_x,
                               uint16_t            tile_y,
                               ra8_tile_t*         out_tile)
{
  RA8_CHECK_NULL_PTR(binder, s_tag, "binder must not be nullptr");
  RA8_CHECK_NULL_PTR(out_tile, s_tag, "out_tile must not be nullptr");
  const int32_t si = internal_find(binder, image_id);
  if (si < 0) {
    return k_ra8_err_not_found;
  }
  const jof_info_t* info = &binder->sources[si].info;
  if (tile_x >= info->tile_cols) {
    return k_ra8_err_out_of_range;
  }
  if (tile_y >= info->tile_rows) {
    return k_ra8_err_out_of_range;
  }
  const ra8_tile_key_t key = {.image_id = image_id, .tile_x = tile_x, .tile_y = tile_y};
  return ra8_tile_cache_get(&binder->cache, &key, out_tile);
}
 
ra8_err_t epub_tile_binder_put(epub_tile_binder_t* binder, const uint8_t* pixels)
{
  RA8_CHECK_NULL_PTR(binder, s_tag, "binder must not be nullptr");
  RA8_CHECK_NULL_PTR(pixels, s_tag, "pixels must not be nullptr");
  return ra8_tile_cache_put(&binder->cache, pixels);
}
 
ra8_err_t epub_tile_binder_prefetch_pan(epub_tile_binder_t*    binder,
                                        uint32_t               image_id,
                                        const ra8_tile_rect_t* view,
                                        ra8_tile_pan_dir_t     dir,
                                        uint16_t               max_tiles,
                                        uint16_t*              out_warmed)
{
  RA8_CHECK_NULL_PTR(binder, s_tag, "binder must not be nullptr");
  RA8_CHECK_NULL_PTR(view, s_tag, "view must not be nullptr");
  const int32_t si = internal_find(binder, image_id);
  if (si < 0) {
    return k_ra8_err_not_found;
  }
  const jof_info_t*             info = &binder->sources[si].info;
  const ra8_tile_prefetch_req_t req  = {.image_id  = image_id,
                                        .view      = *view,
                                        .tile_cols = info->tile_cols,
                                        .tile_rows = info->tile_rows,
                                        .zoom      = 0U,
                                        .max_tiles = max_tiles,
                                        .dir       = dir};
  return ra8_tile_cache_prefetch_pan(&binder->cache, &req, out_warmed);
}
 
/* ---------------------------------------------------------------------------
 * Public API -- reflow img loader.
 * ---------------------------------------------------------------------------
 */

RA8_INTERNAL
static ra8_err_t internal_loader_args_ok(const epub_img_loader_t* ld, uint32_t href_len)
{
  if (ld->book == nullptr) {
    return k_ra8_err_invalid_arg;
  }
  if (ld->scratch == nullptr) {
    return k_ra8_err_invalid_arg;
  }
  if (ld->scratch_cap == 0U) {
    return k_ra8_err_invalid_arg;
  }
  if (href_len == 0U) {
    return k_ra8_err_invalid_arg;
  }
  if (href_len >= (uint32_t)k_epub_max_path_len) {
    return k_ra8_err_invalid_arg;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_loader_null_ok(const void*     ctx,
                                         const char*     href,
                                         const uint8_t** out_bytes,
                                         const size_t*   out_len)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx must not be nullptr");
  RA8_CHECK_NULL_PTR(href, s_tag, "href must not be nullptr");
  RA8_CHECK_NULL_PTR(out_bytes, s_tag, "out_bytes must not be nullptr");
  RA8_CHECK_NULL_PTR(out_len, s_tag, "out_len must not be nullptr");
  return k_ra8_ok;
}
 
ra8_err_t epub_reflow_img_load(void*           ctx,
                               const char*     href,
                               uint32_t        href_len,
                               const uint8_t** out_bytes,
                               size_t*         out_len)
{
  const ra8_err_t nz = internal_loader_null_ok(ctx, href, out_bytes, out_len);
  if (nz != k_ra8_ok) {
    return nz;
  }
  *out_len              = 0U;
  epub_img_loader_t* ld = (epub_img_loader_t*)ctx;
  const ra8_err_t    ok = internal_loader_args_ok(ld, href_len);
  if (ok != k_ra8_ok) {
    return ok;
  }
  char path[k_epub_max_path_len];
  (void)memcpy(path, href, (size_t)href_len);
  path[href_len] = '\0';
 
  size_t          got = 0U;
  const ra8_err_t err = epub_get_resource(ld->book, path, ld->scratch, ld->scratch_cap, &got);
  if (err != k_ra8_ok) {
    return err;
  }
  *out_bytes = ld->scratch;
  *out_len   = got;
  return k_ra8_ok;
}
 
#else
/* ra8_mem tile cache / atlas reader not on the include path for this app: the
 * EPUB image-tile binder is unused here. A single typedef keeps the
 * translation unit non-empty. */
typedef int epub_img_tiles_unused_translation_unit_t;
#endif /* __has_include("ra8_tile_cache.h") && __has_include("jof.h") */