diff --git a/src/hb-cff-interp-common.hh b/src/hb-cff-interp-common.hh index c9829a4db..9ca8bf56d 100644 --- a/src/hb-cff-interp-common.hh +++ b/src/hb-cff-interp-common.hh @@ -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; } diff --git a/src/hb-cff2-interp-cs.hh b/src/hb-cff2-interp-cs.hh index 6a338b462..770a4ae36 100644 --- a/src/hb-cff2-interp-cs.hh +++ b/src/hb-cff2-interp-cs.hh @@ -78,7 +78,8 @@ struct cff2_cs_interp_env_t : cs_interp_env_t 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 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 deltas) const @@ -204,6 +207,7 @@ struct cff2_cs_interp_env_t : cs_interp_env_t const CFF2ItemVariationStore *varStore; unsigned int region_count; unsigned int ivs; + unsigned int orig_ivs; hb_vector_t *scalars = nullptr; hb_atomic_t *> *cached_scalars_vector = nullptr; bool do_blend; @@ -260,6 +264,19 @@ struct cff2_cs_opset_t : cs_opset_t, 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 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); } diff --git a/src/hb-ot-cff2-table.hh b/src/hb-ot-cff2-table.hh index 061863835..e46ea5a87 100644 --- a/src/hb-ot-cff2-table.hh +++ b/src/hb-ot-cff2-table.hh @@ -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; diff --git a/src/hb-subset-cff-common.hh b/src/hb-subset-cff-common.hh index 3140b9ca3..7abeafa1d 100644 --- a/src/hb-subset-cff-common.hh +++ b/src/hb-subset-cff-common.hh @@ -334,6 +334,8 @@ struct cs_command_t typedef hb_vector_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 diff --git a/src/hb-subset-cff2.cc b/src/hb-subset-cff2.cc index 262eeb1ab..687b15d9d 100644 --- a/src/hb-subset-cff2.cc +++ b/src/hb-subset-cff2.cc @@ -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> matrix; + /* Default-value fold-in scalars, one per old region: the old store's + * region scalars at the new default location. */ + hb_vector_t gains; + /* Surviving regions, parallel to matrix rows. */ + hb_vector_t> regions; + /* Index into the new global region list, per new region (finalize). */ + hb_vector_t 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 deltas) const + { + const hb_vector_t &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 transforms; /* per old VarData (vsindex) */ + hb_vector_t> 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 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 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*, unsigned> region_idx_map; + hb_vector_t*> 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 &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 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::static_size); + if (unlikely (!size_field)) return false; + *size_field = total; + + char *header = c->allocate_size (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 (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*> 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 (); + return region_list->serialize (c, axis_tags, region_ptrs); + } + + private: + hb_vector_t> 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 +{ + static void flush_args_and_op (op_code_t op, cff2_cs_interp_env_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 &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 &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 &env, flatten_param_t& param) { switch (op) @@ -353,6 +813,13 @@ struct cff2_private_blend_encoder_param_t hb_vector_t scalars; const CFF2ItemVariationStore *varStore = nullptr; hb_array_t 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 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 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 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 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 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 normalized_coords_) + hb_array_t 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 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 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 env (str, acc, fd); + cs_interpreter_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 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 env (str, acc, fd); + cs_interpreter_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, 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 *axis_tags = nullptr; + unsigned min_charstrings_off_size = 0; hb_array_t normalized_coords; // For instantiation @@ -1138,7 +1808,8 @@ OT::cff2::accelerator_subset_t::serialize (hb_serialize_context_t *c, } auto *pd = c->push (); 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 (); - 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 (); + 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 (); diff --git a/src/hb-subset-input.cc b/src/hb-subset-input.cc index 12d3c36e3..8fc09bd9a 100644 --- a/src/hb-subset-input.cc +++ b/src/hb-subset-input.cc @@ -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 * diff --git a/src/hb-subset.h b/src/hb-subset.h index 49cd12763..a13349ac8 100644 --- a/src/hb-subset.h +++ b/src/hb-subset.h @@ -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. * diff --git a/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.41,42,43.CNTR=drop.otf b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.41,42,43.CNTR=drop.otf new file mode 100644 index 000000000..13f87196c Binary files /dev/null and b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.41,42,43.CNTR=drop.otf differ diff --git a/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.41,42,43.wght=300-500-700,CNTR=25-75.otf b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.41,42,43.wght=300-500-700,CNTR=25-75.otf new file mode 100644 index 000000000..d59b75d52 Binary files /dev/null and b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.41,42,43.wght=300-500-700,CNTR=25-75.otf differ diff --git a/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.41,42,43.wght=300-600.otf b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.41,42,43.wght=300-600.otf new file mode 100644 index 000000000..f1af6023e Binary files /dev/null and b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.41,42,43.wght=300-600.otf differ diff --git a/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.41,42,43.wght=500,CNTR=0-100.otf b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.41,42,43.wght=500,CNTR=0-100.otf new file mode 100644 index 000000000..d11a3cef6 Binary files /dev/null and b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.41,42,43.wght=500,CNTR=0-100.otf differ diff --git a/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.all.CNTR=drop.otf b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.all.CNTR=drop.otf new file mode 100644 index 000000000..389f12758 Binary files /dev/null and b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.all.CNTR=drop.otf differ diff --git a/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.all.wght=300-500-700,CNTR=25-75.otf b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.all.wght=300-500-700,CNTR=25-75.otf new file mode 100644 index 000000000..9d5412577 Binary files /dev/null and b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.all.wght=300-500-700,CNTR=25-75.otf differ diff --git a/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.all.wght=300-600.otf b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.all.wght=300-600.otf new file mode 100644 index 000000000..c7e9e2cbd Binary files /dev/null and b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.all.wght=300-600.otf differ diff --git a/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.all.wght=500,CNTR=0-100.otf b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.all.wght=500,CNTR=0-100.otf new file mode 100644 index 000000000..a68d19590 Binary files /dev/null and b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype.default.all.wght=500,CNTR=0-100.otf differ diff --git a/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.41,42,43.CNTR=drop.otf b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.41,42,43.CNTR=drop.otf new file mode 100644 index 000000000..4db7879bc Binary files /dev/null and b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.41,42,43.CNTR=drop.otf differ diff --git a/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.41,42,43.wght=300-500-700,CNTR=25-75.otf b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.41,42,43.wght=300-500-700,CNTR=25-75.otf new file mode 100644 index 000000000..b7b353ae1 Binary files /dev/null and b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.41,42,43.wght=300-500-700,CNTR=25-75.otf differ diff --git a/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.41,42,43.wght=300-600.otf b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.41,42,43.wght=300-600.otf new file mode 100644 index 000000000..4e7f4d1b9 Binary files /dev/null and b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.41,42,43.wght=300-600.otf differ diff --git a/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.41,42,43.wght=500,CNTR=0-100.otf b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.41,42,43.wght=500,CNTR=0-100.otf new file mode 100644 index 000000000..8bf3f51ba Binary files /dev/null and b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.41,42,43.wght=500,CNTR=0-100.otf differ diff --git a/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.all.CNTR=drop.otf b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.all.CNTR=drop.otf new file mode 100644 index 000000000..4db7879bc Binary files /dev/null and b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.all.CNTR=drop.otf differ diff --git a/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.all.wght=300-500-700,CNTR=25-75.otf b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.all.wght=300-500-700,CNTR=25-75.otf new file mode 100644 index 000000000..b7b353ae1 Binary files /dev/null and b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.all.wght=300-500-700,CNTR=25-75.otf differ diff --git a/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.all.wght=300-600.otf b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.all.wght=300-600.otf new file mode 100644 index 000000000..4e7f4d1b9 Binary files /dev/null and b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.all.wght=300-600.otf differ diff --git a/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.all.wght=500,CNTR=0-100.otf b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.all.wght=500,CNTR=0-100.otf new file mode 100644 index 000000000..8bf3f51ba Binary files /dev/null and b/test/subset/data/expected/instantiate_cff2_partial/AdobeVFPrototype_vsindex.default.all.wght=500,CNTR=0-100.otf differ diff --git a/test/subset/data/fonts/AdobeVFPrototype_vsindex.otf b/test/subset/data/fonts/AdobeVFPrototype_vsindex.otf new file mode 100644 index 000000000..3697b46c1 Binary files /dev/null and b/test/subset/data/fonts/AdobeVFPrototype_vsindex.otf differ diff --git a/test/subset/data/tests/instantiate_cff2_partial.tests b/test/subset/data/tests/instantiate_cff2_partial.tests new file mode 100644 index 000000000..6acfde791 --- /dev/null +++ b/test/subset/data/tests/instantiate_cff2_partial.tests @@ -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 diff --git a/test/subset/meson.build b/test/subset/meson.build index 870601830..82fc425a8 100644 --- a/test/subset/meson.build +++ b/test/subset/meson.build @@ -62,6 +62,7 @@ tests = [ 'instantiate_colrv1', 'instantiate_glyf', 'instantiate_cff2', + 'instantiate_cff2_partial', 'downgrade_cff2', 'instantiate_cff2_tsb', 'full_instance',