src/hb-ot-kern-table.hh

   1 /*
   2  * Copyright © 2017  Google, Inc.
   3  *
   4  *  This is part of HarfBuzz, a text shaping library.
   5  *
   6  * Permission is hereby granted, without written agreement and without
   7  * license or royalty fees, to use, copy, modify, and distribute this
   8  * software and its documentation for any purpose, provided that the
   9  * above copyright notice and the following two paragraphs appear in
  10  * all copies of this software.
  11  *
  12  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
  13  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  14  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
  15  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
  16  * DAMAGE.
  17  *
  18  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
  19  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  20  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  21  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
  22  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  23  *
  24  * Google Author(s): Behdad Esfahbod
  25  */
  26
  27 #ifndef HB_OT_KERN_TABLE_HH
  28 #define HB_OT_KERN_TABLE_HH
  29
  30 #include "hb-aat-layout-kerx-table.hh"
  31
  32
  33 /*
  34  * kern -- Kerning
  35  * https://docs.microsoft.com/en-us/typography/opentype/spec/kern
  36  * https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6kern.html
  37  */
  38 #define HB_OT_TAG_kern HB_TAG('k','e','r','n')
  39
  40
  41 namespace OT {
  42
  43
  44 template <typename KernSubTableHeader>
  45 struct KernSubTableFormat3
  46 {
  47   int get_kerning (hb_codepoint_t left, hb_codepoint_t right) const
  48   {
  49     hb_array_t<const FWORD> kernValue = kernValueZ.as_array (kernValueCount);
  50     hb_array_t<const HBUINT8> leftClass = StructAfter<const UnsizedArrayOf<HBUINT8> > (kernValue).as_array (glyphCount);
  51     hb_array_t<const HBUINT8> rightClass = StructAfter<const UnsizedArrayOf<HBUINT8> > (leftClass).as_array (glyphCount);
  52     hb_array_t<const HBUINT8> kernIndex = StructAfter<const UnsizedArrayOf<HBUINT8> > (rightClass).as_array (leftClassCount * rightClassCount);
  53
  54     unsigned int leftC = leftClass[left];
  55     unsigned int rightC = rightClass[right];
  56     if (unlikely (leftC >= leftClassCount || rightC >= rightClassCount))
  57       return 0;
  58     unsigned int i = leftC * rightClassCount + rightC;
  59     return kernValue[kernIndex[i]];
  60   }
  61
  62   bool apply (AAT::hb_aat_apply_context_t *c) const
  63   {
  64     TRACE_APPLY (this);
  65
  66     if (!c->plan->requested_kerning)
  67       return false;
  68
  69     if (header.coverage & header.Backwards)
  70       return false;
  71
  72     hb_kern_machine_t<KernSubTableFormat3> machine (*this, header.coverage & header.CrossStream);
  73     machine.kern (c->font, c->buffer, c->plan->kern_mask);
  74
  75     return_trace (true);
  76   }
  77
  78   bool sanitize (hb_sanitize_context_t *c) const
  79   {
  80     TRACE_SANITIZE (this);
  81     return_trace (c->check_struct (this) &&
  82                   c->check_range (kernValueZ,
  83                                   kernValueCount * sizeof (FWORD) +
  84                                   glyphCount * 2 +
  85                                   leftClassCount * rightClassCount));
  86   }
  87
  88   protected:
  89   KernSubTableHeader    header;
  90   HBUINT16              glyphCount;     /* The number of glyphs in this font. */
  91   HBUINT8               kernValueCount; /* The number of kerning values. */
  92   HBUINT8               leftClassCount; /* The number of left-hand classes. */
  93   HBUINT8               rightClassCount;/* The number of right-hand classes. */
  94   HBUINT8               flags;          /* Set to zero (reserved for future use). */
  95   UnsizedArrayOf<FWORD> kernValueZ;     /* The kerning values.
  96                                          * Length kernValueCount. */
  97 #if 0
  98   UnsizedArrayOf<HBUINT8>leftClass;     /* The left-hand classes.
  99                                          * Length glyphCount. */
 100   UnsizedArrayOf<HBUINT8>rightClass;    /* The right-hand classes.
 101                                          * Length glyphCount. */
 102   UnsizedArrayOf<HBUINT8>kernIndex;     /* The indices into the kernValue array.
 103                                          * Length leftClassCount * rightClassCount */
 104 #endif
 105   public:
 106   DEFINE_SIZE_ARRAY (KernSubTableHeader::static_size + 6, kernValueZ);
 107 };
 108
 109 template <typename KernSubTableHeader>
 110 struct KernSubTable
 111 {
 112   unsigned int get_size () const { return u.header.length; }
 113   unsigned int get_type () const { return u.header.format; }
 114
 115   int get_kerning (hb_codepoint_t left, hb_codepoint_t right) const
 116   {
 117     switch (get_type ()) {
 118     /* This method hooks up to hb_font_t's get_h_kerning.  Only support Format0. */
 119     case 0: return u.format0.get_kerning (left, right);
 120     default:return 0;
 121     }
 122   }
 123
 124   template <typename context_t>
 125   typename context_t::return_t dispatch (context_t *c) const
 126   {
 127     unsigned int subtable_type = get_type ();
 128     TRACE_DISPATCH (this, subtable_type);
 129     switch (subtable_type) {
 130     case 0:     return_trace (c->dispatch (u.format0));
 131     case 1:     return_trace (u.header.apple ? c->dispatch (u.format1) : c->default_return_value ());
 132     case 2:     return_trace (c->dispatch (u.format2));
 133     case 3:     return_trace (u.header.apple ? c->dispatch (u.format3) : c->default_return_value ());
 134     default:    return_trace (c->default_return_value ());
 135     }
 136   }
 137
 138   bool sanitize (hb_sanitize_context_t *c) const
 139   {
 140     TRACE_SANITIZE (this);
 141     if (unlikely (!u.header.sanitize (c) ||
 142                   u.header.length < u.header.min_size ||
 143                   !c->check_range (this, u.header.length))) return_trace (false);
 144
 145     return_trace (dispatch (c));
 146   }
 147
 148   public:
 149   union {
 150   KernSubTableHeader                            header;
 151   AAT::KerxSubTableFormat0<KernSubTableHeader>  format0;
 152   AAT::KerxSubTableFormat1<KernSubTableHeader>  format1;
 153   AAT::KerxSubTableFormat2<KernSubTableHeader>  format2;
 154   KernSubTableFormat3<KernSubTableHeader>       format3;
 155   } u;
 156   public:
 157   DEFINE_SIZE_MIN (KernSubTableHeader::static_size);
 158 };
 159
 160
 161 struct KernOTSubTableHeader
 162 {
 163   static constexpr bool apple = false;
 164   typedef AAT::ObsoleteTypes Types;
 165
 166   unsigned int tuple_count () const { return 0; }
 167   bool is_horizontal () const { return (coverage & Horizontal); }
 168
 169   enum Coverage
 170   {
 171     Horizontal  = 0x01u,
 172     Minimum     = 0x02u,
 173     CrossStream = 0x04u,
 174     Override    = 0x08u,
 175
 176     /* Not supported: */
 177     Backwards   = 0x00u,
 178     Variation   = 0x00u,
 179   };
 180
 181   bool sanitize (hb_sanitize_context_t *c) const
 182   {
 183     TRACE_SANITIZE (this);
 184     return_trace (c->check_struct (this));
 185   }
 186
 187   public:
 188   HBUINT16      versionZ;       /* Unused. */
 189   HBUINT16      length;         /* Length of the subtable (including this header). */
 190   HBUINT8       format;         /* Subtable format. */
 191   HBUINT8       coverage;       /* Coverage bits. */
 192   public:
 193   DEFINE_SIZE_STATIC (6);
 194 };
 195
 196 struct KernOT : AAT::KerxTable<KernOT>
 197 {
 198   friend struct AAT::KerxTable<KernOT>;
 199
 200   static constexpr hb_tag_t tableTag = HB_OT_TAG_kern;
 201   static constexpr unsigned minVersion = 0u;
 202
 203   typedef KernOTSubTableHeader SubTableHeader;
 204   typedef SubTableHeader::Types Types;
 205   typedef KernSubTable<SubTableHeader> SubTable;
 206
 207   protected:
 208   HBUINT16      version;        /* Version--0x0000u */
 209   HBUINT16      tableCount;     /* Number of subtables in the kerning table. */
 210   SubTable      firstSubTable;  /* Subtables. */
 211   public:
 212   DEFINE_SIZE_MIN (4);
 213 };
 214
 215
 216 struct KernAATSubTableHeader
 217 {
 218   static constexpr bool apple = true;
 219   typedef AAT::ObsoleteTypes Types;
 220
 221   unsigned int tuple_count () const { return 0; }
 222   bool is_horizontal () const       { return !(coverage & Vertical); }
 223
 224   enum Coverage
 225   {
 226     Vertical    = 0x80u,
 227     CrossStream = 0x40u,
 228     Variation   = 0x20u,
 229
 230     /* Not supported: */
 231     Backwards   = 0x00u,
 232   };
 233
 234   bool sanitize (hb_sanitize_context_t *c) const
 235   {
 236     TRACE_SANITIZE (this);
 237     return_trace (c->check_struct (this));
 238   }
 239
 240   public:
 241   HBUINT32      length;         /* Length of the subtable (including this header). */
 242   HBUINT8       coverage;       /* Coverage bits. */
 243   HBUINT8       format;         /* Subtable format. */
 244   HBUINT16      tupleIndex;     /* The tuple index (used for variations fonts).
 245                                * This value specifies which tuple this subtable covers.
 246                                * Note: We don't implement. */
 247   public:
 248   DEFINE_SIZE_STATIC (8);
 249 };
 250
 251 struct KernAAT : AAT::KerxTable<KernAAT>
 252 {
 253   friend struct AAT::KerxTable<KernAAT>;
 254
 255   static constexpr hb_tag_t tableTag = HB_OT_TAG_kern;
 256   static constexpr unsigned minVersion = 0x00010000u;
 257
 258   typedef KernAATSubTableHeader SubTableHeader;
 259   typedef SubTableHeader::Types Types;
 260   typedef KernSubTable<SubTableHeader> SubTable;
 261
 262   protected:
 263   HBUINT32      version;        /* Version--0x00010000u */
 264   HBUINT32      tableCount;     /* Number of subtables in the kerning table. */
 265   SubTable      firstSubTable;  /* Subtables. */
 266   public:
 267   DEFINE_SIZE_MIN (8);
 268 };
 269
 270 struct kern
 271 {
 272   static constexpr hb_tag_t tableTag = HB_OT_TAG_kern;
 273
 274   bool has_data () const { return u.version32; }
 275   unsigned int get_type () const { return u.major; }
 276
 277   bool has_state_machine () const
 278   {
 279     switch (get_type ()) {
 280     case 0: return u.ot.has_state_machine ();
 281     case 1: return u.aat.has_state_machine ();
 282     default:return false;
 283     }
 284   }
 285
 286   bool has_cross_stream () const
 287   {
 288     switch (get_type ()) {
 289     case 0: return u.ot.has_cross_stream ();
 290     case 1: return u.aat.has_cross_stream ();
 291     default:return false;
 292     }
 293   }
 294
 295   int get_h_kerning (hb_codepoint_t left, hb_codepoint_t right) const
 296   {
 297     switch (get_type ()) {
 298     case 0: return u.ot.get_h_kerning (left, right);
 299     case 1: return u.aat.get_h_kerning (left, right);
 300     default:return 0;
 301     }
 302   }
 303
 304   bool apply (AAT::hb_aat_apply_context_t *c) const
 305   { return dispatch (c); }
 306
 307   template <typename context_t>
 308   typename context_t::return_t dispatch (context_t *c) const
 309   {
 310     unsigned int subtable_type = get_type ();
 311     TRACE_DISPATCH (this, subtable_type);
 312     switch (subtable_type) {
 313     case 0:     return_trace (c->dispatch (u.ot));
 314     case 1:     return_trace (c->dispatch (u.aat));
 315     default:    return_trace (c->default_return_value ());
 316     }
 317   }
 318
 319   bool sanitize (hb_sanitize_context_t *c) const
 320   {
 321     TRACE_SANITIZE (this);
 322     if (!u.version32.sanitize (c)) return_trace (false);
 323     return_trace (dispatch (c));
 324   }
 325
 326   protected:
 327   union {
 328   HBUINT32              version32;
 329   HBUINT16              major;
 330   KernOT                ot;
 331   KernAAT               aat;
 332   } u;
 333   public:
 334   DEFINE_SIZE_UNION (4, version32);
 335 };
 336
 337 } /* namespace OT */
 338
 339
 340 #endif /* HB_OT_KERN_TABLE_HH */