[kern/kerx] Add accelerator and set-digest filtering

src/hb-aat-layout-common.hh

@@ -46,8 +46,9 @@ struct hb_aat_apply_context_t :
        hb_dispatch_context_t<hb_aat_apply_context_t, bool, HB_DEBUG_APPLY>
 {
   const char *get_name () { return "APPLY"; }
-  template <typename T>
-  return_t dispatch (const T &obj) { return obj.apply (this); }
+  template <typename T, typename ...Ts>
+  return_t dispatch (const T &obj, Ts&&... ds)
+  { return obj.apply (this, std::forward<Ts> (ds)...); }
   static return_t default_return_value () { return false; }
   bool stop_sublookup_iteration (return_t r) const { return r; }
 
@@ -60,6 +61,8 @@ struct hb_aat_apply_context_t :
   const OT::GDEF *gdef_table;
   const hb_sorted_vector_t<hb_aat_map_t::range_flags_t> *range_flags = nullptr;
   hb_set_digest_t machine_glyph_set = hb_set_digest_t::full ();
+  hb_set_digest_t left_set = hb_set_digest_t::full ();
+  hb_set_digest_t right_set = hb_set_digest_t::full ();
   hb_mask_t subtable_flags = 0;
 
   /* Unused. For debug tracing only. */
@@ -425,6 +428,16 @@ struct LookupFormat10
     return v;
   }
 
+  template <typename set_t>
+  void collect_glyphs (set_t &glyphs) const
+  {
+    if (unlikely (!glyphCount))
+      return;
+    if (firstGlyph == DELETED_GLYPH)
+      return;
+    glyphs.add_range (firstGlyph, firstGlyph + glyphCount - 1);
+  }
+
   bool sanitize (hb_sanitize_context_t *c) const
   {
     TRACE_SANITIZE (this);
@@ -482,6 +495,7 @@ struct Lookup
     case 4: u.format4.collect_glyphs (glyphs); return;
     case 6: u.format6.collect_glyphs (glyphs); return;
     case 8: u.format8.collect_glyphs (glyphs); return;
+    case 10: u.format10.collect_glyphs (glyphs); return;
     default:return;
     }
   }

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

@@ -119,6 +119,16 @@ struct KerxSubTableFormat0
     return_trace (true);
   }
 
+  template <typename set_t>
+  void collect_glyphs (set_t &left_set, set_t &right_set, unsigned num_glyphs) const
+  {
+    for (const KernPair& pair : pairs)
+    {
+      left_set.add (pair.left);
+      right_set.add (pair.right);
+    }
+  }
+
   struct accelerator_t
   {
     const KerxSubTableFormat0 &table;
@@ -130,6 +140,7 @@ struct KerxSubTableFormat0
 
     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);
     }
   };
@@ -369,6 +380,15 @@ struct KerxSubTableFormat1
 			  machine.sanitize (c)));
   }
 
+  template <typename set_t>
+  void collect_glyphs (set_t &left_set, set_t &right_set, unsigned num_glyphs) const
+  {
+    set_t set;
+    machine.collect_glyphs (set, num_glyphs);
+    left_set.union_ (set);
+    right_set.union_ (set);
+  }
+
   protected:
   KernSubTableHeader				header;
   StateTable<Types, EntryData>			machine;
@@ -417,6 +437,13 @@ struct KerxSubTableFormat2
     return_trace (true);
   }
 
+  template <typename set_t>
+  void collect_glyphs (set_t &left_set, set_t &right_set, unsigned num_glyphs) const
+  {
+    (this+leftClassTable).collect_glyphs (left_set, num_glyphs);
+    (this+rightClassTable).collect_glyphs (right_set, num_glyphs);
+  }
+
   struct accelerator_t
   {
     const KerxSubTableFormat2 &table;
@@ -427,7 +454,10 @@ struct KerxSubTableFormat2
 		     table (table_), c (c_) {}
 
     int get_kerning (hb_codepoint_t left, hb_codepoint_t right) const
-    { return table.get_kerning (left, right, c); }
+    {
+      if (!c->left_set[left] || !c->right_set[right]) return 0;
+      return table.get_kerning (left, right, c);
+    }
   };
 
   bool sanitize (hb_sanitize_context_t *c) const
@@ -618,6 +648,15 @@ struct KerxSubTableFormat4
 			  machine.sanitize (c)));
   }
 
+  template <typename set_t>
+  void collect_glyphs (set_t &left_set, set_t &right_set, unsigned num_glyphs) const
+  {
+    set_t set;
+    machine.collect_glyphs (set, num_glyphs);
+    left_set.union_ (set);
+    right_set.union_ (set);
+  }
+
   protected:
   KernSubTableHeader		header;
   StateTable<Types, EntryData>	machine;
@@ -642,7 +681,7 @@ struct KerxSubTableFormat6
     unsigned int num_glyphs = c->sanitizer.get_num_glyphs ();
     if (is_long ())
     {
-      const typename U::Long &t = u.l;
+      const auto &t = u.l;
       unsigned int l = (this+t.rowIndexTable).get_value_or_null (left, num_glyphs);
       unsigned int r = (this+t.columnIndexTable).get_value_or_null (right, num_glyphs);
       unsigned int offset = l + r;
@@ -655,7 +694,7 @@ struct KerxSubTableFormat6
     }
     else
     {
-      const typename U::Short &t = u.s;
+      const auto &t = u.s;
       unsigned int l = (this+t.rowIndexTable).get_value_or_null (left, num_glyphs);
       unsigned int r = (this+t.columnIndexTable).get_value_or_null (right, num_glyphs);
       unsigned int offset = l + r;
@@ -702,6 +741,23 @@ struct KerxSubTableFormat6
 			   c->check_range (this, vector))));
   }
 
+  template <typename set_t>
+  void collect_glyphs (set_t &left_set, set_t &right_set, unsigned num_glyphs) const
+  {
+    if (is_long ())
+    {
+      const auto &t = u.l;
+      (this+t.rowIndexTable).collect_glyphs (left_set, num_glyphs);
+      (this+t.columnIndexTable).collect_glyphs (right_set, num_glyphs);
+    }
+    else
+    {
+      const auto &t = u.s;
+      (this+t.rowIndexTable).collect_glyphs (left_set, num_glyphs);
+      (this+t.columnIndexTable).collect_glyphs (right_set, num_glyphs);
+    }
+  }
+
   struct accelerator_t
   {
     const KerxSubTableFormat6 &table;
@@ -712,7 +768,10 @@ struct KerxSubTableFormat6
 		     table (table_), c (c_) {}
 
     int get_kerning (hb_codepoint_t left, hb_codepoint_t right) const
-    { return table.get_kerning (left, right, c); }
+    {
+      if (!c->left_set[left] || !c->right_set[right]) return 0;
+      return table.get_kerning (left, right, c);
+    }
   };
 
   protected:
@@ -798,6 +857,20 @@ struct KerxSubTable
     }
   }
 
+  template <typename set_t>
+  void collect_glyphs (set_t &left_set, set_t &right_set, unsigned num_glyphs) const
+  {
+    unsigned int subtable_type = get_type ();
+    switch (subtable_type) {
+    case 0:	u.format0.collect_glyphs (left_set, right_set, num_glyphs); return;
+    case 1:	u.format1.collect_glyphs (left_set, right_set, num_glyphs); return;
+    case 2:	u.format2.collect_glyphs (left_set, right_set, num_glyphs); return;
+    case 4:	u.format4.collect_glyphs (left_set, right_set, num_glyphs); return;
+    case 6:	u.format6.collect_glyphs (left_set, right_set, num_glyphs); return;
+    default:	return;
+    }
+  }
+
   bool sanitize (hb_sanitize_context_t *c) const
   {
     TRACE_SANITIZE (this);
@@ -828,6 +901,8 @@ struct KerxSubTable
  * The 'kerx' Table
  */
 
+using kern_accelerator_data_t = hb_vector_t<hb_pair_t<hb_set_digest_t, hb_set_digest_t>>;
+
 template <typename T>
 struct KerxTable
 {
@@ -882,7 +957,8 @@ struct KerxTable
     return v;
   }
 
-  bool apply (AAT::hb_aat_apply_context_t *c) const
+  bool apply (AAT::hb_aat_apply_context_t *c,
+	      const kern_accelerator_data_t *accel_data = nullptr) const
   {
     c->buffer->unsafe_to_concat ();
 
@@ -929,6 +1005,16 @@ struct KerxTable
       if (reverse)
 	c->buffer->reverse ();
 
+      if (accel_data)
+      {
+	c->left_set = (*accel_data)[i].first;
+	c->right_set = (*accel_data)[i].second;
+      }
+      else
+      {
+        c->left_set = c->right_set = hb_set_digest_t::full ();
+      }
+
       {
 	/* See comment in sanitize() for conditional here. */
 	hb_sanitize_with_object_t with (&c->sanitizer, i < count - 1 ? st : (const SubTable *) nullptr);
@@ -993,6 +1079,49 @@ struct KerxTable
 
     return_trace (true);
   }
+
+  kern_accelerator_data_t create_accelerator_data (unsigned num_glyphs) const
+  {
+    kern_accelerator_data_t accel_data;
+
+    typedef typename T::SubTable SubTable;
+
+    const SubTable *st = &thiz()->firstSubTable;
+    unsigned int count = thiz()->tableCount;
+    for (unsigned int i = 0; i < count; i++)
+    {
+      hb_set_digest_t left_set, right_set;
+      st->collect_glyphs (left_set, right_set, num_glyphs);
+      accel_data.push (hb_pair (left_set, right_set));
+      st = &StructAfter<SubTable> (*st);
+    }
+
+    return accel_data;
+  }
+
+  struct accelerator_t
+  {
+    accelerator_t (hb_face_t *face)
+    {
+      hb_sanitize_context_t sc;
+      this->table = sc.reference_table<T> (face);
+      this->accel_data = this->table->create_accelerator_data (face->get_num_glyphs ());
+    }
+    ~accelerator_t ()
+    {
+      this->table.destroy ();
+    }
+
+    hb_blob_t *get_blob () const { return table.get_blob (); }
+
+    bool apply (AAT::hb_aat_apply_context_t *c) const
+    {
+      return table->apply (c, &accel_data);
+    }
+
+    hb_blob_ptr_t<T> table;
+    kern_accelerator_data_t accel_data;
+  };
 };
 
 struct kerx : KerxTable<kerx>
@@ -1021,8 +1150,10 @@ struct kerx : KerxTable<kerx>
   DEFINE_SIZE_MIN (8);
 };
 
+struct kerx_accelerator_t : kerx::accelerator_t {
+  kerx_accelerator_t (hb_face_t *face) : kerx::accelerator_t (face) {}
+};
 
 } /* namespace AAT */
 
-
 #endif /* HB_AAT_LAYOUT_KERX_TABLE_HH */

src/hb-aat-layout.cc

@@ -326,7 +326,7 @@ hb_aat_layout_remove_deleted_glyphs (hb_buffer_t *buffer)
 hb_bool_t
 hb_aat_layout_has_positioning (hb_face_t *face)
 {
-  return face->table.kerx->has_data ();
+  return face->table.kerx->table->has_data ();
 }
 
 void
@@ -334,13 +334,12 @@ hb_aat_layout_position (const hb_ot_shape_plan_t *plan,
 			hb_font_t *font,
 			hb_buffer_t *buffer)
 {
-  hb_blob_t *kerx_blob = font->face->table.kerx.get_blob ();
-  const AAT::kerx& kerx = *kerx_blob->as<AAT::kerx> ();
+  auto &accel = *font->face->table.kerx;
 
-  AAT::hb_aat_apply_context_t c (plan, font, buffer, kerx_blob);
+  AAT::hb_aat_apply_context_t c (plan, font, buffer, accel.get_blob ());
   if (!buffer->message (font, "start table kerx")) return;
   c.set_ankr_table (font->face->table.ankr.get ());
-  kerx.apply (&c);
+  accel.apply (&c);
   (void) buffer->message (font, "end table kerx");
 }
 

src/hb-ot-face-table-list.hh

@@ -100,7 +100,7 @@ HB_OT_CORE_TABLE (OT, MVAR)
 
 /* Legacy kern. */
 #ifndef HB_NO_OT_KERN
-HB_OT_CORE_TABLE (OT, kern)
+HB_OT_ACCELERATOR (OT, kern)
 #endif
 
 /* OpenType shaping. */
@@ -120,7 +120,7 @@ HB_OT_CORE_TABLE (OT, BASE)
 #ifndef HB_NO_AAT
 HB_OT_ACCELERATOR (AAT, morx)
 HB_OT_ACCELERATOR (AAT, mort)
-HB_OT_TABLE (AAT, kerx)
+HB_OT_ACCELERATOR (AAT, kerx)
 HB_OT_TABLE (AAT, ankr)
 HB_OT_TABLE (AAT, trak)
 HB_OT_TABLE (AAT, ltag)

src/hb-ot-face.cc

@@ -41,6 +41,7 @@
 #include "hb-ot-layout-gdef-table.hh"
 #include "hb-ot-layout-gsub-table.hh"
 #include "hb-ot-layout-gpos-table.hh"
+#include "hb-aat-layout-kerx-table.hh"
 #include "hb-aat-layout-morx-table.hh"
 
 

src/hb-ot-kern-table.hh

@@ -86,6 +86,16 @@ struct KernSubTableFormat3
 				  leftClassCount * rightClassCount));
   }
 
+  template <typename set_t>
+  void collect_glyphs (set_t &left_set, set_t &right_set, unsigned num_glyphs) const
+  {
+    set_t set;
+    if (likely (glyphCount))
+      set.add_range (0, glyphCount - 1);
+    left_set.union_ (set);
+    right_set.union_ (set);
+  }
+
   protected:
   KernSubTableHeader
 		header;
@@ -145,6 +155,19 @@ struct KernSubTable
     }
   }
 
+  template <typename set_t>
+  void collect_glyphs (set_t &left_set, set_t &right_set, unsigned num_glyphs) const
+  {
+    unsigned int subtable_type = get_type ();
+    switch (subtable_type) {
+    case 0:	u.format0.collect_glyphs (left_set, right_set, num_glyphs); return;
+    case 1:	u.format1.collect_glyphs (left_set, right_set, num_glyphs); return;
+    case 2:	u.format2.collect_glyphs (left_set, right_set, num_glyphs); return;
+    case 3:	u.format3.collect_glyphs (left_set, right_set, num_glyphs); return;
+    default:	return;
+    }
+  }
+
   bool sanitize (hb_sanitize_context_t *c) const
   {
     TRACE_SANITIZE (this);
@@ -318,8 +341,9 @@ struct kern
     }
   }
 
-  bool apply (AAT::hb_aat_apply_context_t *c) const
-  { return dispatch (c); }
+  bool apply (AAT::hb_aat_apply_context_t *c,
+	      const AAT::kern_accelerator_data_t *accel_data = nullptr) const
+  { return dispatch (c, accel_data); }
 
   template <typename context_t, typename ...Ts>
   typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const
@@ -343,6 +367,41 @@ struct kern
     return_trace (dispatch (c));
   }
 
+  AAT::kern_accelerator_data_t create_accelerator_data (unsigned num_glyphs) const
+  {
+    switch (get_type ()) {
+    case 0: return u.ot.create_accelerator_data (num_glyphs);
+#ifndef HB_NO_AAT_SHAPE
+    case 1: return u.aat.create_accelerator_data (num_glyphs);
+#endif
+    default:return AAT::kern_accelerator_data_t ();
+    }
+  }
+
+  struct accelerator_t
+  {
+    accelerator_t (hb_face_t *face)
+    {
+      hb_sanitize_context_t sc;
+      this->table = sc.reference_table<kern> (face);
+      this->accel_data = this->table->create_accelerator_data (face->get_num_glyphs ());
+    }
+    ~accelerator_t ()
+    {
+      this->table.destroy ();
+    }
+
+    hb_blob_t *get_blob () const { return table.get_blob (); }
+
+    bool apply (AAT::hb_aat_apply_context_t *c) const
+    {
+      return table->apply (c, &accel_data);
+    }
+
+    hb_blob_ptr_t<kern> table;
+    AAT::kern_accelerator_data_t accel_data;
+  };
+
   protected:
   union {
   HBUINT32		version32;
@@ -356,6 +415,10 @@ struct kern
   DEFINE_SIZE_UNION (4, version32);
 };
 
+struct kern_accelerator_t : kern::accelerator_t {
+  kern_accelerator_t (hb_face_t *face) : kern::accelerator_t (face) {}
+};
+
 } /* namespace OT */
 
 

src/hb-ot-layout-gsubgpos.hh

@@ -4387,7 +4387,7 @@ struct hb_ot_layout_lookup_accelerator_t
 
     thiz->digest.init ();
     for (auto& subtable : hb_iter (thiz->subtables, count))
-      thiz->digest.add (subtable.digest);
+      thiz->digest.union_ (subtable.digest);
 
 #ifndef HB_NO_OT_LAYOUT_LOOKUP_CACHE
     thiz->cache_user_idx = c_accelerate_subtables.cache_user_idx;

src/hb-ot-layout.cc

@@ -87,7 +87,7 @@ using OT::Layout::GPOS;
 bool
 hb_ot_layout_has_kerning (hb_face_t *face)
 {
-  return face->table.kern->has_data ();
+  return face->table.kern->table->has_data ();
 }
 
 /**
@@ -103,7 +103,7 @@ hb_ot_layout_has_kerning (hb_face_t *face)
 bool
 hb_ot_layout_has_machine_kerning (hb_face_t *face)
 {
-  return face->table.kern->has_state_machine ();
+  return face->table.kern->table->has_state_machine ();
 }
 
 /**
@@ -123,7 +123,7 @@ hb_ot_layout_has_machine_kerning (hb_face_t *face)
 bool
 hb_ot_layout_has_cross_kerning (hb_face_t *face)
 {
-  return face->table.kern->has_cross_stream ();
+  return face->table.kern->table->has_cross_stream ();
 }
 
 void
@@ -132,7 +132,7 @@ hb_ot_layout_kern (const hb_ot_shape_plan_t *plan,
 		   hb_buffer_t  *buffer)
 {
   hb_blob_t *blob = font->face->table.kern.get_blob ();
-  const AAT::kern& kern = *font->face->table.kern;
+  const auto& kern = *font->face->table.kern;
 
   AAT::hb_aat_apply_context_t c (plan, font, buffer, blob);
 

src/hb-set-digest.hh

@@ -84,7 +84,7 @@ struct hb_set_digest_bits_pattern_t
 
   static hb_set_digest_bits_pattern_t full () { hb_set_digest_bits_pattern_t d; d.mask = (mask_t) -1; return d; }
 
-  void add (const hb_set_digest_bits_pattern_t &o) { mask |= o.mask; }
+  void union_ (const hb_set_digest_bits_pattern_t &o) { mask |= o.mask; }
 
   void add (hb_codepoint_t g) { mask |= mask_for (g); }
 
@@ -152,10 +152,10 @@ struct hb_set_digest_combiner_t
 
   static hb_set_digest_combiner_t full () { hb_set_digest_combiner_t d; d.head = head_t::full(); d.tail = tail_t::full (); return d; }
 
-  void add (const hb_set_digest_combiner_t &o)
+  void union_ (const hb_set_digest_combiner_t &o)
   {
-    head.add (o.head);
-    tail.add (o.tail);
+    head.union_ (o.head);
+    tail.union_(o.tail);
   }
 
   void add (hb_codepoint_t g)