harfbuzz/src/hb-ot-kern-table.hh

487 lines
13 KiB
C++
Raw Normal View History

/*
* 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"
2018-10-09 05:09:48 +02:00
#include "hb-ot-shape.hh"
#include "hb-ot-layout-gsubgpos.hh"
template <typename Driver>
struct hb_kern_machine_t
{
hb_kern_machine_t (const Driver &driver_) : driver (driver_) {}
2018-10-09 05:09:48 +02:00
inline void kern (const hb_ot_shape_plan_t *plan,
hb_font_t *font,
hb_buffer_t *buffer) const
{
if (!plan->kerning_requested) return;
OT::hb_ot_apply_context_t c (1, font, buffer);
hb_mask_t kern_mask = plan->kern_mask;
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);
hb_position_t kern1 = kern >> 1;
hb_position_t kern2 = kern - kern1;
if (horizontal)
{
pos[i].x_advance += kern1;
pos[j].x_advance += kern2;
pos[j].x_offset += kern2;
}
else
{
pos[i].y_advance += kern1;
pos[j].y_advance += kern2;
pos[j].y_offset += kern2;
}
buffer->unsafe_to_break (i, j + 1);
idx = skippy_iter.idx;
}
}
const Driver &driver;
2018-10-09 05:09:48 +02:00
};
/*
* 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 {
2017-11-02 01:12:26 +01:00
struct hb_glyph_pair_t
{
hb_codepoint_t left;
hb_codepoint_t right;
};
2017-11-02 01:12:26 +01:00
struct KernPair
2017-11-02 00:54:56 +01:00
{
2017-11-02 01:12:26 +01:00
inline int get_kerning (void) const
{ return value; }
inline int cmp (const hb_glyph_pair_t &o) const
2017-11-02 00:54:56 +01:00
{
2017-11-02 01:12:26 +01:00
int ret = left.cmp (o.left);
if (ret) return ret;
return right.cmp (o.right);
2017-11-02 00:54:56 +01:00
}
inline bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
2017-11-02 01:12:26 +01:00
return_trace (c->check_struct (this));
}
2017-11-02 00:54:56 +01:00
2017-11-02 01:12:26 +01:00
protected:
GlyphID left;
GlyphID right;
FWORD value;
public:
DEFINE_SIZE_STATIC (6);
};
2017-11-02 00:54:56 +01:00
2017-11-02 01:12:26 +01:00
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 ();
2017-11-02 00:54:56 +01:00
}
2017-11-02 01:12:26 +01:00
inline bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (pairs.sanitize (c));
}
protected:
BinSearchArrayOf<KernPair> pairs; /* Array of kerning pairs. */
public:
DEFINE_SIZE_ARRAY (8, pairs);
2017-11-02 00:54:56 +01:00
};
2017-11-04 17:01:11 +01:00
struct KernClassTable
2017-11-02 00:54:56 +01:00
{
2017-11-04 17:01:11 +01:00
inline unsigned int get_class (hb_codepoint_t g) const { return classes[g - firstGlyph]; }
inline bool sanitize (hb_sanitize_context_t *c) const
2017-11-02 02:33:09 +01:00
{
2017-11-04 17:01:11 +01:00
TRACE_SANITIZE (this);
return_trace (firstGlyph.sanitize (c) && classes.sanitize (c));
2017-11-02 02:33:09 +01:00
}
2017-11-04 17:01:11 +01:00
protected:
HBUINT16 firstGlyph; /* First glyph in class range. */
ArrayOf<HBUINT16> classes; /* Glyph classes. */
2017-11-04 17:01:11 +01:00
public:
DEFINE_SIZE_ARRAY (4, classes);
};
struct KernSubTableFormat2
{
inline int get_kerning (hb_codepoint_t left, hb_codepoint_t right, const char *end) const
2017-11-02 00:54:56 +01:00
{
2017-11-04 17:01:11 +01:00
unsigned int l = (this+leftClassTable).get_class (left);
unsigned int r = (this+rightClassTable).get_class (right);
unsigned int offset = l + r;
const FWORD *arr = &(this+array);
if (unlikely ((const void *) arr < (const void *) this || (const void *) arr >= (const void *) end))
return 0;
const FWORD *v = &StructAtOffset<FWORD> (arr, offset);
if (unlikely ((const void *) v < (const void *) arr || (const void *) (v + 1) > (const void *) end))
return 0;
return *v;
2017-11-02 00:54:56 +01:00
}
inline bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
2017-11-04 17:01:11 +01:00
return_trace (rowWidth.sanitize (c) &&
leftClassTable.sanitize (c, this) &&
rightClassTable.sanitize (c, this) &&
array.sanitize (c, this));
2017-11-02 00:54:56 +01:00
}
2017-11-04 17:01:11 +01:00
protected:
HBUINT16 rowWidth; /* The width, in bytes, of a row in the table. */
2017-11-04 17:01:11 +01:00
OffsetTo<KernClassTable>
leftClassTable; /* Offset from beginning of this subtable to
* left-hand class table. */
OffsetTo<KernClassTable>
rightClassTable;/* Offset from beginning of this subtable to
* right-hand class table. */
OffsetTo<FWORD>
array; /* Offset from beginning of this subtable to
* the start of the kerning array. */
public:
DEFINE_SIZE_MIN (8);
2017-11-02 00:54:56 +01:00
};
struct KernSubTable
{
inline int get_kerning (hb_codepoint_t left, hb_codepoint_t right, const char *end, unsigned int format) const
2017-11-02 02:33:09 +01:00
{
switch (format) {
case 0: return u.format0.get_kerning (left, right);
case 2: return u.format2.get_kerning (left, right, end);
2017-11-02 00:54:56 +01:00
default:return 0;
}
}
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 2: return_trace (u.format2.sanitize (c));
default:return_trace (true);
}
}
protected:
union {
KernSubTableFormat0 format0;
KernSubTableFormat2 format2;
} u;
public:
DEFINE_SIZE_MIN (0);
};
template <typename T>
struct KernSubTableWrapper
{
/* https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern */
inline const T* thiz (void) const { return static_cast<const T *> (this); }
2017-11-02 02:33:09 +01:00
inline bool is_horizontal (void) const
2018-10-08 04:58:06 +02:00
{ return (thiz()->coverage & T::CheckFlags) == T::CheckHorizontal; }
2017-11-02 02:33:09 +01:00
inline bool is_override (void) const
2018-10-08 04:58:06 +02:00
{ return bool (thiz()->coverage & T::Override); }
2017-11-02 02:33:09 +01:00
inline int get_kerning (hb_codepoint_t left, hb_codepoint_t right, const char *end) const
{ return thiz()->subtable.get_kerning (left, right, end, thiz()->format); }
2017-11-02 02:33:09 +01:00
inline int get_h_kerning (hb_codepoint_t left, hb_codepoint_t right, const char *end) const
{ return is_horizontal () ? get_kerning (left, right, end) : 0; }
2017-11-02 02:33:09 +01:00
inline unsigned int get_size (void) const { return thiz()->length; }
inline bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
2017-11-02 00:54:56 +01:00
return_trace (c->check_struct (thiz()) &&
thiz()->length >= T::min_size &&
c->check_array (thiz(), thiz()->length, 1) &&
2017-11-04 17:01:11 +01:00
thiz()->subtable.sanitize (c, thiz()->format));
}
};
template <typename T>
struct KernTable
{
/* https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern */
inline const T* thiz (void) const { return static_cast<const T *> (this); }
inline int get_h_kerning (hb_codepoint_t left, hb_codepoint_t right, unsigned int table_length) const
2017-11-02 02:33:09 +01:00
{
int v = 0;
2018-09-10 23:29:26 +02:00
const typename T::SubTableWrapper *st = CastP<typename T::SubTableWrapper> (&thiz()->dataZ);
2017-11-02 02:33:09 +01:00
unsigned int count = thiz()->nTables;
for (unsigned int i = 0; i < count; i++)
{
if (st->is_override ())
v = 0;
v += st->get_h_kerning (left, right, table_length + (const char *) this);
2017-11-02 02:33:09 +01:00
st = &StructAfter<typename T::SubTableWrapper> (*st);
}
return v;
}
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);
2018-09-10 23:29:26 +02:00
const typename T::SubTableWrapper *st = CastP<typename T::SubTableWrapper> (&thiz()->dataZ);
2017-11-02 00:54:56 +01:00
unsigned int count = thiz()->nTables;
for (unsigned int i = 0; i < count; i++)
{
if (unlikely (!st->sanitize (c)))
return_trace (false);
st = &StructAfter<typename T::SubTableWrapper> (*st);
}
return_trace (true);
}
};
struct KernOT : KernTable<KernOT>
{
friend struct KernTable<KernOT>;
static const uint16_t VERSION = 0x0000u;
struct SubTableWrapper : KernSubTableWrapper<SubTableWrapper>
{
friend struct KernSubTableWrapper<SubTableWrapper>;
2018-10-08 04:58:06 +02:00
enum Coverage
{
Direction = 0x01u,
Minimum = 0x02u,
CrossStream = 0x04u,
Override = 0x08u,
2017-11-02 02:33:09 +01:00
2018-10-08 04:58:06 +02:00
Variation = 0x00u, /* Not supported. */
2017-11-02 02:33:09 +01:00
2018-10-08 04:58:06 +02:00
CheckFlags = 0x07u,
CheckHorizontal = 0x01u
2017-11-02 02:33:09 +01:00
};
protected:
HBUINT16 versionZ; /* Unused. */
HBUINT16 length; /* Length of the subtable (including this header). */
HBUINT8 format; /* Subtable format. */
HBUINT8 coverage; /* Coverage bits. */
2017-11-02 00:54:56 +01:00
KernSubTable subtable; /* Subtable data. */
public:
2017-11-02 00:54:56 +01:00
DEFINE_SIZE_MIN (6);
};
protected:
2018-09-10 23:29:26 +02:00
HBUINT16 version; /* Version--0x0000u */
HBUINT16 nTables; /* Number of subtables in the kerning table. */
UnsizedArrayOf<HBUINT8> dataZ;
public:
2018-09-10 23:29:26 +02:00
DEFINE_SIZE_ARRAY (4, dataZ);
};
struct KernAAT : KernTable<KernAAT>
{
friend struct KernTable<KernAAT>;
static const uint32_t VERSION = 0x00010000u;
struct SubTableWrapper : KernSubTableWrapper<SubTableWrapper>
{
friend struct KernSubTableWrapper<SubTableWrapper>;
2018-10-08 04:58:06 +02:00
enum Coverage
{
Direction = 0x80u,
CrossStream = 0x40u,
Variation = 0x20u,
2017-11-02 02:33:09 +01:00
2018-10-08 04:58:06 +02:00
Override = 0x00u, /* Not supported. */
2017-11-02 02:33:09 +01:00
2018-10-08 04:58:06 +02:00
CheckFlags = 0xE0u,
CheckHorizontal = 0x00u
2017-11-02 02:33:09 +01:00
};
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. */
2017-11-02 00:54:56 +01:00
KernSubTable subtable; /* Subtable data. */
public:
2017-11-02 00:54:56 +01:00
DEFINE_SIZE_MIN (8);
};
protected:
2018-09-10 23:29:26 +02:00
HBUINT32 version; /* Version--0x00010000u */
HBUINT32 nTables; /* Number of subtables in the kerning table. */
UnsizedArrayOf<HBUINT8> dataZ;
public:
2018-09-10 23:29:26 +02:00
DEFINE_SIZE_ARRAY (8, dataZ);
};
struct kern
{
static const hb_tag_t tableTag = HB_OT_TAG_kern;
inline int get_h_kerning (hb_codepoint_t left, hb_codepoint_t right, unsigned int table_length) const
2017-11-02 02:33:09 +01:00
{
switch (u.major) {
case 0: return u.ot.get_h_kerning (left, right, table_length);
case 1: return u.aat.get_h_kerning (left, right, table_length);
2017-11-02 02:33:09 +01:00
default:return 0;
}
}
inline bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
if (!u.major.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);
}
}
struct accelerator_t
{
inline void init (hb_face_t *face)
{
2018-07-23 07:40:32 +02:00
blob = hb_sanitize_context_t().reference_table<kern> (face);
table = blob->as<kern> ();
2018-05-08 11:53:03 +02:00
table_length = blob->length;
}
inline void fini (void)
{
hb_blob_destroy (blob);
}
inline int get_h_kerning (hb_codepoint_t left, hb_codepoint_t right) const
{ return table->get_h_kerning (left, right, table_length); }
inline int get_kerning (hb_codepoint_t first, hb_codepoint_t second) const
{ return get_h_kerning (first, second); }
inline void apply (hb_ot_shape_plan_t *plan,
hb_font_t *font,
hb_buffer_t *buffer) const
{
if (!HB_DIRECTION_IS_HORIZONTAL (buffer->props.direction))
return;
hb_kern_machine_t<accelerator_t> machine (*this);
machine.kern (plan, font, buffer);
}
private:
hb_blob_t *blob;
const kern *table;
unsigned int table_length;
};
protected:
union {
HBUINT16 major;
KernOT ot;
KernAAT aat;
} u;
public:
DEFINE_SIZE_UNION (2, major);
};
struct kern_accelerator_t : kern::accelerator_t {};
} /* namespace OT */
#endif /* HB_OT_KERN_TABLE_HH */