From 3fa9ba24736137f1c1d48d91f4dc9da0e09f5517 Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Sun, 12 Apr 2026 21:27:00 -0600 Subject: [PATCH 1/3] [api] Add _clear() companions to _reset() across render contexts MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Introduce a public _clear() entry point on each render-context type that discards accumulated output state while preserving user configuration. _reset() is redefined as _clear() plus resetting user configuration to defaults — same observable effect as before, but now there is one code path for the output-state teardown. New public API: hb_vector_draw_clear() hb_vector_paint_clear() hb_raster_draw_clear() hb_raster_paint_clear() hb_gpu_draw_clear() Contract: _clear(): preserves transform, scale factors, precision, flat, foreground, palette, custom palette colors. _reset(): equivalent to _clear() + resetting all user config. The render/encode entry points now auto-clear on every exit path, so the context is ready for the next glyph out of the box: hb_vector_draw_render (SVG + PDF) — ends with _clear(). hb_vector_paint_render (SVG + PDF) — ends with _clear(). hb_raster_draw_render — wraps body in HB_SCOPE_GUARD (_clear()). hb_raster_paint_render — wraps body in HB_SCOPE_GUARD (_clear()). hb_gpu_draw_encode is intentionally NOT auto-clearing: its hb_gpu_draw_get_extents() reads computed extents from the draw after encode, so callers need that state preserved until they explicitly clear. Side fix: hb_vector_paint_clear() (and therefore _reset() and the render paths) now correctly free the PDF backend's heap-allocated hb_pdf_resources_t that had been leaking through clear_render_state. hb_vector_paint_destroy() also free it now. Expose hb_vector_paint_pdf_free_resources() as HB_INTERNAL from hb-vector-paint-pdf.cc for that. All 240 tests still pass. Assisted-by: Claude Opus 4.6 (1M context) --- src/hb-gpu-draw.cc | 38 +++++++++++++++++++++++++++----- src/hb-gpu.h | 3 +++ src/hb-raster-draw.cc | 34 +++++++++++++++++++++-------- src/hb-raster-paint.cc | 44 +++++++++++++++++++++++--------------- src/hb-raster.h | 6 ++++++ src/hb-vector-draw.cc | 43 +++++++++++++++++++++---------------- src/hb-vector-paint-pdf.cc | 11 +++------- src/hb-vector-paint.cc | 24 +++++++++++++++++---- src/hb-vector-paint.hh | 1 + src/hb-vector.h | 6 ++++++ 10 files changed, 149 insertions(+), 61 deletions(-) diff --git a/src/hb-gpu-draw.cc b/src/hb-gpu-draw.cc index 9adc81b30..5e0ca0a64 100644 --- a/src/hb-gpu-draw.cc +++ b/src/hb-gpu-draw.cc @@ -372,6 +372,12 @@ encode_curve_info (const hb_gpu_curve_t *c) hb_blob_t * hb_gpu_draw_encode (hb_gpu_draw_t *draw) { + /* Unlike hb_vector_*_render and hb_raster_*_render, encode() does + * NOT auto-clear — the encoded extents live on @draw (not on the + * returned blob) and callers typically read them via + * hb_gpu_draw_get_extents() after encode(). Call + * hb_gpu_draw_clear() explicitly before the next glyph. */ + if (unlikely (!draw->success)) return nullptr; @@ -1073,16 +1079,20 @@ hb_gpu_draw_get_extents (hb_gpu_draw_t *draw, } /** - * hb_gpu_draw_reset: + * hb_gpu_draw_clear: * @draw: a GPU shape encoder * - * Resets the encoder, discarding all accumulated outlines. - * The internal encode buffer is kept for reuse. + * Discards accumulated outlines so @draw can be reused for another + * encode. User configuration (font scale) is preserved. Call + * hb_gpu_draw_reset() to also reset user configuration to defaults. * - * Since: 14.0.0 + * The internal encode buffer is kept for reuse across subsequent + * encodes. + * + * XSince: REPLACEME **/ void -hb_gpu_draw_reset (hb_gpu_draw_t *draw) +hb_gpu_draw_clear (hb_gpu_draw_t *draw) { draw->start_x = draw->start_y = 0; draw->current_x = draw->current_y = 0; @@ -1097,6 +1107,24 @@ hb_gpu_draw_reset (hb_gpu_draw_t *draw) draw->ext_max_y = -HUGE_VAL; } +/** + * hb_gpu_draw_reset: + * @draw: a GPU shape encoder + * + * Resets the encoder, discarding all accumulated outlines and + * resetting user configuration to defaults. The internal encode + * buffer is kept for reuse. + * + * Since: 14.0.0 + **/ +void +hb_gpu_draw_reset (hb_gpu_draw_t *draw) +{ + draw->x_scale = 0; + draw->y_scale = 0; + hb_gpu_draw_clear (draw); +} + /** * hb_gpu_draw_recycle_blob: * @draw: a GPU shape encoder diff --git a/src/hb-gpu.h b/src/hb-gpu.h index be6aa15ca..c9788e47d 100644 --- a/src/hb-gpu.h +++ b/src/hb-gpu.h @@ -116,6 +116,9 @@ HB_EXTERN void hb_gpu_draw_get_extents (hb_gpu_draw_t *draw, hb_glyph_extents_t *extents); +HB_EXTERN void +hb_gpu_draw_clear (hb_gpu_draw_t *draw); + HB_EXTERN void hb_gpu_draw_reset (hb_gpu_draw_t *draw); diff --git a/src/hb-raster-draw.cc b/src/hb-raster-draw.cc index 4fbf58117..ec98b62c2 100644 --- a/src/hb-raster-draw.cc +++ b/src/hb-raster-draw.cc @@ -404,6 +404,29 @@ hb_raster_draw_set_glyph_extents (hb_raster_draw_t *draw, return true; } +/** + * hb_raster_draw_clear: + * @draw: a rasterizer + * + * Discards accumulated geometry and extents so @draw can be reused + * for another render. User configuration (transform, scale factors) + * is preserved. Call hb_raster_draw_reset() to also reset user + * configuration to defaults. + * + * Internal scratch buffers and recycled image cache are preserved + * for reuse across subsequent renders. + * + * XSince: REPLACEME + **/ +void +hb_raster_draw_clear (hb_raster_draw_t *draw) +{ + draw->fixed_extents = {}; + draw->has_extents = false; + draw->edges.clear (); + draw->active_edges.clear (); +} + /** * hb_raster_draw_reset: * @draw: a rasterizer @@ -423,10 +446,7 @@ hb_raster_draw_reset (hb_raster_draw_t *draw) draw->transform = {1, 0, 0, 1, 0, 0}; draw->x_scale_factor = 1.f; draw->y_scale_factor = 1.f; - draw->fixed_extents = {}; - draw->has_extents = false; - draw->edges.clear (); - draw->active_edges.clear (); + hb_raster_draw_clear (draw); } /** @@ -1283,11 +1303,7 @@ hb_raster_draw_render (hb_raster_draw_t *draw) /* ── 3. Allocate or reuse image ─────────────────────────────────── */ /* Reset one-shot state on every exit path. */ - HB_SCOPE_GUARD ({ - draw->edges.clear (); - draw->has_extents = false; - draw->fixed_extents = {}; - }); + HB_SCOPE_GUARD (hb_raster_draw_clear (draw)); hb_raster_image_t *image; if (draw->recycled_image) diff --git a/src/hb-raster-paint.cc b/src/hb-raster-paint.cc index 467955b66..c70084b97 100644 --- a/src/hb-raster-paint.cc +++ b/src/hb-raster-paint.cc @@ -2203,16 +2203,7 @@ hb_raster_paint_render (hb_raster_paint_t *paint) { /* Common per-exit state reset. Runs on every return path, * including the early-return failure cases below. */ - HB_SCOPE_GUARD ({ - paint->transform_stack.clear (); - paint->release_all_clips (); - for (auto *s : paint->surface_stack) - paint->release_surface (s); - paint->surface_stack.clear (); - hb_raster_draw_reset (paint->clip_rdr); - paint->has_extents = false; - paint->fixed_extents = {}; - }); + HB_SCOPE_GUARD (hb_raster_paint_clear (paint)); if (unlikely (!paint->has_extents)) return nullptr; @@ -2237,6 +2228,31 @@ hb_raster_paint_render (hb_raster_paint_t *paint) return result; } +/** + * hb_raster_paint_clear: + * @paint: a paint context + * + * Discards accumulated paint output so @paint can be reused for + * another render. User configuration (base transform, scale + * factors, foreground, custom palette colors) is preserved. Call + * hb_raster_paint_reset() to also reset user configuration to + * defaults. + * + * XSince: REPLACEME + **/ +void +hb_raster_paint_clear (hb_raster_paint_t *paint) +{ + paint->fixed_extents = {}; + paint->has_extents = false; + paint->transform_stack.clear (); + paint->release_all_clips (); + for (auto *s : paint->surface_stack) + paint->release_surface (s); + paint->surface_stack.clear (); + hb_raster_draw_reset (paint->clip_rdr); +} + /** * hb_raster_paint_reset: * @paint: a paint context @@ -2252,15 +2268,9 @@ hb_raster_paint_reset (hb_raster_paint_t *paint) paint->base_transform = {1, 0, 0, 1, 0, 0}; paint->x_scale_factor = 1.f; paint->y_scale_factor = 1.f; - paint->fixed_extents = {}; - paint->has_extents = false; paint->foreground = HB_COLOR (0, 0, 0, 255); hb_raster_paint_clear_custom_palette_colors (paint); - paint->transform_stack.clear (); - paint->release_all_clips (); - for (auto *s : paint->surface_stack) - paint->release_surface (s); - paint->surface_stack.clear (); + hb_raster_paint_clear (paint); } /** diff --git a/src/hb-raster.h b/src/hb-raster.h index 296e171b0..fc37f2ae0 100644 --- a/src/hb-raster.h +++ b/src/hb-raster.h @@ -205,6 +205,9 @@ hb_raster_draw_glyph (hb_raster_draw_t *draw, HB_EXTERN hb_raster_image_t * hb_raster_draw_render (hb_raster_draw_t *draw); +HB_EXTERN void +hb_raster_draw_clear (hb_raster_draw_t *draw); + HB_EXTERN void hb_raster_draw_reset (hb_raster_draw_t *draw); @@ -308,6 +311,9 @@ hb_raster_paint_glyph (hb_raster_paint_t *paint, HB_EXTERN hb_raster_image_t * hb_raster_paint_render (hb_raster_paint_t *paint); +HB_EXTERN void +hb_raster_paint_clear (hb_raster_paint_t *paint); + HB_EXTERN void hb_raster_paint_reset (hb_raster_paint_t *paint); diff --git a/src/hb-vector-draw.cc b/src/hb-vector-draw.cc index 6b5235d5a..fb3df381e 100644 --- a/src/hb-vector-draw.cc +++ b/src/hb-vector-draw.cc @@ -777,12 +777,7 @@ hb_vector_draw_render_pdf (hb_vector_draw_t *draw) hb_blob_t *blob = hb_buf_blob_from (&draw->recycled_blob, &out); - draw->path.clear (); - draw->defs.clear (); - draw->body.clear (); - hb_set_clear (draw->defined_glyphs); - draw->has_extents = false; - draw->extents = {0, 0, 0, 0}; + hb_vector_draw_clear (draw); return blob; } @@ -835,12 +830,7 @@ hb_vector_draw_render_svg (hb_vector_draw_t *draw) hb_blob_t *blob = hb_buf_blob_from (&draw->recycled_blob, &out); - draw->path.clear (); - draw->defs.clear (); - draw->body.clear (); - hb_set_clear (draw->defined_glyphs); - draw->has_extents = false; - draw->extents = {0, 0, 0, 0}; + hb_vector_draw_clear (draw); return blob; } @@ -871,6 +861,28 @@ hb_vector_draw_render (hb_vector_draw_t *draw) } } +/** + * hb_vector_draw_clear: + * @draw: a draw context. + * + * Discards accumulated draw output so @draw can be reused for + * another render. User configuration (transform, scale factors, + * precision, flat) is preserved. Call hb_vector_draw_reset() to + * also reset user configuration to defaults. + * + * XSince: REPLACEME + */ +void +hb_vector_draw_clear (hb_vector_draw_t *draw) +{ + draw->extents = {0, 0, 0, 0}; + draw->has_extents = false; + draw->defs.clear (); + draw->body.clear (); + draw->path.clear (); + hb_set_clear (draw->defined_glyphs); +} + /** * hb_vector_draw_reset: * @draw: a draw context. @@ -885,14 +897,9 @@ hb_vector_draw_reset (hb_vector_draw_t *draw) draw->transform = {1, 0, 0, 1, 0, 0}; draw->x_scale_factor = 1.f; draw->y_scale_factor = 1.f; - draw->extents = {0, 0, 0, 0}; - draw->has_extents = false; draw->precision = 2; draw->flat = false; - draw->defs.clear (); - draw->body.clear (); - draw->path.clear (); - hb_set_clear (draw->defined_glyphs); + hb_vector_draw_clear (draw); } /** diff --git a/src/hb-vector-paint-pdf.cc b/src/hb-vector-paint-pdf.cc index 8c2e8cdb8..b798f1cfe 100644 --- a/src/hb-vector-paint-pdf.cc +++ b/src/hb-vector-paint-pdf.cc @@ -254,8 +254,8 @@ hb_pdf_get_resources (hb_vector_paint_t *paint) return res; } -static void -hb_pdf_free_resources (hb_vector_paint_t *paint) +void +hb_vector_paint_pdf_free_resources (hb_vector_paint_t *paint) { if (paint->defs.length >= sizeof (void *)) { @@ -1342,12 +1342,7 @@ hb_vector_paint_render_pdf (hb_vector_paint_t *paint) hb_blob_t *blob = hb_buf_blob_from (&paint->recycled_blob, &out); - /* Reset state. */ - hb_pdf_free_resources (paint); - paint->group_stack.clear (); - paint->path.clear (); - paint->has_extents = false; - paint->extents = {0, 0, 0, 0}; + hb_vector_paint_clear (paint); return blob; } diff --git a/src/hb-vector-paint.cc b/src/hb-vector-paint.cc index c24f9f04d..cc7cee68f 100644 --- a/src/hb-vector-paint.cc +++ b/src/hb-vector-paint.cc @@ -882,6 +882,8 @@ hb_vector_paint_destroy (hb_vector_paint_t *paint) if (!hb_object_should_destroy (paint)) return; + if (paint->format == HB_VECTOR_FORMAT_PDF) + hb_vector_paint_pdf_free_resources (paint); hb_blob_destroy (paint->recycled_blob); hb_set_destroy (paint->defined_outlines); hb_set_destroy (paint->defined_clips); @@ -1416,12 +1418,26 @@ hb_vector_paint_set_precision (hb_vector_paint_t *paint, paint->precision = hb_min (precision, 12u); } -static void -hb_vector_paint_clear_render_state (hb_vector_paint_t *paint) +/** + * hb_vector_paint_clear: + * @paint: a paint context. + * + * Discards accumulated paint output so @paint can be reused for + * another render. User configuration (transform, scale factors, + * precision, flat, foreground, palette, custom palette colors) + * is preserved. Call hb_vector_paint_reset() to also reset + * user configuration to defaults. + * + * XSince: REPLACEME + */ +void +hb_vector_paint_clear (hb_vector_paint_t *paint) { paint->extents = {0, 0, 0, 0}; paint->has_extents = false; + if (paint->format == HB_VECTOR_FORMAT_PDF) + hb_vector_paint_pdf_free_resources (paint); paint->defs.clear (); paint->path.clear (); paint->group_stack.clear (); @@ -1484,7 +1500,7 @@ hb_vector_paint_render_svg (hb_vector_paint_t *paint) hb_blob_t *blob = hb_buf_blob_from (&paint->recycled_blob, &out); - hb_vector_paint_clear_render_state (paint); + hb_vector_paint_clear (paint); return blob; } @@ -1533,7 +1549,7 @@ hb_vector_paint_reset (hb_vector_paint_t *paint) paint->palette = 0; paint->precision = 2; paint->flat = false; - hb_vector_paint_clear_render_state (paint); + hb_vector_paint_clear (paint); } /** diff --git a/src/hb-vector-paint.hh b/src/hb-vector-paint.hh index da367821c..1b7315dab 100644 --- a/src/hb-vector-paint.hh +++ b/src/hb-vector-paint.hh @@ -78,5 +78,6 @@ struct hb_vector_paint_t /* Implemented in hb-vector-paint-pdf.cc */ HB_INTERNAL hb_paint_funcs_t * hb_vector_paint_pdf_funcs_get (); HB_INTERNAL hb_blob_t * hb_vector_paint_render_pdf (hb_vector_paint_t *paint); +HB_INTERNAL void hb_vector_paint_pdf_free_resources (hb_vector_paint_t *paint); #endif /* HB_VECTOR_PAINT_HH */ diff --git a/src/hb-vector.h b/src/hb-vector.h index 10234e554..af7b37b7f 100644 --- a/src/hb-vector.h +++ b/src/hb-vector.h @@ -173,6 +173,9 @@ hb_vector_draw_set_precision (hb_vector_draw_t *draw, HB_EXTERN hb_blob_t * hb_vector_draw_render (hb_vector_draw_t *draw); +HB_EXTERN void +hb_vector_draw_clear (hb_vector_draw_t *draw); + HB_EXTERN void hb_vector_draw_reset (hb_vector_draw_t *draw); @@ -275,6 +278,9 @@ hb_vector_paint_set_precision (hb_vector_paint_t *paint, HB_EXTERN hb_blob_t * hb_vector_paint_render (hb_vector_paint_t *paint); +HB_EXTERN void +hb_vector_paint_clear (hb_vector_paint_t *paint); + HB_EXTERN void hb_vector_paint_reset (hb_vector_paint_t *paint); From 8ad69b41757d0db285da536e0a067a47c22221de Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Sun, 12 Apr 2026 21:27:51 -0600 Subject: [PATCH 2/3] [docs] List the new _clear() entry points in harfbuzz-sections.txt MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Follow-up to the _clear() API additions — add the five new public symbols to the generated-docs section index so gtk-doc picks them up. Assisted-by: Claude Opus 4.6 (1M context) --- docs/harfbuzz-sections.txt | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/docs/harfbuzz-sections.txt b/docs/harfbuzz-sections.txt index 66477f7dd..86cbaa890 100644 --- a/docs/harfbuzz-sections.txt +++ b/docs/harfbuzz-sections.txt @@ -1033,6 +1033,7 @@ hb_raster_draw_get_transform hb_raster_draw_set_extents hb_raster_draw_get_extents hb_raster_draw_set_glyph_extents +hb_raster_draw_clear hb_raster_draw_reset hb_raster_draw_get_funcs hb_raster_draw_glyph @@ -1057,6 +1058,7 @@ hb_raster_paint_set_custom_palette_color hb_raster_paint_get_funcs hb_raster_paint_glyph hb_raster_paint_render +hb_raster_paint_clear hb_raster_paint_reset hb_raster_paint_recycle_image @@ -1084,6 +1086,7 @@ hb_vector_draw_glyph hb_vector_draw_set_flat hb_vector_draw_set_precision hb_vector_draw_render +hb_vector_draw_clear hb_vector_draw_reset hb_vector_draw_recycle_blob hb_vector_paint_t @@ -1108,6 +1111,7 @@ hb_vector_paint_glyph hb_vector_paint_set_flat hb_vector_paint_set_precision hb_vector_paint_render +hb_vector_paint_clear hb_vector_paint_reset hb_vector_paint_recycle_blob @@ -1128,6 +1132,7 @@ hb_gpu_draw_set_scale hb_gpu_draw_glyph hb_gpu_draw_encode hb_gpu_draw_get_extents +hb_gpu_draw_clear hb_gpu_draw_reset hb_gpu_draw_recycle_blob From 040dce087f35adb85b19ab24cd126bf01400991c Mon Sep 17 00:00:00 2001 From: Behdad Esfahbod Date: Sun, 12 Apr 2026 21:40:12 -0600 Subject: [PATCH 3/3] [docs] Drop implementation-detail notes from _clear/_reset docstrings The "internal scratch buffers / encode buffer / image cache are preserved for reuse" notes in hb_raster_draw_{clear,reset} and hb_gpu_draw_{clear,reset} leak an implementation detail into the public API docs. Users shouldn't care; drop the lines. Assisted-by: Claude Opus 4.6 (1M context) --- src/hb-gpu-draw.cc | 6 +----- src/hb-raster-draw.cc | 6 ------ 2 files changed, 1 insertion(+), 11 deletions(-) diff --git a/src/hb-gpu-draw.cc b/src/hb-gpu-draw.cc index 5e0ca0a64..7b3afb9a6 100644 --- a/src/hb-gpu-draw.cc +++ b/src/hb-gpu-draw.cc @@ -1086,9 +1086,6 @@ hb_gpu_draw_get_extents (hb_gpu_draw_t *draw, * encode. User configuration (font scale) is preserved. Call * hb_gpu_draw_reset() to also reset user configuration to defaults. * - * The internal encode buffer is kept for reuse across subsequent - * encodes. - * * XSince: REPLACEME **/ void @@ -1112,8 +1109,7 @@ hb_gpu_draw_clear (hb_gpu_draw_t *draw) * @draw: a GPU shape encoder * * Resets the encoder, discarding all accumulated outlines and - * resetting user configuration to defaults. The internal encode - * buffer is kept for reuse. + * resetting user configuration to defaults. * * Since: 14.0.0 **/ diff --git a/src/hb-raster-draw.cc b/src/hb-raster-draw.cc index ec98b62c2..00e417fb9 100644 --- a/src/hb-raster-draw.cc +++ b/src/hb-raster-draw.cc @@ -413,9 +413,6 @@ hb_raster_draw_set_glyph_extents (hb_raster_draw_t *draw, * is preserved. Call hb_raster_draw_reset() to also reset user * configuration to defaults. * - * Internal scratch buffers and recycled image cache are preserved - * for reuse across subsequent renders. - * * XSince: REPLACEME **/ void @@ -435,9 +432,6 @@ hb_raster_draw_clear (hb_raster_draw_t *draw) * geometry, the transform, and fixed extents. The object can then be * reused for a new glyph. * - * Internal scratch buffers and recycled image cache are preserved for - * reuse across subsequent renders. - * * Since: 13.0.0 **/ void