1 /****************************************************************************
2 *
3 * ttkern.c
4 *
5 * Load the basic TrueType kerning table. This doesn't handle
6 * kerning data within the GPOS table at the moment.
7 *
8 * Copyright (C) 1996-2023 by
9 * David Turner, Robert Wilhelm, and Werner Lemberg.
10 *
11 * This file is part of the FreeType project, and may only be used,
12 * modified, and distributed under the terms of the FreeType project
13 * license, LICENSE.TXT. By continuing to use, modify, or distribute
14 * this file you indicate that you have read the license and
15 * understand and accept it fully.
16 *
17 */
18
19
20 #include <freetype/internal/ftdebug.h>
21 #include <freetype/internal/ftstream.h>
22 #include <freetype/tttags.h>
23 #include "ttkern.h"
24
25 #include "sferrors.h"
26
27
28 /**************************************************************************
29 *
30 * The macro FT_COMPONENT is used in trace mode. It is an implicit
31 * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
32 * messages during execution.
33 */
34 #undef FT_COMPONENT
35 #define FT_COMPONENT ttkern
36
37
38 #undef TT_KERN_INDEX
39 #define TT_KERN_INDEX( g1, g2 ) ( ( (FT_ULong)(g1) << 16 ) | (g2) )
40
41
42 FT_LOCAL_DEF( FT_Error )
43 tt_face_load_kern( TT_Face face,
44 FT_Stream stream )
45 {
46 FT_Error error;
47 FT_ULong table_size;
48 FT_Byte* p;
49 FT_Byte* p_limit;
50 FT_UInt nn, num_tables;
51 FT_UInt32 avail = 0, ordered = 0;
52
53
54 /* the kern table is optional; exit silently if it is missing */
55 error = face->goto_table( face, TTAG_kern, stream, &table_size );
56 if ( error )
57 goto Exit;
58
59 if ( table_size < 4 ) /* the case of a malformed table */
60 {
61 FT_ERROR(( "tt_face_load_kern:"
62 " kerning table is too small - ignored\n" ));
63 error = FT_THROW( Table_Missing );
64 goto Exit;
65 }
66
67 if ( FT_FRAME_EXTRACT( table_size, face->kern_table ) )
68 {
69 FT_ERROR(( "tt_face_load_kern:"
70 " could not extract kerning table\n" ));
71 goto Exit;
72 }
73
74 face->kern_table_size = table_size;
75
76 p = face->kern_table;
77 p_limit = p + table_size;
78
79 p += 2; /* skip version */
80 num_tables = FT_NEXT_USHORT( p );
81
82 if ( num_tables > 32 ) /* we only support up to 32 sub-tables */
83 num_tables = 32;
84
85 for ( nn = 0; nn < num_tables; nn++ )
86 {
87 FT_UInt num_pairs, length, coverage, format;
88 FT_Byte* p_next;
89 FT_UInt32 mask = (FT_UInt32)1UL << nn;
90
91
92 if ( p + 6 > p_limit )
93 break;
94
95 p_next = p;
96
97 p += 2; /* skip version */
98 length = FT_NEXT_USHORT( p );
99 coverage = FT_NEXT_USHORT( p );
100
101 if ( length <= 6 + 8 )
102 break;
103
104 p_next += length;
105
106 if ( p_next > p_limit ) /* handle broken table */
107 p_next = p_limit;
108
109 format = coverage >> 8;
110
111 /* we currently only support format 0 kerning tables */
112 if ( format != 0 )
113 goto NextTable;
114
115 /* only use horizontal kerning tables */
116 if ( ( coverage & 3U ) != 0x0001 ||
117 p + 8 > p_next )
118 goto NextTable;
119
120 num_pairs = FT_NEXT_USHORT( p );
121 p += 6;
122
123 if ( ( p_next - p ) < 6 * (int)num_pairs ) /* handle broken count */
124 num_pairs = (FT_UInt)( ( p_next - p ) / 6 );
125
126 avail |= mask;
127
128 /*
129 * Now check whether the pairs in this table are ordered.
130 * We then can use binary search.
131 */
132 if ( num_pairs > 0 )
133 {
134 FT_ULong count;
135 FT_ULong old_pair;
136
137
138 old_pair = FT_NEXT_ULONG( p );
139 p += 2;
140
141 for ( count = num_pairs - 1; count > 0; count-- )
142 {
143 FT_UInt32 cur_pair;
144
145
146 cur_pair = FT_NEXT_ULONG( p );
147 if ( cur_pair < old_pair )
148 break;
149
150 p += 2;
151 old_pair = cur_pair;
152 }
153
154 if ( count == 0 )
155 ordered |= mask;
156 }
157
158 NextTable:
159 p = p_next;
160 }
161
162 face->num_kern_tables = nn;
163 face->kern_avail_bits = avail;
164 face->kern_order_bits = ordered;
165
166 Exit:
167 return error;
168 }
169
170
171 FT_LOCAL_DEF( void )
172 tt_face_done_kern( TT_Face face )
173 {
174 FT_Stream stream = face->root.stream;
175
176
177 FT_FRAME_RELEASE( face->kern_table );
178 face->kern_table_size = 0;
179 face->num_kern_tables = 0;
180 face->kern_avail_bits = 0;
181 face->kern_order_bits = 0;
182 }
183
184
185 FT_LOCAL_DEF( FT_Int )
186 tt_face_get_kerning( TT_Face face,
187 FT_UInt left_glyph,
188 FT_UInt right_glyph )
189 {
190 FT_Int result = 0;
191 FT_UInt count, mask;
192
193 FT_Byte* p;
194 FT_Byte* p_limit;
195
196
197 if ( !face->kern_table )
198 return result;
199
200 p = face->kern_table;
201 p_limit = p + face->kern_table_size;
202
203 p += 4;
204 mask = 0x0001;
205
206 for ( count = face->num_kern_tables;
207 count > 0 && p + 6 <= p_limit;
208 count--, mask <<= 1 )
209 {
210 FT_Byte* base = p;
211 FT_Byte* next;
212 FT_UInt version = FT_NEXT_USHORT( p );
213 FT_UInt length = FT_NEXT_USHORT( p );
214 FT_UInt coverage = FT_NEXT_USHORT( p );
215 FT_UInt num_pairs;
216 FT_Int value = 0;
217
218 FT_UNUSED( version );
219
220
221 next = base + length;
222
223 if ( next > p_limit ) /* handle broken table */
224 next = p_limit;
225
226 if ( ( face->kern_avail_bits & mask ) == 0 )
227 goto NextTable;
228
229 FT_ASSERT( p + 8 <= next ); /* tested in tt_face_load_kern */
230
231 num_pairs = FT_NEXT_USHORT( p );
232 p += 6;
233
234 if ( ( next - p ) < 6 * (int)num_pairs ) /* handle broken count */
235 num_pairs = (FT_UInt)( ( next - p ) / 6 );
236
237 switch ( coverage >> 8 )
238 {
239 case 0:
240 {
241 FT_ULong key0 = TT_KERN_INDEX( left_glyph, right_glyph );
242
243
244 if ( face->kern_order_bits & mask ) /* binary search */
245 {
246 FT_UInt min = 0;
247 FT_UInt max = num_pairs;
248
249
250 while ( min < max )
251 {
252 FT_UInt mid = ( min + max ) >> 1;
253 FT_Byte* q = p + 6 * mid;
254 FT_ULong key;
255
256
257 key = FT_NEXT_ULONG( q );
258
259 if ( key == key0 )
260 {
261 value = FT_PEEK_SHORT( q );
262 goto Found;
263 }
264 if ( key < key0 )
265 min = mid + 1;
266 else
267 max = mid;
268 }
269 }
270 else /* linear search */
271 {
272 FT_UInt count2;
273
274
275 for ( count2 = num_pairs; count2 > 0; count2-- )
276 {
277 FT_ULong key = FT_NEXT_ULONG( p );
278
279
280 if ( key == key0 )
281 {
282 value = FT_PEEK_SHORT( p );
283 goto Found;
284 }
285 p += 2;
286 }
287 }
288 }
289 break;
290
291 /*
292 * We don't support format 2 because we haven't seen a single font
293 * using it in real life...
294 */
295
296 default:
297 ;
298 }
299
300 goto NextTable;
301
302 Found:
303 if ( coverage & 8 ) /* override or add */
304 result = value;
305 else
306 result += value;
307
308 NextTable:
309 p = next;
310 }
311
312 return result;
313 }
314
315 #undef TT_KERN_INDEX
316
317 /* END */