[subset] Partially instantiate lookup conditions

Reduce LookupVariationRecord conditions to false, true, or a residual
condition when axes are pinned or restricted.  Fold compound AND, OR,
and NOT conditions, remap value-condition variation indices, and emit a
constant condition when a surviving lookup becomes unconditional.

Extend the test font with a second axis and all condition formats so the
subset tests cover structural, full, and partial instancing behavior.

Tested with the full Meson test suite, targeted Clang HB_NO_VAR and GCC
builds, and OTS validation of the fixture.

Assisted-by: OpenAI Codex <codex@openai.com>
This commit is contained in:
Behdad Esfahbod committed 2026-10-01 19:43:47 -06:00
1 parent c8d6c273fb
commit 3f39e24e75
7 files changed
+316 -14

No files matched your search

+257 -1
View File
@@ -4217,6 +4217,14 @@ enum Cond_with_Var_flag_t
DROP_RECORD_WITH_VAR = 3,
};
enum lookup_condition_subset_result_t
{
LOOKUP_CONDITION_SUBSET_ERROR,
LOOKUP_CONDITION_SUBSET_FALSE,
LOOKUP_CONDITION_SUBSET_TRUE,
LOOKUP_CONDITION_SUBSET_KEEP,
};
struct Condition;
template <typename Instancer>
@@ -4413,6 +4421,7 @@ struct ConditionAnd
auto *out = c->serializer->start_embed (this);
if (unlikely (!out || !c->serializer->extend_min (out)))
return_trace (false);
out->format = format;
for (const auto &offset : conditions)
if (unlikely (!subset_offset_array (c, out->conditions, this) (offset)))
@@ -4468,6 +4477,7 @@ struct ConditionOr
auto *out = c->serializer->start_embed (this);
if (unlikely (!out || !c->serializer->extend_min (out)))
return_trace (false);
out->format = format;
for (const auto &offset : conditions)
if (unlikely (!subset_offset_array (c, out->conditions, this) (offset)))
@@ -4560,6 +4570,11 @@ struct ConditionNegate
struct Condition
{
lookup_condition_subset_result_t subset_lookup_condition (
hb_subset_context_t *c,
unsigned depth = HB_MAX_NESTING_LEVEL,
bool materialize_true = false) const;
template <typename Instancer>
bool evaluate (const int *coords, unsigned int coord_len,
Instancer *instancer) const
@@ -4616,6 +4631,11 @@ struct Condition
const Condition *src,
const hb_map_t &varidx_map);
private:
lookup_condition_subset_result_t subset_lookup_condition_impl (
hb_subset_context_t *c,
unsigned depth) const;
protected:
union {
struct { HBUINT16 v; } format; /* Format identifier */
@@ -4774,6 +4794,231 @@ Condition::serialize (hb_serialize_context_t *c,
}
}
inline lookup_condition_subset_result_t
Condition::subset_lookup_condition (hb_subset_context_t *c,
unsigned depth,
bool materialize_true) const
{
auto snap = c->serializer->snapshot ();
lookup_condition_subset_result_t result =
subset_lookup_condition_impl (c, depth);
if (result == LOOKUP_CONDITION_SUBSET_KEEP)
return result;
c->serializer->revert (snap);
if (result != LOOKUP_CONDITION_SUBSET_TRUE || !materialize_true)
return result;
auto *out = c->serializer->start_embed<ConditionValue> ();
if (unlikely (!out || !c->serializer->extend_min (out)))
return LOOKUP_CONDITION_SUBSET_ERROR;
out->format = 2;
out->defaultValue = 1;
out->varIdx = VarIdx::NO_VARIATION;
return LOOKUP_CONDITION_SUBSET_KEEP;
}
inline lookup_condition_subset_result_t
Condition::subset_lookup_condition_impl (hb_subset_context_t *c,
unsigned depth) const
{
if (unlikely (!depth))
return LOOKUP_CONDITION_SUBSET_ERROR;
auto subset_offset = [c, depth] (auto &out,
const Condition &condition)
-> lookup_condition_subset_result_t
{
auto snap = c->serializer->snapshot ();
auto *offset = out.serialize_append (c->serializer);
if (unlikely (!offset))
return LOOKUP_CONDITION_SUBSET_ERROR;
c->serializer->push ();
lookup_condition_subset_result_t result =
condition.subset_lookup_condition (c, depth - 1);
if (result == LOOKUP_CONDITION_SUBSET_KEEP)
c->serializer->add_link (*offset, c->serializer->pop_pack ());
else
{
c->serializer->pop_discard ();
out.pop ();
c->serializer->revert (snap);
}
return result;
};
switch (u.format.v)
{
case 1:
{
const ConditionAxisRange &src = u.format1;
if (c->plan->user_axes_location.is_empty ())
return c->serializer->embed (&src) ?
LOOKUP_CONDITION_SUBSET_KEEP :
LOOKUP_CONDITION_SUBSET_ERROR;
hb_codepoint_t *axis_tag;
if (!c->plan->axes_old_index_tag_map.has (src.axisIndex, &axis_tag))
return LOOKUP_CONDITION_SUBSET_ERROR;
Triple axis_limit {-1.0, 0.0, 1.0};
Triple *normalized_limit;
if (c->plan->axes_location.has (*axis_tag, &normalized_limit))
axis_limit = *normalized_limit;
double filter_min = (double) src.filterRangeMinValue.to_float ();
double filter_max = (double) src.filterRangeMaxValue.to_float ();
if (filter_min > filter_max)
return LOOKUP_CONDITION_SUBSET_FALSE;
if (axis_limit.is_point ())
return filter_min <= axis_limit.middle &&
axis_limit.middle <= filter_max ?
LOOKUP_CONDITION_SUBSET_TRUE :
LOOKUP_CONDITION_SUBSET_FALSE;
if (axis_limit.maximum < filter_min ||
filter_max < axis_limit.minimum)
return LOOKUP_CONDITION_SUBSET_FALSE;
if (filter_min <= axis_limit.minimum &&
axis_limit.maximum <= filter_max)
return LOOKUP_CONDITION_SUBSET_TRUE;
if (!c->plan->axes_index_map.has (src.axisIndex))
return LOOKUP_CONDITION_SUBSET_ERROR;
auto *out = c->serializer->embed (&src);
if (unlikely (!out))
return LOOKUP_CONDITION_SUBSET_ERROR;
TripleDistances axis_distances {1.0, 1.0};
TripleDistances *distances;
if (c->plan->axes_triple_distances.has (*axis_tag, &distances))
axis_distances = *distances;
out->filterRangeMinValue.set_float (
renormalizeValue (filter_min, axis_limit, axis_distances, false));
out->filterRangeMaxValue.set_float (
renormalizeValue (filter_max, axis_limit, axis_distances, false));
if (unlikely (!c->serializer->check_assign (
out->axisIndex,
c->plan->axes_index_map.get (src.axisIndex),
HB_SERIALIZE_ERROR_INT_OVERFLOW)))
return LOOKUP_CONDITION_SUBSET_ERROR;
return LOOKUP_CONDITION_SUBSET_KEEP;
}
case 2:
{
const ConditionValue &src = u.format2;
auto *out = c->serializer->embed (&src);
if (unlikely (!out))
return LOOKUP_CONDITION_SUBSET_ERROR;
if (src.varIdx == VarIdx::NO_VARIATION)
return c->plan->user_axes_location.is_empty () ?
LOOKUP_CONDITION_SUBSET_KEEP :
((int) src.defaultValue > 0 ?
LOOKUP_CONDITION_SUBSET_TRUE :
LOOKUP_CONDITION_SUBSET_FALSE);
hb_pair_t<unsigned, int> *new_varidx_delta;
if (!c->plan->layout_variation_idx_delta_map.has (src.varIdx,
&new_varidx_delta))
return c->plan->user_axes_location.is_empty () ?
LOOKUP_CONDITION_SUBSET_KEEP :
((int) src.defaultValue > 0 ?
LOOKUP_CONDITION_SUBSET_TRUE :
LOOKUP_CONDITION_SUBSET_FALSE);
int default_value = (int) src.defaultValue +
hb_second (*new_varidx_delta);
if (unlikely (!c->serializer->check_assign (
out->defaultValue,
default_value,
HB_SERIALIZE_ERROR_INT_OVERFLOW)))
return LOOKUP_CONDITION_SUBSET_ERROR;
out->varIdx = hb_first (*new_varidx_delta);
if (!c->plan->user_axes_location.is_empty () &&
out->varIdx == VarIdx::NO_VARIATION)
return default_value > 0 ?
LOOKUP_CONDITION_SUBSET_TRUE :
LOOKUP_CONDITION_SUBSET_FALSE;
return LOOKUP_CONDITION_SUBSET_KEEP;
}
case 3:
{
const ConditionAnd &src = u.format3;
auto *out = c->serializer->start_embed (&src);
if (unlikely (!out || !c->serializer->extend_min (out)))
return LOOKUP_CONDITION_SUBSET_ERROR;
out->format = 3;
for (const auto &offset : src.conditions)
{
lookup_condition_subset_result_t result =
subset_offset (out->conditions, &src + offset);
if (result == LOOKUP_CONDITION_SUBSET_ERROR ||
result == LOOKUP_CONDITION_SUBSET_FALSE)
return result;
}
return out->conditions ?
LOOKUP_CONDITION_SUBSET_KEEP :
LOOKUP_CONDITION_SUBSET_TRUE;
}
case 4:
{
const ConditionOr &src = u.format4;
auto *out = c->serializer->start_embed (&src);
if (unlikely (!out || !c->serializer->extend_min (out)))
return LOOKUP_CONDITION_SUBSET_ERROR;
out->format = 4;
for (const auto &offset : src.conditions)
{
lookup_condition_subset_result_t result =
subset_offset (out->conditions, &src + offset);
if (result == LOOKUP_CONDITION_SUBSET_ERROR ||
result == LOOKUP_CONDITION_SUBSET_TRUE)
return result;
}
return out->conditions ?
LOOKUP_CONDITION_SUBSET_KEEP :
LOOKUP_CONDITION_SUBSET_FALSE;
}
case 5:
{
const ConditionNegate &src = u.format5;
auto *out = c->serializer->embed (&src);
if (unlikely (!out))
return LOOKUP_CONDITION_SUBSET_ERROR;
out->condition = 0;
c->serializer->push ();
lookup_condition_subset_result_t result =
(&src + src.condition).subset_lookup_condition (c, depth - 1);
if (result == LOOKUP_CONDITION_SUBSET_KEEP)
{
c->serializer->add_link (out->condition,
c->serializer->pop_pack ());
return result;
}
c->serializer->pop_discard ();
if (result == LOOKUP_CONDITION_SUBSET_TRUE)
return LOOKUP_CONDITION_SUBSET_FALSE;
if (result == LOOKUP_CONDITION_SUBSET_FALSE)
return LOOKUP_CONDITION_SUBSET_TRUE;
return result;
}
default:
return LOOKUP_CONDITION_SUBSET_FALSE;
}
}
struct ConditionSet
{
bool evaluate (const int *coords, unsigned int coord_len,
@@ -5190,8 +5435,19 @@ struct LookupConditionRecord
auto *out = c->serializer->embed (this);
if (unlikely (!out)) return_trace (false);
if (unlikely (!out->condition.serialize_subset (c, condition, base)))
out->condition = 0;
c->serializer->push ();
lookup_condition_subset_result_t result =
(base + condition).subset_lookup_condition (c,
HB_MAX_NESTING_LEVEL,
true);
if (result != LOOKUP_CONDITION_SUBSET_KEEP)
{
c->serializer->pop_discard ();
return_trace (false);
}
c->serializer->add_link (out->condition, c->serializer->pop_pack ());
return_trace (out->lookupIndices.serialize_subset (c, lookupIndices, base, l));
}
+1 -1
View File
@@ -298,7 +298,7 @@ static void
test_ot_layout_collect_lookup_variations (void)
{
hb_face_t *face = hb_test_open_font_file (
"../shape/data/in-house/fonts/48b61f685ab1b3a3690fe4fea46ffc73dac3c301.ttf");
"../shape/data/in-house/fonts/ce30d3c1c8f77c156589ac7584acecaa4dfb619b.ttf");
const hb_tag_t features[] = {HB_TAG ('l','i','g','a'), HB_TAG_NONE};
hb_set_t *lookups = hb_set_create ();
+1 -1
View File
@@ -323,7 +323,7 @@ static void
test_ot_shape_plan_lookup_variations_cache (void)
{
hb_face_t *face = hb_test_open_font_file (
"../shape/data/in-house/fonts/48b61f685ab1b3a3690fe4fea46ffc73dac3c301.ttf");
"../shape/data/in-house/fonts/ce30d3c1c8f77c156589ac7584acecaa4dfb619b.ttf");
hb_segment_properties_t props = HB_SEGMENT_PROPERTIES_DEFAULT;
int coords[] = {0};
+52 -6
View File
@@ -96,7 +96,8 @@ test_subset_crash (void)
static void
assert_lookup_variations_shape (hb_face_t *face,
const int *coords,
unsigned coord_count)
unsigned coord_count,
const hb_codepoint_t *expected)
{
hb_font_t *font = hb_font_create (face);
hb_font_set_var_coords_normalized (font, coords, coord_count);
@@ -108,8 +109,7 @@ assert_lookup_variations_shape (hb_face_t *face,
unsigned length;
const hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffer, &length);
const hb_codepoint_t expected[] = {2, 4, 6, 8, 9, 10};
g_assert_cmpuint (length, ==, G_N_ELEMENTS (expected));
g_assert_cmpuint (length, ==, 6);
for (unsigned i = 0; i < length; i++)
g_assert_cmpuint (info[i].codepoint, ==, expected[i]);
@@ -121,7 +121,11 @@ static void
test_subset_lookup_variations (void)
{
hb_face_t *face = hb_test_open_font_file (
"../shape/data/in-house/fonts/48b61f685ab1b3a3690fe4fea46ffc73dac3c301.ttf");
"../shape/data/in-house/fonts/ce30d3c1c8f77c156589ac7584acecaa4dfb619b.ttf");
const hb_codepoint_t expected_all[] = {2, 4, 6, 8, 9, 10};
const hb_codepoint_t expected_test_08_dumy_08[] = {2, 3, 6, 8, 9, 10};
const hb_codepoint_t expected_test_03_dumy_0[] = {2, 4, 5, 7, 8, 11};
const hb_codepoint_t expected_test_03_dumy_08[] = {2, 3, 6, 7, 8, 11};
hb_subset_input_t *input = hb_subset_input_create_or_fail ();
hb_set_add_range (hb_subset_input_unicode_set (input), 'A', 'F');
@@ -132,7 +136,24 @@ test_subset_lookup_variations (void)
hb_face_t *subset = hb_subset_or_fail (face, input);
g_assert_nonnull (subset);
int coords[] = {13107}; /* 0.8 */
assert_lookup_variations_shape (subset, coords, 1);
assert_lookup_variations_shape (subset, coords, 1, expected_all);
hb_face_destroy (subset);
hb_subset_input_destroy (input);
input = hb_subset_input_create_or_fail ();
hb_set_add_range (hb_subset_input_unicode_set (input), 'A', 'F');
features = hb_subset_input_set (input, HB_SUBSET_SETS_LAYOUT_FEATURE_TAG);
hb_set_clear (features);
hb_set_add (features, HB_TAG ('l', 'i', 'g', 'a'));
g_assert_true (hb_subset_input_pin_axis_location (
input, face, HB_TAG ('T', 'E', 'S', 'T'), 0.8f));
g_assert_true (hb_subset_input_pin_axis_location (
input, face, HB_TAG ('D', 'U', 'M', 'Y'), 0.f));
subset = hb_subset_or_fail (face, input);
g_assert_nonnull (subset);
assert_lookup_variations_shape (subset, NULL, 0, expected_all);
hb_face_destroy (subset);
hb_subset_input_destroy (input);
@@ -147,7 +168,32 @@ test_subset_lookup_variations (void)
subset = hb_subset_or_fail (face, input);
g_assert_nonnull (subset);
assert_lookup_variations_shape (subset, NULL, 0);
coords[0] = 0;
assert_lookup_variations_shape (subset, coords, 1, expected_all);
coords[0] = 13107; /* DUMY=0.8 */
assert_lookup_variations_shape (
subset, coords, 1, expected_test_08_dumy_08);
hb_face_destroy (subset);
hb_subset_input_destroy (input);
input = hb_subset_input_create_or_fail ();
hb_set_add_range (hb_subset_input_unicode_set (input), 'A', 'F');
features = hb_subset_input_set (input, HB_SUBSET_SETS_LAYOUT_FEATURE_TAG);
hb_set_clear (features);
hb_set_add (features, HB_TAG ('l', 'i', 'g', 'a'));
hb_set_add (features, HB_TAG ('r', 'l', 'i', 'g'));
g_assert_true (hb_subset_input_pin_axis_location (
input, face, HB_TAG ('T', 'E', 'S', 'T'), 0.3f));
subset = hb_subset_or_fail (face, input);
g_assert_nonnull (subset);
coords[0] = 0;
assert_lookup_variations_shape (
subset, coords, 1, expected_test_03_dumy_0);
coords[0] = 13107; /* DUMY=0.8 */
assert_lookup_variations_shape (
subset, coords, 1, expected_test_03_dumy_08);
hb_face_destroy (subset);
hb_subset_input_destroy (input);
@@ -4,8 +4,8 @@
../fonts/ab40c89624a6104e5d0a2308e448a989302f515b.ttf;--variations=wdth=60;U+0020;[space=0+266]
../fonts/ab40c89624a6104e5d0a2308e448a989302f515b.ttf;--variations=wdth=402;U+0020;[space=0+639]
../fonts/e8691822f6a705e3e9fb48a0405c645b1a036590.ttf;--variations=0001=500;U+002E,U+0065;[period=0+681|e=1+650]
../fonts/48b61f685ab1b3a3690fe4fea46ffc73dac3c301.ttf;--variations=TEST=0;U+0041,U+0042,U+0043,U+0044,U+0045,U+0046;[A.alt=0+600|B=1+600|C=2+600|D=3+600|E=4+600|F=5+600]
../fonts/48b61f685ab1b3a3690fe4fea46ffc73dac3c301.ttf;--variations=TEST=.3;U+0041,U+0042,U+0043,U+0044,U+0045,U+0046;[A.alt=0+600|B.alt=1+600|C=2+600|D=3+600|E=4+600|F.alt=5+600]
../fonts/48b61f685ab1b3a3690fe4fea46ffc73dac3c301.ttf;--variations=TEST=.6;U+0041,U+0042,U+0043,U+0044,U+0045,U+0046;[A.alt=0+600|B.alt=1+600|C.alt=2+600|D=3+600|E=4+600|F.alt=5+600]
../fonts/48b61f685ab1b3a3690fe4fea46ffc73dac3c301.ttf;--variations=TEST=.8;U+0041,U+0042,U+0043,U+0044,U+0045,U+0046;[A.alt=0+600|B.alt=1+600|C.alt=2+600|D.alt=3+600|E=4+600|F.alt=5+600]
../fonts/48b61f685ab1b3a3690fe4fea46ffc73dac3c301.ttf;--variations=TEST=0;U+0041,U+0042,U+0043,U+0044,U+0045,U+0046;[A.alt=0+600|B=1+600|C=2+600|D=3+600|E=4+600|F=5+600]
../fonts/ce30d3c1c8f77c156589ac7584acecaa4dfb619b.ttf;--variations=TEST=0;U+0041,U+0042,U+0043,U+0044,U+0045,U+0046;[A.alt=0+600|B=1+600|C=2+600|D=3+600|E=4+600|F=5+600]
../fonts/ce30d3c1c8f77c156589ac7584acecaa4dfb619b.ttf;--variations=TEST=.3;U+0041,U+0042,U+0043,U+0044,U+0045,U+0046;[A.alt=0+600|B.alt=1+600|C=2+600|D=3+600|E=4+600|F.alt=5+600]
../fonts/ce30d3c1c8f77c156589ac7584acecaa4dfb619b.ttf;--variations=TEST=.6;U+0041,U+0042,U+0043,U+0044,U+0045,U+0046;[A.alt=0+600|B.alt=1+600|C.alt=2+600|D=3+600|E=4+600|F.alt=5+600]
../fonts/ce30d3c1c8f77c156589ac7584acecaa4dfb619b.ttf;--variations=TEST=.8;U+0041,U+0042,U+0043,U+0044,U+0045,U+0046;[A.alt=0+600|B.alt=1+600|C.alt=2+600|D.alt=3+600|E=4+600|F.alt=5+600]
../fonts/ce30d3c1c8f77c156589ac7584acecaa4dfb619b.ttf;--variations=TEST=0;U+0041,U+0042,U+0043,U+0044,U+0045,U+0046;[A.alt=0+600|B=1+600|C=2+600|D=3+600|E=4+600|F=5+600]