mirror of
https://github.com/storytold/harfbuzz.git
synced 2026-11-22 07:21:06 +01:00
Merge branch 'main' into HVF
This commit is contained in:
commit
0855d33ae4
13 files changed
+1003
-70
No files matched your search
@@ -18,7 +18,7 @@ variations=
|
||||
face_loader=ot
|
||||
shaper=ot
|
||||
font_funcs1=ot
|
||||
font_funcs2=coretext
|
||||
font_funcs2=fontations
|
||||
clear1=false
|
||||
clear2=false
|
||||
unicodes=
|
||||
|
||||
@@ -94,7 +94,8 @@ struct AnchorFormat3
|
||||
/* in case that all axes are pinned or no variations after instantiation,
|
||||
* both var_idxes will be mapped to HB_OT_LAYOUT_NO_VARIATIONS_INDEX */
|
||||
if (x_varidx == HB_OT_LAYOUT_NO_VARIATIONS_INDEX &&
|
||||
y_varidx == HB_OT_LAYOUT_NO_VARIATIONS_INDEX)
|
||||
y_varidx == HB_OT_LAYOUT_NO_VARIATIONS_INDEX &&
|
||||
c->plan->normalized_coords)
|
||||
return_trace (c->serializer->check_assign (out->format, 1, HB_SERIALIZE_ERROR_INT_OVERFLOW));
|
||||
|
||||
if (!c->serializer->embed (xDeviceTable)) return_trace (false);
|
||||
|
||||
@@ -11,11 +11,11 @@ namespace GSUB_impl {
|
||||
template <typename Types>
|
||||
struct LigatureSet
|
||||
{
|
||||
protected:
|
||||
public:
|
||||
Array16OfOffset16To<Ligature<Types>>
|
||||
ligature; /* Array LigatureSet tables
|
||||
* ordered by preference */
|
||||
public:
|
||||
|
||||
DEFINE_SIZE_ARRAY (2, ligature);
|
||||
|
||||
bool sanitize (hb_sanitize_context_t *c) const
|
||||
|
||||
@@ -74,7 +74,7 @@ struct ClassDef : public OT::ClassDef
|
||||
class_def_link->width = SmallTypes::size;
|
||||
class_def_link->objidx = class_def_prime_id;
|
||||
class_def_link->position = link_position;
|
||||
class_def_prime_vertex.add_parent (parent_id);
|
||||
class_def_prime_vertex.add_parent (parent_id, false);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -98,11 +98,33 @@ struct Coverage : public OT::Layout::Common::Coverage
|
||||
coverage_link->width = SmallTypes::size;
|
||||
coverage_link->objidx = coverage_prime_id;
|
||||
coverage_link->position = link_position;
|
||||
coverage_prime_vertex.add_parent (parent_id);
|
||||
coverage_prime_vertex.add_parent (parent_id, false);
|
||||
|
||||
return (Coverage*) coverage_prime_vertex.obj.head;
|
||||
}
|
||||
|
||||
// Filter an existing coverage table to glyphs at indices [start, end) and replace it with the filtered version.
|
||||
static bool filter_coverage (gsubgpos_graph_context_t& c,
|
||||
unsigned existing_coverage,
|
||||
unsigned start, unsigned end) {
|
||||
unsigned coverage_size = c.graph.vertices_[existing_coverage].table_size ();
|
||||
auto& coverage_v = c.graph.vertices_[existing_coverage];
|
||||
Coverage* coverage_table = (Coverage*) coverage_v.obj.head;
|
||||
if (!coverage_table || !coverage_table->sanitize (coverage_v))
|
||||
return false;
|
||||
|
||||
auto new_coverage =
|
||||
+ hb_zip (coverage_table->iter (), hb_range ())
|
||||
| hb_filter ([&] (hb_pair_t<unsigned, unsigned> p) {
|
||||
return p.second >= start && p.second < end;
|
||||
})
|
||||
| hb_map_retains_sorting (hb_first)
|
||||
;
|
||||
|
||||
return make_coverage (c, new_coverage, existing_coverage, coverage_size * 2 + 100);
|
||||
}
|
||||
|
||||
// Replace the coverage table at dest obj with one covering 'glyphs'.
|
||||
template<typename It>
|
||||
static bool make_coverage (gsubgpos_graph_context_t& c,
|
||||
It glyphs,
|
||||
|
||||
+64
-19
@@ -50,6 +50,7 @@ struct graph_t
|
||||
private:
|
||||
unsigned incoming_edges_ = 0;
|
||||
unsigned single_parent = (unsigned) -1;
|
||||
bool has_incoming_virtual_edges_ = false;
|
||||
hb_hashmap_t<unsigned, unsigned> parents;
|
||||
public:
|
||||
|
||||
@@ -66,6 +67,11 @@ struct graph_t
|
||||
return parents.in_error ();
|
||||
}
|
||||
|
||||
bool has_incoming_virtual_edges () const
|
||||
{
|
||||
return has_incoming_virtual_edges_;
|
||||
}
|
||||
|
||||
bool link_positions_valid (unsigned num_objects, bool removed_nil)
|
||||
{
|
||||
hb_set_t assigned_bytes;
|
||||
@@ -121,7 +127,9 @@ struct graph_t
|
||||
}
|
||||
}
|
||||
|
||||
bool equals (const vertex_t& other,
|
||||
bool equals (unsigned this_index,
|
||||
unsigned other_index,
|
||||
const vertex_t& other,
|
||||
const graph_t& graph,
|
||||
const graph_t& other_graph,
|
||||
unsigned depth) const
|
||||
@@ -129,8 +137,10 @@ struct graph_t
|
||||
if (!(as_bytes () == other.as_bytes ()))
|
||||
{
|
||||
DEBUG_MSG (SUBSET_REPACK, nullptr,
|
||||
"vertex [%lu] bytes != [%lu] bytes, depth = %u",
|
||||
"vertex %u [%lu bytes] != %u [%lu bytes], depth = %u",
|
||||
this_index,
|
||||
(unsigned long) table_size (),
|
||||
other_index,
|
||||
(unsigned long) other.table_size (),
|
||||
depth);
|
||||
|
||||
@@ -162,6 +172,7 @@ struct graph_t
|
||||
hb_swap (a.single_parent, b.single_parent);
|
||||
hb_swap (a.parents, b.parents);
|
||||
hb_swap (a.incoming_edges_, b.incoming_edges_);
|
||||
hb_swap (a.has_incoming_virtual_edges_, b.has_incoming_virtual_edges_);
|
||||
hb_swap (a.start, b.start);
|
||||
hb_swap (a.end, b.end);
|
||||
hb_swap (a.priority, b.priority);
|
||||
@@ -207,13 +218,16 @@ struct graph_t
|
||||
void reset_parents ()
|
||||
{
|
||||
incoming_edges_ = 0;
|
||||
has_incoming_virtual_edges_ = false;
|
||||
single_parent = (unsigned) -1;
|
||||
parents.reset ();
|
||||
}
|
||||
|
||||
void add_parent (unsigned parent_index)
|
||||
void add_parent (unsigned parent_index, bool is_virtual)
|
||||
{
|
||||
assert (parent_index != (unsigned) -1);
|
||||
has_incoming_virtual_edges_ |= is_virtual;
|
||||
|
||||
if (incoming_edges_ == 0)
|
||||
{
|
||||
single_parent = parent_index;
|
||||
@@ -408,7 +422,7 @@ struct graph_t
|
||||
link_a.bias != link_b.bias)
|
||||
return false;
|
||||
|
||||
if (!graph.vertices_[link_a.objidx].equals (
|
||||
if (!graph.vertices_[link_a.objidx].equals (link_a.objidx, link_b.objidx,
|
||||
other_graph.vertices_[link_b.objidx], graph, other_graph, depth + 1))
|
||||
return false;
|
||||
|
||||
@@ -490,7 +504,7 @@ struct graph_t
|
||||
|
||||
bool operator== (const graph_t& other) const
|
||||
{
|
||||
return root ().equals (other.root (), *this, other, 0);
|
||||
return root ().equals (root_idx(), other.root_idx(), other.root (), *this, other, 0);
|
||||
}
|
||||
|
||||
void print () const {
|
||||
@@ -501,6 +515,9 @@ struct graph_t
|
||||
for (const auto &l : v.obj.real_links) {
|
||||
printf("%u, ", l.objidx);
|
||||
}
|
||||
for (const auto &l : v.obj.virtual_links) {
|
||||
printf("v%u, ", l.objidx);
|
||||
}
|
||||
printf("]\n");
|
||||
}
|
||||
}
|
||||
@@ -556,7 +573,7 @@ struct graph_t
|
||||
link->width = 2;
|
||||
link->objidx = child_id;
|
||||
link->position = (char*) offset - (char*) v.obj.head;
|
||||
vertices_[child_id].add_parent (parent_id);
|
||||
vertices_[child_id].add_parent (parent_id, false);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -943,9 +960,11 @@ struct graph_t
|
||||
/*
|
||||
* Moves the child of old_parent_idx pointed to by old_offset to a new
|
||||
* vertex at the new_offset.
|
||||
*
|
||||
* Returns the id of the child node that was moved.
|
||||
*/
|
||||
template<typename O>
|
||||
void move_child (unsigned old_parent_idx,
|
||||
unsigned move_child (unsigned old_parent_idx,
|
||||
const O* old_offset,
|
||||
unsigned new_parent_idx,
|
||||
const O* new_offset)
|
||||
@@ -965,10 +984,12 @@ struct graph_t
|
||||
new_link->position = (const char*) new_offset - (const char*) new_v.obj.head;
|
||||
|
||||
auto& child = vertices_[child_id];
|
||||
child.add_parent (new_parent_idx);
|
||||
child.add_parent (new_parent_idx, false);
|
||||
|
||||
old_v.remove_real_link (child_id, old_offset);
|
||||
child.remove_parent (old_parent_idx);
|
||||
|
||||
return child_id;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -1015,12 +1036,12 @@ struct graph_t
|
||||
for (const auto& l : child.obj.real_links)
|
||||
{
|
||||
clone->obj.real_links.push (l);
|
||||
vertices_[l.objidx].add_parent (clone_idx);
|
||||
vertices_[l.objidx].add_parent (clone_idx, false);
|
||||
}
|
||||
for (const auto& l : child.obj.virtual_links)
|
||||
{
|
||||
clone->obj.virtual_links.push (l);
|
||||
vertices_[l.objidx].add_parent (clone_idx);
|
||||
vertices_[l.objidx].add_parent (clone_idx, true);
|
||||
}
|
||||
|
||||
check_success (!clone->obj.real_links.in_error ());
|
||||
@@ -1073,10 +1094,15 @@ struct graph_t
|
||||
const auto& child = vertices_[child_idx];
|
||||
unsigned links_to_child = child.incoming_edges_from_parent(parent_idx);
|
||||
|
||||
if (child.incoming_edges () <= links_to_child)
|
||||
if (child.incoming_edges () <= links_to_child || child.has_incoming_virtual_edges())
|
||||
{
|
||||
// Can't duplicate this node, doing so would orphan the original one as all remaining links
|
||||
// to child are from parent.
|
||||
//
|
||||
// We don't allow duplication of nodes with incoming virtual edges because we don't track
|
||||
// the number of virtual vs real incoming edges. As a result we can't tell if a node
|
||||
// with virtual edges may end up orphaned by duplication (ie. where one copy is only pointed
|
||||
// to by virtual edges).
|
||||
DEBUG_MSG (SUBSET_REPACK, nullptr, " Not duplicating %u => %u",
|
||||
parent_idx, child_idx);
|
||||
return -1;
|
||||
@@ -1091,12 +1117,15 @@ struct graph_t
|
||||
if (parent_idx == clone_idx) parent_idx++;
|
||||
|
||||
auto& parent = vertices_[parent_idx];
|
||||
unsigned count = 0;
|
||||
unsigned num_real = parent.obj.real_links.length;
|
||||
for (auto& l : parent.obj.all_links_writer ())
|
||||
{
|
||||
count++;
|
||||
if (l.objidx != child_idx)
|
||||
continue;
|
||||
|
||||
reassign_link (l, parent_idx, clone_idx);
|
||||
reassign_link (l, parent_idx, clone_idx, count > num_real);
|
||||
}
|
||||
|
||||
return clone_idx;
|
||||
@@ -1129,10 +1158,15 @@ struct graph_t
|
||||
links_to_child += child.incoming_edges_from_parent(parent_idx);
|
||||
}
|
||||
|
||||
if (child.incoming_edges () <= links_to_child)
|
||||
if (child.incoming_edges () <= links_to_child || child.has_incoming_virtual_edges())
|
||||
{
|
||||
// Can't duplicate this node, doing so would orphan the original one as all remaining links
|
||||
// to child are from parent.
|
||||
//
|
||||
// We don't allow duplication of nodes with incoming virtual edges because we don't track
|
||||
// the number of virtual vs real incoming edges. As a result we can't tell if a node
|
||||
// with virtual edges may end up orphaned by duplication (ie. where one copy is only pointed
|
||||
// to by virtual edges).
|
||||
DEBUG_MSG (SUBSET_REPACK, nullptr, " Not duplicating %u, ..., %u => %u", first_parent, last_parent, child_idx);
|
||||
return -1;
|
||||
}
|
||||
@@ -1146,12 +1180,15 @@ struct graph_t
|
||||
// duplicate shifts the root node idx, so if parent_idx was root update it.
|
||||
if (parent_idx == clone_idx) parent_idx++;
|
||||
auto& parent = vertices_[parent_idx];
|
||||
unsigned count = 0;
|
||||
unsigned num_real = parent.obj.real_links.length;
|
||||
for (auto& l : parent.obj.all_links_writer ())
|
||||
{
|
||||
count++;
|
||||
if (l.objidx != child_idx)
|
||||
continue;
|
||||
|
||||
reassign_link (l, parent_idx, clone_idx);
|
||||
reassign_link (l, parent_idx, clone_idx, count > num_real);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1279,6 +1316,7 @@ struct graph_t
|
||||
if (!DEBUG_ENABLED(SUBSET_REPACK)) return;
|
||||
|
||||
DEBUG_MSG (SUBSET_REPACK, nullptr, "Graph is not fully connected.");
|
||||
|
||||
parents_invalid = true;
|
||||
update_parents();
|
||||
|
||||
@@ -1398,8 +1436,11 @@ struct graph_t
|
||||
|
||||
for (unsigned p = 0; p < count; p++)
|
||||
{
|
||||
for (auto& l : vertices_.arrayZ[p].obj.all_links ())
|
||||
vertices_[l.objidx].add_parent (p);
|
||||
for (auto& l : vertices_.arrayZ[p].obj.real_links)
|
||||
vertices_[l.objidx].add_parent (p, false);
|
||||
|
||||
for (auto& l : vertices_.arrayZ[p].obj.virtual_links)
|
||||
vertices_[l.objidx].add_parent (p, true);
|
||||
}
|
||||
|
||||
for (unsigned i = 0; i < count; i++)
|
||||
@@ -1502,12 +1543,13 @@ struct graph_t
|
||||
*/
|
||||
void reassign_link (hb_serialize_context_t::object_t::link_t& link,
|
||||
unsigned parent_idx,
|
||||
unsigned new_idx)
|
||||
unsigned new_idx,
|
||||
bool is_virtual)
|
||||
{
|
||||
unsigned old_idx = link.objidx;
|
||||
link.objidx = new_idx;
|
||||
vertices_[old_idx].remove_parent (parent_idx);
|
||||
vertices_[new_idx].add_parent (parent_idx);
|
||||
vertices_[new_idx].add_parent (parent_idx, is_virtual);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -1521,13 +1563,16 @@ struct graph_t
|
||||
if (!id_map) return;
|
||||
for (unsigned i : subgraph)
|
||||
{
|
||||
unsigned num_real = vertices_[i].obj.real_links.length;
|
||||
unsigned count = 0;
|
||||
for (auto& link : vertices_[i].obj.all_links_writer ())
|
||||
{
|
||||
count++;
|
||||
const uint32_t *v;
|
||||
if (!id_map.has (link.objidx, &v)) continue;
|
||||
if (only_wide && !(link.width == 4 && !link.is_signed)) continue;
|
||||
|
||||
reassign_link (link, i, *v);
|
||||
reassign_link (link, i, *v, count > num_real);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+50
-24
@@ -27,9 +27,11 @@
|
||||
#include "graph.hh"
|
||||
#include "../hb-ot-layout-gsubgpos.hh"
|
||||
#include "../OT/Layout/GSUB/ExtensionSubst.hh"
|
||||
#include "../OT/Layout/GSUB/SubstLookupSubTable.hh"
|
||||
#include "gsubgpos-context.hh"
|
||||
#include "pairpos-graph.hh"
|
||||
#include "markbasepos-graph.hh"
|
||||
#include "ligature-graph.hh"
|
||||
|
||||
#ifndef GRAPH_GSUBGPOS_GRAPH_HH
|
||||
#define GRAPH_GSUBGPOS_GRAPH_HH
|
||||
@@ -120,12 +122,10 @@ struct Lookup : public OT::Lookup
|
||||
unsigned type = lookupType;
|
||||
bool is_ext = is_extension (c.table_tag);
|
||||
|
||||
if (c.table_tag != HB_OT_TAG_GPOS)
|
||||
if (c.table_tag != HB_OT_TAG_GPOS && c.table_tag != HB_OT_TAG_GSUB)
|
||||
return true;
|
||||
|
||||
if (!is_ext &&
|
||||
type != OT::Layout::GPOS_impl::PosLookupSubTable::Type::Pair &&
|
||||
type != OT::Layout::GPOS_impl::PosLookupSubTable::Type::MarkBase)
|
||||
if (!is_ext && !is_supported_gpos_type(type, c) && !is_supported_gsub_type(type, c))
|
||||
return true;
|
||||
|
||||
hb_vector_t<hb_pair_t<unsigned, hb_vector_t<unsigned>>> all_new_subtables;
|
||||
@@ -144,21 +144,32 @@ struct Lookup : public OT::Lookup
|
||||
|
||||
subtable_index = extension->get_subtable_index (c.graph, ext_subtable_index);
|
||||
type = extension->get_lookup_type ();
|
||||
if (type != OT::Layout::GPOS_impl::PosLookupSubTable::Type::Pair
|
||||
&& type != OT::Layout::GPOS_impl::PosLookupSubTable::Type::MarkBase)
|
||||
if (!is_supported_gpos_type(type, c) && !is_supported_gsub_type(type, c))
|
||||
continue;
|
||||
}
|
||||
|
||||
hb_vector_t<unsigned> new_sub_tables;
|
||||
switch (type)
|
||||
{
|
||||
case 2:
|
||||
new_sub_tables = split_subtable<PairPos> (c, parent_index, subtable_index); break;
|
||||
case 4:
|
||||
new_sub_tables = split_subtable<MarkBasePos> (c, parent_index, subtable_index); break;
|
||||
default:
|
||||
break;
|
||||
|
||||
if (c.table_tag == HB_OT_TAG_GPOS) {
|
||||
switch (type)
|
||||
{
|
||||
case 2:
|
||||
new_sub_tables = split_subtable<PairPos> (c, parent_index, subtable_index); break;
|
||||
case 4:
|
||||
new_sub_tables = split_subtable<MarkBasePos> (c, parent_index, subtable_index); break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
} else if (c.table_tag == HB_OT_TAG_GSUB) {
|
||||
switch (type)
|
||||
{
|
||||
case 4:
|
||||
new_sub_tables = split_subtable<graph::LigatureSubst> (c, parent_index, subtable_index); break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (new_sub_tables.in_error ()) return false;
|
||||
if (!new_sub_tables) continue;
|
||||
hb_pair_t<unsigned, hb_vector_t<unsigned>>* entry = all_new_subtables.push ();
|
||||
@@ -191,14 +202,14 @@ struct Lookup : public OT::Lookup
|
||||
hb_vector_t<hb_pair_t<unsigned, hb_vector_t<unsigned>>>& subtable_ids)
|
||||
{
|
||||
bool is_ext = is_extension (c.table_tag);
|
||||
auto& v = c.graph.vertices_[this_index];
|
||||
auto* v = &c.graph.vertices_[this_index];
|
||||
fix_existing_subtable_links (c, this_index, subtable_ids);
|
||||
|
||||
unsigned new_subtable_count = 0;
|
||||
for (const auto& p : subtable_ids)
|
||||
new_subtable_count += p.second.length;
|
||||
|
||||
size_t new_size = v.table_size ()
|
||||
size_t new_size = v->table_size ()
|
||||
+ new_subtable_count * OT::Offset16::static_size;
|
||||
char* buffer = (char*) hb_calloc (1, new_size);
|
||||
if (!buffer) return false;
|
||||
@@ -207,10 +218,10 @@ struct Lookup : public OT::Lookup
|
||||
hb_free (buffer);
|
||||
return false;
|
||||
}
|
||||
hb_memcpy (buffer, v.obj.head, v.table_size());
|
||||
hb_memcpy (buffer, v->obj.head, v->table_size());
|
||||
|
||||
v.obj.head = buffer;
|
||||
v.obj.tail = buffer + new_size;
|
||||
v->obj.head = buffer;
|
||||
v->obj.tail = buffer + new_size;
|
||||
|
||||
Lookup* new_lookup = (Lookup*) buffer;
|
||||
|
||||
@@ -226,21 +237,23 @@ struct Lookup : public OT::Lookup
|
||||
if (is_ext)
|
||||
{
|
||||
unsigned ext_id = create_extension_subtable (c, subtable_id, type);
|
||||
c.graph.vertices_[subtable_id].add_parent (ext_id);
|
||||
c.graph.vertices_[subtable_id].add_parent (ext_id, false);
|
||||
subtable_id = ext_id;
|
||||
// the reference to v may have changed on adding a node, so reassign it.
|
||||
v = &c.graph.vertices_[this_index];
|
||||
}
|
||||
|
||||
auto* link = v.obj.real_links.push ();
|
||||
auto* link = v->obj.real_links.push ();
|
||||
link->width = 2;
|
||||
link->objidx = subtable_id;
|
||||
link->position = (char*) &new_lookup->subTable[offset_index++] -
|
||||
(char*) new_lookup;
|
||||
c.graph.vertices_[subtable_id].add_parent (this_index);
|
||||
c.graph.vertices_[subtable_id].add_parent (this_index, false);
|
||||
}
|
||||
}
|
||||
|
||||
// Repacker sort order depends on link order, which we've messed up so resort it.
|
||||
v.obj.real_links.qsort ();
|
||||
v->obj.real_links.qsort ();
|
||||
|
||||
// The head location of the lookup has changed, invalidating the lookups map entry
|
||||
// in the context. Update the map.
|
||||
@@ -326,7 +339,7 @@ struct Lookup : public OT::Lookup
|
||||
|
||||
// Make extension point at the subtable.
|
||||
auto& ext_vertex = c.graph.vertices_[ext_index];
|
||||
ext_vertex.add_parent (lookup_index);
|
||||
ext_vertex.add_parent (lookup_index, false);
|
||||
if (!existing_ext_index)
|
||||
subtable_vertex.remap_parent (lookup_index, ext_index);
|
||||
|
||||
@@ -334,6 +347,19 @@ struct Lookup : public OT::Lookup
|
||||
}
|
||||
|
||||
private:
|
||||
bool is_supported_gsub_type(unsigned type, gsubgpos_graph_context_t& c) const {
|
||||
return (c.table_tag == HB_OT_TAG_GSUB) && (
|
||||
type == OT::Layout::GSUB_impl::SubstLookupSubTable::Type::Ligature
|
||||
);
|
||||
}
|
||||
|
||||
bool is_supported_gpos_type(unsigned type, gsubgpos_graph_context_t& c) const {
|
||||
return (c.table_tag == HB_OT_TAG_GPOS) && (
|
||||
type == OT::Layout::GPOS_impl::PosLookupSubTable::Type::Pair ||
|
||||
type == OT::Layout::GPOS_impl::PosLookupSubTable::Type::MarkBase
|
||||
);
|
||||
}
|
||||
|
||||
unsigned extension_type (hb_tag_t table_tag) const
|
||||
{
|
||||
switch (table_tag)
|
||||
|
||||
@@ -0,0 +1,480 @@
|
||||
/*
|
||||
* Copyright © 2025 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
|
||||
*/
|
||||
|
||||
#ifndef GRAPH_LIGATURE_GRAPH_HH
|
||||
#define GRAPH_LIGATURE_GRAPH_HH
|
||||
|
||||
#include "graph.hh"
|
||||
#include "../OT/Layout/GSUB/LigatureSubst.hh"
|
||||
#include "../OT/Layout/GSUB/LigatureSubstFormat1.hh"
|
||||
#include "../OT/Layout/GSUB/LigatureSet.hh"
|
||||
#include "../OT/Layout/types.hh"
|
||||
#include <algorithm>
|
||||
#include <utility>
|
||||
|
||||
namespace graph {
|
||||
|
||||
struct LigatureSet : public OT::Layout::GSUB_impl::LigatureSet<SmallTypes>
|
||||
{
|
||||
bool sanitize (graph_t::vertex_t& vertex) const
|
||||
{
|
||||
int64_t vertex_len = vertex.obj.tail - vertex.obj.head;
|
||||
if (vertex_len < OT::Layout::GSUB_impl::LigatureSet<SmallTypes>::min_size) return false;
|
||||
hb_barrier ();
|
||||
|
||||
int64_t total_len = ligature.get_size() + OT::Layout::GSUB_impl::LigatureSet<SmallTypes>::min_size - ligature.len.get_size();
|
||||
if (vertex_len < total_len) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
struct LigatureSubstFormat1 : public OT::Layout::GSUB_impl::LigatureSubstFormat1_2<SmallTypes>
|
||||
{
|
||||
bool sanitize (graph_t::vertex_t& vertex) const
|
||||
{
|
||||
int64_t vertex_len = vertex.obj.tail - vertex.obj.head;
|
||||
unsigned min_size = OT::Layout::GSUB_impl::LigatureSubstFormat1_2<SmallTypes>::min_size;
|
||||
if (vertex_len < min_size) return false;
|
||||
hb_barrier ();
|
||||
|
||||
return vertex_len >=
|
||||
min_size + ligatureSet.get_size() - ligatureSet.len.get_size();
|
||||
}
|
||||
|
||||
hb_vector_t<unsigned> split_subtables (gsubgpos_graph_context_t& c,
|
||||
unsigned parent_index,
|
||||
unsigned this_index)
|
||||
{
|
||||
auto split_points = compute_split_points(c, parent_index, this_index);
|
||||
split_context_t split_context {
|
||||
c,
|
||||
this,
|
||||
c.graph.duplicate_if_shared (parent_index, this_index),
|
||||
total_number_ligas(c, this_index),
|
||||
liga_counts(c, this_index),
|
||||
};
|
||||
return actuate_subtable_split<split_context_t> (split_context, split_points);
|
||||
}
|
||||
|
||||
private:
|
||||
unsigned total_number_ligas(gsubgpos_graph_context_t& c, unsigned this_index) const {
|
||||
unsigned total = 0;
|
||||
for (unsigned i = 0; i < ligatureSet.len; i++)
|
||||
{
|
||||
auto liga_set = c.graph.as_table<LigatureSet>(this_index, &ligatureSet[i]);
|
||||
if (!liga_set.table) {
|
||||
return 0;
|
||||
}
|
||||
total += liga_set.table->ligature.len;
|
||||
}
|
||||
return total;
|
||||
}
|
||||
|
||||
hb_vector_t<unsigned> liga_counts(gsubgpos_graph_context_t& c, unsigned this_index) const {
|
||||
hb_vector_t<unsigned> result;
|
||||
for (unsigned i = 0; i < ligatureSet.len; i++)
|
||||
{
|
||||
auto liga_set = c.graph.as_table<LigatureSet>(this_index, &ligatureSet[i]);
|
||||
result.push(!liga_set.table ? 0 : liga_set.table->ligature.len);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
hb_vector_t<unsigned> compute_split_points(gsubgpos_graph_context_t& c,
|
||||
unsigned parent_index,
|
||||
unsigned this_index) const
|
||||
{
|
||||
// For ligature subst coverage is always packed last, and as a result is where an overflow
|
||||
// will happen if there is one, so we can check the estimate length of the
|
||||
// LigatureSubstFormat1 -> Coverage offset length which is the sum of all data in the
|
||||
// retained sub graph except for the coverage table itself.
|
||||
const unsigned base_size = OT::Layout::GSUB_impl::LigatureSubstFormat1_2<SmallTypes>::min_size;
|
||||
unsigned accumulated = base_size;
|
||||
|
||||
unsigned ligature_index = 0;
|
||||
hb_vector_t<unsigned> split_points;
|
||||
for (unsigned i = 0; i < ligatureSet.len; i++)
|
||||
{
|
||||
accumulated += OT::HBUINT16::static_size; // for ligature set offset
|
||||
accumulated += OT::Layout::GSUB_impl::LigatureSet<SmallTypes>::min_size; // for ligature set table
|
||||
|
||||
auto liga_set = c.graph.as_table<LigatureSet>(this_index, &ligatureSet[i]);
|
||||
if (!liga_set.table) {
|
||||
return hb_vector_t<unsigned> {};
|
||||
}
|
||||
|
||||
for (unsigned j = 0; j < liga_set.table->ligature.len; j++)
|
||||
{
|
||||
const unsigned liga_id = c.graph.index_for_offset (liga_set.index, &liga_set.table->ligature[j]);
|
||||
const unsigned liga_size = c.graph.vertices_[liga_id].table_size ();
|
||||
|
||||
accumulated += OT::HBUINT16::static_size; // for ligature offset
|
||||
accumulated += liga_size; // for the ligature table
|
||||
|
||||
if (accumulated >= (1 << 16))
|
||||
{
|
||||
split_points.push(ligature_index);
|
||||
// We're going to split such that the current ligature will be in the new sub table.
|
||||
// That means we'll have one ligature subst (base_base), one ligature set, and one liga table
|
||||
accumulated = base_size + // for liga subst subtable
|
||||
(OT::HBUINT16::static_size * 2) + // for liga set and liga offset
|
||||
OT::Layout::GSUB_impl::LigatureSet<SmallTypes>::min_size + // for liga set subtable
|
||||
liga_size; // for liga sub table
|
||||
}
|
||||
|
||||
ligature_index++;
|
||||
}
|
||||
}
|
||||
|
||||
return split_points;
|
||||
}
|
||||
|
||||
|
||||
struct split_context_t
|
||||
{
|
||||
gsubgpos_graph_context_t& c;
|
||||
LigatureSubstFormat1* thiz;
|
||||
unsigned this_index;
|
||||
unsigned original_count_;
|
||||
hb_vector_t<unsigned> liga_counts;
|
||||
|
||||
unsigned original_count ()
|
||||
{
|
||||
return original_count_;
|
||||
}
|
||||
|
||||
unsigned clone_range (unsigned start, unsigned end)
|
||||
{
|
||||
return thiz->clone_range (c, this_index, liga_counts, start, end);
|
||||
}
|
||||
|
||||
bool shrink (unsigned count)
|
||||
{
|
||||
return thiz->shrink (c, this_index, original_count(), liga_counts, count);
|
||||
}
|
||||
};
|
||||
|
||||
hb_pair_t<unsigned, LigatureSet*> new_liga_set(gsubgpos_graph_context_t& c, unsigned count) const {
|
||||
unsigned prime_size = OT::Layout::GSUB_impl::LigatureSet<SmallTypes>::min_size
|
||||
+ count * SmallTypes::size;
|
||||
|
||||
unsigned prime_id = c.create_node (prime_size);
|
||||
if (prime_id == (unsigned) -1) return hb_pair(-1, nullptr);
|
||||
|
||||
LigatureSet* prime = (LigatureSet*) c.graph.object (prime_id).head;
|
||||
prime->ligature.len = count;
|
||||
return hb_pair(prime_id, prime);
|
||||
}
|
||||
|
||||
void clear_virtual_links (gsubgpos_graph_context_t& c, unsigned node_index) const
|
||||
{
|
||||
auto& obj = c.graph.vertices_[node_index].obj;
|
||||
for (const auto& l : obj.virtual_links)
|
||||
{
|
||||
auto& child = c.graph.vertices_[l.objidx];
|
||||
child.remove_parent(node_index);
|
||||
}
|
||||
obj.virtual_links.clear();
|
||||
}
|
||||
|
||||
void add_virtual_link(gsubgpos_graph_context_t& c, unsigned from, unsigned to) const {
|
||||
auto& from_obj = c.graph.vertices_[from].obj;
|
||||
c.graph.vertices_[to].add_parent(from, true);
|
||||
auto& link = *from_obj.virtual_links.push ();
|
||||
link.objidx = to;
|
||||
}
|
||||
|
||||
hb_pair_t<unsigned, unsigned> current_liga_set_bounds (gsubgpos_graph_context_t& c,
|
||||
unsigned liga_set_index,
|
||||
const hb_serialize_context_t::object_t& liga_set) const
|
||||
{
|
||||
// Finds the actual liga indices present in the liga set currently. Takes
|
||||
// into account those that have been removed by processing.
|
||||
unsigned min_index = (unsigned) -1;
|
||||
unsigned max_index = 0;
|
||||
for (const auto& l : liga_set.real_links) {
|
||||
if (l.position < 2) continue;
|
||||
|
||||
unsigned liga_index = (l.position - 2) / 2;
|
||||
min_index = hb_min(min_index, liga_index);
|
||||
max_index = hb_max(max_index, liga_index);
|
||||
}
|
||||
return hb_pair(min_index, max_index + 1);
|
||||
}
|
||||
|
||||
void compact_liga_set (gsubgpos_graph_context_t& c, LigatureSet* table, hb_serialize_context_t::object_t& obj) const
|
||||
{
|
||||
if (table->ligature.len <= obj.real_links.length) return;
|
||||
|
||||
// compact the remaining linked liga offsets into a continous array and shrink the node as needed.
|
||||
unsigned to_remove = table->ligature.len - obj.real_links.length;
|
||||
unsigned new_position = SmallTypes::size;
|
||||
obj.real_links.qsort(); // for this to work we need to process links in order of position.
|
||||
for (auto& l : obj.real_links)
|
||||
{
|
||||
l.position = new_position;
|
||||
new_position += SmallTypes::size;
|
||||
}
|
||||
|
||||
table->ligature.len = obj.real_links.length;
|
||||
obj.tail -= to_remove * SmallTypes::size;
|
||||
}
|
||||
|
||||
unsigned clone_range (gsubgpos_graph_context_t& c,
|
||||
unsigned this_index,
|
||||
hb_vector_t<unsigned> liga_counts,
|
||||
unsigned start, unsigned end) const
|
||||
{
|
||||
DEBUG_MSG (SUBSET_REPACK, nullptr,
|
||||
" Cloning LigatureSubstFormat1 (%u) range [%u, %u).", this_index, start, end);
|
||||
|
||||
// Create an oversized new liga subst, we'll adjust the size down later. We don't know
|
||||
// the final size until we process it but we also need it to exist while we're processing
|
||||
// so that nodes can be moved to it as needed.
|
||||
unsigned prime_size = OT::Layout::GSUB_impl::LigatureSubstFormat1_2<SmallTypes>::min_size
|
||||
+ ligatureSet.get_size() - ligatureSet.len.get_size();
|
||||
|
||||
unsigned liga_subst_prime_id = c.create_node (prime_size);
|
||||
if (liga_subst_prime_id == (unsigned) -1) return -1;
|
||||
|
||||
LigatureSubstFormat1* liga_subst_prime = (LigatureSubstFormat1*) c.graph.object (liga_subst_prime_id).head;
|
||||
liga_subst_prime->format = this->format;
|
||||
liga_subst_prime->ligatureSet.len = this->ligatureSet.len;
|
||||
|
||||
// Create a place holder coverage prime id since we need to add virtual links to it while
|
||||
// generating liga and liga sets. Afterwards it will be updated to have the correct coverage.
|
||||
unsigned coverage_id = c.graph.index_for_offset (this_index, &coverage);
|
||||
unsigned coverage_prime_id = c.graph.duplicate(coverage_id);
|
||||
auto& coverage_prime_vertex = c.graph.vertices_[coverage_prime_id];
|
||||
auto* coverage_prime_link = c.graph.vertices_[liga_subst_prime_id].obj.real_links.push ();
|
||||
coverage_prime_link->width = SmallTypes::size;
|
||||
coverage_prime_link->objidx = coverage_prime_id;
|
||||
coverage_prime_link->position = 2;
|
||||
coverage_prime_vertex.add_parent (liga_subst_prime_id, false);
|
||||
|
||||
// Locate all liga sets with ligas between start and end.
|
||||
// Clone or move them as needed.
|
||||
unsigned count = 0;
|
||||
unsigned liga_set_count = 0;
|
||||
unsigned liga_set_start = -1;
|
||||
unsigned liga_set_end = 0; // inclusive
|
||||
for (unsigned i = 0; i < liga_counts.length; i++)
|
||||
{
|
||||
unsigned num_ligas = liga_counts[i];
|
||||
|
||||
unsigned current_start = count;
|
||||
unsigned current_end = count + num_ligas;
|
||||
|
||||
if (current_start >= end || start >= current_end) {
|
||||
// No intersection, so just skip
|
||||
count += num_ligas;
|
||||
continue;
|
||||
}
|
||||
|
||||
auto liga_set_index = c.graph.index_for_offset(this_index, &ligatureSet[i]);
|
||||
auto liga_set = c.graph.as_table<LigatureSet>(this_index, &ligatureSet[i]);
|
||||
if (!liga_set.table) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Bounds may need to be adjusted if some ligas have been previously removed.
|
||||
hb_pair_t<unsigned, unsigned> liga_bounds = current_liga_set_bounds(c, liga_set_index, liga_set.vertex->obj);
|
||||
current_start = hb_max(count + liga_bounds.first, current_start);
|
||||
current_end = hb_min(count + liga_bounds.second, current_end);
|
||||
|
||||
unsigned liga_set_prime_id;
|
||||
if (current_start >= start && current_end <= end) {
|
||||
// This liga set is fully contined within [start, end)
|
||||
// We can move the entire ligaset to the new liga subset object.
|
||||
liga_set_end = i;
|
||||
if (i < liga_set_start) liga_set_start = i;
|
||||
liga_set_prime_id = c.graph.move_child<> (this_index,
|
||||
&ligatureSet[i],
|
||||
liga_subst_prime_id,
|
||||
&liga_subst_prime->ligatureSet[liga_set_count++]);
|
||||
compact_liga_set(c, liga_set.table, liga_set.vertex->obj);
|
||||
}
|
||||
else
|
||||
{
|
||||
// This liga set partially overlaps [start, end). We'll need to create
|
||||
// a new liga set sub table and move the intersecting ligas to it.
|
||||
unsigned liga_count = hb_min(end, current_end) - hb_max(start, current_start);
|
||||
auto result = new_liga_set(c, liga_count);
|
||||
liga_set_prime_id = result.first;
|
||||
LigatureSet* prime = result.second;
|
||||
if (liga_set_prime_id == (unsigned) -1) return -1;
|
||||
|
||||
unsigned new_index = 0;
|
||||
for (unsigned j = hb_max(start, current_start) - count; j < hb_min(end, current_end) - count; j++) {
|
||||
c.graph.move_child<> (liga_set_index,
|
||||
&liga_set.table->ligature[j],
|
||||
liga_set_prime_id,
|
||||
&prime->ligature[new_index++]);
|
||||
}
|
||||
|
||||
liga_set_end = i;
|
||||
if (i < liga_set_start) liga_set_start = i;
|
||||
c.graph.add_link(&liga_subst_prime->ligatureSet[liga_set_count++], liga_subst_prime_id, liga_set_prime_id);
|
||||
}
|
||||
|
||||
// The new liga and all children set needs to have a virtual link to the new coverage table:
|
||||
auto& liga_set_prime = c.graph.vertices_[liga_set_prime_id].obj;
|
||||
clear_virtual_links(c, liga_set_prime_id);
|
||||
add_virtual_link(c, liga_set_prime_id, coverage_prime_id);
|
||||
for (const auto& l : liga_set_prime.real_links) {
|
||||
clear_virtual_links(c, l.objidx);
|
||||
add_virtual_link(c, l.objidx, coverage_prime_id);
|
||||
}
|
||||
|
||||
count += num_ligas;
|
||||
}
|
||||
|
||||
c.graph.vertices_[liga_subst_prime_id].obj.tail -= (liga_subst_prime->ligatureSet.len - liga_set_count) * SmallTypes::size;
|
||||
liga_subst_prime->ligatureSet.len = liga_set_count;
|
||||
|
||||
if (!Coverage::filter_coverage (c,
|
||||
coverage_prime_id,
|
||||
liga_set_start, liga_set_end + 1))
|
||||
return -1;
|
||||
|
||||
return liga_subst_prime_id;
|
||||
}
|
||||
|
||||
bool shrink (gsubgpos_graph_context_t& c,
|
||||
unsigned this_index,
|
||||
unsigned old_count,
|
||||
hb_vector_t<unsigned> liga_counts,
|
||||
unsigned count)
|
||||
{
|
||||
DEBUG_MSG (SUBSET_REPACK, nullptr,
|
||||
" Shrinking LigatureSubstFormat1 (%u) to [0, %u).",
|
||||
this_index,
|
||||
count);
|
||||
if (count >= old_count)
|
||||
return true;
|
||||
|
||||
hb_set_t retained_indices;
|
||||
unsigned new_liga_set_count = 0;
|
||||
for (unsigned i = 0; i < liga_counts.length; i++)
|
||||
{
|
||||
auto liga_set = c.graph.as_table<LigatureSet>(this_index, &ligatureSet[i]);
|
||||
if (!liga_set.table) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// We need the virtual links to coverage removed from all descendants on this liga subst.
|
||||
// If any are left when we try to mutate the coverage table later it will be unnessecarily
|
||||
// duplicated. Code later on will re-add the virtual links as needed (via retained_indices).
|
||||
clear_virtual_links(c, liga_set.index);
|
||||
retained_indices.add(liga_set.index);
|
||||
for (const auto& liga_offset : liga_set.table->ligature) {
|
||||
unsigned liga_index = c.graph.index_for_offset(liga_set.index, &liga_offset);
|
||||
if (liga_index != (unsigned) -1) {
|
||||
clear_virtual_links(c, liga_index);
|
||||
retained_indices.add(liga_index);
|
||||
}
|
||||
}
|
||||
|
||||
unsigned num_ligas = liga_counts[i];
|
||||
if (num_ligas >= count) {
|
||||
// drop the trailing liga's from this set and all subsequent liga sets
|
||||
unsigned num_ligas_to_remove = num_ligas - count;
|
||||
new_liga_set_count = i + 1;
|
||||
c.graph.vertices_[liga_set.index].obj.tail -= num_ligas_to_remove * SmallTypes::size;
|
||||
liga_set.table->ligature.len = count;
|
||||
break;
|
||||
} else {
|
||||
count -= num_ligas;
|
||||
}
|
||||
}
|
||||
|
||||
// Adjust liga set array
|
||||
c.graph.vertices_[this_index].obj.tail -= (ligatureSet.len - new_liga_set_count) * SmallTypes::size;
|
||||
ligatureSet.len = new_liga_set_count;
|
||||
|
||||
// Coverage matches the number of liga sets so rebuild as needed
|
||||
auto coverage = c.graph.as_mutable_table<Coverage> (this_index, &this->coverage);
|
||||
if (!coverage) return false;
|
||||
|
||||
for (unsigned i : retained_indices.iter())
|
||||
add_virtual_link(c, i, coverage.index);
|
||||
|
||||
unsigned coverage_size = coverage.vertex->table_size ();
|
||||
auto new_coverage =
|
||||
+ hb_zip (coverage.table->iter (), hb_range ())
|
||||
| hb_filter ([&] (hb_pair_t<unsigned, unsigned> p) {
|
||||
return p.second < new_liga_set_count;
|
||||
})
|
||||
| hb_map_retains_sorting (hb_first)
|
||||
;
|
||||
|
||||
return Coverage::make_coverage (c, new_coverage, coverage.index, coverage_size);
|
||||
}
|
||||
};
|
||||
|
||||
struct LigatureSubst : public OT::Layout::GSUB_impl::LigatureSubst
|
||||
{
|
||||
|
||||
hb_vector_t<unsigned> split_subtables (gsubgpos_graph_context_t& c,
|
||||
unsigned parent_index,
|
||||
unsigned this_index)
|
||||
{
|
||||
switch (u.format) {
|
||||
case 1:
|
||||
return ((LigatureSubstFormat1*)(&u.format1))->split_subtables (c, parent_index, this_index);
|
||||
#ifndef HB_NO_BEYOND_64K
|
||||
case 2: HB_FALLTHROUGH;
|
||||
// Don't split 24bit Ligature Subs
|
||||
#endif
|
||||
default:
|
||||
return hb_vector_t<unsigned> ();
|
||||
}
|
||||
}
|
||||
|
||||
bool sanitize (graph_t::vertex_t& vertex) const
|
||||
{
|
||||
int64_t vertex_len = vertex.obj.tail - vertex.obj.head;
|
||||
if (vertex_len < u.format.get_size ()) return false;
|
||||
hb_barrier ();
|
||||
|
||||
switch (u.format) {
|
||||
case 1:
|
||||
return ((LigatureSubstFormat1*)(&u.format1))->sanitize (vertex);
|
||||
#ifndef HB_NO_BEYOND_64K
|
||||
case 2: HB_FALLTHROUGH;
|
||||
#endif
|
||||
default:
|
||||
// We don't handle format 2 here.
|
||||
return false;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif // GRAPH_LIGATURE_GRAPH_HH
|
||||
@@ -423,7 +423,7 @@ struct PairPosFormat2 : public OT::Layout::GPOS_impl::PairPosFormat2_4<SmallType
|
||||
class_def_link->width = SmallTypes::size;
|
||||
class_def_link->objidx = class_def_2_id;
|
||||
class_def_link->position = 10;
|
||||
graph.vertices_[class_def_2_id].add_parent (pair_pos_prime_id);
|
||||
graph.vertices_[class_def_2_id].add_parent (pair_pos_prime_id, false);
|
||||
graph.duplicate (pair_pos_prime_id, class_def_2_id);
|
||||
|
||||
return pair_pos_prime_id;
|
||||
|
||||
+10
-6
@@ -172,8 +172,11 @@ void print_overflows (graph_t& graph,
|
||||
template <typename O> inline void
|
||||
serialize_link_of_type (const hb_serialize_context_t::object_t::link_t& link,
|
||||
char* head,
|
||||
unsigned size,
|
||||
hb_serialize_context_t* c)
|
||||
{
|
||||
assert(link.position + link.width <= size);
|
||||
|
||||
OT::Offset<O>* offset = reinterpret_cast<OT::Offset<O>*> (head + link.position);
|
||||
*offset = 0;
|
||||
c->add_link (*offset,
|
||||
@@ -187,6 +190,7 @@ serialize_link_of_type (const hb_serialize_context_t::object_t::link_t& link,
|
||||
inline
|
||||
void serialize_link (const hb_serialize_context_t::object_t::link_t& link,
|
||||
char* head,
|
||||
unsigned size,
|
||||
hb_serialize_context_t* c)
|
||||
{
|
||||
switch (link.width)
|
||||
@@ -197,21 +201,21 @@ void serialize_link (const hb_serialize_context_t::object_t::link_t& link,
|
||||
case 4:
|
||||
if (link.is_signed)
|
||||
{
|
||||
serialize_link_of_type<OT::HBINT32> (link, head, c);
|
||||
serialize_link_of_type<OT::HBINT32> (link, head, size, c);
|
||||
} else {
|
||||
serialize_link_of_type<OT::HBUINT32> (link, head, c);
|
||||
serialize_link_of_type<OT::HBUINT32> (link, head, size, c);
|
||||
}
|
||||
return;
|
||||
case 2:
|
||||
if (link.is_signed)
|
||||
{
|
||||
serialize_link_of_type<OT::HBINT16> (link, head, c);
|
||||
serialize_link_of_type<OT::HBINT16> (link, head, size, c);
|
||||
} else {
|
||||
serialize_link_of_type<OT::HBUINT16> (link, head, c);
|
||||
serialize_link_of_type<OT::HBUINT16> (link, head, size, c);
|
||||
}
|
||||
return;
|
||||
case 3:
|
||||
serialize_link_of_type<OT::HBUINT24> (link, head, c);
|
||||
serialize_link_of_type<OT::HBUINT24> (link, head, size, c);
|
||||
return;
|
||||
default:
|
||||
// Unexpected link width.
|
||||
@@ -251,7 +255,7 @@ inline hb_blob_t* serialize (const graph_t& graph)
|
||||
|
||||
// Only real links needs to be serialized.
|
||||
for (const auto& link : vertices[i].obj.real_links)
|
||||
serialize_link (link, start, &c);
|
||||
serialize_link (link, start, size, &c);
|
||||
|
||||
// All duplications are already encoded in the graph, so don't
|
||||
// enable sharing during packing.
|
||||
|
||||
+7
-4
@@ -266,7 +266,7 @@ bool _resolve_shared_overflow(const hb_vector_t<graph::overflow_record_t>& overf
|
||||
result = sorted_graph.duplicate(&parents, r.child);
|
||||
}
|
||||
|
||||
if (result == (unsigned) -1) return result;
|
||||
if (result == (unsigned) -1) return false;
|
||||
|
||||
if (parents.get_population() > 1) {
|
||||
// If the duplicated node has more than one parent pre-emptively raise it's priority to the maximum.
|
||||
@@ -283,7 +283,7 @@ bool _resolve_shared_overflow(const hb_vector_t<graph::overflow_record_t>& overf
|
||||
sorted_graph.vertices_[result].give_max_priority();
|
||||
}
|
||||
|
||||
return result;
|
||||
return true;
|
||||
}
|
||||
|
||||
static inline
|
||||
@@ -302,8 +302,11 @@ bool _process_overflows (const hb_vector_t<graph::overflow_record_t>& overflows,
|
||||
{
|
||||
// The child object is shared, we may be able to eliminate the overflow
|
||||
// by duplicating it.
|
||||
if (!_resolve_shared_overflow(overflows, i, sorted_graph)) continue;
|
||||
return true;
|
||||
if (_resolve_shared_overflow(overflows, i, sorted_graph))
|
||||
return true;
|
||||
|
||||
// Sometimes we can't duplicate a node which looks shared because it's not actually shared
|
||||
// (eg. all links from the same parent) in this case continue on to other resolution options.
|
||||
}
|
||||
|
||||
if (child.is_leaf () && !priority_bumped_parents.has (r.parent))
|
||||
|
||||
+36
-10
@@ -5,7 +5,7 @@ use std::ffi::c_void;
|
||||
use std::mem::transmute;
|
||||
use std::ptr::null_mut;
|
||||
use std::sync::atomic::{AtomicPtr, AtomicU32, Ordering};
|
||||
use std::sync::{Mutex, OnceLock};
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
use skrifa::charmap::Charmap;
|
||||
use skrifa::charmap::MapVariant::Variant;
|
||||
@@ -35,7 +35,6 @@ struct FontationsData<'a> {
|
||||
outline_glyphs: OutlineGlyphCollection<'a>,
|
||||
color_glyphs: ColorGlyphCollection<'a>,
|
||||
glyph_names: GlyphNames<'a>,
|
||||
glyph_from_names: OnceLock<HashMap<String, hb_codepoint_t>>,
|
||||
size: Size,
|
||||
vert_metrics: Option<Vmtx<'a>>,
|
||||
vert_origin: Option<Vorg<'a>>,
|
||||
@@ -89,7 +88,6 @@ impl FontationsData<'_> {
|
||||
outline_glyphs,
|
||||
color_glyphs,
|
||||
glyph_names,
|
||||
glyph_from_names: OnceLock::new(),
|
||||
size: Size::new(upem as f32),
|
||||
vert_metrics,
|
||||
vert_origin,
|
||||
@@ -980,8 +978,14 @@ extern "C" fn _hb_fontations_glyph_name(
|
||||
}
|
||||
}
|
||||
|
||||
static mut GLYPH_FROM_NAMES_KEY: hb_user_data_key_t = hb_user_data_key_t { unused: 0 };
|
||||
|
||||
extern "C" fn _hb_glyph_from_names_destroy(data: *mut c_void) {
|
||||
let _ = unsafe { Arc::from_raw(data as *const HashMap<String, u32>) };
|
||||
}
|
||||
|
||||
extern "C" fn _hb_fontations_glyph_from_name(
|
||||
_font: *mut hb_font_t,
|
||||
font: *mut hb_font_t,
|
||||
font_data: *mut ::std::os::raw::c_void,
|
||||
name: *const ::std::os::raw::c_char,
|
||||
len: ::std::os::raw::c_int,
|
||||
@@ -992,13 +996,35 @@ extern "C" fn _hb_fontations_glyph_from_name(
|
||||
|
||||
let name = unsafe { std::slice::from_raw_parts(name as *const u8, len as usize) };
|
||||
let name = std::str::from_utf8(name).unwrap_or_default();
|
||||
let mut glyph_from_names: *mut c_void;
|
||||
|
||||
let glyph_from_names = data.glyph_from_names.get_or_init(|| {
|
||||
data.glyph_names
|
||||
.iter()
|
||||
.map(|(gid, name)| (name.to_string(), gid.to_u32()))
|
||||
.collect()
|
||||
});
|
||||
let face = unsafe { hb_font_get_face(font) };
|
||||
loop {
|
||||
glyph_from_names = unsafe { hb_face_get_user_data(face, &raw mut GLYPH_FROM_NAMES_KEY) };
|
||||
if !glyph_from_names.is_null() {
|
||||
break;
|
||||
}
|
||||
// Create a new HashMap to store the glyph names
|
||||
let mut glyph_from_names = HashMap::new();
|
||||
for (glyph_id, glyph_name) in data.glyph_names.iter() {
|
||||
glyph_from_names.insert(glyph_name.to_string(), glyph_id.to_u32());
|
||||
}
|
||||
|
||||
let glyph_from_names = Arc::new(glyph_from_names);
|
||||
unsafe {
|
||||
if hb_face_set_user_data(
|
||||
face,
|
||||
&raw mut GLYPH_FROM_NAMES_KEY,
|
||||
Arc::into_raw(glyph_from_names) as *mut c_void,
|
||||
Some(_hb_glyph_from_names_destroy),
|
||||
true as hb_bool_t,
|
||||
) != false as hb_bool_t
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
let glyph_from_names = unsafe { &*(glyph_from_names as *const HashMap<String, u32>) };
|
||||
if let Some(glyph_id) = glyph_from_names.get(name) {
|
||||
unsafe {
|
||||
*glyph = *glyph_id;
|
||||
|
||||
@@ -24,6 +24,7 @@
|
||||
* Google Author(s): Garret Rieger
|
||||
*/
|
||||
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
|
||||
#include "hb-repacker.hh"
|
||||
@@ -147,6 +148,17 @@ static unsigned add_extension (unsigned child,
|
||||
static unsigned add_coverage (unsigned start, unsigned end,
|
||||
hb_serialize_context_t* c)
|
||||
{
|
||||
if (end - start == 0) {
|
||||
uint8_t coverage[] = {
|
||||
0, 1, // format
|
||||
0, 1, // count
|
||||
|
||||
(uint8_t) ((start >> 8) & 0xFF),
|
||||
(uint8_t) (start & 0xFF), // glyph[0]
|
||||
};
|
||||
return add_object ((char*) coverage, 6, c);
|
||||
}
|
||||
|
||||
if (end - start == 1)
|
||||
{
|
||||
uint8_t coverage[] = {
|
||||
@@ -242,6 +254,31 @@ static unsigned add_pair_pos_1 (unsigned* pair_sets,
|
||||
return c->pop_pack (false);
|
||||
}
|
||||
|
||||
static void add_liga_set_header (char liga_count,
|
||||
hb_serialize_context_t* c)
|
||||
{
|
||||
uint8_t liga_count_bytes[] = {
|
||||
(uint8_t) (0xFF & (liga_count >> 8)),
|
||||
(uint8_t) (0xFF & liga_count),
|
||||
};
|
||||
|
||||
start_object ((const char*) liga_count_bytes, 2, c);
|
||||
}
|
||||
|
||||
static void add_liga_header (unsigned coverage, unsigned liga_set_count, hb_serialize_context_t* c)
|
||||
{
|
||||
uint8_t format[] = {0, 1};
|
||||
start_object ((const char*) format, 2, c);
|
||||
add_offset(coverage, c);
|
||||
|
||||
uint8_t liga_set_count_bytes[] = {
|
||||
(uint8_t) (0xFF & (liga_set_count >> 8)),
|
||||
(uint8_t) (0xFF & liga_set_count),
|
||||
};
|
||||
|
||||
extend((const char *) liga_set_count_bytes, 2, c);
|
||||
}
|
||||
|
||||
static unsigned add_pair_pos_2 (unsigned starting_class,
|
||||
unsigned coverage,
|
||||
unsigned class_def_1, uint16_t class_def_1_count,
|
||||
@@ -521,6 +558,39 @@ populate_serializer_simple (hb_serialize_context_t* c)
|
||||
c->end_serialize();
|
||||
}
|
||||
|
||||
static void
|
||||
populate_serializer_virtual (hb_serialize_context_t* c, bool with_overflow)
|
||||
{
|
||||
std::string large_string(50000, 'a');
|
||||
c->start_serialize<char> ();
|
||||
|
||||
unsigned obj_4, obj_5;
|
||||
if (with_overflow) {
|
||||
obj_5 = add_object("55555", 5, c);
|
||||
obj_4 = add_object(large_string.c_str(), 50000, c);
|
||||
} else {
|
||||
obj_4 = add_object(large_string.c_str(), 50000, c);
|
||||
obj_5 = add_object("55555", 5, c);
|
||||
}
|
||||
|
||||
start_object(large_string.c_str(), 20000, c);
|
||||
add_offset(obj_5, c);
|
||||
unsigned obj_3 = c->pop_pack(false);
|
||||
|
||||
start_object("2", 2, c);
|
||||
add_virtual_offset(obj_5, c);
|
||||
unsigned obj_2 = c->pop_pack(false);
|
||||
|
||||
// obj 1
|
||||
start_object("1", 1, c);
|
||||
add_offset(obj_2, c);
|
||||
add_offset(obj_3, c);
|
||||
add_offset(obj_4, c);
|
||||
c->pop_pack(false);
|
||||
|
||||
c->end_serialize();
|
||||
}
|
||||
|
||||
static void
|
||||
populate_serializer_with_overflow (hb_serialize_context_t* c)
|
||||
{
|
||||
@@ -1568,6 +1638,163 @@ populate_serializer_with_large_mark_base_pos_1 (hb_serialize_context_t* c)
|
||||
c->end_serialize();
|
||||
}
|
||||
|
||||
template<int liga_subst_count,
|
||||
int liga_set_count,
|
||||
int liga_per_set_count,
|
||||
int liga_size>
|
||||
static void
|
||||
populate_serializer_with_large_liga (hb_serialize_context_t* c, bool sequential_liga_sets)
|
||||
{
|
||||
std::string large_string(100000, 'a');
|
||||
c->start_serialize<char> ();
|
||||
|
||||
unsigned liga_subst[liga_subst_count];
|
||||
|
||||
for (unsigned l = 0; l < liga_subst_count; l++) {
|
||||
unsigned coverage_start = 0;
|
||||
unsigned coverage_end = liga_set_count - 1;
|
||||
if (sequential_liga_sets) {
|
||||
coverage_start = l * liga_set_count;
|
||||
coverage_end = (l + 1) * liga_set_count - 1;
|
||||
}
|
||||
unsigned coverage = add_coverage(coverage_start, coverage_end, c);
|
||||
|
||||
unsigned liga[liga_set_count * liga_per_set_count];
|
||||
unsigned liga_set[liga_set_count];
|
||||
for (unsigned i = 0; i < liga_set_count; i++) {
|
||||
for (unsigned j = 0; j < liga_per_set_count; j++)
|
||||
{
|
||||
start_object (large_string.c_str(), liga_size, c);
|
||||
add_virtual_offset(coverage, c);
|
||||
liga[i * liga_per_set_count + j] = c->pop_pack (false);
|
||||
}
|
||||
|
||||
add_liga_set_header(liga_per_set_count, c);
|
||||
add_virtual_offset(coverage, c);
|
||||
for (unsigned j = 0; j < liga_per_set_count; j++)
|
||||
{
|
||||
add_offset(liga[i * liga_per_set_count + j], c);
|
||||
}
|
||||
|
||||
liga_set[i] = c->pop_pack(false);
|
||||
}
|
||||
|
||||
add_liga_header(coverage, liga_set_count, c);
|
||||
for (unsigned i = 0; i < liga_set_count; i++)
|
||||
{
|
||||
add_offset(liga_set[i], c);
|
||||
}
|
||||
|
||||
liga_subst[l] = c->pop_pack(false);
|
||||
}
|
||||
|
||||
for (unsigned l = 0; l < liga_subst_count; l++) {
|
||||
liga_subst[l] = add_extension(liga_subst[l], 4, c);
|
||||
}
|
||||
|
||||
start_lookup (7, liga_subst_count, c);
|
||||
for (unsigned l = 0; l < liga_subst_count; l++) {
|
||||
add_offset(liga_subst[l], c);
|
||||
}
|
||||
|
||||
unsigned lookup = finish_lookup (c);
|
||||
|
||||
unsigned lookup_list = add_lookup_list (&lookup, 1, c);
|
||||
|
||||
add_gsubgpos_header (lookup_list, c);
|
||||
|
||||
c->end_serialize();
|
||||
}
|
||||
|
||||
static void
|
||||
populate_serializer_with_large_liga_overlapping_clone_result (hb_serialize_context_t* c)
|
||||
{
|
||||
std::string large_string(100000, 'a');
|
||||
c->start_serialize<char> ();
|
||||
|
||||
constexpr unsigned liga_size = 30000;
|
||||
|
||||
unsigned liga[6];
|
||||
unsigned liga_subst[3];
|
||||
unsigned liga_set[2];
|
||||
|
||||
// LigaSubst 3
|
||||
unsigned coverage = add_coverage(1, 1, c);
|
||||
for (int i = 1; i >= 0; i--) {
|
||||
start_object (large_string.c_str(), liga_size, c);
|
||||
add_virtual_offset(coverage, c);
|
||||
liga[i] = c->pop_pack (false);
|
||||
}
|
||||
|
||||
add_liga_set_header(2, c);
|
||||
add_virtual_offset(coverage, c);
|
||||
for (unsigned i = 0; i < 2; i++)
|
||||
add_offset(liga[i], c);
|
||||
liga_set[0] = c->pop_pack(false);
|
||||
|
||||
add_liga_header(coverage, 1, c);
|
||||
add_offset(liga_set[0], c);
|
||||
liga_subst[2] = c->pop_pack(false);
|
||||
|
||||
// LigaSubst 2
|
||||
coverage = add_coverage(0, 1, c);
|
||||
for (int i = 1; i >= 0; i--) {
|
||||
start_object (large_string.c_str(), liga_size, c);
|
||||
add_virtual_offset(coverage, c);
|
||||
liga[i] = c->pop_pack (false);
|
||||
}
|
||||
|
||||
add_liga_set_header(1, c);
|
||||
add_virtual_offset(coverage, c);
|
||||
add_offset(liga[1], c);
|
||||
liga_set[1] = c->pop_pack(false);
|
||||
|
||||
add_liga_set_header(1, c);
|
||||
add_virtual_offset(coverage, c);
|
||||
add_offset(liga[0], c);
|
||||
liga_set[0] = c->pop_pack(false);
|
||||
|
||||
add_liga_header(coverage, 2, c);
|
||||
add_offset(liga_set[0], c);
|
||||
add_offset(liga_set[1], c);
|
||||
liga_subst[1] = c->pop_pack(false);
|
||||
|
||||
// LigaSubst 1
|
||||
coverage = add_coverage(0, 0, c);
|
||||
for (int i = 1; i >= 0; i--) {
|
||||
start_object (large_string.c_str(), liga_size, c);
|
||||
add_virtual_offset(coverage, c);
|
||||
liga[i] = c->pop_pack (false);
|
||||
}
|
||||
|
||||
add_liga_set_header(2, c);
|
||||
add_virtual_offset(coverage, c);
|
||||
for (unsigned i = 0; i < 2; i++)
|
||||
add_offset(liga[i], c);
|
||||
liga_set[0] = c->pop_pack(false);
|
||||
|
||||
add_liga_header(coverage, 1, c);
|
||||
add_offset(liga_set[0], c);
|
||||
liga_subst[0] = c->pop_pack(false);
|
||||
|
||||
for (int l = 2; l >= 0; l--) {
|
||||
liga_subst[l] = add_extension(liga_subst[l], 4, c);
|
||||
}
|
||||
|
||||
start_lookup (7, 3, c);
|
||||
for (unsigned l = 0; l < 3; l++) {
|
||||
add_offset(liga_subst[l], c);
|
||||
}
|
||||
|
||||
unsigned lookup = finish_lookup (c);
|
||||
|
||||
unsigned lookup_list = add_lookup_list (&lookup, 1, c);
|
||||
|
||||
add_gsubgpos_header (lookup_list, c);
|
||||
|
||||
c->end_serialize();
|
||||
}
|
||||
|
||||
static void test_sort_shortest ()
|
||||
{
|
||||
size_t buffer_size = 100;
|
||||
@@ -2113,6 +2340,75 @@ static void test_resolve_with_basic_mark_base_pos_1_split ()
|
||||
free (expected_buffer);
|
||||
}
|
||||
|
||||
static void test_resolve_with_basic_liga_split ()
|
||||
{
|
||||
size_t buffer_size = 200000;
|
||||
void* buffer = malloc (buffer_size);
|
||||
assert (buffer);
|
||||
hb_serialize_context_t c (buffer, buffer_size);
|
||||
populate_serializer_with_large_liga<1, 1, 2, 40000>(&c, false);
|
||||
|
||||
void* expected_buffer = malloc (buffer_size);
|
||||
assert (expected_buffer);
|
||||
hb_serialize_context_t e (expected_buffer, buffer_size);
|
||||
populate_serializer_with_large_liga<2, 1, 1, 40000>(&e, false);
|
||||
|
||||
run_resolve_overflow_test ("test_resolve_with_basic_liga_split",
|
||||
c,
|
||||
e,
|
||||
20,
|
||||
true,
|
||||
HB_TAG('G', 'S', 'U', 'B'));
|
||||
free (buffer);
|
||||
free (expected_buffer);
|
||||
}
|
||||
|
||||
static void test_resolve_with_liga_split_move ()
|
||||
{
|
||||
size_t buffer_size = 400000;
|
||||
void* buffer = malloc (buffer_size);
|
||||
assert (buffer);
|
||||
hb_serialize_context_t c (buffer, buffer_size);
|
||||
populate_serializer_with_large_liga<1, 6, 2, 16000>(&c, true);
|
||||
|
||||
void* expected_buffer = malloc (buffer_size);
|
||||
assert (expected_buffer);
|
||||
hb_serialize_context_t e (expected_buffer, buffer_size);
|
||||
populate_serializer_with_large_liga<3, 2, 2, 16000>(&e, true);
|
||||
|
||||
run_resolve_overflow_test ("test_resolve_with_liga_split_move",
|
||||
c,
|
||||
e,
|
||||
20,
|
||||
true,
|
||||
HB_TAG('G', 'S', 'U', 'B'));
|
||||
free (buffer);
|
||||
free (expected_buffer);
|
||||
}
|
||||
|
||||
static void test_resolve_with_liga_split_overlapping_clone ()
|
||||
{
|
||||
size_t buffer_size = 400000;
|
||||
void* buffer = malloc (buffer_size);
|
||||
assert (buffer);
|
||||
hb_serialize_context_t c (buffer, buffer_size);
|
||||
populate_serializer_with_large_liga<1, 2, 3, 30000>(&c, true);
|
||||
|
||||
void* expected_buffer = malloc (buffer_size);
|
||||
assert (expected_buffer);
|
||||
hb_serialize_context_t e (expected_buffer, buffer_size);
|
||||
populate_serializer_with_large_liga_overlapping_clone_result(&e);
|
||||
|
||||
run_resolve_overflow_test ("test_resolve_with_liga_split_overlapping_clone",
|
||||
c,
|
||||
e,
|
||||
20,
|
||||
true,
|
||||
HB_TAG('G', 'S', 'U', 'B'));
|
||||
free (buffer);
|
||||
free (expected_buffer);
|
||||
}
|
||||
|
||||
static void test_resolve_overflows_via_splitting_spaces ()
|
||||
{
|
||||
size_t buffer_size = 160000;
|
||||
@@ -2257,6 +2553,32 @@ test_repack_last ()
|
||||
free (expected_buffer);
|
||||
}
|
||||
|
||||
static void
|
||||
test_dont_duplicate_virtual ()
|
||||
{
|
||||
size_t buffer_size = 200000;
|
||||
void* buffer = malloc (buffer_size);
|
||||
assert (buffer);
|
||||
hb_serialize_context_t c (buffer, buffer_size);
|
||||
populate_serializer_virtual (&c, true);
|
||||
|
||||
void* expected_buffer = malloc (buffer_size);
|
||||
assert (expected_buffer);
|
||||
hb_serialize_context_t e (expected_buffer, buffer_size);
|
||||
populate_serializer_virtual (&e, false);
|
||||
|
||||
run_resolve_overflow_test ("test_dont_duplicate_virtual",
|
||||
c,
|
||||
e,
|
||||
20,
|
||||
false,
|
||||
HB_TAG('a', 'b', 'c', 'd'),
|
||||
true);
|
||||
|
||||
free (buffer);
|
||||
free (expected_buffer);
|
||||
}
|
||||
|
||||
// TODO(garretrieger): update will_overflow tests to check the overflows array.
|
||||
// TODO(garretrieger): add tests for priority raising.
|
||||
|
||||
@@ -2294,6 +2616,10 @@ main (int argc, char **argv)
|
||||
test_resolve_with_pair_pos_2_split_with_device_tables ();
|
||||
test_resolve_with_close_to_limit_pair_pos_2_split ();
|
||||
test_resolve_with_basic_mark_base_pos_1_split ();
|
||||
test_resolve_with_basic_liga_split ();
|
||||
test_resolve_with_liga_split_move ();
|
||||
test_dont_duplicate_virtual ();
|
||||
test_resolve_with_liga_split_overlapping_clone ();
|
||||
|
||||
// TODO(grieger): have run overflow tests compare graph equality not final packed binary.
|
||||
// TODO(grieger): split test where multiple subtables in one lookup are split to test link ordering.
|
||||
|
||||
Reference in new issue
Block a user