epub_img_import.c

Go to the documentation of this file.

 
#if __has_include("ra8_tile_cache.h") && __has_include("jof.h")
 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "epub.h"
#include "epub_entry.h"
#include "epub_img_tiles.h"
#include "jof.h"
#include "jof_produce.h"
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"

typedef enum : uint8_t {
  k_epub_import_magic_len = 4U, 
} epub_import_const_t;

typedef struct {
  epub_entry_reader_t reader; 
} epub_entry_pull_t;

RA8_INTERNAL
static ra8_err_t internal_entry_pull(void* ctx, uint8_t* buf, size_t cap, size_t* got)
{
  epub_entry_pull_t* pull = (epub_entry_pull_t*)ctx;
  return epub_entry_read(&pull->reader, buf, cap, got);
}

RA8_INTERNAL
static ra8_err_t internal_classify(epub_book_t* book, const char* href, bool* out_is_atlas)
{
  static const uint8_t s_atlas_magic[k_epub_import_magic_len] = {'J', 'O', 'F', '1'};
  *out_is_atlas                                               = false;
  uint8_t         magic[k_epub_import_magic_len]              = {};
  size_t          got                                         = 0U;
  const ra8_err_t err = epub_entry_pread(book, href, 0U, magic, sizeof(magic), &got);
  if (err == k_ra8_err_not_supported) {
    return k_ra8_ok; /* deflated entry: cannot be an in-place atlas */
  }
  if (err != k_ra8_ok) {
    return err;
  }
  if ((got == sizeof(magic)) && (memcmp(magic, s_atlas_magic, sizeof(magic)) == 0)) {
    *out_is_atlas = true;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_transcode(epub_book_t*                   book,
                                    const char*                    href,
                                    const epub_atlas_import_cfg_t* cfg,
                                    jof_info_t*                    out_info)
{
  epub_entry_pull_t pull = {};
  uint64_t          size = 0U;
  ra8_err_t         err  = epub_entry_open(book, href, &pull.reader, &size);
  if (err != k_ra8_ok) {
    return err;
  }
  const jof_produce_cfg_t pcfg = {
    .pull          = internal_entry_pull,
    .pull_ctx      = &pull,
    .sink          = cfg->store.sink,
    .sink_ctx      = cfg->store.sink_ctx,
    .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,
  };
  err                       = jof_produce(&pcfg, out_info);
  const ra8_err_t close_err = epub_entry_close(&pull.reader);
  return (err != k_ra8_ok) ? err : close_err;
}

RA8_INTERNAL
static ra8_err_t internal_import_args_ok(const epub_tile_binder_t*      binder,
                                         const epub_book_t*             book,
                                         const char*                    href,
                                         const epub_atlas_import_cfg_t* cfg)
{
  static const char* const s_tag = "epub_img_import";
  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(href, s_tag, "href must not be nullptr");
  RA8_CHECK_NULL_PTR(cfg, s_tag, "cfg must not be nullptr");
  RA8_CHECK_NULL_PTR(cfg->store.sink, s_tag, "store.sink must not be nullptr");
  RA8_CHECK_NULL_PTR(cfg->store.pread, s_tag, "store.pread must not be nullptr");
  return k_ra8_ok;
}
 
ra8_err_t epub_tile_binder_import(epub_tile_binder_t*            binder,
                                  epub_book_t*                   book,
                                  const char*                    href,
                                  uint32_t                       image_id,
                                  const epub_atlas_import_cfg_t* cfg)
{
  const ra8_err_t nz = internal_import_args_ok(binder, book, href, cfg);
  if (nz != k_ra8_ok) {
    return nz;
  }
  const size_t hlen = strlen(href);
  if ((hlen == 0U) || (hlen >= (size_t)k_epub_max_path_len)) {
    return k_ra8_err_invalid_arg;
  }
  bool      is_atlas = false;
  ra8_err_t err      = internal_classify(book, href, &is_atlas);
  if (err != k_ra8_ok) {
    return err;
  }
  if (is_atlas) {
    return epub_tile_binder_add(binder, book, href, image_id); /* in-place */
  }
  jof_info_t info = {};
  err             = internal_transcode(book, href, cfg, &info);
  if (err != k_ra8_ok) {
    return err;
  }
  return epub_tile_binder_add_ext(binder,
                                  cfg->store.pread,
                                  cfg->store.pread_ctx,
                                  (uint64_t)info.total_size,
                                  image_id);
}
 
#else
/* ra8_mem tile cache / atlas producer not on the include path for this app:
 * the import wiring is unused here. A single typedef keeps the translation
 * unit non-empty. */
typedef int epub_img_import_unused_translation_unit_t;
#endif /* __has_include("ra8_tile_cache.h") && __has_include("jof.h") */