reflow_cache.c

Go to the documentation of this file.

 
#include "reflow_cache.h"
 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_err.h"
#include "reflow.h"
 
/* ===========================================================================
 * Internal numeric constants (no magic numbers).
 * ===========================================================================
 */

typedef enum : uint32_t {
  k_priv_fnv_offset = 0x811C9DC5U, 
  k_priv_fnv_prime  = 0x01000193U, 
  k_priv_byte_mask  = 0xFFU,       
  k_priv_shift_8    = 8U,          
  k_priv_shift_16   = 16U,         
  k_priv_shift_24   = 24U,         
} priv_cache_const_t;

typedef enum : size_t {
  k_priv_checksum_off = 48U, 
} priv_cache_off_t;

typedef struct {
  uint32_t magic;         
  uint32_t version;       
  uint16_t viewport_w;    
  uint16_t viewport_h;    
  uint16_t font_px;       
  uint32_t body_color;    
  uint32_t link_color;    
  uint32_t font_len;      
  uint32_t font_hash;     
  uint32_t content_len;   
  uint32_t content_hash;  
  uint32_t glyph_count;   
  uint32_t page_count;    
  uint32_t body_checksum; 
} priv_cache_key_t;
 
/* ===========================================================================
 * Little-endian byte cursors
 * ===========================================================================
 */

RA8_INTERNAL
static void internal_put_u32(uint8_t* buf, size_t* off, uint32_t word)
{
  buf[*off] = (uint8_t)(word & (uint32_t)k_priv_byte_mask);
  *off += 1U;
  buf[*off] = (uint8_t)((word >> (uint32_t)k_priv_shift_8) & (uint32_t)k_priv_byte_mask);
  *off += 1U;
  buf[*off] = (uint8_t)((word >> (uint32_t)k_priv_shift_16) & (uint32_t)k_priv_byte_mask);
  *off += 1U;
  buf[*off] = (uint8_t)((word >> (uint32_t)k_priv_shift_24) & (uint32_t)k_priv_byte_mask);
  *off += 1U;
}

RA8_INTERNAL
static void internal_put_u16(uint8_t* buf, size_t* off, uint16_t half)
{
  buf[*off] = (uint8_t)(half & (uint16_t)k_priv_byte_mask);
  *off += 1U;
  buf[*off] = (uint8_t)((half >> (uint32_t)k_priv_shift_8) & (uint16_t)k_priv_byte_mask);
  *off += 1U;
}

RA8_INTERNAL
static uint32_t internal_get_u32(const uint8_t* buf, size_t* off)
{
  uint32_t word = (uint32_t)buf[*off];
  *off += 1U;
  word |= (uint32_t)buf[*off] << (uint32_t)k_priv_shift_8;
  *off += 1U;
  word |= (uint32_t)buf[*off] << (uint32_t)k_priv_shift_16;
  *off += 1U;
  word |= (uint32_t)buf[*off] << (uint32_t)k_priv_shift_24;
  *off += 1U;
  return word;
}

RA8_INTERNAL
static uint16_t internal_get_u16(const uint8_t* buf, size_t* off)
{
  uint16_t half = (uint16_t)buf[*off];
  *off += 1U;
  half = (uint16_t)(half | ((uint16_t)buf[*off] << (uint32_t)k_priv_shift_8));
  *off += 1U;
  return half;
}
 
/* ===========================================================================
 * Hash + record codecs
 * ===========================================================================
 */

RA8_INTERNAL
static uint32_t internal_fnv1a(const uint8_t* data, size_t len)
{
  uint32_t hash = (uint32_t)k_priv_fnv_offset;
  for (size_t i = 0U; i < len; ++i) {
    hash ^= (uint32_t)data[i];
    hash *= (uint32_t)k_priv_fnv_prime;
  }
  return hash;
}

RA8_INTERNAL
static void internal_put_glyph(uint8_t* buf, size_t* off, const reflow_glyph_t* glyph)
{
  internal_put_u32(buf, off, (uint32_t)glyph->x);
  internal_put_u32(buf, off, (uint32_t)glyph->y);
  internal_put_u32(buf, off, (uint32_t)glyph->cp);
  internal_put_u32(buf, off, glyph->color);
  internal_put_u16(buf, off, glyph->font_px);
  buf[*off] = glyph->style;
  *off += 1U;
  buf[*off] = glyph->reserved;
  *off += 1U;
}

RA8_INTERNAL
static void internal_get_glyph(const uint8_t* buf, size_t* off, reflow_glyph_t* glyph)
{
  glyph->x       = (int32_t)internal_get_u32(buf, off);
  glyph->y       = (int32_t)internal_get_u32(buf, off);
  glyph->cp      = (int32_t)internal_get_u32(buf, off);
  glyph->color   = internal_get_u32(buf, off);
  glyph->font_px = internal_get_u16(buf, off);
  glyph->style   = buf[*off];
  *off += 1U;
  glyph->reserved = buf[*off];
  *off += 1U;
}

RA8_INTERNAL
static void internal_put_page(uint8_t* buf, size_t* off, const reflow_page_t* page)
{
  internal_put_u32(buf, off, page->glyph_first);
  internal_put_u32(buf, off, page->glyph_count);
}

RA8_INTERNAL
static void internal_get_page(const uint8_t* buf, size_t* off, reflow_page_t* page)
{
  page->glyph_first = internal_get_u32(buf, off);
  page->glyph_count = internal_get_u32(buf, off);
}
 
/* ===========================================================================
 * Header codecs + key compare
 * ===========================================================================
 */

RA8_INTERNAL
static uint32_t internal_font_hash(const reflow_t* engine)
{
  if (engine->font_data == nullptr) {
    return 0U;
  }
  return internal_fnv1a(engine->font_data, engine->font_len);
}

RA8_INTERNAL
static void
internal_put_header(uint8_t* buf, const reflow_t* engine, size_t content_len, uint32_t content_hash)
{
  size_t off = 0U;
  internal_put_u32(buf, &off, (uint32_t)k_reflow_cache_magic);
  internal_put_u16(buf, &off, (uint16_t)k_reflow_cache_version);
  internal_put_u16(buf, &off, 0U); /* reserved */
  internal_put_u16(buf, &off, engine->viewport_w);
  internal_put_u16(buf, &off, engine->viewport_h);
  internal_put_u16(buf, &off, engine->font_px);
  internal_put_u16(buf, &off, 0U); /* reserved16 */
  internal_put_u32(buf, &off, engine->body_color);
  internal_put_u32(buf, &off, engine->link_color);
  internal_put_u32(buf, &off, (uint32_t)engine->font_len);
  internal_put_u32(buf, &off, internal_font_hash(engine));
  internal_put_u32(buf, &off, (uint32_t)content_len);
  internal_put_u32(buf, &off, content_hash);
  internal_put_u32(buf, &off, engine->glyph_count);
  internal_put_u32(buf, &off, engine->page_count);
  internal_put_u32(buf, &off, 0U); /* body_checksum placeholder */
}

RA8_INTERNAL
static void internal_get_header(const uint8_t* buf, priv_cache_key_t* key)
{
  size_t off   = 0U;
  key->magic   = internal_get_u32(buf, &off);
  key->version = internal_get_u16(buf, &off);
  (void)internal_get_u16(buf, &off); /* reserved */
  key->viewport_w = internal_get_u16(buf, &off);
  key->viewport_h = internal_get_u16(buf, &off);
  key->font_px    = internal_get_u16(buf, &off);
  (void)internal_get_u16(buf, &off); /* reserved16 */
  key->body_color    = internal_get_u32(buf, &off);
  key->link_color    = internal_get_u32(buf, &off);
  key->font_len      = internal_get_u32(buf, &off);
  key->font_hash     = internal_get_u32(buf, &off);
  key->content_len   = internal_get_u32(buf, &off);
  key->content_hash  = internal_get_u32(buf, &off);
  key->glyph_count   = internal_get_u32(buf, &off);
  key->page_count    = internal_get_u32(buf, &off);
  key->body_checksum = internal_get_u32(buf, &off);
}

RA8_INTERNAL
static size_t internal_blob_size(uint32_t glyph_count, uint32_t page_count)
{
  return (size_t)k_reflow_cache_header_bytes +
         ((size_t)glyph_count * (size_t)k_reflow_cache_glyph_bytes) +
         ((size_t)page_count * (size_t)k_reflow_cache_page_bytes);
}

RA8_INTERNAL
static bool internal_key_matches(const reflow_t*         engine,
                                 const priv_cache_key_t* key,
                                 const uint8_t*          content,
                                 size_t                  content_len)
{
  /* One simple decision per attribute (no compound boolean): any single
   * mismatch makes the cached layout stale. */
  if (key->viewport_w != engine->viewport_w) {
    return false;
  }
  if (key->viewport_h != engine->viewport_h) {
    return false;
  }
  if (key->font_px != engine->font_px) {
    return false;
  }
  if (key->body_color != engine->body_color) {
    return false;
  }
  if (key->link_color != engine->link_color) {
    return false;
  }
  if (key->font_len != (uint32_t)engine->font_len) {
    return false;
  }
  if (key->font_hash != internal_font_hash(engine)) {
    return false;
  }
  if (key->content_len != (uint32_t)content_len) {
    return false;
  }
  if (key->content_hash != internal_fnv1a(content, content_len)) {
    return false;
  }
  return true;
}

RA8_INTERNAL
static ra8_err_t
internal_parse_header(const uint8_t* buf, size_t len, priv_cache_key_t* key, size_t* need)
{
  if (len < (size_t)k_reflow_cache_header_bytes) {
    return k_ra8_err_invalid_size;
  }
  internal_get_header(buf, key);
  if (key->magic != (uint32_t)k_reflow_cache_magic) {
    return k_ra8_err_not_found;
  }
  if (key->version != (uint32_t)k_reflow_cache_version) {
    return k_ra8_err_invalid_state;
  }
  if (key->glyph_count > (uint32_t)k_reflow_max_glyphs) {
    return k_ra8_err_invalid_size;
  }
  if (key->page_count > (uint32_t)k_reflow_max_pages) {
    return k_ra8_err_invalid_size;
  }
  *need = internal_blob_size(key->glyph_count, key->page_count);
  if (len < *need) {
    return k_ra8_err_invalid_size;
  }
  return k_ra8_ok;
}
 
/* ===========================================================================
 * Public API
 * ===========================================================================
 */
 
[[nodiscard]] ra8_err_t reflow_cache_size(const reflow_t* engine, size_t* out_bytes)
{
  if ((engine == nullptr) || (out_bytes == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  if (engine->in_use == 0U) {
    return k_ra8_err_not_initialized;
  }
  *out_bytes = internal_blob_size(engine->glyph_count, engine->page_count);
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t
internal_cache_precheck(const reflow_t* engine, const uint8_t* content, size_t content_len)
{
  if (engine->in_use == 0U) {
    return k_ra8_err_not_initialized;
  }
  if ((content == nullptr) && (content_len != 0U)) {
    return k_ra8_err_invalid_arg;
  }
  if (engine->face_count != 0U) {
    return k_ra8_err_invalid_state;
  }
  return k_ra8_ok;
}
 
[[nodiscard]] ra8_err_t reflow_cache_serialize(const reflow_t* engine,
                                               const uint8_t*  content,
                                               size_t          content_len,
                                               uint8_t*        out_buf,
                                               size_t          out_cap,
                                               size_t*         out_len)
{
  if ((engine == nullptr) || (out_buf == nullptr) || (out_len == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  const ra8_err_t verr = internal_cache_precheck(engine, content, content_len);
  if (verr != k_ra8_ok) {
    return verr;
  }
  const size_t need = internal_blob_size(engine->glyph_count, engine->page_count);
  if (out_cap < need) {
    return k_ra8_err_invalid_size;
  }
 
  internal_put_header(out_buf, engine, content_len, internal_fnv1a(content, content_len));
 
  size_t off = (size_t)k_reflow_cache_header_bytes;
  for (uint32_t i = 0U; i < engine->glyph_count; ++i) {
    internal_put_glyph(out_buf, &off, &engine->glyphs[i]);
  }
  for (uint32_t i = 0U; i < engine->page_count; ++i) {
    internal_put_page(out_buf, &off, &engine->pages[i]);
  }
 
  const uint32_t checksum = internal_fnv1a(&out_buf[(size_t)k_reflow_cache_header_bytes],
                                           need - (size_t)k_reflow_cache_header_bytes);
  size_t         ck_off   = (size_t)k_priv_checksum_off;
  internal_put_u32(out_buf, &ck_off, checksum);
  *out_len = need;
  return k_ra8_ok;
}
 
[[nodiscard]] ra8_err_t reflow_cache_load(reflow_t*      engine,
                                          const uint8_t* content,
                                          size_t         content_len,
                                          const uint8_t* buf,
                                          size_t         len)
{
  if ((engine == nullptr) || (buf == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  const ra8_err_t verr = internal_cache_precheck(engine, content, content_len);
  if (verr != k_ra8_ok) {
    return verr;
  }
 
  priv_cache_key_t key  = {};
  size_t           need = 0U;
  const ra8_err_t  perr = internal_parse_header(buf, len, &key, &need);
  if (perr != k_ra8_ok) {
    return perr;
  }
  if (!internal_key_matches(engine, &key, content, content_len)) {
    return k_ra8_err_invalid_state;
  }
 
  const uint32_t checksum = internal_fnv1a(&buf[(size_t)k_reflow_cache_header_bytes],
                                           need - (size_t)k_reflow_cache_header_bytes);
  if (checksum != key.body_checksum) {
    return k_ra8_err_checksum_mismatch;
  }
 
  size_t off = (size_t)k_reflow_cache_header_bytes;
  for (uint32_t i = 0U; i < key.glyph_count; ++i) {
    internal_get_glyph(buf, &off, &engine->glyphs[i]);
  }
  for (uint32_t i = 0U; i < key.page_count; ++i) {
    internal_get_page(buf, &off, &engine->pages[i]);
  }
  engine->glyph_count = key.glyph_count;
  engine->page_count  = key.page_count;
  engine->xhtml_buf   = content;
  engine->xhtml_len   = content_len;
  return k_ra8_ok;
}