ra8_rabook_finalize.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "rabook_compile.h"

static const char* const s_tag_rabook = "ra8_rabook_finalize";

typedef enum : uint32_t {
  k_rabook_crc_init = 0xFFFFFFFFU, 
  k_rabook_crc_poly = 0xEDB88320U, 
} ra8_rabook_crc_t;

typedef enum : uint32_t {
  k_rabook_crc_byte_bits = 8U, 
} ra8_rabook_crc_bits_t;

typedef enum : uint8_t {
  k_rabook_pool_external = 2U, 
} ra8_rabook_pool_mode_t;

RA8_INTERNAL
static uint32_t internal_crc_update(uint32_t crc, const uint8_t* data, uint32_t len)
{
  uint32_t running_crc = crc;
  for (uint32_t i = 0U; i < len; i++) {
    running_crc ^= (uint32_t)data[i];
    for (uint32_t bit = 0U; bit < (uint32_t)k_rabook_crc_byte_bits; bit++) {
      const uint32_t lsb  = running_crc & 1U;
      const uint32_t mask = 0U - lsb;
      running_crc         = (running_crc >> 1U) ^ ((uint32_t)k_rabook_crc_poly & mask);
    }
  }
  return running_crc;
}

typedef struct {
  uint32_t off_chap;   
  uint32_t off_node;   
  uint32_t off_attr;   
  uint32_t off_style;  
  uint32_t off_image;  
  uint32_t off_string; 
  uint32_t off_pool;   
  uint32_t total;      
} ra8_rabook_layout_t;

RA8_INTERNAL
static ra8_err_t internal_compute_layout(const ra8_rabook_ctx_t* ctx, ra8_rabook_layout_t* lay)
{
  const uint64_t chap_bytes  = (uint64_t)ctx->chapter_count * (uint64_t)k_book_sizeof_chapter;
  const uint64_t node_bytes  = (uint64_t)ctx->node_count * (uint64_t)k_book_sizeof_node;
  const uint64_t attr_bytes  = (uint64_t)ctx->attr_count * (uint64_t)k_book_sizeof_attr;
  const uint64_t style_bytes = (uint64_t)ctx->stylesheet_count * (uint64_t)k_book_sizeof_stylesheet;
  const uint64_t image_bytes = (uint64_t)ctx->image_count * (uint64_t)k_book_sizeof_image;
 
  const uint64_t off_chap   = (uint64_t)k_book_sizeof_header;
  const uint64_t off_node   = off_chap + chap_bytes;
  const uint64_t off_attr   = off_node + node_bytes;
  const uint64_t off_style  = off_attr + attr_bytes;
  const uint64_t off_image  = off_style + style_bytes;
  const uint64_t off_string = off_image + image_bytes;
  const uint64_t off_pool   = off_string + (uint64_t)ctx->string_size;
  const uint64_t total      = off_pool + (uint64_t)ctx->image_pool_size;
 
  if (total > (uint64_t)UINT32_MAX) {
    ra8_log_error(s_tag_rabook, "finalize: layout overflows 32-bit offsets");
    return k_ra8_err_invalid_size;
  }
 
  lay->off_chap   = (uint32_t)off_chap;
  lay->off_node   = (uint32_t)off_node;
  lay->off_attr   = (uint32_t)off_attr;
  lay->off_style  = (uint32_t)off_style;
  lay->off_image  = (uint32_t)off_image;
  lay->off_string = (uint32_t)off_string;
  lay->off_pool   = (uint32_t)off_pool;
  lay->total      = (uint32_t)total;
  return k_ra8_ok;
}

typedef struct {
  const uint8_t* data; 
  uint32_t       len;  
} ra8_rabook_segment_t;

typedef enum : uint8_t {
  k_rabook_segment_chapters = 0U, 
  k_rabook_segment_nodes    = 1U, 
  k_rabook_segment_attrs    = 2U, 
  k_rabook_segment_styles   = 3U, 
  k_rabook_segment_images   = 4U, 
  k_rabook_segment_strings  = 5U, 
  k_rabook_segment_count    = 6U, 
} ra8_rabook_segment_count_t;

RA8_INTERNAL
static void internal_segments(const ra8_rabook_ctx_t*    ctx,
                              const ra8_rabook_layout_t* lay,
                              ra8_rabook_segment_t       seg[k_rabook_segment_count])
{
  seg[k_rabook_segment_chapters] =
    (ra8_rabook_segment_t){(const uint8_t*)ctx->buf.chapters, lay->off_node - lay->off_chap};
  seg[k_rabook_segment_nodes] =
    (ra8_rabook_segment_t){(const uint8_t*)ctx->buf.nodes, lay->off_attr - lay->off_node};
  seg[k_rabook_segment_attrs] =
    (ra8_rabook_segment_t){(const uint8_t*)ctx->buf.attrs, lay->off_style - lay->off_attr};
  seg[k_rabook_segment_styles] =
    (ra8_rabook_segment_t){(const uint8_t*)ctx->buf.stylesheets, lay->off_image - lay->off_style};
  seg[k_rabook_segment_images] =
    (ra8_rabook_segment_t){(const uint8_t*)ctx->buf.images, lay->off_string - lay->off_image};
  seg[k_rabook_segment_strings] =
    (ra8_rabook_segment_t){(const uint8_t*)ctx->buf.string_pool, ctx->string_size};
}

RA8_INTERNAL
static ra8_err_t internal_read_exact(ra8_rabook_image_read_fn read,
                                     void*                    read_ctx,
                                     uint32_t                 offset,
                                     uint8_t*                 dst,
                                     uint32_t                 len)
{
  uint32_t        got = 0U;
  const ra8_err_t err = read(read_ctx, offset, dst, len, &got);
  if (err != k_ra8_ok) {
    return err;
  }
  return (got == len) ? k_ra8_ok : k_ra8_err_invalid_size;
}

RA8_INTERNAL
static ra8_err_t
internal_write_exact(ra8_rabook_write_fn write, void* write_ctx, const uint8_t* src, uint32_t len)
{
  if (len == 0U) {
    return k_ra8_ok;
  }
  uint32_t        wrote = 0U;
  const ra8_err_t err   = write(write_ctx, src, len, &wrote);
  if (err != k_ra8_ok) {
    return err;
  }
  return (wrote == len) ? k_ra8_ok : k_ra8_err_invalid_size;
}

RA8_INTERNAL
static ra8_err_t internal_crc_image_pool(const ra8_rabook_ctx_t*  ctx,
                                         ra8_rabook_image_read_fn read,
                                         void*                    read_ctx,
                                         uint8_t*                 scratch,
                                         uint32_t                 scratch_cap,
                                         uint32_t*                crc)
{
  if (ctx->image_pool_size == 0U) {
    return k_ra8_ok;
  }
  if (ctx->image_pool_mode != (uint8_t)k_rabook_pool_external) {
    *crc = internal_crc_update(*crc, ctx->buf.image_pool, ctx->image_pool_size);
    return k_ra8_ok;
  }
  uint32_t offset = 0U;
  while (offset < ctx->image_pool_size) {
    uint32_t span = ctx->image_pool_size - offset;
    if (span > scratch_cap) {
      span = scratch_cap;
    }
    const ra8_err_t err = internal_read_exact(read, read_ctx, offset, scratch, span);
    if (err != k_ra8_ok) {
      return err;
    }
    *crc = internal_crc_update(*crc, scratch, span);
    offset += span;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static book_header_t
internal_make_header(const ra8_rabook_ctx_t* ctx, const ra8_rabook_layout_t* lay, uint32_t crc)
{
  book_header_t hdr = {};
  (void)memcpy(hdr.magic, "RABOOK1", sizeof(hdr.magic));
  hdr.format_version    = (uint32_t)k_book_format_version;
  hdr.total_size        = lay->total;
  hdr.flags             = ctx->flags;
  hdr.title_off         = ctx->title_off;
  hdr.author_off        = ctx->author_off;
  hdr.language_off      = ctx->language_off;
  hdr.identifier_off    = ctx->identifier_off;
  hdr.cover_image_index = ctx->cover_image_index;
  hdr.chapter_count     = ctx->chapter_count;
  hdr.chapter_off       = lay->off_chap;
  hdr.node_count        = ctx->node_count;
  hdr.node_off          = lay->off_node;
  hdr.attr_count        = ctx->attr_count;
  hdr.attr_off          = lay->off_attr;
  hdr.stylesheet_count  = ctx->stylesheet_count;
  hdr.stylesheet_off    = lay->off_style;
  hdr.image_count       = ctx->image_count;
  hdr.image_off         = lay->off_image;
  hdr.string_off        = lay->off_string;
  hdr.string_size       = ctx->string_size;
  hdr.image_pool_off    = lay->off_pool;
  hdr.image_pool_size   = ctx->image_pool_size;
  hdr.crc32_val         = crc;
  return hdr;
}

RA8_INTERNAL
static ra8_err_t internal_write_image_pool(const ra8_rabook_ctx_t*  ctx,
                                           ra8_rabook_image_read_fn read,
                                           void*                    read_ctx,
                                           ra8_rabook_write_fn      write,
                                           void*                    write_ctx,
                                           uint8_t*                 scratch,
                                           uint32_t                 scratch_cap)
{
  if (ctx->image_pool_size == 0U) {
    return k_ra8_ok;
  }
  if (ctx->image_pool_mode != (uint8_t)k_rabook_pool_external) {
    return internal_write_exact(write, write_ctx, ctx->buf.image_pool, ctx->image_pool_size);
  }
  uint32_t offset = 0U;
  while (offset < ctx->image_pool_size) {
    uint32_t span = ctx->image_pool_size - offset;
    if (span > scratch_cap) {
      span = scratch_cap;
    }
    ra8_err_t err = internal_read_exact(read, read_ctx, offset, scratch, span);
    if (err == k_ra8_ok) {
      err = internal_write_exact(write, write_ctx, scratch, span);
    }
    if (err != k_ra8_ok) {
      return err;
    }
    offset += span;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_crc_body(const ra8_rabook_ctx_t*    ctx,
                                   const ra8_rabook_segment_t seg[k_rabook_segment_count],
                                   ra8_rabook_image_read_fn   read,
                                   void*                      read_ctx,
                                   uint8_t*                   scratch,
                                   uint32_t                   scratch_cap,
                                   uint32_t*                  out_crc)
{
  uint32_t crc = (uint32_t)k_rabook_crc_init;
  for (uint8_t i = 0U; i < (uint8_t)k_rabook_segment_count; ++i) {
    crc = internal_crc_update(crc, seg[i].data, seg[i].len);
  }
  const ra8_err_t err = internal_crc_image_pool(ctx, read, read_ctx, scratch, scratch_cap, &crc);
  if (err != k_ra8_ok) {
    return err;
  }
  *out_crc = crc ^ (uint32_t)k_rabook_crc_init;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_write_book(const ra8_rabook_ctx_t*    ctx,
                                     const book_header_t*       hdr,
                                     const ra8_rabook_segment_t seg[k_rabook_segment_count],
                                     ra8_rabook_image_read_fn   read,
                                     void*                      read_ctx,
                                     ra8_rabook_write_fn        write,
                                     void*                      write_ctx,
                                     uint8_t*                   scratch,
                                     uint32_t                   scratch_cap)
{
  ra8_err_t err =
    internal_write_exact(write, write_ctx, (const uint8_t*)hdr, (uint32_t)sizeof(*hdr));
  for (uint8_t i = 0U; i < (uint8_t)k_rabook_segment_count; ++i) {
    if (err != k_ra8_ok) {
      break;
    }
    err = internal_write_exact(write, write_ctx, seg[i].data, seg[i].len);
  }
  if (err != k_ra8_ok) {
    return err;
  }
  return internal_write_image_pool(ctx, read, read_ctx, write, write_ctx, scratch, scratch_cap);
}

RA8_INTERNAL
static ra8_err_t internal_validate_stream_args(const ra8_rabook_ctx_t*  ctx,
                                               ra8_rabook_image_read_fn image_read,
                                               ra8_rabook_write_fn      write,
                                               const uint8_t*           scratch,
                                               uint32_t                 scratch_cap,
                                               const uint32_t*          out_len)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag_rabook, "ctx");
  if (write == nullptr) {
    ra8_log_error(s_tag_rabook, "write is NULL");
    return k_ra8_err_null_ptr;
  }
  RA8_CHECK_NULL_PTR(out_len, s_tag_rabook, "out_len");
  if (ctx->failed) {
    return k_ra8_err_no_mem;
  }
  bool external = false;
  if (ctx->image_pool_size != 0U) {
    external = ctx->image_pool_mode == (uint8_t)k_rabook_pool_external;
  }
  if (external) {
    if (image_read == nullptr) {
      return k_ra8_err_null_ptr;
    }
    if (scratch == nullptr) {
      return k_ra8_err_null_ptr;
    }
    if (scratch_cap == 0U) {
      return k_ra8_err_invalid_size;
    }
  }
  return k_ra8_ok;
}
 
ra8_err_t ra8_rabook_finalize_stream(const ra8_rabook_ctx_t*  ctx,
                                     ra8_rabook_image_read_fn image_read,
                                     void*                    image_ctx,
                                     ra8_rabook_write_fn      write,
                                     void*                    write_ctx,
                                     uint8_t*                 scratch,
                                     uint32_t                 scratch_cap,
                                     uint32_t*                out_len)
{
  const ra8_err_t arg_err =
    internal_validate_stream_args(ctx, image_read, write, scratch, scratch_cap, out_len);
  if (arg_err != k_ra8_ok) {
    return arg_err;
  }
 
  ra8_rabook_layout_t lay     = {};
  const ra8_err_t     lay_err = internal_compute_layout(ctx, &lay);
  if (lay_err != k_ra8_ok) {
    return lay_err;
  }
  ra8_rabook_segment_t seg[k_rabook_segment_count] = {};
  internal_segments(ctx, &lay, seg);
  uint32_t  crc = 0U;
  ra8_err_t err = internal_crc_body(ctx, seg, image_read, image_ctx, scratch, scratch_cap, &crc);
  if (err != k_ra8_ok) {
    return err;
  }
  const book_header_t hdr = internal_make_header(ctx, &lay, crc);
  err                     = internal_write_book(ctx,
                                                &hdr,
                                                seg,
                                                image_read,
                                                image_ctx,
                                                write,
                                                write_ctx,
                                                scratch,
                                                scratch_cap);
  if (err != k_ra8_ok) {
    return err;
  }
  *out_len = lay.total;
  return k_ra8_ok;
}

typedef struct {
  uint8_t* data; 
  uint32_t cap;  
  uint32_t used; 
} ra8_rabook_memory_sink_t;

RA8_INTERNAL
static ra8_err_t
internal_memory_write(void* opaque, const uint8_t* src, uint32_t requested, uint32_t* out_written)
{
  ra8_rabook_memory_sink_t* sink = (ra8_rabook_memory_sink_t*)opaque;
  *out_written                   = 0U;
  if (requested > (sink->cap - sink->used)) {
    return k_ra8_err_invalid_size;
  }
  (void)memcpy(&sink->data[sink->used], src, (size_t)requested);
  sink->used += requested;
  *out_written = requested;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_validate_memory_finalize(ra8_rabook_ctx_t* ctx,
                                                   const void**      out_blob,
                                                   const uint32_t*   out_len)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag_rabook, "ctx");
  RA8_CHECK_NULL_PTR(out_blob, s_tag_rabook, "out_blob");
  RA8_CHECK_NULL_PTR(out_len, s_tag_rabook, "out_len");
  if (ctx->failed) {
    ra8_log_error(s_tag_rabook, "finalize after a builder overflow");
    return k_ra8_err_no_mem;
  }
  ra8_rabook_layout_t lay = {};
  RA8_RETURN_ON_ERROR(internal_compute_layout(ctx, &lay), s_tag_rabook, "layout");
  return (lay.total <= ctx->buf.out_cap) ? k_ra8_ok : k_ra8_err_invalid_size;
}
 
ra8_err_t ra8_rabook_finalize(ra8_rabook_ctx_t* ctx, const void** out_blob, uint32_t* out_len)
{
  const ra8_err_t arg_err = internal_validate_memory_finalize(ctx, out_blob, out_len);
  if (arg_err != k_ra8_ok) {
    return arg_err;
  }
  ra8_rabook_memory_sink_t sink = {.data = ctx->buf.out, .cap = ctx->buf.out_cap};
  uint32_t                 len  = 0U;
  const ra8_err_t          err  = ra8_rabook_finalize_stream(ctx,
                                                             nullptr,
                                                             nullptr,
                                                             internal_memory_write,
                                                             &sink,
                                                             nullptr,
                                                             0U,
                                                             &len);
  if (err != k_ra8_ok) {
    return err;
  }
 
  *out_blob = ctx->buf.out;
  *out_len  = len;
  return k_ra8_ok;
}