book.h

Go to the documentation of this file.

#pragma once
 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_err.h"

typedef enum : uint32_t {
  k_book_format_version = 1U, 
} book_version_t;

typedef enum : uint8_t {
  k_book_container_magic_len  = 4U,  
  k_book_container_header_len = 24U, 
  k_book_container_entry_len  = 8U,  
} book_container_t;

typedef enum : uint32_t {
  k_book_nil = 0xFFFFFFFFU, 
} book_sentinel_t;

typedef enum : uint32_t {
  k_book_flag_rtl        = 0x00000001U, 
  k_book_flag_mask_known = 0x00000001U, 
} book_flag_t;

typedef enum : uint8_t {
  k_book_node_element = 0U, 
  k_book_node_text    = 1U, 
} book_node_kind_t;

typedef enum : uint8_t {
  k_book_image_gray4 = 0U, 
  k_book_image_svg   = 1U, 
} book_image_format_t;

typedef enum : uint8_t {
  k_book_pixfmt_gray4 = 0U, 
  k_book_pixfmt_gray8 = 1U,
} book_image_pixfmt_t;

typedef enum : uint16_t {
  k_book_sizeof_header     = 100U, 
  k_book_sizeof_chapter    = 12U,  
  k_book_sizeof_node       = 24U,  
  k_book_sizeof_attr       = 8U,   
  k_book_sizeof_stylesheet = 8U,   
  k_book_sizeof_image      = 24U,  
} book_struct_size_t;

typedef struct {
  char     magic[8];          
  uint32_t format_version;    
  uint32_t total_size;        
  uint32_t flags;             
  uint32_t title_off;         
  uint32_t author_off;        
  uint32_t language_off;      
  uint32_t identifier_off;    
  uint32_t cover_image_index; 
  uint32_t chapter_count;     
  uint32_t chapter_off;       
  uint32_t node_count;        
  uint32_t node_off;          
  uint32_t attr_count;        
  uint32_t attr_off;          
  uint32_t stylesheet_count;  
  uint32_t stylesheet_off;    
  uint32_t image_count;       
  uint32_t image_off;         
  uint32_t string_off;        
  uint32_t string_size;       
  uint32_t image_pool_off;    
  uint32_t image_pool_size;   
  uint32_t crc32_val;         
} book_header_t;
 
static_assert(sizeof(book_header_t) == k_book_sizeof_header, "book_header_t size pinned");

typedef struct {
  uint32_t title_off; 
  uint32_t href_off;  
  uint32_t root_node; 
} book_chapter_t;
 
static_assert(sizeof(book_chapter_t) == k_book_sizeof_chapter, "book_chapter_t size pinned");

typedef struct {
  uint8_t  kind;         
  uint8_t  reserved;     
  uint16_t attr_count;   
  uint32_t name_off;     
  uint32_t text_off;     
  uint32_t first_attr;   
  uint32_t first_child;  
  uint32_t next_sibling; 
} book_node_t;
 
static_assert(sizeof(book_node_t) == k_book_sizeof_node, "book_node_t size pinned");

typedef struct {
  uint32_t name_off;  
  uint32_t value_off; 
} book_attr_t;
 
static_assert(sizeof(book_attr_t) == k_book_sizeof_attr, "book_attr_t size pinned");

typedef struct {
  uint32_t source_off;    
  uint32_t scope_chapter; 
} book_stylesheet_t;
 
static_assert(sizeof(book_stylesheet_t) == k_book_sizeof_stylesheet,
              "book_stylesheet_t size pinned");

typedef struct {
  uint32_t id_off;       
  uint16_t width;        
  uint16_t height;       
  uint8_t  format;       
  uint8_t  pixel_format; 
  uint16_t reserved2;    
  uint32_t data_off;     
  uint32_t data_size;    
  uint32_t raw_size;     
} book_image_t;
 
static_assert(sizeof(book_image_t) == k_book_sizeof_image, "book_image_t size pinned");
 
/* -------------------------------------------------------------------------- */
/* Inline accessors. All take a validated blob base; see book_validate(). */
/* -------------------------------------------------------------------------- */

static inline const book_header_t* book_header(const void* base)
{
  return (const book_header_t*)base;
}

static inline bool book_is_rtl(const void* base)
{
  return (book_header(base)->flags & (uint32_t)k_book_flag_rtl) != 0U;
}

static inline const void* book_at(const void* base, uint32_t off)
{
  return (const void*)&((const uint8_t*)base)[off];
}

static inline const char* book_string(const void* base, uint32_t off)
{
  return (const char*)book_at(base, book_header(base)->string_off + off);
}

static inline const book_chapter_t* book_chapters(const void* base)
{
  return (const book_chapter_t*)book_at(base, book_header(base)->chapter_off);
}

static inline const book_node_t* book_nodes(const void* base)
{
  return (const book_node_t*)book_at(base, book_header(base)->node_off);
}

static inline const book_attr_t* book_attrs(const void* base)
{
  return (const book_attr_t*)book_at(base, book_header(base)->attr_off);
}

static inline const book_stylesheet_t* book_stylesheets(const void* base)
{
  return (const book_stylesheet_t*)book_at(base, book_header(base)->stylesheet_off);
}

static inline const book_image_t* book_images(const void* base)
{
  return (const book_image_t*)book_at(base, book_header(base)->image_off);
}

static inline const char* book_node_name(const void* base, const book_node_t* node)
{
  return book_string(base, node->name_off);
}

static inline const char* book_node_text(const void* base, const book_node_t* node)
{
  return book_string(base, node->text_off);
}

static inline const uint8_t* book_image_data(const void* base, const book_image_t* img)
{
  return &((const uint8_t*)book_at(base, book_header(base)->image_pool_off))[img->data_off];
}

static inline book_image_pixfmt_t book_image_pixfmt(const book_image_t* img)
{
  return (book_image_pixfmt_t)img->pixel_format;
}

ra8_err_t book_validate(const void* base, size_t size);

typedef ra8_err_t (
  *book_inflate_fn)(const void* src, size_t src_len, void* dst, size_t dst_cap, size_t* out_len);

ra8_err_t book_open(const void*     file,
                    size_t          file_len,
                    book_inflate_fn inflate,
                    void*           scratch,
                    size_t          scratch_cap,
                    const void**    out_base,
                    size_t*         out_size);

ra8_err_t book_chapter_to_xhtml(const void* base,
                                uint32_t    chapter_idx,
                                char*       out,
                                size_t      cap,
                                size_t*     out_len);

ra8_err_t
book_chapter_text(const void* base, uint32_t chapter_idx, char* out, size_t cap, size_t* out_len);