mdl_export_rabook.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <string.h>
 
#include "book.h"
#include "mdl_export_rabook_internal.h"
#include "miniz.h"
#include "ra8_rabook_container.h"
#include "ra8_rabook_pipeline.h"

typedef enum : uint32_t {
  k_rabook_page_cap          = 47U,                 
  k_rabook_chapter_cap       = 48U,                 
  k_rabook_node_cap          = 512U,                
  k_rabook_attr_cap          = 256U,                
  k_rabook_style_cap         = 4U,                  
  k_rabook_image_cap         = 48U,                 
  k_rabook_string_bytes      = 256U * 1024U,        
  k_rabook_image_pool_bytes  = 24U * 1024U * 1024U, 
  k_rabook_flat_bytes        = 26U * 1024U * 1024U, 
  k_rabook_xhtml_bytes       = 64U * 1024U,         
  k_rabook_image_raw_bytes   = 8U * 1024U * 1024U,  
  k_rabook_image_arena_bytes = 20U * 1024U * 1024U, 
  k_rabook_gray_bytes        = 1024U * 1024U,       
  k_rabook_css_bytes         = 64U * 1024U,         
  k_rabook_max_image_edge    = 1024U,               
  k_rabook_chunk_bytes       = 1024U * 1024U,       
  k_rabook_compressed_bytes  = k_rabook_chunk_bytes + (64U * 1024U),
  k_rabook_offset_entries = 64U, 
} mdl_rabook_profile_limit_t;

typedef struct {
  epub_book_t*                     book;        
  ra8_rabook_buffers_t             builder;     
  ra8_rabook_pipeline_scratch_t    pipeline;    
  ra8_img_arena_t                  image_arena; 
  ra8_rabook_container_workspace_t container;   
} mdl_rabook_profile_t;

RA8_INTERNAL static ra8_err_t internal_allocate_builder(mdl_export_workspace_t* workspace,
                                                        mdl_rabook_profile_t*   profile)
{
  ra8_rabook_buffers_t* const builder = &profile->builder;
  builder->chapters = mdl_export_workspace_take(workspace,
                                                k_rabook_chapter_cap * sizeof(*builder->chapters),
                                                _Alignof(book_chapter_t));
  builder->nodes    = mdl_export_workspace_take(workspace,
                                                k_rabook_node_cap * sizeof(*builder->nodes),
                                                _Alignof(book_node_t));
  builder->attrs    = mdl_export_workspace_take(workspace,
                                                k_rabook_attr_cap * sizeof(*builder->attrs),
                                                _Alignof(book_attr_t));
  builder->stylesheets =
    mdl_export_workspace_take(workspace,
                              k_rabook_style_cap * sizeof(*builder->stylesheets),
                              _Alignof(book_stylesheet_t));
  builder->images      = mdl_export_workspace_take(workspace,
                                                   k_rabook_image_cap * sizeof(*builder->images),
                                                   _Alignof(book_image_t));
  builder->string_pool = mdl_export_workspace_take(workspace, k_rabook_string_bytes, 1U);
  builder->image_pool =
    mdl_export_workspace_take(workspace, k_rabook_image_pool_bytes, _Alignof(max_align_t));
  builder->out = mdl_export_workspace_take(workspace, k_rabook_flat_bytes, _Alignof(max_align_t));
  if ((builder->chapters == nullptr) || (builder->nodes == nullptr) ||
      (builder->attrs == nullptr) || (builder->stylesheets == nullptr) ||
      (builder->images == nullptr) || (builder->string_pool == nullptr) ||
      (builder->image_pool == nullptr) || (builder->out == nullptr)) {
    return k_ra8_err_invalid_size;
  }
  builder->chapter_cap    = k_rabook_chapter_cap;
  builder->node_cap       = k_rabook_node_cap;
  builder->attr_cap       = k_rabook_attr_cap;
  builder->stylesheet_cap = k_rabook_style_cap;
  builder->image_cap      = k_rabook_image_cap;
  builder->string_cap     = k_rabook_string_bytes;
  builder->image_pool_cap = k_rabook_image_pool_bytes;
  builder->out_cap        = k_rabook_flat_bytes;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_allocate_pipeline(mdl_export_workspace_t* workspace,
                                                         mdl_rabook_profile_t*   profile)
{
  profile->book =
    mdl_export_workspace_take(workspace, sizeof(*profile->book), _Alignof(epub_book_t));
  uint8_t* xhtml = mdl_export_workspace_take(workspace, k_rabook_xhtml_bytes, 1U);
  uint8_t* raw =
    mdl_export_workspace_take(workspace, k_rabook_image_raw_bytes, _Alignof(max_align_t));
  uint8_t* arena =
    mdl_export_workspace_take(workspace, k_rabook_image_arena_bytes, _Alignof(max_align_t));
  uint8_t* gray = mdl_export_workspace_take(workspace, k_rabook_gray_bytes, _Alignof(max_align_t));
  char*    css  = mdl_export_workspace_take(workspace, k_rabook_css_bytes, 1U);
  ra8_rabook_xml_workspace_t* xml =
    mdl_export_workspace_take(workspace, sizeof(*xml), _Alignof(ra8_rabook_xml_workspace_t));
  if ((profile->book == nullptr) || (xhtml == nullptr) || (raw == nullptr) || (arena == nullptr) ||
      (gray == nullptr) || (css == nullptr) || (xml == nullptr)) {
    return k_ra8_err_invalid_size;
  }
  profile->image_arena = (ra8_img_arena_t){.base = arena, .cap = k_rabook_image_arena_bytes};
  profile->pipeline    = (ra8_rabook_pipeline_scratch_t){.xhtml          = xhtml,
                                                         .xhtml_cap      = k_rabook_xhtml_bytes,
                                                         .image_raw      = raw,
                                                         .image_cap      = k_rabook_image_raw_bytes,
                                                         .img_arena      = &profile->image_arena,
                                                         .gray           = gray,
                                                         .gray_cap       = k_rabook_gray_bytes,
                                                         .css            = css,
                                                         .css_cap        = k_rabook_css_bytes,
                                                         .max_image_edge = k_rabook_max_image_edge,
                                                         .pixel_format   = k_book_pixfmt_gray4,
                                                         .xml_workspace  = xml};
  (void)memset(profile->book, 0, sizeof(*profile->book));
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_allocate_container(mdl_export_workspace_t* workspace,
                                                          mdl_rabook_profile_t*   profile)
{
  ra8_rabook_container_workspace_t* const container = &profile->container;
  container->input =
    mdl_export_workspace_take(workspace, k_rabook_chunk_bytes, _Alignof(max_align_t));
  container->compressed =
    mdl_export_workspace_take(workspace, k_rabook_compressed_bytes, _Alignof(max_align_t));
  container->compressor =
    mdl_export_workspace_take(workspace, sizeof(tdefl_compressor), _Alignof(max_align_t));
  container->offsets =
    mdl_export_workspace_take(workspace,
                              k_rabook_offset_entries * sizeof(*container->offsets),
                              _Alignof(uint64_t));
  if ((container->input == nullptr) || (container->compressed == nullptr) ||
      (container->compressor == nullptr) || (container->offsets == nullptr)) {
    return k_ra8_err_invalid_size;
  }
  container->input_cap      = k_rabook_chunk_bytes;
  container->compressed_cap = k_rabook_compressed_bytes;
  container->compressor_cap = sizeof(tdefl_compressor);
  container->offset_cap     = k_rabook_offset_entries;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_allocate_profile(mdl_export_workspace_t* workspace,
                                                        mdl_rabook_profile_t*   profile)
{
  *profile        = (mdl_rabook_profile_t){};
  ra8_err_t error = internal_allocate_builder(workspace, profile);
  if (error == k_ra8_ok) {
    error = internal_allocate_pipeline(workspace, profile);
  }
  if (error == k_ra8_ok) {
    error = internal_allocate_container(workspace, profile);
  }
  return error;
}

RA8_INTERNAL static ra8_err_t internal_write_temp_epub(mdl_storage_t*           storage,
                                                       const char*              directory,
                                                       char                     names[][k_name_max],
                                                       size_t                   count,
                                                       const char*              destination,
                                                       const mdl_export_meta_t* meta,
                                                       mdl_export_workspace_t*  workspace,
                                                       char*                    temp_path,
                                                       bool*                    temp_exists)
{
  *temp_exists               = false;
  mdl_export_output_t output = {};
  ra8_err_t           error  = priv_mdl_rabook_temp_begin(&output,
                                                          storage,
                                                          directory,
                                                          destination,
                                                          temp_path,
                                                          k_fw_fs_path_cap);
  if (error == k_ra8_ok) {
    error = priv_mdl_export_epub(storage, directory, names, count, &output, meta, workspace);
  }
  if ((error != k_ra8_ok) && output.writer.transaction.active) {
    const ra8_err_t aborted = priv_mdl_export_output_abort(&output);
    return (aborted == k_ra8_ok) ? error : aborted;
  }
  if (error == k_ra8_ok) {
    error = priv_mdl_export_output_commit(&output, workspace, temp_exists);
  }
  return error;
}

RA8_INTERNAL static ra8_err_t
internal_close_compile_sources(ra8_err_t error, epub_book_t* book, mdl_rabook_epub_source_t* source)
{
  ra8_err_t result = error;
  if ((book != nullptr) && (book->in_use != 0U)) {
    const ra8_err_t closed = epub_close(book);
    if ((result == k_ra8_ok) && (closed != k_ra8_ok)) {
      result = closed;
    }
  }
  if (source->file.is_open) {
    const ra8_err_t closed = priv_mdl_rabook_epub_close(source);
    if ((result == k_ra8_ok) && (closed != k_ra8_ok)) {
      result = closed;
    }
  }
  return result;
}

RA8_INTERNAL static ra8_err_t internal_check_compiled_page_count(const void* blob,
                                                                 size_t      page_count)
{
  const book_header_t* header         = book_header(blob);
  const uint32_t       expected_pages = (uint32_t)page_count;
  if ((header->chapter_count != expected_pages) || (header->image_count < expected_pages) ||
      (header->image_count > (expected_pages + 1U))) {
    return k_ra8_err_validation_failed;
  }
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_compile_temp(mdl_storage_t*            storage,
                                                    const char*               temp_path,
                                                    size_t                    page_count,
                                                    mdl_export_workspace_t*   workspace,
                                                    mdl_rabook_profile_t*     profile,
                                                    mdl_rabook_flat_source_t* flat)
{
  workspace->used                 = 0U;
  ra8_err_t                error  = internal_allocate_profile(workspace, profile);
  mdl_rabook_epub_source_t source = {};
  if (error == k_ra8_ok) {
    error = priv_mdl_rabook_epub_open(&source, storage, temp_path);
  }
  epub_stream_media_t media = {.read = priv_mdl_rabook_epub_read,
                               .ctx  = &source,
                               .size = source.size_bytes};
  if (error == k_ra8_ok) {
    error = epub_open_streamed(&media, temp_path, profile->book);
  }
  const void* blob   = nullptr;
  uint32_t    length = 0U;
  if (error == k_ra8_ok) {
    error = rabook_compile_from_epub_to_buffer(profile->book,
                                               &profile->builder,
                                               &profile->pipeline,
                                               &blob,
                                               &length);
  }
  if ((error == k_ra8_ok) && (source.error != k_ra8_ok)) {
    error = source.error;
  }
  error = internal_close_compile_sources(error, profile->book, &source);
  if (error == k_ra8_ok) {
    error = book_validate(blob, length);
  }
  if (error == k_ra8_ok) {
    error = internal_check_compiled_page_count(blob, page_count);
  }
  if (error == k_ra8_ok) {
    *flat = (mdl_rabook_flat_source_t){.bytes = blob, .size_bytes = length};
  }
  return error;
}

RA8_INTERNAL static ra8_err_t internal_emit_container(mdl_storage_t*            storage,
                                                      const char*               destination,
                                                      mdl_rabook_flat_source_t* flat,
                                                      mdl_rabook_profile_t*     profile,
                                                      mdl_export_workspace_t*   workspace)
{
  mdl_export_output_t output = {};
  ra8_err_t           error =
    priv_mdl_export_output_begin(&output, storage, destination, k_mdl_format_rabook);
  uint64_t container_length = 0U;
  if (error == k_ra8_ok) {
    error = ra8_rabook_container_write(priv_mdl_rabook_flat_read,
                                       flat,
                                       flat->size_bytes,
                                       k_rabook_chunk_bytes,
                                       priv_mdl_export_output_write_at,
                                       &output,
                                       &profile->container,
                                       &container_length);
  }
  if ((error == k_ra8_ok) && (container_length != output.extent)) {
    error = k_ra8_err_invalid_size;
  }
  if ((error != k_ra8_ok) && output.writer.transaction.active) {
    const ra8_err_t aborted = priv_mdl_export_output_abort(&output);
    return (aborted == k_ra8_ok) ? error : aborted;
  }
  bool published = false;
  return (error == k_ra8_ok) ? priv_mdl_export_output_commit(&output, workspace, &published)
                             : error;
}
 
RA8_PRIV ra8_err_t priv_mdl_export_rabook(mdl_storage_t*           storage,
                                          const char*              directory,
                                          char                     names[][k_name_max],
                                          size_t                   count,
                                          const char*              destination,
                                          const mdl_export_meta_t* meta,
                                          mdl_export_workspace_t*  workspace)
{
  if ((storage == nullptr) || (directory == nullptr) || (names == nullptr) ||
      (destination == nullptr) || (meta == nullptr) || (workspace == nullptr)) {
    return k_ra8_err_invalid_arg;
  }
  if ((count == 0U) || (count > (size_t)k_rabook_page_cap)) {
    return k_ra8_err_invalid_size;
  }
  char                     temp_path[k_fw_fs_path_cap] = {};
  bool                     temp_exists                 = false;
  ra8_err_t                error                       = internal_write_temp_epub(storage,
                                                                                  directory,
                                                                                  names,
                                                                                  count,
                                                                                  destination,
                                                                                  meta,
                                                                                  workspace,
                                                                                  temp_path,
                                                                                  &temp_exists);
  mdl_rabook_profile_t     profile                     = {};
  mdl_rabook_flat_source_t flat                        = {};
  if (error == k_ra8_ok) {
    error = internal_compile_temp(storage, temp_path, count, workspace, &profile, &flat);
  }
  if (temp_exists) {
    const ra8_err_t removed = fw_fs_unlink(&storage->fs->names, temp_path);
    if (removed != k_ra8_ok) {
      return removed;
    }
  }
  if (error == k_ra8_ok) {
    error = internal_emit_container(storage, destination, &flat, &profile, workspace);
  }
  return error;
}