PageRenderTime 36ms CodeModel.GetById 14ms app.highlight 18ms RepoModel.GetById 2ms app.codeStats 0ms

/src/freetype/src/sfnt/ttkern.c

https://bitbucket.org/cabalistic/ogredeps/
C | 306 lines | 195 code | 77 blank | 34 comment | 34 complexity | 0fe2d7c9b7c51b44e1d8daedaa29b820 MD5 | raw file
  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 <ft2build.h>
 21#include FT_INTERNAL_DEBUG_H
 22#include FT_INTERNAL_STREAM_H
 23#include FT_TRUETYPE_TAGS_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 = SFNT_Err_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 */