630 Commits
Author SHA1 Message Date
Behdad EsfahbodandMattias Eriksson e563058688 [font] Add hb_font_create_without_funcs_or_fail() (#6651)
Let clients install their own font funcs without initializing and
immediately discarding the default backend. Return NULL if the font
object or its initial variation coordinates cannot be allocated.
Keep hb_font_create()'s initialization order and behavior.

Use the new constructor in hb-ft, Fontconfig, explicit tool backend
selection, and the font benchmarks. This avoids loading a second
FT_Face when FreeType is the default while preserving the caller's
face. Document the custom-client use case and add API and stream-read
regressions.

Testing: full Meson suite (302 passed, one skipped), generated docs,
reduced-feature builds, allocator failures, and tool/benchmark checks.

Supersedes: https://github.com/harfbuzz/harfbuzz/pull/6648

Assisted-by: OpenAI Codex

Co-authored-by: Mattias Eriksson <me@axentia.se>
2026-11-12 13:30:19 -06:00
aa7a824cc4 [JSTF] Expose extender glyphs via hb_ot_layout_get_extender_glyphs (#6568)
* [JSTF] Expose extender glyphs via hb_ot_layout_get_extender_glyphs

The JSTF table is already parsed but never exposed to clients. Extender
glyphs are the most widely populated part of it and are useful for
cursive-script justification implementations that want to prefer a
font-provided extender over the plain U+0640 TATWEEL fallback.

Adds hb_ot_layout_get_extender_glyphs(face, script, language,
start_offset, &count, glyphs) following the standard iterator idiom
used by hb_ot_layout_get_attach_points and friends: NULL for size
probing, inout count for pagination.

Only the script tag is consulted: per the OT spec, extender glyphs live
directly on JstfScript and do not vary by language. JstfLangSys carries
per-language justification priorities, but exposing those is both
harder and less common among fonts than the (already rare) JSTF table
itself; that can be a separate accessor later.

Co-authored-by: Helmut Januschka <helmut@januschka.com>

* [JSTF] Minor simplification by refactoring exposed methods

---------

Co-authored-by: Helmut Januschka <helmut@januschka.com>
Co-authored-by: Behdad Esfahbod <behdad@behdad.org>
2026-11-11 18:58:24 -06:00
Khaled Hosny 3df40d9b98 15.1.0 2026-11-04 23:03:36 +02:00
Eugenio Depalo 2db1b3ab9d [buffer] Add deserializers with byte offsets (#6552)
* [buffer] Add deserializers with byte offsets

Buffer deserializers return a pointer into caller-owned input. GIR
describes it as an owned UTF-8 string, so bindings can free an
interior pointer or read beyond explicitly sized input.

Add _with_offset variants with bounded byte-array inputs and optional
byte counts. Preserve the existing return values and partial buffer
contents, including on failure. Cross-check both variants against the
existing deserializers in the buffer API tests.

Testing: full Meson suite, buffer tests under Valgrind, and GIR and
PyGObject checks.

Fixes: #6446
Assisted-by: OpenAI Codex

* [buffer] Rename new deserializers to use 2 suffix

Use the established 2 suffix for the new buffer deserializers,
following hb_shape_plan_create2(). Update API docs, NEWS, and tests.

Testing: full Meson suite, generated GIR, and PyGObject checks.

Assisted-by: OpenAI Codex
2026-11-04 12:05:35 -06:00
Roshan Ramani 1a6008afb8 [docs] Drop HB_SUBSET_DEPEND_API from the depend API guide (#6570)
df5ce0d58 removed the macro, so the depend API is now only built with
experimental_api. The basic example also needs hb-subset.h, not hb.h.

Assisted-by: Claude
2026-11-04 12:03:10 -06:00
Roshan Ramani bb702ff6de [docs] Fix five function names in the user manual
The manual named hb_ot_color_reference_png/svg(),
hb_font_paint_or_fail_glyph(), hb_ft_get_face() and
hb_coretext_face_get_ct_font(), none of which exist. Use
hb_ot_color_glyph_reference_png/svg(), hb_font_paint_glyph_or_fail(),
hb_ft_font_get_face() and hb_coretext_font_get_ct_font().

Assisted-by: Claude Code:claude-opus-5-5
2026-10-17 14:13:49 +03:00
Mar 5365d272d5 [font] Deprecate hb_font_set_face()
Changing the face now resets font funcs. Deprecate the setter in favor
of creating a new font with hb_font_create() and setting its properties.
Keep the exported symbol and move its declaration to hb-deprecated.h.

Document the deprecation in NEWS and the API section index. Guard the
face-setter tests with HB_DISABLE_DEPRECATED, and suppress expected
warnings from their deliberate use of the deprecated API.

The full ASan Meson suite passes (270 passed, 1 skipped). test-font also
builds and passes with HB_DISABLE_DEPRECATED. Its source passes Clang
-Werror checks both with and without deprecated APIs enabled.

Assisted-by: Claude
Assisted-by: Codex
2026-10-16 00:19:21 +03:00
Behdad Esfahbod aa5eff6b85 [docs] Qualify the object constructor failure guarantee (#6364)
The lifecycle chapter claimed that all constructors return empty
singletons on failure. Constructors ending in _or_fail instead return
NULL, including the established blob constructors.

Describe both conventions and require checking _or_fail results.
Validated the XML and reproduced the blob constructor behavior with
a nonexistent file and an oversized blob. Documentation only.

Fixes: https://github.com/harfbuzz/harfbuzz/issues/6359
Assisted-by: Codex
2026-10-10 18:34:47 -06:00
Khaled Hosny 863d3f7787 14.5.0 2026-09-21 00:41:07 +03:00
Behdad Esfahbod cfe86ce5e7 [subset] Harden VARC closure handling
Propagate allocation and component-decoding failures from VARC closure
instead of continuing with an incomplete glyph set. Treat malformed VARC
records as dependency-extraction failures as well.

Document VARC dependency edges and exercise subset variation-store
remapping at non-default coordinates.

Tested with:
- meson test -C build
- standalone lean and world syntax checks
- CMake harfbuzz-subset build

Assisted-by: OpenAI Codex <openai-codex@users.noreply.github.com>
2026-09-10 12:11:13 -06:00
Behdad Esfahbod 46ea946ab4 Merge pull request #6214 from harfbuzz/rendering-work-budgets
[limits] Add rendering work budgets
2026-09-06 16:36:58 -06:00
Behdad Esfahbod 472c3e0fd3 [draw] Add rendering work-budget API
Expose budget policy and remaining-work callbacks on draw and paint function
objects.  The public setters clamp invalid negative caps, distinguish finite
defaults from explicit unlimited operation, and report whether a backend
participates in accounting.

Let draw sessions borrow the live counter owned by draw_data.  OpenType glyf
and CFF traversal then debit the same counter in place, while unsupported
backends retain a finite per-glyph fallback.  Forward budget access through
the parent-font draw adaptor.

Document the new API and cover nil, default, unlimited, clamped, concrete,
and live-depletion behavior.

Tests: meson test -C build (272/272 passed)

Assisted-by: OpenAI Codex <codex@openai.com>
2026-08-26 17:11:21 -06:00
Khaled Hosny 36cb489cb0 14.4.0 2026-08-26 22:27:05 +03:00
Behdad Esfahbod 5e75e91ebf [set] Add hb_set_intersects API
Expose the exact set-intersection query so callers can test whether two
sets have any elements in common without copying and mutating a set.
The implementation handles inverted sets through the internal helper.

Document the new API with its release placeholder, add it to the docs
section index, and cover regular and inverted set combinations.

Tested with the full Meson test suite (270/270 passed).

Assisted-by: OpenAI Codex <codex@openai.com>
2026-08-19 16:00:05 -06:00
Simon Cozens 32d6e5c491 Update WASM shaper docs (#6138) 2026-08-04 01:41:30 -06:00
Khaled Hosny 4c2aa80467 14.3.0 2026-07-31 17:49:40 +03:00
Khaled Hosny 86e7473f0d [ot] Add hb_ot_fetch_number()
Similar to hb_ot_fetch_bits() but for signed numbers.

The only tags so far are for font bounding box from head table.

Fixes https://github.com/harfbuzz/harfbuzz/issues/6110
2026-07-31 04:31:26 +03:00
Khaled Hosny 6e67c5feed [ot] Add hb_ot_fetch_bits()
For fetching various bit fields scattered around OpenType tables. Many of
these are legacy or unreliable, but applications might need them for
various legacy reasons.

Fixes https://github.com/harfbuzz/harfbuzz/issues/1920
2026-07-31 04:31:26 +03:00
Behdad Esfahbod 25fc94439a Merge pull request #5733 from skef/depend-draft-pr
OpenType font dependency graph support
2026-07-30 11:12:48 -06:00
Garret Rieger 2725565dab Address review comments. 2026-07-14 16:26:49 -06:00
Khaled Hosny 421cc8f5a7 [paint] Add hb_paint_fill_glyph()
Instead of painting COLRv0 and outline fallback layers with
push_clip_glyph + color + pop_clip, add a dedicated callback for this
common paint operation.

The default (*_nil) implementation uses the decomposed sequence, so
existing clients without a fill_glyph implementation continue to work as
before.
2026-07-08 20:29:31 +03:00
Skef Iterum 71984479b1 [depend] Add direct-include guard to hb-subset-depend.h
Add the standard HB_SUBSET_H_IN / HB_NO_SINGLE_HEADER_ERROR guard
to hb-subset-depend.h, matching the pattern used by hb-*.h subheaders
(HB_H_IN) and hb-ot-*.h subheaders (HB_OT_H_IN).

hb-subset.h now defines HB_SUBSET_H_IN around its subheader includes,
and hb.hh defines it permanently for internal library code. Consumers
that include hb-subset-depend.h directly will get a clear error
directing them to use hb-subset.h instead.

Also add HB_SUBSET_H_IN to the Private subsection in
harfbuzz-sections.txt so gtkdoc doesn't flag it.

Assisted-by: Claude <noreply@anthropic.com>
2026-06-05 15:14:28 -07:00
Skef Iterum c0059c1f61 [depend] Fix docs build and add missing hb-subset.h includes
The SECTION annotation in hb-depend.cc used the old name "hb-depend"
which didn't match the "hb-subset-depend" FILE name in sections.txt
after the header rename. This caused gtkdoc to report the section
description as unused and the section symbols as undocumented. Also
add HB_SUBSET_DEPEND_EDGE_FLAGS_T_DEFINED to a Private subsection
so gtkdoc doesn't flag it as an unused declaration.

The header move from hb.h to hb-subset.h (e3e754f9c) also left
util/hb-subset-depend.cc and test/api/test-ot-depend.c without
access to hb-subset-depend.h, causing build failures on sanitizer
CI jobs that build the utility and test. Add the missing
#include <hb-subset.h> to both.

Assisted-by: Claude <noreply@anthropic.com>
2026-06-05 15:09:13 -07:00
Skef Iterum 0b29fc9be4 [depend] Move public header from libharfbuzz to libharfbuzz-subset
Rename hb-depend.h to hb-subset-depend.h and include it from
hb-subset.h instead of hb.h, so the depend API is scoped entirely
to the subset library. The implementation was already compiled into
libharfbuzz-subset; this aligns the public header with that.

Assisted-by: Claude <noreply@anthropic.com>
2026-06-05 15:09:13 -07:00
Skef Iterum b421888ce4 [depend] Fix docs build: remove enum constants from sections.txt
gtk-doc does not expect individual enum constants to be listed in
harfbuzz-sections.txt — only the typedef name.  Other HarfBuzz flag
enums (hb_glyph_flags_t, hb_subset_flags_t, etc.) follow this
pattern.  The three HB_SUBSET_DEPEND_EDGE_FLAG_* entries caused
"undeclared" warnings and doc check failures.

Also keeps the include-guard removal from the previous commit
(moving #define after the typedef so gtk-doc sees the unguarded
declaration).

Assisted-by: Claude Opus 4.6 <noreply@anthropic.com>
2026-06-05 15:09:12 -07:00
Skef Iterum ea668aaa34 [depend] Detect GSUB self-feeding chains in parity checker
When the parity checker finds unexpected over-approximation (depend
closure has extra glyphs without flagged edges), check whether the
font has self-feeding GSUB lookups — lookups whose output coverage
overlaps their input coverage.  These create transitive chains that
the depend closure follows to completion while the subsetter's
iteration-capped closure truncates.

No shaper re-applies a lookup to its own output within a single
feature application, so the extra glyphs are harmless.  The
detection traces extra glyphs through self-feeding feature edges
from the subset closure; if all are explained, the test passes.

Detection runs only on the failure path and is O(edges), so
well-formed fonts (which don't have self-feeding lookups) pay no
cost.

Also document MATH single-pass closure and GSUB self-feeding chains
in depend-for-closure.md and depend-implementation.md.

Assisted-by: Claude Opus 4.6 <noreply@anthropic.com>
2026-06-05 15:09:12 -07:00
Skef IterumandClaude Sonnet 4.6 4753f010c6 [depend] Address review feedback: drop face field, stale include, minor cleanup
- hb_subset_depend_t: drop face field; only needed during construction
- hb-ot-cmap-table.hh: remove stale hb-depend-data.hh include (cmap depend was removed)
- hb-ot-layout-gsubgpos.hh: clarify dispatch return type; use push_or_fail() in push_cur_active_glyphs()
- docs/harfbuzz-docs.xml: remove premature api-index-12-4-0 entry (added at release time)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-05 15:09:12 -07:00
Skef IterumandClaude Sonnet 4.6 211d7646f0 [depend] Update documentation for public API rename
Update all doc files to reflect the hb_subset_depend_* rename, the
removal of print from the public API, the new struct-based entry type,
the array-getter signature for lookup_glyph, and the switch from the
old depend_api/HB_DEPEND_API build controls to experimental_api /
HB_NO_SUBSET_DEPEND / HB_SUBSET_DEPEND_API.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-06-05 15:09:12 -07:00
Skef IterumandClaude Sonnet 4.5 a1114985d6 Remove cmap depend extraction - UVS now handled via query API
With UVS (Unicode Variation Sequence) closure now handled directly via
hb_font_get_variation_glyph() query API, the cmap depend extraction code
is no longer needed. This commit removes all cmap-related depend code:

Code removals:
- src/hb-depend.cc: Remove get_cmap_dependencies() function
- src/hb-depend.hh: Remove get_cmap_dependencies() declaration
- src/hb-ot-cmap-table.hh: Remove 4 depend() methods (NonDefaultUVS,
  VariationSelectorRecord, CmapSubtableFormat14, cmap)

Documentation updates:
- docs/depend-api.md: Remove cmap from table list, add UVS note
- docs/depend-for-closure.md: Update closure steps, reference impl notes
- docs/depend-implementation.md: Update table list in Future Considerations

The old cmap depend code only extracted format 14 (UVS) edges, so removing
it does not affect fonts without UVS mappings.

Testing: 153 fonts in test/api/fonts (10k iterations each), 10 fonts with
UVS mappings (1M iterations each) - all pass.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
2026-06-05 15:09:12 -07:00
Skef IterumandClaude 51caf2b6fa Fix documentation build: Revert version and add hb-depend chapter
Address reviewer feedback and fix remaining doc build errors:

1. Revert "Since: 12.4.0" back to "Since: REPLACEME" per reviewer
   comment - version numbers are assigned at release time, not in PRs

2. Remove premature api-index-12-4-0 entry from harfbuzz-docs.xml -
   this is also done at release time

3. Add hb-depend chapter to harfbuzz-docs.xml to include the
   generated xml/hb-depend.xml file

This fixes the three doc check errors:
- "1 undocumented or incomplete symbols"
- "doesn't appear to include xml/hb-depend.xml"
- "doesn't appear to include xml/api-index-REPLACEME.xml"

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
2026-06-05 15:09:12 -07:00
Skef IterumandClaude 888e8b3435 Fix CI: Add depend API documentation to harfbuzz-sections.txt
The documentation build was failing with two errors:
1. "6 unused declarations" - depend API functions weren't listed in
   harfbuzz-sections.txt
2. "doesn't appear to include xml/api-index-REPLACEME.xml" - the
   version placeholder needed to be replaced with an actual version

Changes:
- Add hb-depend section to docs/harfbuzz-sections.txt with all 6 API
  symbols (hb_depend_t, hb_depend_from_face_or_fail,
  hb_depend_get_glyph_entry, hb_depend_get_set_from_index,
  hb_depend_print, hb_depend_destroy)
- Replace "REPLACEME" with "12.4.0" in src/hb-depend.h
- Add api-index-12-4-0 entry to docs/harfbuzz-docs.xml

This fixes the harfbuzz:harfbuzz-doc-check test failure.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
2026-06-05 15:09:12 -07:00
Skef IterumandClaude ec97c40d5f Fix CI: Filter depend API symbols from exports when depend_api=false
The depend API follows the same pattern as experimental_api: the code
is always compiled (guarded by #ifdef HB_DEPEND_API), but symbols
should only be exported when the option is enabled.

Changes:
1. gen-def.py: Add --depend-api flag and filter list (like --experimental-api)
2. src/meson.build: Pass --depend-api flag when option is enabled

This ensures depend symbols are excluded from .def files when depend_api=false
(the CI default), fixing macOS check-symbols test failures.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
2026-06-05 15:09:11 -07:00
Skef IterumandClaude f298400085 Address code review feedback for depend API
This commit addresses multiple code review comments:

1. Switch RNG to std::mt19937 for deterministic tests
   - Replace std::rand/srand with std::mt19937 in parity checker
   - Use std::uniform_int_distribution for all random number generation
   - Ensures test determinism across platforms for non-error-injection tests

2. Convert debug fprintf to DEBUG_MSG_LEVEL
   - Convert GSUB lookup processing prints to DEBUG_MSG_LEVEL(DEPEND, nullptr, 1, 0, ...)
   - Visible at HB_DEBUG_DEPEND=2 or higher for detailed per-lookup debugging

3. Rename function for consistency
   - hb_depend_from_face → hb_depend_from_face_or_fail
   - Follows HarfBuzz convention for functions returning nullptr on failure
   - Update all call sites, documentation, and code comments

4. Adopt established set deduplication pattern
   - Change from hb_vector_t<hb_set_t> to hb_vector_t<hb::unique_ptr<hb_set_t>>
   - Use pointer-based hashmap: hb_hashmap_t<const hb_set_t*, hb_codepoint_t>
   - Leverages hb_hash's content-based deduplication via pointer dereferencing
   - Follows pattern established elsewhere in HarfBuzz codebase

5. Separate ligature and context set semantics
   - Rename free_set → free_ligature_set (no hashmap manipulation)
   - Rename new_set → new_ligature_set (no hashmap manipulation)
   - Rename find_or_create_set → find_or_create_context_set (only function using hashmap)
   - Makes it explicit which sets are deduplicated (context) vs unique (ligature)
   - Update all call sites in Ligature.hh, ReverseChainSingleSubstFormat1.hh, hb-ot-layout-gsubgpos.hh

6. Code cleanup
   - Remove unused add_to_ligature_set function (dead code)
   - Refactor new_ligature_set(cp) to delegate to new_ligature_set(set)
   - Move set_to_index declaration near sets/free_set_list for better organization

All tests pass.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
2026-06-05 15:09:11 -07:00
Skef IterumandClaude Opus 4.5 b351a2dc9c Fix under-approximation in context set filtering and update edge flag docs
Two related fixes:

1. Context set under-approximation fix (hb-ot-layout-gsubgpos.hh):
   When a direct requirement (from input positions) overlapped with a
   disjunctive set (backtrack/lookahead), the code incorrectly added
   the filtered (remaining) set as an additional requirement. Fix:
   if position_context intersects with original_set at all, the
   disjunctive requirement is already satisfied - don't add anything.

2. Parity checker ligature fix (hb-depend-closure-parity.cc):
   When processing deferred ligatures, store {dependent, ligature_set,
   flags} at deferral time instead of re-scanning edges later. This
   preserves the feature filtering that was already done and correctly
   propagates edge flags.

Also updates edge flag documentation to correctly explain the mechanism:
- Depend extraction records edges based on static input coverage/class
- During closure, lookups within a rule are applied sequentially
- Lookups at earlier positions may transform later positions
- Multiple lookups at same position may interact (one produces a glyph,
  another immediately consumes it as an "intermediate")
- So a glyph matching coverage might not persist when closure traverses

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
2026-06-05 15:09:11 -07:00
Skef IterumandClaude ce4564da0d Add edge flags to detect over-approximation from contextual positions
Edges created from non-zero positions in multi-position contextual rules
can consume intermediate glyphs (glyphs produced then immediately consumed,
never settling in closure). This causes depend's closure to include extra
glyphs compared to subset's closure, which is expected behavior.

Added HB_DEPEND_EDGE_FLAG_FROM_CONTEXT_POSITION flag to mark these edges
at extraction time. Updated parity checker to track when such edges are
hit during closure computation and distinguish between:
- Expected over-approximation (hit flagged edge): informational only
- Unexpected over-approximation (no flagged edge): critical error

This enables detection of genuine bugs (unexpected over-approximation)
while allowing expected cases from intermediate glyphs.

Updated all API callers and documentation to include nullable flags
parameter. Renamed parity checker terminology from "fuzzer" to "parity"
for clarity.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
2026-06-05 15:09:11 -07:00
Skef Iterum d0cee3ca7e Update depend API docs and add explicit test mode to fuzzer
Documentation updates:
- Add comprehensive context_set documentation to depend-api.md with
  encoding details and example code for check_context_satisfied()
- Update depend-for-closure.md: remove obsolete over-approximation
  analysis, reflect that recent testing shows no over-approximation
  with proper context_set filtering
- Update depend-implementation.md: correct descriptions of active
  glyph filtering, sequential accumulation, ligature sets, and
  context recording to match current implementation
- Fix terminology: change 'binning' to 'segmentation' throughout
- Fix hb-depend-data.hh:557: use HB_CODEPOINT_INVALID instead of 0
  for layout_tag default value

Fuzzer enhancements (hb-depend-closure-parity):
- Add explicit test mode with command-line options similar to
  hb-subset conventions:
    --unicodes=LIST       Unicode codepoints (U+XXXX, decimal, ranges)
    --gids=LIST           Glyph IDs (decimal, ranges)
    --no-layout-closure   Skip GSUB closure
    --layout-features=LIST GSUB features (comma-separated or *)
- Support multiple input formats:
    --unicodes=U+0041,U+0042,U+0043
    --unicodes=65-90
    --gids=10-50 --no-layout-closure
    --layout-features=liga,calt or --layout-features='*'
- Add robust input parsing with validation to prevent infinite loops
  on invalid input (e.g., --gids=abc or --unicodes=U+GGGG)
- Add error checking for conflicting options

This allows reproducing random test cases manually and testing
specific scenarios without finding the right seed.

Tested: All modes produce identical results to seed-based tests.
2026-06-05 15:09:11 -07:00
Skef Iterum 29cf3aa519 Add depend API: graph extraction with contextual filtering
This commit implements the experimental depend API for extracting glyph
dependency graphs from OpenType fonts. The depend API provides the foundation
for computing glyph closures and analyzing font structure.

The implementation significantly improves upon the initial draft (commit
3f59433d5) by adding contextual filtering to reduce over-approximation while
still capturing complete dependency graphs.

Core Architecture
-----------------

The depend implementation operates in graph extraction mode: it walks all font
tables once to build a complete dependency graph. The key innovation is
contextual filtering that reduces over-approximation compared to the naive
approach.

Contextual Filtering for Reduced Over-Approximation
----------------------------------------------------

The initial implementation (3f59433d5) recorded dependencies for ALL glyphs in
every lookup's coverage, leading to significant over-approximation. The current
implementation filters dependencies based on context:

**Individual Lookups**: Each lookup's depend() method filters by active glyphs:

  // Old approach (3f59433d5)
  + hb_iter (this+coverage)  // ALL coverage glyphs
  | hb_apply (record_dependency)

  // New approach
  hb_set_t intersection;
  (this+coverage).intersect_set (c->parent_active_glyphs(), intersection);
  + hb_iter (intersection)  // ONLY contextually relevant glyphs
  | hb_apply (record_dependency)

**Contextual Lookups**: ContextFormat1/2/3 and ChainContextFormat1/2/3 set up
active glyph contexts for nested lookups:

  hb_set_t* cur_active_glyphs = c->push_cur_active_glyphs();
  get_coverage().intersect_set(*c->glyphs, *cur_active_glyphs);

  // Process rules with filtered coverage
  + hb_zip (this+coverage, ruleSet)
  | hb_filter ([&] (hb_codepoint_t g) {
      return c->parent_active_glyphs().has(g);
    }, hb_first)
  | hb_apply (process_rule)

This significantly reduces over-approximation for simple cases while maintaining
complete graph coverage.

**Intentional Over-Approximation at Nested Boundaries**: When contextual rules
invoke nested lookups, we pass ALL glyphs to ensure no edges are missed:

  // In context_depend_recurse_lookups()
  cur_active_glyphs->set (*c->glyphs);  // Universe for nested lookups

This design choice prioritizes completeness over precision at contextual
boundaries, which is appropriate for graph extraction.

Edge Deduplication and Performance
-----------------------------------

Dependency extraction can generate millions of potential edges. To maintain
acceptable performance:

- Edge hashing (compute_edge_hash): O(1) duplicate detection via hash table
  keyed on (source, table_tag, layout_tag, dependent, ligature_set_contents)
- Hash collision handling: Falls back to O(n) linear search through glyph's
  existing dependencies only on collision (rare)
- Component vectors: Stores edge components for collision detection
- Post-extraction cleanup: Frees temporary structures (edge_hashes,
  lookup_features) to reduce memory footprint

Table-Specific Extraction
--------------------------

- **cmap**: Unicode → glyph mappings including UVS (Unicode Variation Sequences)
- **GSUB**: All substitution rules with feature tags and ligature set tracking
  - Handles all 8 GSUB lookup types including Extension (type 7)
  - Records which features reference each dependency
  - Groups ligature alternatives via ligature_set indices
- **glyf**: TrueType composite glyph components
- **CFF**: CFF1 SEAC (Standard Encoding Accented Character) composites
- **COLR**: Color layer dependencies for both COLRv0 and COLRv1
  - Filters self-referential PaintGlyph to prevent trivial cycles
- **MATH**: Mathematical variant glyphs and assembly components

CFF SEAC dependencies use table_tag='CFF ' with layout_tag=0 and
ligature_set=HB_CODEPOINT_INVALID, matching the pattern used for glyf.

Data Structure: hb_depend_data_record_t
----------------------------------------

Each dependency edge contains:
- table_tag: Source table (GSUB, glyf, CFF, COLR, MATH, cmap)
- dependent: Target glyph ID
- layout_tag: Feature tag (for GSUB) or UVS codepoint (for cmap), else 0
- ligature_set: Index into sets array for ligature alternatives, else INVALID
- context_set: Reserved for future contextual filtering (currently unused)

Graph stored as vector indexed by glyph ID, each containing vector of records.

Testing and Documentation
--------------------------

- test/api/test-ot-depend.c: Comprehensive test suite (645 lines)
  - Tests all table types and GSUB substitution formats
  - Includes regression tests for edge cases
  - Uses ContextFormat2-Depend-Test.ttf (minimized from 486KB to 85KB)

- test/fuzzing/hb-depend-fuzzer.cc: Production-quality closure implementation
  - Demonstrates correct ligature set handling
  - Includes feature filtering and over-approximation analysis
  - Reference implementation for depend-based closure computation

- docs/depend-api.md: Public API documentation with usage examples
- docs/depend-for-closure.md: Guide to using depend for closure computation
- docs/depend-implementation.md: Implementation details and architecture

Build System
-------------

- Meson option: -Ddepend_api=true
- Compile flag: -DHB_DEPEND_API
- Symbols in libharfbuzz-subset.dylib (applications must link both
  libharfbuzz and libharfbuzz-subset)

Status: Experimental API, subject to change.
2026-06-05 15:09:11 -07:00
Skef Iterum 4ea82e1afc Add comprehensive documentation for depend API
This commit adds complete documentation for the dependency analysis API
at all levels: public API, internal structures, and implementation.

Public API documentation (src/hb-depend.cc, src/hb-depend.h):
- Replaced "XXX Todo" placeholder in SECTION comment with detailed
  module description explaining dependency graphs and use cases
- Fixed misleading hb_depend_t description (was only mentioning UVS)
- Added full documentation for hb_depend_print() with debugging notes
- Added usage examples to all three public functions
- Updated all version tags from "?.0.0" to "REPLACEME"
- Added experimental API warnings throughout

Internal documentation (src/hb-depend-data.hh, src/hb-depend.hh):
- Documented 5 internal structures with purpose and ownership semantics
- Added comments explaining data relationships and lifecycle

Algorithm documentation (src/hb-depend.cc):
- Added detailed algorithm comments to 5 extraction methods explaining
  how dependencies are collected from each OpenType table (cmap, GSUB,
  glyf, COLR, MATH)

User guide (docs/depend-api.md):
- Created comprehensive 250-line API guide with:
  * Introduction with mechanism overview
  * Basic usage example (iterating dependencies)
  * Advanced examples (computing reachable glyphs, ligature sets)
  * API details and compilation instructions
  * Implementation notes including ownership semantics
  * Use cases (subsetting, coverage analysis, binning, testing)
- Prominent experimental API warnings

Build configuration (meson_options.txt):
- Updated option description to emphasize experimental status

All documentation follows HarfBuzz conventions and includes gtk-doc
formatting for API reference generation.
2026-06-05 15:09:11 -07:00
Khaled Hosny b0ffab42d4 14.2.0 2026-04-20 05:10:48 +02:00
Behdad Esfahbod b3c3e6a818 [vector] Add public hb_vector_draw_new_path() API
Exposes the path separation as a public function so callers
using the draw funcs directly can separate glyph outlines.

Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-04-18 11:41:44 -06:00
Behdad Esfahbod 750df72e2b [NEWS/docs] Update for vector API changes
- Remove draw svg_prefix from New API list and sections.txt
- Document pen_x/pen_y removal, dedup removal, _glyph
  simplification in the Vector library section

Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-04-18 11:36:05 -06:00
Behdad Esfahbod 77b0369078 [hb-vector.png] Fixup 2026-04-17 16:50:36 -06:00
Behdad Esfahbod d689790d5d hb-shape.png: Optimize 2026-04-17 15:58:27 -06:00
Behdad Esfahbod d5819716b3 Add hb-shape.png 2026-04-17 15:53:57 -06:00
Behdad Esfahbod e9c62e1ad3 [vector] Center logo to match others 2026-04-17 15:43:28 -06:00
Behdad Esfahbod 7c54a401c0 [vector-draw] Add foreground/background color API
Add hb_vector_draw_set_{foreground,background}() and getters.

SVG: foreground wraps body in <g fill="rgb(...)">; background
emits a <rect> covering the viewBox before content.

PDF: foreground sets fill color via rg operator before glyph
content; background emits a filled rect at the start of the
content stream.

Default: foreground opaque black, background transparent.

Wire both into the hb-vector CLI util alongside the paint
equivalents.  Remove the old util-side emit_background_rect.

Regenerated vector test expected outputs.

Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-04-16 19:13:33 -06:00
Behdad Esfahbod d774a9a4e2 [vector/raster] Add set_background / get_background API
Add hb_vector_paint_set_background() / get_background() and
hb_raster_paint_set_background() / get_background().

For vector: if set to a non-transparent color, the SVG renderer
emits a <rect> covering the viewBox before glyph content, and
the PDF renderer prepends a filled rectangle to the content
stream.  Both support semi-transparent backgrounds (SVG via
fill-opacity, PDF via ExtGState /ca).

For raster: the root surface is pre-filled with the background
color before glyph compositing begins.

Default is transparent (no background emitted).

The hb-vector CLI util wires --background to the new API.

Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-04-16 18:22:07 -06:00
Behdad EsfahbodandClaude Opus 4.6 591748f1e1 [draw][paint] Make get_funcs instance-aware; add get_format
The six public draw / paint funcs getters across raster,
vector, and gpu used to be singletons:

  hb_raster_draw_get_funcs (void)
  hb_raster_paint_get_funcs (void)
  hb_vector_draw_get_funcs (void)
  hb_vector_paint_get_funcs (void)
  hb_gpu_draw_get_funcs (void)
  hb_gpu_paint_get_funcs (void)

That works fine for raster and gpu, where there's a single
backend per type, but breaks for the vector backend where
SVG and PDF have separate funcs sets — callers using the
public getter always got SVG funcs and silently produced
SVG markup inside PDF output streams when invoking the new
arbitrary-path clip API on a PDF context.

Make all six take a const-pointer to the relevant context
instance.  vector_paint dispatches on paint->format; the
other five just use the instance for symmetry today (room
for future format-style dispatch later).

Also expose hb_vector_draw_get_format / hb_vector_paint_
get_format public getters so callers (or third parties)
can ask a vector context for its format without poking at
internals.

Also: hb_vector_paint_push_clip_path_end now wraps the
emitted SVG clipPath's path in transform="scale(1,-1)" so
free-form arbitrary clips at base body level land in the
same coord system the per-glyph <use scale(_,-sy)>
wrappers establish.  Without this, free-form clip-path
arbitrary outlines emitted between paint_glyph calls came
out mirrored across the X axis.

Updates internal callers (hb_vector_paint_glyph,
hb_pdf_emit_glyph_path, hb_raster_paint_push_clip_path_
start, hb_gpu_paint_push_clip_path_start, the GPU pen
adapter), util sites (raster-output.hh, vector-output.hh,
gpu/demo-font.cc), API tests (test-raster.cc, test-gpu.cc),
and the docs section index.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-04-16 16:21:49 -06:00
Behdad EsfahbodandClaude Opus 4.6 98470a3e02 [draw] Rename hb_draw_rect to hb_draw_rectangle
API rename for the not-yet-released stroked/filled
rectangle helper added to hb-draw — full names
(hb_draw_line, hb_draw_circle, hb_draw_rectangle) read
better than mixed full/abbreviated.

Updates the public header, impl, the gpu doc reference,
the GPU API test, the GPU demo's extents overlay, the
extents-overlay paint helper, and the docs section
listing.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-04-16 16:18:20 -06:00
Behdad Esfahbod 599c99b589 [paint] Add arbitrary-path clip API
Add push_clip_path_start / push_clip_path_end to the
hb_paint_funcs_t vtable, for callers that want to clip paint
output to an arbitrary shape (not just a glyph or rectangle).

  hb_draw_funcs_t *df = hb_paint_push_clip_path_start (pf, pd, &dd);
  hb_draw_move_to (df, dd, NULL, ...);
  hb_draw_line_to (df, dd, NULL, ...);
  ...
  hb_draw_close_path (df, dd, NULL);
  hb_paint_push_clip_path_end (pf, pd);
  /* paint ops here are clipped to the emitted path */
  hb_paint_pop_clip (pf, pd);

The backend hands back a draw_funcs + draw_data pair (transfer
none) that accumulates the clip path; end() signals the
caller is done drawing clip geometry and the accumulated
path becomes an active clip.  pop_clip closes the scope,
symmetric with push_clip_glyph / push_clip_rectangle.

Only public API and the nil vtable stubs land here.  Backend
implementations (hb-vector, hb-raster, hb-gpu) follow in
separate commits.

Partial: https://github.com/harfbuzz/harfbuzz/issues/5930

Assisted-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-04-16 16:18:20 -06:00