ra8_rabook_pipeline.c

Go to the documentation of this file.

 
#include "ra8_rabook_pipeline.h"
 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "book.h"
#include "epub.h"
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_fs.h"
#include "ra8_img_arena.h"
#include "ra8_log.h"
#include "ra8_rabook_gray4.h"
#include "ra8_rabook_pipeline_internal.h"
#include "ra8_rabook_xml_shim.h"
#include "rabook_compile.h"
#include "reflow_image.h"
#include "stb_image.h"
 
/* -------------------------------------------------------------------------- */
/* Private constants */
/* -------------------------------------------------------------------------- */

typedef enum : uint16_t {
  k_pipeline_max_chapters = 64U, 
  k_pipeline_max_toc      = 64U, 
} ra8_pipeline_limits_t;
 
static_assert((uint16_t)k_pipeline_max_chapters == (uint16_t)k_epub_max_chapters,
              "pipeline chapter cap must match epub cap");
static_assert((uint16_t)k_pipeline_max_toc == (uint16_t)k_epub_max_toc,
              "pipeline toc cap must match epub cap");

typedef enum : uint8_t {
  k_stbi_grey = 1U, 
} ra8_pipeline_stbi_t;
 
static const char* const s_tag = "ra8_rabook_pipeline";
 
/* -------------------------------------------------------------------------- */
/* Private helpers */
/* -------------------------------------------------------------------------- */
 
/* The raster image path (stb_image decode + gray4 transcode) is compiled out of a
 * RA8_RABOOK_NO_RASTER build -- e.g. the Cortex-M33 text/CSS/SVG-only image, which
 * then links no stb_image. SVG images are stored verbatim and need none of this. */
#ifndef RA8_RABOOK_NO_RASTER

RA8_INTERNAL
static const uint8_t* internal_downscale_if_needed(const ra8_rabook_pipeline_scratch_t* scr,
                                                   const uint8_t*                       pixels,
                                                   uint16_t                             sw,
                                                   uint16_t                             sh,
                                                   uint16_t                             ow,
                                                   uint16_t                             oh)
{
  if ((ow == sw) && (oh == sh)) {
    return pixels;
  }
  if (((uint32_t)ow * (uint32_t)oh) > scr->gray_cap) {
    ra8_log_error(s_tag, "gray scratch too small for downscale");
    return nullptr;
  }
  if (ra8_rabook_gray4_downscale(pixels, sw, sh, scr->gray, ow, oh) != k_ra8_ok) {
    return nullptr;
  }
  return scr->gray;
}

RA8_INTERNAL
static ra8_err_t internal_encode_gray(const ra8_rabook_pipeline_scratch_t* scr,
                                      const uint8_t*                       gray_src,
                                      uint16_t                             ow,
                                      uint16_t                             oh,
                                      uint32_t*                            out_size)
{
  if (scr->pixel_format == (uint8_t)k_book_pixfmt_gray8) {
    return ra8_rabook_gray8_encode(gray_src,
                                   ow,
                                   oh,
                                   scr->image_raw,
                                   (uint32_t)scr->image_cap,
                                   out_size);
  }
  return ra8_rabook_gray4_encode(gray_src,
                                 ow,
                                 oh,
                                 scr->image_raw,
                                 (uint32_t)scr->image_cap,
                                 out_size);
}

RA8_INTERNAL
static uint32_t internal_transcode_image(ra8_rabook_ctx_t*                    ctx,
                                         const ra8_rabook_pipeline_scratch_t* scr,
                                         uint32_t                             id_off,
                                         size_t                               raw_len)
{
  int sw   = 0;
  int sh   = 0;
  int comp = 0;
  ra8_img_arena_bind(scr->img_arena);
  stbi_uc* pixels =
    stbi_load_from_memory(scr->image_raw, /* alloc-allow: stb backed by ra8_img_arena */
                          (int)raw_len,
                          &sw,
                          &sh,
                          &comp,
                          (int)k_stbi_grey);
  if (pixels == nullptr) {
    ra8_img_arena_unbind();
    ra8_log_error(s_tag, "stb_image decode failed");
    return k_book_nil;
  }
 
  /* Downscale is opt-in: max_image_edge == 0 (the default) preserves the
   * source resolution so zoomable content (manga pages) keeps every pixel. */
  uint16_t ow = (uint16_t)sw;
  uint16_t oh = (uint16_t)sh;
  if (scr->max_image_edge != 0U) {
    ra8_rabook_gray4_output_dims((uint16_t)sw, (uint16_t)sh, scr->max_image_edge, &ow, &oh);
  }
 
  const uint8_t* gray_src =
    internal_downscale_if_needed(scr, pixels, (uint16_t)sw, (uint16_t)sh, ow, oh);
  if (gray_src == nullptr) {
    stbi_image_free(pixels); /* alloc-allow: stb backed by ra8_img_arena */
    ra8_img_arena_unbind();
    return k_book_nil;
  }
 
  uint32_t  encoded_size = 0U;
  ra8_err_t enc_err      = internal_encode_gray(scr, gray_src, ow, oh, &encoded_size);
  stbi_image_free(pixels); /* alloc-allow: stb backed by ra8_img_arena */
  ra8_img_arena_unbind();
 
  if (enc_err != k_ra8_ok) {
    return k_book_nil;
  }
 
  return ra8_rabook_add_image(ctx,
                              id_off,
                              ow,
                              oh,
                              (uint8_t)k_book_image_gray4,
                              scr->pixel_format,
                              scr->image_raw,
                              encoded_size);
}
 
#endif /* RA8_RABOOK_NO_RASTER -- raster transcode helpers */

RA8_INTERNAL
static const char* internal_chapter_title(const epub_book_t* epub,
                                          uint16_t           chapter_idx,
                                          uint16_t           toc_count,
                                          epub_toc_entry_t*  entry_buf)
{
  for (uint16_t ti = 0U; ti < toc_count; ti++) {
    uint16_t ch_idx = 0U;
    if ((epub_toc_entry_to_chapter(epub, ti, &ch_idx) == k_ra8_ok) && (ch_idx == chapter_idx)) {
      if (epub_get_toc_entry(epub, ti, entry_buf) == k_ra8_ok) {
        return entry_buf->title;
      }
      break;
    }
  }
  return "";
}

RA8_PRIV ra8_err_t priv_rabook_pipeline_check_common(const epub_book_t*                   epub,
                                                     const ra8_rabook_buffers_t*          bufs,
                                                     const ra8_rabook_pipeline_scratch_t* scr)
{
  RA8_CHECK_NULL_PTR(epub, s_tag, "epub");
  RA8_CHECK_NULL_PTR(bufs, s_tag, "bufs");
  RA8_CHECK_NULL_PTR(scr, s_tag, "scr");
  RA8_CHECK_NULL_PTR(scr->xml_workspace, s_tag, "scr->xml_workspace");
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_compile_stylesheets(ra8_rabook_ctx_t*                    ctx,
                                              const ra8_rabook_pipeline_scratch_t* scr,
                                              epub_book_t*                         epub)
{
  const uint16_t count = epub_manifest_count(epub);
  for (uint16_t i = 0U; i < count; i++) {
    const epub_manifest_item_t* item = epub_manifest_item(epub, i);
    if (item == nullptr) {
      continue;
    }
    if (strcmp(item->media_type, "text/css") != 0) {
      continue;
    }
    size_t    got = 0U;
    ra8_err_t err =
      epub_get_resource(epub, item->href, (uint8_t*)scr->css, scr->css_cap - 1U, &got);
    if (err == k_ra8_err_not_found) {
      continue; /* desktop skips a css item absent from the archive */
    }
    if (err != k_ra8_ok) {
      return err;
    }
    scr->css[got]             = '\0';
    const uint32_t source_off = ra8_rabook_intern(ctx, scr->css);
    (void)ra8_rabook_add_stylesheet(ctx, source_off, (uint32_t)k_book_nil);
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static uint32_t internal_add_manifest_image(ra8_rabook_ctx_t*                    ctx,
                                            const ra8_rabook_pipeline_scratch_t* scr,
                                            epub_book_t*                         epub,
                                            const epub_manifest_item_t*          item)
{
  const char* const img_prefix = "image/";
  uint8_t           fmt        = (uint8_t)k_book_image_gray4;
  if (strcmp(item->media_type, "image/svg+xml") == 0) {
    fmt = (uint8_t)k_book_image_svg;
  } else if (strncmp(item->media_type, img_prefix, strlen(img_prefix)) != 0) {
    return (uint32_t)k_book_nil; /* not an image item */
  } else {
    /* All remaining image media types use the raster decode path below. */
  }
 
#ifdef RA8_RABOOK_NO_RASTER
  if (fmt != (uint8_t)k_book_image_svg) {
    ra8_log_error(s_tag, "raster image skipped (text/CSS/SVG-only build)");
    return (uint32_t)k_book_nil;
  }
#endif
 
  size_t    got = 0U;
  ra8_err_t err = epub_get_resource(epub, item->href, scr->image_raw, scr->image_cap, &got);
  if (err != k_ra8_ok) {
    return (uint32_t)k_book_nil; /* absent / unreadable -> skip, like the desktop */
  }
 
  const uint32_t id_off = ra8_rabook_intern(ctx, item->href);
  if (fmt == (uint8_t)k_book_image_svg) {
    return ra8_rabook_add_image(ctx,
                                id_off,
                                0U,
                                0U,
                                (uint8_t)k_book_image_svg,
                                (uint8_t)k_book_pixfmt_gray4, /* unused for SVG; store 0 */
                                scr->image_raw,
                                (uint32_t)got);
  }
#ifndef RA8_RABOOK_NO_RASTER
  return internal_transcode_image(ctx, scr, id_off, got);
#else
  return (uint32_t)k_book_nil; /* unreachable: raster returned nil above */
#endif
}

RA8_INTERNAL
static ra8_err_t internal_compile_images(ra8_rabook_ctx_t*                    ctx,
                                         const ra8_rabook_pipeline_scratch_t* scr,
                                         epub_book_t*                         epub,
                                         uint32_t*                            cover_index_out)
{
  *cover_index_out = (uint32_t)k_book_nil;
  if (scr->skip_images) {
    return k_ra8_ok; /* desktop --no-images: empty image loop, cover stays nil */
  }
  const uint16_t count = epub_manifest_count(epub);
  for (uint16_t i = 0U; i < count; i++) {
    const epub_manifest_item_t* item = epub_manifest_item(epub, i);
    if (item == nullptr) {
      continue;
    }
    const uint32_t idx = internal_add_manifest_image(ctx, scr, epub, item);
    if (idx == (uint32_t)k_book_nil) {
      continue;
    }
    if (strcmp(item->href, epub->cover_path) == 0) {
      *cover_index_out = idx;
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_compile_chapters(epub_book_t*                         epub,
                                           const ra8_rabook_pipeline_scratch_t* scr,
                                           ra8_rabook_ctx_t*                    ctx)
{
  uint16_t  chapter_count = 0U;
  ra8_err_t err           = epub_get_chapter_count(epub, &chapter_count);
  if (err != k_ra8_ok) {
    return err;
  }
 
  uint16_t toc_count = 0U;
  (void)epub_get_toc_count(epub, &toc_count);
 
  epub_toc_entry_t toc_entry = {};
 
  for (uint16_t ci = 0U; ci < chapter_count; ci++) {
    size_t got_len = 0U;
    err            = epub_load_chapter(epub, ci, scr->xhtml, scr->xhtml_cap, &got_len);
    if (err != k_ra8_ok) {
      return err;
    }
 
    const char* ch_title = internal_chapter_title(epub, ci, toc_count, &toc_entry);
    const char* ch_href  = epub->chapter_paths[ci];
 
    err =
      ra8_rabook_xml_parse_chapter(scr->xhtml, got_len, ctx, ch_href, ch_title, scr->xml_workspace);
    if (err != k_ra8_ok) {
      return err;
    }
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t
internal_compile_metadata(ra8_rabook_ctx_t* ctx, epub_book_t* epub, uint32_t cover_image_index)
{
  epub_metadata_t meta = {};
  ra8_err_t       err  = epub_get_metadata(epub, &meta);
  if (err != k_ra8_ok) {
    return err;
  }
  const uint32_t title_off      = ra8_rabook_intern(ctx, meta.title);
  const uint32_t author_off     = ra8_rabook_intern(ctx, meta.author);
  const uint32_t language_off   = ra8_rabook_intern(ctx, meta.language);
  const uint32_t identifier_off = ra8_rabook_intern(ctx, meta.identifier);
  return ra8_rabook_set_metadata(ctx,
                                 title_off,
                                 author_off,
                                 language_off,
                                 identifier_off,
                                 cover_image_index);
}

RA8_INTERNAL
static ra8_err_t internal_compile_to_blob(epub_book_t*                         epub,
                                          const ra8_rabook_buffers_t*          bufs,
                                          const ra8_rabook_pipeline_scratch_t* scr,
                                          const void**                         out_blob,
                                          uint32_t*                            out_len)
{
  ra8_rabook_ctx_t ctx = {};
  ra8_err_t        err = rabook_compile_init(&ctx, bufs);
  if (err != k_ra8_ok) {
    return err;
  }
  /* Emit in the desktop epub_compile.py order so the blob is byte-identical:
   * stylesheets, images (cover resolved within), chapters, metadata interned LAST. */
  err = internal_compile_stylesheets(&ctx, scr, epub);
  if (err != k_ra8_ok) {
    return err;
  }
  uint32_t cover_image_index = (uint32_t)k_book_nil;
  err                        = internal_compile_images(&ctx, scr, epub, &cover_image_index);
  if (err != k_ra8_ok) {
    return err;
  }
  err = internal_compile_chapters(epub, scr, &ctx);
  if (err != k_ra8_ok) {
    return err;
  }
  err = internal_compile_metadata(&ctx, epub, cover_image_index);
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_rabook_finalize(&ctx, out_blob, out_len);
}
 
/* -------------------------------------------------------------------------- */
/* Public API */
/* -------------------------------------------------------------------------- */
 
ra8_err_t rabook_compile_from_epub_to_buffer(epub_book_t*                         epub,
                                             const ra8_rabook_buffers_t*          bufs,
                                             const ra8_rabook_pipeline_scratch_t* scr,
                                             const void**                         out_blob,
                                             uint32_t*                            out_len)
{
  ra8_err_t err = priv_rabook_pipeline_check_common(epub, bufs, scr);
  if (err != k_ra8_ok) {
    return err;
  }
  RA8_CHECK_NULL_PTR(out_blob, s_tag, "out_blob");
  RA8_CHECK_NULL_PTR(out_len, s_tag, "out_len");
  return internal_compile_to_blob(epub, bufs, scr, out_blob, out_len);
}