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 {
get_kerningOT::KernSubTableFormat347   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 
applyOT::KernSubTableFormat362   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 
sanitizeOT::KernSubTableFormat378   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 {
get_sizeOT::KernSubTable112   unsigned int get_size () const { return u.header.length; }
get_typeOT::KernSubTable113   unsigned int get_type () const { return u.header.format; }
114 
get_kerningOT::KernSubTable115   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>
dispatchOT::KernSubTable125   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 
sanitizeOT::KernSubTable138   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   enum { apple = false };
164   typedef AAT::ObsoleteTypes Types;
165 
tuple_countOT::KernOTSubTableHeader166   unsigned int tuple_count () const { return 0; }
is_horizontalOT::KernOTSubTableHeader167   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 
sanitizeOT::KernOTSubTableHeader181   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   enum { tableTag = HB_OT_TAG_kern };
201   enum { 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   enum { apple = true };
219   typedef AAT::ObsoleteTypes Types;
220 
tuple_countOT::KernAATSubTableHeader221   unsigned int tuple_count () const { return 0; }
is_horizontalOT::KernAATSubTableHeader222   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 
sanitizeOT::KernAATSubTableHeader234   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   enum { tableTag = HB_OT_TAG_kern };
256   enum { 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   enum { tableTag = HB_OT_TAG_kern };
273 
has_dataOT::kern274   bool has_data () const { return u.version32; }
get_typeOT::kern275   unsigned int get_type () const { return u.major; }
276 
has_state_machineOT::kern277   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 
has_cross_streamOT::kern286   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 
get_h_kerningOT::kern295   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 
applyOT::kern304   bool apply (AAT::hb_aat_apply_context_t *c) const
305   { return dispatch (c); }
306 
307   template <typename context_t>
dispatchOT::kern308   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 
sanitizeOT::kern319   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 */
341