ra8_rabook_comic.c

Go to the documentation of this file.

 
#include "ra8_rabook_comic.h"
 
#include <stddef.h>
#include <stdint.h>
 
#include "book.h"
#include "ra8_attributes.h"

RA8_INTERNAL static bool internal_string_is_bounded(const char* text)
{
  if (text == nullptr) {
    return false;
  }
  for (uint16_t i = 0U; i < (uint16_t)k_ra8_rabook_comic_string_max; ++i) {
    if (text[i] == '\0') {
      return true;
    }
  }
  return false;
}

RA8_INTERNAL static ra8_err_t
internal_intern(ra8_rabook_ctx_t* builder, const char* text, uint32_t* out_off)
{
  const uint32_t off = ra8_rabook_intern(builder, text);
  if (off == (uint32_t)k_book_nil) {
    return k_ra8_err_no_mem;
  }
  *out_off = off;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_append_chapter(ra8_rabook_comic_t* comic,
                                                      uint32_t            page_id_off)
{
  uint32_t  body_off = 0U;
  uint32_t  img_off  = 0U;
  uint32_t  src_off  = 0U;
  ra8_err_t result   = internal_intern(&comic->builder, "body", &body_off);
  if (result == k_ra8_ok) {
    result = internal_intern(&comic->builder, "img", &img_off);
  }
  if (result == k_ra8_ok) {
    result = internal_intern(&comic->builder, "src", &src_off);
  }
  const book_attr_t source = {.name_off = src_off, .value_off = page_id_off};
  const uint32_t    body   = (result == k_ra8_ok)
                               ? ra8_rabook_add_element(&comic->builder, body_off, nullptr, 0U)
                               : (uint32_t)k_book_nil;
  const uint32_t    image  = (body != (uint32_t)k_book_nil)
                               ? ra8_rabook_add_element(&comic->builder, img_off, &source, 1U)
                               : (uint32_t)k_book_nil;
  if ((body == (uint32_t)k_book_nil) || (image == (uint32_t)k_book_nil)) {
    return (result == k_ra8_ok) ? k_ra8_err_no_mem : result;
  }
  result = ra8_rabook_link_child(&comic->builder, body, image);
  if (result != k_ra8_ok) {
    return result;
  }
  if (ra8_rabook_add_chapter(&comic->builder, page_id_off, page_id_off, body) ==
      (uint32_t)k_book_nil) {
    return k_ra8_err_no_mem;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_store_image(ra8_rabook_comic_t*               comic,
                                                   uint32_t                          page_id_off,
                                                   const ra8_rabook_raster_result_t* raster)
{
  const uint32_t offset  = comic->builder.image_pool_size;
  uint32_t       written = 0U;
  ra8_err_t      result =
    comic->image_write(comic->image_ctx, offset, comic->normalized, raster->encoded_size, &written);
  if (result != k_ra8_ok) {
    return result;
  }
  if (written != raster->encoded_size) {
    return k_ra8_err_invalid_size;
  }
  uint32_t       recorded_offset = 0U;
  const uint32_t image           = ra8_rabook_add_image_external(&comic->builder,
                                                                 page_id_off,
                                                                 raster->width,
                                                                 raster->height,
                                                                 (uint8_t)k_book_image_gray4,
                                                                 raster->pixel_format,
                                                                 raster->encoded_size,
                                                                 &recorded_offset);
  if (image == (uint32_t)k_book_nil) {
    return k_ra8_err_no_mem;
  }
  if (recorded_offset != offset) {
    comic->builder.failed = true;
    return k_ra8_err_validation_failed;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_set_metadata(ra8_rabook_comic_t*                comic,
                                                    const ra8_rabook_comic_metadata_t* metadata)
{
  if (metadata == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (!internal_string_is_bounded(metadata->title) ||
      !internal_string_is_bounded(metadata->author) ||
      !internal_string_is_bounded(metadata->language) ||
      !internal_string_is_bounded(metadata->identifier)) {
    return k_ra8_err_invalid_size;
  }
  uint32_t          fields[] = {0U, 0U, 0U, 0U};
  const char* const values[] = {metadata->title,
                                metadata->author,
                                metadata->language,
                                metadata->identifier};
  for (size_t i = 0U; i < (sizeof(values) / sizeof(values[0])); ++i) {
    const ra8_err_t result = internal_intern(&comic->builder, values[i], &fields[i]);
    if (result != k_ra8_ok) {
      return result;
    }
  }
  return ra8_rabook_set_metadata(&comic->builder, fields[0], fields[1], fields[2], fields[3], 0U);
}
 
ra8_err_t ra8_rabook_comic_init(ra8_rabook_comic_t*                 comic,
                                const ra8_rabook_comic_workspace_t* workspace,
                                ra8_rabook_image_read_fn            image_read,
                                ra8_rabook_comic_write_at_fn        image_write,
                                void*                               image_ctx,
                                uint16_t                            max_image_edge,
                                uint8_t                             pixel_format)
{
  if (comic == nullptr) {
    return k_ra8_err_null_ptr;
  }
  *comic = (ra8_rabook_comic_t){};
  if ((workspace == nullptr) || (image_read == nullptr) || (image_write == nullptr) ||
      (image_ctx == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if ((workspace->normalized == nullptr) || (workspace->stream_scratch == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if ((workspace->normalized_cap == 0U) || (workspace->stream_scratch_cap == 0U)) {
    return k_ra8_err_invalid_size;
  }
  if ((pixel_format != (uint8_t)k_book_pixfmt_gray4) &&
      (pixel_format != (uint8_t)k_book_pixfmt_gray8)) {
    return k_ra8_err_invalid_arg;
  }
  ra8_err_t result = rabook_compile_init(&comic->builder, &workspace->builder);
  if (result == k_ra8_ok) {
    comic->raster             = workspace->raster;
    comic->image_read         = image_read;
    comic->image_write        = image_write;
    comic->image_ctx          = image_ctx;
    comic->normalized         = workspace->normalized;
    comic->normalized_cap     = workspace->normalized_cap;
    comic->stream_scratch     = workspace->stream_scratch;
    comic->stream_scratch_cap = workspace->stream_scratch_cap;
    comic->max_image_edge     = max_image_edge;
    comic->pixel_format       = pixel_format;
    comic->active             = true;
  }
  return result;
}
 
ra8_err_t ra8_rabook_comic_add_page(ra8_rabook_comic_t* comic,
                                    const char*         page_id,
                                    const uint8_t*      source,
                                    size_t              source_size)
{
  if (comic == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (!comic->active) {
    return k_ra8_err_invalid_state;
  }
  if ((page_id == nullptr) || (source == nullptr) || (source_size == 0U)) {
    comic->active = false;
    return k_ra8_err_invalid_arg;
  }
  if (!internal_string_is_bounded(page_id)) {
    comic->active = false;
    return k_ra8_err_invalid_size;
  }
  ra8_rabook_raster_result_t raster      = {};
  ra8_err_t                  result      = ra8_rabook_raster_encode(source,
                                                                    source_size,
                                                                    comic->max_image_edge,
                                                                    comic->pixel_format,
                                                                    &comic->raster,
                                                                    comic->normalized,
                                                                    comic->normalized_cap,
                                                                    &raster);
  uint32_t                   page_id_off = 0U;
  if (result == k_ra8_ok) {
    result = internal_intern(&comic->builder, page_id, &page_id_off);
  }
  if (result == k_ra8_ok) {
    result = internal_store_image(comic, page_id_off, &raster);
  }
  if (result == k_ra8_ok) {
    result = internal_append_chapter(comic, page_id_off);
  }
  if (result == k_ra8_ok) {
    comic->page_count++;
  } else {
    comic->active = false;
  }
  return result;
}
 
ra8_err_t ra8_rabook_comic_finish(ra8_rabook_comic_t*                comic,
                                  const ra8_rabook_comic_metadata_t* metadata,
                                  ra8_rabook_write_fn                write,
                                  void*                              write_ctx,
                                  uint32_t*                          out_len)
{
  if (comic == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (!comic->active) {
    return k_ra8_err_invalid_state;
  }
  comic->active = false;
  if ((write == nullptr) || (write_ctx == nullptr) || (out_len == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if (comic->page_count == 0U) {
    return k_ra8_err_empty;
  }
  ra8_err_t result = internal_set_metadata(comic, metadata);
  if (result == k_ra8_ok) {
    result = ra8_rabook_finalize_stream(&comic->builder,
                                        comic->image_read,
                                        comic->image_ctx,
                                        write,
                                        write_ctx,
                                        comic->stream_scratch,
                                        comic->stream_scratch_cap,
                                        out_len);
  }
  return result;
}