/* * Copyright © 2017 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): Behdad Esfahbod */ #ifndef HB_OT_KERN_TABLE_HH #define HB_OT_KERN_TABLE_HH #include "hb-open-type.hh" #include "hb-ot-shape.hh" #include "hb-ot-layout-gsubgpos.hh" #include "hb-aat-layout-common.hh" template struct hb_kern_machine_t { hb_kern_machine_t (const Driver &driver_) : driver (driver_) {} HB_NO_SANITIZE_SIGNED_INTEGER_OVERFLOW inline void kern (hb_font_t *font, hb_buffer_t *buffer, hb_mask_t kern_mask, bool scale = true) const { OT::hb_ot_apply_context_t c (1, font, buffer); c.set_lookup_mask (kern_mask); c.set_lookup_props (OT::LookupFlag::IgnoreMarks); OT::hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c.iter_input; skippy_iter.init (&c); bool horizontal = HB_DIRECTION_IS_HORIZONTAL (buffer->props.direction); unsigned int count = buffer->len; hb_glyph_info_t *info = buffer->info; hb_glyph_position_t *pos = buffer->pos; for (unsigned int idx = 0; idx < count;) { if (!(info[idx].mask & kern_mask)) { idx++; continue; } skippy_iter.reset (idx, 1); if (!skippy_iter.next ()) { idx++; continue; } unsigned int i = idx; unsigned int j = skippy_iter.idx; hb_position_t kern = driver.get_kerning (info[i].codepoint, info[j].codepoint); if (likely (!kern)) goto skip; if (horizontal) { if (scale) kern = font->em_scale_x (kern); hb_position_t kern1 = kern >> 1; hb_position_t kern2 = kern - kern1; pos[i].x_advance += kern1; pos[j].x_advance += kern2; pos[j].x_offset += kern2; } else { if (scale) kern = font->em_scale_y (kern); hb_position_t kern1 = kern >> 1; hb_position_t kern2 = kern - kern1; pos[i].y_advance += kern1; pos[j].y_advance += kern2; pos[j].y_offset += kern2; } buffer->unsafe_to_break (i, j + 1); skip: idx = skippy_iter.idx; } } const Driver &driver; }; /* * kern -- Kerning * https://docs.microsoft.com/en-us/typography/opentype/spec/kern * https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6kern.html */ #define HB_OT_TAG_kern HB_TAG('k','e','r','n') namespace OT { struct hb_glyph_pair_t { hb_codepoint_t left; hb_codepoint_t right; }; struct KernPair { inline int get_kerning (void) const { return value; } inline int cmp (const hb_glyph_pair_t &o) const { int ret = left.cmp (o.left); if (ret) return ret; return right.cmp (o.right); } inline bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this)); } protected: GlyphID left; GlyphID right; FWORD value; public: DEFINE_SIZE_STATIC (6); }; struct KernSubTableFormat0 { inline int get_kerning (hb_codepoint_t left, hb_codepoint_t right) const { hb_glyph_pair_t pair = {left, right}; int i = pairs.bsearch (pair); if (i == -1) return 0; return pairs[i].get_kerning (); } inline bool apply (AAT::hb_aat_apply_context_t *c) const { TRACE_APPLY (this); if (!c->plan->requested_kerning) return false; hb_kern_machine_t machine (*this); machine.kern (c->font, c->buffer, c->plan->kern_mask); return_trace (true); } inline bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (pairs.sanitize (c)); } protected: BinSearchArrayOf pairs; /* Array of kerning pairs. */ public: DEFINE_SIZE_ARRAY (8, pairs); }; struct KernSubTableFormat1 { typedef void EntryData; struct driver_context_t { static const bool in_place = true; enum Flags { Push = 0x8000, /* If set, push this glyph on the kerning stack. */ DontAdvance = 0x4000, /* If set, don't advance to the next glyph * before going to the new state. */ Offset = 0x3FFF, /* Byte offset from beginning of subtable to the * value table for the glyphs on the kerning stack. */ }; inline driver_context_t (const KernSubTableFormat1 *table_, AAT::hb_aat_apply_context_t *c_) : c (c_), table (table_), /* Apparently the offset kernAction is from the beginning of the state-machine, * similar to offsets in morx table, NOT from beginning of this table, like * other subtables in kerx. Discovered via testing. */ kernAction (&table->machine + table->kernAction), depth (0) {} inline bool is_actionable (AAT::StateTableDriver *driver HB_UNUSED, const AAT::Entry *entry) { return entry->flags & Offset; } inline bool transition (AAT::StateTableDriver *driver, const AAT::Entry *entry) { hb_buffer_t *buffer = driver->buffer; unsigned int flags = entry->flags; if (flags & Push) { if (likely (depth < ARRAY_LENGTH (stack))) stack[depth++] = buffer->idx; else depth = 0; /* Probably not what CoreText does, but better? */ } if (entry->flags & Offset) { unsigned int kernIndex = AAT::MortTypes::offsetToIndex (entry->flags & Offset, &table->machine, kernAction.arrayZ); const FWORD *actions = &kernAction[kernIndex]; if (!c->sanitizer.check_array (actions, depth)) { depth = 0; return false; } hb_mask_t kern_mask = c->plan->kern_mask; for (unsigned int i = 0; i < depth; i++) { /* Apparently, when spec says "Each pops one glyph from the kerning stack * and applies the kerning value to it.", it doesn't mean it in that order. * The deepest item in the stack corresponds to the first item in the action * list. Discovered by testing. */ unsigned int idx = stack[i]; int v = *actions++; if (idx < buffer->len && buffer->info[idx].mask & kern_mask) { if (HB_DIRECTION_IS_HORIZONTAL (buffer->props.direction)) { buffer->pos[idx].x_advance += c->font->em_scale_x (v); if (HB_DIRECTION_IS_BACKWARD (buffer->props.direction)) buffer->pos[idx].x_offset += c->font->em_scale_x (v); } else { buffer->pos[idx].y_advance += c->font->em_scale_y (v); if (HB_DIRECTION_IS_BACKWARD (buffer->props.direction)) buffer->pos[idx].y_offset += c->font->em_scale_y (v); } } } depth = 0; } return true; } private: AAT::hb_aat_apply_context_t *c; const KernSubTableFormat1 *table; const UnsizedArrayOf &kernAction; unsigned int stack[8]; unsigned int depth; }; inline bool apply (AAT::hb_aat_apply_context_t *c) const { TRACE_APPLY (this); if (!c->plan->requested_kerning) return false; driver_context_t dc (this, c); AAT::StateTableDriver driver (machine, c->buffer, c->font->face); driver.drive (&dc); return_trace (true); } inline bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); /* The rest of array sanitizations are done at run-time. */ return_trace (likely (c->check_struct (this) && machine.sanitize (c))); } protected: AAT::StateTable machine; OffsetTo, HBUINT16, false> kernAction; public: DEFINE_SIZE_STATIC (10); }; struct KernClassTable { inline unsigned int get_class (hb_codepoint_t g) const { return classes[g - firstGlyph]; } inline bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this) && classes.sanitize (c)); } protected: HBUINT16 firstGlyph; /* First glyph in class range. */ ArrayOf classes; /* Glyph classes. */ public: DEFINE_SIZE_ARRAY (4, classes); }; struct KernSubTableFormat2 { inline int get_kerning (hb_codepoint_t left, hb_codepoint_t right, AAT::hb_aat_apply_context_t *c) const { /* This subtable is disabled. It's not cleaer to me *exactly* where the offests are * based from. I *think* they should be based from beginning of kern subtable wrapper, * *NOT* "this". Since we know of no fonts that use this subtable, we are disabling * it. Someday fix it and re-enable. */ return 0; unsigned int l = (this+leftClassTable).get_class (left); unsigned int r = (this+rightClassTable).get_class (right); unsigned int offset = l + r; const FWORD *v = &StructAtOffset (&(this+array), offset); #if 0 if (unlikely ((const char *) v < (const char *) &array || (const char *) v > (const char *) end - 2)) #endif return 0; return *v; } inline bool apply (AAT::hb_aat_apply_context_t *c) const { TRACE_APPLY (this); if (!c->plan->requested_kerning) return false; accelerator_t accel (*this, c); hb_kern_machine_t machine (accel); machine.kern (c->font, c->buffer, c->plan->kern_mask); return_trace (true); } struct accelerator_t { const KernSubTableFormat2 &table; AAT::hb_aat_apply_context_t *c; inline accelerator_t (const KernSubTableFormat2 &table_, AAT::hb_aat_apply_context_t *c_) : table (table_), c (c_) {} inline int get_kerning (hb_codepoint_t left, hb_codepoint_t right) const { return table.get_kerning (left, right, c); } }; inline bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (true); /* Disabled. See above. */ return_trace (c->check_struct (this) && leftClassTable.sanitize (c, this) && rightClassTable.sanitize (c, this) && array.sanitize (c, this)); } protected: HBUINT16 rowWidth; /* The width, in bytes, of a row in the table. */ OffsetTo leftClassTable; /* Offset from beginning of this subtable to * left-hand class table. */ OffsetTo rightClassTable;/* Offset from beginning of this subtable to * right-hand class table. */ OffsetTo array; /* Offset from beginning of this subtable to * the start of the kerning array. */ public: DEFINE_SIZE_MIN (8); }; struct KernSubTableFormat3 { inline int get_kerning (hb_codepoint_t left, hb_codepoint_t right) const { hb_array_t kernValue = kernValueZ.as_array (kernValueCount); hb_array_t leftClass = StructAfter > (kernValue).as_array (glyphCount); hb_array_t rightClass = StructAfter > (leftClass).as_array (glyphCount); hb_array_t kernIndex = StructAfter > (rightClass).as_array (leftClassCount * rightClassCount); unsigned int leftC = leftClass[left]; unsigned int rightC = rightClass[right]; if (unlikely (leftC >= leftClassCount || rightC >= rightClassCount)) return 0; unsigned int i = leftC * rightClassCount + rightC; return kernValue[kernIndex[i]]; } inline bool apply (AAT::hb_aat_apply_context_t *c) const { TRACE_APPLY (this); if (!c->plan->requested_kerning) return false; hb_kern_machine_t machine (*this); machine.kern (c->font, c->buffer, c->plan->kern_mask); return_trace (true); } inline bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (c->check_struct (this) && c->check_range (kernValueZ, kernValueCount * sizeof (FWORD) + glyphCount * 2 + leftClassCount * rightClassCount)); } protected: HBUINT16 glyphCount; /* The number of glyphs in this font. */ HBUINT8 kernValueCount; /* The number of kerning values. */ HBUINT8 leftClassCount; /* The number of left-hand classes. */ HBUINT8 rightClassCount;/* The number of right-hand classes. */ HBUINT8 flags; /* Set to zero (reserved for future use). */ UnsizedArrayOf kernValueZ; /* The kerning values. * Length kernValueCount. */ #if 0 UnsizedArrayOf leftClass; /* The left-hand classes. * Length glyphCount. */ UnsizedArrayOf RightClass; /* The right-hand classes. * Length glyphCount. */ UnsizedArrayOf kernIndex; /* The indices into the kernValue array. * Length leftClassCount * rightClassCount */ #endif public: DEFINE_SIZE_ARRAY (6, kernValueZ); }; struct KernSubTable { inline int get_kerning (hb_codepoint_t left, hb_codepoint_t right, unsigned int format) const { switch (format) { /* This method hooks up to hb_font_t's get_h_kerning. Only support Format0. */ case 0: return u.format0.get_kerning (left, right); default:return 0; } } inline void apply (AAT::hb_aat_apply_context_t *c, unsigned int format) const { /* TODO Switch to dispatch(). */ switch (format) { case 0: u.format0.apply (c); return; case 1: u.format1.apply (c); return; case 2: u.format2.apply (c); return; case 3: u.format3.apply (c); return; default: return; } } inline bool sanitize (hb_sanitize_context_t *c, unsigned int format) const { TRACE_SANITIZE (this); switch (format) { case 0: return_trace (u.format0.sanitize (c)); case 1: return_trace (u.format1.sanitize (c)); case 2: return_trace (u.format2.sanitize (c)); case 3: return_trace (u.format3.sanitize (c)); default:return_trace (true); } } protected: union { KernSubTableFormat0 format0; KernSubTableFormat1 format1; KernSubTableFormat2 format2; KernSubTableFormat3 format3; } u; public: DEFINE_SIZE_MIN (0); }; template struct KernSubTableWrapper { /* https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern */ inline const T* thiz (void) const { return static_cast (this); } inline bool is_supported (void) const { return !(thiz()->coverage & T::CheckFlags); } inline bool is_horizontal (void) const { return (thiz()->coverage & T::Direction) == T::CheckHorizontal; } inline bool is_override (void) const { return bool (thiz()->coverage & T::Override); } inline int get_kerning (hb_codepoint_t left, hb_codepoint_t right) const { return thiz()->subtable.get_kerning (left, right, thiz()->format); } inline int get_h_kerning (hb_codepoint_t left, hb_codepoint_t right) const { return is_supported () && is_horizontal () ? get_kerning (left, right) : 0; } inline void apply (AAT::hb_aat_apply_context_t *c) const { thiz()->subtable.apply (c, thiz()->format); } inline unsigned int get_size (void) const { return thiz()->length; } inline bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); return_trace (c->check_struct (thiz()) && thiz()->length >= T::min_size && c->check_range (thiz(), thiz()->length) && thiz()->subtable.sanitize (c, thiz()->format)); } }; template struct KernTable { /* https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern */ inline const T* thiz (void) const { return static_cast (this); } inline int get_h_kerning (hb_codepoint_t left, hb_codepoint_t right) const { int v = 0; const typename T::SubTableWrapper *st = CastP (&thiz()->dataZ); unsigned int count = thiz()->nTables; for (unsigned int i = 0; i < count; i++) { if (st->is_supported () && st->is_override ()) v = 0; v += st->get_h_kerning (left, right); st = &StructAfter (*st); } return v; } inline void apply (AAT::hb_aat_apply_context_t *c) const { c->set_lookup_index (0); const typename T::SubTableWrapper *st = CastP (&thiz()->dataZ); unsigned int count = thiz()->nTables; /* If there's an override subtable, skip subtables before that. */ unsigned int last_override = 0; for (unsigned int i = 0; i < count; i++) { if (st->is_supported () && st->is_override ()) last_override = i; st = &StructAfter (*st); } st = CastP (&thiz()->dataZ); for (unsigned int i = 0; i < count; i++) { if (!st->is_supported ()) goto skip; if (HB_DIRECTION_IS_HORIZONTAL (c->buffer->props.direction) != st->is_horizontal ()) goto skip; if (i < last_override) goto skip; if (!c->buffer->message (c->font, "start kern subtable %d", c->lookup_index)) goto skip; c->sanitizer.set_object (*st); st->apply (c); (void) c->buffer->message (c->font, "end kern subtable %d", c->lookup_index); skip: st = &StructAfter (*st); } } inline bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); if (unlikely (!c->check_struct (thiz()) || thiz()->version != T::VERSION)) return_trace (false); const typename T::SubTableWrapper *st = CastP (&thiz()->dataZ); unsigned int count = thiz()->nTables; for (unsigned int i = 0; i < count; i++) { if (unlikely (!st->sanitize (c))) return_trace (false); st = &StructAfter (*st); } return_trace (true); } }; struct KernOT : KernTable { friend struct KernTable; static const uint16_t VERSION = 0x0000u; struct SubTableWrapper : KernSubTableWrapper { friend struct KernTable; friend struct KernSubTableWrapper; enum Coverage { Direction = 0x01u, Minimum = 0x02u, CrossStream = 0x04u, Override = 0x08u, Variation = 0x00u, /* Not supported. */ CheckFlags = 0x06u, CheckHorizontal = 0x01u }; protected: HBUINT16 versionZ; /* Unused. */ HBUINT16 length; /* Length of the subtable (including this header). */ HBUINT8 format; /* Subtable format. */ HBUINT8 coverage; /* Coverage bits. */ KernSubTable subtable; /* Subtable data. */ public: DEFINE_SIZE_MIN (6); }; protected: HBUINT16 version; /* Version--0x0000u */ HBUINT16 nTables; /* Number of subtables in the kerning table. */ UnsizedArrayOf dataZ; public: DEFINE_SIZE_ARRAY (4, dataZ); }; struct KernAAT : KernTable { friend struct KernTable; static const uint32_t VERSION = 0x00010000u; struct SubTableWrapper : KernSubTableWrapper { friend struct KernTable; friend struct KernSubTableWrapper; enum Coverage { Direction = 0x80u, CrossStream = 0x40u, Variation = 0x20u, Override = 0x00u, /* Not supported. */ CheckFlags = 0x60u, CheckHorizontal = 0x00u }; protected: HBUINT32 length; /* Length of the subtable (including this header). */ HBUINT8 coverage; /* Coverage bits. */ HBUINT8 format; /* Subtable format. */ HBUINT16 tupleIndex; /* The tuple index (used for variations fonts). * This value specifies which tuple this subtable covers. */ KernSubTable subtable; /* Subtable data. */ public: DEFINE_SIZE_MIN (8); }; protected: HBUINT32 version; /* Version--0x00010000u */ HBUINT32 nTables; /* Number of subtables in the kerning table. */ UnsizedArrayOf dataZ; public: DEFINE_SIZE_ARRAY (8, dataZ); }; struct kern { static const hb_tag_t tableTag = HB_OT_TAG_kern; inline bool has_data (void) const { return u.version32 != 0; } inline int get_h_kerning (hb_codepoint_t left, hb_codepoint_t right) const { switch (u.major) { case 0: return u.ot.get_h_kerning (left, right); case 1: return u.aat.get_h_kerning (left, right); default:return 0; } } inline void apply (AAT::hb_aat_apply_context_t *c) const { /* TODO Switch to dispatch(). */ switch (u.major) { case 0: u.ot.apply (c); return; case 1: u.aat.apply (c); return; default: return; } } inline bool sanitize (hb_sanitize_context_t *c) const { TRACE_SANITIZE (this); if (!u.version32.sanitize (c)) return_trace (false); switch (u.major) { case 0: return_trace (u.ot.sanitize (c)); case 1: return_trace (u.aat.sanitize (c)); default:return_trace (true); } } protected: union { HBUINT32 version32; HBUINT16 major; KernOT ot; KernAAT aat; } u; public: DEFINE_SIZE_UNION (4, version32); }; } /* namespace OT */ #endif /* HB_OT_KERN_TABLE_HH */