src/truetype/ttdriver.c

   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 */