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