reflow_render.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_err.h"
#include "ra8_gfx.h"
#include "ra8_glyph_atlas.h"
#include "reflow.h"
#include "reflow_svg.h"
#include "stb_truetype.h"
 
/* ===========================================================================
 * Internal sizing constants (no magic numbers).
 * ===========================================================================
 */

typedef enum : uint16_t {
  k_priv_alpha_threshold     = 96U,  
  k_priv_alpha_max_byte      = 255U, 
  k_priv_underline_offset_px = 2U,   
  k_priv_underline_thick_px  = 1U,   
  k_priv_glyph_dim_max       = 192U, 
  k_priv_svg_href_max        = 256U, 
  k_priv_glyph_mode_aa       = 0U,   
} priv_render_consts_t;

typedef struct {
  const stbtt_fontinfo* font;  
  float                 scale; 
  int                   w;     
  int                   h;     
} priv_glyph_render_ctx_t;

static priv_glyph_render_ctx_t s_glyph_render_ctx;

RA8_INTERNAL
static ra8_err_t internal_atlas_render_glyph(void*                  ctx,
                                             const ra8_glyph_key_t* key,
                                             uint8_t*               cell,
                                             uint32_t               cell_bytes,
                                             uint16_t*              out_w,
                                             uint16_t*              out_h)
{
  const priv_glyph_render_ctx_t* rc = (const priv_glyph_render_ctx_t*)ctx;
  /* w/h were computed and validated (> 0) by internal_blit_glyph before the get. */
  if (((size_t)rc->w * (size_t)rc->h) > (size_t)cell_bytes) {
    return k_ra8_err_invalid_size; /* Too big to cache -> caller blits directly. */
  }
  stbtt_MakeCodepointBitmap(rc->font,
                            cell,
                            rc->w,
                            rc->h,
                            rc->w,
                            rc->scale,
                            rc->scale,
                            (int)key->glyph_id);
  *out_w = (uint16_t)rc->w;
  *out_h = (uint16_t)rc->h;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_init_font(const reflow_t* engine, stbtt_fontinfo* out_font)
{
  const int32_t offset = stbtt_GetFontOffsetForIndex(engine->font_data, 0);
  if (offset < 0) {
    return k_ra8_err_validation_failed;
  }
  if (stbtt_InitFont(out_font, engine->font_data, (int)engine->font_len, offset) == 0) {
    return k_ra8_err_validation_failed;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static void internal_blit_alpha_mask(const reflow_glyph_t* g,
                                     const unsigned char*  bitmap,
                                     int                   w,
                                     int                   h,
                                     int                   xoff,
                                     int                   yoff,
                                     int32_t               ox,
                                     int32_t               oy)
{
  for (int row = 0; row < h; ++row) {
    for (int col = 0; col < w; ++col) {
      const uint8_t alpha = (uint8_t)bitmap[((size_t)row * (size_t)w) + (size_t)col];
      if (alpha < k_priv_alpha_threshold) {
        continue;
      }
      const int32_t px = g->x + (int32_t)col + (int32_t)xoff + ox;
      const int32_t py = g->y + (int32_t)row + (int32_t)yoff + oy;
      (void)ra8_gfx_pixel(px, py, g->color);
    }
  }
}

RA8_INTERNAL
static void internal_draw_underline(const stbtt_fontinfo* font,
                                    const reflow_glyph_t* g,
                                    float                 scale,
                                    int32_t               ox,
                                    int32_t               oy)
{
  int advance_units = 0;
  int lsb           = 0;
  stbtt_GetCodepointHMetrics(font, g->cp, &advance_units, &lsb);
  const int32_t advance = (int32_t)((float)advance_units * scale);
  const int32_t y_under = g->y + (int32_t)k_priv_underline_offset_px + oy;
  for (int32_t i = 0; i < advance; ++i) {
    (void)ra8_gfx_pixel(g->x + i + ox, y_under, g->color);
  }
}

RA8_INTERNAL
static void internal_glyph_render_direct(const stbtt_fontinfo* font,
                                         float                 scale,
                                         const reflow_glyph_t* g,
                                         int                   w,
                                         int                   h,
                                         int                   x0,
                                         int                   y0,
                                         int32_t               ox,
                                         int32_t               oy)
{
  /* Fixed rasterisation storage: rendering is single-threaded and heap-free. */
  static uint8_t s_glyph_mask[(size_t)k_priv_glyph_dim_max * (size_t)k_priv_glyph_dim_max];
  /* Skip (do not truncate) any glyph larger than the fixed mask. */
  const size_t total = (size_t)w * (size_t)h;
  if (total <= sizeof s_glyph_mask) {
    stbtt_MakeCodepointBitmap(font, s_glyph_mask, w, h, w, scale, scale, g->cp);
    internal_blit_alpha_mask(g, s_glyph_mask, w, h, x0, y0, ox, oy);
  }
}

RA8_INTERNAL
static bool internal_glyph_render_cached(ra8_glyph_atlas_t*    atlas,
                                         uint8_t               face_id,
                                         const stbtt_fontinfo* font,
                                         float                 scale,
                                         const reflow_glyph_t* g,
                                         int                   w,
                                         int                   h,
                                         int                   x0,
                                         int                   y0,
                                         int32_t               ox,
                                         int32_t               oy)
{
  /* Hand the render-on-miss callback the font/scale/extent for this glyph. */
  s_glyph_render_ctx.font  = font;
  s_glyph_render_ctx.scale = scale;
  s_glyph_render_ctx.w     = w;
  s_glyph_render_ctx.h     = h;
 
  ra8_glyph_key_t key = {};
  key.glyph_id        = (uint32_t)g->cp;
  key.face_id         = (uint16_t)face_id;
  key.size_px         = g->font_px;
  key.mode            = (uint16_t)k_priv_glyph_mode_aa;
 
  ra8_glyph_t glyph = {};
  if (ra8_glyph_atlas_get(atlas, &key, &glyph) != k_ra8_ok) {
    return false; /* Uncacheable (oversized / full) -> caller blits directly. */
  }
  internal_blit_alpha_mask(g, glyph.bitmap, (int)glyph.width, (int)glyph.height, x0, y0, ox, oy);
  (void)ra8_glyph_atlas_put(atlas, glyph.bitmap);
  return true;
}

RA8_INTERNAL
static void internal_blit_glyph(ra8_glyph_atlas_t*    atlas,
                                uint8_t               face_id,
                                const stbtt_fontinfo* font,
                                const reflow_glyph_t* g,
                                int32_t               ox,
                                int32_t               oy)
{
  const float scale = stbtt_ScaleForPixelHeight(font, (float)g->font_px);
  int         x0    = 0;
  int         y0    = 0;
  int         x1    = 0;
  int         y1    = 0;
  stbtt_GetCodepointBitmapBox(font, g->cp, scale, scale, &x0, &y0, &x1, &y1);
  const int w = x1 - x0;
  const int h = y1 - y0;
  /*
   * w and h are the glyph bitmap-box extents returned by
   * stbtt_GetCodepointBitmapBox(). A codepoint is either inked -- a non-empty
   * box with w > 0 AND h > 0 -- or empty -- a zero box with w == 0 AND h == 0
   * (e.g. U+0020 space). The mixed states (w <= 0, h > 0) and (w > 0, h <= 0)
   * never occur for a real font glyph, so the vectors that would give w and h
   * independent MC/DC influence are structurally unreachable.
   */
  /* mcdc-deactivated: glyph bbox w,h co-dependent (inked or empty); mixed vectors unreachable. */
  if ((w > 0) && (h > 0)) {
    bool drawn = false;
    if (atlas != nullptr) {
      drawn = internal_glyph_render_cached(atlas, face_id, font, scale, g, w, h, x0, y0, ox, oy);
    }
    if (!drawn) {
      internal_glyph_render_direct(font, scale, g, w, h, x0, y0, ox, oy);
    }
  }
 
  if ((g->style & k_reflow_style_underline) != 0U) {
    internal_draw_underline(font, g, scale, ox, oy);
  }
}

RA8_INTERNAL
static void internal_render_svg(const reflow_t* engine,
                                const uint8_t*  svg,
                                size_t          len,
                                int32_t         x,
                                int32_t         y,
                                int32_t         w,
                                int32_t         h)
{
  size_t hoff = 0U;
  size_t hlen = 0U;
  if (ra8_svg_image_href(svg, len, &hoff, &hlen) != k_ra8_ok) {
    (void)ra8_svg_render(svg, len, x, y, w, h);
    return;
  }
  char href[k_priv_svg_href_max] = {};
  if (hlen >= sizeof(href)) {
    return;
  }
  (void)memcpy(href, &svg[hoff], hlen);
  const uint8_t* rbytes = nullptr;
  size_t         rlen   = 0U;
  if (engine->img_loader(engine->img_loader_ctx, href, (uint32_t)hlen, &rbytes, &rlen) ==
      k_ra8_ok) {
    (void)ra8_img_decode_blit(engine->img_arena, rbytes, rlen, x, y, w, h, nullptr, nullptr);
  }
}

RA8_INTERNAL
static void internal_render_one_image(const reflow_t*           engine,
                                      const reflow_image_box_t* box,
                                      int32_t                   ox,
                                      int32_t                   oy)
{
  const char*    href  = (const char*)&engine->text_pool[box->src_off];
  const uint8_t* bytes = nullptr;
  size_t         blen  = 0U;
  if (engine->img_loader(engine->img_loader_ctx, href, box->src_len, &bytes, &blen) != k_ra8_ok) {
    return;
  }
  const int32_t bx = box->x + ox;
  const int32_t by = box->y + oy;
  if (ra8_svg_is_svg(bytes, blen)) {
    internal_render_svg(engine, bytes, blen, bx, by, box->w, box->h);
    return;
  }
  (void)
    ra8_img_decode_blit(engine->img_arena, bytes, blen, bx, by, box->w, box->h, nullptr, nullptr);
}

RA8_INTERNAL
static void
internal_render_images(const reflow_t* engine, uint32_t page_idx, int32_t ox, int32_t oy)
{
  if ((engine->img_loader == nullptr) || (engine->img_arena == nullptr)) {
    return;
  }
  for (uint32_t i = 0U; i < engine->image_box_count; ++i) {
    const reflow_image_box_t* box = &engine->image_boxes[i];
    if (box->page_index == page_idx) {
      internal_render_one_image(engine, box, ox, oy);
    }
  }
}
 
/* ===========================================================================
 * Public API -- render
 * ===========================================================================
 */

RA8_INTERNAL
static ra8_err_t internal_init_faces(const reflow_t* engine, stbtt_fontinfo* faces, uint8_t* out_n)
{
  const ra8_err_t err = internal_init_font(engine, &faces[0]);
  if (err != k_ra8_ok) {
    return err;
  }
  for (uint8_t k = 0U; k < engine->face_count; ++k) {
    const uint8_t* blob   = engine->faces[k].blob;
    const int32_t  offset = stbtt_GetFontOffsetForIndex(blob, 0);
    if ((offset < 0) ||
        (stbtt_InitFont(&faces[k + 1U], blob, (int)engine->faces[k].len, offset) == 0)) {
      faces[k + 1U] = faces[0]; /* graceful: bad face -> default */
    }
  }
  *out_n = (uint8_t)(engine->face_count + 1U);
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t
internal_render_page(const reflow_t* engine, uint32_t page_idx, int32_t ox, int32_t oy)
{
  if (engine == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (engine->in_use == 0U) {
    return k_ra8_err_not_initialized;
  }
  if (page_idx >= engine->page_count) {
    return k_ra8_err_out_of_range;
  }
 
  /* One fontinfo per face (static because render is single-threaded; keeps the
   * ~1.4 KB off the stack). Default at 0, embedded at 1..N. */
  static stbtt_fontinfo s_faces[1U + (uint32_t)k_reflow_max_faces];
  uint8_t               nfaces = 0U;
  ra8_err_t             err    = internal_init_faces(engine, s_faces, &nfaces);
  if (err != k_ra8_ok) {
    return err;
  }
 
  const reflow_page_t* page  = &engine->pages[page_idx];
  ra8_glyph_atlas_t*   atlas = engine->glyph_atlas;
  for (uint32_t i = 0U; i < page->glyph_count; ++i) {
    const reflow_glyph_t* g  = &engine->glyphs[page->glyph_first + i];
    uint8_t               fi = (uint8_t)(((uint32_t)g->style >> (uint32_t)k_reflow_face_shift) &
                                         (uint32_t)k_reflow_face_mask);
    if (fi >= nfaces) {
      fi = 0U; /* defensive: out-of-range face index -> default */
    }
    internal_blit_glyph(atlas, fi, &s_faces[fi], g, ox, oy);
  }
  internal_render_images(engine, page_idx, ox, oy);
  return k_ra8_ok;
}
 
ra8_err_t reflow_render_page(const reflow_t* engine, uint32_t page_idx, void* framebuffer)
{
  (void)framebuffer; /* Reserved hook -- ra8_gfx is bound externally. */
  return internal_render_page(engine, page_idx, 0, 0);
}
 
ra8_err_t
reflow_render_page_at(const reflow_t* engine, uint32_t page_idx, int32_t origin_x, int32_t origin_y)
{
  return internal_render_page(engine, page_idx, origin_x, origin_y);
}
 
ra8_err_t reflow_set_glyph_atlas(reflow_t*                           engine,
                                 ra8_glyph_atlas_t*                  atlas,
                                 const reflow_glyph_atlas_storage_t* storage)
{
  if (engine == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (engine->in_use == 0U) {
    return k_ra8_err_not_initialized;
  }
  if (atlas == nullptr) {
    engine->glyph_atlas = nullptr; /* Detach -> revert to direct rasterisation. */
    return k_ra8_ok;
  }
  if (storage == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if ((storage->cell_bytes == 0U) || (storage->cell_count == 0U) || (storage->bucket_count == 0U)) {
    return k_ra8_err_invalid_size;
  }
 
  const ra8_glyph_atlas_cfg_t cfg = {
    .cell_mem     = storage->cell_mem,
    .cell_bytes   = storage->cell_bytes,
    .cell_count   = storage->cell_count,
    .meta         = storage->meta,
    .keys         = storage->keys,
    .dims         = storage->dims,
    .buckets      = storage->buckets,
    .bucket_count = storage->bucket_count,
    .render       = internal_atlas_render_glyph,
    .render_ctx   = &s_glyph_render_ctx,
  };
  const ra8_err_t err = ra8_glyph_atlas_init(atlas, &cfg);
  if (err != k_ra8_ok) {
    return err;
  }
  engine->glyph_atlas = atlas;
  return k_ra8_ok;
}