Merge pull request #4710 from harfbuzz/cff2-instancing-try2

Trying to partial-instance CFF2
This commit is contained in:
Behdad Esfahbod authored and GitHub committed 2026-07-14 14:02:20 -06:00
commit 88e09bb1dc
26 files changed
+763 -27

No files matched your search

+2 -1
View File
@@ -238,7 +238,8 @@ struct number_t
}
void set_fixed (int32_t v) { value = v / 65536.0; }
int32_t to_fixed () const { return value * 65536.0; }
int32_t to_fixed () const
{ return (int32_t) hb_clamp (value * 65536.0, (double) INT32_MIN, (double) INT32_MAX); }
void set_real (double v) { value = v; }
double to_real () const { return value; }
+18 -1
View File
@@ -78,7 +78,8 @@ struct cff2_cs_interp_env_t : cs_interp_env_t<ELEM, CFF2Subrs>
num_coords = num_coords_;
varStore = acc.varStore;
do_blend = num_coords && varStore->size;
set_ivs (acc.privateDicts[fd].ivs);
orig_ivs = acc.privateDicts[fd].ivs;
set_ivs (orig_ivs);
}
~cff2_cs_interp_env_t ()
@@ -179,6 +180,8 @@ struct cff2_cs_interp_env_t : cs_interp_env_t<ELEM, CFF2Subrs>
void set_region_count (unsigned int region_count_) { region_count = region_count_; }
unsigned int get_ivs () const { return ivs; }
void set_ivs (unsigned int ivs_) { ivs = ivs_; }
/* The FD's private-dict ivs, before any vsindex op in the charstring. */
unsigned int get_orig_ivs () const { return orig_ivs; }
bool seen_vsindex () const { return seen_vsindex_; }
double blend_deltas (hb_array_t<const ELEM> deltas) const
@@ -204,6 +207,7 @@ struct cff2_cs_interp_env_t : cs_interp_env_t<ELEM, CFF2Subrs>
const CFF2ItemVariationStore *varStore;
unsigned int region_count;
unsigned int ivs;
unsigned int orig_ivs;
hb_vector_t<float> *scalars = nullptr;
hb_atomic_t<hb_vector_t<float> *> *cached_scalars_vector = nullptr;
bool do_blend;
@@ -260,6 +264,19 @@ struct cff2_cs_opset_t : cs_opset_t<ELEM, OPSET, cff2_cs_interp_env_t<ELEM>, PAR
{
if (env.have_coords ())
arg.set_int (round (arg.to_real () + env.blend_deltas (blends)));
else if (unlikely (arg.blending ()))
{
/* A blend result used as an operand of a later blend: the value is
* default + inner deltas + outer deltas, so accumulate the deltas. */
hb_vector_t<number_t> inner = std::move (arg.deltas);
arg.set_blends (n, i, blends);
if (likely (inner.length == arg.deltas.length))
for (unsigned j = 0; j < inner.length; j++)
arg.deltas.arrayZ[j].set_real (arg.deltas.arrayZ[j].to_real () +
inner.arrayZ[j].to_real ());
else
env.set_error ();
}
else
arg.set_blends (n, i, blends);
}
+6
View File
@@ -346,6 +346,12 @@ struct cff2_private_dict_opset_subset_t : dict_opset_t
env.clear_args ();
break;
case OpCode_vsindexdict:
env.process_vsindex ();
dictval.ivs = env.get_ivs ();
env.clear_args ();
break;
default:
SUPER::process_op (op, env);
if (!env.argStack.is_empty ()) return;
+7
View File
@@ -334,6 +334,8 @@ struct cs_command_t
typedef hb_vector_t<cs_command_t> *cs_command_vec_t;
struct cff2_instancing_plan_t;
struct flatten_param_t
{
flatten_param_t (str_buff_t &flatStr_,
@@ -346,6 +348,11 @@ struct flatten_param_t
bool drop_hints;
const hb_subset_plan_t *plan;
cs_command_vec_t commands; /* Optional: capture parsed commands for specialization */
/* CFF2 partial instancing: when set, blends are rewritten against the
* instanced variation store instead of being copied or flattened. */
const cff2_instancing_plan_t *instancer = nullptr;
bool emitted_blend = false;
};
template <typename ACC, typename ENV, typename OPSET, op_code_t endchar_op=OpCode_Invalid>
+704 -16
View File
@@ -30,6 +30,7 @@
#include "hb-open-type.hh"
#include "hb-ot-cff2-table.hh"
#include "hb-ot-var-common.hh"
#include "hb-set.h"
#include "hb-subset-plan.hh"
#include "hb-subset-cff-common.hh"
@@ -38,6 +39,353 @@
using namespace CFF;
namespace CFF {
/*
* Partial instancing (some axes pinned or limited, others kept).
*
* This is a port of fontTools' instantiateCFF2 (fonttools/fonttools#3506),
* with one simplification: the variation-store instancing solver acts on
* regions independently of the per-blend delta values, so instead of lifting
* every blend's deltas into the store, instancing it, and reading the rows
* back, we instance each VarData once with identity delta rows. The
* instantiated tuples then give, per VarData, a fixed linear map from old
* per-region deltas to new per-region deltas. The contribution that folds
* into each blend's default value is the old store's region scalars
* evaluated at the new default location (plan->normalized_coords); the
* surviving rebased regions all evaluate to zero there.
*
* Use: create (), then note_use () for every blend the retained charstrings
* and private dicts hold, then finalize (); only VarDatas that are both
* still variable and actually used survive into the new store.
*/
struct cff2_instancing_plan_t
{
struct vardata_transform_t
{
/* new_deltas[j] = Σ_i matrix[j][i] * old_deltas[i] */
hb_vector_t<hb_vector_t<float>> matrix;
/* Default-value fold-in scalars, one per old region: the old store's
* region scalars at the new default location. */
hb_vector_t<float> gains;
/* Surviving regions, parallel to matrix rows. */
hb_vector_t<hb_hashmap_t<hb_tag_t, Triple>> regions;
/* Index into the new global region list, per new region (finalize). */
hb_vector_t<unsigned> region_indices;
unsigned new_major = 0;
bool alive_ = false;
bool alive () const { return alive_; }
/* One value's delta for new region j, from its old per-region deltas. */
double transform_delta (unsigned j, hb_array_t<const number_t> deltas) const
{
const hb_vector_t<float> &col = matrix.arrayZ[j];
double d = 0.;
unsigned count = hb_min (col.length, deltas.length);
for (unsigned c = 0; c < count; c++)
d += (double) col.arrayZ[c] * deltas.arrayZ[c].to_real ();
return d;
}
};
hb_vector_t<vardata_transform_t> transforms; /* per old VarData (vsindex) */
hb_vector_t<hb_hashmap_t<hb_tag_t, Triple>> new_regions; /* global region list */
hb_set_t used_majors;
unsigned new_major_count = 0;
bool has_variations () const { return new_major_count; }
const vardata_transform_t *get_transform (unsigned major) const
{ return major < transforms.length ? &transforms.arrayZ[major] : nullptr; }
/* Record that a retained blend references this VarData. */
void note_use (unsigned major) { used_majors.add (major); }
/* The new vsindex a private dict's (or charstring's) old ivs maps to;
* dead VarDatas fall back to 0, their blends having become static. */
unsigned remap_ivs (unsigned old_ivs) const
{
const vardata_transform_t *t = get_transform (old_ivs);
return (t && t->alive ()) ? t->new_major : 0;
}
double fold_deltas (unsigned old_ivs, hb_array_t<const number_t> deltas) const
{
const vardata_transform_t *t = get_transform (old_ivs);
if (unlikely (!t || t->gains.length != deltas.length)) return 0.;
double v = 0.;
for (unsigned i = 0; i < deltas.length; i++)
v += (double) t->gains.arrayZ[i] * deltas.arrayZ[i].to_real ();
return v;
}
bool create (const CFF2ItemVariationStore *cff2VarStore,
const hb_subset_plan_t *plan)
{
const OT::ItemVariationStore &varStore = cff2VarStore->varStore;
unsigned major_count = varStore.get_sub_table_count ();
if (!transforms.resize (major_count)) return false;
if (!varStore.get_region_list ().get_var_regions (plan->axes_old_index_tag_map, orig_regions))
return false;
/* Instance each VarData with identity delta rows; the surviving tuples'
* delta columns are the old-region → new-region transform. */
OT::optimize_scratch_t scratch;
for (unsigned m = 0; m < major_count; m++)
{
const OT::VarData &var_data = varStore.get_sub_table (m);
unsigned k = var_data.get_region_index_count ();
vardata_transform_t &t = transforms.arrayZ[m];
if (!t.gains.resize_exact (k)) return false;
varStore.get_region_scalars (m, plan->normalized_coords.arrayZ,
plan->normalized_coords.length,
t.gains.arrayZ, k);
OT::tuple_variations_t tuples;
for (unsigned r = 0; r < k; r++)
{
OT::tuple_delta_t tuple;
if (!tuple.deltas_x.resize (k) ||
!tuple.indices.resize (k))
return false;
for (unsigned i = 0; i < k; i++)
tuple.indices.arrayZ[i] = true;
tuple.deltas_x.arrayZ[r] = 1.f;
unsigned region_index = var_data.get_region_index (r);
if (unlikely (region_index >= orig_regions.length)) return false;
tuple.axis_tuples = orig_regions.arrayZ[region_index];
if (unlikely (tuple.axis_tuples.in_error ())) return false;
tuples.tuple_vars.push (std::move (tuple));
}
if (unlikely (tuples.tuple_vars.in_error ())) return false;
if (!tuples.instantiate (plan->axes_location, plan->axes_triple_distances, scratch))
return false;
for (auto &tuple : tuples.tuple_vars)
{
if (unlikely (tuple.deltas_x.length != k)) return false;
hb_vector_t<float> col;
if (unlikely (!col.resize_exact (k))) return false;
for (unsigned i = 0; i < k; i++)
col.arrayZ[i] = tuple.deltas_x.arrayZ[i];
t.matrix.push (std::move (col));
t.regions.push (std::move (tuple.axis_tuples));
}
if (unlikely (t.matrix.in_error () || t.regions.in_error ())) return false;
}
return true;
}
/* Decide which VarDatas survive, number them, and build the new global
* region list: surviving original regions first, in their original order,
* then solver-split new regions in order of appearance (fontTools'
* rebuildRegions + prune_regions). */
bool finalize ()
{
for (unsigned m = 0; m < transforms.length; m++)
{
vardata_transform_t &t = transforms.arrayZ[m];
t.alive_ = t.matrix.length && used_majors.has (m);
if (t.alive_)
t.new_major = new_major_count++;
}
/* Keys hash by content, so pointers into different owners compare fine. */
hb_hashmap_t<const hb_hashmap_t<hb_tag_t, Triple>*, unsigned> region_idx_map;
hb_vector_t<const hb_hashmap_t<hb_tag_t, Triple>*> region_ptrs;
for (const vardata_transform_t &t : transforms)
{
if (!t.alive ()) continue;
for (const auto &region : t.regions)
if (!region_idx_map.has (&region))
if (unlikely (!region_idx_map.set (&region, (unsigned) -1)))
return false;
}
for (const auto &r : orig_regions)
{
unsigned *idx;
if (region_idx_map.has (&r, &idx) && *idx == (unsigned) -1)
{
if (unlikely (!region_idx_map.set (&r, region_ptrs.length))) return false;
region_ptrs.push (&r);
}
}
for (const vardata_transform_t &t : transforms)
{
if (!t.alive ()) continue;
for (const auto &region : t.regions)
{
unsigned *idx;
if (region_idx_map.has (&region, &idx) && *idx == (unsigned) -1)
{
if (unlikely (!region_idx_map.set (&region, region_ptrs.length))) return false;
region_ptrs.push (&region);
}
}
}
if (unlikely (region_ptrs.in_error ())) return false;
for (vardata_transform_t &t : transforms)
{
if (!t.alive ()) continue;
for (const auto &region : t.regions)
{
unsigned *idx;
if (unlikely (!region_idx_map.has (&region, &idx))) return false;
t.region_indices.push (*idx);
}
if (unlikely (t.region_indices.in_error ())) return false;
}
if (!new_regions.resize (region_ptrs.length)) return false;
for (unsigned i = 0; i < region_ptrs.length; i++)
{
new_regions.arrayZ[i] = *region_ptrs.arrayZ[i];
if (unlikely (new_regions.arrayZ[i].in_error ())) return false;
}
return true;
}
/* Serialize the instanced store: a CFF2ItemVariationStore whose VarDatas
* carry no items, just region indexes (blend deltas live in charstrings).
* Laid out manually since all sizes are known up front. */
bool serialize_var_store (hb_serialize_context_t *c,
const hb_vector_t<hb_tag_t> &axis_tags) const
{
unsigned data_count = new_major_count;
unsigned header_size = 2 + 4 + 2 + 4 * data_count;
uint64_t offset = header_size;
hb_vector_t<unsigned> data_offsets;
for (const vardata_transform_t &t : transforms)
{
if (!t.alive ()) continue;
data_offsets.push ((unsigned) offset);
offset += 6 + 2 * (uint64_t) t.region_indices.length;
}
if (unlikely (data_offsets.in_error () || data_offsets.length != data_count))
return false;
unsigned regions_offset = (unsigned) offset;
uint64_t total = offset + 4 + (uint64_t) new_regions.length * axis_tags.length * 6;
if (unlikely (total > 0xFFFFu)) return false;
HBUINT16 *size_field = c->allocate_size<HBUINT16> (HBUINT16::static_size);
if (unlikely (!size_field)) return false;
*size_field = total;
char *header = c->allocate_size<char> (header_size);
if (unlikely (!header)) return false;
* (HBUINT16 *) (header + 0) = 1; /* format */
* (HBUINT32 *) (header + 2) = regions_offset;
* (HBUINT16 *) (header + 6) = data_count;
for (unsigned i = 0; i < data_count; i++)
* (HBUINT32 *) (header + 8 + 4 * i) = data_offsets.arrayZ[i];
for (const vardata_transform_t &t : transforms)
{
if (!t.alive ()) continue;
unsigned k = t.region_indices.length;
HBUINT16 *v = (HBUINT16 *) c->allocate_size<char> (6 + 2 * k);
if (unlikely (!v)) return false;
v[0] = 0; /* itemCount */
v[1] = 0; /* wordSizeCount */
v[2] = k; /* regionIndices.len */
for (unsigned j = 0; j < k; j++)
v[3 + j] = t.region_indices.arrayZ[j];
}
hb_vector_t<const hb_hashmap_t<hb_tag_t, Triple>*> region_ptrs;
if (unlikely (!region_ptrs.alloc_exact (new_regions.length))) return false;
for (const auto &r : new_regions)
region_ptrs.push (&r);
auto *region_list = c->start_embed<OT::VarRegionList> ();
return region_list->serialize (c, axis_tags, region_ptrs);
}
private:
hb_vector_t<hb_hashmap_t<hb_tag_t, Triple>> orig_regions;
};
/* Usage-collection pass for partial instancing: record which VarDatas the
* retained charstrings' and private dicts' blends reference. Mirrors the
* emission pass: blends consumed by dropped hint ops don't count. */
struct cff2_usage_param_t
{
void init () {}
cff2_instancing_plan_t *instancing = nullptr;
bool drop_hints = false;
unsigned ivs = 0; /* dict-side current vsindex */
};
struct cff2_cs_opset_usage_t : cff2_cs_opset_t<cff2_cs_opset_usage_t, cff2_usage_param_t, blend_arg_t>
{
static void flush_args_and_op (op_code_t op, cff2_cs_interp_env_t<blend_arg_t> &env, cff2_usage_param_t& param)
{
bool counts = true;
switch (op)
{
case OpCode_return:
case OpCode_endchar:
counts = false;
break;
case OpCode_hstem:
case OpCode_hstemhm:
case OpCode_vstem:
case OpCode_vstemhm:
case OpCode_hintmask:
case OpCode_cntrmask:
if (param.drop_hints)
counts = false;
break;
default:
break;
}
if (counts)
for (unsigned int i = 0; i < env.argStack.get_count (); i++)
if (env.argStack[i].blending ())
{
param.instancing->note_use (env.get_ivs ());
break;
}
env.clear_args ();
}
};
struct cff2_private_dict_usage_opset_t : dict_opset_t
{
static void process_op (op_code_t op, cff2_priv_dict_interp_env_t& env, cff2_usage_param_t& param)
{
switch (op) {
case OpCode_vsindexdict:
env.process_vsindex ();
param.ivs = env.get_ivs ();
env.clear_args ();
return;
case OpCode_blenddict:
param.instancing->note_use (param.ivs);
env.clear_args ();
return;
default:
dict_opset_t::process_op (op, env);
if (!env.argStack.is_empty ()) return;
env.clear_args ();
return;
}
}
};
} /* namespace CFF */
struct cff2_sub_table_info_t : cff_sub_table_info_t
{
cff2_sub_table_info_t ()
@@ -129,6 +477,8 @@ struct cff2_cs_opset_flatten_t : cff2_cs_opset_t<cff2_cs_opset_flatten_t, flatte
case OpCode_return:
case OpCode_endchar:
/* dummy opcodes in CFF2. ignore */
if (op == OpCode_endchar && param.instancer)
emit_vsindex_prefix (env, param);
break;
case OpCode_hstem:
@@ -162,7 +512,10 @@ struct cff2_cs_opset_flatten_t : cff2_cs_opset_t<cff2_cs_opset_flatten_t, flatte
env.set_error ();
return;
}
flatten_blends (arg, i, env, param);
if (param.instancer)
rewrite_blends (arg, i, env, param);
else
flatten_blends (arg, i, env, param);
i += arg.numValues;
}
else
@@ -202,6 +555,113 @@ struct cff2_cs_opset_flatten_t : cff2_cs_opset_t<cff2_cs_opset_flatten_t, flatte
encoder.encode_op (OpCode_blendcs);
}
/* Partial instancing: rewrite one blend group against the instanced store.
* Each value's default absorbs the folded (pinned-away) contribution, and
* its deltas are mapped onto the new region list. */
static void rewrite_blends (const blend_arg_t &arg, unsigned int i, cff2_cs_interp_env_t<blend_arg_t> &env, flatten_param_t& param)
{
const cff2_instancing_plan_t &instancer = *param.instancer;
unsigned ivs = env.get_ivs ();
const cff2_instancing_plan_t::vardata_transform_t *t = instancer.get_transform (ivs);
if (unlikely (!t))
{
env.set_error ();
return;
}
unsigned n = arg.numValues;
for (unsigned int j = 0; j < n; j++)
{
const blend_arg_t &arg1 = env.argStack[i + j];
if (unlikely (!(arg1.blending () && (arg1.numValues == n) && (arg1.valueIndex == j) &&
(arg1.deltas.length == env.get_region_count ()) &&
(arg1.deltas.length == t->gains.length))))
{
env.set_error ();
return;
}
}
str_encoder_t encoder (param.flatStr);
unsigned k_new = t->alive () ? t->matrix.length : 0;
if (!k_new)
{
/* All of this VarData's regions died; blends dissolve into statics. */
for (unsigned int j = 0; j < n; j++)
{
const blend_arg_t &arg1 = env.argStack[i + j];
number_t v;
v.set_real (arg1.to_real () + round (instancer.fold_deltas (ivs, arg1.deltas.as_array ())));
encoder.encode_num_cs (v);
}
return;
}
/* Emit in chunks so the output charstring stays within the argument
* stack limit: values already emitted for this op, plus this chunk's
* defaults, deltas and count, must not exceed 513. */
unsigned done = 0;
while (done < n)
{
unsigned avail = 512 > (i + done) ? 512 - (i + done) : 0;
unsigned chunk = hb_min (avail / (k_new + 1), n - done);
if (unlikely (!chunk))
{
env.set_error ();
return;
}
for (unsigned int j = done; j < done + chunk; j++)
{
const blend_arg_t &arg1 = env.argStack[i + j];
number_t v;
v.set_real (arg1.to_real () + round (instancer.fold_deltas (ivs, arg1.deltas.as_array ())));
encoder.encode_num_cs (v);
}
for (unsigned int j = done; j < done + chunk; j++)
{
const blend_arg_t &arg1 = env.argStack[i + j];
for (unsigned r = 0; r < k_new; r++)
{
number_t v;
v.set_int ((int) round (t->transform_delta (r, arg1.deltas.as_array ())));
encoder.encode_num_cs (v);
}
}
encoder.encode_int (chunk);
encoder.encode_op (OpCode_blendcs);
done += chunk;
}
param.emitted_blend = true;
}
/* Partial instancing: prepend a vsindex op when the charstring's
* (remapped) ivs differs from its FD's (remapped) private-dict ivs. */
static void emit_vsindex_prefix (cff2_cs_interp_env_t<blend_arg_t> &env, flatten_param_t& param)
{
if (!param.emitted_blend) return;
const cff2_instancing_plan_t &instancer = *param.instancer;
unsigned new_ivs = instancer.remap_ivs (env.get_ivs ());
unsigned fd_ivs = instancer.remap_ivs (env.get_orig_ivs ());
if (new_ivs == fd_ivs) return;
str_buff_t prefix;
str_encoder_t enc (prefix);
enc.encode_int ((int) new_ivs);
enc.encode_op (OpCode_vsindexcs);
str_buff_t &buf = param.flatStr;
unsigned old_len = buf.length;
if (unlikely (prefix.in_error () || !buf.resize (old_len + prefix.length)))
{
env.set_error ();
return;
}
memmove (buf.arrayZ + prefix.length, buf.arrayZ, old_len);
hb_memcpy (buf.arrayZ, prefix.arrayZ, prefix.length);
}
static void flush_op (op_code_t op, cff2_cs_interp_env_t<blend_arg_t> &env, flatten_param_t& param)
{
switch (op)
@@ -353,6 +813,13 @@ struct cff2_private_blend_encoder_param_t
hb_vector_t<float> scalars;
const CFF2ItemVariationStore *varStore = nullptr;
hb_array_t<int> normalized_coords;
/* CFF2 partial instancing: when set, blends are rewritten against the
* instanced variation store instead of being flattened. */
const cff2_instancing_plan_t *instancer = nullptr;
/* Error-compensated fold rounding state, per dict operator. */
double fold_exact = 0.;
double fold_emitted = 0.;
};
struct cff2_private_dict_blend_opset_t : dict_opset_t
@@ -365,6 +832,98 @@ struct cff2_private_dict_blend_opset_t : dict_opset_t
arg.set_int (round (arg.to_real () + param.blend_deltas (blends)));
}
/* The fold added to a value, error-compensated across the operator: most
* blended private-dict values (BlueValues, StemSnap*, ...) are
* delta-encoded, so independently rounded folds would accumulate in the
* decoded absolutes; keeping the emitted cumulative fold equal to the
* rounded exact cumulative fold bounds every absolute within ±0.5. */
static double fold (cff2_private_blend_encoder_param_t& param,
const hb_array_t<const number_t> blends)
{
double f = param.blend_deltas (blends);
double emit = round (param.fold_exact + f) - param.fold_emitted;
param.fold_exact += f;
param.fold_emitted += emit;
return emit;
}
/* Partial instancing: emit the args preceding this blend group, then the
* group itself rewritten against the instanced store, and clear the
* stack. The op's remaining args are flushed at process_op time. */
static void rewrite_blends (cff2_priv_dict_interp_env_t& env,
cff2_private_blend_encoder_param_t& param,
unsigned start, unsigned n, unsigned k)
{
const cff2_instancing_plan_t &instancer = *param.instancer;
const cff2_instancing_plan_t::vardata_transform_t *t = instancer.get_transform (param.ivs);
if (unlikely (!t || t->gains.length != k))
{
env.set_error ();
return;
}
str_buff_t str;
str_encoder_t encoder (str);
for (unsigned idx = 0; idx < start; idx++)
encoder.encode_num_tp (env.argStack[idx]);
unsigned k_new = t->alive () ? t->matrix.length : 0;
if (!k_new)
{
/* This VarData died (or is unused by any retained charstring, which
* can happen for FDs kept only for retain-gids holes); blends
* dissolve into statics. */
for (unsigned j = 0; j < n; j++)
{
const hb_array_t<const number_t> blends = env.argStack.sub_array (start + n + (j * k), k);
number_t v;
v.set_real (env.argStack[start + j].to_real () + fold (param, blends));
encoder.encode_num_tp (v);
}
}
else
{
unsigned done = 0;
while (done < n)
{
unsigned avail = 512 > (start + done) ? 512 - (start + done) : 0;
unsigned chunk = hb_min (avail / (k_new + 1), n - done);
if (unlikely (!chunk))
{
env.set_error ();
return;
}
for (unsigned j = done; j < done + chunk; j++)
{
const hb_array_t<const number_t> blends = env.argStack.sub_array (start + n + (j * k), k);
number_t v;
v.set_real (env.argStack[start + j].to_real () + fold (param, blends));
encoder.encode_num_tp (v);
}
for (unsigned j = done; j < done + chunk; j++)
{
const hb_array_t<const number_t> blends = env.argStack.sub_array (start + n + (j * k), k);
for (unsigned r = 0; r < k_new; r++)
{
number_t v;
v.set_int ((int) round (t->transform_delta (r, blends)));
encoder.encode_num_tp (v);
}
}
encoder.encode_int (chunk);
encoder.encode_op (OpCode_blenddict);
done += chunk;
}
}
auto bytes = str.as_bytes ();
param.c->embed (&bytes, bytes.length);
env.clear_args ();
}
static void process_blend (cff2_priv_dict_interp_env_t& env, cff2_private_blend_encoder_param_t& param)
{
unsigned int n, k;
@@ -380,6 +939,13 @@ struct cff2_private_dict_blend_opset_t : dict_opset_t
env.set_error ();
return;
}
if (param.instancer && k)
{
rewrite_blends (env, param, start, n, k);
return;
}
for (unsigned int i = 0; i < n; i++)
{
const hb_array_t<const number_t> blends = env.argStack.sub_array (start + n + (i * k), k);
@@ -410,6 +976,20 @@ struct cff2_private_dict_blend_opset_t : dict_opset_t
case OpCode_vsindexdict:
env.process_vsindex ();
param.ivs = env.get_ivs ();
if (param.instancer)
{
/* Re-emit with the remapped vsindex; 0 is the dict default. */
unsigned new_ivs = param.instancer->remap_ivs (param.ivs);
if (new_ivs)
{
str_buff_t str;
str_encoder_t encoder (str);
encoder.encode_int ((int) new_ivs);
encoder.encode_op (OpCode_vsindexdict);
auto bytes = str.as_bytes ();
param.c->embed (&bytes, bytes.length);
}
}
env.clear_args ();
return;
case OpCode_blenddict:
@@ -439,6 +1019,7 @@ struct cff2_private_dict_blend_opset_t : dict_opset_t
param.c->embed (&bytes, bytes.length);
env.clear_args ();
param.fold_exact = param.fold_emitted = 0.;
}
};
@@ -446,9 +1027,11 @@ struct cff2_private_dict_op_serializer_t : op_serializer_t
{
cff2_private_dict_op_serializer_t (bool desubroutinize_, bool drop_hints_, bool pinned_,
const CFF::CFF2ItemVariationStore* varStore_,
hb_array_t<int> normalized_coords_)
hb_array_t<int> normalized_coords_,
const cff2_instancing_plan_t *instancer_ = nullptr)
: desubroutinize (desubroutinize_), drop_hints (drop_hints_), pinned (pinned_),
varStore (varStore_), normalized_coords (normalized_coords_) {}
param (nullptr, varStore_, normalized_coords_)
{ param.instancer = instancer_; }
bool serialize (hb_serialize_context_t *c,
const op_str_t &opstr,
@@ -467,11 +1050,13 @@ struct cff2_private_dict_op_serializer_t : op_serializer_t
return_trace (FontDict::serialize_link2_op (c, opstr.op, subrs_link));
}
if (pinned)
if (pinned || param.instancer)
{
// Reinterpret opstr and process blends.
/* Reinterpret opstr and process blends. The param persists across
* this dict's opstrs, so that an ivs set by a vsindexdict opstr is
* still in effect when a later opstr's blends are processed. */
cff2_priv_dict_interp_env_t env {hb_ubytes_t (opstr.ptr, opstr.length)};
cff2_private_blend_encoder_param_t param (c, varStore, normalized_coords);
param.c = c;
dict_interpreter_t<cff2_private_dict_blend_opset_t, cff2_private_blend_encoder_param_t, cff2_priv_dict_interp_env_t> interp (env);
return_trace (interp.interpret (param));
}
@@ -483,11 +1068,11 @@ struct cff2_private_dict_op_serializer_t : op_serializer_t
const bool desubroutinize;
const bool drop_hints;
const bool pinned;
const CFF::CFF2ItemVariationStore* varStore;
hb_array_t<int> normalized_coords;
mutable cff2_private_blend_encoder_param_t param;
};
namespace OT {
struct cff2_subset_plan
{
@@ -502,12 +1087,21 @@ struct cff2_subset_plan
orig_fdcount = acc.fdArray->count;
drop_hints = plan->flags & HB_SUBSET_FLAGS_NO_HINTING;
pinned = (bool) plan->normalized_coords;
bool instancing_requested = (bool) plan->normalized_coords;
pinned = instancing_requested && plan->all_axes_pinned;
normalized_coords = plan->normalized_coords;
head_maxp_info = plan->head_maxp_info;
hmtx_map = &plan->hmtx_map;
desubroutinize = plan->flags & HB_SUBSET_FLAGS_DESUBROUTINIZE ||
pinned; // For instancing we need this path
instancing_requested; // For instancing we need this path
/* Partial instancing: some axes pinned or limited, others kept. */
partial_instancing = instancing_requested && !pinned &&
acc.varStore != &Null (CFF2ItemVariationStore);
if (partial_instancing &&
unlikely (!instancing.create (acc.varStore, plan)))
return false;
axis_tags = &plan->axis_tags;
/* Enable command capture for CFF2→CFF1 conversion (for specialization) */
capture_commands = pinned;
@@ -520,6 +1114,77 @@ struct cff2_subset_plan
if (desubroutinize)
{
if (partial_instancing)
{
/* Pass 1: collect which VarDatas the retained blends reference, so
* unused ones get pruned and the survivors renumbered. */
hb_set_t used_fds;
for (unsigned int i = 0; i < num_glyphs; i++)
{
hb_codepoint_t glyph;
if (!plan->old_gid_for_new_gid (i, &glyph))
continue;
const hb_ubytes_t str = (*acc.charStrings)[glyph];
unsigned int fd = acc.fdSelect->get_fd (glyph);
if (unlikely (fd >= acc.fdCount))
return false;
used_fds.add (fd);
cff2_cs_interp_env_t<blend_arg_t> env (str, acc, fd);
cs_interpreter_t<cff2_cs_interp_env_t<blend_arg_t>, cff2_cs_opset_usage_t, cff2_usage_param_t> interp (env);
cff2_usage_param_t param;
param.instancing = &instancing;
param.drop_hints = drop_hints;
if (unlikely (!interp.interpret (param)))
return false;
}
for (unsigned fd : used_fds)
{
cff2_usage_param_t param;
param.instancing = &instancing;
unsigned count = acc.privateDicts[fd].get_count ();
for (unsigned j = 0; j < count; j++)
{
const op_str_t &opstr = acc.privateDicts[fd][j];
if (drop_hints && dict_opset_t::is_hint_op (opstr.op))
continue;
cff2_priv_dict_interp_env_t env {hb_ubytes_t (opstr.ptr, opstr.length)};
dict_interpreter_t<cff2_private_dict_usage_opset_t, cff2_usage_param_t, cff2_priv_dict_interp_env_t> interp (env);
if (unlikely (!interp.interpret (param)))
return false;
}
}
if (unlikely (!instancing.finalize ()))
return false;
/* Pass 2: like subr_flattener_t, but blends stay symbolic (no coords
* fed to the env) and get rewritten against the instanced store. */
if (!subset_charstrings.resize_exact (num_glyphs))
return false;
for (unsigned int i = 0; i < num_glyphs; i++)
{
hb_codepoint_t glyph;
if (!plan->old_gid_for_new_gid (i, &glyph))
continue;
const hb_ubytes_t str = (*acc.charStrings)[glyph];
unsigned int fd = acc.fdSelect->get_fd (glyph);
if (unlikely (fd >= acc.fdCount))
return false;
cff2_cs_interp_env_t<blend_arg_t> env (str, acc, fd);
cs_interpreter_t<cff2_cs_interp_env_t<blend_arg_t>, cff2_cs_opset_flatten_t, flatten_param_t> interp (env);
flatten_param_t param = {
subset_charstrings.arrayZ[i],
(bool) (plan->flags & HB_SUBSET_FLAGS_NO_HINTING),
plan
};
param.instancer = &instancing;
if (unlikely (!interp.interpret (param)))
return false;
}
}
else
{
/* Flatten global & local subrs */
subr_flattener_t<const OT::cff2::accelerator_subset_t, cff2_cs_interp_env_t<blend_arg_t>, cff2_cs_opset_flatten_t>
flattener(acc, plan);
@@ -538,6 +1203,7 @@ struct cff2_subset_plan
if (!flattener.flatten (subset_charstrings))
return false;
}
}
}
else
{
@@ -603,6 +1269,10 @@ struct cff2_subset_plan
bool drop_hints = false;
bool desubroutinize = false;
bool partial_instancing = false;
cff2_instancing_plan_t instancing;
const hb_vector_t<hb_tag_t> *axis_tags = nullptr;
unsigned min_charstrings_off_size = 0;
hb_array_t<int> normalized_coords; // For instantiation
@@ -1138,7 +1808,8 @@ OT::cff2::accelerator_subset_t::serialize (hb_serialize_context_t *c,
}
auto *pd = c->push<PrivateDict> ();
cff2_private_dict_op_serializer_t privSzr (plan.desubroutinize, plan.drop_hints, plan.pinned,
varStore, normalized_coords);
varStore, normalized_coords,
plan.partial_instancing ? &plan.instancing : nullptr);
if (likely (pd->serialize (c, privateDicts[i], privSzr, subrs_link)))
{
unsigned fd = plan.fdmap[i];
@@ -1191,13 +1862,30 @@ OT::cff2::accelerator_subset_t::serialize (hb_serialize_context_t *c,
if (varStore != &Null (CFF2ItemVariationStore) &&
!plan.pinned)
{
auto *dest = c->push<CFF2ItemVariationStore> ();
if (unlikely (!dest->serialize (c, varStore)))
if (plan.partial_instancing)
{
c->pop_discard ();
return false;
if (plan.instancing.has_variations ())
{
c->push ();
if (unlikely (!plan.instancing.serialize_var_store (c, *plan.axis_tags)))
{
c->pop_discard ();
return false;
}
plan.info.var_store_link = c->pop_pack (false);
}
/* else: the store emptied; the vstore op gets dropped along with it. */
}
else
{
auto *dest = c->push<CFF2ItemVariationStore> ();
if (unlikely (!dest->serialize (c, varStore)))
{
c->pop_discard ();
return false;
}
plan.info.var_store_link = c->pop_pack (false);
}
plan.info.var_store_link = c->pop_pack (false);
}
OT::cff2 *cff2 = c->allocate_min<OT::cff2> ();
+3 -6
View File
@@ -426,8 +426,7 @@ hb_subset_input_keep_everything (hb_subset_input_t *input)
*
* Pin all axes to default locations in the given subset input object.
*
* All axes in a font must be pinned. Additionally, `CFF2` table, if present,
* will be de-subroutinized.
* The `CFF2` table, if present, will be de-subroutinized.
*
* Return value: `true` if success, `false` otherwise
*
@@ -467,8 +466,7 @@ hb_subset_input_pin_all_axes_to_default (hb_subset_input_t *input,
*
* Pin an axis to its default location in the given subset input object.
*
* All axes in a font must be pinned. Additionally, `CFF2` table, if present,
* will be de-subroutinized.
* The `CFF2` table, if present, will be de-subroutinized.
*
* Return value: `true` if success, `false` otherwise
*
@@ -496,8 +494,7 @@ hb_subset_input_pin_axis_to_default (hb_subset_input_t *input,
*
* Pin an axis to a fixed location in the given subset input object.
*
* All axes in a font must be pinned. Additionally, `CFF2` table, if present,
* will be de-subroutinized.
* The `CFF2` table, if present, will be de-subroutinized.
*
* Return value: `true` if success, `false` otherwise
*
+3 -3
View File
@@ -84,9 +84,9 @@ typedef struct hb_subset_plan_t hb_subset_plan_t;
* HB_SUBSET_FLAGS_RETAIN_GIDS then the number of glyphs in the font won't
* be reduced as a result of subsetting. If necessary empty glyphs will be
* included at the end of the font to keep the number of glyphs unchanged.
* @HB_SUBSET_FLAGS_DOWNGRADE_CFF2: If set and instantiating a variable font,
* convert the output CFF2 table to CFF1. This enables compatibility with older
* renderers that don't support CFF2. Since: 13.0.0
* @HB_SUBSET_FLAGS_DOWNGRADE_CFF2: If set and instantiating a variable font
* with all axes pinned, convert the output CFF2 table to CFF1. This enables
* compatibility with older renderers that don't support CFF2. Since: 13.0.0
*
* List of boolean properties that can be configured on the subset input.
*
Binary file not shown.
@@ -0,0 +1,19 @@
FONTS:
AdobeVFPrototype.otf
AdobeVFPrototype_vsindex.otf
PROFILES:
default.txt
SUBSETS:
*
ABC
INSTANCES:
wght=300:600
wght=500,CNTR=0:100
wght=300:500:700,CNTR=25:75
CNTR=drop
OPTIONS:
no_fonttools
+1
View File
@@ -62,6 +62,7 @@ tests = [
'instantiate_colrv1',
'instantiate_glyf',
'instantiate_cff2',
'instantiate_cff2_partial',
'downgrade_cff2',
'instantiate_cff2_tsb',
'full_instance',