mirror of
https://github.com/harfbuzz/harfbuzz.git
synced 2025-04-05 05:25:05 +00:00
Merge pull request #4711 from harfbuzz/aat-set-digest
[aat] Use set digest to speed up
This commit is contained in:
Behdad Esfahbod
GitHub
commit
31c45e841f
10 changed files with 612 additions and 119 deletions
|
|
@ -46,8 +46,9 @@ struct hb_aat_apply_context_t :
|
|||
hb_dispatch_context_t<hb_aat_apply_context_t, bool, HB_DEBUG_APPLY>
|
||||
{
|
||||
const char *get_name () { return "APPLY"; }
|
||||
template <typename T>
|
||||
return_t dispatch (const T &obj) { return obj.apply (this); }
|
||||
template <typename T, typename ...Ts>
|
||||
return_t dispatch (const T &obj, Ts&&... ds)
|
||||
{ return obj.apply (this, std::forward<Ts> (ds)...); }
|
||||
static return_t default_return_value () { return false; }
|
||||
bool stop_sublookup_iteration (return_t r) const { return r; }
|
||||
|
||||
|
|
@ -59,6 +60,9 @@ struct hb_aat_apply_context_t :
|
|||
const ankr *ankr_table;
|
||||
const OT::GDEF *gdef_table;
|
||||
const hb_sorted_vector_t<hb_aat_map_t::range_flags_t> *range_flags = nullptr;
|
||||
hb_set_digest_t machine_glyph_set = hb_set_digest_t::full ();
|
||||
hb_set_digest_t left_set = hb_set_digest_t::full ();
|
||||
hb_set_digest_t right_set = hb_set_digest_t::full ();
|
||||
hb_mask_t subtable_flags = 0;
|
||||
|
||||
/* Unused. For debug tracing only. */
|
||||
|
|
@ -81,6 +85,8 @@ struct hb_aat_apply_context_t :
|
|||
* Lookup Table
|
||||
*/
|
||||
|
||||
enum { DELETED_GLYPH = 0xFFFF };
|
||||
|
||||
template <typename T> struct Lookup;
|
||||
|
||||
template <typename T>
|
||||
|
|
@ -95,6 +101,12 @@ struct LookupFormat0
|
|||
return &arrayZ[glyph_id];
|
||||
}
|
||||
|
||||
template <typename set_t>
|
||||
void collect_glyphs (set_t &glyphs, unsigned num_glyphs) const
|
||||
{
|
||||
glyphs.add_range (0, num_glyphs - 1);
|
||||
}
|
||||
|
||||
bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
|
|
@ -123,6 +135,14 @@ struct LookupSegmentSingle
|
|||
int cmp (hb_codepoint_t g) const
|
||||
{ return g < first ? -1 : g <= last ? 0 : +1 ; }
|
||||
|
||||
template <typename set_t>
|
||||
void collect_glyphs (set_t &glyphs) const
|
||||
{
|
||||
if (first == DELETED_GLYPH)
|
||||
return;
|
||||
glyphs.add_range (first, last);
|
||||
}
|
||||
|
||||
bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
|
|
@ -153,6 +173,14 @@ struct LookupFormat2
|
|||
return v ? &v->value : nullptr;
|
||||
}
|
||||
|
||||
template <typename set_t>
|
||||
void collect_glyphs (set_t &glyphs) const
|
||||
{
|
||||
unsigned count = segments.get_length ();
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
segments[i].collect_glyphs (glyphs);
|
||||
}
|
||||
|
||||
bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
|
|
@ -184,6 +212,14 @@ struct LookupSegmentArray
|
|||
return first <= glyph_id && glyph_id <= last ? &(base+valuesZ)[glyph_id - first] : nullptr;
|
||||
}
|
||||
|
||||
template <typename set_t>
|
||||
void collect_glyphs (set_t &glyphs) const
|
||||
{
|
||||
if (first == DELETED_GLYPH)
|
||||
return;
|
||||
glyphs.add_range (first, last);
|
||||
}
|
||||
|
||||
int cmp (hb_codepoint_t g) const
|
||||
{ return g < first ? -1 : g <= last ? 0 : +1; }
|
||||
|
||||
|
|
@ -226,6 +262,14 @@ struct LookupFormat4
|
|||
return v ? v->get_value (glyph_id, this) : nullptr;
|
||||
}
|
||||
|
||||
template <typename set_t>
|
||||
void collect_glyphs (set_t &glyphs) const
|
||||
{
|
||||
unsigned count = segments.get_length ();
|
||||
for (unsigned i = 0; i < count; i++)
|
||||
segments[i].collect_glyphs (glyphs);
|
||||
}
|
||||
|
||||
bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
|
|
@ -254,6 +298,14 @@ struct LookupSingle
|
|||
|
||||
int cmp (hb_codepoint_t g) const { return glyph.cmp (g); }
|
||||
|
||||
template <typename set_t>
|
||||
void collect_glyphs (set_t &glyphs) const
|
||||
{
|
||||
if (glyph == DELETED_GLYPH)
|
||||
return;
|
||||
glyphs.add (glyph);
|
||||
}
|
||||
|
||||
bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
|
|
@ -283,6 +335,14 @@ struct LookupFormat6
|
|||
return v ? &v->value : nullptr;
|
||||
}
|
||||
|
||||
template <typename set_t>
|
||||
void collect_glyphs (set_t &glyphs) const
|
||||
{
|
||||
unsigned count = entries.get_length ();
|
||||
for (unsigned i = 0; i < count; i++)
|
||||
entries[i].collect_glyphs (glyphs);
|
||||
}
|
||||
|
||||
bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
|
|
@ -314,6 +374,16 @@ struct LookupFormat8
|
|||
&valueArrayZ[glyph_id - firstGlyph] : nullptr;
|
||||
}
|
||||
|
||||
template <typename set_t>
|
||||
void collect_glyphs (set_t &glyphs) const
|
||||
{
|
||||
if (unlikely (!glyphCount))
|
||||
return;
|
||||
if (firstGlyph == DELETED_GLYPH)
|
||||
return;
|
||||
glyphs.add_range (firstGlyph, firstGlyph + glyphCount - 1);
|
||||
}
|
||||
|
||||
bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
|
|
@ -358,6 +428,16 @@ struct LookupFormat10
|
|||
return v;
|
||||
}
|
||||
|
||||
template <typename set_t>
|
||||
void collect_glyphs (set_t &glyphs) const
|
||||
{
|
||||
if (unlikely (!glyphCount))
|
||||
return;
|
||||
if (firstGlyph == DELETED_GLYPH)
|
||||
return;
|
||||
glyphs.add_range (firstGlyph, firstGlyph + glyphCount - 1);
|
||||
}
|
||||
|
||||
bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
|
|
@ -406,6 +486,20 @@ struct Lookup
|
|||
}
|
||||
}
|
||||
|
||||
template <typename set_t>
|
||||
void collect_glyphs (set_t &glyphs, unsigned int num_glyphs) const
|
||||
{
|
||||
switch (u.format) {
|
||||
case 0: u.format0.collect_glyphs (glyphs, num_glyphs); return;
|
||||
case 2: u.format2.collect_glyphs (glyphs); return;
|
||||
case 4: u.format4.collect_glyphs (glyphs); return;
|
||||
case 6: u.format6.collect_glyphs (glyphs); return;
|
||||
case 8: u.format8.collect_glyphs (glyphs); return;
|
||||
case 10: u.format10.collect_glyphs (glyphs); return;
|
||||
default:return;
|
||||
}
|
||||
}
|
||||
|
||||
typename T::type get_class (hb_codepoint_t glyph_id,
|
||||
unsigned int num_glyphs,
|
||||
unsigned int outOfRange) const
|
||||
|
|
@ -460,8 +554,6 @@ struct Lookup
|
|||
};
|
||||
DECLARE_NULL_NAMESPACE_BYTES_TEMPLATE1 (AAT, Lookup, 2);
|
||||
|
||||
enum { DELETED_GLYPH = 0xFFFF };
|
||||
|
||||
/*
|
||||
* (Extended) State Table
|
||||
*/
|
||||
|
|
@ -512,6 +604,14 @@ struct Entry<void>
|
|||
DEFINE_SIZE_STATIC (4);
|
||||
};
|
||||
|
||||
enum Class
|
||||
{
|
||||
CLASS_END_OF_TEXT = 0,
|
||||
CLASS_OUT_OF_BOUNDS = 1,
|
||||
CLASS_DELETED_GLYPH = 2,
|
||||
CLASS_END_OF_LINE = 3,
|
||||
};
|
||||
|
||||
template <typename Types, typename Extra>
|
||||
struct StateTable
|
||||
{
|
||||
|
|
@ -524,21 +624,24 @@ struct StateTable
|
|||
STATE_START_OF_TEXT = 0,
|
||||
STATE_START_OF_LINE = 1,
|
||||
};
|
||||
enum Class
|
||||
|
||||
template <typename set_t>
|
||||
void collect_glyphs (set_t &glyphs, unsigned num_glyphs) const
|
||||
{
|
||||
CLASS_END_OF_TEXT = 0,
|
||||
CLASS_OUT_OF_BOUNDS = 1,
|
||||
CLASS_DELETED_GLYPH = 2,
|
||||
CLASS_END_OF_LINE = 3,
|
||||
};
|
||||
(this+classTable).collect_glyphs (glyphs, num_glyphs);
|
||||
}
|
||||
|
||||
int new_state (unsigned int newState) const
|
||||
{ return Types::extended ? newState : ((int) newState - (int) stateArrayTable) / (int) nClasses; }
|
||||
|
||||
unsigned int get_class (hb_codepoint_t glyph_id, unsigned int num_glyphs) const
|
||||
template <typename set_t>
|
||||
unsigned int get_class (hb_codepoint_t glyph_id,
|
||||
unsigned int num_glyphs,
|
||||
const set_t &glyphs) const
|
||||
{
|
||||
if (unlikely (glyph_id == DELETED_GLYPH)) return CLASS_DELETED_GLYPH;
|
||||
return (this+classTable).get_class (glyph_id, num_glyphs, 1);
|
||||
if (!glyphs[glyph_id]) return CLASS_OUT_OF_BOUNDS;
|
||||
return (this+classTable).get_class (glyph_id, num_glyphs, CLASS_OUT_OF_BOUNDS);
|
||||
}
|
||||
|
||||
const Entry<Extra> *get_entries () const
|
||||
|
|
@ -547,7 +650,7 @@ struct StateTable
|
|||
const Entry<Extra> &get_entry (int state, unsigned int klass) const
|
||||
{
|
||||
if (unlikely (klass >= nClasses))
|
||||
klass = StateTable::CLASS_OUT_OF_BOUNDS;
|
||||
klass = CLASS_OUT_OF_BOUNDS;
|
||||
|
||||
const HBUSHORT *states = (this+stateArrayTable).arrayZ;
|
||||
const Entry<Extra> *entries = (this+entryTable).arrayZ;
|
||||
|
|
@ -690,6 +793,15 @@ struct ClassTable
|
|||
{
|
||||
return get_class (glyph_id, outOfRange);
|
||||
}
|
||||
|
||||
template <typename set_t>
|
||||
void collect_glyphs (set_t &glyphs, unsigned num_glyphs) const
|
||||
{
|
||||
for (unsigned i = 0; i < classArray.len; i++)
|
||||
if (classArray.arrayZ[i] != CLASS_OUT_OF_BOUNDS)
|
||||
glyphs.add (firstGlyph + i);
|
||||
}
|
||||
|
||||
bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
|
|
@ -811,15 +923,15 @@ struct StateTableDriver
|
|||
using EntryT = Entry<EntryData>;
|
||||
|
||||
StateTableDriver (const StateTableT &machine_,
|
||||
hb_buffer_t *buffer_,
|
||||
hb_face_t *face_) :
|
||||
machine (machine_),
|
||||
buffer (buffer_),
|
||||
num_glyphs (face_->get_num_glyphs ()) {}
|
||||
|
||||
template <typename context_t>
|
||||
template <typename context_t, typename set_t = hb_set_digest_t>
|
||||
void drive (context_t *c, hb_aat_apply_context_t *ac)
|
||||
{
|
||||
hb_buffer_t *buffer = ac->buffer;
|
||||
|
||||
if (!c->in_place)
|
||||
buffer->clear_output ();
|
||||
|
||||
|
|
@ -854,9 +966,9 @@ struct StateTableDriver
|
|||
}
|
||||
}
|
||||
|
||||
unsigned int klass = buffer->idx < buffer->len ?
|
||||
machine.get_class (buffer->cur().codepoint, num_glyphs) :
|
||||
(unsigned) StateTableT::CLASS_END_OF_TEXT;
|
||||
unsigned int klass = likely (buffer->idx < buffer->len) ?
|
||||
machine.get_class (buffer->cur().codepoint, num_glyphs, ac->machine_glyph_set) :
|
||||
(unsigned) CLASS_END_OF_TEXT;
|
||||
DEBUG_MSG (APPLY, nullptr, "c%u at %u", klass, buffer->idx);
|
||||
const EntryT &entry = machine.get_entry (state, klass);
|
||||
const int next_state = machine.new_state (entry.newState);
|
||||
|
|
@ -896,7 +1008,7 @@ struct StateTableDriver
|
|||
const auto wouldbe_entry = machine.get_entry(StateTableT::STATE_START_OF_TEXT, klass);
|
||||
|
||||
/* 2c'. */
|
||||
if (c->is_actionable (this, wouldbe_entry))
|
||||
if (c->is_actionable (buffer, this, wouldbe_entry))
|
||||
return false;
|
||||
|
||||
/* 2c". */
|
||||
|
|
@ -907,7 +1019,7 @@ struct StateTableDriver
|
|||
const auto is_safe_to_break = [&]()
|
||||
{
|
||||
/* 1. */
|
||||
if (c->is_actionable (this, entry))
|
||||
if (c->is_actionable (buffer, this, entry))
|
||||
return false;
|
||||
|
||||
/* 2. */
|
||||
|
|
@ -920,13 +1032,13 @@ struct StateTableDriver
|
|||
return false;
|
||||
|
||||
/* 3. */
|
||||
return !c->is_actionable (this, machine.get_entry (state, StateTableT::CLASS_END_OF_TEXT));
|
||||
return !c->is_actionable (buffer, this, machine.get_entry (state, CLASS_END_OF_TEXT));
|
||||
};
|
||||
|
||||
if (!is_safe_to_break () && buffer->backtrack_len () && buffer->idx < buffer->len)
|
||||
buffer->unsafe_to_break_from_outbuffer (buffer->backtrack_len () - 1, buffer->idx + 1);
|
||||
|
||||
c->transition (this, entry);
|
||||
c->transition (buffer, this, entry);
|
||||
|
||||
state = next_state;
|
||||
DEBUG_MSG (APPLY, nullptr, "s%d", state);
|
||||
|
|
@ -944,7 +1056,6 @@ struct StateTableDriver
|
|||
|
||||
public:
|
||||
const StateTableT &machine;
|
||||
hb_buffer_t *buffer;
|
||||
unsigned int num_glyphs;
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -30,6 +30,7 @@
|
|||
|
||||
#include "hb-kern.hh"
|
||||
#include "hb-aat-layout-ankr-table.hh"
|
||||
#include "hb-set-digest.hh"
|
||||
|
||||
/*
|
||||
* kerx -- Extended Kerning
|
||||
|
|
@ -82,7 +83,7 @@ struct KernPair
|
|||
return_trace (c->check_struct (this));
|
||||
}
|
||||
|
||||
protected:
|
||||
public:
|
||||
HBGlyphID16 left;
|
||||
HBGlyphID16 right;
|
||||
FWORD value;
|
||||
|
|
@ -118,6 +119,16 @@ struct KerxSubTableFormat0
|
|||
return_trace (true);
|
||||
}
|
||||
|
||||
template <typename set_t>
|
||||
void collect_glyphs (set_t &left_set, set_t &right_set, unsigned num_glyphs) const
|
||||
{
|
||||
for (const KernPair& pair : pairs)
|
||||
{
|
||||
left_set.add (pair.left);
|
||||
right_set.add (pair.right);
|
||||
}
|
||||
}
|
||||
|
||||
struct accelerator_t
|
||||
{
|
||||
const KerxSubTableFormat0 &table;
|
||||
|
|
@ -128,7 +139,10 @@ struct KerxSubTableFormat0
|
|||
table (table_), c (c_) {}
|
||||
|
||||
int get_kerning (hb_codepoint_t left, hb_codepoint_t right) const
|
||||
{ return table.get_kerning (left, right, c); }
|
||||
{
|
||||
if (!c->left_set[left] || !c->right_set[right]) return 0;
|
||||
return table.get_kerning (left, right, c);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -228,13 +242,14 @@ struct KerxSubTableFormat1
|
|||
depth (0),
|
||||
crossStream (table->header.coverage & table->header.CrossStream) {}
|
||||
|
||||
bool is_actionable (StateTableDriver<Types, EntryData> *driver HB_UNUSED,
|
||||
bool is_actionable (hb_buffer_t *buffer HB_UNUSED,
|
||||
StateTableDriver<Types, EntryData> *driver HB_UNUSED,
|
||||
const Entry<EntryData> &entry)
|
||||
{ return Format1EntryT::performAction (entry); }
|
||||
void transition (StateTableDriver<Types, EntryData> *driver,
|
||||
void transition (hb_buffer_t *buffer,
|
||||
StateTableDriver<Types, EntryData> *driver,
|
||||
const Entry<EntryData> &entry)
|
||||
{
|
||||
hb_buffer_t *buffer = driver->buffer;
|
||||
unsigned int flags = entry.flags;
|
||||
|
||||
if (flags & Format1EntryT::Reset)
|
||||
|
|
@ -351,7 +366,7 @@ struct KerxSubTableFormat1
|
|||
|
||||
driver_context_t dc (this, c);
|
||||
|
||||
StateTableDriver<Types, EntryData> driver (machine, c->buffer, c->font->face);
|
||||
StateTableDriver<Types, EntryData> driver (machine, c->font->face);
|
||||
driver.drive (&dc, c);
|
||||
|
||||
return_trace (true);
|
||||
|
|
@ -365,12 +380,21 @@ struct KerxSubTableFormat1
|
|||
machine.sanitize (c)));
|
||||
}
|
||||
|
||||
template <typename set_t>
|
||||
void collect_glyphs (set_t &left_set, set_t &right_set, unsigned num_glyphs) const
|
||||
{
|
||||
set_t set;
|
||||
machine.collect_glyphs (set, num_glyphs);
|
||||
left_set.union_ (set);
|
||||
right_set.union_ (set);
|
||||
}
|
||||
|
||||
protected:
|
||||
KernSubTableHeader header;
|
||||
StateTable<Types, EntryData> machine;
|
||||
NNOffsetTo<UnsizedArrayOf<FWORD>, HBUINT> kernAction;
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (KernSubTableHeader::static_size + 5 * sizeof (HBUINT));
|
||||
DEFINE_SIZE_STATIC (KernSubTableHeader::static_size + (StateTable<Types, EntryData>::static_size + HBUINT::static_size));
|
||||
};
|
||||
|
||||
template <typename KernSubTableHeader>
|
||||
|
|
@ -413,6 +437,13 @@ struct KerxSubTableFormat2
|
|||
return_trace (true);
|
||||
}
|
||||
|
||||
template <typename set_t>
|
||||
void collect_glyphs (set_t &left_set, set_t &right_set, unsigned num_glyphs) const
|
||||
{
|
||||
(this+leftClassTable).collect_glyphs (left_set, num_glyphs);
|
||||
(this+rightClassTable).collect_glyphs (right_set, num_glyphs);
|
||||
}
|
||||
|
||||
struct accelerator_t
|
||||
{
|
||||
const KerxSubTableFormat2 &table;
|
||||
|
|
@ -423,7 +454,10 @@ struct KerxSubTableFormat2
|
|||
table (table_), c (c_) {}
|
||||
|
||||
int get_kerning (hb_codepoint_t left, hb_codepoint_t right) const
|
||||
{ return table.get_kerning (left, right, c); }
|
||||
{
|
||||
if (!c->left_set[left] || !c->right_set[right]) return 0;
|
||||
return table.get_kerning (left, right, c);
|
||||
}
|
||||
};
|
||||
|
||||
bool sanitize (hb_sanitize_context_t *c) const
|
||||
|
|
@ -493,14 +527,14 @@ struct KerxSubTableFormat4
|
|||
mark_set (false),
|
||||
mark (0) {}
|
||||
|
||||
bool is_actionable (StateTableDriver<Types, EntryData> *driver HB_UNUSED,
|
||||
bool is_actionable (hb_buffer_t *buffer HB_UNUSED,
|
||||
StateTableDriver<Types, EntryData> *driver HB_UNUSED,
|
||||
const Entry<EntryData> &entry)
|
||||
{ return entry.data.ankrActionIndex != 0xFFFF; }
|
||||
void transition (StateTableDriver<Types, EntryData> *driver,
|
||||
void transition (hb_buffer_t *buffer,
|
||||
StateTableDriver<Types, EntryData> *driver,
|
||||
const Entry<EntryData> &entry)
|
||||
{
|
||||
hb_buffer_t *buffer = driver->buffer;
|
||||
|
||||
if (mark_set && entry.data.ankrActionIndex != 0xFFFF && buffer->idx < buffer->len)
|
||||
{
|
||||
hb_glyph_position_t &o = buffer->cur_pos();
|
||||
|
|
@ -600,7 +634,7 @@ struct KerxSubTableFormat4
|
|||
|
||||
driver_context_t dc (this, c);
|
||||
|
||||
StateTableDriver<Types, EntryData> driver (machine, c->buffer, c->font->face);
|
||||
StateTableDriver<Types, EntryData> driver (machine, c->font->face);
|
||||
driver.drive (&dc, c);
|
||||
|
||||
return_trace (true);
|
||||
|
|
@ -614,12 +648,21 @@ struct KerxSubTableFormat4
|
|||
machine.sanitize (c)));
|
||||
}
|
||||
|
||||
template <typename set_t>
|
||||
void collect_glyphs (set_t &left_set, set_t &right_set, unsigned num_glyphs) const
|
||||
{
|
||||
set_t set;
|
||||
machine.collect_glyphs (set, num_glyphs);
|
||||
left_set.union_ (set);
|
||||
right_set.union_ (set);
|
||||
}
|
||||
|
||||
protected:
|
||||
KernSubTableHeader header;
|
||||
StateTable<Types, EntryData> machine;
|
||||
HBUINT32 flags;
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (KernSubTableHeader::static_size + 20);
|
||||
DEFINE_SIZE_STATIC (KernSubTableHeader::static_size + (StateTable<Types, EntryData>::static_size + HBUINT32::static_size));
|
||||
};
|
||||
|
||||
template <typename KernSubTableHeader>
|
||||
|
|
@ -638,7 +681,7 @@ struct KerxSubTableFormat6
|
|||
unsigned int num_glyphs = c->sanitizer.get_num_glyphs ();
|
||||
if (is_long ())
|
||||
{
|
||||
const typename U::Long &t = u.l;
|
||||
const auto &t = u.l;
|
||||
unsigned int l = (this+t.rowIndexTable).get_value_or_null (left, num_glyphs);
|
||||
unsigned int r = (this+t.columnIndexTable).get_value_or_null (right, num_glyphs);
|
||||
unsigned int offset = l + r;
|
||||
|
|
@ -651,7 +694,7 @@ struct KerxSubTableFormat6
|
|||
}
|
||||
else
|
||||
{
|
||||
const typename U::Short &t = u.s;
|
||||
const auto &t = u.s;
|
||||
unsigned int l = (this+t.rowIndexTable).get_value_or_null (left, num_glyphs);
|
||||
unsigned int r = (this+t.columnIndexTable).get_value_or_null (right, num_glyphs);
|
||||
unsigned int offset = l + r;
|
||||
|
|
@ -698,6 +741,23 @@ struct KerxSubTableFormat6
|
|||
c->check_range (this, vector))));
|
||||
}
|
||||
|
||||
template <typename set_t>
|
||||
void collect_glyphs (set_t &left_set, set_t &right_set, unsigned num_glyphs) const
|
||||
{
|
||||
if (is_long ())
|
||||
{
|
||||
const auto &t = u.l;
|
||||
(this+t.rowIndexTable).collect_glyphs (left_set, num_glyphs);
|
||||
(this+t.columnIndexTable).collect_glyphs (right_set, num_glyphs);
|
||||
}
|
||||
else
|
||||
{
|
||||
const auto &t = u.s;
|
||||
(this+t.rowIndexTable).collect_glyphs (left_set, num_glyphs);
|
||||
(this+t.columnIndexTable).collect_glyphs (right_set, num_glyphs);
|
||||
}
|
||||
}
|
||||
|
||||
struct accelerator_t
|
||||
{
|
||||
const KerxSubTableFormat6 &table;
|
||||
|
|
@ -708,7 +768,10 @@ struct KerxSubTableFormat6
|
|||
table (table_), c (c_) {}
|
||||
|
||||
int get_kerning (hb_codepoint_t left, hb_codepoint_t right) const
|
||||
{ return table.get_kerning (left, right, c); }
|
||||
{
|
||||
if (!c->left_set[left] || !c->right_set[right]) return 0;
|
||||
return table.get_kerning (left, right, c);
|
||||
}
|
||||
};
|
||||
|
||||
protected:
|
||||
|
|
@ -794,6 +857,20 @@ struct KerxSubTable
|
|||
}
|
||||
}
|
||||
|
||||
template <typename set_t>
|
||||
void collect_glyphs (set_t &left_set, set_t &right_set, unsigned num_glyphs) const
|
||||
{
|
||||
unsigned int subtable_type = get_type ();
|
||||
switch (subtable_type) {
|
||||
case 0: u.format0.collect_glyphs (left_set, right_set, num_glyphs); return;
|
||||
case 1: u.format1.collect_glyphs (left_set, right_set, num_glyphs); return;
|
||||
case 2: u.format2.collect_glyphs (left_set, right_set, num_glyphs); return;
|
||||
case 4: u.format4.collect_glyphs (left_set, right_set, num_glyphs); return;
|
||||
case 6: u.format6.collect_glyphs (left_set, right_set, num_glyphs); return;
|
||||
default: return;
|
||||
}
|
||||
}
|
||||
|
||||
bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
|
|
@ -824,6 +901,8 @@ struct KerxSubTable
|
|||
* The 'kerx' Table
|
||||
*/
|
||||
|
||||
using kern_accelerator_data_t = hb_vector_t<hb_pair_t<hb_set_digest_t, hb_set_digest_t>>;
|
||||
|
||||
template <typename T>
|
||||
struct KerxTable
|
||||
{
|
||||
|
|
@ -878,7 +957,8 @@ struct KerxTable
|
|||
return v;
|
||||
}
|
||||
|
||||
bool apply (AAT::hb_aat_apply_context_t *c) const
|
||||
bool apply (AAT::hb_aat_apply_context_t *c,
|
||||
const kern_accelerator_data_t *accel_data = nullptr) const
|
||||
{
|
||||
c->buffer->unsafe_to_concat ();
|
||||
|
||||
|
|
@ -925,6 +1005,16 @@ struct KerxTable
|
|||
if (reverse)
|
||||
c->buffer->reverse ();
|
||||
|
||||
if (accel_data)
|
||||
{
|
||||
c->left_set = (*accel_data)[i].first;
|
||||
c->right_set = (*accel_data)[i].second;
|
||||
}
|
||||
else
|
||||
{
|
||||
c->left_set = c->right_set = hb_set_digest_t::full ();
|
||||
}
|
||||
|
||||
{
|
||||
/* See comment in sanitize() for conditional here. */
|
||||
hb_sanitize_with_object_t with (&c->sanitizer, i < count - 1 ? st : (const SubTable *) nullptr);
|
||||
|
|
@ -989,6 +1079,49 @@ struct KerxTable
|
|||
|
||||
return_trace (true);
|
||||
}
|
||||
|
||||
kern_accelerator_data_t create_accelerator_data (unsigned num_glyphs) const
|
||||
{
|
||||
kern_accelerator_data_t accel_data;
|
||||
|
||||
typedef typename T::SubTable SubTable;
|
||||
|
||||
const SubTable *st = &thiz()->firstSubTable;
|
||||
unsigned int count = thiz()->tableCount;
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
{
|
||||
hb_set_digest_t left_set, right_set;
|
||||
st->collect_glyphs (left_set, right_set, num_glyphs);
|
||||
accel_data.push (hb_pair (left_set, right_set));
|
||||
st = &StructAfter<SubTable> (*st);
|
||||
}
|
||||
|
||||
return accel_data;
|
||||
}
|
||||
|
||||
struct accelerator_t
|
||||
{
|
||||
accelerator_t (hb_face_t *face)
|
||||
{
|
||||
hb_sanitize_context_t sc;
|
||||
this->table = sc.reference_table<T> (face);
|
||||
this->accel_data = this->table->create_accelerator_data (face->get_num_glyphs ());
|
||||
}
|
||||
~accelerator_t ()
|
||||
{
|
||||
this->table.destroy ();
|
||||
}
|
||||
|
||||
hb_blob_t *get_blob () const { return table.get_blob (); }
|
||||
|
||||
bool apply (AAT::hb_aat_apply_context_t *c) const
|
||||
{
|
||||
return table->apply (c, &accel_data);
|
||||
}
|
||||
|
||||
hb_blob_ptr_t<T> table;
|
||||
kern_accelerator_data_t accel_data;
|
||||
};
|
||||
};
|
||||
|
||||
struct kerx : KerxTable<kerx>
|
||||
|
|
@ -1017,8 +1150,10 @@ struct kerx : KerxTable<kerx>
|
|||
DEFINE_SIZE_MIN (8);
|
||||
};
|
||||
|
||||
struct kerx_accelerator_t : kerx::accelerator_t {
|
||||
kerx_accelerator_t (hb_face_t *face) : kerx::accelerator_t (face) {}
|
||||
};
|
||||
|
||||
} /* namespace AAT */
|
||||
|
||||
|
||||
#endif /* HB_AAT_LAYOUT_KERX_TABLE_HH */
|
||||
|
|
|
|||
|
|
@ -74,15 +74,16 @@ struct RearrangementSubtable
|
|||
ret (false),
|
||||
start (0), end (0) {}
|
||||
|
||||
bool is_actionable (StateTableDriver<Types, EntryData> *driver HB_UNUSED,
|
||||
bool is_actionable (hb_buffer_t *buffer HB_UNUSED,
|
||||
StateTableDriver<Types, EntryData> *driver HB_UNUSED,
|
||||
const Entry<EntryData> &entry)
|
||||
{
|
||||
return (entry.flags & Verb) && start < end;
|
||||
}
|
||||
void transition (StateTableDriver<Types, EntryData> *driver,
|
||||
void transition (hb_buffer_t *buffer,
|
||||
StateTableDriver<Types, EntryData> *driver,
|
||||
const Entry<EntryData> &entry)
|
||||
{
|
||||
hb_buffer_t *buffer = driver->buffer;
|
||||
unsigned int flags = entry.flags;
|
||||
|
||||
if (flags & MarkFirst)
|
||||
|
|
@ -168,7 +169,7 @@ struct RearrangementSubtable
|
|||
|
||||
driver_context_t dc (this);
|
||||
|
||||
StateTableDriver<Types, EntryData> driver (machine, c->buffer, c->face);
|
||||
StateTableDriver<Types, EntryData> driver (machine, c->face);
|
||||
driver.drive (&dc, c);
|
||||
|
||||
return_trace (dc.ret);
|
||||
|
|
@ -180,10 +181,10 @@ struct RearrangementSubtable
|
|||
return_trace (machine.sanitize (c));
|
||||
}
|
||||
|
||||
protected:
|
||||
public:
|
||||
StateTable<Types, EntryData> machine;
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (16);
|
||||
DEFINE_SIZE_STATIC ((StateTable<Types, EntryData>::static_size));
|
||||
};
|
||||
|
||||
template <typename Types>
|
||||
|
|
@ -223,21 +224,19 @@ struct ContextualSubtable
|
|||
table (table_),
|
||||
subs (table+table->substitutionTables) {}
|
||||
|
||||
bool is_actionable (StateTableDriver<Types, EntryData> *driver,
|
||||
bool is_actionable (hb_buffer_t *buffer,
|
||||
StateTableDriver<Types, EntryData> *driver,
|
||||
const Entry<EntryData> &entry)
|
||||
{
|
||||
hb_buffer_t *buffer = driver->buffer;
|
||||
|
||||
if (buffer->idx == buffer->len && !mark_set)
|
||||
return false;
|
||||
|
||||
return entry.data.markIndex != 0xFFFF || entry.data.currentIndex != 0xFFFF;
|
||||
}
|
||||
void transition (StateTableDriver<Types, EntryData> *driver,
|
||||
void transition (hb_buffer_t *buffer,
|
||||
StateTableDriver<Types, EntryData> *driver,
|
||||
const Entry<EntryData> &entry)
|
||||
{
|
||||
hb_buffer_t *buffer = driver->buffer;
|
||||
|
||||
/* Looks like CoreText applies neither mark nor current substitution for
|
||||
* end-of-text if mark was not explicitly set. */
|
||||
if (buffer->idx == buffer->len && !mark_set)
|
||||
|
|
@ -328,7 +327,7 @@ struct ContextualSubtable
|
|||
|
||||
driver_context_t dc (this, c);
|
||||
|
||||
StateTableDriver<Types, EntryData> driver (machine, c->buffer, c->face);
|
||||
StateTableDriver<Types, EntryData> driver (machine, c->face);
|
||||
driver.drive (&dc, c);
|
||||
|
||||
return_trace (dc.ret);
|
||||
|
|
@ -361,13 +360,14 @@ struct ContextualSubtable
|
|||
return_trace (substitutionTables.sanitize (c, this, num_lookups));
|
||||
}
|
||||
|
||||
protected:
|
||||
public:
|
||||
StateTable<Types, EntryData>
|
||||
machine;
|
||||
protected:
|
||||
NNOffsetTo<UnsizedListOfOffset16To<Lookup<HBGlyphID16>, HBUINT, void, false>, HBUINT>
|
||||
substitutionTables;
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (20);
|
||||
DEFINE_SIZE_STATIC ((StateTable<Types, EntryData>::static_size + HBUINT::static_size));
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -464,16 +464,16 @@ struct LigatureSubtable
|
|||
ligature (table+table->ligature),
|
||||
match_length (0) {}
|
||||
|
||||
bool is_actionable (StateTableDriver<Types, EntryData> *driver HB_UNUSED,
|
||||
bool is_actionable (hb_buffer_t *buffer HB_UNUSED,
|
||||
StateTableDriver<Types, EntryData> *driver HB_UNUSED,
|
||||
const Entry<EntryData> &entry)
|
||||
{
|
||||
return LigatureEntryT::performAction (entry);
|
||||
}
|
||||
void transition (StateTableDriver<Types, EntryData> *driver,
|
||||
void transition (hb_buffer_t *buffer,
|
||||
StateTableDriver<Types, EntryData> *driver,
|
||||
const Entry<EntryData> &entry)
|
||||
{
|
||||
hb_buffer_t *buffer = driver->buffer;
|
||||
|
||||
DEBUG_MSG (APPLY, nullptr, "Ligature transition at %u", buffer->idx);
|
||||
if (entry.flags & LigatureEntryT::SetComponent)
|
||||
{
|
||||
|
|
@ -585,7 +585,7 @@ struct LigatureSubtable
|
|||
|
||||
driver_context_t dc (this, c);
|
||||
|
||||
StateTableDriver<Types, EntryData> driver (machine, c->buffer, c->face);
|
||||
StateTableDriver<Types, EntryData> driver (machine, c->face);
|
||||
driver.drive (&dc, c);
|
||||
|
||||
return_trace (dc.ret);
|
||||
|
|
@ -600,9 +600,10 @@ struct LigatureSubtable
|
|||
ligAction && component && ligature);
|
||||
}
|
||||
|
||||
protected:
|
||||
public:
|
||||
StateTable<Types, EntryData>
|
||||
machine;
|
||||
protected:
|
||||
NNOffsetTo<UnsizedArrayOf<HBUINT32>, HBUINT>
|
||||
ligAction; /* Offset to the ligature action table. */
|
||||
NNOffsetTo<UnsizedArrayOf<HBUINT16>, HBUINT>
|
||||
|
|
@ -610,7 +611,7 @@ struct LigatureSubtable
|
|||
NNOffsetTo<UnsizedArrayOf<HBGlyphID16>, HBUINT>
|
||||
ligature; /* Offset to the actual ligature lists. */
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (28);
|
||||
DEFINE_SIZE_STATIC ((StateTable<Types, EntryData>::static_size + 3 * HBUINT::static_size));
|
||||
};
|
||||
|
||||
template <typename Types>
|
||||
|
|
@ -754,16 +755,17 @@ struct InsertionSubtable
|
|||
mark (0),
|
||||
insertionAction (table+table->insertionAction) {}
|
||||
|
||||
bool is_actionable (StateTableDriver<Types, EntryData> *driver HB_UNUSED,
|
||||
bool is_actionable (hb_buffer_t *buffer HB_UNUSED,
|
||||
StateTableDriver<Types, EntryData> *driver HB_UNUSED,
|
||||
const Entry<EntryData> &entry)
|
||||
{
|
||||
return (entry.flags & (CurrentInsertCount | MarkedInsertCount)) &&
|
||||
(entry.data.currentInsertIndex != 0xFFFF ||entry.data.markedInsertIndex != 0xFFFF);
|
||||
}
|
||||
void transition (StateTableDriver<Types, EntryData> *driver,
|
||||
void transition (hb_buffer_t *buffer,
|
||||
StateTableDriver<Types, EntryData> *driver,
|
||||
const Entry<EntryData> &entry)
|
||||
{
|
||||
hb_buffer_t *buffer = driver->buffer;
|
||||
unsigned int flags = entry.flags;
|
||||
|
||||
unsigned mark_loc = buffer->out_len;
|
||||
|
|
@ -850,7 +852,7 @@ struct InsertionSubtable
|
|||
|
||||
driver_context_t dc (this, c);
|
||||
|
||||
StateTableDriver<Types, EntryData> driver (machine, c->buffer, c->face);
|
||||
StateTableDriver<Types, EntryData> driver (machine, c->face);
|
||||
driver.drive (&dc, c);
|
||||
|
||||
return_trace (dc.ret);
|
||||
|
|
@ -865,14 +867,15 @@ struct InsertionSubtable
|
|||
insertionAction);
|
||||
}
|
||||
|
||||
protected:
|
||||
public:
|
||||
StateTable<Types, EntryData>
|
||||
machine;
|
||||
protected:
|
||||
NNOffsetTo<UnsizedArrayOf<HBGlyphID16>, HBUINT>
|
||||
insertionAction; /* Byte offset from stateHeader to the start of
|
||||
* the insertion glyph table. */
|
||||
public:
|
||||
DEFINE_SIZE_STATIC (20);
|
||||
DEFINE_SIZE_STATIC ((StateTable<Types, EntryData>::static_size + HBUINT::static_size));
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -896,6 +899,89 @@ struct Feature
|
|||
DEFINE_SIZE_STATIC (12);
|
||||
};
|
||||
|
||||
|
||||
struct hb_accelerate_subtables_context_t :
|
||||
hb_dispatch_context_t<hb_accelerate_subtables_context_t>
|
||||
{
|
||||
struct hb_applicable_t
|
||||
{
|
||||
friend struct hb_accelerate_subtables_context_t;
|
||||
friend struct hb_aat_layout_lookup_accelerator_t;
|
||||
|
||||
public:
|
||||
hb_set_digest_t digest;
|
||||
|
||||
template <typename T>
|
||||
auto init_ (const T &obj_, unsigned num_glyphs, hb_priority<1>) HB_AUTO_RETURN
|
||||
(
|
||||
obj_.machine.collect_glyphs (this->digest, num_glyphs)
|
||||
)
|
||||
|
||||
template <typename T>
|
||||
void init_ (const T &obj_, unsigned num_glyphs, hb_priority<0>)
|
||||
{
|
||||
digest = digest.full ();
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void init (const T &obj_, unsigned num_glyphs)
|
||||
{
|
||||
init_ (obj_, num_glyphs, hb_prioritize);
|
||||
}
|
||||
};
|
||||
|
||||
/* Dispatch interface. */
|
||||
template <typename T>
|
||||
return_t dispatch (const T &obj)
|
||||
{
|
||||
hb_applicable_t *entry = &array[i++];
|
||||
|
||||
entry->init (obj, num_glyphs);
|
||||
|
||||
return hb_empty_t ();
|
||||
}
|
||||
static return_t default_return_value () { return hb_empty_t (); }
|
||||
|
||||
bool stop_sublookup_iteration (return_t r) const { return false; }
|
||||
|
||||
hb_accelerate_subtables_context_t (hb_applicable_t *array_, unsigned num_glyphs_) :
|
||||
hb_dispatch_context_t<hb_accelerate_subtables_context_t> (),
|
||||
array (array_), num_glyphs (num_glyphs_) {}
|
||||
|
||||
hb_applicable_t *array;
|
||||
unsigned num_glyphs;
|
||||
unsigned i = 0;
|
||||
};
|
||||
|
||||
struct hb_aat_layout_chain_accelerator_t
|
||||
{
|
||||
template <typename TChain>
|
||||
static hb_aat_layout_chain_accelerator_t *create (const TChain &chain, unsigned num_glyphs)
|
||||
{
|
||||
unsigned count = chain.get_subtable_count ();
|
||||
|
||||
unsigned size = sizeof (hb_aat_layout_chain_accelerator_t) -
|
||||
HB_VAR_ARRAY * sizeof (hb_accelerate_subtables_context_t::hb_applicable_t) +
|
||||
count * sizeof (hb_accelerate_subtables_context_t::hb_applicable_t);
|
||||
|
||||
/* The following is a calloc because when we are collecting subtables,
|
||||
* some of them might be invalid and hence not collect; as a result,
|
||||
* we might not fill in all the count entries of the subtables array.
|
||||
* Zeroing it allows the set digest to gatekeep it without having to
|
||||
* initialize it further. */
|
||||
auto *thiz = (hb_aat_layout_chain_accelerator_t *) hb_calloc (1, size);
|
||||
if (unlikely (!thiz))
|
||||
return nullptr;
|
||||
|
||||
hb_accelerate_subtables_context_t c_accelerate_subtables (thiz->subtables, num_glyphs);
|
||||
chain.dispatch (&c_accelerate_subtables);
|
||||
|
||||
return thiz;
|
||||
}
|
||||
|
||||
hb_accelerate_subtables_context_t::hb_applicable_t subtables[HB_VAR_ARRAY];
|
||||
};
|
||||
|
||||
template <typename Types>
|
||||
struct ChainSubtable
|
||||
{
|
||||
|
|
@ -987,6 +1073,8 @@ struct Chain
|
|||
{
|
||||
typedef typename Types::HBUINT HBUINT;
|
||||
|
||||
unsigned get_subtable_count () const { return subtableCount; }
|
||||
|
||||
hb_mask_t compile_flags (const hb_aat_map_builder_t *map) const
|
||||
{
|
||||
hb_mask_t flags = defaultFlags;
|
||||
|
|
@ -1027,7 +1115,8 @@ struct Chain
|
|||
return flags;
|
||||
}
|
||||
|
||||
void apply (hb_aat_apply_context_t *c) const
|
||||
void apply (hb_aat_apply_context_t *c,
|
||||
const hb_aat_layout_chain_accelerator_t *accel) const
|
||||
{
|
||||
const ChainSubtable<Types> *subtable = &StructAfter<ChainSubtable<Types>> (featureZ.as_array (featureCount));
|
||||
unsigned int count = subtableCount;
|
||||
|
|
@ -1039,6 +1128,7 @@ struct Chain
|
|||
hb_map ([&subtable] (const hb_aat_map_t::range_flags_t _) -> bool { return subtable->subFeatureFlags & (_.flags); })))
|
||||
goto skip;
|
||||
c->subtable_flags = subtable->subFeatureFlags;
|
||||
c->machine_glyph_set = accel ? accel->subtables[i].digest : hb_set_digest_t::full ();
|
||||
|
||||
if (!(subtable->get_coverage() & ChainSubtable<Types>::AllDirections) &&
|
||||
HB_DIRECTION_IS_VERTICAL (c->buffer->props.direction) !=
|
||||
|
|
@ -1100,6 +1190,21 @@ struct Chain
|
|||
|
||||
unsigned int get_size () const { return length; }
|
||||
|
||||
template <typename context_t, typename ...Ts>
|
||||
typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const
|
||||
{
|
||||
const ChainSubtable<Types> *subtable = &StructAfter<ChainSubtable<Types>> (featureZ.as_array (featureCount));
|
||||
unsigned int count = subtableCount;
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
{
|
||||
typename context_t::return_t ret = subtable->dispatch (c, std::forward<Ts> (ds)...);
|
||||
if (c->stop_sublookup_iteration (ret))
|
||||
return ret;
|
||||
subtable = &StructAfter<ChainSubtable<Types>> (*subtable);
|
||||
}
|
||||
return c->default_return_value ();
|
||||
}
|
||||
|
||||
bool sanitize (hb_sanitize_context_t *c, unsigned int version) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
|
|
@ -1151,13 +1256,69 @@ struct Chain
|
|||
* The 'mort'/'morx' Table
|
||||
*/
|
||||
|
||||
template <typename Types, hb_tag_t TAG>
|
||||
template <typename T, typename Types, hb_tag_t TAG>
|
||||
struct mortmorx
|
||||
{
|
||||
static constexpr hb_tag_t tableTag = TAG;
|
||||
|
||||
bool has_data () const { return version != 0; }
|
||||
|
||||
struct accelerator_t
|
||||
{
|
||||
accelerator_t (hb_face_t *face)
|
||||
{
|
||||
hb_sanitize_context_t sc;
|
||||
this->table = sc.reference_table<T> (face);
|
||||
|
||||
this->chain_count = table->get_chain_count ();
|
||||
|
||||
this->accels = (hb_atomic_ptr_t<hb_aat_layout_chain_accelerator_t> *) hb_calloc (this->chain_count, sizeof (*accels));
|
||||
if (unlikely (!this->accels))
|
||||
{
|
||||
this->chain_count = 0;
|
||||
this->table.destroy ();
|
||||
this->table = hb_blob_get_empty ();
|
||||
}
|
||||
}
|
||||
~accelerator_t ()
|
||||
{
|
||||
for (unsigned int i = 0; i < this->chain_count; i++)
|
||||
hb_free (this->accels[i]);
|
||||
hb_free (this->accels);
|
||||
this->table.destroy ();
|
||||
}
|
||||
|
||||
hb_blob_t *get_blob () const { return table.get_blob (); }
|
||||
|
||||
template <typename Chain>
|
||||
hb_aat_layout_chain_accelerator_t *get_accel (unsigned chain_index, const Chain &chain, unsigned num_glyphs) const
|
||||
{
|
||||
if (unlikely (chain_index >= chain_count)) return nullptr;
|
||||
|
||||
retry:
|
||||
auto *accel = accels[chain_index].get_acquire ();
|
||||
if (unlikely (!accel))
|
||||
{
|
||||
accel = hb_aat_layout_chain_accelerator_t::create (chain, num_glyphs);
|
||||
if (unlikely (!accel))
|
||||
return nullptr;
|
||||
|
||||
if (unlikely (!accels[chain_index].cmpexch (nullptr, accel)))
|
||||
{
|
||||
hb_free (accel);
|
||||
goto retry;
|
||||
}
|
||||
}
|
||||
|
||||
return accel;
|
||||
}
|
||||
|
||||
hb_blob_ptr_t<T> table;
|
||||
unsigned int chain_count;
|
||||
hb_atomic_ptr_t<hb_aat_layout_chain_accelerator_t> *accels;
|
||||
};
|
||||
|
||||
|
||||
void compile_flags (const hb_aat_map_builder_t *mapper,
|
||||
hb_aat_map_t *map) const
|
||||
{
|
||||
|
|
@ -1174,8 +1335,14 @@ struct mortmorx
|
|||
}
|
||||
}
|
||||
|
||||
unsigned get_chain_count () const
|
||||
{
|
||||
return chainCount;
|
||||
}
|
||||
|
||||
void apply (hb_aat_apply_context_t *c,
|
||||
const hb_aat_map_t &map) const
|
||||
const hb_aat_map_t &map,
|
||||
const accelerator_t &accel) const
|
||||
{
|
||||
if (unlikely (!c->buffer->successful)) return;
|
||||
|
||||
|
|
@ -1186,8 +1353,9 @@ struct mortmorx
|
|||
unsigned int count = chainCount;
|
||||
for (unsigned int i = 0; i < count; i++)
|
||||
{
|
||||
auto *chain_accel = accel.get_accel (i, *chain, c->face->get_num_glyphs ());
|
||||
c->range_flags = &map.chain_flags[i];
|
||||
chain->apply (c);
|
||||
chain->apply (c, chain_accel);
|
||||
if (unlikely (!c->buffer->successful)) return;
|
||||
chain = &StructAfter<Chain<Types>> (*chain);
|
||||
}
|
||||
|
|
@ -1227,8 +1395,15 @@ struct mortmorx
|
|||
DEFINE_SIZE_MIN (8);
|
||||
};
|
||||
|
||||
struct morx : mortmorx<ExtendedTypes, HB_AAT_TAG_morx> {};
|
||||
struct mort : mortmorx<ObsoleteTypes, HB_AAT_TAG_mort> {};
|
||||
struct morx : mortmorx<morx, ExtendedTypes, HB_AAT_TAG_morx> {};
|
||||
struct mort : mortmorx<mort, ObsoleteTypes, HB_AAT_TAG_mort> {};
|
||||
|
||||
struct morx_accelerator_t : morx::accelerator_t {
|
||||
morx_accelerator_t (hb_face_t *face) : morx::accelerator_t (face) {}
|
||||
};
|
||||
struct mort_accelerator_t : mort::accelerator_t {
|
||||
mort_accelerator_t (hb_face_t *face) : mort::accelerator_t (face) {}
|
||||
};
|
||||
|
||||
|
||||
} /* namespace AAT */
|
||||
|
|
|
|||
|
|
@ -211,14 +211,14 @@ void
|
|||
hb_aat_layout_compile_map (const hb_aat_map_builder_t *mapper,
|
||||
hb_aat_map_t *map)
|
||||
{
|
||||
const AAT::morx& morx = *mapper->face->table.morx;
|
||||
const AAT::morx& morx = *mapper->face->table.morx->table;
|
||||
if (morx.has_data ())
|
||||
{
|
||||
morx.compile_flags (mapper, map);
|
||||
return;
|
||||
}
|
||||
|
||||
const AAT::mort& mort = *mapper->face->table.mort;
|
||||
const AAT::mort& mort = *mapper->face->table.mort->table;
|
||||
if (mort.has_data ())
|
||||
{
|
||||
mort.compile_flags (mapper, map);
|
||||
|
|
@ -243,8 +243,8 @@ hb_aat_layout_compile_map (const hb_aat_map_builder_t *mapper,
|
|||
hb_bool_t
|
||||
hb_aat_layout_has_substitution (hb_face_t *face)
|
||||
{
|
||||
return face->table.morx->has_data () ||
|
||||
face->table.mort->has_data ();
|
||||
return face->table.morx->table->has_data () ||
|
||||
face->table.mort->table->has_data ();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -260,26 +260,30 @@ hb_aat_layout_substitute (const hb_ot_shape_plan_t *plan,
|
|||
hb_aat_map_t map;
|
||||
builder.compile (map);
|
||||
|
||||
hb_blob_t *morx_blob = font->face->table.morx.get_blob ();
|
||||
const AAT::morx& morx = *morx_blob->as<AAT::morx> ();
|
||||
if (morx.has_data ())
|
||||
{
|
||||
AAT::hb_aat_apply_context_t c (plan, font, buffer, morx_blob);
|
||||
if (!buffer->message (font, "start table morx")) return;
|
||||
morx.apply (&c, map);
|
||||
(void) buffer->message (font, "end table morx");
|
||||
return;
|
||||
auto &accel = *font->face->table.morx;
|
||||
const AAT::morx& morx = *accel.table;
|
||||
if (morx.has_data ())
|
||||
{
|
||||
AAT::hb_aat_apply_context_t c (plan, font, buffer, accel.get_blob ());
|
||||
if (!buffer->message (font, "start table morx")) return;
|
||||
morx.apply (&c, map, accel);
|
||||
(void) buffer->message (font, "end table morx");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
hb_blob_t *mort_blob = font->face->table.mort.get_blob ();
|
||||
const AAT::mort& mort = *mort_blob->as<AAT::mort> ();
|
||||
if (mort.has_data ())
|
||||
{
|
||||
AAT::hb_aat_apply_context_t c (plan, font, buffer, mort_blob);
|
||||
if (!buffer->message (font, "start table mort")) return;
|
||||
mort.apply (&c, map);
|
||||
(void) buffer->message (font, "end table mort");
|
||||
return;
|
||||
auto &accel = *font->face->table.mort;
|
||||
const AAT::mort& mort = *accel.table;
|
||||
if (mort.has_data ())
|
||||
{
|
||||
AAT::hb_aat_apply_context_t c (plan, font, buffer, accel.get_blob ());
|
||||
if (!buffer->message (font, "start table mort")) return;
|
||||
mort.apply (&c, map, accel);
|
||||
(void) buffer->message (font, "end table mort");
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -322,7 +326,7 @@ hb_aat_layout_remove_deleted_glyphs (hb_buffer_t *buffer)
|
|||
hb_bool_t
|
||||
hb_aat_layout_has_positioning (hb_face_t *face)
|
||||
{
|
||||
return face->table.kerx->has_data ();
|
||||
return face->table.kerx->table->has_data ();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -330,13 +334,12 @@ hb_aat_layout_position (const hb_ot_shape_plan_t *plan,
|
|||
hb_font_t *font,
|
||||
hb_buffer_t *buffer)
|
||||
{
|
||||
hb_blob_t *kerx_blob = font->face->table.kerx.get_blob ();
|
||||
const AAT::kerx& kerx = *kerx_blob->as<AAT::kerx> ();
|
||||
auto &accel = *font->face->table.kerx;
|
||||
|
||||
AAT::hb_aat_apply_context_t c (plan, font, buffer, kerx_blob);
|
||||
AAT::hb_aat_apply_context_t c (plan, font, buffer, accel.get_blob ());
|
||||
if (!buffer->message (font, "start table kerx")) return;
|
||||
c.set_ankr_table (font->face->table.ankr.get ());
|
||||
kerx.apply (&c);
|
||||
accel.apply (&c);
|
||||
(void) buffer->message (font, "end table kerx");
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -100,7 +100,7 @@ HB_OT_CORE_TABLE (OT, MVAR)
|
|||
|
||||
/* Legacy kern. */
|
||||
#ifndef HB_NO_OT_KERN
|
||||
HB_OT_CORE_TABLE (OT, kern)
|
||||
HB_OT_ACCELERATOR (OT, kern)
|
||||
#endif
|
||||
|
||||
/* OpenType shaping. */
|
||||
|
|
@ -118,9 +118,9 @@ HB_OT_CORE_TABLE (OT, BASE)
|
|||
|
||||
/* AAT shaping. */
|
||||
#ifndef HB_NO_AAT
|
||||
HB_OT_TABLE (AAT, morx)
|
||||
HB_OT_TABLE (AAT, mort)
|
||||
HB_OT_TABLE (AAT, kerx)
|
||||
HB_OT_ACCELERATOR (AAT, morx)
|
||||
HB_OT_ACCELERATOR (AAT, mort)
|
||||
HB_OT_ACCELERATOR (AAT, kerx)
|
||||
HB_OT_TABLE (AAT, ankr)
|
||||
HB_OT_TABLE (AAT, trak)
|
||||
HB_OT_TABLE (AAT, ltag)
|
||||
|
|
|
|||
|
|
@ -41,6 +41,8 @@
|
|||
#include "hb-ot-layout-gdef-table.hh"
|
||||
#include "hb-ot-layout-gsub-table.hh"
|
||||
#include "hb-ot-layout-gpos-table.hh"
|
||||
#include "hb-aat-layout-kerx-table.hh"
|
||||
#include "hb-aat-layout-morx-table.hh"
|
||||
|
||||
|
||||
void hb_ot_face_t::init0 (hb_face_t *face)
|
||||
|
|
|
|||
|
|
@ -86,6 +86,16 @@ struct KernSubTableFormat3
|
|||
leftClassCount * rightClassCount));
|
||||
}
|
||||
|
||||
template <typename set_t>
|
||||
void collect_glyphs (set_t &left_set, set_t &right_set, unsigned num_glyphs) const
|
||||
{
|
||||
set_t set;
|
||||
if (likely (glyphCount))
|
||||
set.add_range (0, glyphCount - 1);
|
||||
left_set.union_ (set);
|
||||
right_set.union_ (set);
|
||||
}
|
||||
|
||||
protected:
|
||||
KernSubTableHeader
|
||||
header;
|
||||
|
|
@ -135,16 +145,29 @@ struct KernSubTable
|
|||
switch (subtable_type) {
|
||||
case 0: return_trace (c->dispatch (u.format0));
|
||||
#ifndef HB_NO_AAT_SHAPE
|
||||
case 1: return_trace (u.header.apple ? c->dispatch (u.format1, std::forward<Ts> (ds)...) : c->default_return_value ());
|
||||
case 1: return_trace (c->dispatch (u.format1, std::forward<Ts> (ds)...));
|
||||
#endif
|
||||
case 2: return_trace (c->dispatch (u.format2));
|
||||
#ifndef HB_NO_AAT_SHAPE
|
||||
case 3: return_trace (u.header.apple ? c->dispatch (u.format3, std::forward<Ts> (ds)...) : c->default_return_value ());
|
||||
case 3: return_trace (c->dispatch (u.format3, std::forward<Ts> (ds)...));
|
||||
#endif
|
||||
default: return_trace (c->default_return_value ());
|
||||
}
|
||||
}
|
||||
|
||||
template <typename set_t>
|
||||
void collect_glyphs (set_t &left_set, set_t &right_set, unsigned num_glyphs) const
|
||||
{
|
||||
unsigned int subtable_type = get_type ();
|
||||
switch (subtable_type) {
|
||||
case 0: u.format0.collect_glyphs (left_set, right_set, num_glyphs); return;
|
||||
case 1: u.format1.collect_glyphs (left_set, right_set, num_glyphs); return;
|
||||
case 2: u.format2.collect_glyphs (left_set, right_set, num_glyphs); return;
|
||||
case 3: u.format3.collect_glyphs (left_set, right_set, num_glyphs); return;
|
||||
default: return;
|
||||
}
|
||||
}
|
||||
|
||||
bool sanitize (hb_sanitize_context_t *c) const
|
||||
{
|
||||
TRACE_SANITIZE (this);
|
||||
|
|
@ -318,8 +341,9 @@ struct kern
|
|||
}
|
||||
}
|
||||
|
||||
bool apply (AAT::hb_aat_apply_context_t *c) const
|
||||
{ return dispatch (c); }
|
||||
bool apply (AAT::hb_aat_apply_context_t *c,
|
||||
const AAT::kern_accelerator_data_t *accel_data = nullptr) const
|
||||
{ return dispatch (c, accel_data); }
|
||||
|
||||
template <typename context_t, typename ...Ts>
|
||||
typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const
|
||||
|
|
@ -343,6 +367,41 @@ struct kern
|
|||
return_trace (dispatch (c));
|
||||
}
|
||||
|
||||
AAT::kern_accelerator_data_t create_accelerator_data (unsigned num_glyphs) const
|
||||
{
|
||||
switch (get_type ()) {
|
||||
case 0: return u.ot.create_accelerator_data (num_glyphs);
|
||||
#ifndef HB_NO_AAT_SHAPE
|
||||
case 1: return u.aat.create_accelerator_data (num_glyphs);
|
||||
#endif
|
||||
default:return AAT::kern_accelerator_data_t ();
|
||||
}
|
||||
}
|
||||
|
||||
struct accelerator_t
|
||||
{
|
||||
accelerator_t (hb_face_t *face)
|
||||
{
|
||||
hb_sanitize_context_t sc;
|
||||
this->table = sc.reference_table<kern> (face);
|
||||
this->accel_data = this->table->create_accelerator_data (face->get_num_glyphs ());
|
||||
}
|
||||
~accelerator_t ()
|
||||
{
|
||||
this->table.destroy ();
|
||||
}
|
||||
|
||||
hb_blob_t *get_blob () const { return table.get_blob (); }
|
||||
|
||||
bool apply (AAT::hb_aat_apply_context_t *c) const
|
||||
{
|
||||
return table->apply (c, &accel_data);
|
||||
}
|
||||
|
||||
hb_blob_ptr_t<kern> table;
|
||||
AAT::kern_accelerator_data_t accel_data;
|
||||
};
|
||||
|
||||
protected:
|
||||
union {
|
||||
HBUINT32 version32;
|
||||
|
|
@ -356,6 +415,10 @@ struct kern
|
|||
DEFINE_SIZE_UNION (4, version32);
|
||||
};
|
||||
|
||||
struct kern_accelerator_t : kern::accelerator_t {
|
||||
kern_accelerator_t (hb_face_t *face) : kern::accelerator_t (face) {}
|
||||
};
|
||||
|
||||
} /* namespace OT */
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -4387,7 +4387,7 @@ struct hb_ot_layout_lookup_accelerator_t
|
|||
|
||||
thiz->digest.init ();
|
||||
for (auto& subtable : hb_iter (thiz->subtables, count))
|
||||
thiz->digest.add (subtable.digest);
|
||||
thiz->digest.union_ (subtable.digest);
|
||||
|
||||
#ifndef HB_NO_OT_LAYOUT_LOOKUP_CACHE
|
||||
thiz->cache_user_idx = c_accelerate_subtables.cache_user_idx;
|
||||
|
|
|
|||
|
|
@ -87,7 +87,7 @@ using OT::Layout::GPOS;
|
|||
bool
|
||||
hb_ot_layout_has_kerning (hb_face_t *face)
|
||||
{
|
||||
return face->table.kern->has_data ();
|
||||
return face->table.kern->table->has_data ();
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -103,7 +103,7 @@ hb_ot_layout_has_kerning (hb_face_t *face)
|
|||
bool
|
||||
hb_ot_layout_has_machine_kerning (hb_face_t *face)
|
||||
{
|
||||
return face->table.kern->has_state_machine ();
|
||||
return face->table.kern->table->has_state_machine ();
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -123,7 +123,7 @@ hb_ot_layout_has_machine_kerning (hb_face_t *face)
|
|||
bool
|
||||
hb_ot_layout_has_cross_kerning (hb_face_t *face)
|
||||
{
|
||||
return face->table.kern->has_cross_stream ();
|
||||
return face->table.kern->table->has_cross_stream ();
|
||||
}
|
||||
|
||||
void
|
||||
|
|
@ -132,7 +132,7 @@ hb_ot_layout_kern (const hb_ot_shape_plan_t *plan,
|
|||
hb_buffer_t *buffer)
|
||||
{
|
||||
hb_blob_t *blob = font->face->table.kern.get_blob ();
|
||||
const AAT::kern& kern = *blob->as<AAT::kern> ();
|
||||
const auto& kern = *font->face->table.kern;
|
||||
|
||||
AAT::hb_aat_apply_context_t c (plan, font, buffer, blob);
|
||||
|
||||
|
|
|
|||
|
|
@ -82,7 +82,9 @@ struct hb_set_digest_bits_pattern_t
|
|||
|
||||
void init () { mask = 0; }
|
||||
|
||||
void add (const hb_set_digest_bits_pattern_t &o) { mask |= o.mask; }
|
||||
static hb_set_digest_bits_pattern_t full () { hb_set_digest_bits_pattern_t d; d.mask = (mask_t) -1; return d; }
|
||||
|
||||
void union_ (const hb_set_digest_bits_pattern_t &o) { mask |= o.mask; }
|
||||
|
||||
void add (hb_codepoint_t g) { mask |= mask_for (g); }
|
||||
|
||||
|
|
@ -148,10 +150,12 @@ struct hb_set_digest_combiner_t
|
|||
tail.init ();
|
||||
}
|
||||
|
||||
void add (const hb_set_digest_combiner_t &o)
|
||||
static hb_set_digest_combiner_t full () { hb_set_digest_combiner_t d; d.head = head_t::full(); d.tail = tail_t::full (); return d; }
|
||||
|
||||
void union_ (const hb_set_digest_combiner_t &o)
|
||||
{
|
||||
head.add (o.head);
|
||||
tail.add (o.tail);
|
||||
head.union_ (o.head);
|
||||
tail.union_(o.tail);
|
||||
}
|
||||
|
||||
void add (hb_codepoint_t g)
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue