diff --git a/src/hb-raster-svg-render.cc b/src/hb-raster-svg-render.cc new file mode 100644 index 000000000..979ac6e58 --- /dev/null +++ b/src/hb-raster-svg-render.cc @@ -0,0 +1,680 @@ +/* + * Copyright © 2026 Behdad Esfahbod + * + * This is part of HarfBuzz, a text shaping library. + * + * Permission is hereby granted, without written agreement and without + * license or royalty fees, to use, copy, modify, and distribute this + * software and its documentation for any purpose, provided that the + * above copyright notice and the following two paragraphs appear in + * all copies of this software. + * + * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR + * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN + * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, + * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO + * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. + * + * Author(s): Behdad Esfahbod + */ + +#include "hb.hh" + +#include "hb-face.hh" +#include "hb-raster.h" +#include "hb-raster-paint.hh" +#include "hb-raster-svg.hh" +#include "hb-raster-svg-base.hh" +#include "hb-raster-svg-parse.hh" +#include "hb-raster-svg-defs.hh" +#include "hb-raster-svg-gradient.hh" +#include "hb-raster-svg-clip.hh" +#include "hb-raster-svg-bbox.hh" +#include "hb-raster-svg-fill.hh" +#include "hb-raster-svg-use.hh" +#include "OT/Color/svg/svg.hh" +#include "hb-draw.h" +#include "hb-ot-color.h" + +#include +#include + + +/* + * 10. SVG rendering context + */ + +#define SVG_MAX_DEPTH 32 + +struct hb_svg_render_context_t +{ + hb_raster_paint_t *paint; + hb_paint_funcs_t *pfuncs; + hb_font_t *font; + unsigned palette; + hb_color_t foreground; + hb_svg_defs_t defs; + int depth = 0; + + /* The full SVG document for resolution */ + const char *doc_start; + unsigned doc_len; + const OT::SVG::accelerator_t *svg_accel = nullptr; + const OT::SVG::svg_doc_cache_t *doc_cache = nullptr; + + void push_transform (float xx, float yx, float xy, float yy, float dx, float dy) + { + hb_paint_push_transform (pfuncs, paint, xx, yx, xy, yy, dx, dy); + } + void pop_transform () + { + hb_paint_pop_transform (pfuncs, paint); + } + void push_group () + { + hb_paint_push_group (pfuncs, paint); + } + void pop_group (hb_paint_composite_mode_t mode) + { + hb_paint_pop_group (pfuncs, paint, mode); + } + void paint_color (hb_color_t color) + { + hb_paint_color (pfuncs, paint, false, color); + } + void pop_clip () + { + hb_paint_pop_clip (pfuncs, paint); + } +}; + +struct hb_svg_cascade_t +{ + hb_svg_str_t fill; + float fill_opacity = 1.f; + hb_svg_str_t clip_path; + hb_color_t color = HB_COLOR (0, 0, 0, 255); + bool visibility = true; + float opacity = 1.f; +}; + +/* + * 11. Element renderer — recursive SVG rendering + */ + +static void svg_render_element (hb_svg_render_context_t *ctx, + hb_svg_xml_parser_t &parser, + const struct hb_svg_cascade_t &inherited); + +/* Gradient def parsing lives in hb-raster-svg-gradient.* */ + +/* Clip-path defs and push helpers live in hb-raster-svg-clip.* */ + +/* Process children — gradients, clipPaths */ +static void +svg_process_defs (hb_svg_render_context_t *ctx, hb_svg_xml_parser_t &parser) +{ + int depth = 1; + + while (depth > 0) + { + hb_svg_token_type_t tok = parser.next (); + if (tok == SVG_TOKEN_EOF) break; + + if (tok == SVG_TOKEN_CLOSE_TAG) + { + depth--; + continue; + } + + if (tok == SVG_TOKEN_OPEN_TAG || tok == SVG_TOKEN_SELF_CLOSE_TAG) + { + if (parser.tag_name.eq ("linearGradient")) + svg_process_gradient_def (&ctx->defs, parser, tok, SVG_GRADIENT_LINEAR, + ctx->pfuncs, ctx->paint, + ctx->foreground, hb_font_get_face (ctx->font), + ctx->palette); + else if (parser.tag_name.eq ("radialGradient")) + svg_process_gradient_def (&ctx->defs, parser, tok, SVG_GRADIENT_RADIAL, + ctx->pfuncs, ctx->paint, + ctx->foreground, hb_font_get_face (ctx->font), + ctx->palette); + else if (parser.tag_name.eq ("clipPath")) + svg_process_clip_path_def (&ctx->defs, parser, tok); + else + { + if (tok == SVG_TOKEN_OPEN_TAG) + depth++; + } + } + } +} + +/* Render a single shape element */ +static void +svg_render_shape (hb_svg_render_context_t *ctx, + hb_svg_shape_emit_data_t &shape, + const hb_svg_cascade_t &state, + hb_svg_str_t transform_str) +{ + bool has_transform = transform_str.len > 0; + bool has_opacity = state.opacity < 1.f; + bool has_clip_path = false; + + if (has_opacity) + ctx->push_group (); + + if (has_transform) + { + hb_svg_transform_t t; + svg_parse_transform (transform_str, &t); + ctx->push_transform (t.xx, t.yx, t.xy, t.yy, t.dx, t.dy); + } + + hb_extents_t<> bbox; + bool has_bbox = svg_compute_shape_bbox (shape, &bbox); + has_clip_path = svg_push_clip_path_ref (ctx->paint, &ctx->defs, state.clip_path, + has_bbox ? &bbox : nullptr); + + /* Clip with shape path, then fill */ + hb_raster_paint_push_clip_path (ctx->paint, svg_shape_path_emit, &shape); + + /* Default fill is black */ + if (state.fill.is_null ()) + { + hb_color_t black = HB_COLOR (0, 0, 0, 255); + if (state.fill_opacity < 1.f) + black = HB_COLOR (0, 0, 0, (uint8_t) (255 * state.fill_opacity + 0.5f)); + ctx->paint_color (black); + } + else + { + hb_svg_fill_context_t fill_ctx = {ctx->paint, ctx->pfuncs, ctx->font, ctx->palette, &ctx->defs}; + svg_emit_fill (&fill_ctx, state.fill, state.fill_opacity, has_bbox ? &bbox : nullptr, state.color); + } + + ctx->pop_clip (); + if (has_clip_path) + ctx->pop_clip (); + + if (has_transform) + ctx->pop_transform (); + + if (has_opacity) + ctx->pop_group (HB_PAINT_COMPOSITE_MODE_SRC_OVER); +} + +static void +svg_render_container_element (hb_svg_render_context_t *ctx, + hb_svg_xml_parser_t &parser, + hb_svg_str_t tag, + bool self_closing, + const hb_svg_cascade_t &state, + hb_svg_str_t transform_str, + hb_svg_str_t clip_path_str) +{ + bool has_transform = transform_str.len > 0; + bool has_opacity = state.opacity < 1.f; + bool has_clip = false; + bool has_viewbox = false; + float vb_x = 0, vb_y = 0, vb_w = 0, vb_h = 0; + + if (tag.eq ("svg")) + { + hb_svg_str_t viewbox_str = parser.find_attr ("viewBox"); + if (viewbox_str.len) + { + has_viewbox = true; + hb_svg_float_parser_t vb_fp (viewbox_str); + vb_x = vb_fp.next_float (); + vb_y = vb_fp.next_float (); + vb_w = vb_fp.next_float (); + vb_h = vb_fp.next_float (); + } + } + + if (has_opacity) + ctx->push_group (); + + if (has_transform) + { + hb_svg_transform_t t; + svg_parse_transform (transform_str, &t); + ctx->push_transform (t.xx, t.yx, t.xy, t.yy, t.dx, t.dy); + } + + if (has_viewbox && vb_w > 0 && vb_h > 0) + ctx->push_transform (1, 0, 0, 1, -vb_x, -vb_y); + + has_clip = svg_push_clip_path_ref (ctx->paint, &ctx->defs, clip_path_str, nullptr); + + if (!self_closing) + { + int depth = 1; + while (depth > 0) + { + hb_svg_token_type_t tok = parser.next (); + if (tok == SVG_TOKEN_EOF) break; + + if (tok == SVG_TOKEN_CLOSE_TAG) + { + depth--; + continue; + } + + if (tok == SVG_TOKEN_OPEN_TAG || tok == SVG_TOKEN_SELF_CLOSE_TAG) + { + hb_svg_str_t child_tag = parser.tag_name; + if (parser.tag_name.eq ("defs")) + { + if (tok != SVG_TOKEN_SELF_CLOSE_TAG) + svg_process_defs (ctx, parser); + continue; + } + svg_render_element (ctx, parser, state); + if (tok == SVG_TOKEN_OPEN_TAG && !child_tag.eq ("g") && + !child_tag.eq ("svg") && !child_tag.eq ("use")) + { + /* Skip children of non-container elements we don't handle. */ + int skip_depth = 1; + while (skip_depth > 0) + { + hb_svg_token_type_t st = parser.next (); + if (st == SVG_TOKEN_EOF) break; + if (st == SVG_TOKEN_CLOSE_TAG) skip_depth--; + else if (st == SVG_TOKEN_OPEN_TAG) skip_depth++; + } + } + } + } + } + + if (has_viewbox && vb_w > 0 && vb_h > 0) + ctx->pop_transform (); + + if (has_clip) + ctx->pop_clip (); + + if (has_transform) + ctx->pop_transform (); + + if (has_opacity) + ctx->pop_group (HB_PAINT_COMPOSITE_MODE_SRC_OVER); +} + +static bool +svg_render_primitive_shape_element (hb_svg_render_context_t *ctx, + hb_svg_xml_parser_t &parser, + hb_svg_str_t tag, + const hb_svg_cascade_t &state, + hb_svg_str_t transform_str) +{ + if (tag.eq ("path")) + { + hb_svg_str_t d = parser.find_attr ("d"); + if (d.len) + { + hb_svg_shape_emit_data_t shape; + shape.type = hb_svg_shape_emit_data_t::SHAPE_PATH; + shape.str_data = d; + svg_render_shape (ctx, shape, state, transform_str); + } + return true; + } + if (tag.eq ("rect")) + { + float x = svg_parse_float (parser.find_attr ("x")); + float y = svg_parse_float (parser.find_attr ("y")); + float w = svg_parse_float (parser.find_attr ("width")); + float h = svg_parse_float (parser.find_attr ("height")); + float rx = svg_parse_float (parser.find_attr ("rx")); + float ry = svg_parse_float (parser.find_attr ("ry")); + + if (w > 0 && h > 0) + { + hb_svg_shape_emit_data_t shape; + shape.type = hb_svg_shape_emit_data_t::SHAPE_RECT; + shape.params[0] = x; + shape.params[1] = y; + shape.params[2] = w; + shape.params[3] = h; + shape.params[4] = rx; + shape.params[5] = ry; + svg_render_shape (ctx, shape, state, transform_str); + } + return true; + } + if (tag.eq ("circle")) + { + float cx = svg_parse_float (parser.find_attr ("cx")); + float cy = svg_parse_float (parser.find_attr ("cy")); + float r = svg_parse_float (parser.find_attr ("r")); + + if (r > 0) + { + hb_svg_shape_emit_data_t shape; + shape.type = hb_svg_shape_emit_data_t::SHAPE_CIRCLE; + shape.params[0] = cx; + shape.params[1] = cy; + shape.params[2] = r; + svg_render_shape (ctx, shape, state, transform_str); + } + return true; + } + if (tag.eq ("ellipse")) + { + float cx = svg_parse_float (parser.find_attr ("cx")); + float cy = svg_parse_float (parser.find_attr ("cy")); + float rx = svg_parse_float (parser.find_attr ("rx")); + float ry = svg_parse_float (parser.find_attr ("ry")); + + if (rx > 0 && ry > 0) + { + hb_svg_shape_emit_data_t shape; + shape.type = hb_svg_shape_emit_data_t::SHAPE_ELLIPSE; + shape.params[0] = cx; + shape.params[1] = cy; + shape.params[2] = rx; + shape.params[3] = ry; + svg_render_shape (ctx, shape, state, transform_str); + } + return true; + } + if (tag.eq ("line")) + { + float x1 = svg_parse_float (parser.find_attr ("x1")); + float y1 = svg_parse_float (parser.find_attr ("y1")); + float x2 = svg_parse_float (parser.find_attr ("x2")); + float y2 = svg_parse_float (parser.find_attr ("y2")); + + hb_svg_shape_emit_data_t shape; + shape.type = hb_svg_shape_emit_data_t::SHAPE_LINE; + shape.params[0] = x1; + shape.params[1] = y1; + shape.params[2] = x2; + shape.params[3] = y2; + svg_render_shape (ctx, shape, state, transform_str); + return true; + } + if (tag.eq ("polyline")) + { + hb_svg_str_t points = parser.find_attr ("points"); + if (points.len) + { + hb_svg_shape_emit_data_t shape; + shape.type = hb_svg_shape_emit_data_t::SHAPE_POLYLINE; + shape.str_data = points; + svg_render_shape (ctx, shape, state, transform_str); + } + return true; + } + if (tag.eq ("polygon")) + { + hb_svg_str_t points = parser.find_attr ("points"); + if (points.len) + { + hb_svg_shape_emit_data_t shape; + shape.type = hb_svg_shape_emit_data_t::SHAPE_POLYGON; + shape.str_data = points; + svg_render_shape (ctx, shape, state, transform_str); + } + return true; + } + + return false; +} + +static void +svg_render_use_callback (void *render_user, + hb_svg_xml_parser_t &parser, + const void *state) +{ + svg_render_element ((hb_svg_render_context_t *) render_user, + parser, + *(const hb_svg_cascade_t *) state); +} + +static void +svg_skip_subtree (hb_svg_xml_parser_t &parser) +{ + int depth = 1; + while (depth > 0) + { + hb_svg_token_type_t tok = parser.next (); + if (tok == SVG_TOKEN_EOF) break; + if (tok == SVG_TOKEN_CLOSE_TAG) depth--; + else if (tok == SVG_TOKEN_OPEN_TAG) depth++; + } +} + +/* Render one element (may be a container or shape) */ +static void +svg_render_element (hb_svg_render_context_t *ctx, + hb_svg_xml_parser_t &parser, + const hb_svg_cascade_t &inherited) +{ + if (ctx->depth >= SVG_MAX_DEPTH) return; + + const HB_UNUSED unsigned transform_depth = ctx->paint->transform_stack.length; + const HB_UNUSED unsigned clip_depth = ctx->paint->clip_stack.length; + const HB_UNUSED unsigned surface_depth = ctx->paint->surface_stack.length; + + ctx->depth++; + + hb_svg_str_t tag = parser.tag_name; + bool self_closing = parser.self_closing; + + /* Extract common attributes */ + hb_svg_str_t style = parser.find_attr ("style"); + hb_svg_style_props_t style_props; + svg_parse_style_props (style, &style_props); + hb_svg_str_t fill_attr = svg_pick_attr_or_style (parser, style_props.fill, "fill"); + hb_svg_str_t fill_opacity_str = svg_pick_attr_or_style (parser, style_props.fill_opacity, "fill-opacity"); + hb_svg_str_t opacity_str = svg_pick_attr_or_style (parser, style_props.opacity, "opacity"); + hb_svg_str_t transform_str = svg_pick_attr_or_style (parser, style_props.transform, "transform"); + hb_svg_str_t clip_path_attr = svg_pick_attr_or_style (parser, style_props.clip_path, "clip-path"); + hb_svg_str_t display_str = svg_pick_attr_or_style (parser, style_props.display, "display"); + hb_svg_str_t color_str = svg_pick_attr_or_style (parser, style_props.color, "color"); + hb_svg_str_t visibility_str = svg_pick_attr_or_style (parser, style_props.visibility, "visibility"); + + hb_svg_cascade_t state = inherited; + state.fill = (fill_attr.is_null () || svg_str_is_inherit (fill_attr)) ? inherited.fill : fill_attr; + state.fill_opacity = (fill_opacity_str.len && !svg_str_is_inherit (fill_opacity_str)) + ? svg_parse_float_clamped01 (fill_opacity_str) + : inherited.fill_opacity; + state.opacity = (opacity_str.len && !svg_str_is_inherit (opacity_str) && !svg_str_is_none (opacity_str)) + ? svg_parse_float_clamped01 (opacity_str) + : (svg_str_is_inherit (opacity_str) ? inherited.opacity : 1.f); + state.clip_path = (clip_path_attr.is_null () || svg_str_is_inherit (clip_path_attr)) + ? inherited.clip_path + : clip_path_attr; + if (svg_str_is_inherit (transform_str) || svg_str_is_none (transform_str)) + transform_str = {}; + state.color = inherited.color; + bool is_none = false; + if (color_str.len && !svg_str_eq_ascii_ci (color_str.trim (), "inherit")) + state.color = svg_parse_color (color_str, ctx->pfuncs, ctx->paint, + inherited.color, hb_font_get_face (ctx->font), + ctx->palette, &is_none); + state.visibility = inherited.visibility; + hb_svg_str_t visibility_trim = visibility_str.trim (); + if (visibility_trim.len && !svg_str_eq_ascii_ci (visibility_trim, "inherit")) + state.visibility = !(svg_str_eq_ascii_ci (visibility_trim, "hidden") || + svg_str_eq_ascii_ci (visibility_trim, "collapse")); + + if (svg_str_eq_ascii_ci (display_str.trim (), "none")) + { + if (!self_closing) + svg_skip_subtree (parser); + ctx->depth--; + assert (ctx->paint->transform_stack.length == transform_depth); + assert (ctx->paint->clip_stack.length == clip_depth); + assert (ctx->paint->surface_stack.length == surface_depth); + return; + } + if (!state.visibility) + { + if (!self_closing) + svg_skip_subtree (parser); + ctx->depth--; + assert (ctx->paint->transform_stack.length == transform_depth); + assert (ctx->paint->clip_stack.length == clip_depth); + assert (ctx->paint->surface_stack.length == surface_depth); + return; + } + + if (tag.eq ("g") || tag.eq ("svg")) + svg_render_container_element (ctx, parser, tag, self_closing, + state, transform_str, state.clip_path); + else if (svg_render_primitive_shape_element (ctx, parser, tag, state, transform_str)) + ; + else if (tag.eq ("use")) + { + hb_svg_use_context_t use_ctx = {ctx->paint, ctx->pfuncs, + ctx->doc_start, ctx->doc_len, + ctx->svg_accel, ctx->doc_cache}; + svg_render_use_element (&use_ctx, parser, &state, transform_str, + svg_render_use_callback, ctx); + } + + ctx->depth--; + + assert (ctx->paint->transform_stack.length == transform_depth); + assert (ctx->paint->clip_stack.length == clip_depth); + assert (ctx->paint->surface_stack.length == surface_depth); +} + + +/* + * 12. Entry point + */ + +hb_bool_t +hb_raster_svg_render (hb_raster_paint_t *paint, + hb_blob_t *blob, + hb_codepoint_t glyph, + hb_font_t *font, + unsigned palette, + hb_color_t foreground) +{ + unsigned data_len; + const char *data = hb_blob_get_data (blob, &data_len); + if (!data || !data_len) return false; + + hb_face_t *face = hb_font_get_face (font); + const OT::SVG::svg_doc_cache_t *doc_cache = nullptr; + unsigned doc_index = 0; + hb_codepoint_t start_glyph = HB_CODEPOINT_INVALID; + hb_codepoint_t end_glyph = HB_CODEPOINT_INVALID; + + if (face && + hb_ot_color_glyph_get_svg_document_index (face, glyph, &doc_index) && + hb_ot_color_get_svg_document_glyph_range (face, doc_index, &start_glyph, &end_glyph)) + doc_cache = face->table.SVG->get_or_create_doc_cache (blob, data, data_len, + doc_index, start_glyph, end_glyph); + + if (doc_cache) + data = face->table.SVG->doc_cache_get_svg (doc_cache, &data_len); + + hb_paint_funcs_t *pfuncs = hb_raster_paint_get_funcs (); + + hb_svg_render_context_t ctx; + ctx.paint = paint; + ctx.pfuncs = pfuncs; + ctx.font = font; + ctx.palette = palette; + ctx.foreground = foreground; + ctx.doc_start = data; + ctx.doc_len = data_len; + ctx.svg_accel = face ? face->table.SVG.get () : nullptr; + ctx.doc_cache = doc_cache; + + hb_svg_cascade_t initial_state; + initial_state.color = foreground; + + /* First pass: collect defs (gradients, clip-paths) from the entire document, + * including entries that are authored outside . */ + { + hb_svg_xml_parser_t defs_parser (data, data_len); + while (true) + { + hb_svg_token_type_t tok = defs_parser.next (); + if (tok == SVG_TOKEN_EOF) break; + if (tok == SVG_TOKEN_OPEN_TAG || tok == SVG_TOKEN_SELF_CLOSE_TAG) + { + if (defs_parser.tag_name.eq ("linearGradient")) + svg_process_gradient_def (&ctx.defs, defs_parser, tok, SVG_GRADIENT_LINEAR, + ctx.pfuncs, ctx.paint, + ctx.foreground, hb_font_get_face (ctx.font), + ctx.palette); + else if (defs_parser.tag_name.eq ("radialGradient")) + svg_process_gradient_def (&ctx.defs, defs_parser, tok, SVG_GRADIENT_RADIAL, + ctx.pfuncs, ctx.paint, + ctx.foreground, hb_font_get_face (ctx.font), + ctx.palette); + else if (defs_parser.tag_name.eq ("clipPath")) + svg_process_clip_path_def (&ctx.defs, defs_parser, tok); + } + } + } + + bool found_glyph = false; + unsigned glyph_start = 0, glyph_end = 0; + if (doc_cache && face->table.SVG->doc_cache_get_glyph_span (doc_cache, glyph, &glyph_start, &glyph_end)) + { + hb_svg_xml_parser_t parser (data + glyph_start, glyph_end - glyph_start); + hb_svg_token_type_t tok = parser.next (); + if (tok == SVG_TOKEN_OPEN_TAG || tok == SVG_TOKEN_SELF_CLOSE_TAG) + { + hb_paint_push_font_transform (ctx.pfuncs, ctx.paint, font); + ctx.push_transform (1, 0, 0, -1, 0, 0); + svg_render_element (&ctx, parser, initial_state); + ctx.pop_transform (); + hb_paint_pop_transform (ctx.pfuncs, ctx.paint); + found_glyph = true; + } + } + else + { + /* Fallback for malformed/uncached docs: linear scan by glyph id. */ + char glyph_id_str[32]; + snprintf (glyph_id_str, sizeof (glyph_id_str), "glyph%u", glyph); + hb_svg_xml_parser_t parser (data, data_len); + while (true) + { + hb_svg_token_type_t tok = parser.next (); + if (tok == SVG_TOKEN_EOF) break; + + if (tok == SVG_TOKEN_OPEN_TAG || tok == SVG_TOKEN_SELF_CLOSE_TAG) + { + hb_svg_str_t id = parser.find_attr ("id"); + if (id.len) + { + char id_buf[64]; + unsigned n = hb_min (id.len, (unsigned) sizeof (id_buf) - 1); + memcpy (id_buf, id.data, n); + id_buf[n] = '\0'; + + if (strcmp (id_buf, glyph_id_str) == 0) + { + hb_paint_push_font_transform (ctx.pfuncs, ctx.paint, font); + ctx.push_transform (1, 0, 0, -1, 0, 0); + svg_render_element (&ctx, parser, initial_state); + ctx.pop_transform (); + hb_paint_pop_transform (ctx.pfuncs, ctx.paint); + found_glyph = true; + break; + } + } + } + } + } + + return found_glyph; +} diff --git a/src/hb-raster-svg.cc b/src/hb-raster-svg.cc index 411e3ab20..8977129f8 100644 --- a/src/hb-raster-svg.cc +++ b/src/hb-raster-svg.cc @@ -361,636 +361,3 @@ svg_parse_color (hb_svg_str_t s, return HB_COLOR (0, 0, 0, 255); } - -/* - * 10. SVG rendering context - */ - -#define SVG_MAX_DEPTH 32 - -struct hb_svg_render_context_t -{ - hb_raster_paint_t *paint; - hb_paint_funcs_t *pfuncs; - hb_font_t *font; - unsigned palette; - hb_color_t foreground; - hb_svg_defs_t defs; - int depth = 0; - - /* The full SVG document for resolution */ - const char *doc_start; - unsigned doc_len; - const OT::SVG::accelerator_t *svg_accel = nullptr; - const OT::SVG::svg_doc_cache_t *doc_cache = nullptr; - - void push_transform (float xx, float yx, float xy, float yy, float dx, float dy) - { - hb_paint_push_transform (pfuncs, paint, xx, yx, xy, yy, dx, dy); - } - void pop_transform () - { - hb_paint_pop_transform (pfuncs, paint); - } - void push_group () - { - hb_paint_push_group (pfuncs, paint); - } - void pop_group (hb_paint_composite_mode_t mode) - { - hb_paint_pop_group (pfuncs, paint, mode); - } - void paint_color (hb_color_t color) - { - hb_paint_color (pfuncs, paint, false, color); - } - void pop_clip () - { - hb_paint_pop_clip (pfuncs, paint); - } -}; - -struct hb_svg_cascade_t -{ - hb_svg_str_t fill; - float fill_opacity = 1.f; - hb_svg_str_t clip_path; - hb_color_t color = HB_COLOR (0, 0, 0, 255); - bool visibility = true; - float opacity = 1.f; -}; - -/* - * 11. Element renderer — recursive SVG rendering - */ - -static void svg_render_element (hb_svg_render_context_t *ctx, - hb_svg_xml_parser_t &parser, - const struct hb_svg_cascade_t &inherited); - -/* Gradient def parsing lives in hb-raster-svg-gradient.* */ - -/* Clip-path defs and push helpers live in hb-raster-svg-clip.* */ - -/* Process children — gradients, clipPaths */ -static void -svg_process_defs (hb_svg_render_context_t *ctx, hb_svg_xml_parser_t &parser) -{ - int depth = 1; - - while (depth > 0) - { - hb_svg_token_type_t tok = parser.next (); - if (tok == SVG_TOKEN_EOF) break; - - if (tok == SVG_TOKEN_CLOSE_TAG) - { - depth--; - continue; - } - - if (tok == SVG_TOKEN_OPEN_TAG || tok == SVG_TOKEN_SELF_CLOSE_TAG) - { - if (parser.tag_name.eq ("linearGradient")) - svg_process_gradient_def (&ctx->defs, parser, tok, SVG_GRADIENT_LINEAR, - ctx->pfuncs, ctx->paint, - ctx->foreground, hb_font_get_face (ctx->font), - ctx->palette); - else if (parser.tag_name.eq ("radialGradient")) - svg_process_gradient_def (&ctx->defs, parser, tok, SVG_GRADIENT_RADIAL, - ctx->pfuncs, ctx->paint, - ctx->foreground, hb_font_get_face (ctx->font), - ctx->palette); - else if (parser.tag_name.eq ("clipPath")) - svg_process_clip_path_def (&ctx->defs, parser, tok); - else - { - if (tok == SVG_TOKEN_OPEN_TAG) - depth++; - } - } - } -} - -/* Render a single shape element */ -static void -svg_render_shape (hb_svg_render_context_t *ctx, - hb_svg_shape_emit_data_t &shape, - const hb_svg_cascade_t &state, - hb_svg_str_t transform_str) -{ - bool has_transform = transform_str.len > 0; - bool has_opacity = state.opacity < 1.f; - bool has_clip_path = false; - - if (has_opacity) - ctx->push_group (); - - if (has_transform) - { - hb_svg_transform_t t; - svg_parse_transform (transform_str, &t); - ctx->push_transform (t.xx, t.yx, t.xy, t.yy, t.dx, t.dy); - } - - hb_extents_t<> bbox; - bool has_bbox = svg_compute_shape_bbox (shape, &bbox); - has_clip_path = svg_push_clip_path_ref (ctx->paint, &ctx->defs, state.clip_path, - has_bbox ? &bbox : nullptr); - - /* Clip with shape path, then fill */ - hb_raster_paint_push_clip_path (ctx->paint, svg_shape_path_emit, &shape); - - /* Default fill is black */ - if (state.fill.is_null ()) - { - hb_color_t black = HB_COLOR (0, 0, 0, 255); - if (state.fill_opacity < 1.f) - black = HB_COLOR (0, 0, 0, (uint8_t) (255 * state.fill_opacity + 0.5f)); - ctx->paint_color (black); - } - else - { - hb_svg_fill_context_t fill_ctx = {ctx->paint, ctx->pfuncs, ctx->font, ctx->palette, &ctx->defs}; - svg_emit_fill (&fill_ctx, state.fill, state.fill_opacity, has_bbox ? &bbox : nullptr, state.color); - } - - ctx->pop_clip (); - if (has_clip_path) - ctx->pop_clip (); - - if (has_transform) - ctx->pop_transform (); - - if (has_opacity) - ctx->pop_group (HB_PAINT_COMPOSITE_MODE_SRC_OVER); -} - -static void -svg_render_container_element (hb_svg_render_context_t *ctx, - hb_svg_xml_parser_t &parser, - hb_svg_str_t tag, - bool self_closing, - const hb_svg_cascade_t &state, - hb_svg_str_t transform_str, - hb_svg_str_t clip_path_str) -{ - bool has_transform = transform_str.len > 0; - bool has_opacity = state.opacity < 1.f; - bool has_clip = false; - bool has_viewbox = false; - float vb_x = 0, vb_y = 0, vb_w = 0, vb_h = 0; - - if (tag.eq ("svg")) - { - hb_svg_str_t viewbox_str = parser.find_attr ("viewBox"); - if (viewbox_str.len) - { - has_viewbox = true; - hb_svg_float_parser_t vb_fp (viewbox_str); - vb_x = vb_fp.next_float (); - vb_y = vb_fp.next_float (); - vb_w = vb_fp.next_float (); - vb_h = vb_fp.next_float (); - } - } - - if (has_opacity) - ctx->push_group (); - - if (has_transform) - { - hb_svg_transform_t t; - svg_parse_transform (transform_str, &t); - ctx->push_transform (t.xx, t.yx, t.xy, t.yy, t.dx, t.dy); - } - - if (has_viewbox && vb_w > 0 && vb_h > 0) - ctx->push_transform (1, 0, 0, 1, -vb_x, -vb_y); - - has_clip = svg_push_clip_path_ref (ctx->paint, &ctx->defs, clip_path_str, nullptr); - - if (!self_closing) - { - int depth = 1; - while (depth > 0) - { - hb_svg_token_type_t tok = parser.next (); - if (tok == SVG_TOKEN_EOF) break; - - if (tok == SVG_TOKEN_CLOSE_TAG) - { - depth--; - continue; - } - - if (tok == SVG_TOKEN_OPEN_TAG || tok == SVG_TOKEN_SELF_CLOSE_TAG) - { - hb_svg_str_t child_tag = parser.tag_name; - if (parser.tag_name.eq ("defs")) - { - if (tok != SVG_TOKEN_SELF_CLOSE_TAG) - svg_process_defs (ctx, parser); - continue; - } - svg_render_element (ctx, parser, state); - if (tok == SVG_TOKEN_OPEN_TAG && !child_tag.eq ("g") && - !child_tag.eq ("svg") && !child_tag.eq ("use")) - { - /* Skip children of non-container elements we don't handle. */ - int skip_depth = 1; - while (skip_depth > 0) - { - hb_svg_token_type_t st = parser.next (); - if (st == SVG_TOKEN_EOF) break; - if (st == SVG_TOKEN_CLOSE_TAG) skip_depth--; - else if (st == SVG_TOKEN_OPEN_TAG) skip_depth++; - } - } - } - } - } - - if (has_viewbox && vb_w > 0 && vb_h > 0) - ctx->pop_transform (); - - if (has_clip) - ctx->pop_clip (); - - if (has_transform) - ctx->pop_transform (); - - if (has_opacity) - ctx->pop_group (HB_PAINT_COMPOSITE_MODE_SRC_OVER); -} - -static bool -svg_render_primitive_shape_element (hb_svg_render_context_t *ctx, - hb_svg_xml_parser_t &parser, - hb_svg_str_t tag, - const hb_svg_cascade_t &state, - hb_svg_str_t transform_str) -{ - if (tag.eq ("path")) - { - hb_svg_str_t d = parser.find_attr ("d"); - if (d.len) - { - hb_svg_shape_emit_data_t shape; - shape.type = hb_svg_shape_emit_data_t::SHAPE_PATH; - shape.str_data = d; - svg_render_shape (ctx, shape, state, transform_str); - } - return true; - } - if (tag.eq ("rect")) - { - float x = svg_parse_float (parser.find_attr ("x")); - float y = svg_parse_float (parser.find_attr ("y")); - float w = svg_parse_float (parser.find_attr ("width")); - float h = svg_parse_float (parser.find_attr ("height")); - float rx = svg_parse_float (parser.find_attr ("rx")); - float ry = svg_parse_float (parser.find_attr ("ry")); - - if (w > 0 && h > 0) - { - hb_svg_shape_emit_data_t shape; - shape.type = hb_svg_shape_emit_data_t::SHAPE_RECT; - shape.params[0] = x; - shape.params[1] = y; - shape.params[2] = w; - shape.params[3] = h; - shape.params[4] = rx; - shape.params[5] = ry; - svg_render_shape (ctx, shape, state, transform_str); - } - return true; - } - if (tag.eq ("circle")) - { - float cx = svg_parse_float (parser.find_attr ("cx")); - float cy = svg_parse_float (parser.find_attr ("cy")); - float r = svg_parse_float (parser.find_attr ("r")); - - if (r > 0) - { - hb_svg_shape_emit_data_t shape; - shape.type = hb_svg_shape_emit_data_t::SHAPE_CIRCLE; - shape.params[0] = cx; - shape.params[1] = cy; - shape.params[2] = r; - svg_render_shape (ctx, shape, state, transform_str); - } - return true; - } - if (tag.eq ("ellipse")) - { - float cx = svg_parse_float (parser.find_attr ("cx")); - float cy = svg_parse_float (parser.find_attr ("cy")); - float rx = svg_parse_float (parser.find_attr ("rx")); - float ry = svg_parse_float (parser.find_attr ("ry")); - - if (rx > 0 && ry > 0) - { - hb_svg_shape_emit_data_t shape; - shape.type = hb_svg_shape_emit_data_t::SHAPE_ELLIPSE; - shape.params[0] = cx; - shape.params[1] = cy; - shape.params[2] = rx; - shape.params[3] = ry; - svg_render_shape (ctx, shape, state, transform_str); - } - return true; - } - if (tag.eq ("line")) - { - float x1 = svg_parse_float (parser.find_attr ("x1")); - float y1 = svg_parse_float (parser.find_attr ("y1")); - float x2 = svg_parse_float (parser.find_attr ("x2")); - float y2 = svg_parse_float (parser.find_attr ("y2")); - - hb_svg_shape_emit_data_t shape; - shape.type = hb_svg_shape_emit_data_t::SHAPE_LINE; - shape.params[0] = x1; - shape.params[1] = y1; - shape.params[2] = x2; - shape.params[3] = y2; - svg_render_shape (ctx, shape, state, transform_str); - return true; - } - if (tag.eq ("polyline")) - { - hb_svg_str_t points = parser.find_attr ("points"); - if (points.len) - { - hb_svg_shape_emit_data_t shape; - shape.type = hb_svg_shape_emit_data_t::SHAPE_POLYLINE; - shape.str_data = points; - svg_render_shape (ctx, shape, state, transform_str); - } - return true; - } - if (tag.eq ("polygon")) - { - hb_svg_str_t points = parser.find_attr ("points"); - if (points.len) - { - hb_svg_shape_emit_data_t shape; - shape.type = hb_svg_shape_emit_data_t::SHAPE_POLYGON; - shape.str_data = points; - svg_render_shape (ctx, shape, state, transform_str); - } - return true; - } - - return false; -} - -static void -svg_render_use_callback (void *render_user, - hb_svg_xml_parser_t &parser, - const void *state) -{ - svg_render_element ((hb_svg_render_context_t *) render_user, - parser, - *(const hb_svg_cascade_t *) state); -} - -static void -svg_skip_subtree (hb_svg_xml_parser_t &parser) -{ - int depth = 1; - while (depth > 0) - { - hb_svg_token_type_t tok = parser.next (); - if (tok == SVG_TOKEN_EOF) break; - if (tok == SVG_TOKEN_CLOSE_TAG) depth--; - else if (tok == SVG_TOKEN_OPEN_TAG) depth++; - } -} - -/* Render one element (may be a container or shape) */ -static void -svg_render_element (hb_svg_render_context_t *ctx, - hb_svg_xml_parser_t &parser, - const hb_svg_cascade_t &inherited) -{ - if (ctx->depth >= SVG_MAX_DEPTH) return; - - const HB_UNUSED unsigned transform_depth = ctx->paint->transform_stack.length; - const HB_UNUSED unsigned clip_depth = ctx->paint->clip_stack.length; - const HB_UNUSED unsigned surface_depth = ctx->paint->surface_stack.length; - - ctx->depth++; - - hb_svg_str_t tag = parser.tag_name; - bool self_closing = parser.self_closing; - - /* Extract common attributes */ - hb_svg_str_t style = parser.find_attr ("style"); - hb_svg_style_props_t style_props; - svg_parse_style_props (style, &style_props); - hb_svg_str_t fill_attr = svg_pick_attr_or_style (parser, style_props.fill, "fill"); - hb_svg_str_t fill_opacity_str = svg_pick_attr_or_style (parser, style_props.fill_opacity, "fill-opacity"); - hb_svg_str_t opacity_str = svg_pick_attr_or_style (parser, style_props.opacity, "opacity"); - hb_svg_str_t transform_str = svg_pick_attr_or_style (parser, style_props.transform, "transform"); - hb_svg_str_t clip_path_attr = svg_pick_attr_or_style (parser, style_props.clip_path, "clip-path"); - hb_svg_str_t display_str = svg_pick_attr_or_style (parser, style_props.display, "display"); - hb_svg_str_t color_str = svg_pick_attr_or_style (parser, style_props.color, "color"); - hb_svg_str_t visibility_str = svg_pick_attr_or_style (parser, style_props.visibility, "visibility"); - - hb_svg_cascade_t state = inherited; - state.fill = (fill_attr.is_null () || svg_str_is_inherit (fill_attr)) ? inherited.fill : fill_attr; - state.fill_opacity = (fill_opacity_str.len && !svg_str_is_inherit (fill_opacity_str)) - ? svg_parse_float_clamped01 (fill_opacity_str) - : inherited.fill_opacity; - state.opacity = (opacity_str.len && !svg_str_is_inherit (opacity_str) && !svg_str_is_none (opacity_str)) - ? svg_parse_float_clamped01 (opacity_str) - : (svg_str_is_inherit (opacity_str) ? inherited.opacity : 1.f); - state.clip_path = (clip_path_attr.is_null () || svg_str_is_inherit (clip_path_attr)) - ? inherited.clip_path - : clip_path_attr; - if (svg_str_is_inherit (transform_str) || svg_str_is_none (transform_str)) - transform_str = {}; - state.color = inherited.color; - bool is_none = false; - if (color_str.len && !svg_str_eq_ascii_ci (color_str.trim (), "inherit")) - state.color = svg_parse_color (color_str, ctx->pfuncs, ctx->paint, - inherited.color, hb_font_get_face (ctx->font), - ctx->palette, &is_none); - state.visibility = inherited.visibility; - hb_svg_str_t visibility_trim = visibility_str.trim (); - if (visibility_trim.len && !svg_str_eq_ascii_ci (visibility_trim, "inherit")) - state.visibility = !(svg_str_eq_ascii_ci (visibility_trim, "hidden") || - svg_str_eq_ascii_ci (visibility_trim, "collapse")); - - if (svg_str_eq_ascii_ci (display_str.trim (), "none")) - { - if (!self_closing) - svg_skip_subtree (parser); - ctx->depth--; - assert (ctx->paint->transform_stack.length == transform_depth); - assert (ctx->paint->clip_stack.length == clip_depth); - assert (ctx->paint->surface_stack.length == surface_depth); - return; - } - if (!state.visibility) - { - if (!self_closing) - svg_skip_subtree (parser); - ctx->depth--; - assert (ctx->paint->transform_stack.length == transform_depth); - assert (ctx->paint->clip_stack.length == clip_depth); - assert (ctx->paint->surface_stack.length == surface_depth); - return; - } - - if (tag.eq ("g") || tag.eq ("svg")) - svg_render_container_element (ctx, parser, tag, self_closing, - state, transform_str, state.clip_path); - else if (svg_render_primitive_shape_element (ctx, parser, tag, state, transform_str)) - ; - else if (tag.eq ("use")) - { - hb_svg_use_context_t use_ctx = {ctx->paint, ctx->pfuncs, - ctx->doc_start, ctx->doc_len, - ctx->svg_accel, ctx->doc_cache}; - svg_render_use_element (&use_ctx, parser, &state, transform_str, - svg_render_use_callback, ctx); - } - - ctx->depth--; - - assert (ctx->paint->transform_stack.length == transform_depth); - assert (ctx->paint->clip_stack.length == clip_depth); - assert (ctx->paint->surface_stack.length == surface_depth); -} - - -/* - * 12. Entry point - */ - -hb_bool_t -hb_raster_svg_render (hb_raster_paint_t *paint, - hb_blob_t *blob, - hb_codepoint_t glyph, - hb_font_t *font, - unsigned palette, - hb_color_t foreground) -{ - unsigned data_len; - const char *data = hb_blob_get_data (blob, &data_len); - if (!data || !data_len) return false; - - hb_face_t *face = hb_font_get_face (font); - const OT::SVG::svg_doc_cache_t *doc_cache = nullptr; - unsigned doc_index = 0; - hb_codepoint_t start_glyph = HB_CODEPOINT_INVALID; - hb_codepoint_t end_glyph = HB_CODEPOINT_INVALID; - - if (face && - hb_ot_color_glyph_get_svg_document_index (face, glyph, &doc_index) && - hb_ot_color_get_svg_document_glyph_range (face, doc_index, &start_glyph, &end_glyph)) - doc_cache = face->table.SVG->get_or_create_doc_cache (blob, data, data_len, - doc_index, start_glyph, end_glyph); - - if (doc_cache) - data = face->table.SVG->doc_cache_get_svg (doc_cache, &data_len); - - hb_paint_funcs_t *pfuncs = hb_raster_paint_get_funcs (); - - hb_svg_render_context_t ctx; - ctx.paint = paint; - ctx.pfuncs = pfuncs; - ctx.font = font; - ctx.palette = palette; - ctx.foreground = foreground; - ctx.doc_start = data; - ctx.doc_len = data_len; - ctx.svg_accel = face ? face->table.SVG.get () : nullptr; - ctx.doc_cache = doc_cache; - - hb_svg_cascade_t initial_state; - initial_state.color = foreground; - - /* First pass: collect defs (gradients, clip-paths) from the entire document, - * including entries that are authored outside . */ - { - hb_svg_xml_parser_t defs_parser (data, data_len); - while (true) - { - hb_svg_token_type_t tok = defs_parser.next (); - if (tok == SVG_TOKEN_EOF) break; - if (tok == SVG_TOKEN_OPEN_TAG || tok == SVG_TOKEN_SELF_CLOSE_TAG) - { - if (defs_parser.tag_name.eq ("linearGradient")) - svg_process_gradient_def (&ctx.defs, defs_parser, tok, SVG_GRADIENT_LINEAR, - ctx.pfuncs, ctx.paint, - ctx.foreground, hb_font_get_face (ctx.font), - ctx.palette); - else if (defs_parser.tag_name.eq ("radialGradient")) - svg_process_gradient_def (&ctx.defs, defs_parser, tok, SVG_GRADIENT_RADIAL, - ctx.pfuncs, ctx.paint, - ctx.foreground, hb_font_get_face (ctx.font), - ctx.palette); - else if (defs_parser.tag_name.eq ("clipPath")) - svg_process_clip_path_def (&ctx.defs, defs_parser, tok); - } - } - } - - bool found_glyph = false; - unsigned glyph_start = 0, glyph_end = 0; - if (doc_cache && face->table.SVG->doc_cache_get_glyph_span (doc_cache, glyph, &glyph_start, &glyph_end)) - { - hb_svg_xml_parser_t parser (data + glyph_start, glyph_end - glyph_start); - hb_svg_token_type_t tok = parser.next (); - if (tok == SVG_TOKEN_OPEN_TAG || tok == SVG_TOKEN_SELF_CLOSE_TAG) - { - hb_paint_push_font_transform (ctx.pfuncs, ctx.paint, font); - ctx.push_transform (1, 0, 0, -1, 0, 0); - svg_render_element (&ctx, parser, initial_state); - ctx.pop_transform (); - hb_paint_pop_transform (ctx.pfuncs, ctx.paint); - found_glyph = true; - } - } - else - { - /* Fallback for malformed/uncached docs: linear scan by glyph id. */ - char glyph_id_str[32]; - snprintf (glyph_id_str, sizeof (glyph_id_str), "glyph%u", glyph); - hb_svg_xml_parser_t parser (data, data_len); - while (true) - { - hb_svg_token_type_t tok = parser.next (); - if (tok == SVG_TOKEN_EOF) break; - - if (tok == SVG_TOKEN_OPEN_TAG || tok == SVG_TOKEN_SELF_CLOSE_TAG) - { - hb_svg_str_t id = parser.find_attr ("id"); - if (id.len) - { - char id_buf[64]; - unsigned n = hb_min (id.len, (unsigned) sizeof (id_buf) - 1); - memcpy (id_buf, id.data, n); - id_buf[n] = '\0'; - - if (strcmp (id_buf, glyph_id_str) == 0) - { - hb_paint_push_font_transform (ctx.pfuncs, ctx.paint, font); - ctx.push_transform (1, 0, 0, -1, 0, 0); - svg_render_element (&ctx, parser, initial_state); - ctx.pop_transform (); - hb_paint_pop_transform (ctx.pfuncs, ctx.paint); - found_glyph = true; - break; - } - } - } - } - } - - return found_glyph; -} diff --git a/src/meson.build b/src/meson.build index 489f78211..37bc35d36 100644 --- a/src/meson.build +++ b/src/meson.build @@ -719,6 +719,7 @@ hb_raster_sources = [ 'hb-raster-svg-fill.hh', 'hb-raster-svg-use.cc', 'hb-raster-svg-use.hh', + 'hb-raster-svg-render.cc', 'hb-raster-svg-parse.cc', 'hb-raster-svg-parse.hh', 'hb-raster-paint.cc',