harfbuzz/src/hb-aat-layout-kerx-table.hh

1000 lines
29 KiB
C++
Raw Normal View History

2018-02-19 00:47:44 +01:00
/*
* Copyright © 2018 Ebrahim Byagowi
* Copyright © 2018 Google, Inc.
2018-02-19 00:47:44 +01:00
*
* 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_AAT_LAYOUT_KERX_TABLE_HH
#define HB_AAT_LAYOUT_KERX_TABLE_HH
2018-11-07 16:25:25 +01:00
#include "hb-kern.hh"
2018-11-07 16:39:39 +01:00
#include "hb-aat-layout-ankr-table.hh"
2018-02-19 00:47:44 +01:00
/*
* kerx -- Extended Kerning
* https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6kerx.html
*/
#define HB_AAT_TAG_kerx HB_TAG('k','e','r','x')
2018-02-19 00:47:44 +01:00
namespace AAT {
2018-02-19 00:47:44 +01:00
using namespace OT;
2018-02-19 00:47:44 +01:00
static inline int
kerxTupleKern (int value,
unsigned int tupleCount,
const void *base,
hb_aat_apply_context_t *c)
{
if (likely (!tupleCount || !c)) return value;
unsigned int offset = value;
const FWORD *pv = &StructAtOffset<FWORD> (base, offset);
2018-11-07 19:48:45 +01:00
if (unlikely (!c->sanitizer.check_array (pv, tupleCount))) return 0;
return *pv;
}
2018-11-07 16:39:39 +01:00
struct hb_glyph_pair_t
{
2018-11-07 16:39:39 +01:00
hb_codepoint_t left;
hb_codepoint_t right;
};
2018-11-07 16:33:46 +01:00
2018-11-07 16:39:39 +01:00
struct KernPair
{
int get_kerning () const { return value; }
2018-11-07 16:39:39 +01:00
int cmp (const hb_glyph_pair_t &o) const
2018-11-06 20:48:42 +01:00
{
2018-11-07 16:39:39 +01:00
int ret = left.cmp (o.left);
if (ret) return ret;
return right.cmp (o.right);
}
2018-11-06 20:48:42 +01:00
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
2018-11-07 16:39:39 +01:00
return_trace (c->check_struct (this));
}
2018-11-07 16:39:39 +01:00
protected:
HBGlyphID left;
HBGlyphID right;
2018-11-07 16:39:39 +01:00
FWORD value;
public:
2018-11-07 16:39:39 +01:00
DEFINE_SIZE_STATIC (6);
};
template <typename KernSubTableHeader>
2018-10-08 04:33:41 +02:00
struct KerxSubTableFormat0
2018-02-19 00:47:44 +01:00
{
int get_kerning (hb_codepoint_t left, hb_codepoint_t right,
hb_aat_apply_context_t *c = nullptr) const
2018-02-19 00:47:44 +01:00
{
2018-10-08 04:33:41 +02:00
hb_glyph_pair_t pair = {left, right};
int v = pairs.bsearch (pair).get_kerning ();
2018-11-07 16:45:25 +01:00
return kerxTupleKern (v, header.tuple_count (), this, c);
2018-02-19 00:47:44 +01:00
}
bool apply (hb_aat_apply_context_t *c) const
{
TRACE_APPLY (this);
if (!c->plan->requested_kerning)
return false;
if (header.coverage & header.Backwards)
2018-11-06 20:48:42 +01:00
return false;
accelerator_t accel (*this, c);
hb_kern_machine_t<accelerator_t> machine (accel, header.coverage & header.CrossStream);
machine.kern (c->font, c->buffer, c->plan->kern_mask);
return_trace (true);
}
2018-02-19 00:47:44 +01:00
struct accelerator_t
{
const KerxSubTableFormat0 &table;
hb_aat_apply_context_t *c;
accelerator_t (const KerxSubTableFormat0 &table_,
hb_aat_apply_context_t *c_) :
table (table_), c (c_) {}
int get_kerning (hb_codepoint_t left, hb_codepoint_t right) const
{ return table.get_kerning (left, right, c); }
};
bool sanitize (hb_sanitize_context_t *c) const
2018-02-19 00:47:44 +01:00
{
TRACE_SANITIZE (this);
2018-11-07 16:33:46 +01:00
return_trace (likely (pairs.sanitize (c)));
2018-02-19 00:47:44 +01:00
}
protected:
KernSubTableHeader header;
2018-11-07 16:33:46 +01:00
BinSearchArrayOf<KernPair, typename KernSubTableHeader::Types::HBUINT>
pairs; /* Sorted kern records. */
2018-02-19 00:47:44 +01:00
public:
DEFINE_SIZE_ARRAY (KernSubTableHeader::static_size + 16, pairs);
2018-02-19 00:47:44 +01:00
};
2018-11-07 17:02:04 +01:00
template <bool extended>
struct Format1Entry;
template <>
struct Format1Entry<true>
2018-02-19 00:47:44 +01:00
{
2018-11-07 17:02:04 +01:00
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. */
Reset = 0x2000, /* If set, reset the kerning data (clear the stack) */
Reserved = 0x1FFF, /* Not used; set to 0. */
};
2018-10-11 02:37:22 +02:00
struct EntryData
{
2018-10-11 03:18:37 +02:00
HBUINT16 kernActionIndex;/* Index into the kerning value array. If
* this index is 0xFFFF, then no kerning
* is to be performed. */
2018-10-11 02:37:22 +02:00
public:
DEFINE_SIZE_STATIC (2);
};
2018-11-07 17:20:14 +01:00
2019-01-24 17:21:41 +01:00
static bool performAction (const Entry<EntryData> &entry)
{ return entry.data.kernActionIndex != 0xFFFF; }
2018-11-07 17:20:14 +01:00
2019-01-24 17:21:41 +01:00
static unsigned int kernActionIndex (const Entry<EntryData> &entry)
{ return entry.data.kernActionIndex; }
2018-11-07 17:02:04 +01:00
};
template <>
struct Format1Entry<false>
{
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. */
Reset = 0x0000, /* Not supported? */
};
typedef void EntryData;
2018-11-07 17:20:14 +01:00
2019-01-24 17:21:41 +01:00
static bool performAction (const Entry<EntryData> &entry)
{ return entry.flags & Offset; }
2018-11-07 17:20:14 +01:00
2019-01-24 17:21:41 +01:00
static unsigned int kernActionIndex (const Entry<EntryData> &entry)
{ return entry.flags & Offset; }
2018-11-07 17:02:04 +01:00
};
template <typename KernSubTableHeader>
struct KerxSubTableFormat1
{
typedef typename KernSubTableHeader::Types Types;
typedef typename Types::HBUINT HBUINT;
typedef Format1Entry<Types::extended> Format1EntryT;
typedef typename Format1EntryT::EntryData EntryData;
2018-10-11 02:37:22 +02:00
struct driver_context_t
{
static constexpr bool in_place = true;
2018-11-07 17:02:04 +01:00
enum
2018-10-11 02:37:22 +02:00
{
2018-11-07 17:02:04 +01:00
DontAdvance = Format1EntryT::DontAdvance,
2018-10-11 02:37:22 +02:00
};
driver_context_t (const KerxSubTableFormat1 *table_,
hb_aat_apply_context_t *c_) :
2018-10-11 03:18:37 +02:00
c (c_),
2018-11-07 17:20:14 +01:00
table (table_),
2018-10-11 03:53:14 +02:00
/* 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),
2018-11-06 20:48:42 +01:00
depth (0),
crossStream (table->header.coverage & table->header.CrossStream) {}
2018-11-07 17:20:14 +01:00
bool is_actionable (StateTableDriver<Types, EntryData> *driver HB_UNUSED,
2019-01-24 17:21:41 +01:00
const Entry<EntryData> &entry)
2020-07-22 15:00:48 +02:00
{ return Format1EntryT::performAction (entry); }
void transition (StateTableDriver<Types, EntryData> *driver,
2019-01-24 17:21:41 +01:00
const Entry<EntryData> &entry)
2018-10-11 02:37:22 +02:00
{
2018-10-11 03:18:37 +02:00
hb_buffer_t *buffer = driver->buffer;
2019-01-24 17:21:41 +01:00
unsigned int flags = entry.flags;
2018-10-11 03:18:37 +02:00
2018-11-07 17:02:04 +01:00
if (flags & Format1EntryT::Reset)
2018-10-19 18:58:45 +02:00
depth = 0;
2018-10-11 03:18:37 +02:00
2018-11-07 17:02:04 +01:00
if (flags & Format1EntryT::Push)
2018-10-11 03:18:37 +02:00
{
2018-10-19 18:58:45 +02:00
if (likely (depth < ARRAY_LENGTH (stack)))
2018-10-11 03:18:37 +02:00
stack[depth++] = buffer->idx;
else
depth = 0; /* Probably not what CoreText does, but better? */
}
2018-11-12 19:56:48 +01:00
if (Format1EntryT::performAction (entry) && depth)
2018-10-11 03:18:37 +02:00
{
unsigned int tuple_count = hb_max (1u, table->header.tuple_count ());
2018-11-07 17:20:14 +01:00
unsigned int kern_idx = Format1EntryT::kernActionIndex (entry);
2018-11-28 21:24:30 +01:00
kern_idx = Types::byteOffsetToIndex (kern_idx, &table->machine, kernAction.arrayZ);
2018-11-07 17:20:14 +01:00
const FWORD *actions = &kernAction[kern_idx];
2018-11-12 20:24:36 +01:00
if (!c->sanitizer.check_array (actions, depth, tuple_count))
2018-10-11 03:18:37 +02:00
{
depth = 0;
return;
2018-10-11 03:18:37 +02:00
}
hb_mask_t kern_mask = c->plan->kern_mask;
/* From Apple 'kern' spec:
* "Each pops one glyph from the kerning stack and applies the kerning value to it.
* The end of the list is marked by an odd value... */
bool last = false;
2018-11-12 19:56:48 +01:00
while (!last && depth)
2018-10-11 03:18:37 +02:00
{
2018-11-12 19:56:48 +01:00
unsigned int idx = stack[--depth];
int v = *actions;
actions += tuple_count;
2018-11-07 20:11:48 +01:00
if (idx >= buffer->len) continue;
/* "The end of the list is marked by an odd value..." */
last = v & 1;
v &= ~1;
hb_glyph_position_t &o = buffer->pos[idx];
if (HB_DIRECTION_IS_HORIZONTAL (buffer->props.direction))
{
2018-11-07 20:11:48 +01:00
if (crossStream)
{
/* The following flag is undocumented in the spec, but described
* in the 'kern' table example. */
if (v == -0x8000)
{
o.attach_type() = ATTACH_TYPE_NONE;
o.attach_chain() = 0;
o.y_offset = 0;
}
else if (o.attach_type())
{
o.y_offset += c->font->em_scale_y (v);
buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT;
}
}
2018-11-07 20:11:48 +01:00
else if (buffer->info[idx].mask & kern_mask)
{
o.x_advance += c->font->em_scale_x (v);
o.x_offset += c->font->em_scale_x (v);
2018-11-07 20:11:48 +01:00
}
}
else
{
if (crossStream)
{
/* CoreText doesn't do crossStream kerning in vertical. We do. */
if (v == -0x8000)
{
o.attach_type() = ATTACH_TYPE_NONE;
o.attach_chain() = 0;
o.x_offset = 0;
}
else if (o.attach_type())
{
o.x_offset += c->font->em_scale_x (v);
buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT;
}
2018-11-07 20:11:48 +01:00
}
else if (buffer->info[idx].mask & kern_mask)
{
o.y_advance += c->font->em_scale_y (v);
o.y_offset += c->font->em_scale_y (v);
}
}
2018-10-11 03:18:37 +02:00
}
}
2018-10-11 02:37:22 +02:00
}
private:
2018-10-11 03:18:37 +02:00
hb_aat_apply_context_t *c;
2018-11-07 17:20:14 +01:00
const KerxSubTableFormat1 *table;
2018-10-11 03:18:37 +02:00
const UnsizedArrayOf<FWORD> &kernAction;
unsigned int stack[8];
unsigned int depth;
2018-11-06 20:48:42 +01:00
bool crossStream;
2018-10-11 02:37:22 +02:00
};
bool apply (hb_aat_apply_context_t *c) const
{
TRACE_APPLY (this);
if (!c->plan->requested_kerning &&
!(header.coverage & header.CrossStream))
return false;
2018-10-11 03:18:37 +02:00
driver_context_t dc (this, c);
2018-10-11 02:37:22 +02:00
2018-11-07 17:28:36 +01:00
StateTableDriver<Types, EntryData> driver (machine, c->buffer, c->font->face);
2018-10-11 02:37:22 +02:00
driver.drive (&dc);
return_trace (true);
}
bool sanitize (hb_sanitize_context_t *c) const
2018-02-19 00:47:44 +01:00
{
TRACE_SANITIZE (this);
/* The rest of array sanitizations are done at run-time. */
return_trace (likely (c->check_struct (this) &&
machine.sanitize (c)));
2018-02-19 00:47:44 +01:00
}
protected:
KernSubTableHeader header;
2018-11-07 17:02:04 +01:00
StateTable<Types, EntryData> machine;
2019-01-18 00:24:18 +01:00
NNOffsetTo<UnsizedArrayOf<FWORD>, HBUINT> kernAction;
2018-02-19 00:47:44 +01:00
public:
2018-11-07 17:25:55 +01:00
DEFINE_SIZE_STATIC (KernSubTableHeader::static_size + 5 * sizeof (HBUINT));
2018-02-19 00:47:44 +01:00
};
template <typename KernSubTableHeader>
2018-02-19 00:47:44 +01:00
struct KerxSubTableFormat2
{
2018-11-07 18:16:38 +01:00
typedef typename KernSubTableHeader::Types Types;
typedef typename Types::HBUINT HBUINT;
int get_kerning (hb_codepoint_t left, hb_codepoint_t right,
hb_aat_apply_context_t *c) const
2018-02-19 00:47:44 +01:00
{
unsigned int num_glyphs = c->sanitizer.get_num_glyphs ();
2018-11-07 18:16:38 +01:00
unsigned int l = (this+leftClassTable).get_class (left, num_glyphs, 0);
unsigned int r = (this+rightClassTable).get_class (right, num_glyphs, 0);
const UnsizedArrayOf<FWORD> &arrayZ = this+array;
unsigned int kern_idx = l + r;
kern_idx = Types::offsetToIndex (kern_idx, this, arrayZ.arrayZ);
const FWORD *v = &arrayZ[kern_idx];
if (unlikely (!v->sanitize (&c->sanitizer))) return 0;
2018-11-07 16:45:25 +01:00
return kerxTupleKern (*v, header.tuple_count (), this, c);
2018-02-19 00:47:44 +01:00
}
bool apply (hb_aat_apply_context_t *c) const
{
TRACE_APPLY (this);
if (!c->plan->requested_kerning)
return false;
if (header.coverage & header.Backwards)
2018-11-06 20:48:42 +01:00
return false;
accelerator_t accel (*this, c);
hb_kern_machine_t<accelerator_t> machine (accel, header.coverage & header.CrossStream);
machine.kern (c->font, c->buffer, c->plan->kern_mask);
return_trace (true);
}
struct accelerator_t
{
const KerxSubTableFormat2 &table;
hb_aat_apply_context_t *c;
accelerator_t (const KerxSubTableFormat2 &table_,
hb_aat_apply_context_t *c_) :
table (table_), c (c_) {}
int get_kerning (hb_codepoint_t left, hb_codepoint_t right) const
{ return table.get_kerning (left, right, c); }
};
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (likely (c->check_struct (this) &&
leftClassTable.sanitize (c, this) &&
rightClassTable.sanitize (c, this) &&
c->check_range (this, array)));
}
2018-02-19 00:47:44 +01:00
protected:
KernSubTableHeader header;
2018-11-07 18:16:38 +01:00
HBUINT rowWidth; /* The width, in bytes, of a row in the table. */
2019-01-18 00:24:18 +01:00
NNOffsetTo<typename Types::ClassTypeWide, HBUINT>
leftClassTable; /* Offset from beginning of this subtable to
* left-hand class table. */
2019-01-18 00:24:18 +01:00
NNOffsetTo<typename Types::ClassTypeWide, HBUINT>
rightClassTable;/* Offset from beginning of this subtable to
* right-hand class table. */
2019-01-18 00:24:18 +01:00
NNOffsetTo<UnsizedArrayOf<FWORD>, HBUINT>
2018-10-11 02:43:21 +02:00
array; /* Offset from beginning of this subtable to
* the start of the kerning array. */
2018-02-19 00:47:44 +01:00
public:
2018-11-07 18:16:38 +01:00
DEFINE_SIZE_STATIC (KernSubTableHeader::static_size + 4 * sizeof (HBUINT));
2018-02-19 00:47:44 +01:00
};
template <typename KernSubTableHeader>
2018-02-19 00:47:44 +01:00
struct KerxSubTableFormat4
{
2018-11-07 17:51:40 +01:00
typedef ExtendedTypes Types;
struct EntryData
{
HBUINT16 ankrActionIndex;/* Either 0xFFFF (for no action) or the index of
* the action to perform. */
public:
DEFINE_SIZE_STATIC (2);
};
struct driver_context_t
{
static constexpr bool in_place = true;
enum Flags
{
Mark = 0x8000, /* If set, remember this glyph as the marked glyph. */
DontAdvance = 0x4000, /* If set, don't advance to the next glyph before
* going to the new state. */
Reserved = 0x3FFF, /* Not used; set to 0. */
};
enum SubTableFlags
{
ActionType = 0xC0000000, /* A two-bit field containing the action type. */
Unused = 0x3F000000, /* Unused - must be zero. */
Offset = 0x00FFFFFF, /* Masks the offset in bytes from the beginning
* of the subtable to the beginning of the control
* point table. */
};
driver_context_t (const KerxSubTableFormat4 *table,
2020-07-18 19:44:52 +02:00
hb_aat_apply_context_t *c_) :
c (c_),
action_type ((table->flags & ActionType) >> 30),
ankrData ((HBUINT16 *) ((const char *) &table->machine + (table->flags & Offset))),
mark_set (false),
mark (0) {}
bool is_actionable (StateTableDriver<Types, EntryData> *driver HB_UNUSED,
2019-01-24 17:21:41 +01:00
const Entry<EntryData> &entry)
2020-07-18 19:44:52 +02:00
{ return entry.data.ankrActionIndex != 0xFFFF; }
void transition (StateTableDriver<Types, EntryData> *driver,
2019-01-24 17:21:41 +01:00
const Entry<EntryData> &entry)
{
hb_buffer_t *buffer = driver->buffer;
2019-01-24 17:21:41 +01:00
if (mark_set && entry.data.ankrActionIndex != 0xFFFF && buffer->idx < buffer->len)
{
hb_glyph_position_t &o = buffer->cur_pos();
switch (action_type)
{
case 0: /* Control Point Actions.*/
{
/* Indexed into glyph outline. */
/* Each action (record in ankrData) contains two 16-bit fields, so we must
double the ankrActionIndex to get the correct offset here. */
const HBUINT16 *data = &ankrData[entry.data.ankrActionIndex * 2];
if (!c->sanitizer.check_array (data, 2)) return;
unsigned int markControlPoint = *data++;
unsigned int currControlPoint = *data++;
hb_position_t markX = 0;
hb_position_t markY = 0;
hb_position_t currX = 0;
hb_position_t currY = 0;
if (!c->font->get_glyph_contour_point_for_origin (c->buffer->info[mark].codepoint,
markControlPoint,
HB_DIRECTION_LTR /*XXX*/,
&markX, &markY) ||
!c->font->get_glyph_contour_point_for_origin (c->buffer->cur ().codepoint,
currControlPoint,
HB_DIRECTION_LTR /*XXX*/,
&currX, &currY))
return;
o.x_offset = markX - currX;
o.y_offset = markY - currY;
}
break;
case 1: /* Anchor Point Actions. */
{
/* Indexed into 'ankr' table. */
/* Each action (record in ankrData) contains two 16-bit fields, so we must
double the ankrActionIndex to get the correct offset here. */
const HBUINT16 *data = &ankrData[entry.data.ankrActionIndex * 2];
if (!c->sanitizer.check_array (data, 2)) return;
unsigned int markAnchorPoint = *data++;
unsigned int currAnchorPoint = *data++;
2019-01-17 20:06:32 +01:00
const Anchor &markAnchor = c->ankr_table->get_anchor (c->buffer->info[mark].codepoint,
markAnchorPoint,
2019-01-17 23:47:29 +01:00
c->sanitizer.get_num_glyphs ());
2019-01-17 20:06:32 +01:00
const Anchor &currAnchor = c->ankr_table->get_anchor (c->buffer->cur ().codepoint,
currAnchorPoint,
2019-01-17 23:47:29 +01:00
c->sanitizer.get_num_glyphs ());
o.x_offset = c->font->em_scale_x (markAnchor.xCoordinate) - c->font->em_scale_x (currAnchor.xCoordinate);
o.y_offset = c->font->em_scale_y (markAnchor.yCoordinate) - c->font->em_scale_y (currAnchor.yCoordinate);
}
break;
case 2: /* Control Point Coordinate Actions. */
{
/* Each action contains four 16-bit fields, so we multiply the ankrActionIndex
by 4 to get the correct offset for the given action. */
const FWORD *data = (const FWORD *) &ankrData[entry.data.ankrActionIndex * 4];
if (!c->sanitizer.check_array (data, 4)) return;
int markX = *data++;
int markY = *data++;
int currX = *data++;
int currY = *data++;
o.x_offset = c->font->em_scale_x (markX) - c->font->em_scale_x (currX);
o.y_offset = c->font->em_scale_y (markY) - c->font->em_scale_y (currY);
}
break;
}
o.attach_type() = ATTACH_TYPE_MARK;
o.attach_chain() = (int) mark - (int) buffer->idx;
buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT;
}
2019-01-24 17:21:41 +01:00
if (entry.flags & Mark)
{
mark_set = true;
mark = buffer->idx;
}
}
private:
hb_aat_apply_context_t *c;
unsigned int action_type;
const HBUINT16 *ankrData;
bool mark_set;
unsigned int mark;
};
bool apply (hb_aat_apply_context_t *c) const
{
TRACE_APPLY (this);
driver_context_t dc (this, c);
2018-11-07 17:51:40 +01:00
StateTableDriver<Types, EntryData> driver (machine, c->buffer, c->font->face);
driver.drive (&dc);
return_trace (true);
}
bool sanitize (hb_sanitize_context_t *c) const
2018-02-19 00:47:44 +01:00
{
TRACE_SANITIZE (this);
/* The rest of array sanitizations are done at run-time. */
return_trace (likely (c->check_struct (this) &&
machine.sanitize (c)));
2018-02-19 00:47:44 +01:00
}
protected:
2018-11-07 17:51:40 +01:00
KernSubTableHeader header;
StateTable<Types, EntryData> machine;
HBUINT32 flags;
2018-02-19 00:47:44 +01:00
public:
DEFINE_SIZE_STATIC (KernSubTableHeader::static_size + 20);
2018-02-19 00:47:44 +01:00
};
template <typename KernSubTableHeader>
2018-02-19 00:47:44 +01:00
struct KerxSubTableFormat6
{
2018-10-11 01:58:20 +02:00
enum Flags
{
ValuesAreLong = 0x00000001,
};
bool is_long () const { return flags & ValuesAreLong; }
2018-10-11 01:58:20 +02:00
int get_kerning (hb_codepoint_t left, hb_codepoint_t right,
2020-07-18 19:44:52 +02:00
hb_aat_apply_context_t *c) const
{
unsigned int num_glyphs = c->sanitizer.get_num_glyphs ();
if (is_long ())
{
const typename U::Long &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;
2018-10-13 17:39:12 +02:00
if (unlikely (offset < l)) return 0; /* Addition overflow. */
if (unlikely (hb_unsigned_mul_overflows (offset, sizeof (FWORD32)))) return 0;
const FWORD32 *v = &StructAtOffset<FWORD32> (&(this+t.array), offset * sizeof (FWORD32));
if (unlikely (!v->sanitize (&c->sanitizer))) return 0;
2018-11-07 16:45:25 +01:00
return kerxTupleKern (*v, header.tuple_count (), &(this+vector), c);
}
else
{
const typename U::Short &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;
const FWORD *v = &StructAtOffset<FWORD> (&(this+t.array), offset * sizeof (FWORD));
if (unlikely (!v->sanitize (&c->sanitizer))) return 0;
2018-11-07 16:45:25 +01:00
return kerxTupleKern (*v, header.tuple_count (), &(this+vector), c);
}
}
bool apply (hb_aat_apply_context_t *c) const
{
TRACE_APPLY (this);
if (!c->plan->requested_kerning)
return false;
if (header.coverage & header.Backwards)
2018-11-06 20:48:42 +01:00
return false;
accelerator_t accel (*this, c);
hb_kern_machine_t<accelerator_t> machine (accel, header.coverage & header.CrossStream);
machine.kern (c->font, c->buffer, c->plan->kern_mask);
return_trace (true);
}
bool sanitize (hb_sanitize_context_t *c) const
2018-02-19 00:47:44 +01:00
{
TRACE_SANITIZE (this);
2018-04-20 18:42:58 +02:00
return_trace (likely (c->check_struct (this) &&
(is_long () ?
(
u.l.rowIndexTable.sanitize (c, this) &&
u.l.columnIndexTable.sanitize (c, this) &&
c->check_range (this, u.l.array)
) : (
u.s.rowIndexTable.sanitize (c, this) &&
u.s.columnIndexTable.sanitize (c, this) &&
c->check_range (this, u.s.array)
)) &&
2018-11-07 16:45:25 +01:00
(header.tuple_count () == 0 ||
c->check_range (this, vector))));
2018-02-19 00:47:44 +01:00
}
struct accelerator_t
{
const KerxSubTableFormat6 &table;
hb_aat_apply_context_t *c;
accelerator_t (const KerxSubTableFormat6 &table_,
hb_aat_apply_context_t *c_) :
table (table_), c (c_) {}
int get_kerning (hb_codepoint_t left, hb_codepoint_t right) const
{ return table.get_kerning (left, right, c); }
};
2018-02-19 00:47:44 +01:00
protected:
KernSubTableHeader header;
HBUINT32 flags;
HBUINT16 rowCount;
HBUINT16 columnCount;
union U
2018-10-11 01:58:20 +02:00
{
struct Long
2018-10-11 01:58:20 +02:00
{
NNOffset32To<Lookup<HBUINT32>> rowIndexTable;
NNOffset32To<Lookup<HBUINT32>> columnIndexTable;
NNOffset32To<UnsizedArrayOf<FWORD32>> array;
2018-10-11 01:58:20 +02:00
} l;
struct Short
{
NNOffset32To<Lookup<HBUINT16>> rowIndexTable;
NNOffset32To<Lookup<HBUINT16>> columnIndexTable;
NNOffset32To<UnsizedArrayOf<FWORD>> array;
} s;
2018-10-11 01:58:20 +02:00
} u;
NNOffset32To<UnsizedArrayOf<FWORD>> vector;
2018-02-19 00:47:44 +01:00
public:
DEFINE_SIZE_STATIC (KernSubTableHeader::static_size + 24);
2018-02-19 00:47:44 +01:00
};
2018-11-07 16:39:39 +01:00
struct KerxSubTableHeader
{
2018-11-07 17:51:40 +01:00
typedef ExtendedTypes Types;
2018-11-07 16:39:39 +01:00
2019-10-01 12:19:55 +02:00
unsigned tuple_count () const { return tupleCount; }
bool is_horizontal () const { return !(coverage & Vertical); }
2018-11-07 16:45:25 +01:00
2018-11-07 16:39:39 +01:00
enum Coverage
{
Vertical = 0x80000000u, /* Set if table has vertical kerning values. */
CrossStream = 0x40000000u, /* Set if table has cross-stream kerning values. */
Variation = 0x20000000u, /* Set if table has variation kerning values. */
Backwards = 0x10000000u, /* If clear, process the glyphs forwards, that
* is, from first to last in the glyph stream.
* If we, process them from last to first.
* This flag only applies to state-table based
* 'kerx' subtables (types 1 and 4). */
Reserved = 0x0FFFFF00u, /* Reserved, set to zero. */
SubtableType= 0x000000FFu, /* Subtable type. */
2018-11-07 16:39:39 +01:00
};
bool sanitize (hb_sanitize_context_t *c) const
2018-11-07 16:39:39 +01:00
{
TRACE_SANITIZE (this);
return_trace (likely (c->check_struct (this)));
}
public:
HBUINT32 length;
HBUINT32 coverage;
HBUINT32 tupleCount;
public:
DEFINE_SIZE_STATIC (12);
};
2018-11-07 17:56:36 +01:00
struct KerxSubTable
{
2018-10-09 14:28:07 +02:00
friend struct kerx;
2018-10-09 04:41:08 +02:00
unsigned int get_size () const { return u.header.length; }
unsigned int get_type () const { return u.header.coverage & u.header.SubtableType; }
template <typename context_t, typename ...Ts>
2019-05-08 05:58:43 +02:00
typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const
{
unsigned int subtable_type = get_type ();
TRACE_DISPATCH (this, subtable_type);
switch (subtable_type) {
case 0: return_trace (c->dispatch (u.format0, hb_forward<Ts> (ds)...));
case 1: return_trace (c->dispatch (u.format1, hb_forward<Ts> (ds)...));
case 2: return_trace (c->dispatch (u.format2, hb_forward<Ts> (ds)...));
case 4: return_trace (c->dispatch (u.format4, hb_forward<Ts> (ds)...));
case 6: return_trace (c->dispatch (u.format6, hb_forward<Ts> (ds)...));
2018-11-06 18:11:45 +01:00
default: return_trace (c->default_return_value ());
}
2018-02-19 00:47:44 +01:00
}
bool sanitize (hb_sanitize_context_t *c) const
2018-02-19 00:47:44 +01:00
{
TRACE_SANITIZE (this);
if (!u.header.sanitize (c) ||
u.header.length <= u.header.static_size ||
!c->check_range (this, u.header.length))
return_trace (false);
return_trace (dispatch (c));
2018-02-19 00:47:44 +01:00
}
public:
2018-02-19 00:47:44 +01:00
union {
KerxSubTableHeader header;
KerxSubTableFormat0<KerxSubTableHeader> format0;
KerxSubTableFormat1<KerxSubTableHeader> format1;
KerxSubTableFormat2<KerxSubTableHeader> format2;
KerxSubTableFormat4<KerxSubTableHeader> format4;
KerxSubTableFormat6<KerxSubTableHeader> format6;
2018-02-19 00:47:44 +01:00
} u;
public:
DEFINE_SIZE_MIN (12);
2018-02-19 00:47:44 +01:00
};
/*
* The 'kerx' Table
*/
template <typename T>
struct KerxTable
2018-02-19 00:47:44 +01:00
{
/* https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern */
const T* thiz () const { return static_cast<const T *> (this); }
2018-02-19 00:47:44 +01:00
bool has_state_machine () const
{
typedef typename T::SubTable SubTable;
const SubTable *st = &thiz()->firstSubTable;
unsigned int count = thiz()->tableCount;
for (unsigned int i = 0; i < count; i++)
{
if (st->get_type () == 1)
return true;
st = &StructAfter<SubTable> (*st);
}
return false;
}
bool has_cross_stream () const
2018-11-07 22:02:40 +01:00
{
typedef typename T::SubTable SubTable;
const SubTable *st = &thiz()->firstSubTable;
unsigned int count = thiz()->tableCount;
for (unsigned int i = 0; i < count; i++)
{
if (st->u.header.coverage & st->u.header.CrossStream)
return true;
2018-11-07 22:02:40 +01:00
st = &StructAfter<SubTable> (*st);
}
return false;
}
int get_h_kerning (hb_codepoint_t left, hb_codepoint_t right) const
{
typedef typename T::SubTable SubTable;
int v = 0;
const SubTable *st = &thiz()->firstSubTable;
unsigned int count = thiz()->tableCount;
for (unsigned int i = 0; i < count; i++)
{
if ((st->u.header.coverage & (st->u.header.Variation | st->u.header.CrossStream)) ||
!st->u.header.is_horizontal ())
continue;
v += st->get_kerning (left, right);
st = &StructAfter<SubTable> (*st);
}
return v;
}
bool apply (AAT::hb_aat_apply_context_t *c) const
2018-02-24 10:19:42 +01:00
{
typedef typename T::SubTable SubTable;
2018-11-07 22:03:09 +01:00
bool ret = false;
bool seenCrossStream = false;
c->set_lookup_index (0);
const SubTable *st = &thiz()->firstSubTable;
unsigned int count = thiz()->tableCount;
for (unsigned int i = 0; i < count; i++)
{
2018-10-09 04:41:08 +02:00
bool reverse;
if (!T::Types::extended && (st->u.header.coverage & st->u.header.Variation))
goto skip;
2018-11-07 18:32:39 +01:00
if (HB_DIRECTION_IS_HORIZONTAL (c->buffer->props.direction) != st->u.header.is_horizontal ())
2018-10-10 23:32:32 +02:00
goto skip;
2018-10-09 04:41:08 +02:00
reverse = bool (st->u.header.coverage & st->u.header.Backwards) !=
2018-10-09 04:41:08 +02:00
HB_DIRECTION_IS_BACKWARD (c->buffer->props.direction);
if (!c->buffer->message (c->font, "start subtable %d", c->lookup_index))
2018-10-10 23:32:32 +02:00
goto skip;
2018-10-09 04:41:08 +02:00
if (!seenCrossStream &&
(st->u.header.coverage & st->u.header.CrossStream))
{
/* Attach all glyphs into a chain. */
seenCrossStream = true;
hb_glyph_position_t *pos = c->buffer->pos;
unsigned int count = c->buffer->len;
for (unsigned int i = 0; i < count; i++)
{
pos[i].attach_type() = ATTACH_TYPE_CURSIVE;
pos[i].attach_chain() = HB_DIRECTION_IS_FORWARD (c->buffer->props.direction) ? -1 : +1;
/* We intentionally don't set HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT,
* since there needs to be a non-zero attachment for post-positioning to
* be needed. */
}
}
2018-10-09 04:41:08 +02:00
if (reverse)
2018-10-10 23:32:32 +02:00
c->buffer->reverse ();
2018-10-09 04:41:08 +02:00
{
/* See comment in sanitize() for conditional here. */
hb_sanitize_with_object_t with (&c->sanitizer, i < count - 1 ? st : (const SubTable *) nullptr);
ret |= st->dispatch (c);
}
2018-10-09 04:41:08 +02:00
if (reverse)
2018-10-10 23:32:32 +02:00
c->buffer->reverse ();
2018-10-09 04:41:08 +02:00
(void) c->buffer->message (c->font, "end subtable %d", c->lookup_index);
2018-10-09 04:41:08 +02:00
skip:
st = &StructAfter<SubTable> (*st);
2018-11-06 19:51:39 +01:00
c->set_lookup_index (c->lookup_index + 1);
}
2018-11-07 22:03:09 +01:00
return ret;
2018-02-24 10:19:42 +01:00
}
bool sanitize (hb_sanitize_context_t *c) const
2018-02-19 00:47:44 +01:00
{
TRACE_SANITIZE (this);
if (unlikely (!thiz()->version.sanitize (c) ||
(unsigned) thiz()->version < (unsigned) T::minVersion ||
!thiz()->tableCount.sanitize (c)))
return_trace (false);
2018-02-19 00:47:44 +01:00
typedef typename T::SubTable SubTable;
const SubTable *st = &thiz()->firstSubTable;
unsigned int count = thiz()->tableCount;
for (unsigned int i = 0; i < count; i++)
2018-02-19 00:47:44 +01:00
{
if (unlikely (!st->u.header.sanitize (c)))
return_trace (false);
/* OpenType kern table has 2-byte subtable lengths. That's limiting.
* MS implementation also only supports one subtable, of format 0,
* anyway. Certain versions of some fonts, like Calibry, contain
* kern subtable that exceeds 64kb. Looks like, the subtable length
* is simply ignored. Which makes sense. It's only needed if you
* have multiple subtables. To handle such fonts, we just ignore
* the length for the last subtable. */
hb_sanitize_with_object_t with (c, i < count - 1 ? st : (const SubTable *) nullptr);
if (unlikely (!st->sanitize (c)))
return_trace (false);
st = &StructAfter<SubTable> (*st);
2018-02-19 00:47:44 +01:00
}
return_trace (true);
}
};
struct kerx : KerxTable<kerx>
{
friend struct KerxTable<kerx>;
static constexpr hb_tag_t tableTag = HB_AAT_TAG_kerx;
static constexpr unsigned minVersion = 2u;
typedef KerxSubTableHeader SubTableHeader;
typedef SubTableHeader::Types Types;
typedef KerxSubTable SubTable;
bool has_data () const { return version; }
2018-02-19 00:47:44 +01:00
protected:
HBUINT16 version; /* The version number of the extended kerning table
* (currently 2, 3, or 4). */
HBUINT16 unused; /* Set to 0. */
HBUINT32 tableCount; /* The number of subtables included in the extended kerning
* table. */
SubTable firstSubTable; /* Subtables. */
/*subtableGlyphCoverageArray*/ /* Only if version >= 3. We don't use. */
2018-02-19 00:47:44 +01:00
public:
DEFINE_SIZE_MIN (8);
2018-02-19 00:47:44 +01:00
};
2018-11-07 16:39:39 +01:00
2018-02-19 00:47:44 +01:00
} /* namespace AAT */
#endif /* HB_AAT_LAYOUT_KERX_TABLE_HH */