mirror of
https://github.com/storytold/harfbuzz.git
synced 2026-11-21 23:11:04 +01:00
Merge pull request #4710 from harfbuzz/cff2-instancing-try2
Trying to partial-instance CFF2
This commit is contained in:
26 files changed
+763
-27
No files matched your search
@@ -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; }
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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
@@ -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 ®ion : t.regions)
|
||||
if (!region_idx_map.has (®ion))
|
||||
if (unlikely (!region_idx_map.set (®ion, (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 ®ion : t.regions)
|
||||
{
|
||||
unsigned *idx;
|
||||
if (region_idx_map.has (®ion, &idx) && *idx == (unsigned) -1)
|
||||
{
|
||||
if (unlikely (!region_idx_map.set (®ion, region_ptrs.length))) return false;
|
||||
region_ptrs.push (®ion);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (unlikely (region_ptrs.in_error ())) return false;
|
||||
|
||||
for (vardata_transform_t &t : transforms)
|
||||
{
|
||||
if (!t.alive ()) continue;
|
||||
for (const auto ®ion : t.regions)
|
||||
{
|
||||
unsigned *idx;
|
||||
if (unlikely (!region_idx_map.has (®ion, &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> ();
|
||||
|
||||
@@ -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
@@ -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.
|
||||
*
|
||||
|
||||
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
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
|
||||
@@ -62,6 +62,7 @@ tests = [
|
||||
'instantiate_colrv1',
|
||||
'instantiate_glyf',
|
||||
'instantiate_cff2',
|
||||
'instantiate_cff2_partial',
|
||||
'downgrade_cff2',
|
||||
'instantiate_cff2_tsb',
|
||||
'full_instance',
|
||||
|
||||
Reference in new issue
Block a user