Files
harfbuzz/src/hb-subset.cc
T
Behdad EsfahbodandClaude Opus 4.8 c752b532bd [subset] Instance self-contained pinned axes for avar2
A pinned axis whose final coordinate is CONSTANT over the retained box
-- its varIdx is NO_VARIATION_INDEX, or its avar2 delta row is constant
(zero-width delta interval, detected with the same plan-time interval
arithmetic as the reachable ranges) -- is "self-contained": there is no
reason to keep it in the instance. Remove it from fvar and avar
entirely and bake its constant contribution into the variation tables,
mirroring fontTools' selfContainedAxes handling on its avar2-instancing
branch.

The key move fits fontTools' second instancing pass into HarfBuzz's
single-pass architecture: the plan presents the self-contained pins to
every other table as an ORDINARY partial instancing in old
final-coordinate space. plan->axes_location and plan->normalized_coords
now hold only those pins (empty when there are none), while the
intermediate-space ranges that avar itself needs move to a new
plan->avar2_axes_location. With that, the blanket
"normalized_coords && !has_avar2" instancing skips added earlier reduce
to plain "normalized_coords" checks: under avar2 with no self-contained
axes the tables take their non-instancing paths exactly as before, and
with self-contained axes the standard instancing machinery pins exactly
those axes -- correct, because their final coordinates are constants in
the space the variation tables live in. This effectively reverts the
special-casing from "[subset] Skip glyf instancing and hmtx MVAR for
avar2", "[subset] Skip remaining instancing paths for avar2" and
"[subset] Skip GPOS value format optimization for avar2" in favor of
the emptiness of the plan's instancing state. cvar and MVAR also
instance (rather than pass through) when self-contained axes exist.

avar-side changes: _subset_avar2 skips dropped axes for privatization
and offset compensation, writes the DeltaSetIndexMap over the retained
axes only, and rebases the IVS with avar2_axes_location;
SegmentMaps::subset picks the right location map; fvar InstanceRecords
drop the removed axes' coordinates.

The avar2 variation culling now also hooks the decompiled instancing
paths (tuple_variations_t::cull_unreachable, called from
item_variations_t::instantiate and gvar's glyph_variations_t), since
self-contained axes route those tables through instantiation, where the
byte-level culling paths don't apply.

Under non-avar2, all of this is a no-op (has_avar2 was always false in
the flipped guards).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-03 18:57:00 -06:00

461 lines
14 KiB
C++

/*
* Copyright © 2018 Google, Inc.
*
* 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.
*
* Google Author(s): Garret Rieger, Rod Sheeter, Behdad Esfahbod
*/
#include "hb.hh"
#include "hb-open-type.hh"
#include "hb-open-file.hh"
#include "hb-subset.hh"
#include "hb-subset-table.hh"
#include "hb-subset-accelerator.hh"
#include "hb-ot-cmap-table.hh"
#include "hb-ot-var-cvar-table.hh"
#include "hb-ot-head-table.hh"
#include "hb-ot-stat-table.hh"
#include "hb-ot-post-table-v2subset.hh"
/**
* SECTION:hb-subset
* @title: hb-subset
* @short_description: Subsets font files.
* @include: hb-subset.h
*
* Subsetting reduces the codepoint coverage of font files and removes all data
* that is no longer needed. A subset input describes the desired subset. The input is
* provided along with a font to the subsetting operation. Output is a new font file
* containing only the data specified in the input.
*
* Currently most outline and bitmap tables are supported: glyf, CFF, CFF2, sbix,
* COLR, and CBDT/CBLC. This also includes fonts with variable outlines via OpenType
* variations. Notably EBDT/EBLC and SVG are not supported. Layout subsetting is supported
* only for OpenType Layout tables (GSUB, GPOS, GDEF). Notably subsetting of graphite or AAT tables
* is not yet supported.
*
* Fonts with graphite or AAT tables may still be subsetted but will likely need to use the
* retain glyph ids option and configure the subset to pass through the layout tables untouched.
*/
hb_user_data_key_t _hb_subset_accelerator_user_data_key = {};
/*
* The list of tables in the open type spec. Used to check for tables that may need handling
* if we are unable to list the tables in a face.
*/
static hb_tag_t known_tables[] {
HB_TAG('a','v','a','r'),
HB_TAG('B','A','S','E'),
HB_TAG('C','B','D','T'),
HB_TAG('C','B','L','C'),
HB_TAG('C','F','F',' '),
HB_TAG('C','F','F','2'),
HB_TAG('c','m','a','p'),
HB_TAG('C','O','L','R'),
HB_TAG('C','P','A','L'),
HB_TAG('c','v','a','r'),
HB_TAG('c','v','t',' '),
HB_TAG('D','S','I','G'),
HB_TAG('E','B','D','T'),
HB_TAG('E','B','L','C'),
HB_TAG('E','B','S','C'),
HB_TAG('f','p','g','m'),
HB_TAG('f','v','a','r'),
HB_TAG('g','a','s','p'),
HB_TAG('G','D','E','F'),
HB_TAG('g','l','y','f'),
HB_TAG('G','P','O','S'),
HB_TAG('G','S','U','B'),
HB_TAG('g','v','a','r'),
HB_TAG('h','d','m','x'),
HB_TAG('h','e','a','d'),
HB_TAG('h','h','e','a'),
HB_TAG('h','m','t','x'),
HB_TAG('H','V','A','R'),
HB_TAG('J','S','T','F'),
HB_TAG('k','e','r','n'),
HB_TAG('l','o','c','a'),
HB_TAG('L','T','S','H'),
HB_TAG('M','A','T','H'),
HB_TAG('m','a','x','p'),
HB_TAG('M','E','R','G'),
HB_TAG('m','e','t','a'),
HB_TAG('M','V','A','R'),
HB_TAG('P','C','L','T'),
HB_TAG('p','o','s','t'),
HB_TAG('p','r','e','p'),
HB_TAG('s','b','i','x'),
HB_TAG('S','T','A','T'),
HB_TAG('S','V','G',' '),
HB_TAG('V','D','M','X'),
HB_TAG('v','h','e','a'),
HB_TAG('v','m','t','x'),
HB_TAG('V','O','R','G'),
HB_TAG('V','V','A','R'),
HB_TAG('n','a','m','e'),
HB_TAG('O','S','/','2')
};
static bool _table_is_empty (const hb_face_t *face, hb_tag_t tag)
{
hb_blob_t* blob = hb_face_reference_table (face, tag);
bool result = (blob == hb_blob_get_empty ());
hb_blob_destroy (blob);
return result;
}
static unsigned int
_get_table_tags (const hb_subset_plan_t* plan,
unsigned int start_offset,
unsigned int *table_count, /* IN/OUT */
hb_tag_t *table_tags /* OUT */)
{
unsigned num_tables = hb_face_get_table_tags (plan->source, 0, nullptr, nullptr);
if (num_tables)
return hb_face_get_table_tags (plan->source, start_offset, table_count, table_tags);
// If face has 0 tables associated with it, assume that it was built from
// hb_face_create_tables and thus is unable to list its tables. Fallback to
// checking each table type we can handle for existence instead.
auto it =
hb_concat (
+ hb_array (known_tables)
| hb_filter ([&] (hb_tag_t tag) {
return !_table_is_empty (plan->source, tag) && !plan->no_subset_tables.has (tag);
})
| hb_map ([] (hb_tag_t tag) -> hb_tag_t { return tag; }),
plan->no_subset_tables.iter ()
| hb_filter([&] (hb_tag_t tag) {
return !_table_is_empty (plan->source, tag);
}));
it += start_offset;
unsigned num_written = 0;
while (bool (it) && num_written < *table_count)
table_tags[num_written++] = *it++;
*table_count = num_written;
return num_written;
}
static bool
_is_table_present (hb_face_t *source, hb_tag_t tag)
{
if (!hb_face_get_table_tags (source, 0, nullptr, nullptr)) {
// If face has 0 tables associated with it, assume that it was built from
// hb_face_create_tables and thus is unable to list its tables. Fallback to
// checking if the blob associated with tag is empty.
return !_table_is_empty (source, tag);
}
hb_tag_t table_tags[32];
unsigned offset = 0, num_tables = ARRAY_LENGTH (table_tags);
while (((void) hb_face_get_table_tags (source, offset, &num_tables, table_tags), num_tables))
{
for (unsigned i = 0; i < num_tables; ++i)
if (table_tags[i] == tag)
return true;
offset += num_tables;
}
return false;
}
static bool
_should_drop_table (hb_subset_plan_t *plan, hb_tag_t tag)
{
if (plan->drop_tables.has (tag))
return true;
switch (tag)
{
case HB_TAG('c','v','a','r'): /* hint table, fallthrough */
return plan->all_axes_pinned || (plan->flags & HB_SUBSET_FLAGS_NO_HINTING);
case HB_TAG('c','v','t',' '): /* hint table, fallthrough */
case HB_TAG('f','p','g','m'): /* hint table, fallthrough */
case HB_TAG('p','r','e','p'): /* hint table, fallthrough */
case HB_TAG('h','d','m','x'): /* hint table, fallthrough */
case HB_TAG('V','D','M','X'): /* hint table, fallthrough */
return plan->flags & HB_SUBSET_FLAGS_NO_HINTING;
#ifdef HB_NO_SUBSET_LAYOUT
// Drop Layout Tables if requested.
case HB_TAG('G','D','E','F'):
case HB_TAG('G','P','O','S'):
case HB_TAG('G','S','U','B'):
case HB_TAG('m','o','r','x'):
case HB_TAG('m','o','r','t'):
case HB_TAG('k','e','r','x'):
case HB_TAG('k','e','r','n'):
return true;
#endif
case HB_TAG('a','v','a','r'):
case HB_TAG('f','v','a','r'):
case HB_TAG('g','v','a','r'):
case HB_TAG('H','V','A','R'):
case HB_TAG('V','V','A','R'):
case HB_TAG('M','V','A','R'):
return plan->all_axes_pinned;
default:
return false;
}
}
static bool
_dependencies_satisfied (hb_subset_plan_t *plan, hb_tag_t tag,
const hb_set_t &subsetted_tags,
const hb_set_t &pending_subset_tags)
{
switch (tag)
{
case HB_TAG('h','m','t','x'):
case HB_TAG('v','m','t','x'):
case HB_TAG('m','a','x','p'):
case HB_TAG('O','S','/','2'):
return !plan->normalized_coords || !pending_subset_tags.has (HB_TAG('g','l','y','f'));
case HB_TAG('G','P','O','S'):
return plan->all_axes_pinned || !pending_subset_tags.has (HB_TAG('G','D','E','F'));
/* For avar2, variation tables must wait for avar to be subsetted first. */
case HB_TAG('g','v','a','r'):
case HB_TAG('c','v','a','r'):
case HB_TAG('H','V','A','R'):
case HB_TAG('V','V','A','R'):
case HB_TAG('M','V','A','R'):
case HB_TAG('G','D','E','F'):
case HB_TAG('C','F','F','2'):
return !plan->has_avar2 || !pending_subset_tags.has (HB_TAG('a','v','a','r'));
default:
return true;
}
}
static bool
_subset_table (hb_subset_plan_t *plan,
hb_vector_t<char> &buf,
hb_tag_t tag)
{
if (plan->no_subset_tables.has (tag)) {
return _hb_subset_table_passthrough (plan, tag);
}
DEBUG_MSG (SUBSET, nullptr, "subset %c%c%c%c", HB_UNTAG (tag));
bool success;
if (_hb_subset_table_layout (plan, buf, tag, &success) ||
_hb_subset_table_var (plan, buf, tag, &success) ||
_hb_subset_table_cff (plan, buf, tag, &success) ||
_hb_subset_table_color (plan, buf, tag, &success) ||
_hb_subset_table_other (plan, buf, tag, &success))
return success;
switch (tag)
{
case HB_TAG('h','e','a','d'):
if (_is_table_present (plan->source, HB_TAG('g','l','y','f')) && !_should_drop_table (plan, HB_TAG('g','l','y','f')))
return true; /* skip head, handled by glyf */
return _hb_subset_table<const OT::head> (plan, buf);
case HB_TAG('S','T','A','T'):
if (!plan->user_axes_location.is_empty ()) return _hb_subset_table<const OT::STAT> (plan, buf);
else return _hb_subset_table_passthrough (plan, tag);
case HB_TAG('c','v','t',' '):
#ifndef HB_NO_VAR
if (_is_table_present (plan->source, HB_TAG('c','v','a','r')) &&
plan->normalized_coords && !plan->pinned_at_default)
{
auto &cvar = *plan->source->table.cvar;
return OT::cvar::add_cvt_and_apply_deltas (plan, cvar.get_tuple_var_data (), &cvar);
}
#endif
return _hb_subset_table_passthrough (plan, tag);
}
if (plan->flags & HB_SUBSET_FLAGS_PASSTHROUGH_UNRECOGNIZED)
return _hb_subset_table_passthrough (plan, tag);
// Drop table
return true;
}
static void _attach_accelerator_data (hb_subset_plan_t* plan,
hb_face_t* face /* IN/OUT */)
{
if (!plan->inprogress_accelerator) return;
// Transfer the accelerator from the plan to us.
hb_subset_accelerator_t* accel = plan->inprogress_accelerator;
plan->inprogress_accelerator = nullptr;
if (accel->in_error ())
{
hb_subset_accelerator_t::destroy (accel);
return;
}
// Populate caches that need access to the final tables.
hb_blob_ptr_t<OT::cmap> cmap_ptr (hb_sanitize_context_t ().reference_table<OT::cmap> (face));
accel->cmap_cache = OT::cmap::create_filled_cache (cmap_ptr);
accel->destroy_cmap_cache = OT::SubtableUnicodesCache::destroy;
if (!hb_face_set_user_data(face,
hb_subset_accelerator_t::user_data_key(),
accel,
hb_subset_accelerator_t::destroy,
true))
hb_subset_accelerator_t::destroy (accel);
}
/**
* hb_subset_or_fail:
* @source: font face data to be subset.
* @input: input to use for the subsetting.
*
* Subsets a font according to provided input. Returns nullptr
* if the subset operation fails or the face has no glyphs.
*
* Since: 2.9.0
**/
hb_face_t *
hb_subset_or_fail (hb_face_t *source, const hb_subset_input_t *input)
{
if (unlikely (!input || !source)) return nullptr;
if (unlikely (!source->get_num_glyphs ()))
{
DEBUG_MSG (SUBSET, nullptr, "No glyphs in source font.");
return nullptr;
}
hb_subset_plan_t *plan = hb_subset_plan_create_or_fail (source, input);
if (unlikely (!plan)) {
return nullptr;
}
hb_face_t * result = hb_subset_plan_execute_or_fail (plan);
hb_subset_plan_destroy (plan);
return result;
}
/**
* hb_subset_plan_execute_or_fail:
* @plan: a subsetting plan.
*
* Executes the provided subsetting @plan.
*
* Return value:
* on success returns a reference to generated font subset. If the subsetting operation fails
* returns nullptr.
*
* Since: 4.0.0
**/
hb_face_t *
hb_subset_plan_execute_or_fail (hb_subset_plan_t *plan)
{
if (unlikely (!plan || plan->in_error ())) {
return nullptr;
}
hb_tag_t table_tags[32];
unsigned offset = 0, num_tables = ARRAY_LENGTH (table_tags);
hb_set_t subsetted_tags, pending_subset_tags;
while (((void) _get_table_tags (plan, offset, &num_tables, table_tags), num_tables))
{
for (unsigned i = 0; i < num_tables; ++i)
{
hb_tag_t tag = table_tags[i];
if (_should_drop_table (plan, tag)) continue;
pending_subset_tags.add (tag);
}
offset += num_tables;
}
bool success = true;
{
// Grouping to deallocate buf before calling hb_face_reference (plan->dest).
hb_vector_t<char> buf;
buf.alloc (8192 - 16);
while (!pending_subset_tags.is_empty ())
{
if (subsetted_tags.in_error ()
|| pending_subset_tags.in_error ()) {
success = false;
goto end;
}
bool made_changes = false;
for (hb_tag_t tag : pending_subset_tags)
{
if (!_dependencies_satisfied (plan, tag,
subsetted_tags,
pending_subset_tags))
{
// delayed subsetting for some tables since they might have dependency on other tables
// in some cases: e.g: during instantiating glyf tables, hmetrics/vmetrics are updated
// and saved in subset plan, hmtx/vmtx subsetting need to use these updated metrics values
continue;
}
pending_subset_tags.del (tag);
subsetted_tags.add (tag);
made_changes = true;
success = _subset_table (plan, buf, tag);
if (unlikely (!success)) goto end;
}
if (!made_changes)
{
DEBUG_MSG (SUBSET, nullptr, "Table dependencies unable to be satisfied. Subset failed.");
success = false;
goto end;
}
}
}
if (success && plan->attach_accelerator_data) {
_attach_accelerator_data (plan, plan->dest);
}
end:
return success ? hb_face_reference (plan->dest) : nullptr;
}