reflow_svg_doc.c

Go to the documentation of this file.

 
#include <string.h>
 
#include "ra8_attributes.h"
#include "reflow_svg.h"
#include "reflow_svg_internal.h"

static const float s_svg_unit = 1.0F;
 
/* ===========================================================================
 * Document parsing + render walk
 * ===========================================================================
 */

RA8_INTERNAL
static bool internal_elem_at(const uint8_t* s, size_t len, size_t at, const char* name)
{
  if (!priv_ra8_svgp_starts_ci(s, len, at, name)) {
    return false;
  }
  const size_t after = at + strlen(name);
  if (after >= len) {
    return true;
  }
  const char c = (char)s[after];
  return priv_ra8_svgp_ws(c) || (c == '>') || (c == '/');
}

RA8_INTERNAL
static bool internal_tag_span(const uint8_t* s,
                              size_t         len,
                              size_t         from,
                              const char*    name,
                              size_t*        open,
                              size_t*        close)
{
  const size_t at = priv_ra8_svgp_find_ci(s, len, from, name);
  if (at >= len) {
    return false;
  }
  size_t j = at;
  while ((j < len) && (s[j] != (uint8_t)'>')) {
    ++j;
  }
  *open  = at;
  *close = j;
  return true;
}

RA8_INTERNAL
static void internal_read_viewbox(const uint8_t* s, size_t len, svg_xform_t* t)
{
  t->vx        = 0;
  t->vy        = 0;
  t->vw        = t->bw;
  t->vh        = t->bh;
  size_t open  = 0U;
  size_t close = 0U;
  if (!internal_tag_span(s, len, 0U, "<svg", &open, &close)) {
    return;
  }
  const uint8_t* tag  = &s[open];
  const size_t   tlen = close - open;
  size_t         voff = 0U;
  size_t         vlen = 0U;
  if (priv_ra8_svgp_attr(tag, tlen, "viewBox", &voff, &vlen)) {
    int32_t nums[k_svg_viewbox_n] = {};
    size_t  k                     = 0U;
    for (size_t n = 0U; n < (size_t)k_svg_viewbox_n; ++n) {
      nums[n] = priv_ra8_svgp_num(&tag[voff], vlen, &k);
    }
    if ((nums[2] > 0) && (nums[3] > 0)) {
      t->vx = nums[0];
      t->vy = nums[1];
      t->vw = nums[2];
      t->vh = nums[3];
    }
  } else {
    const int32_t wv = priv_ra8_svgp_attr_num(tag, tlen, "width", t->bw);
    const int32_t hv = priv_ra8_svgp_attr_num(tag, tlen, "height", t->bh);
    if ((wv > 0) && (hv > 0)) {
      t->vw = wv;
      t->vh = hv;
    }
  }
}

RA8_INTERNAL
static void
internal_dispatch_shape(const uint8_t* s, size_t len, size_t at, size_t close, const svg_xform_t* t)
{
  const uint8_t* tag  = &s[at];
  const size_t   tlen = (close > at) ? (close - at) : 0U;
  /* Compose this element's own `transform=` onto the inherited group transform. */
  svg_xform_t lt = *t;
  priv_ra8_svgp_apply_xform(&lt, tag, tlen);
  if (internal_elem_at(s, len, at, "<rect")) {
    priv_ra8_svgp_draw_rect(tag, tlen, &lt);
  } else if (internal_elem_at(s, len, at, "<circle")) {
    priv_ra8_svgp_draw_circle(tag, tlen, &lt);
  } else if (internal_elem_at(s, len, at, "<polygon")) {
    priv_ra8_svgp_draw_polygon(tag, tlen, &lt);
  } else if (internal_elem_at(s, len, at, "<polyline")) {
    priv_ra8_svgp_draw_polyline(tag, tlen, &lt);
  } else if (internal_elem_at(s, len, at, "<path")) {
    priv_ra8_svgp_draw_path(tag, tlen, &lt);
  } else if (internal_elem_at(s, len, at, "<line")) {
    priv_ra8_svgp_draw_line(tag, tlen, &lt);
  } else {
    /* Unsupported element -> skip. */
  }
}

RA8_INTERNAL
static void internal_xform_with_group(const svg_xform_t* t, svg_utf_t g, svg_xform_t* out)
{
  *out    = *t;
  out->ua = g.a;
  out->ub = g.b;
  out->uc = g.c;
  out->ud = g.d;
  out->ue = g.e;
  out->uf = g.f;
}

RA8_INTERNAL
static int32_t internal_group_open(const uint8_t*     s,
                                   size_t             i,
                                   size_t             close,
                                   const svg_xform_t* t,
                                   svg_utf_t*         gstk,
                                   int32_t            gsp)
{
  svg_xform_t gt = {};
  internal_xform_with_group(t, gstk[gsp], &gt);
  priv_ra8_svgp_apply_xform(&gt, &s[i], (close > i) ? (close - i) : 0U);
  /*
   * internal_group_open is dispatched only for a well-formed element tag whose name
   * occupies at least one byte between '<' (scan position `i`) and '>'
   * (position `close`), so close > i is structurally invariant on every
   * reachable call. The close <= i arm defends against an empty "<>" tag that
   * the upstream element scanner never yields, so the first condition cannot be
   * flipped independently.
   */
  /* mcdc-deactivated: close>i is invariant for a named tag; the empty-"<>" (close<=i) arm is unreachable via public API. */
  const bool self_close = (close > i) && (s[close - 1U] == (uint8_t)'/');
  if (self_close || (gsp >= (int32_t)k_svg_g_depth_max)) {
    return gsp;
  }
  gstk[gsp + 1] =
    (svg_utf_t){.a = gt.ua, .b = gt.ub, .c = gt.uc, .d = gt.ud, .e = gt.ue, .f = gt.uf};
  return gsp + 1;
}

RA8_INTERNAL
static void internal_draw_shapes(const uint8_t* s, size_t len, const svg_xform_t* t)
{
  svg_utf_t gstk[k_svg_g_depth_max + 1U];
  int32_t   gsp = 0;
  gstk[0]  = (svg_utf_t){.a = t->ua, .b = t->ub, .c = t->uc, .d = t->ud, .e = t->ue, .f = t->uf};
  size_t i = 0U;
  /* Bounded: each iteration advances past one '<...>' element or breaks at EOF. */
  while (i < len) {
    while ((i < len) && (s[i] != (uint8_t)'<')) {
      ++i;
    }
    if (i >= len) {
      break;
    }
    size_t close = i;
    while ((close < len) && (s[close] != (uint8_t)'>')) {
      ++close;
    }
    if (internal_elem_at(s, len, i, "</g")) {
      gsp = (gsp > 0) ? (gsp - 1) : 0;
    } else if (internal_elem_at(s, len, i, "<g")) {
      gsp = internal_group_open(s, i, close, t, gstk, gsp);
    } else {
      svg_xform_t ct = {};
      internal_xform_with_group(t, gstk[gsp], &ct);
      internal_dispatch_shape(s, len, i, close, &ct);
    }
    i = (close < len) ? (close + 1U) : len;
  }
}
 
/* ===========================================================================
 * Gradient definitions (<linearGradient> / <radialGradient> + <stop>)
 * ===========================================================================
 */

RA8_INTERNAL
static float internal_attr_numf(const uint8_t* s, size_t len, const char* name, float def)
{
  size_t off = 0U;
  size_t vl  = 0U;
  if (!priv_ra8_svgp_attr(s, len, name, &off, &vl)) {
    return def;
  }
  size_t k = 0U;
  return priv_ra8_svgp_numf(&s[off], vl, &k);
}

RA8_INTERNAL
static void internal_copy_attr_id(const uint8_t* s, size_t len, char* dst)
{
  dst[0]     = '\0';
  size_t off = 0U;
  size_t vl  = 0U;
  if (!priv_ra8_svgp_attr(s, len, "id", &off, &vl)) {
    return;
  }
  const size_t n = (vl < (size_t)(k_svg_grad_id - 1U)) ? vl : (size_t)(k_svg_grad_id - 1U);
  for (size_t i = 0U; i < n; ++i) {
    dst[i] = (char)s[off + i];
  }
  dst[n] = '\0';
}

RA8_INTERNAL
static float internal_clamp01(float v)
{
  if (v < 0.0F) {
    return 0.0F;
  }
  return (v > s_svg_unit) ? s_svg_unit : v;
}

RA8_INTERNAL
static float internal_stop_offset(const uint8_t* tag, size_t tlen)
{
  static const float k_percent = 100.0F;
  size_t             ooff      = 0U;
  size_t             ovl       = 0U;
  if (!priv_ra8_svgp_attr(tag, tlen, "offset", &ooff, &ovl)) {
    return 0.0F;
  }
  size_t      k   = 0U;
  const float off = priv_ra8_svgp_numf(&tag[ooff], ovl, &k);
  for (size_t z = 0U; z < ovl; ++z) {
    if (tag[ooff + z] == (uint8_t)'%') {
      return off / k_percent;
    }
  }
  return off;
}

RA8_INTERNAL
static uint32_t internal_stop_color(const uint8_t* tag, size_t tlen)
{
  size_t coff = 0U;
  size_t cvl  = 0U;
  if (!priv_ra8_svgp_attr(tag, tlen, "stop-color", &coff, &cvl)) {
    return (uint32_t)k_svg_def_fill;
  }
  const uint32_t pc = priv_ra8_svgp_paint(&tag[coff], cvl);
  return (pc != (uint32_t)k_svg_no_paint) ? pc : (uint32_t)k_svg_def_fill;
}

RA8_INTERNAL
static void internal_parse_stops(const uint8_t* s, size_t from, size_t end, svg_grad_t* g)
{
  size_t at = from;
  /* Bounded: <= k_svg_grad_stops stops; `at` advances past each `<stop>`. */
  while (g->nstops < (uint8_t)k_svg_grad_stops) {
    const size_t sp = priv_ra8_svgp_find_ci(s, end, at, "<stop");
    if (sp >= end) {
      break;
    }
    size_t close = sp;
    while ((close < end) && (s[close] != (uint8_t)'>')) {
      ++close;
    }
    const uint8_t* tag      = &s[sp];
    const size_t   tlen     = (close > sp) ? (close - sp) : 0U;
    g->stops[g->nstops].off = internal_clamp01(internal_stop_offset(tag, tlen));
    g->stops[g->nstops].col = internal_stop_color(tag, tlen);
    g->nstops += 1U;
    at = (close < end) ? (close + 1U) : end;
  }
}

RA8_INTERNAL
static void internal_scan_grads(const uint8_t* s, size_t len, svg_grads_t* gs)
{
  static const float k_half = 0.5F;
  gs->n                     = 0;
  size_t from               = 0U;
  /* Bounded: <= k_svg_grad_max gradients; `from` strictly advances each pass. */
  while (gs->n < (int32_t)k_svg_grad_max) {
    const size_t lin    = priv_ra8_svgp_find_ci(s, len, from, "<linearGradient");
    const size_t rad    = priv_ra8_svgp_find_ci(s, len, from, "<radialGradient");
    const bool   is_rad = (rad < lin);
    const size_t at     = is_rad ? rad : lin;
    if (at >= len) {
      break;
    }
    size_t close = at;
    while ((close < len) && (s[close] != (uint8_t)'>')) {
      ++close;
    }
    const uint8_t* tag  = &s[at];
    const size_t   tlen = (close > at) ? (close - at) : 0U;
    svg_grad_t*    g    = &gs->g[gs->n];
    *g                  = (svg_grad_t){};
    g->kind             = is_rad ? (uint8_t)k_svg_grad_radial : (uint8_t)k_svg_grad_linear;
    internal_copy_attr_id(tag, tlen, g->id);
    if (is_rad) {
      g->x1 = internal_attr_numf(tag, tlen, "cx", k_half);
      g->y1 = internal_attr_numf(tag, tlen, "cy", k_half);
      g->x2 = internal_attr_numf(tag, tlen, "r", k_half);
    } else {
      g->x1 = internal_attr_numf(tag, tlen, "x1", 0.0F);
      g->y1 = internal_attr_numf(tag, tlen, "y1", 0.0F);
      g->x2 = internal_attr_numf(tag, tlen, "x2", s_svg_unit);
      g->y2 = internal_attr_numf(tag, tlen, "y2", 0.0F);
    }
    const char*  endtag  = is_rad ? "</radialGradient" : "</linearGradient";
    const size_t endpos  = priv_ra8_svgp_find_ci(s, len, close, endtag);
    const size_t stopend = (endpos < len) ? endpos : len;
    internal_parse_stops(s, close, stopend, g);
    if (g->nstops > 0U) {
      gs->n += 1;
    }
    from = (endpos < len) ? (endpos + 1U) : len;
  }
}
 
/* ===========================================================================
 * Public API
 * ===========================================================================
 */
 
bool ra8_svg_is_svg(const uint8_t* bytes, size_t len)
{
  if ((bytes == nullptr) || (len == 0U)) {
    return false;
  }
  size_t i = 0U;
  /* Skip a UTF-8 BOM if present. */
  if ((len >= (size_t)k_svg_bom_len) && (bytes[0] == (uint8_t)k_svg_bom0) &&
      (bytes[1] == (uint8_t)k_svg_bom1) && (bytes[2] == (uint8_t)k_svg_bom2)) {
    i = (size_t)k_svg_bom_len;
  }
  while ((i < len) && priv_ra8_svgp_ws((char)bytes[i])) {
    ++i;
  }
  return priv_ra8_svgp_starts_ci(bytes, len, i, "<?xml") ||
         priv_ra8_svgp_starts_ci(bytes, len, i, "<svg");
}
 
ra8_err_t ra8_svg_image_href(const uint8_t* svg, size_t len, size_t* out_off, size_t* out_len)
{
  if ((svg == nullptr) || (out_off == nullptr) || (out_len == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  size_t open  = 0U;
  size_t close = 0U;
  if (!internal_tag_span(svg, len, 0U, "<image", &open, &close)) {
    return k_ra8_err_not_found;
  }
  const uint8_t* tag  = &svg[open];
  const size_t   tlen = close - open;
  size_t         voff = 0U;
  size_t         vlen = 0U;
  if (!priv_ra8_svgp_attr(tag, tlen, "xlink:href", &voff, &vlen) &&
      !priv_ra8_svgp_attr(tag, tlen, "href", &voff, &vlen)) {
    return k_ra8_err_not_found;
  }
  *out_off = open + voff;
  *out_len = vlen;
  return k_ra8_ok;
}
 
ra8_err_t ra8_svg_size(const uint8_t* svg, size_t len, int32_t* out_w, int32_t* out_h)
{
  if ((svg == nullptr) || (out_w == nullptr) || (out_h == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  size_t open  = 0U;
  size_t close = 0U;
  if (!internal_tag_span(svg, len, 0U, "<svg", &open, &close)) {
    return k_ra8_err_not_found;
  }
  const uint8_t* tag  = &svg[open];
  const size_t   tlen = close - open;
  int32_t        w    = priv_ra8_svgp_attr_num(tag, tlen, "width", 0);
  int32_t        h    = priv_ra8_svgp_attr_num(tag, tlen, "height", 0);
  if ((w <= 0) || (h <= 0)) {
    size_t voff = 0U;
    size_t vlen = 0U;
    if (priv_ra8_svgp_attr(tag, tlen, "viewBox", &voff, &vlen)) {
      int32_t nums[k_svg_viewbox_n] = {};
      size_t  k                     = 0U;
      for (size_t n = 0U; n < (size_t)k_svg_viewbox_n; ++n) {
        nums[n] = priv_ra8_svgp_num(&tag[voff], vlen, &k);
      }
      w = nums[2];
      h = nums[3];
    }
  }
  if ((w <= 0) || (h <= 0)) {
    return k_ra8_err_not_found;
  }
  *out_w = w;
  *out_h = h;
  return k_ra8_ok;
}
 
ra8_err_t ra8_svg_render(const uint8_t* svg, size_t len, int32_t x, int32_t y, int32_t w, int32_t h)
{
  if (svg == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if ((w <= 0) || (h <= 0)) {
    return k_ra8_err_invalid_arg;
  }
  svg_xform_t t     = {.bx = x,
                       .by = y,
                       .bw = w,
                       .bh = h,
                       .ua = 1.0F,
                       .ub = 0.0F,
                       .uc = 0.0F,
                       .ud = 1.0F,
                       .ue = 0.0F,
                       .uf = 0.0F};
  svg_grads_t grads = {};
  internal_scan_grads(svg, len, &grads);
  t.grads = &grads;
  internal_read_viewbox(svg, len, &t);
  internal_draw_shapes(svg, len, &t);
  return k_ra8_ok;
}