/work/workdir/UnpackedTarball/harfbuzz/src/hb-aat-layout-kerx-table.hh

Source (jump to first uncovered line)
/*
 * Copyright © 2018  Ebrahim Byagowi
 * Copyright © 2018  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_AAT_LAYOUT_KERX_TABLE_HH
#define HB_AAT_LAYOUT_KERX_TABLE_HH

#include "hb-kern.hh"
#include "hb-aat-layout-ankr-table.hh"
#include "hb-set-digest.hh"

/*
 * 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')


namespace AAT {

using namespace OT;


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);
  if (unlikely (!c->sanitizer.check_array (pv, tupleCount))) return 0;
  hb_barrier ();
  return *pv;
}


struct hb_glyph_pair_t
{
  hb_codepoint_t left;
  hb_codepoint_t right;
};

struct KernPair
{
  int get_kerning () const { return value; }

  int cmp (const hb_glyph_pair_t &o) const
  {
    int ret = left.cmp (o.left);
    if (ret) return ret;
    return right.cmp (o.right);
  }

  bool sanitize (hb_sanitize_context_t *c) const
  {
    TRACE_SANITIZE (this);
    return_trace (c->check_struct (this));
  }

  public:
  HBGlyphID16 left;
  HBGlyphID16 right;
  FWORD   value;
  public:
  DEFINE_SIZE_STATIC (6);
};

template <typename KernSubTableHeader>
struct KerxSubTableFormat0
{
  int get_kerning (hb_codepoint_t left, hb_codepoint_t right,
       hb_aat_apply_context_t *c = nullptr) const
  {
    hb_glyph_pair_t pair = {left, right};
    int v = pairs.bsearch (pair).get_kerning ();
    return kerxTupleKern (v, header.tuple_count (), this, c);
  }

  bool apply (hb_aat_apply_context_t *c) const
  {
    TRACE_APPLY (this);

    if (!c->plan->requested_kerning)
      return_trace (false);

    if (header.coverage & header.Backwards)
      return_trace (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);
  }

  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;
    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
    {
      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
  {
    TRACE_SANITIZE (this);
    return_trace (likely (pairs.sanitize (c)));
  }

  protected:
  KernSubTableHeader  header;
  BinSearchArrayOf<KernPair, typename KernSubTableHeader::Types::HBUINT>
      pairs;  /* Sorted kern records. */
  public:
  DEFINE_SIZE_ARRAY (KernSubTableHeader::static_size + 16, pairs);
};


template <bool extended>
struct Format1Entry;

template <>
struct Format1Entry<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. */
    Reset   = 0x2000, /* If set, reset the kerning data (clear the stack) */
    Reserved    = 0x1FFF, /* Not used; set to 0. */
  };

  struct EntryData
  {
    HBUINT16  kernActionIndex;/* Index into the kerning value array. If
         * this index is 0xFFFF, then no kerning
         * is to be performed. */
    public:
    DEFINE_SIZE_STATIC (2);
  };

  static bool initiateAction (const Entry<EntryData> &entry)
  { return entry.flags & Push; }

  static bool performAction (const Entry<EntryData> &entry)
  { return entry.data.kernActionIndex != 0xFFFF; }

  static unsigned int kernActionIndex (const Entry<EntryData> &entry)
  { return entry.data.kernActionIndex; }
};
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;

  static bool initiateAction (const Entry<EntryData> &entry)
  { return entry.flags & Push; }

  static bool performAction (const Entry<EntryData> &entry)
  { return entry.flags & Offset; }

  static unsigned int kernActionIndex (const Entry<EntryData> &entry)
  { return entry.flags & Offset; }
};

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;

  enum Flags
  {
    DontAdvance = Format1EntryT::DontAdvance,
  };

  bool is_action_initiable (const Entry<EntryData> &entry) const
  {
    return Format1EntryT::initiateAction (entry);
  }
  bool is_actionable (const Entry<EntryData> &entry) const
  {
    return Format1EntryT::performAction (entry);
  }

  struct driver_context_t
  {
    static constexpr bool in_place = true;

    driver_context_t (const KerxSubTableFormat1 *table_,
          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),
  crossStream (table->header.coverage & table->header.CrossStream) {}

    void transition (hb_buffer_t *buffer,
         StateTableDriver<Types, EntryData, Flags> *driver,
         const Entry<EntryData> &entry)
    {
      unsigned int flags = entry.flags;

      if (flags & Format1EntryT::Reset)
  depth = 0;

      if (flags & Format1EntryT::Push)
      {
  if (likely (depth < ARRAY_LENGTH (stack)))
    stack[depth++] = buffer->idx;
  else
    depth = 0; /* Probably not what CoreText does, but better? */
      }

      if (Format1EntryT::performAction (entry) && depth)
      {
  unsigned int tuple_count = hb_max (1u, table->header.tuple_count ());

  unsigned int kern_idx = Format1EntryT::kernActionIndex (entry);
  kern_idx = Types::byteOffsetToIndex (kern_idx, &table->machine, kernAction.arrayZ);
  const FWORD *actions = &kernAction[kern_idx];
  if (!c->sanitizer.check_array (actions, depth, tuple_count))
  {
    depth = 0;
    return;
  }
  hb_barrier ();

  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;
  while (!last && depth)
  {
    unsigned int idx = stack[--depth];
    int v = *actions;
    actions += tuple_count;
    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))
    {
      if (crossStream)
      {
        /* The following flag is undocumented in the spec, but described
         * in the 'kern' table example. */
        if (v == -0x8000)
        {
    o.attach_type() = OT::Layout::GPOS_impl::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;
        }
      }
      else if (buffer->info[idx].mask & kern_mask)
      {
        auto scaled = c->font->em_scale_x (v);
        o.x_advance += scaled;
        o.x_offset += scaled;
      }
    }
    else
    {
      if (crossStream)
      {
        /* CoreText doesn't do crossStream kerning in vertical.  We do. */
        if (v == -0x8000)
        {
    o.attach_type() = OT::Layout::GPOS_impl::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;
        }
      }
      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);
      }
    }
  }
      }
    }

    public:
    hb_aat_apply_context_t *c;
    const KerxSubTableFormat1 *table;
    private:
    const UnsizedArrayOf<FWORD> &kernAction;
    unsigned int stack[8];
    unsigned int depth;
    bool crossStream;
  };

  bool apply (hb_aat_apply_context_t *c) const
  {
    TRACE_APPLY (this);

    if (!c->plan->requested_kerning &&
  !(header.coverage & header.CrossStream))
      return false;

    driver_context_t dc (this, c);

    StateTableDriver<Types, EntryData, Flags> driver (machine, c->font->face);

    driver.drive (&dc, c);

    return_trace (true);
  }

  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)));
  }

  template <typename set_t>
  void collect_glyphs (set_t &left_set, set_t &right_set, unsigned num_glyphs) const
  {
    machine.collect_initial_glyphs (left_set, num_glyphs, *this);
    //machine.collect_glyphs (right_set, num_glyphs); // right_set is unused for machine kerning
  }

  protected:
  KernSubTableHeader        header;
  StateTable<Types, EntryData>      machine;
  NNOffsetTo<UnsizedArrayOf<FWORD>, HBUINT> kernAction;
  public:
  DEFINE_SIZE_STATIC (KernSubTableHeader::static_size + (StateTable<Types, EntryData>::static_size + HBUINT::static_size));
};

template <typename KernSubTableHeader>
struct KerxSubTableFormat2
{
  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
  {
    unsigned int num_glyphs = c->sanitizer.get_num_glyphs ();
    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;
    hb_barrier ();

    return kerxTupleKern (*v, header.tuple_count (), this, c);
  }

  bool apply (hb_aat_apply_context_t *c) const
  {
    TRACE_APPLY (this);

    if (!c->plan->requested_kerning)
      return_trace (false);

    if (header.coverage & header.Backwards)
      return_trace (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);
  }

  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;
    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
    {
      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
  {
    TRACE_SANITIZE (this);
    return_trace (likely (c->check_struct (this) &&
        leftClassTable.sanitize (c, this) &&
        rightClassTable.sanitize (c, this) &&
        hb_barrier () &&
        c->check_range (this, array)));
  }

  protected:
  KernSubTableHeader  header;
  HBUINT    rowWidth; /* The width, in bytes, of a row in the table. */
  NNOffsetTo<typename Types::ClassTypeWide, HBUINT>
      leftClassTable; /* Offset from beginning of this subtable to
           * left-hand class table. */
  NNOffsetTo<typename Types::ClassTypeWide, HBUINT>
      rightClassTable;/* Offset from beginning of this subtable to
           * right-hand class table. */
  NNOffsetTo<UnsizedArrayOf<FWORD>, HBUINT>
       array;   /* Offset from beginning of this subtable to
           * the start of the kerning array. */
  public:
  DEFINE_SIZE_STATIC (KernSubTableHeader::static_size + 4 * sizeof (HBUINT));
};

template <typename KernSubTableHeader>
struct KerxSubTableFormat4
{
  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);
  };

  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. */
  };

  bool is_action_initiable (const Entry<EntryData> &entry) const
  {
    return (entry.flags & Mark);
  }
  bool is_actionable (const Entry<EntryData> &entry) const
  {
    return entry.data.ankrActionIndex != 0xFFFF;
  }

  struct driver_context_t
  {
    static constexpr bool in_place = true;
    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_,
          hb_aat_apply_context_t *c_) :
  c (c_),
  table (table_),
  action_type ((table->flags & ActionType) >> 30),
  ankrData ((HBUINT16 *) ((const char *) &table->machine + (table->flags & Offset))),
  mark_set (false),
  mark (0) {}

    void transition (hb_buffer_t *buffer,
         StateTableDriver<Types, EntryData, Flags> *driver,
         const Entry<EntryData> &entry)
    {
      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;
      hb_barrier ();
      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;
      hb_barrier ();
      unsigned int markAnchorPoint = *data++;
      unsigned int currAnchorPoint = *data++;
      const Anchor &markAnchor = c->ankr_table->get_anchor (c->buffer->info[mark].codepoint,
                  markAnchorPoint,
                  c->sanitizer.get_num_glyphs ());
      const Anchor &currAnchor = c->ankr_table->get_anchor (c->buffer->cur ().codepoint,
                  currAnchorPoint,
                  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;
      hb_barrier ();
      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() = OT::Layout::GPOS_impl::ATTACH_TYPE_MARK;
  o.attach_chain() = (int) mark - (int) buffer->idx;
  buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT;
      }

      if (entry.flags & Mark)
      {
  mark_set = true;
  mark = buffer->idx;
      }
    }

    public:
    hb_aat_apply_context_t *c;
    const KerxSubTableFormat4 *table;
    private:
    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);

    StateTableDriver<Types, EntryData, Flags> driver (machine, c->font->face);

    driver.drive (&dc, c);

    return_trace (true);
  }

  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)));
  }

  template <typename set_t>
  void collect_glyphs (set_t &left_set, set_t &right_set, unsigned num_glyphs) const
  {
    machine.collect_initial_glyphs (left_set, num_glyphs, *this);
    //machine.collect_glyphs (right_set, num_glyphs); // right_set is unused for machine kerning
  }

  protected:
  KernSubTableHeader    header;
  StateTable<Types, EntryData>  machine;
  HBUINT32      flags;
  public:
  DEFINE_SIZE_STATIC (KernSubTableHeader::static_size + (StateTable<Types, EntryData>::static_size + HBUINT32::static_size));
};

template <typename KernSubTableHeader>
struct KerxSubTableFormat6
{
  enum Flags
  {
    ValuesAreLong = 0x00000001,
  };

  bool is_long () const { return flags & ValuesAreLong; }

  int get_kerning (hb_codepoint_t left, hb_codepoint_t right,
       hb_aat_apply_context_t *c) const
  {
    unsigned int num_glyphs = c->sanitizer.get_num_glyphs ();
    if (is_long ())
    {
      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;
      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;
      hb_barrier ();
      return kerxTupleKern (*v, header.tuple_count (), &(this+vector), c);
    }
    else
    {
      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;
      const FWORD *v = &StructAtOffset<FWORD> (&(this+t.array), offset * sizeof (FWORD));
      if (unlikely (!v->sanitize (&c->sanitizer))) return 0;
      hb_barrier ();
      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_trace (false);

    if (header.coverage & header.Backwards)
      return_trace (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
  {
    TRACE_SANITIZE (this);
    return_trace (likely (c->check_struct (this) &&
        hb_barrier () &&
        (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)
         )) &&
        (header.tuple_count () == 0 ||
         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;
    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
    {
      if (!(*c->left_set)[left] || !(*c->right_set)[right]) return 0;
      return table.get_kerning (left, right, c);
    }
  };

  protected:
  KernSubTableHeader    header;
  HBUINT32      flags;
  HBUINT16      rowCount;
  HBUINT16      columnCount;
  union U
  {
    struct Long
    {
      NNOffset32To<Lookup<HBUINT32>>    rowIndexTable;
      NNOffset32To<Lookup<HBUINT32>>    columnIndexTable;
      NNOffset32To<UnsizedArrayOf<FWORD32>> array;
    } l;
    struct Short
    {
      NNOffset32To<Lookup<HBUINT16>>    rowIndexTable;
      NNOffset32To<Lookup<HBUINT16>>    columnIndexTable;
      NNOffset32To<UnsizedArrayOf<FWORD>> array;
    } s;
  } u;
  NNOffset32To<UnsizedArrayOf<FWORD>> vector;
  public:
  DEFINE_SIZE_STATIC (KernSubTableHeader::static_size + 24);
};


struct KerxSubTableHeader
{
  typedef ExtendedTypes Types;

  unsigned   tuple_count () const { return tupleCount; }
  bool     is_horizontal () const { return !(coverage & Vertical); }

  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. */
  };

  bool sanitize (hb_sanitize_context_t *c) const
  {
    TRACE_SANITIZE (this);
    return_trace (c->check_struct (this));
  }

  public:
  HBUINT32  length;
  HBUINT32  coverage;
  HBUINT32  tupleCount;
  public:
  DEFINE_SIZE_STATIC (12);
};

struct KerxSubTable
{
  friend struct kerx;

  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>
  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, std::forward<Ts> (ds)...));
    case 1: return_trace (c->dispatch (u.format1, std::forward<Ts> (ds)...));
    case 2: return_trace (c->dispatch (u.format2, std::forward<Ts> (ds)...));
    case 4: return_trace (c->dispatch (u.format4, std::forward<Ts> (ds)...));
    case 6: return_trace (c->dispatch (u.format6, std::forward<Ts> (ds)...));
    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 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);
    if (!(u.header.sanitize (c) &&
    hb_barrier () &&
    u.header.length >= u.header.static_size &&
    c->check_range (this, u.header.length)))
      return_trace (false);

    return_trace (dispatch (c));
  }

  public:
  union {
  KerxSubTableHeader        header;
  KerxSubTableFormat0<KerxSubTableHeader> format0;
  KerxSubTableFormat1<KerxSubTableHeader> format1;
  KerxSubTableFormat2<KerxSubTableHeader> format2;
  KerxSubTableFormat4<KerxSubTableHeader> format4;
  KerxSubTableFormat6<KerxSubTableHeader> format6;
  } u;
  public:
  DEFINE_SIZE_MIN (12);
};


/*
 * The 'kerx' Table
 */

struct kern_subtable_accelerator_data_t
{
  hb_bit_set_t left_set;
  hb_bit_set_t right_set;
  mutable hb_aat_class_cache_t class_cache;
};

struct kern_accelerator_data_t
{
  hb_vector_t<kern_subtable_accelerator_data_t> subtable_accels;
  hb_aat_scratch_t scratch;
};

template <typename T>
struct KerxTable
{
  /* https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern */
  const T* thiz () const { return static_cast<const T *> (this); }

  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;

      // TODO: What about format 4? What's this API used for anyway?

      st = &StructAfter<SubTable> (*st);
    }
    return false;
  }

  bool has_cross_stream () 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->u.header.coverage & st->u.header.CrossStream)
  return true;
      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 kern_accelerator_data_t &accel_data) const
  {
    c->buffer->unsafe_to_concat ();

    c->setup_buffer_glyph_set ();

    typedef typename T::SubTable SubTable;

    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++)
    {
      bool reverse;

      auto &subtable_accel = accel_data.subtable_accels[i];

      if (!T::Types::extended && (st->u.header.coverage & st->u.header.Variation))
  goto skip;

      if (HB_DIRECTION_IS_HORIZONTAL (c->buffer->props.direction) != st->u.header.is_horizontal ())
  goto skip;

      c->left_set = &subtable_accel.left_set;
      c->right_set = &subtable_accel.right_set;
      c->machine_glyph_set = &subtable_accel.left_set;
      c->machine_class_cache = &subtable_accel.class_cache;

      if (!c->buffer_intersects_machine ())
      {
  (void) c->buffer->message (c->font, "skipped subtable %u because no glyph matches", c->lookup_index);
  goto skip;
      }

      reverse = bool (st->u.header.coverage & st->u.header.Backwards) !=
    HB_DIRECTION_IS_BACKWARD (c->buffer->props.direction);

      if (!c->buffer->message (c->font, "start subtable %u", c->lookup_index))
  goto skip;

      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() = OT::Layout::GPOS_impl::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. */
  }
      }

      if (reverse)
  c->buffer->reverse ();

      {
  /* 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);
      }

      if (reverse)
  c->buffer->reverse ();

      (void) c->buffer->message (c->font, "end subtable %u", c->lookup_index);

    skip:
      st = &StructAfter<SubTable> (*st);
      c->set_lookup_index (c->lookup_index + 1);
    }

    return ret;
  }

  bool sanitize (hb_sanitize_context_t *c) const
  {
    TRACE_SANITIZE (this);
    if (unlikely (!(thiz()->version.sanitize (c) &&
        hb_barrier () &&
        (unsigned) thiz()->version >= (unsigned) T::minVersion &&
        thiz()->tableCount.sanitize (c))))
      return_trace (false);

    typedef typename T::SubTable SubTable;

    const SubTable *st = &thiz()->firstSubTable;
    unsigned int count = thiz()->tableCount;
    for (unsigned int i = 0; i < count; i++)
    {
      if (unlikely (!st->u.header.sanitize (c)))
  return_trace (false);
      hb_barrier ();
      /* 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);
    }

    unsigned majorVersion = thiz()->version;
    if (sizeof (thiz()->version) == 4)
      majorVersion = majorVersion >> 16;
    if (majorVersion >= 3)
    {
      const SubtableGlyphCoverage *coverage = (const SubtableGlyphCoverage *) st;
      if (!coverage->sanitize (c, count))
        return_trace (false);
    }

    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++)
    {
      auto &subtable_accel = *accel_data.subtable_accels.push ();
      if (unlikely (accel_data.subtable_accels.in_error ()))
    return accel_data;

      st->collect_glyphs (subtable_accel.left_set, subtable_accel.right_set, num_glyphs);
      subtable_accel.class_cache.clear ();

      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;
    hb_aat_scratch_t scratch;
  };
};

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; }

  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. */

  public:
  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 */

Coverage Report

Created: 2025-07-07 10:01