| /* |
| * Copyright © 2023 Google, Inc. |
| * |
| * This is part of HarfBuzz, a text shaping library. |
| * |
| * Permission is hereby granted, without written agreement and without |
| * license or royalty fees, to use, copy, modify, and distribute this |
| * software and its documentation for any purpose, provided that the |
| * above copyright notice and the following two paragraphs appear in |
| * all copies of this software. |
| * |
| * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR |
| * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES |
| * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN |
| * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH |
| * DAMAGE. |
| * |
| * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, |
| * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND |
| * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS |
| * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO |
| * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. |
| * |
| * Google Author(s): Garret Rieger, Qunxin Liu, Roderick Sheeter |
| */ |
| |
| #include "hb-ot-layout-common.hh" |
| #include "hb-subset-plan.hh" |
| |
| #include "hb-ot-var-common.hh" |
| #include "hb-ot-layout-base-table.hh" |
| #include "hb-ot-glyf-table.hh" |
| #include "hb-ot-var-fvar-table.hh" |
| #include "hb-ot-var-avar-table.hh" |
| #include "hb-ot-cff2-table.hh" |
| |
| #ifndef HB_NO_VAR |
| |
| void |
| generate_varstore_inner_maps (const hb_set_t& varidx_set, |
| unsigned subtable_count, |
| hb_vector_t<hb_inc_bimap_t> &inner_maps /* OUT */) |
| { |
| if (varidx_set.is_empty () || subtable_count == 0) return; |
| |
| if (unlikely (!inner_maps.resize (subtable_count))) return; |
| for (unsigned idx : varidx_set) |
| { |
| uint16_t major = idx >> 16; |
| uint16_t minor = idx & 0xFFFF; |
| |
| if (major >= subtable_count) |
| continue; |
| inner_maps[major].add (minor); |
| } |
| } |
| |
| static inline hb_font_t* |
| _get_hb_font_with_variations (const hb_subset_plan_t *plan) |
| { |
| hb_font_t *font = hb_font_create (plan->source); |
| |
| hb_vector_t<hb_variation_t> vars; |
| if (!vars.alloc (plan->user_axes_location.get_population ())) { |
| hb_font_destroy (font); |
| return nullptr; |
| } |
| |
| for (auto _ : plan->user_axes_location) |
| { |
| hb_variation_t var; |
| var.tag = _.first; |
| var.value = _.second.middle; |
| vars.push (var); |
| } |
| |
| hb_font_set_variations (font, vars.arrayZ, plan->user_axes_location.get_population ()); |
| return font; |
| } |
| |
| template<typename ItemVarStore> |
| void |
| remap_variation_indices (const ItemVarStore &var_store, |
| const hb_set_t &variation_indices, |
| const hb_vector_t<int>& normalized_coords, |
| bool calculate_delta, /* not pinned at default */ |
| bool no_variations, /* all axes pinned */ |
| hb_hashmap_t<unsigned, hb_pair_t<unsigned, int>> &variation_idx_delta_map /* OUT */) |
| { |
| if (&var_store == &Null (OT::ItemVariationStore)) return; |
| unsigned subtable_count = var_store.get_sub_table_count (); |
| auto *store_cache = var_store.create_cache (); |
| |
| unsigned new_major = 0, new_minor = 0; |
| unsigned last_major = (variation_indices.get_min ()) >> 16; |
| for (unsigned idx : variation_indices) |
| { |
| int delta = 0; |
| if (calculate_delta) |
| delta = roundf (var_store.get_delta (idx, normalized_coords.arrayZ, |
| normalized_coords.length, store_cache)); |
| |
| if (no_variations) |
| { |
| variation_idx_delta_map.set (idx, hb_pair_t<unsigned, int> (HB_OT_LAYOUT_NO_VARIATIONS_INDEX, delta)); |
| continue; |
| } |
| |
| uint16_t major = idx >> 16; |
| if (major >= subtable_count) break; |
| if (major != last_major) |
| { |
| new_minor = 0; |
| ++new_major; |
| } |
| |
| unsigned new_idx = (new_major << 16) + new_minor; |
| variation_idx_delta_map.set (idx, hb_pair_t<unsigned, int> (new_idx, delta)); |
| ++new_minor; |
| last_major = major; |
| } |
| var_store.destroy_cache (store_cache); |
| } |
| |
| template |
| void |
| remap_variation_indices<OT::ItemVariationStore> (const OT::ItemVariationStore &var_store, |
| const hb_set_t &variation_indices, |
| const hb_vector_t<int>& normalized_coords, |
| bool calculate_delta, /* not pinned at default */ |
| bool no_variations, /* all axes pinned */ |
| hb_hashmap_t<unsigned, hb_pair_t<unsigned, int>> &variation_idx_delta_map /* OUT */); |
| |
| #ifndef HB_NO_BASE |
| void |
| collect_base_variation_indices (hb_subset_plan_t* plan) |
| { |
| hb_blob_ptr_t<OT::BASE> base = plan->source_table<OT::BASE> (); |
| if (!base->has_var_store ()) |
| { |
| base.destroy (); |
| return; |
| } |
| |
| hb_set_t varidx_set; |
| base->collect_variation_indices (plan, varidx_set); |
| const OT::ItemVariationStore &var_store = base->get_var_store (); |
| unsigned subtable_count = var_store.get_sub_table_count (); |
| |
| |
| remap_variation_indices (var_store, varidx_set, |
| plan->normalized_coords, |
| !plan->pinned_at_default, |
| plan->all_axes_pinned, |
| plan->base_variation_idx_map); |
| generate_varstore_inner_maps (varidx_set, subtable_count, plan->base_varstore_inner_maps); |
| |
| base.destroy (); |
| } |
| |
| #endif |
| |
| bool |
| normalize_axes_location (hb_face_t *face, hb_subset_plan_t *plan) |
| { |
| if (plan->user_axes_location.is_empty ()) |
| return true; |
| |
| hb_array_t<const OT::AxisRecord> axes = face->table.fvar->get_axes (); |
| if (!plan->check_success (plan->normalized_coords.resize (axes.length))) |
| return false; |
| |
| bool has_avar = face->table.avar->has_data (); |
| hb_vector_t<float> normalized_mins; |
| hb_vector_t<float> normalized_defaults; |
| hb_vector_t<float> normalized_maxs; |
| if (has_avar) |
| { |
| if (!plan->check_success (normalized_mins.resize (axes.length)) || |
| !plan->check_success (normalized_defaults.resize (axes.length)) || |
| !plan->check_success (normalized_maxs.resize (axes.length))) |
| return false; |
| } |
| |
| bool axis_not_pinned = false; |
| unsigned new_axis_idx = 0; |
| unsigned last_idx = 0; |
| for (const auto& _ : + hb_enumerate (axes)) |
| { |
| unsigned i = _.first; |
| const OT::AxisRecord &axis = _.second; |
| hb_tag_t axis_tag = axis.get_axis_tag (); |
| plan->axes_old_index_tag_map.set (i, axis_tag); |
| |
| if (!plan->user_axes_location.has (axis_tag) || |
| !plan->user_axes_location.get (axis_tag).is_point ()) |
| { |
| axis_not_pinned = true; |
| plan->axes_index_map.set (i, new_axis_idx); |
| plan->axis_tags.push (axis_tag); |
| new_axis_idx++; |
| } |
| |
| Triple *axis_range; |
| if (plan->user_axes_location.has (axis_tag, &axis_range)) |
| { |
| plan->axes_triple_distances.set (axis_tag, axis.get_triple_distances ()); |
| |
| float normalized_min = axis.normalize_axis_value (axis_range->minimum); |
| float normalized_default = axis.normalize_axis_value (axis_range->middle); |
| float normalized_max = axis.normalize_axis_value (axis_range->maximum); |
| |
| // TODO(behdad): Spec says axis normalization should be done in 16.16; |
| // We used to do it in 2.14, but that's not correct. I fixed this in |
| // the fvar/avar code, but keeping 2.14 here for now to keep tests |
| // happy. We might need to adjust fonttools as well. |
| // I'm only fairly confident in the above statement. Anyway, |
| // we should look deeper into this, and also update fonttools if |
| // needed. |
| |
| // Round to 2.14 |
| normalized_min = roundf (normalized_min * 16384.f) / 16384.f; |
| normalized_default = roundf (normalized_default * 16384.f) / 16384.f; |
| normalized_max = roundf (normalized_max * 16384.f) / 16384.f; |
| |
| if (has_avar) |
| { |
| normalized_mins[i] = normalized_min; |
| normalized_defaults[i] = normalized_default; |
| normalized_maxs[i] = normalized_max; |
| last_idx = i; |
| } |
| else |
| { |
| plan->axes_location.set (axis_tag, Triple ((double) normalized_min, |
| (double) normalized_default, |
| (double) normalized_max)); |
| if (normalized_default == -0.f) |
| normalized_default = 0.f; // Normalize -0 to 0 |
| if (normalized_default != 0.f) |
| plan->pinned_at_default = false; |
| |
| plan->normalized_coords[i] = roundf (normalized_default * 16384.f); |
| } |
| } |
| } |
| plan->all_axes_pinned = !axis_not_pinned; |
| |
| // TODO: use avar map_coords_16_16() when normalization is changed to 16.16 |
| // in fonttools |
| if (has_avar) |
| { |
| const OT::avar* avar_table = face->table.avar; |
| if (avar_table->has_v2_data () && !plan->all_axes_pinned) |
| { |
| DEBUG_MSG (SUBSET, nullptr, "Partial-instancing avar2 table is not supported."); |
| return false; |
| } |
| |
| unsigned coords_len = last_idx + 1; |
| if (!plan->check_success (avar_table->map_coords_2_14 (normalized_mins.arrayZ, coords_len)) || |
| !plan->check_success (avar_table->map_coords_2_14 (normalized_defaults.arrayZ, coords_len)) || |
| !plan->check_success (avar_table->map_coords_2_14 (normalized_maxs.arrayZ, coords_len))) |
| return false; |
| |
| for (const auto& _ : + hb_enumerate (axes)) |
| { |
| unsigned i = _.first; |
| hb_tag_t axis_tag = _.second.get_axis_tag (); |
| if (plan->user_axes_location.has (axis_tag)) |
| { |
| plan->axes_location.set (axis_tag, Triple ((double) normalized_mins[i], |
| (double) normalized_defaults[i], |
| (double) normalized_maxs[i])); |
| float normalized_default = normalized_defaults[i]; |
| if (normalized_default == -0.f) |
| normalized_default = 0.f; // Normalize -0 to 0 |
| if (normalized_default != 0.f) |
| plan->pinned_at_default = false; |
| |
| plan->normalized_coords[i] = roundf (normalized_default * 16384.f); |
| } |
| } |
| } |
| return true; |
| } |
| |
| void |
| update_instance_metrics_map_from_cff2 (hb_subset_plan_t *plan) |
| { |
| if (!plan->normalized_coords) return; |
| OT::cff2::accelerator_t cff2 (plan->source); |
| if (!cff2.is_valid ()) return; |
| |
| hb_font_t *font = _get_hb_font_with_variations (plan); |
| if (unlikely (!plan->check_success (font != nullptr))) |
| { |
| hb_font_destroy (font); |
| return; |
| } |
| |
| hb_glyph_extents_t extents = {0x7FFF, -0x7FFF}; |
| OT::hmtx_accelerator_t _hmtx (plan->source); |
| OT::hb_scalar_cache_t *hvar_store_cache = nullptr; |
| if (_hmtx.has_data () && _hmtx.var_table.get_length ()) |
| hvar_store_cache = _hmtx.var_table->get_var_store ().create_cache (); |
| |
| OT::vmtx_accelerator_t _vmtx (plan->source); |
| OT::hb_scalar_cache_t *vvar_store_cache = nullptr; |
| if (_vmtx.has_data () && _vmtx.var_table.get_length ()) |
| vvar_store_cache = _vmtx.var_table->get_var_store ().create_cache (); |
| |
| for (auto p : *plan->glyph_map) |
| { |
| hb_codepoint_t old_gid = p.first; |
| hb_codepoint_t new_gid = p.second; |
| if (!cff2.get_extents (font, old_gid, &extents)) continue; |
| bool has_bounds_info = true; |
| if (extents.x_bearing == 0 && extents.width == 0 && |
| extents.height == 0 && extents.y_bearing == 0) |
| has_bounds_info = false; |
| |
| if (has_bounds_info) |
| { |
| plan->head_maxp_info.xMin = hb_min (plan->head_maxp_info.xMin, extents.x_bearing); |
| plan->head_maxp_info.xMax = hb_max (plan->head_maxp_info.xMax, extents.x_bearing + extents.width); |
| plan->head_maxp_info.yMax = hb_max (plan->head_maxp_info.yMax, extents.y_bearing); |
| plan->head_maxp_info.yMin = hb_min (plan->head_maxp_info.yMin, extents.y_bearing + extents.height); |
| } |
| |
| if (_hmtx.has_data ()) |
| { |
| int hori_aw = _hmtx.get_advance_without_var_unscaled (old_gid); |
| if (_hmtx.var_table.get_length ()) |
| hori_aw += (int) roundf (_hmtx.var_table->get_advance_delta_unscaled (old_gid, font->coords, font->num_coords, |
| hvar_store_cache)); |
| int lsb = extents.x_bearing; |
| if (!has_bounds_info) |
| { |
| _hmtx.get_leading_bearing_without_var_unscaled (old_gid, &lsb); |
| } |
| plan->hmtx_map.set (new_gid, hb_pair ((unsigned) hori_aw, lsb)); |
| plan->bounds_width_vec[new_gid] = extents.width; |
| } |
| |
| if (_vmtx.has_data ()) |
| { |
| int vert_aw = _vmtx.get_advance_without_var_unscaled (old_gid); |
| if (_vmtx.var_table.get_length ()) |
| vert_aw += (int) roundf (_vmtx.var_table->get_advance_delta_unscaled (old_gid, font->coords, font->num_coords, |
| vvar_store_cache)); |
| hb_position_t vorg_x = 0; |
| hb_position_t vorg_y = 0; |
| int tsb = 0; |
| if (has_bounds_info && |
| hb_font_get_glyph_v_origin (font, old_gid, &vorg_x, &vorg_y)) |
| { |
| tsb = vorg_y - extents.y_bearing; |
| } else { |
| _vmtx.get_leading_bearing_without_var_unscaled (old_gid, &tsb); |
| } |
| |
| plan->vmtx_map.set (new_gid, hb_pair ((unsigned) vert_aw, tsb)); |
| plan->bounds_height_vec[new_gid] = extents.height; |
| } |
| } |
| hb_font_destroy (font); |
| if (hvar_store_cache) |
| _hmtx.var_table->get_var_store ().destroy_cache (hvar_store_cache); |
| if (vvar_store_cache) |
| _vmtx.var_table->get_var_store ().destroy_cache (vvar_store_cache); |
| } |
| |
| bool |
| get_instance_glyphs_contour_points (hb_subset_plan_t *plan) |
| { |
| /* contour_points vector only needed for updating gvar table (infer delta and |
| * iup delta optimization) during partial instancing */ |
| if (plan->user_axes_location.is_empty () || plan->all_axes_pinned) |
| return true; |
| |
| OT::glyf_accelerator_t glyf (plan->source); |
| |
| for (auto &_ : plan->new_to_old_gid_list) |
| { |
| hb_codepoint_t new_gid = _.first; |
| contour_point_vector_t all_points; |
| if (new_gid == 0 && !(plan->flags & HB_SUBSET_FLAGS_NOTDEF_OUTLINE)) |
| { |
| if (unlikely (!plan->new_gid_contour_points_map.set (new_gid, all_points))) |
| return false; |
| continue; |
| } |
| |
| hb_codepoint_t old_gid = _.second; |
| auto glyph = glyf.glyph_for_gid (old_gid); |
| if (unlikely (!glyph.get_all_points_without_var (plan->source, all_points))) |
| return false; |
| if (unlikely (!plan->new_gid_contour_points_map.set (new_gid, all_points))) |
| return false; |
| |
| /* composite new gids are only needed by iup delta optimization */ |
| if ((plan->flags & HB_SUBSET_FLAGS_OPTIMIZE_IUP_DELTAS) && glyph.is_composite ()) |
| plan->composite_new_gids.add (new_gid); |
| } |
| return true; |
| } |
| |
| template<typename DeltaSetIndexMap> |
| void |
| remap_colrv1_delta_set_index_indices (const DeltaSetIndexMap &index_map, |
| const hb_set_t &delta_set_idxes, |
| hb_hashmap_t<unsigned, hb_pair_t<unsigned, int>> &variation_idx_delta_map, /* IN/OUT */ |
| hb_map_t &new_deltaset_idx_varidx_map /* OUT */) |
| { |
| if (!index_map.get_map_count ()) |
| return; |
| |
| hb_hashmap_t<unsigned, hb_pair_t<unsigned, int>> delta_set_idx_delta_map; |
| unsigned new_delta_set_idx = 0; |
| for (unsigned delta_set_idx : delta_set_idxes) |
| { |
| unsigned var_idx = index_map.map (delta_set_idx); |
| unsigned new_varidx = HB_OT_LAYOUT_NO_VARIATIONS_INDEX; |
| int delta = 0; |
| |
| if (var_idx != HB_OT_LAYOUT_NO_VARIATIONS_INDEX) |
| { |
| hb_pair_t<unsigned, int> *new_varidx_delta; |
| if (!variation_idx_delta_map.has (var_idx, &new_varidx_delta)) continue; |
| |
| new_varidx = hb_first (*new_varidx_delta); |
| delta = hb_second (*new_varidx_delta); |
| } |
| |
| new_deltaset_idx_varidx_map.set (new_delta_set_idx, new_varidx); |
| delta_set_idx_delta_map.set (delta_set_idx, hb_pair_t<unsigned, int> (new_delta_set_idx, delta)); |
| new_delta_set_idx++; |
| } |
| variation_idx_delta_map = std::move (delta_set_idx_delta_map); |
| } |
| |
| template void |
| remap_colrv1_delta_set_index_indices<OT::DeltaSetIndexMap> (const OT::DeltaSetIndexMap &index_map, |
| const hb_set_t &delta_set_idxes, |
| hb_hashmap_t<unsigned, hb_pair_t<unsigned, int>> &variation_idx_delta_map, /* IN/OUT */ |
| hb_map_t &new_deltaset_idx_varidx_map /* OUT */); |
| |
| #endif |
