/src/mupdf/source/svg/svg-run.c

Source (jump to first uncovered line)
// Copyright (C) 2004-2025 Artifex Software, Inc.
//
// This file is part of MuPDF.
//
// MuPDF is free software: you can redistribute it and/or modify it under the
// terms of the GNU Affero General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
// details.
//
// You should have received a copy of the GNU Affero General Public License
// along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>
//
// Alternative licensing terms are available from the licensor.
// For commercial licensing, see <https://www.artifex.com/> or contact
// Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
// CA 94129, USA, for further information.

#include "mupdf/fitz.h"
#include "svg-imp.h"

#include <string.h>
#include <math.h>

/* default page size */
#define DEF_WIDTH 612
#define DEF_HEIGHT 792
#define DEF_FONTSIZE 12

#define MAX_USE_DEPTH 100

typedef struct svg_state
{
  fz_matrix transform;
  fz_stroke_state *stroke;
  int use_depth;

  float viewport_w, viewport_h;
  float viewbox_w, viewbox_h, viewbox_size;
  float fontsize;

  float opacity;

  int fill_rule;
  int fill_is_set;
  float fill_color[3];
  float fill_opacity;

  int stroke_is_set;
  float stroke_color[3];
  float stroke_opacity;

  const char *font_family;
  int is_bold;
  int is_italic;
  int text_anchor;
} svg_state;

static void svg_parse_common(fz_context *ctx, svg_document *doc, fz_xml *node, svg_state *state);
static void svg_run_element(fz_context *ctx, fz_device *dev, svg_document *doc, fz_xml *root, const svg_state *state);

void svg_begin_state(fz_context *ctx, svg_state *child, const svg_state *parent)
{
  memcpy(child, parent, sizeof(svg_state));
  child->stroke = fz_clone_stroke_state(ctx, parent->stroke);
}

void svg_end_state(fz_context *ctx, svg_state *child)
{
  fz_drop_stroke_state(ctx, child->stroke);
}

static void svg_fill(fz_context *ctx, fz_device *dev, svg_document *doc, fz_path *path, svg_state *state)
{
  float opacity = state->opacity * state->fill_opacity;
  if (path)
    fz_fill_path(ctx, dev, path, state->fill_rule, state->transform, fz_device_rgb(ctx), state->fill_color, opacity, fz_default_color_params);
}

static void svg_stroke(fz_context *ctx, fz_device *dev, svg_document *doc, fz_path *path, svg_state *state)
{
  float opacity = state->opacity * state->stroke_opacity;
  if (path)
    fz_stroke_path(ctx, dev, path, state->stroke, state->transform, fz_device_rgb(ctx), state->stroke_color, opacity, fz_default_color_params);
}

static void svg_draw_path(fz_context *ctx, fz_device *dev, svg_document *doc, fz_path *path, svg_state *state)
{
  if (state->fill_is_set)
    svg_fill(ctx, dev, doc, path, state);
  if (state->stroke_is_set)
    svg_stroke(ctx, dev, doc, path, state);
}

/*
  We use the MAGIC number 0.551915 as a bezier subdivision to approximate
  a quarter circle arc. The reasons for this can be found here:
  http://mechanicalexpressions.com/explore/geometric-modeling/circle-spline-approximation.pdf
*/
static const float MAGIC_CIRCLE = 0.551915f;

static void approx_circle(fz_context *ctx, fz_path *path, float cx, float cy, float rx, float ry)
{
  float mx = rx * MAGIC_CIRCLE;
  float my = ry * MAGIC_CIRCLE;
  fz_moveto(ctx, path, cx, cy+ry);
  fz_curveto(ctx, path, cx + mx, cy + ry, cx + rx, cy + my, cx + rx, cy);
  fz_curveto(ctx, path, cx + rx, cy - my, cx + mx, cy - ry, cx, cy - ry);
  fz_curveto(ctx, path, cx - mx, cy - ry, cx - rx, cy - my, cx - rx, cy);
  fz_curveto(ctx, path, cx - rx, cy + my, cx - mx, cy + ry, cx, cy + ry);
  fz_closepath(ctx, path);
}

static void
svg_run_rect(fz_context *ctx, fz_device *dev, svg_document *doc, fz_xml *node, const svg_state *inherit_state)
{
  svg_state local_state;

  char *x_att = fz_xml_att(node, "x");
  char *y_att = fz_xml_att(node, "y");
  char *w_att = fz_xml_att(node, "width");
  char *h_att = fz_xml_att(node, "height");
  char *rx_att = fz_xml_att(node, "rx");
  char *ry_att = fz_xml_att(node, "ry");

  float x = 0;
  float y = 0;
  float w = 0;
  float h = 0;
  float rx = 0;
  float ry = 0;

  fz_path *path = NULL;

  fz_var(path);

  fz_try(ctx)
  {
    svg_begin_state(ctx, &local_state, inherit_state);
    svg_parse_common(ctx, doc, node, &local_state);

    if (x_att) x = svg_parse_length(x_att, local_state.viewbox_w, local_state.fontsize);
    if (y_att) y = svg_parse_length(y_att, local_state.viewbox_h, local_state.fontsize);
    if (w_att) w = svg_parse_length(w_att, local_state.viewbox_w, local_state.fontsize);
    if (h_att) h = svg_parse_length(h_att, local_state.viewbox_h, local_state.fontsize);
    if (rx_att) rx = svg_parse_length(rx_att, local_state.viewbox_w, local_state.fontsize);
    if (ry_att) ry = svg_parse_length(ry_att, local_state.viewbox_h, local_state.fontsize);

    if (rx_att && !ry_att)
      ry = rx;
    if (ry_att && !rx_att)
      rx = ry;
    if (rx > w * 0.5f)
      rx = w * 0.5f;
    if (ry > h * 0.5f)
      ry = h * 0.5f;

    if (w <= 0 || h <= 0)
      break;

    path = fz_new_path(ctx);
    if (rx == 0 || ry == 0)
    {
      fz_moveto(ctx, path, x, y);
      fz_lineto(ctx, path, x + w, y);
      fz_lineto(ctx, path, x + w, y + h);
      fz_lineto(ctx, path, x, y + h);
    }
    else
    {
      float rxs = rx * MAGIC_CIRCLE;
      float rys = rx * MAGIC_CIRCLE;
      fz_moveto(ctx, path, x + w - rx, y);
      fz_curveto(ctx, path, x + w - rxs, y, x + w, y + rys, x + w, y + ry);
      fz_lineto(ctx, path, x + w, y + h - ry);
      fz_curveto(ctx, path, x + w, y + h - rys, x + w - rxs, y + h, x + w - rx, y + h);
      fz_lineto(ctx, path, x + rx, y + h);
      fz_curveto(ctx, path, x + rxs, y + h, x, y + h - rys, x, y + h - rx);
      fz_lineto(ctx, path, x, y + rx);
      fz_curveto(ctx, path, x, y + rxs, x + rxs, y, x + rx, y);
    }
    fz_closepath(ctx, path);

    svg_draw_path(ctx, dev, doc, path, &local_state);
  }
  fz_always(ctx)
  {
    fz_drop_path(ctx, path);
    svg_end_state(ctx, &local_state);
  }
  fz_catch(ctx)
    fz_rethrow(ctx);

}

static void
svg_run_circle(fz_context *ctx, fz_device *dev, svg_document *doc, fz_xml *node, const svg_state *inherit_state)
{
  svg_state local_state;

  char *cx_att = fz_xml_att(node, "cx");
  char *cy_att = fz_xml_att(node, "cy");
  char *r_att = fz_xml_att(node, "r");

  float cx = 0;
  float cy = 0;
  float r = 0;
  fz_path *path = NULL;

  fz_var(path);

  fz_try(ctx)
  {
    svg_begin_state(ctx, &local_state, inherit_state);
    svg_parse_common(ctx, doc, node, &local_state);

    if (cx_att) cx = svg_parse_length(cx_att, local_state.viewbox_w, local_state.fontsize);
    if (cy_att) cy = svg_parse_length(cy_att, local_state.viewbox_h, local_state.fontsize);
    if (r_att) r = svg_parse_length(r_att, local_state.viewbox_size, 12);

    if (r > 0)
    {
      path = fz_new_path(ctx);
      approx_circle(ctx, path, cx, cy, r, r);
      svg_draw_path(ctx, dev, doc, path, &local_state);
    }
  }
  fz_always(ctx)
  {
    fz_drop_path(ctx, path);
    svg_end_state(ctx, &local_state);
  }
  fz_catch(ctx)
    fz_rethrow(ctx);

}

static void
svg_run_ellipse(fz_context *ctx, fz_device *dev, svg_document *doc, fz_xml *node, const svg_state *inherit_state)
{
  svg_state local_state;

  char *cx_att = fz_xml_att(node, "cx");
  char *cy_att = fz_xml_att(node, "cy");
  char *rx_att = fz_xml_att(node, "rx");
  char *ry_att = fz_xml_att(node, "ry");

  float cx = 0;
  float cy = 0;
  float rx = 0;
  float ry = 0;

  fz_path *path = NULL;

  fz_var(path);

  fz_try(ctx)
  {
    svg_begin_state(ctx, &local_state, inherit_state);
    svg_parse_common(ctx, doc, node, &local_state);

    if (cx_att) cx = svg_parse_length(cx_att, local_state.viewbox_w, local_state.fontsize);
    if (cy_att) cy = svg_parse_length(cy_att, local_state.viewbox_h, local_state.fontsize);
    if (rx_att) rx = svg_parse_length(rx_att, local_state.viewbox_w, local_state.fontsize);
    if (ry_att) ry = svg_parse_length(ry_att, local_state.viewbox_h, local_state.fontsize);

    if (rx > 0 && ry > 0)
    {
      path = fz_new_path(ctx);
      approx_circle(ctx, path, cx, cy, rx, ry);
      svg_draw_path(ctx, dev, doc, path, &local_state);
    }
  }
  fz_always(ctx)
  {
    fz_drop_path(ctx, path);
    svg_end_state(ctx, &local_state);
  }
  fz_catch(ctx)
    fz_rethrow(ctx);
}

static void
svg_run_line(fz_context *ctx, fz_device *dev, svg_document *doc, fz_xml *node, const svg_state *inherit_state)
{
  svg_state local_state;
  fz_path *path = NULL;

  char *x1_att = fz_xml_att(node, "x1");
  char *y1_att = fz_xml_att(node, "y1");
  char *x2_att = fz_xml_att(node, "x2");
  char *y2_att = fz_xml_att(node, "y2");

  float x1 = 0;
  float y1 = 0;
  float x2 = 0;
  float y2 = 0;

  fz_var(path);

  fz_try(ctx)
  {
    svg_begin_state(ctx, &local_state, inherit_state);
    svg_parse_common(ctx, doc, node, &local_state);

    if (x1_att) x1 = svg_parse_length(x1_att, local_state.viewbox_w, local_state.fontsize);
    if (y1_att) y1 = svg_parse_length(y1_att, local_state.viewbox_h, local_state.fontsize);
    if (x2_att) x2 = svg_parse_length(x2_att, local_state.viewbox_w, local_state.fontsize);
    if (y2_att) y2 = svg_parse_length(y2_att, local_state.viewbox_h, local_state.fontsize);

    if (local_state.stroke_is_set)
    {
      path = fz_new_path(ctx);
      fz_moveto(ctx, path, x1, y1);
      fz_lineto(ctx, path, x2, y2);
      svg_stroke(ctx, dev, doc, path, &local_state);
    }
  }
  fz_always(ctx)
  {
    fz_drop_path(ctx, path);
    svg_end_state(ctx, &local_state);
  }
  fz_catch(ctx)
    fz_rethrow(ctx);
}

static fz_path *
svg_parse_polygon_imp(fz_context *ctx, svg_document *doc, fz_xml *node, int doclose)
{
  fz_path *path;

  const char *str = fz_xml_att(node, "points");
  float number;
  float args[2];
  int nargs;
  int isfirst;

  if (!str)
    return NULL;

  isfirst = 1;
  nargs = 0;

  path = fz_new_path(ctx);
  fz_try(ctx)
  {
    while (*str)
    {
      while (svg_is_whitespace_or_comma(*str))
        str ++;

      if (svg_is_digit(*str))
      {
        str = svg_lex_number(&number, str);
        args[nargs++] = number;
      }
      else
      {
        /* Don't know what this is. Just skip it. */
        fz_warn(ctx, "syntax error in polygon points");
        str++;
      }

      if (nargs == 2)
      {
        if (isfirst)
        {
          fz_moveto(ctx, path, args[0], args[1]);
          isfirst = 0;
        }
        else
        {
          fz_lineto(ctx, path, args[0], args[1]);
        }
        nargs = 0;
      }
    }
  }
  fz_catch(ctx)
  {
    fz_drop_path(ctx, path);
    fz_rethrow(ctx);
  }

  return path;
}

static void
svg_run_polyline(fz_context *ctx, fz_device *dev, svg_document *doc, fz_xml *node, const svg_state *inherit_state)
{
  svg_state local_state;
  fz_path *path = NULL;

  fz_var(path);

  fz_try(ctx)
  {
    svg_begin_state(ctx, &local_state, inherit_state);
    svg_parse_common(ctx, doc, node, &local_state);

    if (local_state.stroke_is_set)
    {
      path = svg_parse_polygon_imp(ctx, doc, node, 0);
      svg_stroke(ctx, dev, doc, path, &local_state);
    }
  }
  fz_always(ctx)
  {
    fz_drop_path(ctx, path);
    svg_end_state(ctx, &local_state);
  }
  fz_catch(ctx)
    fz_rethrow(ctx);
}

static void
svg_run_polygon(fz_context *ctx, fz_device *dev, svg_document *doc, fz_xml *node, const svg_state *inherit_state)
{
  svg_state local_state;
  fz_path *path = NULL;

  fz_var(path);

  fz_try(ctx)
  {
    svg_begin_state(ctx, &local_state, inherit_state);
    svg_parse_common(ctx, doc, node, &local_state);

    path = svg_parse_polygon_imp(ctx, doc, node, 1);
    svg_draw_path(ctx, dev, doc, path, &local_state);
  }
  fz_always(ctx)
  {
    fz_drop_path(ctx, path);
    svg_end_state(ctx, &local_state);
  }
  fz_catch(ctx)
    fz_rethrow(ctx);
}

static void
svg_add_arc_segment(fz_context *ctx, fz_path *path, fz_matrix mtx, float th0, float th1, int iscw)
{
  float t, d;
  fz_point p;

  while (th1 < th0)
    th1 += FZ_PI * 2;

  d = FZ_PI / 180; /* 1-degree precision */

  if (iscw)
  {
    for (t = th0 + d; t < th1 - d/2; t += d)
    {
      p = fz_transform_point_xy(cosf(t), sinf(t), mtx);
      fz_lineto(ctx, path, p.x, p.y);
    }
  }
  else
  {
    th0 += FZ_PI * 2;
    for (t = th0 - d; t > th1 + d/2; t -= d)
    {
      p = fz_transform_point_xy(cosf(t), sinf(t), mtx);
      fz_lineto(ctx, path, p.x, p.y);
    }
  }
}

static float
angle_between(const fz_point u, const fz_point v)
{
  float det = u.x * v.y - u.y * v.x;
  float sign = (det < 0 ? -1 : 1);
  float magu = u.x * u.x + u.y * u.y;
  float magv = v.x * v.x + v.y * v.y;
  float udotv = u.x * v.x + u.y * v.y;
  float t = udotv / (magu * magv);
  /* guard against rounding errors when near |1| (where acos will return NaN) */
  if (t < -1) t = -1;
  if (t > 1) t = 1;
  return sign * acosf(t);
}

static void
svg_add_arc(fz_context *ctx, fz_path *path,
  float size_x, float size_y, float rotation_angle,
  int is_large_arc, int is_clockwise,
  float point_x, float point_y)
{
  fz_matrix rotmat, revmat;
  fz_matrix mtx;
  fz_point pt;
  float rx, ry;
  float x1, y1, x2, y2;
  float x1t, y1t;
  float cxt, cyt, cx, cy;
  float t1, t2, t3;
  float sign;
  float th1, dth;

  pt = fz_currentpoint(ctx, path);
  x1 = pt.x;
  y1 = pt.y;
  x2 = point_x;
  y2 = point_y;
  rx = size_x;
  ry = size_y;

  if (is_clockwise != is_large_arc)
    sign = 1;
  else
    sign = -1;

  rotmat = fz_rotate(rotation_angle);
  revmat = fz_rotate(-rotation_angle);

  /* http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes */
  /* Conversion from endpoint to center parameterization */

  /* F.6.6.1 -- ensure radii are positive and non-zero */
  rx = fabsf(rx);
  ry = fabsf(ry);
  if (rx < 0.001f || ry < 0.001f || (x1 == x2 && y1 == y2))
  {
    fz_lineto(ctx, path, x2, y2);
    return;
  }

  /* F.6.5.1 */
  pt.x = (x1 - x2) / 2;
  pt.y = (y1 - y2) / 2;
  pt = fz_transform_vector(pt, revmat);
  x1t = pt.x;
  y1t = pt.y;

  /* F.6.6.2 -- ensure radii are large enough */
  t1 = (x1t * x1t) / (rx * rx) + (y1t * y1t) / (ry * ry);
  if (t1 > 1)
  {
    rx = rx * sqrtf(t1);
    ry = ry * sqrtf(t1);
  }

  /* F.6.5.2 */
  t1 = (rx * rx * ry * ry) - (rx * rx * y1t * y1t) - (ry * ry * x1t * x1t);
  t2 = (rx * rx * y1t * y1t) + (ry * ry * x1t * x1t);
  t3 = t1 / t2;
  /* guard against rounding errors; sqrt of negative numbers is bad for your health */
  if (t3 < 0) t3 = 0;
  t3 = sqrtf(t3);

  cxt = sign * t3 * (rx * y1t) / ry;
  cyt = sign * t3 * -(ry * x1t) / rx;

  /* F.6.5.3 */
  pt.x = cxt;
  pt.y = cyt;
  pt = fz_transform_vector(pt, rotmat);
  cx = pt.x + (x1 + x2) / 2;
  cy = pt.y + (y1 + y2) / 2;

  /* F.6.5.4 */
  {
    fz_point coord1, coord2, coord3, coord4;
    coord1.x = 1;
    coord1.y = 0;
    coord2.x = (x1t - cxt) / rx;
    coord2.y = (y1t - cyt) / ry;
    coord3.x = (x1t - cxt) / rx;
    coord3.y = (y1t - cyt) / ry;
    coord4.x = (-x1t - cxt) / rx;
    coord4.y = (-y1t - cyt) / ry;
    th1 = angle_between(coord1, coord2);
    dth = angle_between(coord3, coord4);
    if (dth < 0 && !is_clockwise)
      dth += ((FZ_PI / 180) * 360);
    if (dth > 0 && is_clockwise)
      dth -= ((FZ_PI / 180) * 360);
  }

  mtx = fz_pre_scale(fz_pre_rotate(fz_translate(cx, cy), rotation_angle), rx, ry);
  svg_add_arc_segment(ctx, path, mtx, th1, th1 + dth, is_clockwise);

  fz_lineto(ctx, path, point_x, point_y);
}

static void
svg_parse_path_data(fz_context *ctx, fz_path *path, const char *str)
{
  fz_point p;
  float x1, y1, x2, y2;

  int cmd;
  float number;
  float args[7];
  int nargs;

  /* saved control point for smooth curves */
  int reset_smooth = 1;
  float smooth_x = 0.0f;
  float smooth_y = 0.0f;

  cmd = 0;
  nargs = 0;

  fz_moveto(ctx, path, 0.0f, 0.0f); /* for the case of opening 'm' */

  while (*str)
  {
    while (svg_is_whitespace_or_comma(*str))
      str ++;

    /* arcto flag arguments are 1-character 0 or 1 */
    if ((cmd == 'a' || cmd == 'A') && (nargs == 3 || nargs == 4) && (*str == '0' || *str == '1'))
    {
      args[nargs++] = *str++ - '0';
    }
    else if (svg_is_digit(*str))
    {
      str = svg_lex_number(&number, str);
      if (nargs == nelem(args))
      {
        fz_warn(ctx, "stack overflow in path data");
        return;
      }
      args[nargs++] = number;
    }
    else if (svg_is_alpha(*str))
    {
      if (nargs != 0)
      {
        fz_warn(ctx, "syntax error in path data (wrong number of parameters to '%c')", cmd);
        return;
      }
      cmd = *str++;
    }
    else if (*str == 0)
    {
      return;
    }
    else
    {
      fz_warn(ctx, "syntax error in path data: '%c'", *str);
      return;
    }

    if (reset_smooth)
    {
      smooth_x = 0.0f;
      smooth_y = 0.0f;
    }

    reset_smooth = 1;

    switch (cmd)
    {
    case 'M':
      if (nargs == 2)
      {
        fz_moveto(ctx, path, args[0], args[1]);
        nargs = 0;
        cmd = 'L'; /* implicit lineto after */
      }
      break;

    case 'm':
      if (nargs == 2)
      {
        p = fz_currentpoint(ctx, path);
        fz_moveto(ctx, path, p.x + args[0], p.y + args[1]);
        nargs = 0;
        cmd = 'l'; /* implicit lineto after */
      }
      break;

    case 'Z':
    case 'z':
      if (nargs == 0)
      {
        fz_closepath(ctx, path);
      }
      break;

    case 'L':
      if (nargs == 2)
      {
        fz_lineto(ctx, path, args[0], args[1]);
        nargs = 0;
      }
      break;

    case 'l':
      if (nargs == 2)
      {
        p = fz_currentpoint(ctx, path);
        fz_lineto(ctx, path, p.x + args[0], p.y + args[1]);
        nargs = 0;
      }
      break;

    case 'H':
      if (nargs == 1)
      {
        p = fz_currentpoint(ctx, path);
        fz_lineto(ctx, path, args[0], p.y);
        nargs = 0;
      }
      break;

    case 'h':
      if (nargs == 1)
      {
        p = fz_currentpoint(ctx, path);
        fz_lineto(ctx, path, p.x + args[0], p.y);
        nargs = 0;
      }
      break;

    case 'V':
      if (nargs == 1)
      {
        p = fz_currentpoint(ctx, path);
        fz_lineto(ctx, path, p.x, args[0]);
        nargs = 0;
      }
      break;

    case 'v':
      if (nargs == 1)
      {
        p = fz_currentpoint(ctx, path);
        fz_lineto(ctx, path, p.x, p.y + args[0]);
        nargs = 0;
      }
      break;

    case 'C':
      reset_smooth = 0;
      if (nargs == 6)
      {
        fz_curveto(ctx, path, args[0], args[1], args[2], args[3], args[4], args[5]);
        smooth_x = args[4] - args[2];
        smooth_y = args[5] - args[3];
        nargs = 0;
      }
      break;

    case 'c':
      reset_smooth = 0;
      if (nargs == 6)
      {
        p = fz_currentpoint(ctx, path);
        fz_curveto(ctx, path,
          p.x + args[0], p.y + args[1],
          p.x + args[2], p.y + args[3],
          p.x + args[4], p.y + args[5]);
        smooth_x = args[4] - args[2];
        smooth_y = args[5] - args[3];
        nargs = 0;
      }
      break;

    case 'S':
      reset_smooth = 0;
      if (nargs == 4)
      {
        p = fz_currentpoint(ctx, path);
        fz_curveto(ctx, path,
          p.x + smooth_x, p.y + smooth_y,
          args[0], args[1],
          args[2], args[3]);
        smooth_x = args[2] - args[0];
        smooth_y = args[3] - args[1];
        nargs = 0;
      }
      break;

    case 's':
      reset_smooth = 0;
      if (nargs == 4)
      {
        p = fz_currentpoint(ctx, path);
        fz_curveto(ctx, path,
          p.x + smooth_x, p.y + smooth_y,
          p.x + args[0], p.y + args[1],
          p.x + args[2], p.y + args[3]);
        smooth_x = args[2] - args[0];
        smooth_y = args[3] - args[1];
        nargs = 0;
      }
      break;

    case 'Q':
      reset_smooth = 0;
      if (nargs == 4)
      {
        p = fz_currentpoint(ctx, path);
        x1 = args[0];
        y1 = args[1];
        x2 = args[2];
        y2 = args[3];
        fz_curveto(ctx, path,
          (p.x + 2 * x1) / 3, (p.y + 2 * y1) / 3,
          (x2 + 2 * x1) / 3, (y2 + 2 * y1) / 3,
          x2, y2);
        smooth_x = x2 - x1;
        smooth_y = y2 - y1;
        nargs = 0;
      }
      break;

    case 'q':
      reset_smooth = 0;
      if (nargs == 4)
      {
        p = fz_currentpoint(ctx, path);
        x1 = args[0] + p.x;
        y1 = args[1] + p.y;
        x2 = args[2] + p.x;
        y2 = args[3] + p.y;
        fz_curveto(ctx, path,
          (p.x + 2 * x1) / 3, (p.y + 2 * y1) / 3,
          (x2 + 2 * x1) / 3, (y2 + 2 * y1) / 3,
          x2, y2);
        smooth_x = x2 - x1;
        smooth_y = y2 - y1;
        nargs = 0;
      }
      break;

    case 'T':
      reset_smooth = 0;
      if (nargs == 2)
      {
        p = fz_currentpoint(ctx, path);
        x1 = p.x + smooth_x;
        y1 = p.y + smooth_y;
        x2 = args[0];
        y2 = args[1];
        fz_curveto(ctx, path,
          (p.x + 2 * x1) / 3, (p.y + 2 * y1) / 3,
          (x2 + 2 * x1) / 3, (y2 + 2 * y1) / 3,
          x2, y2);
        smooth_x = x2 - x1;
        smooth_y = y2 - y1;
        nargs = 0;
      }
      break;

    case 't':
      reset_smooth = 0;
      if (nargs == 2)
      {
        p = fz_currentpoint(ctx, path);
        x1 = p.x + smooth_x;
        y1 = p.y + smooth_y;
        x2 = args[0] + p.x;
        y2 = args[1] + p.y;
        fz_curveto(ctx, path,
          (p.x + 2 * x1) / 3, (p.y + 2 * y1) / 3,
          (x2 + 2 * x1) / 3, (y2 + 2 * y1) / 3,
          x2, y2);
        smooth_x = x2 - x1;
        smooth_y = y2 - y1;
        nargs = 0;
      }
      break;

    case 'A':
      if (nargs == 7)
      {
        svg_add_arc(ctx, path, args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
        nargs = 0;
      }
      break;
    case 'a':
      if (nargs == 7)
      {
        p = fz_currentpoint(ctx, path);
        svg_add_arc(ctx, path, args[0], args[1], args[2], args[3], args[4], args[5] + p.x, args[6] + p.y);
        nargs = 0;
      }
      break;

    case 0:
      if (nargs != 0)
      {
        fz_warn(ctx, "path data must begin with a command");
        return;
      }
      break;

    default:
      fz_warn(ctx, "unrecognized command in path data: '%c'", cmd);
      return;
    }
  }
}

static void
svg_run_path(fz_context *ctx, fz_device *dev, svg_document *doc, fz_xml *node, const svg_state *inherit_state)
{
  svg_state local_state;
  fz_path *path = NULL;

  const char *d_att = fz_xml_att(node, "d");
  /* unused: char *path_length_att = fz_xml_att(node, "pathLength"); */

  fz_var(path);

  fz_try(ctx)
  {
    svg_begin_state(ctx, &local_state, inherit_state);
    svg_parse_common(ctx, doc, node, &local_state);

    if (d_att)
    {
      path = fz_new_path(ctx);
      svg_parse_path_data(ctx, path, d_att);
      svg_draw_path(ctx, dev, doc, path, &local_state);
    }
  }
  fz_always(ctx)
  {
    fz_drop_path(ctx, path);
    svg_end_state(ctx, &local_state);
  }
  fz_catch(ctx)
    fz_rethrow(ctx);
}

/* svg, symbol, image, foreignObject establish new viewports */
static void
svg_parse_viewport(fz_context *ctx, svg_document *doc, fz_xml *node, svg_state *state)
{
  char *w_att = fz_xml_att(node, "width");
  char *h_att = fz_xml_att(node, "height");

  if (w_att)
    state->viewport_w = svg_parse_length(w_att, state->viewbox_w, state->fontsize);
  if (h_att)
    state->viewport_h = svg_parse_length(h_att, state->viewbox_h, state->fontsize);

}

static void
svg_lex_viewbox(const char *s, float *x, float *y, float *w, float *h)
{
  *x = *y = *w = *h = 0;
  while (svg_is_whitespace_or_comma(*s)) ++s;
  if (svg_is_digit(*s)) s = svg_lex_number(x, s);
  while (svg_is_whitespace_or_comma(*s)) ++s;
  if (svg_is_digit(*s)) s = svg_lex_number(y, s);
  while (svg_is_whitespace_or_comma(*s)) ++s;
  if (svg_is_digit(*s)) s = svg_lex_number(w, s);
  while (svg_is_whitespace_or_comma(*s)) ++s;
  if (svg_is_digit(*s)) s = svg_lex_number(h, s);
}

static int
svg_parse_preserve_aspect_ratio(const char *att, int *x, int *y)
{
  *x = *y = 1;
  if (strstr(att, "none")) return 0;
  if (strstr(att, "xMin")) *x = 0;
  if (strstr(att, "xMid")) *x = 1;
  if (strstr(att, "xMax")) *x = 2;
  if (strstr(att, "YMin")) *y = 0;
  if (strstr(att, "YMid")) *y = 1;
  if (strstr(att, "YMax")) *y = 2;
  return 1;
}

/* svg, symbol, image, foreignObject plus marker, pattern, view can use viewBox to set the transform */
static void
svg_parse_viewbox(fz_context *ctx, svg_document *doc, fz_xml *node, svg_state *state)
{
  char *viewbox_att = fz_xml_att(node, "viewBox");
  char *preserve_att = fz_xml_att(node, "preserveAspectRatio");
  if (viewbox_att)
  {
    /* scale and translate to fit [minx miny minx+w miny+h] to [0 0 viewport.w viewport.h] */
    float min_x, min_y, box_w, box_h, sx, sy;
    int align_x=1, align_y=1, preserve=1;
    float pad_x=0, pad_y=0;

    svg_lex_viewbox(viewbox_att, &min_x, &min_y, &box_w, &box_h);
    sx = state->viewport_w / box_w;
    sy = state->viewport_h / box_h;

    if (preserve_att)
      preserve = svg_parse_preserve_aspect_ratio(preserve_att, &align_x, &align_y);
    if (preserve)
    {
      sx = sy = fz_min(sx, sy);
      if (align_x == 1) pad_x = (box_w * sx - state->viewport_w) / 2;
      if (align_x == 2) pad_x = (box_w * sx - state->viewport_w);
      if (align_y == 1) pad_y = (box_h * sy - state->viewport_h) / 2;
      if (align_y == 2) pad_y = (box_h * sy - state->viewport_h);
      state->transform = fz_concat(fz_translate(-pad_x, -pad_y), state->transform);
    }
    state->transform = fz_concat(fz_scale(sx, sy), state->transform);
    state->transform = fz_concat(fz_translate(-min_x, -min_y), state->transform);
    state->viewbox_w = box_w;
    state->viewbox_h = box_h;
    state->viewbox_size = sqrtf(box_w*box_w + box_h*box_h) / sqrtf(2);
  }
}

static const char *linecap_table[] = { "butt", "round", "square" };
static const char *linejoin_table[] = { "miter", "round", "bevel" };

/* parse transform and presentation attributes */
static void
svg_parse_common(fz_context *ctx, svg_document *doc, fz_xml *node, svg_state *state)
{
  fz_stroke_state *stroke = state->stroke = fz_unshare_stroke_state(ctx, state->stroke);

  char *transform_att = fz_xml_att(node, "transform");

  char *font_size_att = fz_xml_att(node, "font-size");

  char *style_att = fz_xml_att(node, "style");

  // TODO: clip, clip-path, clip-rule

  char *opacity_att = fz_xml_att(node, "opacity");

  char *fill_att = fz_xml_att(node, "fill");
  char *fill_rule_att = fz_xml_att(node, "fill-rule");
  char *fill_opacity_att = fz_xml_att(node, "fill-opacity");

  char *stroke_att = fz_xml_att(node, "stroke");
  char *stroke_opacity_att = fz_xml_att(node, "stroke-opacity");
  char *stroke_width_att = fz_xml_att(node, "stroke-width");
  char *stroke_linecap_att = fz_xml_att(node, "stroke-linecap");
  char *stroke_linejoin_att = fz_xml_att(node, "stroke-linejoin");
  char *stroke_miterlimit_att = fz_xml_att(node, "stroke-miterlimit");
  // TODO: stroke-dasharray, stroke-dashoffset

  // TODO: marker, marker-start, marker-mid, marker-end

  // TODO: overflow
  // TODO: mask

  /* Dirty hack scans of CSS style */
  if (style_att)
  {
    svg_parse_color_from_style(ctx, doc, style_att,
      &state->fill_is_set, state->fill_color,
      &state->stroke_is_set, state->stroke_color);
  }

  if (transform_att)
  {
    state->transform = svg_parse_transform(ctx, doc, transform_att, state->transform);
  }

  if (font_size_att)
  {
    state->fontsize = svg_parse_length(font_size_att, state->fontsize, state->fontsize);
  }
  else
  {
    state->fontsize = svg_parse_number_from_style(ctx, doc, style_att, "font-size", state->fontsize);
  }

  if (opacity_att)
  {
    state->opacity = svg_parse_number(opacity_att, 0, 1, state->opacity);
  }

  if (fill_att)
  {
    if (!strcmp(fill_att, "none"))
    {
      state->fill_is_set = 0;
    }
    else
    {
      state->fill_is_set = 1;
      svg_parse_color(ctx, doc, fill_att, state->fill_color);
    }
  }

  if (fill_opacity_att)
    state->fill_opacity = svg_parse_number(fill_opacity_att, 0, 1, state->fill_opacity);

  if (fill_rule_att)
  {
    if (!strcmp(fill_rule_att, "nonzero"))
      state->fill_rule = 0;
    if (!strcmp(fill_rule_att, "evenodd"))
      state->fill_rule = 1;
  }

  if (stroke_att)
  {
    if (!strcmp(stroke_att, "none"))
    {
      state->stroke_is_set = 0;
    }
    else
    {
      state->stroke_is_set = 1;
      svg_parse_color(ctx, doc, stroke_att, state->stroke_color);
    }
  }

  if (stroke_opacity_att)
    state->stroke_opacity = svg_parse_number(stroke_opacity_att, 0, 1, state->stroke_opacity);

  if (stroke_width_att)
  {
    if (!strcmp(stroke_width_att, "inherit"))
      ;
    else
      stroke->linewidth = svg_parse_length(stroke_width_att, state->viewbox_size, state->fontsize);
  }
  else
  {
    stroke->linewidth = svg_parse_number_from_style(ctx, doc, style_att, "stroke-width", state->stroke->linewidth);
  }

  if (stroke_linecap_att)
  {
    if (!strcmp(stroke_linecap_att, "butt"))
      stroke->start_cap = FZ_LINECAP_BUTT;
    if (!strcmp(stroke_linecap_att, "round"))
      stroke->start_cap = FZ_LINECAP_ROUND;
    if (!strcmp(stroke_linecap_att, "square"))
      stroke->start_cap = FZ_LINECAP_SQUARE;
  }
  else
  {
    stroke->start_cap = svg_parse_enum_from_style(ctx, doc, style_att, "stroke-linecap",
      nelem(linecap_table), linecap_table, stroke->start_cap);
  }

  stroke->dash_cap = stroke->start_cap;
  stroke->end_cap = stroke->start_cap;

  if (stroke_linejoin_att)
  {
    if (!strcmp(stroke_linejoin_att, "miter"))
      stroke->linejoin = FZ_LINEJOIN_MITER;
    if (!strcmp(stroke_linejoin_att, "round"))
      stroke->linejoin = FZ_LINEJOIN_ROUND;
    if (!strcmp(stroke_linejoin_att, "bevel"))
      stroke->linejoin = FZ_LINEJOIN_BEVEL;
  }
  else
  {
    stroke->linejoin = svg_parse_enum_from_style(ctx, doc, style_att, "stroke-linejoin",
      nelem(linejoin_table), linejoin_table, stroke->linejoin);
  }

  if (stroke_miterlimit_att)
  {
    if (!strcmp(stroke_miterlimit_att, "inherit"))
      ;
    else
      stroke->miterlimit = svg_parse_length(stroke_miterlimit_att, state->viewbox_size, state->fontsize);
  }
  else
  {
    stroke->miterlimit = svg_parse_number_from_style(ctx, doc, style_att, "stroke-miterlimit", state->stroke->miterlimit);
  }
}

static void
svg_parse_font_attributes(fz_context *ctx, svg_document *doc, fz_xml *node, svg_state *state, char *buf, int buf_size)
{
  char *style_att = fz_xml_att(node, "style");
  char *font_family_att = fz_xml_att(node, "font-family");
  char *font_weight_att = fz_xml_att(node, "font-weight");
  char *font_style_att = fz_xml_att(node, "font-style");
  char *text_anchor_att = fz_xml_att(node, "text-anchor");

  if (font_family_att)
    fz_strlcpy(buf, font_family_att, buf_size);
  else
    svg_parse_string_from_style(ctx, doc, style_att, "font-family", buf, buf_size, state->font_family);
  state->font_family = buf;

  if (font_weight_att)
  {
    state->is_bold = atoi(font_weight_att) > 400;
    if (!strcmp(font_weight_att, "bold")) state->is_bold = 1;
    if (!strcmp(font_weight_att, "bolder")) state->is_bold = 1;
  }
  else
  {
    static const char *is_bold_table[] = {
      "normal", "100", "200", "300", "400", "bold", "bolder", "500", "600", "700", "800", "900"
    };
    state->is_bold = svg_parse_enum_from_style(ctx, doc, style_att, "font-weight",
      nelem(is_bold_table), is_bold_table, state->is_bold ? 5 : 0) >= 5;
  }

  if (font_style_att)
  {
    state->is_italic = 0;
    if (!strcmp(font_style_att, "italic")) state->is_italic = 1;
    if (!strcmp(font_style_att, "oblique")) state->is_italic = 1;
  }
  else
  {
    static const char *is_italic_table[] = {
      "normal", "italic", "oblique"
    };
    state->is_italic = svg_parse_enum_from_style(ctx, doc, style_att, "font-style",
      nelem(is_italic_table), is_italic_table, state->is_italic) >= 1;
  }

  if (text_anchor_att)
  {
    state->text_anchor = 0;
    if (!strcmp(text_anchor_att, "middle")) state->text_anchor = 1;
    if (!strcmp(text_anchor_att, "end")) state->text_anchor = 2;
  }
  else
  {
    static const char *text_anchor_table[] = {
      "start", "middle", "end"
    };
    state->text_anchor = svg_parse_enum_from_style(ctx, doc, style_att, "text-anchor",
      nelem(text_anchor_table), text_anchor_table, state->text_anchor);
  }
}

static void
svg_run_svg(fz_context *ctx, fz_device *dev, svg_document *doc, fz_xml *root, const svg_state *inherit_state)
{
  svg_state local_state;
  fz_xml *node;

  char *w_att = fz_xml_att(root, "width");
  char *h_att = fz_xml_att(root, "height");
  char *viewbox_att = fz_xml_att(root, "viewBox");

  fz_try(ctx)
  {
    svg_begin_state(ctx, &local_state, inherit_state);

    /* get default viewport from viewBox if width and/or height is missing */
    if (viewbox_att && (!w_att || !h_att))
    {
      float x, y;
      svg_lex_viewbox(viewbox_att, &x, &y, &local_state.viewbox_w, &local_state.viewbox_h);
      if (!w_att) local_state.viewport_w = local_state.viewbox_w;
      if (!h_att) local_state.viewport_h = local_state.viewbox_h;
    }

    svg_parse_viewport(ctx, doc, root, &local_state);
    svg_parse_viewbox(ctx, doc, root, &local_state);
    svg_parse_common(ctx, doc, root, &local_state);

    for (node = fz_xml_down(root); node; node = fz_xml_next(node))
      svg_run_element(ctx, dev, doc, node, &local_state);
  }
  fz_always(ctx)
    svg_end_state(ctx, &local_state);
  fz_catch(ctx)
    fz_rethrow(ctx);
}

static void
svg_run_g(fz_context *ctx, fz_device *dev, svg_document *doc, fz_xml *root, const svg_state *inherit_state)
{
  svg_state local_state;
  fz_xml *node;

  fz_try(ctx)
  {
    svg_begin_state(ctx, &local_state, inherit_state);
    svg_parse_common(ctx, doc, root, &local_state);

    for (node = fz_xml_down(root); node; node = fz_xml_next(node))
      svg_run_element(ctx, dev, doc, node, &local_state);
  }
  fz_always(ctx)
    svg_end_state(ctx, &local_state);
  fz_catch(ctx)
    fz_rethrow(ctx);
}

static void
svg_run_use_symbol(fz_context *ctx, fz_device *dev, svg_document *doc, fz_xml *use, fz_xml *symbol, const svg_state *inherit_state)
{
  svg_state local_state;
  fz_xml *node;

  fz_try(ctx)
  {
    svg_begin_state(ctx, &local_state, inherit_state);

    svg_parse_viewport(ctx, doc, use, &local_state);
    svg_parse_viewbox(ctx, doc, use, &local_state);

    for (node = fz_xml_down(symbol); node; node = fz_xml_next(node))
      svg_run_element(ctx, dev, doc, node, &local_state);
  }
  fz_always(ctx)
    svg_end_state(ctx, &local_state);
  fz_catch(ctx)
    fz_rethrow(ctx);
}

static int
is_use_cycle(fz_xml *use, fz_xml *symbol)
{
  /* If "use" is a direct child of "symbol", we have a recursive symbol/use definition! */
  while (use)
  {
    if (use == symbol)
      return 1;
    use = fz_xml_up(use);
  }
  return 0;
}

static void
svg_run_use(fz_context *ctx, fz_device *dev, svg_document *doc, fz_xml *root, const svg_state *inherit_state)
{
  svg_state local_state;

  char *href_att = fz_xml_att_alt(root, "xlink:href", "href");
  char *x_att = fz_xml_att(root, "x");
  char *y_att = fz_xml_att(root, "y");
  fz_xml *linked = NULL;

  float x = 0;
  float y = 0;

  fz_try(ctx)
  {
    svg_begin_state(ctx, &local_state, inherit_state);

    if (++local_state.use_depth > MAX_USE_DEPTH)
    {
      fz_warn(ctx, "svg: too much recursion");
      break;
    }

    svg_parse_common(ctx, doc, root, &local_state);
    if (x_att) x = svg_parse_length(x_att, local_state.viewbox_w, local_state.fontsize);
    if (y_att) y = svg_parse_length(y_att, local_state.viewbox_h, local_state.fontsize);

    local_state.transform = fz_concat(fz_translate(x, y), local_state.transform);

    if (href_att && href_att[0] == '#')
    {
      linked = fz_tree_lookup(ctx, doc->idmap, href_att + 1);
      if (linked)
      {
        if (is_use_cycle(root, linked))
          fz_warn(ctx, "svg: cyclic <use> reference");

        if (fz_xml_is_tag(linked, "symbol"))
          svg_run_use_symbol(ctx, dev, doc, root, linked, &local_state);
        else
          svg_run_element(ctx, dev, doc, linked, &local_state);
      }
      else
      {
        fz_warn(ctx, "svg: cannot find linked symbol");
      }
    }
    else
    {
      fz_warn(ctx, "svg: cannot find linked symbol");
    }

  }
  fz_always(ctx)
    svg_end_state(ctx, &local_state);
  fz_catch(ctx)
    fz_rethrow(ctx);
}

static void
svg_run_image(fz_context *ctx, fz_device *dev, svg_document *doc, fz_xml *root, const svg_state *inherit_state)
{
  svg_state local_state;
  float x=0, y=0, w=0, h=0;
  const char *data;

  static const char *jpeg_uri = "data:image/jpeg;base64,";
  static const char *png_uri = "data:image/png;base64,";

  char *href_att = fz_xml_att_alt(root, "xlink:href", "href");
  char *x_att = fz_xml_att(root, "x");
  char *y_att = fz_xml_att(root, "y");
  char *w_att = fz_xml_att(root, "width");
  char *h_att = fz_xml_att(root, "height");

  fz_try(ctx)
  {
    svg_begin_state(ctx, &local_state, inherit_state);

    svg_parse_common(ctx, doc, root, &local_state);
    if (x_att) x = svg_parse_length(x_att, local_state.viewbox_w, local_state.fontsize);
    if (y_att) y = svg_parse_length(y_att, local_state.viewbox_h, local_state.fontsize);
    if (w_att) w = svg_parse_length(w_att, local_state.viewbox_w, local_state.fontsize);
    if (h_att) h = svg_parse_length(h_att, local_state.viewbox_h, local_state.fontsize);

    if (w <= 0 || h <= 0)
      break; // out of try-catch

    if (!href_att)
      break; // out of try-catch

    local_state.transform = fz_concat(fz_translate(x, y), local_state.transform);
    local_state.transform = fz_concat(fz_scale(w, h), local_state.transform);

    if (!strncmp(href_att, jpeg_uri, strlen(jpeg_uri)))
      data = href_att + strlen(jpeg_uri);
    else if (!strncmp(href_att, png_uri, strlen(png_uri)))
      data = href_att + strlen(png_uri);
    else
      data = NULL;
    if (data)
    {
      fz_image *img = NULL;
      fz_buffer *buf;

      fz_var(img);

      buf = fz_new_buffer_from_base64(ctx, data, 0);
      fz_try(ctx)
      {
        fz_matrix orient;
        img = fz_new_image_from_buffer(ctx, buf);
        orient = fz_image_orientation_matrix(ctx, img);
        local_state.transform = fz_concat(orient, local_state.transform);
        fz_fill_image(ctx, dev, img, local_state.transform, 1, fz_default_color_params);
      }
      fz_always(ctx)
      {
        fz_drop_buffer(ctx, buf);
        fz_drop_image(ctx, img);
      }
      fz_catch(ctx)
      {
        fz_rethrow_if(ctx, FZ_ERROR_SYSTEM);
        fz_report_error(ctx);
        fz_warn(ctx, "svg: ignoring embedded image '%s'", href_att);
      }
    }
    else if (doc->zip)
    {
      char path[2048];
      fz_buffer *buf = NULL;
      fz_image *img = NULL;

      fz_var(buf);
      fz_var(img);

      fz_strlcpy(path, doc->base_uri, sizeof path);
      fz_strlcat(path, "/", sizeof path);
      fz_strlcat(path, href_att, sizeof path);
      fz_urldecode(path);

      fz_try(ctx)
      {
        fz_matrix orient;
        buf = fz_read_archive_entry(ctx, doc->zip, path);
        img = fz_new_image_from_buffer(ctx, buf);
        orient = fz_image_orientation_matrix(ctx, img);
        local_state.transform = fz_concat(orient, local_state.transform);
        fz_fill_image(ctx, dev, img, local_state.transform, 1, fz_default_color_params);
      }
      fz_always(ctx)
      {
        fz_drop_buffer(ctx, buf);
        fz_drop_image(ctx, img);
      }
      fz_catch(ctx)
      {
        fz_rethrow_if(ctx, FZ_ERROR_SYSTEM);
        fz_report_error(ctx);
        fz_warn(ctx, "svg: ignoring external image '%s'", href_att);
      }
    }
    else
    {
      fz_warn(ctx, "svg: ignoring external image '%s'", href_att);
    }

  }
  fz_always(ctx)
    svg_end_state(ctx, &local_state);
  fz_catch(ctx)
    fz_rethrow(ctx);
}

static fz_font *
svg_load_font(fz_context *ctx, const svg_state *state)
{
  int bold = state->is_bold;
  int italic = state->is_italic;
  int mono = 0;
  int serif = 1;

  /* scan font-family property for common fallback names */

  if (!mono && strstr(state->font_family, "monospace")) mono = 1;
  if (!mono && strstr(state->font_family, "Courier")) mono = 1;

  if (serif && strstr(state->font_family, "sans-serif")) serif = 0;
  if (serif && strstr(state->font_family, "Arial")) serif = 0;
  if (serif && strstr(state->font_family, "Helvetica")) serif = 0;

  if (mono) {
    if (bold) {
      if (italic) return fz_new_base14_font(ctx, "Courier-BoldOblique");
      else return fz_new_base14_font(ctx, "Courier-Bold");
    } else {
      if (italic) return fz_new_base14_font(ctx, "Courier-Oblique");
      else return fz_new_base14_font(ctx, "Courier");
    }
  } else if (serif) {
    if (bold) {
      if (italic) return fz_new_base14_font(ctx, "Times-BoldItalic");
      else return fz_new_base14_font(ctx, "Times-Bold");
    } else {
      if (italic) return fz_new_base14_font(ctx, "Times-Italic");
      else return fz_new_base14_font(ctx, "Times-Roman");
    }
  } else {
    if (bold) {
      if (italic) return fz_new_base14_font(ctx, "Helvetica-BoldOblique");
      else return fz_new_base14_font(ctx, "Helvetica-Bold");
    } else {
      if (italic) return fz_new_base14_font(ctx, "Helvetica-Oblique");
      else return fz_new_base14_font(ctx, "Helvetica");
    }
  }
}

static fz_matrix
svg_run_text_string(fz_context *ctx, fz_device *dev, fz_matrix trm, const char *s, const svg_state *state)
{
  fz_font *font = NULL;
  fz_text *text = NULL;

  fz_var(font);
  fz_var(text);

  fz_try(ctx)
  {
    font = svg_load_font(ctx, state);
    text = fz_new_text(ctx);

    if (state->text_anchor > 0)
    {
      fz_matrix adv = fz_measure_string(ctx, font, trm, s, 0, 0, FZ_BIDI_LTR, FZ_LANG_UNSET);
      if (state->text_anchor == 1)
        trm.e -= (adv.e - trm.e) / 2;
      else if (state->text_anchor == 2)
        trm.e -= (adv.e - trm.e);
    }

    trm = fz_show_string(ctx, text, font, trm, s, 0, 0, FZ_BIDI_LTR, FZ_LANG_UNSET);

    if (state->fill_is_set)
      fz_fill_text(ctx, dev, text,
        state->transform,
        fz_device_rgb(ctx), state->fill_color,
        state->opacity,
        fz_default_color_params);
    if (state->stroke_is_set)
      fz_stroke_text(ctx, dev, text,
        state->stroke,
        state->transform,
        fz_device_rgb(ctx), state->stroke_color,
        state->opacity,
        fz_default_color_params);
    if (!state->fill_is_set && !state->stroke_is_set)
      fz_ignore_text(ctx, dev, text, state->transform);
  }
  fz_always(ctx)
  {
    fz_drop_text(ctx, text);
    fz_drop_font(ctx, font);
  }
  fz_catch(ctx)
  {
    fz_rethrow(ctx);
  }

  return trm;
}

static void
svg_collapse_whitespace(char *start, int is_first, int is_last)
{
  int c, last_c = (is_first ? ' ' : 0);
  char *s, *p;
  s = p = start;
  while ((c = *s++) != 0)
  {
    if (c == '\n' || c == '\r')
      continue;
    if (c == '\t')
      c = ' ';
    if (c == ' ' && last_c == ' ')
      continue;
    *p++ = last_c = c;
  }
  if (is_last && p > start && p[-1] == ' ')
    --p;
  *p = 0;
}

static fz_matrix
svg_run_text(fz_context *ctx, fz_device *dev, svg_document *doc, fz_xml *root, const svg_state *inherit_state,
  float x, float y, int is_first, int is_last)
{
  svg_state local_state;
  char font_family[100];
  fz_xml *node;
  fz_matrix trm;
  int cif, cil;
  char *text;

  char *x_att = fz_xml_att(root, "x");
  char *y_att = fz_xml_att(root, "y");
  char *dx_att = fz_xml_att(root, "dx");
  char *dy_att = fz_xml_att(root, "dy");

  fz_try(ctx)
  {
    svg_begin_state(ctx, &local_state, inherit_state);

    svg_parse_common(ctx, doc, root, &local_state);
    svg_parse_font_attributes(ctx, doc, root, &local_state, font_family, sizeof font_family);

    trm = fz_scale(local_state.fontsize, -local_state.fontsize);
    trm.e = x;
    trm.f = y;

    if (x_att) trm.e = svg_parse_length(x_att, local_state.viewbox_w, local_state.fontsize);
    if (y_att) trm.f = svg_parse_length(y_att, local_state.viewbox_h, local_state.fontsize);

    if (dx_att) trm.e += svg_parse_length(dx_att, local_state.viewbox_w, local_state.fontsize);
    if (dy_att) trm.f += svg_parse_length(dy_att, local_state.viewbox_h, local_state.fontsize);

    cif = is_first;
    for (node = fz_xml_down(root); node; node = fz_xml_next(node))
    {
      cil = is_last && !fz_xml_next(node);
      text = fz_xml_text(node);
      if (text)
      {
        svg_collapse_whitespace(text, cif, cil);
        trm = svg_run_text_string(ctx, dev, trm, text, &local_state);
      }
      else if (fz_xml_is_tag(node, "tspan"))
        trm = svg_run_text(ctx, dev, doc, node, &local_state, trm.e, trm.f, cif, cil);
      else if (fz_xml_is_tag(node, "textPath"))
        trm = svg_run_text(ctx, dev, doc, node, &local_state, trm.e, trm.f, cif, cil);
      cif = 0;
    }
  }
  fz_always(ctx)
    svg_end_state(ctx, &local_state);
  fz_catch(ctx)
    fz_rethrow(ctx);

  return trm;
}

static void
svg_run_element(fz_context *ctx, fz_device *dev, svg_document *doc, fz_xml *root, const svg_state *state)
{
  if (fz_xml_is_tag(root, "svg"))
    svg_run_svg(ctx, dev, doc, root, state);

  else if (fz_xml_is_tag(root, "g"))
    svg_run_g(ctx, dev, doc, root, state);

  else if (fz_xml_is_tag(root, "title"))
    ;
  else if (fz_xml_is_tag(root, "desc"))
    ;

  else if (fz_xml_is_tag(root, "defs"))
    ;
  else if (fz_xml_is_tag(root, "symbol"))
    ;

  else if (fz_xml_is_tag(root, "use"))
    svg_run_use(ctx, dev, doc, root, state);

  else if (fz_xml_is_tag(root, "path"))
    svg_run_path(ctx, dev, doc, root, state);
  else if (fz_xml_is_tag(root, "rect"))
    svg_run_rect(ctx, dev, doc, root, state);
  else if (fz_xml_is_tag(root, "circle"))
    svg_run_circle(ctx, dev, doc, root, state);
  else if (fz_xml_is_tag(root, "ellipse"))
    svg_run_ellipse(ctx, dev, doc, root, state);
  else if (fz_xml_is_tag(root, "line"))
    svg_run_line(ctx, dev, doc, root, state);
  else if (fz_xml_is_tag(root, "polyline"))
    svg_run_polyline(ctx, dev, doc, root, state);
  else if (fz_xml_is_tag(root, "polygon"))
    svg_run_polygon(ctx, dev, doc, root, state);

  else if (fz_xml_is_tag(root, "image"))
    svg_run_image(ctx, dev, doc, root, state);

  else if (fz_xml_is_tag(root, "text"))
    svg_run_text(ctx, dev, doc, root, state, 0, 0, 1, 1);

  else
  {
    /* ignore unrecognized tags */
  }
}

void
svg_parse_document_bounds(fz_context *ctx, svg_document *doc, fz_xml *root)
{
  char *version_att;
  char *w_att;
  char *h_att;
  char *viewbox_att;
  int version;

  if (!fz_xml_is_tag(root, "svg"))
    fz_throw(ctx, FZ_ERROR_SYNTAX, "expected svg element (found %s)", fz_xml_tag(root));

  version_att = fz_xml_att(root, "version");
  w_att = fz_xml_att(root, "width");
  h_att = fz_xml_att(root, "height");
  viewbox_att = fz_xml_att(root, "viewBox");

  version = 10;
  if (version_att)
    version = fz_atof(version_att) * 10;

  if (version > 12)
    fz_warn(ctx, "svg document version is newer than we support");

  /* If no width or height attributes, then guess from the viewbox */
  if (w_att == NULL && h_att == NULL && viewbox_att != NULL)
  {
    float min_x, min_y, box_w, box_h;
    svg_lex_viewbox(viewbox_att, &min_x, &min_y, &box_w, &box_h);
    doc->width = box_w;
    doc->height = box_h;
  }
  else
  {
    doc->width = DEF_WIDTH;
    if (w_att)
      doc->width = svg_parse_length(w_att, doc->width, DEF_FONTSIZE);

    doc->height = DEF_HEIGHT;
    if (h_att)
      doc->height = svg_parse_length(h_att, doc->height, DEF_FONTSIZE);
  }
}

void
svg_run_document(fz_context *ctx, svg_document *doc, fz_xml *root, fz_device *dev, fz_matrix ctm)
{
  svg_state state;

  svg_parse_document_bounds(ctx, doc, root);

  /* Initial graphics state */
  state.transform = ctm;
  state.stroke = fz_new_stroke_state(ctx);
  state.use_depth = 0;

  state.viewport_w = DEF_WIDTH;
  state.viewport_h = DEF_HEIGHT;

  state.viewbox_w = DEF_WIDTH;
  state.viewbox_h = DEF_HEIGHT;
  state.viewbox_size = sqrtf(DEF_WIDTH*DEF_WIDTH + DEF_HEIGHT*DEF_HEIGHT) / sqrtf(2);

  state.fontsize = 12;

  state.opacity = 1;

  state.fill_rule = 0;

  state.fill_is_set = 1;
  state.fill_color[0] = 0;
  state.fill_color[1] = 0;
  state.fill_color[2] = 0;
  state.fill_opacity = 1;

  state.stroke_is_set = 0;
  state.stroke_color[0] = 0;
  state.stroke_color[1] = 0;
  state.stroke_color[2] = 0;
  state.stroke_opacity = 1;

  state.font_family = "serif";
  state.is_bold = 0;
  state.is_italic = 0;
  state.text_anchor = 0;

  fz_try(ctx)
  {
    svg_run_svg(ctx, dev, doc, root, &state);
  }
  fz_always(ctx)
  {
    fz_drop_stroke_state(ctx, state.stroke);
  }
  fz_catch(ctx)
  {
    fz_rethrow(ctx);
  }
}

Coverage Report

Created: 2025-09-04 06:50