/src/skia/third_party/externals/freetype/src/truetype/ttdriver.c

Source (jump to first uncovered line)
/****************************************************************************
 *
 * ttdriver.c
 *
 *   TrueType font driver implementation (body).
 *
 * Copyright (C) 1996-2021 by
 * David Turner, Robert Wilhelm, and Werner Lemberg.
 *
 * This file is part of the FreeType project, and may only be used,
 * modified, and distributed under the terms of the FreeType project
 * license, LICENSE.TXT.  By continuing to use, modify, or distribute
 * this file you indicate that you have read the license and
 * understand and accept it fully.
 *
 */


#include <freetype/internal/ftdebug.h>
#include <freetype/internal/ftstream.h>
#include <freetype/internal/sfnt.h>
#include <freetype/internal/services/svfntfmt.h>

#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
#include <freetype/ftmm.h>
#include <freetype/internal/services/svmm.h>
#include <freetype/internal/services/svmetric.h>
#endif

#include <freetype/internal/services/svtteng.h>
#include <freetype/internal/services/svttglyf.h>
#include <freetype/internal/services/svprop.h>
#include <freetype/ftdriver.h>

#include "ttdriver.h"
#include "ttgload.h"
#include "ttpload.h"

#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
#include "ttgxvar.h"
#endif

#include "tterrors.h"


  /**************************************************************************
   *
   * The macro FT_COMPONENT is used in trace mode.  It is an implicit
   * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
   * messages during execution.
   */
#undef  FT_COMPONENT
#define FT_COMPONENT  ttdriver


  /*
   * PROPERTY SERVICE
   *
   */
  static FT_Error
  tt_property_set( FT_Module    module,         /* TT_Driver */
                   const char*  property_name,
                   const void*  value,
                   FT_Bool      value_is_string )
  {
    FT_Error   error  = FT_Err_Ok;
    TT_Driver  driver = (TT_Driver)module;

#ifndef FT_CONFIG_OPTION_ENVIRONMENT_PROPERTIES
    FT_UNUSED( value_is_string );
#endif


    if ( !ft_strcmp( property_name, "interpreter-version" ) )
    {
      FT_UInt  interpreter_version;


#ifdef FT_CONFIG_OPTION_ENVIRONMENT_PROPERTIES
      if ( value_is_string )
      {
        const char*  s = (const char*)value;


        interpreter_version = (FT_UInt)ft_strtol( s, NULL, 10 );
      }
      else
#endif
      {
        FT_UInt*  iv = (FT_UInt*)value;


        interpreter_version = *iv;
      }

      if ( interpreter_version == TT_INTERPRETER_VERSION_35
#ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY
           || interpreter_version == TT_INTERPRETER_VERSION_38
#endif
#ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL
           || interpreter_version == TT_INTERPRETER_VERSION_40
#endif
         )
        driver->interpreter_version = interpreter_version;
      else
        error = FT_ERR( Unimplemented_Feature );

      return error;
    }

    FT_TRACE2(( "tt_property_set: missing property `%s'\n",
                property_name ));
    return FT_THROW( Missing_Property );
  }


  static FT_Error
  tt_property_get( FT_Module    module,         /* TT_Driver */
                   const char*  property_name,
                   const void*  value )
  {
    FT_Error   error  = FT_Err_Ok;
    TT_Driver  driver = (TT_Driver)module;

    FT_UInt  interpreter_version = driver->interpreter_version;


    if ( !ft_strcmp( property_name, "interpreter-version" ) )
    {
      FT_UInt*  val = (FT_UInt*)value;


      *val = interpreter_version;

      return error;
    }

    FT_TRACE2(( "tt_property_get: missing property `%s'\n",
                property_name ));
    return FT_THROW( Missing_Property );
  }


  FT_DEFINE_SERVICE_PROPERTIESREC(
    tt_service_properties,

    (FT_Properties_SetFunc)tt_property_set,     /* set_property */
    (FT_Properties_GetFunc)tt_property_get      /* get_property */
  )


  /*************************************************************************/
  /*************************************************************************/
  /*************************************************************************/
  /****                                                                 ****/
  /****                                                                 ****/
  /****                          F A C E S                              ****/
  /****                                                                 ****/
  /****                                                                 ****/
  /*************************************************************************/
  /*************************************************************************/
  /*************************************************************************/


  /**************************************************************************
   *
   * @Function:
   *   tt_get_kerning
   *
   * @Description:
   *   A driver method used to return the kerning vector between two
   *   glyphs of the same face.
   *
   * @Input:
   *   face ::
   *     A handle to the source face object.
   *
   *   left_glyph ::
   *     The index of the left glyph in the kern pair.
   *
   *   right_glyph ::
   *     The index of the right glyph in the kern pair.
   *
   * @Output:
   *   kerning ::
   *     The kerning vector.  This is in font units for
   *     scalable formats, and in pixels for fixed-sizes
   *     formats.
   *
   * @Return:
   *   FreeType error code.  0 means success.
   *
   * @Note:
   *   Only horizontal layouts (left-to-right & right-to-left) are
   *   supported by this function.  Other layouts, or more sophisticated
   *   kernings, are out of scope of this method (the basic driver
   *   interface is meant to be simple).
   *
   *   They can be implemented by format-specific interfaces.
   */
  static FT_Error
  tt_get_kerning( FT_Face     ttface,          /* TT_Face */
                  FT_UInt     left_glyph,
                  FT_UInt     right_glyph,
                  FT_Vector*  kerning )
  {
    TT_Face       face = (TT_Face)ttface;
    SFNT_Service  sfnt = (SFNT_Service)face->sfnt;


    kerning->x = 0;
    kerning->y = 0;

    if ( sfnt )
      kerning->x = sfnt->get_kerning( face, left_glyph, right_glyph );

    return 0;
  }


  static FT_Error
  tt_get_advances( FT_Face    ttface,
                   FT_UInt    start,
                   FT_UInt    count,
                   FT_Int32   flags,
                   FT_Fixed  *advances )
  {
    FT_UInt  nn;
    TT_Face  face = (TT_Face)ttface;


    /* XXX: TODO: check for sbits */

    if ( flags & FT_LOAD_VERTICAL_LAYOUT )
    {
#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
      /* no fast retrieval for blended MM fonts without VVAR table */
      if ( ( FT_IS_NAMED_INSTANCE( ttface ) || FT_IS_VARIATION( ttface ) ) &&
           !( face->variation_support & TT_FACE_FLAG_VAR_VADVANCE )        )
        return FT_THROW( Unimplemented_Feature );
#endif

      for ( nn = 0; nn < count; nn++ )
      {
        FT_Short   tsb;
        FT_UShort  ah;


        /* since we don't need `tsb', we use zero for `yMax' parameter */
        TT_Get_VMetrics( face, start + nn, 0, &tsb, &ah );
        advances[nn] = ah;
      }
    }
    else
    {
#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
      /* no fast retrieval for blended MM fonts without HVAR table */
      if ( ( FT_IS_NAMED_INSTANCE( ttface ) || FT_IS_VARIATION( ttface ) ) &&
           !( face->variation_support & TT_FACE_FLAG_VAR_HADVANCE )        )
        return FT_THROW( Unimplemented_Feature );
#endif

      for ( nn = 0; nn < count; nn++ )
      {
        FT_Short   lsb;
        FT_UShort  aw;


        TT_Get_HMetrics( face, start + nn, &lsb, &aw );
        advances[nn] = aw;
      }
    }

    return FT_Err_Ok;
  }


  /*************************************************************************/
  /*************************************************************************/
  /*************************************************************************/
  /****                                                                 ****/
  /****                                                                 ****/
  /****                           S I Z E S                             ****/
  /****                                                                 ****/
  /****                                                                 ****/
  /*************************************************************************/
  /*************************************************************************/
  /*************************************************************************/


#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS

  static FT_Error
  tt_size_select( FT_Size   size,
                  FT_ULong  strike_index )
  {
    TT_Face   ttface = (TT_Face)size->face;
    TT_Size   ttsize = (TT_Size)size;
    FT_Error  error  = FT_Err_Ok;


    ttsize->strike_index = strike_index;

    if ( FT_IS_SCALABLE( size->face ) )
    {
      /* use the scaled metrics, even when tt_size_reset fails */
      FT_Select_Metrics( size->face, strike_index );

      tt_size_reset( ttsize, 0 ); /* ignore return value */
    }
    else
    {
      SFNT_Service      sfnt         = (SFNT_Service)ttface->sfnt;
      FT_Size_Metrics*  size_metrics = &size->metrics;


      error = sfnt->load_strike_metrics( ttface,
                                         strike_index,
                                         size_metrics );
      if ( error )
        ttsize->strike_index = 0xFFFFFFFFUL;
    }

    return error;
  }

#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */


  static FT_Error
  tt_size_request( FT_Size          size,
                   FT_Size_Request  req )
  {
    TT_Size   ttsize = (TT_Size)size;
    FT_Error  error  = FT_Err_Ok;


#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS

    if ( FT_HAS_FIXED_SIZES( size->face ) )
    {
      TT_Face       ttface = (TT_Face)size->face;
      SFNT_Service  sfnt   = (SFNT_Service)ttface->sfnt;
      FT_ULong      strike_index;


      error = sfnt->set_sbit_strike( ttface, req, &strike_index );

      if ( error )
        ttsize->strike_index = 0xFFFFFFFFUL;
      else
        return tt_size_select( size, strike_index );
    }

#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */

    FT_Request_Metrics( size->face, req );

    if ( FT_IS_SCALABLE( size->face ) )
    {
      error = tt_size_reset( ttsize, 0 );

#ifdef TT_USE_BYTECODE_INTERPRETER
      /* for the `MPS' bytecode instruction we need the point size */
      if ( !error )
      {
        FT_UInt  resolution =
                   ttsize->metrics->x_ppem > ttsize->metrics->y_ppem
                     ? req->horiResolution
                     : req->vertResolution;


        /* if we don't have a resolution value, assume 72dpi */
        if ( req->type == FT_SIZE_REQUEST_TYPE_SCALES ||
             !resolution                              )
          resolution = 72;

        ttsize->point_size = FT_MulDiv( ttsize->ttmetrics.ppem,
                                        64 * 72,
                                        resolution );
      }
#endif
    }

    return error;
  }


  /**************************************************************************
   *
   * @Function:
   *   tt_glyph_load
   *
   * @Description:
   *   A driver method used to load a glyph within a given glyph slot.
   *
   * @Input:
   *   slot ::
   *     A handle to the target slot object where the glyph
   *     will be loaded.
   *
   *   size ::
   *     A handle to the source face size at which the glyph
   *     must be scaled, loaded, etc.
   *
   *   glyph_index ::
   *     The index of the glyph in the font file.
   *
   *   load_flags ::
   *     A flag indicating what to load for this glyph.  The
   *     FT_LOAD_XXX constants can be used to control the
   *     glyph loading process (e.g., whether the outline
   *     should be scaled, whether to load bitmaps or not,
   *     whether to hint the outline, etc).
   *
   * @Return:
   *   FreeType error code.  0 means success.
   */
  static FT_Error
  tt_glyph_load( FT_GlyphSlot  ttslot,      /* TT_GlyphSlot */
                 FT_Size       ttsize,      /* TT_Size      */
                 FT_UInt       glyph_index,
                 FT_Int32      load_flags )
  {
    TT_GlyphSlot  slot = (TT_GlyphSlot)ttslot;
    TT_Size       size = (TT_Size)ttsize;
    FT_Face       face = ttslot->face;
    FT_Error      error;


    if ( !slot )
      return FT_THROW( Invalid_Slot_Handle );

    if ( !size )
      return FT_THROW( Invalid_Size_Handle );

    if ( !face )
      return FT_THROW( Invalid_Face_Handle );

#ifdef FT_CONFIG_OPTION_INCREMENTAL
    if ( glyph_index >= (FT_UInt)face->num_glyphs &&
         !face->internal->incremental_interface   )
#else
    if ( glyph_index >= (FT_UInt)face->num_glyphs )
#endif
      return FT_THROW( Invalid_Argument );

    if ( load_flags & FT_LOAD_NO_HINTING )
    {
      /* both FT_LOAD_NO_HINTING and FT_LOAD_NO_AUTOHINT   */
      /* are necessary to disable hinting for tricky fonts */

      if ( FT_IS_TRICKY( face ) )
        load_flags &= ~FT_LOAD_NO_HINTING;

      if ( load_flags & FT_LOAD_NO_AUTOHINT )
        load_flags |= FT_LOAD_NO_HINTING;
    }

    if ( load_flags & ( FT_LOAD_NO_RECURSE | FT_LOAD_NO_SCALE ) )
    {
      load_flags |= FT_LOAD_NO_BITMAP | FT_LOAD_NO_SCALE;

      if ( !FT_IS_TRICKY( face ) )
        load_flags |= FT_LOAD_NO_HINTING;
    }

    /* use hinted metrics only if we load a glyph with hinting */
    size->metrics = ( load_flags & FT_LOAD_NO_HINTING )
                      ? &ttsize->metrics
                      : &size->hinted_metrics;

    /* now fill in the glyph slot with outline/bitmap/layered */
    error = TT_Load_Glyph( size, slot, glyph_index, load_flags );

    /* force drop-out mode to 2 - irrelevant now */
    /* slot->outline.dropout_mode = 2; */

    return error;
  }


  /*************************************************************************/
  /*************************************************************************/
  /*************************************************************************/
  /****                                                                 ****/
  /****                                                                 ****/
  /****                D R I V E R  I N T E R F A C E                   ****/
  /****                                                                 ****/
  /****                                                                 ****/
  /*************************************************************************/
  /*************************************************************************/
  /*************************************************************************/

#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT

  FT_DEFINE_SERVICE_MULTIMASTERSREC(
    tt_service_gx_multi_masters,

    (FT_Get_MM_Func)             NULL,                  /* get_mm              */
    (FT_Set_MM_Design_Func)      NULL,                  /* set_mm_design       */
    (FT_Set_MM_Blend_Func)       TT_Set_MM_Blend,       /* set_mm_blend        */
    (FT_Get_MM_Blend_Func)       TT_Get_MM_Blend,       /* get_mm_blend        */
    (FT_Get_MM_Var_Func)         TT_Get_MM_Var,         /* get_mm_var          */
    (FT_Set_Var_Design_Func)     TT_Set_Var_Design,     /* set_var_design      */
    (FT_Get_Var_Design_Func)     TT_Get_Var_Design,     /* get_var_design      */
    (FT_Set_Instance_Func)       TT_Set_Named_Instance, /* set_instance        */
    (FT_Set_MM_WeightVector_Func)NULL,                  /* set_mm_weightvector */
    (FT_Get_MM_WeightVector_Func)NULL,                  /* get_mm_weightvector */

    (FT_Get_Var_Blend_Func)      tt_get_var_blend,      /* get_var_blend       */
    (FT_Done_Blend_Func)         tt_done_blend          /* done_blend          */
  )

  FT_DEFINE_SERVICE_METRICSVARIATIONSREC(
    tt_service_metrics_variations,

    (FT_HAdvance_Adjust_Func)tt_hadvance_adjust,     /* hadvance_adjust */
    (FT_LSB_Adjust_Func)     NULL,                   /* lsb_adjust      */
    (FT_RSB_Adjust_Func)     NULL,                   /* rsb_adjust      */

    (FT_VAdvance_Adjust_Func)tt_vadvance_adjust,     /* vadvance_adjust */
    (FT_TSB_Adjust_Func)     NULL,                   /* tsb_adjust      */
    (FT_BSB_Adjust_Func)     NULL,                   /* bsb_adjust      */
    (FT_VOrg_Adjust_Func)    NULL,                   /* vorg_adjust     */

    (FT_Metrics_Adjust_Func) tt_apply_mvar           /* metrics_adjust  */
  )

#endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */


  static const FT_Service_TrueTypeEngineRec  tt_service_truetype_engine =
  {
#ifdef TT_USE_BYTECODE_INTERPRETER

    FT_TRUETYPE_ENGINE_TYPE_PATENTED

#else /* !TT_USE_BYTECODE_INTERPRETER */

    FT_TRUETYPE_ENGINE_TYPE_NONE

#endif /* TT_USE_BYTECODE_INTERPRETER */
  };


  FT_DEFINE_SERVICE_TTGLYFREC(
    tt_service_truetype_glyf,

    (TT_Glyf_GetLocationFunc)tt_face_get_location      /* get_location */
  )


#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
  FT_DEFINE_SERVICEDESCREC6(
    tt_services,

    FT_SERVICE_ID_FONT_FORMAT,        FT_FONT_FORMAT_TRUETYPE,
    FT_SERVICE_ID_MULTI_MASTERS,      &tt_service_gx_multi_masters,
    FT_SERVICE_ID_METRICS_VARIATIONS, &tt_service_metrics_variations,
    FT_SERVICE_ID_TRUETYPE_ENGINE,    &tt_service_truetype_engine,
    FT_SERVICE_ID_TT_GLYF,            &tt_service_truetype_glyf,
    FT_SERVICE_ID_PROPERTIES,         &tt_service_properties )
#else
  FT_DEFINE_SERVICEDESCREC4(
    tt_services,

    FT_SERVICE_ID_FONT_FORMAT,     FT_FONT_FORMAT_TRUETYPE,
    FT_SERVICE_ID_TRUETYPE_ENGINE, &tt_service_truetype_engine,
    FT_SERVICE_ID_TT_GLYF,         &tt_service_truetype_glyf,
    FT_SERVICE_ID_PROPERTIES,      &tt_service_properties )
#endif


  FT_CALLBACK_DEF( FT_Module_Interface )
  tt_get_interface( FT_Module    driver,    /* TT_Driver */
                    const char*  tt_interface )
  {
    FT_Library           library;
    FT_Module_Interface  result;
    FT_Module            sfntd;
    SFNT_Service         sfnt;


    result = ft_service_list_lookup( tt_services, tt_interface );
    if ( result )
      return result;

    if ( !driver )
      return NULL;
    library = driver->library;
    if ( !library )
      return NULL;

    /* only return the default interface from the SFNT module */
    sfntd = FT_Get_Module( library, "sfnt" );
    if ( sfntd )
    {
      sfnt = (SFNT_Service)( sfntd->clazz->module_interface );
      if ( sfnt )
        return sfnt->get_interface( driver, tt_interface );
    }

    return 0;
  }


  /* The FT_DriverInterface structure is defined in ftdriver.h. */

#ifdef TT_USE_BYTECODE_INTERPRETER
#define TT_HINTER_FLAG  FT_MODULE_DRIVER_HAS_HINTER
#else
#define TT_HINTER_FLAG  0
#endif

#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
#define TT_SIZE_SELECT  tt_size_select
#else
#define TT_SIZE_SELECT  0
#endif

  FT_DEFINE_DRIVER(
    tt_driver_class,

      FT_MODULE_FONT_DRIVER     |
      FT_MODULE_DRIVER_SCALABLE |
      TT_HINTER_FLAG,

      sizeof ( TT_DriverRec ),

      "truetype",      /* driver name                           */
      0x10000L,        /* driver version == 1.0                 */
      0x20000L,        /* driver requires FreeType 2.0 or above */

      NULL,    /* module-specific interface */

      tt_driver_init,           /* FT_Module_Constructor  module_init   */
      tt_driver_done,           /* FT_Module_Destructor   module_done   */
      tt_get_interface,         /* FT_Module_Requester    get_interface */

    sizeof ( TT_FaceRec ),
    sizeof ( TT_SizeRec ),
    sizeof ( FT_GlyphSlotRec ),

    tt_face_init,               /* FT_Face_InitFunc  init_face */
    tt_face_done,               /* FT_Face_DoneFunc  done_face */
    tt_size_init,               /* FT_Size_InitFunc  init_size */
    tt_size_done,               /* FT_Size_DoneFunc  done_size */
    tt_slot_init,               /* FT_Slot_InitFunc  init_slot */
    NULL,                       /* FT_Slot_DoneFunc  done_slot */

    tt_glyph_load,              /* FT_Slot_LoadFunc  load_glyph */

    tt_get_kerning,             /* FT_Face_GetKerningFunc   get_kerning  */
    NULL,                       /* FT_Face_AttachFunc       attach_file  */
    tt_get_advances,            /* FT_Face_GetAdvancesFunc  get_advances */

    tt_size_request,            /* FT_Size_RequestFunc  request_size */
    TT_SIZE_SELECT              /* FT_Size_SelectFunc   select_size  */
  )


/* END */

Coverage Report

Created: 2021-08-22 09:07

Line	Count	Source (jump to first uncovered line)
1		/****************************************************************************
2		*
3		* ttdriver.c
4		*
5		* TrueType font driver implementation (body).
6		*
7		* Copyright (C) 1996-2021 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 <freetype/internal/ftdebug.h>
20		#include <freetype/internal/ftstream.h>
21		#include <freetype/internal/sfnt.h>
22		#include <freetype/internal/services/svfntfmt.h>
23
24		#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
25		#include <freetype/ftmm.h>
26		#include <freetype/internal/services/svmm.h>
27		#include <freetype/internal/services/svmetric.h>
28		#endif
29
30		#include <freetype/internal/services/svtteng.h>
31		#include <freetype/internal/services/svttglyf.h>
32		#include <freetype/internal/services/svprop.h>
33		#include <freetype/ftdriver.h>
34
35		#include "ttdriver.h"
36		#include "ttgload.h"
37		#include "ttpload.h"
38
39		#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
40		#include "ttgxvar.h"
41		#endif
42
43		#include "tterrors.h"
44
45
46		/**************************************************************************
47		*
48		* The macro FT_COMPONENT is used in trace mode. It is an implicit
49		* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
50		* messages during execution.
51		*/
52		#undef FT_COMPONENT
53		#define FT_COMPONENT ttdriver
54
55
56		/*
57		* PROPERTY SERVICE
58		*
59		*/
60		static FT_Error
61		tt_property_set( FT_Module module, /* TT_Driver */
62		const char* property_name,
63		const void* value,
64		FT_Bool value_is_string )
65		{
66		FT_Error error = FT_Err_Ok;
67		TT_Driver driver = (TT_Driver)module;
68
69		#ifndef FT_CONFIG_OPTION_ENVIRONMENT_PROPERTIES
70		FT_UNUSED( value_is_string );
71		#endif
72
73
74		if ( !ft_strcmp( property_name, "interpreter-version" ) )
75		{
76		FT_UInt interpreter_version;
77
78
79		#ifdef FT_CONFIG_OPTION_ENVIRONMENT_PROPERTIES
80		if ( value_is_string )
81		{
82		const char* s = (const char*)value;
83
84
85		interpreter_version = (FT_UInt)ft_strtol( s, NULL, 10 );
86		}
87		else
88		#endif
89		{
90		FT_UInt* iv = (FT_UInt*)value;
91
92
93		interpreter_version = *iv;
94		}
95
96		if ( interpreter_version == TT_INTERPRETER_VERSION_35
97		#ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY
98		\|\| interpreter_version == TT_INTERPRETER_VERSION_38
99		#endif
100		#ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL
101		\|\| interpreter_version == TT_INTERPRETER_VERSION_40
102		#endif
103		)
104		driver->interpreter_version = interpreter_version;
105		else
106		error = FT_ERR( Unimplemented_Feature );
107
108		return error;
109		}
110
111		FT_TRACE2(( "tt_property_set: missing property `%s'\n",
112		property_name ));
113		return FT_THROW( Missing_Property );
114		}
115
116
117		static FT_Error
118		tt_property_get( FT_Module module, /* TT_Driver */
119		const char* property_name,
120		const void* value )
121	0	{
122	0	FT_Error error = FT_Err_Ok;
123	0	TT_Driver driver = (TT_Driver)module;
124
125	0	FT_UInt interpreter_version = driver->interpreter_version;
126
127
128	0	if ( !ft_strcmp( property_name, "interpreter-version" ) )
129	0	{
130	0	FT_UInt* val = (FT_UInt*)value;
131
132
133	0	*val = interpreter_version;
134
135	0	return error;
136	0	}
137
138	0	FT_TRACE2(( "tt_property_get: missing property `%s'\n",
139	0	property_name ));
140	0	return FT_THROW( Missing_Property );
141	0	}
142
143
144		FT_DEFINE_SERVICE_PROPERTIESREC(
145		tt_service_properties,
146
147		(FT_Properties_SetFunc)tt_property_set, /* set_property */
148		(FT_Properties_GetFunc)tt_property_get /* get_property */
149		)
150
151
152		/*************************************************************************/
153		/*************************************************************************/
154		/*************************************************************************/
155		/** **/
156		/** **/
157		/** F A C E S **/
158		/** **/
159		/** **/
160		/*************************************************************************/
161		/*************************************************************************/
162		/*************************************************************************/
163
164
165		/**************************************************************************
166		*
167		* @Function:
168		* tt_get_kerning
169		*
170		* @Description:
171		* A driver method used to return the kerning vector between two
172		* glyphs of the same face.
173		*
174		* @Input:
175		* face ::
176		* A handle to the source face object.
177		*
178		* left_glyph ::
179		* The index of the left glyph in the kern pair.
180		*
181		* right_glyph ::
182		* The index of the right glyph in the kern pair.
183		*
184		* @Output:
185		* kerning ::
186		* The kerning vector. This is in font units for
187		* scalable formats, and in pixels for fixed-sizes
188		* formats.
189		*
190		* @Return:
191		* FreeType error code. 0 means success.
192		*
193		* @Note:
194		* Only horizontal layouts (left-to-right & right-to-left) are
195		* supported by this function. Other layouts, or more sophisticated
196		* kernings, are out of scope of this method (the basic driver
197		* interface is meant to be simple).
198		*
199		* They can be implemented by format-specific interfaces.
200		*/
201		static FT_Error
202		tt_get_kerning( FT_Face ttface, /* TT_Face */
203		FT_UInt left_glyph,
204		FT_UInt right_glyph,
205		FT_Vector* kerning )
206	0	{
207	0	TT_Face face = (TT_Face)ttface;
208	0	SFNT_Service sfnt = (SFNT_Service)face->sfnt;
209
210
211	0	kerning->x = 0;
212	0	kerning->y = 0;
213
214	0	if ( sfnt )
215	0	kerning->x = sfnt->get_kerning( face, left_glyph, right_glyph );
216
217	0	return 0;
218	0	}
219
220
221		static FT_Error
222		tt_get_advances( FT_Face ttface,
223		FT_UInt start,
224		FT_UInt count,
225		FT_Int32 flags,
226		FT_Fixed *advances )
227	0	{
228	0	FT_UInt nn;
229	0	TT_Face face = (TT_Face)ttface;
230
231
232		/* XXX: TODO: check for sbits */
233
234	0	if ( flags & FT_LOAD_VERTICAL_LAYOUT )
235	0	{
236	0	#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
237		/* no fast retrieval for blended MM fonts without VVAR table */
238	0	if ( ( FT_IS_NAMED_INSTANCE( ttface ) \|\| FT_IS_VARIATION( ttface ) ) &&
239	0	!( face->variation_support & TT_FACE_FLAG_VAR_VADVANCE ) )
240	0	return FT_THROW( Unimplemented_Feature );
241	0	#endif
242
243	0	for ( nn = 0; nn < count; nn++ )
244	0	{
245	0	FT_Short tsb;
246	0	FT_UShort ah;
247
248
249		/* since we don't need `tsb', we use zero for `yMax' parameter */
250	0	TT_Get_VMetrics( face, start + nn, 0, &tsb, &ah );
251	0	advances[nn] = ah;
252	0	}
253	0	}
254	0	else
255	0	{
256	0	#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
257		/* no fast retrieval for blended MM fonts without HVAR table */
258	0	if ( ( FT_IS_NAMED_INSTANCE( ttface ) \|\| FT_IS_VARIATION( ttface ) ) &&
259	0	!( face->variation_support & TT_FACE_FLAG_VAR_HADVANCE ) )
260	0	return FT_THROW( Unimplemented_Feature );
261	0	#endif
262
263	0	for ( nn = 0; nn < count; nn++ )
264	0	{
265	0	FT_Short lsb;
266	0	FT_UShort aw;
267
268
269	0	TT_Get_HMetrics( face, start + nn, &lsb, &aw );
270	0	advances[nn] = aw;
271	0	}
272	0	}
273
274	0	return FT_Err_Ok;
275	0	}
276
277
278		/*************************************************************************/
279		/*************************************************************************/
280		/*************************************************************************/
281		/** **/
282		/** **/
283		/** S I Z E S **/
284		/** **/
285		/** **/
286		/*************************************************************************/
287		/*************************************************************************/
288		/*************************************************************************/
289
290
291		#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
292
293		static FT_Error
294		tt_size_select( FT_Size size,
295		FT_ULong strike_index )
296	0	{
297	0	TT_Face ttface = (TT_Face)size->face;
298	0	TT_Size ttsize = (TT_Size)size;
299	0	FT_Error error = FT_Err_Ok;
300
301
302	0	ttsize->strike_index = strike_index;
303
304	0	if ( FT_IS_SCALABLE( size->face ) )
305	0	{
306		/* use the scaled metrics, even when tt_size_reset fails */
307	0	FT_Select_Metrics( size->face, strike_index );
308
309	0	tt_size_reset( ttsize, 0 ); /* ignore return value */
310	0	}
311	0	else
312	0	{
313	0	SFNT_Service sfnt = (SFNT_Service)ttface->sfnt;
314	0	FT_Size_Metrics* size_metrics = &size->metrics;
315
316
317	0	error = sfnt->load_strike_metrics( ttface,
318	0	strike_index,
319	0	size_metrics );
320	0	if ( error )
321	0	ttsize->strike_index = 0xFFFFFFFFUL;
322	0	}
323
324	0	return error;
325	0	}
326
327		#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
328
329
330		static FT_Error
331		tt_size_request( FT_Size size,
332		FT_Size_Request req )
333	0	{
334	0	TT_Size ttsize = (TT_Size)size;
335	0	FT_Error error = FT_Err_Ok;
336
337
338	0	#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
339
340	0	if ( FT_HAS_FIXED_SIZES( size->face ) )
341	0	{
342	0	TT_Face ttface = (TT_Face)size->face;
343	0	SFNT_Service sfnt = (SFNT_Service)ttface->sfnt;
344	0	FT_ULong strike_index;
345
346
347	0	error = sfnt->set_sbit_strike( ttface, req, &strike_index );
348
349	0	if ( error )
350	0	ttsize->strike_index = 0xFFFFFFFFUL;
351	0	else
352	0	return tt_size_select( size, strike_index );
353	0	}
354
355	0	#endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
356
357	0	FT_Request_Metrics( size->face, req );
358
359	0	if ( FT_IS_SCALABLE( size->face ) )
360	0	{
361	0	error = tt_size_reset( ttsize, 0 );
362
363	0	#ifdef TT_USE_BYTECODE_INTERPRETER
364		/* for the `MPS' bytecode instruction we need the point size */
365	0	if ( !error )
366	0	{
367	0	FT_UInt resolution =
368	0	ttsize->metrics->x_ppem > ttsize->metrics->y_ppem
369	0	? req->horiResolution
370	0	: req->vertResolution;
371
372
373		/* if we don't have a resolution value, assume 72dpi */
374	0	if ( req->type == FT_SIZE_REQUEST_TYPE_SCALES \|\|
375	0	!resolution )
376	0	resolution = 72;
377
378	0	ttsize->point_size = FT_MulDiv( ttsize->ttmetrics.ppem,
379	0	64 * 72,
380	0	resolution );
381	0	}
382	0	#endif
383	0	}
384
385	0	return error;
386	0	}
387
388
389		/**************************************************************************
390		*
391		* @Function:
392		* tt_glyph_load
393		*
394		* @Description:
395		* A driver method used to load a glyph within a given glyph slot.
396		*
397		* @Input:
398		* slot ::
399		* A handle to the target slot object where the glyph
400		* will be loaded.
401		*
402		* size ::
403		* A handle to the source face size at which the glyph
404		* must be scaled, loaded, etc.
405		*
406		* glyph_index ::
407		* The index of the glyph in the font file.
408		*
409		* load_flags ::
410		* A flag indicating what to load for this glyph. The
411		* FT_LOAD_XXX constants can be used to control the
412		* glyph loading process (e.g., whether the outline
413		* should be scaled, whether to load bitmaps or not,
414		* whether to hint the outline, etc).
415		*
416		* @Return:
417		* FreeType error code. 0 means success.
418		*/
419		static FT_Error
420		tt_glyph_load( FT_GlyphSlot ttslot, /* TT_GlyphSlot */
421		FT_Size ttsize, /* TT_Size */
422		FT_UInt glyph_index,
423		FT_Int32 load_flags )
424	0	{
425	0	TT_GlyphSlot slot = (TT_GlyphSlot)ttslot;
426	0	TT_Size size = (TT_Size)ttsize;
427	0	FT_Face face = ttslot->face;
428	0	FT_Error error;
429
430
431	0	if ( !slot )
432	0	return FT_THROW( Invalid_Slot_Handle );
433
434	0	if ( !size )
435	0	return FT_THROW( Invalid_Size_Handle );
436
437	0	if ( !face )
438	0	return FT_THROW( Invalid_Face_Handle );
439
440	0	#ifdef FT_CONFIG_OPTION_INCREMENTAL
441	0	if ( glyph_index >= (FT_UInt)face->num_glyphs &&
442	0	!face->internal->incremental_interface )
443		#else
444		if ( glyph_index >= (FT_UInt)face->num_glyphs )
445		#endif
446	0	return FT_THROW( Invalid_Argument );
447
448	0	if ( load_flags & FT_LOAD_NO_HINTING )
449	0	{
450		/* both FT_LOAD_NO_HINTING and FT_LOAD_NO_AUTOHINT */
451		/* are necessary to disable hinting for tricky fonts */
452
453	0	if ( FT_IS_TRICKY( face ) )
454	0	load_flags &= ~FT_LOAD_NO_HINTING;
455
456	0	if ( load_flags & FT_LOAD_NO_AUTOHINT )
457	0	load_flags \|= FT_LOAD_NO_HINTING;
458	0	}
459
460	0	if ( load_flags & ( FT_LOAD_NO_RECURSE \| FT_LOAD_NO_SCALE ) )
461	0	{
462	0	load_flags \|= FT_LOAD_NO_BITMAP \| FT_LOAD_NO_SCALE;
463
464	0	if ( !FT_IS_TRICKY( face ) )
465	0	load_flags \|= FT_LOAD_NO_HINTING;
466	0	}
467
468		/* use hinted metrics only if we load a glyph with hinting */
469	0	size->metrics = ( load_flags & FT_LOAD_NO_HINTING )
470	0	? &ttsize->metrics
471	0	: &size->hinted_metrics;
472
473		/* now fill in the glyph slot with outline/bitmap/layered */
474	0	error = TT_Load_Glyph( size, slot, glyph_index, load_flags );
475
476		/* force drop-out mode to 2 - irrelevant now */
477		/* slot->outline.dropout_mode = 2; */
478
479	0	return error;
480	0	}
481
482
483		/*************************************************************************/
484		/*************************************************************************/
485		/*************************************************************************/
486		/** **/
487		/** **/
488		/** D R I V E R I N T E R F A C E **/
489		/** **/
490		/** **/
491		/*************************************************************************/
492		/*************************************************************************/
493		/*************************************************************************/
494
495		#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
496
497		FT_DEFINE_SERVICE_MULTIMASTERSREC(
498		tt_service_gx_multi_masters,
499
500		(FT_Get_MM_Func) NULL, /* get_mm */
501		(FT_Set_MM_Design_Func) NULL, /* set_mm_design */
502		(FT_Set_MM_Blend_Func) TT_Set_MM_Blend, /* set_mm_blend */
503		(FT_Get_MM_Blend_Func) TT_Get_MM_Blend, /* get_mm_blend */
504		(FT_Get_MM_Var_Func) TT_Get_MM_Var, /* get_mm_var */
505		(FT_Set_Var_Design_Func) TT_Set_Var_Design, /* set_var_design */
506		(FT_Get_Var_Design_Func) TT_Get_Var_Design, /* get_var_design */
507		(FT_Set_Instance_Func) TT_Set_Named_Instance, /* set_instance */
508		(FT_Set_MM_WeightVector_Func)NULL, /* set_mm_weightvector */
509		(FT_Get_MM_WeightVector_Func)NULL, /* get_mm_weightvector */
510
511		(FT_Get_Var_Blend_Func) tt_get_var_blend, /* get_var_blend */
512		(FT_Done_Blend_Func) tt_done_blend /* done_blend */
513		)
514
515		FT_DEFINE_SERVICE_METRICSVARIATIONSREC(
516		tt_service_metrics_variations,
517
518		(FT_HAdvance_Adjust_Func)tt_hadvance_adjust, /* hadvance_adjust */
519		(FT_LSB_Adjust_Func) NULL, /* lsb_adjust */
520		(FT_RSB_Adjust_Func) NULL, /* rsb_adjust */
521
522		(FT_VAdvance_Adjust_Func)tt_vadvance_adjust, /* vadvance_adjust */
523		(FT_TSB_Adjust_Func) NULL, /* tsb_adjust */
524		(FT_BSB_Adjust_Func) NULL, /* bsb_adjust */
525		(FT_VOrg_Adjust_Func) NULL, /* vorg_adjust */
526
527		(FT_Metrics_Adjust_Func) tt_apply_mvar /* metrics_adjust */
528		)
529
530		#endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */
531
532
533		static const FT_Service_TrueTypeEngineRec tt_service_truetype_engine =
534		{
535		#ifdef TT_USE_BYTECODE_INTERPRETER
536
537		FT_TRUETYPE_ENGINE_TYPE_PATENTED
538
539		#else /* !TT_USE_BYTECODE_INTERPRETER */
540
541		FT_TRUETYPE_ENGINE_TYPE_NONE
542
543		#endif /* TT_USE_BYTECODE_INTERPRETER */
544		};
545
546
547		FT_DEFINE_SERVICE_TTGLYFREC(
548		tt_service_truetype_glyf,
549
550		(TT_Glyf_GetLocationFunc)tt_face_get_location /* get_location */
551		)
552
553
554		#ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
555		FT_DEFINE_SERVICEDESCREC6(
556		tt_services,
557
558		FT_SERVICE_ID_FONT_FORMAT, FT_FONT_FORMAT_TRUETYPE,
559		FT_SERVICE_ID_MULTI_MASTERS, &tt_service_gx_multi_masters,
560		FT_SERVICE_ID_METRICS_VARIATIONS, &tt_service_metrics_variations,
561		FT_SERVICE_ID_TRUETYPE_ENGINE, &tt_service_truetype_engine,
562		FT_SERVICE_ID_TT_GLYF, &tt_service_truetype_glyf,
563		FT_SERVICE_ID_PROPERTIES, &tt_service_properties )
564		#else
565		FT_DEFINE_SERVICEDESCREC4(
566		tt_services,
567
568		FT_SERVICE_ID_FONT_FORMAT, FT_FONT_FORMAT_TRUETYPE,
569		FT_SERVICE_ID_TRUETYPE_ENGINE, &tt_service_truetype_engine,
570		FT_SERVICE_ID_TT_GLYF, &tt_service_truetype_glyf,
571		FT_SERVICE_ID_PROPERTIES, &tt_service_properties )
572		#endif
573
574
575		FT_CALLBACK_DEF( FT_Module_Interface )
576		tt_get_interface( FT_Module driver, /* TT_Driver */
577		const char* tt_interface )
578	49.9k	{
579	49.9k	FT_Library library;
580	49.9k	FT_Module_Interface result;
581	49.9k	FT_Module sfntd;
582	49.9k	SFNT_Service sfnt;
583
584
585	49.9k	result = ft_service_list_lookup( tt_services, tt_interface );
586	49.9k	if ( result )
587	25.0k	return result;
588
589	24.9k	if ( !driver )
590	0	return NULL;
591	24.9k	library = driver->library;
592	24.9k	if ( !library )
593	0	return NULL;
594
595		/* only return the default interface from the SFNT module */
596	24.9k	sfntd = FT_Get_Module( library, "sfnt" );
597	24.9k	if ( sfntd )
598	24.9k	{
599	24.9k	sfnt = (SFNT_Service)( sfntd->clazz->module_interface );
600	24.9k	if ( sfnt )
601	24.9k	return sfnt->get_interface( driver, tt_interface );
602	0	}
603
604	0	return 0;
605	0	}
606
607
608		/* The FT_DriverInterface structure is defined in ftdriver.h. */
609
610		#ifdef TT_USE_BYTECODE_INTERPRETER
611		#define TT_HINTER_FLAG FT_MODULE_DRIVER_HAS_HINTER
612		#else
613		#define TT_HINTER_FLAG 0
614		#endif
615
616		#ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
617		#define TT_SIZE_SELECT tt_size_select
618		#else
619		#define TT_SIZE_SELECT 0
620		#endif
621
622		FT_DEFINE_DRIVER(
623		tt_driver_class,
624
625		FT_MODULE_FONT_DRIVER \|
626		FT_MODULE_DRIVER_SCALABLE \|
627		TT_HINTER_FLAG,
628
629		sizeof ( TT_DriverRec ),
630
631		"truetype", /* driver name */
632		0x10000L, /* driver version == 1.0 */
633		0x20000L, /* driver requires FreeType 2.0 or above */
634
635		NULL, /* module-specific interface */
636
637		tt_driver_init, /* FT_Module_Constructor module_init */
638		tt_driver_done, /* FT_Module_Destructor module_done */
639		tt_get_interface, /* FT_Module_Requester get_interface */
640
641		sizeof ( TT_FaceRec ),
642		sizeof ( TT_SizeRec ),
643		sizeof ( FT_GlyphSlotRec ),
644
645		tt_face_init, /* FT_Face_InitFunc init_face */
646		tt_face_done, /* FT_Face_DoneFunc done_face */
647		tt_size_init, /* FT_Size_InitFunc init_size */
648		tt_size_done, /* FT_Size_DoneFunc done_size */
649		tt_slot_init, /* FT_Slot_InitFunc init_slot */
650		NULL, /* FT_Slot_DoneFunc done_slot */
651
652		tt_glyph_load, /* FT_Slot_LoadFunc load_glyph */
653
654		tt_get_kerning, /* FT_Face_GetKerningFunc get_kerning */
655		NULL, /* FT_Face_AttachFunc attach_file */
656		tt_get_advances, /* FT_Face_GetAdvancesFunc get_advances */
657
658		tt_size_request, /* FT_Size_RequestFunc request_size */
659		TT_SIZE_SELECT /* FT_Size_SelectFunc select_size */
660		)
661
662
663		/* END */