PageRenderTime 40ms CodeModel.GetById 2ms app.highlight 31ms RepoModel.GetById 1ms app.codeStats 1ms

/src/freetype/src/truetype/ttdriver.c

https://bitbucket.org/cabalistic/ogredeps/
C | 502 lines | 273 code | 105 blank | 124 comment | 27 complexity | f4b985b912fe931368ca05c943260dfa MD5 | raw file
  1/***************************************************************************/
  2/*                                                                         */
  3/*  ttdriver.c                                                             */
  4/*                                                                         */
  5/*    TrueType font driver implementation (body).                          */
  6/*                                                                         */
  7/*  Copyright 1996-2012 by                                                 */
  8/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
  9/*                                                                         */
 10/*  This file is part of the FreeType project, and may only be used,       */
 11/*  modified, and distributed under the terms of the FreeType project      */
 12/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
 13/*  this file you indicate that you have read the license and              */
 14/*  understand and accept it fully.                                        */
 15/*                                                                         */
 16/***************************************************************************/
 17
 18
 19#include <ft2build.h>
 20#include FT_INTERNAL_DEBUG_H
 21#include FT_INTERNAL_STREAM_H
 22#include FT_INTERNAL_SFNT_H
 23#include FT_SERVICE_XFREE86_NAME_H
 24
 25#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
 26#include FT_MULTIPLE_MASTERS_H
 27#include FT_SERVICE_MULTIPLE_MASTERS_H
 28#endif
 29
 30#include FT_SERVICE_TRUETYPE_ENGINE_H
 31#include FT_SERVICE_TRUETYPE_GLYF_H
 32
 33#include "ttdriver.h"
 34#include "ttgload.h"
 35#include "ttpload.h"
 36
 37#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
 38#include "ttgxvar.h"
 39#endif
 40
 41#include "tterrors.h"
 42
 43#include "ttpic.h"
 44
 45  /*************************************************************************/
 46  /*                                                                       */
 47  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
 48  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
 49  /* messages during execution.                                            */
 50  /*                                                                       */
 51#undef  FT_COMPONENT
 52#define FT_COMPONENT  trace_ttdriver
 53
 54
 55  /*************************************************************************/
 56  /*************************************************************************/
 57  /*************************************************************************/
 58  /****                                                                 ****/
 59  /****                                                                 ****/
 60  /****                          F A C E S                              ****/
 61  /****                                                                 ****/
 62  /****                                                                 ****/
 63  /*************************************************************************/
 64  /*************************************************************************/
 65  /*************************************************************************/
 66
 67
 68#undef  PAIR_TAG
 69#define PAIR_TAG( left, right )  ( ( (FT_ULong)left << 16 ) | \
 70                                     (FT_ULong)right        )
 71
 72
 73  /*************************************************************************/
 74  /*                                                                       */
 75  /* <Function>                                                            */
 76  /*    tt_get_kerning                                                     */
 77  /*                                                                       */
 78  /* <Description>                                                         */
 79  /*    A driver method used to return the kerning vector between two      */
 80  /*    glyphs of the same face.                                           */
 81  /*                                                                       */
 82  /* <Input>                                                               */
 83  /*    face        :: A handle to the source face object.                 */
 84  /*                                                                       */
 85  /*    left_glyph  :: The index of the left glyph in the kern pair.       */
 86  /*                                                                       */
 87  /*    right_glyph :: The index of the right glyph in the kern pair.      */
 88  /*                                                                       */
 89  /* <Output>                                                              */
 90  /*    kerning     :: The kerning vector.  This is in font units for      */
 91  /*                   scalable formats, and in pixels for fixed-sizes     */
 92  /*                   formats.                                            */
 93  /*                                                                       */
 94  /* <Return>                                                              */
 95  /*    FreeType error code.  0 means success.                             */
 96  /*                                                                       */
 97  /* <Note>                                                                */
 98  /*    Only horizontal layouts (left-to-right & right-to-left) are        */
 99  /*    supported by this function.  Other layouts, or more sophisticated  */
100  /*    kernings, are out of scope of this method (the basic driver        */
101  /*    interface is meant to be simple).                                  */
102  /*                                                                       */
103  /*    They can be implemented by format-specific interfaces.             */
104  /*                                                                       */
105  static FT_Error
106  tt_get_kerning( FT_Face     ttface,          /* TT_Face */
107                  FT_UInt     left_glyph,
108                  FT_UInt     right_glyph,
109                  FT_Vector*  kerning )
110  {
111    TT_Face       face = (TT_Face)ttface;
112    SFNT_Service  sfnt = (SFNT_Service)face->sfnt;
113
114
115    kerning->x = 0;
116    kerning->y = 0;
117
118    if ( sfnt )
119      kerning->x = sfnt->get_kerning( face, left_glyph, right_glyph );
120
121    return 0;
122  }
123
124
125#undef PAIR_TAG
126
127
128  static FT_Error
129  tt_get_advances( FT_Face    ttface,
130                   FT_UInt    start,
131                   FT_UInt    count,
132                   FT_Int32   flags,
133                   FT_Fixed  *advances )
134  {
135    FT_UInt  nn;
136    TT_Face  face  = (TT_Face) ttface;
137
138
139    /* XXX: TODO: check for sbits */
140
141    if ( flags & FT_LOAD_VERTICAL_LAYOUT )
142    {
143      for ( nn = 0; nn < count; nn++ )
144      {
145        FT_Short   tsb;
146        FT_UShort  ah;
147
148
149        TT_Get_VMetrics( face, start + nn, &tsb, &ah );
150        advances[nn] = ah;
151      }
152    }
153    else
154    {
155      for ( nn = 0; nn < count; nn++ )
156      {
157        FT_Short   lsb;
158        FT_UShort  aw;
159
160
161        TT_Get_HMetrics( face, start + nn, &lsb, &aw );
162        advances[nn] = aw;
163      }
164    }
165
166    return TT_Err_Ok;
167  }
168
169  /*************************************************************************/
170  /*************************************************************************/
171  /*************************************************************************/
172  /****                                                                 ****/
173  /****                                                                 ****/
174  /****                           S I Z E S                             ****/
175  /****                                                                 ****/
176  /****                                                                 ****/
177  /*************************************************************************/
178  /*************************************************************************/
179  /*************************************************************************/
180
181
182#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
183
184  static FT_Error
185  tt_size_select( FT_Size   size,
186                  FT_ULong  strike_index )
187  {
188    TT_Face   ttface = (TT_Face)size->face;
189    TT_Size   ttsize = (TT_Size)size;
190    FT_Error  error  = TT_Err_Ok;
191
192
193    ttsize->strike_index = strike_index;
194
195    if ( FT_IS_SCALABLE( size->face ) )
196    {
197      /* use the scaled metrics, even when tt_size_reset fails */
198      FT_Select_Metrics( size->face, strike_index );
199
200      tt_size_reset( ttsize );
201    }
202    else
203    {
204      SFNT_Service      sfnt    = (SFNT_Service) ttface->sfnt;
205      FT_Size_Metrics*  metrics = &size->metrics;
206
207
208      error = sfnt->load_strike_metrics( ttface, strike_index, metrics );
209      if ( error )
210        ttsize->strike_index = 0xFFFFFFFFUL;
211    }
212
213    return error;
214  }
215
216#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
217
218
219  static FT_Error
220  tt_size_request( FT_Size          size,
221                   FT_Size_Request  req )
222  {
223    TT_Size   ttsize = (TT_Size)size;
224    FT_Error  error  = TT_Err_Ok;
225
226
227#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
228
229    if ( FT_HAS_FIXED_SIZES( size->face ) )
230    {
231      TT_Face       ttface = (TT_Face)size->face;
232      SFNT_Service  sfnt   = (SFNT_Service) ttface->sfnt;
233      FT_ULong      strike_index;
234
235
236      error = sfnt->set_sbit_strike( ttface, req, &strike_index );
237
238      if ( error )
239        ttsize->strike_index = 0xFFFFFFFFUL;
240      else
241        return tt_size_select( size, strike_index );
242    }
243
244#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
245
246    FT_Request_Metrics( size->face, req );
247
248    if ( FT_IS_SCALABLE( size->face ) )
249    {
250      error = tt_size_reset( ttsize );
251      ttsize->root.metrics = ttsize->metrics;
252    }
253
254    return error;
255  }
256
257
258  /*************************************************************************/
259  /*                                                                       */
260  /* <Function>                                                            */
261  /*    tt_glyph_load                                                      */
262  /*                                                                       */
263  /* <Description>                                                         */
264  /*    A driver method used to load a glyph within a given glyph slot.    */
265  /*                                                                       */
266  /* <Input>                                                               */
267  /*    slot        :: A handle to the target slot object where the glyph  */
268  /*                   will be loaded.                                     */
269  /*                                                                       */
270  /*    size        :: A handle to the source face size at which the glyph */
271  /*                   must be scaled, loaded, etc.                        */
272  /*                                                                       */
273  /*    glyph_index :: The index of the glyph in the font file.            */
274  /*                                                                       */
275  /*    load_flags  :: A flag indicating what to load for this glyph.  The */
276  /*                   FT_LOAD_XXX constants can be used to control the    */
277  /*                   glyph loading process (e.g., whether the outline    */
278  /*                   should be scaled, whether to load bitmaps or not,   */
279  /*                   whether to hint the outline, etc).                  */
280  /*                                                                       */
281  /* <Return>                                                              */
282  /*    FreeType error code.  0 means success.                             */
283  /*                                                                       */
284  static FT_Error
285  tt_glyph_load( FT_GlyphSlot  ttslot,      /* TT_GlyphSlot */
286                 FT_Size       ttsize,      /* TT_Size      */
287                 FT_UInt       glyph_index,
288                 FT_Int32      load_flags )
289  {
290    TT_GlyphSlot  slot = (TT_GlyphSlot)ttslot;
291    TT_Size       size = (TT_Size)ttsize;
292    FT_Face       face = ttslot->face;
293    FT_Error      error;
294
295
296    if ( !slot )
297      return TT_Err_Invalid_Slot_Handle;
298
299    if ( !size )
300      return TT_Err_Invalid_Size_Handle;
301
302    if ( !face )
303      return TT_Err_Invalid_Argument;
304
305#ifdef FT_CONFIG_OPTION_INCREMENTAL
306    if ( glyph_index >= (FT_UInt)face->num_glyphs &&
307         !face->internal->incremental_interface   )
308#else
309    if ( glyph_index >= (FT_UInt)face->num_glyphs )
310#endif
311      return TT_Err_Invalid_Argument;
312
313    if ( load_flags & FT_LOAD_NO_HINTING )
314    {
315      /* both FT_LOAD_NO_HINTING and FT_LOAD_NO_AUTOHINT   */
316      /* are necessary to disable hinting for tricky fonts */
317
318      if ( FT_IS_TRICKY( face ) )
319        load_flags &= ~FT_LOAD_NO_HINTING;
320
321      if ( load_flags & FT_LOAD_NO_AUTOHINT )
322        load_flags |= FT_LOAD_NO_HINTING;
323    }
324
325    if ( load_flags & ( FT_LOAD_NO_RECURSE | FT_LOAD_NO_SCALE ) )
326    {
327      load_flags |= FT_LOAD_NO_BITMAP | FT_LOAD_NO_SCALE;
328
329      if ( !FT_IS_TRICKY( face ) )
330        load_flags |= FT_LOAD_NO_HINTING;
331    }
332
333    /* now load the glyph outline if necessary */
334    error = TT_Load_Glyph( size, slot, glyph_index, load_flags );
335
336    /* force drop-out mode to 2 - irrelevant now */
337    /* slot->outline.dropout_mode = 2; */
338
339    return error;
340  }
341
342
343  /*************************************************************************/
344  /*************************************************************************/
345  /*************************************************************************/
346  /****                                                                 ****/
347  /****                                                                 ****/
348  /****                D R I V E R  I N T E R F A C E                   ****/
349  /****                                                                 ****/
350  /****                                                                 ****/
351  /*************************************************************************/
352  /*************************************************************************/
353  /*************************************************************************/
354
355#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
356  FT_DEFINE_SERVICE_MULTIMASTERSREC(tt_service_gx_multi_masters,
357    (FT_Get_MM_Func)        NULL,
358    (FT_Set_MM_Design_Func) NULL,
359    (FT_Set_MM_Blend_Func)  TT_Set_MM_Blend,
360    (FT_Get_MM_Var_Func)    TT_Get_MM_Var,
361    (FT_Set_Var_Design_Func)TT_Set_Var_Design
362  )
363#endif
364
365  static const FT_Service_TrueTypeEngineRec  tt_service_truetype_engine =
366  {
367#ifdef TT_USE_BYTECODE_INTERPRETER
368
369#ifdef TT_CONFIG_OPTION_UNPATENTED_HINTING
370    FT_TRUETYPE_ENGINE_TYPE_UNPATENTED
371#else
372    FT_TRUETYPE_ENGINE_TYPE_PATENTED
373#endif
374
375#else /* !TT_USE_BYTECODE_INTERPRETER */
376
377    FT_TRUETYPE_ENGINE_TYPE_NONE
378
379#endif /* TT_USE_BYTECODE_INTERPRETER */
380  };
381
382  FT_DEFINE_SERVICE_TTGLYFREC(tt_service_truetype_glyf,
383    (TT_Glyf_GetLocationFunc)tt_face_get_location
384  )
385
386#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
387  FT_DEFINE_SERVICEDESCREC4(tt_services,
388    FT_SERVICE_ID_XF86_NAME,       FT_XF86_FORMAT_TRUETYPE,
389    FT_SERVICE_ID_MULTI_MASTERS,   &FT_TT_SERVICE_GX_MULTI_MASTERS_GET,
390    FT_SERVICE_ID_TRUETYPE_ENGINE, &tt_service_truetype_engine,
391    FT_SERVICE_ID_TT_GLYF,         &FT_TT_SERVICE_TRUETYPE_GLYF_GET
392  )
393#else
394  FT_DEFINE_SERVICEDESCREC3(tt_services,
395    FT_SERVICE_ID_XF86_NAME,       FT_XF86_FORMAT_TRUETYPE,
396    FT_SERVICE_ID_TRUETYPE_ENGINE, &tt_service_truetype_engine,
397    FT_SERVICE_ID_TT_GLYF,         &FT_TT_SERVICE_TRUETYPE_GLYF_GET
398  )
399#endif
400
401  FT_CALLBACK_DEF( FT_Module_Interface )
402  tt_get_interface( FT_Module    driver,    /* TT_Driver */
403                    const char*  tt_interface )
404  {
405    FT_Library           library;
406    FT_Module_Interface  result;
407    FT_Module            sfntd;
408    SFNT_Service         sfnt;
409
410
411    /* FT_TT_SERVICES_GET derefers `library' in PIC mode */
412#ifdef FT_CONFIG_OPTION_PIC
413    if ( !driver )
414      return NULL;
415    library = driver->library;
416    if ( !library )
417      return NULL;
418#endif
419
420    result = ft_service_list_lookup( FT_TT_SERVICES_GET, tt_interface );
421    if ( result != NULL )
422      return result;
423
424#ifndef FT_CONFIG_OPTION_PIC
425    if ( !driver )
426      return NULL;
427    library = driver->library;
428    if ( !library )
429      return NULL;
430#endif
431
432    /* only return the default interface from the SFNT module */
433    sfntd = FT_Get_Module( library, "sfnt" );
434    if ( sfntd )
435    {
436      sfnt = (SFNT_Service)( sfntd->clazz->module_interface );
437      if ( sfnt )
438        return sfnt->get_interface( driver, tt_interface );
439    }
440
441    return 0;
442  }
443
444
445  /* The FT_DriverInterface structure is defined in ftdriver.h. */
446
447#ifdef TT_USE_BYTECODE_INTERPRETER
448#define TT_HINTER_FLAG   FT_MODULE_DRIVER_HAS_HINTER
449#else
450#define TT_HINTER_FLAG   0
451#endif
452
453#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
454#define TT_SIZE_SELECT    tt_size_select
455#else
456#define TT_SIZE_SELECT    0
457#endif
458
459  FT_DEFINE_DRIVER( tt_driver_class,
460
461      FT_MODULE_FONT_DRIVER     |
462      FT_MODULE_DRIVER_SCALABLE |
463      TT_HINTER_FLAG,
464
465      sizeof ( TT_DriverRec ),
466
467      "truetype",      /* driver name                           */
468      0x10000L,        /* driver version == 1.0                 */
469      0x20000L,        /* driver requires FreeType 2.0 or above */
470
471      (void*)0,        /* driver specific interface */
472
473      tt_driver_init,
474      tt_driver_done,
475      tt_get_interface,
476
477    sizeof ( TT_FaceRec ),
478    sizeof ( TT_SizeRec ),
479    sizeof ( FT_GlyphSlotRec ),
480
481    tt_face_init,
482    tt_face_done,
483    tt_size_init,
484    tt_size_done,
485    tt_slot_init,
486    0,                       /* FT_Slot_DoneFunc */
487
488    ft_stub_set_char_sizes,  /* FT_CONFIG_OPTION_OLD_INTERNALS */
489    ft_stub_set_pixel_sizes, /* FT_CONFIG_OPTION_OLD_INTERNALS */
490
491    tt_glyph_load,
492
493    tt_get_kerning,
494    0,                       /* FT_Face_AttachFunc */
495    tt_get_advances,
496
497    tt_size_request,
498    TT_SIZE_SELECT
499  )
500
501
502/* END */