t1load.h File Reference

#include <freetype/internal/ftstream.h>
#include <freetype/internal/psaux.h>
#include <freetype/ftmm.h>
#include "t1parse.h"

Include dependency graph for t1load.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	T1_Loader_

Macros
#define	T1_PRIVATE   ( 1 << 0 )
#define	T1_FONTDIR_AFTER_PRIVATE   ( 1 << 1 )

Typedefs
typedef FT_BEGIN_HEADER struct T1_Loader_	T1_LoaderRec
typedef FT_BEGIN_HEADER struct T1_Loader_ *	T1_Loader

Functions
	T1_Open_Face (T1_Face face)
	T1_Get_Multi_Master (T1_Face face, FT_Multi_Master *master)
	T1_Get_MM_Var (T1_Face face, FT_MM_Var **master)
	T1_Set_MM_Blend (T1_Face face, FT_UInt num_coords, FT_Fixed *coords)
	T1_Get_MM_Blend (T1_Face face, FT_UInt num_coords, FT_Fixed *coords)
	T1_Set_MM_Design (T1_Face face, FT_UInt num_coords, FT_Long *coords)
	T1_Reset_MM_Blend (T1_Face face, FT_UInt instance_index)
	T1_Get_Var_Design (T1_Face face, FT_UInt num_coords, FT_Fixed *coords)
	T1_Set_Var_Design (T1_Face face, FT_UInt num_coords, FT_Fixed *coords)
	T1_Done_Blend (T1_Face face)
	T1_Set_MM_WeightVector (T1_Face face, FT_UInt len, FT_Fixed *weightvector)
	T1_Get_MM_WeightVector (T1_Face face, FT_UInt *len, FT_Fixed *weightvector)

Macro Definition Documentation

T1_FONTDIR_AFTER_PRIVATE

#define T1_FONTDIR_AFTER_PRIVATE   ( 1 << 1 )

Definition at line 60 of file t1load.h.

T1_PRIVATE

#define T1_PRIVATE   ( 1 << 0 )

Definition at line 59 of file t1load.h.

Typedef Documentation

T1_Loader

typedef FT_BEGIN_HEADER struct T1_Loader_ * T1_Loader

T1_LoaderRec

typedef FT_BEGIN_HEADER struct T1_Loader_ T1_LoaderRec

Function Documentation

T1_Done_Blend()

T1_Done_Blend

(

T1_Face

face

)

Definition at line 734 of file t1load.c.

  {
    FT_Memory  memory = face->root.memory;
    PS_Blend   blend  = face->blend;
 
 
    if ( blend )
    {
      FT_UInt  num_designs = blend->num_designs;
      FT_UInt  num_axis    = blend->num_axis;
      FT_UInt  n;
 
 
      /* release design pos table */
      FT_FREE( blend->design_pos[0] );
      for ( n = 1; n < num_designs; n++ )
        blend->design_pos[n] = NULL;
 
      /* release blend `private' and `font info' dictionaries */
      FT_FREE( blend->privates[1] );
      FT_FREE( blend->font_infos[1] );
      FT_FREE( blend->bboxes[1] );
 
      for ( n = 0; n < num_designs; n++ )
      {
        blend->privates  [n] = NULL;
        blend->font_infos[n] = NULL;
        blend->bboxes    [n] = NULL;
      }
 
      /* release weight vectors */
      FT_FREE( blend->weight_vector );
      blend->default_weight_vector = NULL;
 
      /* release axis names */
      for ( n = 0; n < num_axis; n++ )
        FT_FREE( blend->axis_names[n] );
 
      /* release design map */
      for ( n = 0; n < num_axis; n++ )
      {
        PS_DesignMap  dmap = blend->design_map + n;
 
 
        FT_FREE( dmap->design_points );
        dmap->num_points = 0;
      }
 
      FT_FREE( face->blend );
    }
  }

Referenced by T1_Face_Done(), and T1_Open_Face().

T1_Get_MM_Blend()

T1_Get_MM_Blend	(	T1_Face	face,
		FT_UInt	num_coords,
		FT_Fixed *	coords
	)

Definition at line 473 of file t1load.c.

  {
    PS_Blend  blend = face->blend;
 
    FT_Fixed  axiscoords[4];
    FT_UInt   i, nc;
 
 
    if ( !blend )
      return FT_THROW( Invalid_Argument );
 
    mm_weights_unmap( blend->weight_vector,
                      axiscoords,
                      blend->num_axis );
 
    nc = num_coords;
    if ( num_coords > blend->num_axis )
    {
      FT_TRACE2(( "T1_Get_MM_Blend: only using first %d of %d coordinates\n",
                  blend->num_axis, num_coords ));
      nc = blend->num_axis;
    }
 
    for ( i = 0; i < nc; i++ )
      coords[i] = axiscoords[i];
    for ( ; i < num_coords; i++ )
      coords[i] = 0x8000;
 
    return FT_Err_Ok;
  }

T1_Get_MM_Var()

T1_Get_MM_Var	(	T1_Face	face,
		FT_MM_Var **	master
	)

Definition at line 302 of file t1load.c.

  {
    FT_Memory        memory = face->root.memory;
    FT_MM_Var       *mmvar = NULL;
    FT_Multi_Master  mmaster;
    FT_Error         error;
    FT_UInt          i;
    FT_Fixed         axiscoords[T1_MAX_MM_AXIS];
    PS_Blend         blend = face->blend;
    FT_UShort*       axis_flags;
 
    FT_Offset  mmvar_size;
    FT_Offset  axis_flags_size;
    FT_Offset  axis_size;
 
 
    error = T1_Get_Multi_Master( face, &mmaster );
    if ( error )
      goto Exit;
 
    /* the various `*_size' variables, which we also use as     */
    /* offsets into the `mmvar' array, must be multiples of the */
    /* pointer size (except the last one); without such an      */
    /* alignment there might be runtime errors due to           */
    /* misaligned addresses                                     */
#undef  ALIGN_SIZE
#define ALIGN_SIZE( n ) \
          ( ( (n) + sizeof (void*) - 1 ) & ~( sizeof (void*) - 1 ) )
 
    mmvar_size      = ALIGN_SIZE( sizeof ( FT_MM_Var ) );
    axis_flags_size = ALIGN_SIZE( mmaster.num_axis *
                                  sizeof ( FT_UShort ) );
    axis_size       = mmaster.num_axis * sizeof ( FT_Var_Axis );
 
    if ( FT_ALLOC( mmvar, mmvar_size +
                          axis_flags_size +
                          axis_size ) )
      goto Exit;
 
    mmvar->num_axis        = mmaster.num_axis;
    mmvar->num_designs     = mmaster.num_designs;
    mmvar->num_namedstyles = 0;                           /* Not supported */
 
    /* while axis flags are meaningless here, we have to provide the array */
    /* to make `FT_Get_Var_Axis_Flags' work: the function expects that the */
    /* values directly follow the data of `FT_MM_Var'                      */
    axis_flags = (FT_UShort*)( (char*)mmvar + mmvar_size );
    for ( i = 0; i < mmaster.num_axis; i++ )
      axis_flags[i] = 0;
 
    mmvar->axis       = (FT_Var_Axis*)( (char*)axis_flags + axis_flags_size );
    mmvar->namedstyle = NULL;
 
    for ( i = 0; i < mmaster.num_axis; i++ )
    {
      mmvar->axis[i].name    = mmaster.axis[i].name;
      mmvar->axis[i].minimum = INT_TO_FIXED( mmaster.axis[i].minimum );
      mmvar->axis[i].maximum = INT_TO_FIXED( mmaster.axis[i].maximum );
      mmvar->axis[i].strid   = ~0U;                      /* Does not apply */
      mmvar->axis[i].tag     = ~0U;                      /* Does not apply */
 
      if ( !mmvar->axis[i].name )
        continue;
 
      if ( ft_strcmp( mmvar->axis[i].name, "Weight" ) == 0 )
        mmvar->axis[i].tag = FT_MAKE_TAG( 'w', 'g', 'h', 't' );
      else if ( ft_strcmp( mmvar->axis[i].name, "Width" ) == 0 )
        mmvar->axis[i].tag = FT_MAKE_TAG( 'w', 'd', 't', 'h' );
      else if ( ft_strcmp( mmvar->axis[i].name, "OpticalSize" ) == 0 )
        mmvar->axis[i].tag = FT_MAKE_TAG( 'o', 'p', 's', 'z' );
    }
 
    mm_weights_unmap( blend->default_weight_vector,
                      axiscoords,
                      blend->num_axis );
 
    for ( i = 0; i < mmaster.num_axis; i++ )
      mmvar->axis[i].def = mm_axis_unmap( &blend->design_map[i],
                                          axiscoords[i] );
 
    *master = mmvar;
 
  Exit:
    return error;
  }

T1_Get_MM_WeightVector()

T1_Get_MM_WeightVector	(	T1_Face	face,
		FT_UInt *	len,
		FT_Fixed *	weightvector
	)

Definition at line 548 of file t1load.c.

  {
    PS_Blend  blend = face->blend;
    FT_UInt   i;
 
 
    if ( !blend )
      return FT_THROW( Invalid_Argument );
 
    if ( *len < blend->num_designs )
    {
      *len = blend->num_designs;
      return FT_THROW( Invalid_Argument );
    }
 
    for ( i = 0; i < blend->num_designs; i++ )
      weightvector[i] = blend->weight_vector[i];
    for ( ; i < *len; i++ )
      weightvector[i] = (FT_Fixed)0;
 
    *len = blend->num_designs;
 
    return FT_Err_Ok;
  }

T1_Get_Multi_Master()

T1_Get_Multi_Master	(	T1_Face	face,
		FT_Multi_Master *	master
	)

Definition at line 192 of file t1load.c.

  {
    PS_Blend  blend = face->blend;
    FT_UInt   n;
    FT_Error  error;
 
 
    error = FT_THROW( Invalid_Argument );
 
    if ( blend )
    {
      master->num_axis    = blend->num_axis;
      master->num_designs = blend->num_designs;
 
      for ( n = 0; n < blend->num_axis; n++ )
      {
        FT_MM_Axis*   axis = master->axis + n;
        PS_DesignMap  map = blend->design_map + n;
 
 
        axis->name    = blend->axis_names[n];
        axis->minimum = map->design_points[0];
        axis->maximum = map->design_points[map->num_points - 1];
      }
 
      error = FT_Err_Ok;
    }
 
    return error;
  }

Referenced by T1_Get_MM_Var().

T1_Get_Var_Design()

T1_Get_Var_Design	(	T1_Face	face,
		FT_UInt	num_coords,
		FT_Fixed *	coords
	)

Definition at line 698 of file t1load.c.

  {
    PS_Blend  blend = face->blend;
 
    FT_Fixed  axiscoords[4];
    FT_UInt   i, nc;
 
 
    if ( !blend )
      return FT_THROW( Invalid_Argument );
 
    mm_weights_unmap( blend->weight_vector,
                      axiscoords,
                      blend->num_axis );
 
    nc = num_coords;
    if ( num_coords > blend->num_axis )
    {
      FT_TRACE2(( "T1_Get_Var_Design:"
                  " only using first %d of %d coordinates\n",
                  blend->num_axis, num_coords ));
      nc = blend->num_axis;
    }
 
    for ( i = 0; i < nc; i++ )
      coords[i] = mm_axis_unmap( &blend->design_map[i], axiscoords[i] );
    for ( ; i < num_coords; i++ )
      coords[i] = 0;
 
    return FT_Err_Ok;
  }

T1_Open_Face()

T1_Open_Face

(

T1_Face

face

)

Definition at line 2499 of file t1load.c.

  {
    T1_LoaderRec   loader;
    T1_Parser      parser;
    T1_Font        type1 = &face->type1;
    PS_Private     priv  = &type1->private_dict;
    FT_Error       error;
 
    PSAux_Service  psaux = (PSAux_Service)face->psaux;
 
 
    t1_init_loader( &loader, face );
 
    /* default values */
    face->ndv_idx          = -1;
    face->cdv_idx          = -1;
    face->len_buildchar    = 0;
 
    priv->blue_shift       = 7;
    priv->blue_fuzz        = 1;
    priv->lenIV            = 4;
    priv->expansion_factor = (FT_Fixed)( 0.06 * 0x10000L );
    priv->blue_scale       = (FT_Fixed)( 0.039625 * 0x10000L * 1000 );
 
    parser = &loader.parser;
    error  = T1_New_Parser( parser,
                            face->root.stream,
                            face->root.memory,
                            psaux );
    if ( error )
      goto Exit;
 
    FT_TRACE4(( " top dictionary:\n" ));
    error = parse_dict( face, &loader,
                        parser->base_dict, parser->base_len );
    if ( error )
      goto Exit;
 
    error = T1_Get_Private_Dict( parser, psaux );
    if ( error )
      goto Exit;
 
    FT_TRACE4(( " private dictionary:\n" ));
    error = parse_dict( face, &loader,
                        parser->private_dict, parser->private_len );
    if ( error )
      goto Exit;
 
    /* ensure even-ness of `num_blue_values' */
    priv->num_blue_values &= ~1;
 
#ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT
 
    /* we don't support Multiple Master fonts with intermediate designs; */
    /* this implies that `num_designs' must be equal to `2^^num_axis'    */
    if ( face->blend                                                 &&
         face->blend->num_designs != ( 1U << face->blend->num_axis ) )
    {
      FT_ERROR(( "T1_Open_Face:"
                 " number-of-designs != 2 ^^ number-of-axes\n" ));
      T1_Done_Blend( face );
    }
 
    if ( face->blend                                                     &&
         face->blend->num_default_design_vector != 0                     &&
         face->blend->num_default_design_vector != face->blend->num_axis )
    {
      /* we don't use it currently so just warn, reset, and ignore */
      FT_ERROR(( "T1_Open_Face(): /DesignVector contains %u entries "
                 "while there are %u axes.\n",
                 face->blend->num_default_design_vector,
                 face->blend->num_axis ));
 
      face->blend->num_default_design_vector = 0;
    }
 
    /* the following can happen for MM instances; we then treat the */
    /* font as a normal PS font                                     */
    if ( face->blend                                             &&
         ( !face->blend->num_designs || !face->blend->num_axis ) )
      T1_Done_Blend( face );
 
    /* another safety check */
    if ( face->blend )
    {
      FT_UInt  i;
 
 
      for ( i = 0; i < face->blend->num_axis; i++ )
        if ( !face->blend->design_map[i].num_points )
        {
          T1_Done_Blend( face );
          break;
        }
    }
 
    if ( face->blend )
    {
      if ( face->len_buildchar > 0 )
      {
        FT_Memory  memory = face->root.memory;
 
 
        if ( FT_NEW_ARRAY( face->buildchar, face->len_buildchar ) )
        {
          FT_ERROR(( "T1_Open_Face: cannot allocate BuildCharArray\n" ));
          face->len_buildchar = 0;
          goto Exit;
        }
      }
    }
    else
      face->len_buildchar = 0;
 
#endif /* !T1_CONFIG_OPTION_NO_MM_SUPPORT */
 
    /* now, propagate the subrs, charstrings, and glyphnames tables */
    /* to the Type1 data                                            */
    type1->num_glyphs = loader.num_glyphs;
 
    if ( loader.subrs.init )
    {
      type1->num_subrs   = loader.num_subrs;
      type1->subrs_block = loader.subrs.block;
      type1->subrs       = loader.subrs.elements;
      type1->subrs_len   = loader.subrs.lengths;
      type1->subrs_hash  = loader.subrs_hash;
 
      /* prevent `t1_done_loader' from freeing the propagated data */
      loader.subrs.init = 0;
      loader.subrs_hash = NULL;
    }
 
    if ( !IS_INCREMENTAL )
      if ( !loader.charstrings.init )
      {
        FT_ERROR(( "T1_Open_Face: no `/CharStrings' array in face\n" ));
        error = FT_THROW( Invalid_File_Format );
      }
 
    loader.charstrings.init  = 0;
    type1->charstrings_block = loader.charstrings.block;
    type1->charstrings       = loader.charstrings.elements;
    type1->charstrings_len   = loader.charstrings.lengths;
 
    /* we copy the glyph names `block' and `elements' fields; */
    /* the `lengths' field must be released later             */
    type1->glyph_names_block    = loader.glyph_names.block;
    type1->glyph_names          = (FT_String**)loader.glyph_names.elements;
    loader.glyph_names.block    = NULL;
    loader.glyph_names.elements = NULL;
 
    /* we must now build type1.encoding when we have a custom array */
    if ( type1->encoding_type == T1_ENCODING_TYPE_ARRAY )
    {
      FT_Int  charcode, idx, min_char, max_char;
 
 
      /* OK, we do the following: for each element in the encoding  */
      /* table, look up the index of the glyph having the same name */
      /* the index is then stored in type1.encoding.char_index, and */
      /* the name to type1.encoding.char_name                       */
 
      min_char = 0;
      max_char = 0;
 
      charcode = 0;
      for ( ; charcode < loader.encoding_table.max_elems; charcode++ )
      {
        const FT_String*  char_name =
              (const FT_String*)loader.encoding_table.elements[charcode];
 
 
        type1->encoding.char_index[charcode] = 0;
        type1->encoding.char_name [charcode] = ".notdef";
 
        if ( char_name )
          for ( idx = 0; idx < type1->num_glyphs; idx++ )
          {
            const FT_String*  glyph_name = type1->glyph_names[idx];
 
 
            if ( ft_strcmp( char_name, glyph_name ) == 0 )
            {
              type1->encoding.char_index[charcode] = (FT_UShort)idx;
              type1->encoding.char_name [charcode] = glyph_name;
 
              /* Change min/max encoded char only if glyph name is */
              /* not /.notdef                                      */
              if ( ft_strcmp( ".notdef", glyph_name ) != 0 )
              {
                if ( charcode < min_char )
                  min_char = charcode;
                if ( charcode >= max_char )
                  max_char = charcode + 1;
              }
              break;
            }
          }
      }
 
      type1->encoding.code_first = min_char;
      type1->encoding.code_last  = max_char;
      type1->encoding.num_chars  = loader.num_chars;
    }
 
    /* some sanitizing to avoid overflows later on; */
    /* the upper limits are ad-hoc values           */
    if ( priv->blue_shift > 1000 || priv->blue_shift < 0 )
    {
      FT_TRACE2(( "T1_Open_Face:"
                  " setting unlikely BlueShift value %d to default (7)\n",
                  priv->blue_shift ));
      priv->blue_shift = 7;
    }
 
    if ( priv->blue_fuzz > 1000 || priv->blue_fuzz < 0 )
    {
      FT_TRACE2(( "T1_Open_Face:"
                  " setting unlikely BlueFuzz value %d to default (1)\n",
                  priv->blue_fuzz ));
      priv->blue_fuzz = 1;
    }
 
  Exit:
    t1_done_loader( &loader );
    return error;
  }

Referenced by T1_Face_Init().

T1_Reset_MM_Blend()

T1_Reset_MM_Blend	(	T1_Face	face,
		FT_UInt	instance_index
	)

Definition at line 664 of file t1load.c.

  {
    FT_UNUSED( instance_index );
 
    return T1_Set_MM_Blend( face, 0, NULL );
  }

T1_Set_MM_Blend()

T1_Set_MM_Blend	(	T1_Face	face,
		FT_UInt	num_coords,
		FT_Fixed *	coords
	)

Definition at line 452 of file t1load.c.

  {
    FT_Error  error;
 
 
    error = t1_set_mm_blend( face, num_coords, coords );
    if ( error )
      return error;
 
    if ( num_coords )
      face->root.face_flags |= FT_FACE_FLAG_VARIATION;
    else
      face->root.face_flags &= ~FT_FACE_FLAG_VARIATION;
 
    return FT_Err_Ok;
  }

Referenced by T1_Reset_MM_Blend().

T1_Set_MM_Design()

T1_Set_MM_Design	(	T1_Face	face,
		FT_UInt	num_coords,
		FT_Long *	coords
	)

Definition at line 577 of file t1load.c.

  {
    FT_Error  error;
    PS_Blend  blend = face->blend;
    FT_UInt   n, p;
    FT_Fixed  final_blends[T1_MAX_MM_DESIGNS];
 
 
    if ( !blend )
      return FT_THROW( Invalid_Argument );
 
    if ( num_coords > blend->num_axis )
      num_coords = blend->num_axis;
 
    /* compute the blend coordinates through the blend design map */
 
    for ( n = 0; n < blend->num_axis; n++ )
    {
      FT_Long       design;
      FT_Fixed      the_blend;
      PS_DesignMap  map     = blend->design_map + n;
      FT_Long*      designs = map->design_points;
      FT_Fixed*     blends  = map->blend_points;
      FT_Int        before  = -1, after = -1;
 
 
      /* use a default value if we don't have a coordinate */
      if ( n < num_coords )
        design = coords[n];
      else
        design = ( designs[map->num_points - 1] - designs[0] ) / 2;
 
      for ( p = 0; p < (FT_UInt)map->num_points; p++ )
      {
        FT_Long  p_design = designs[p];
 
 
        /* exact match? */
        if ( design == p_design )
        {
          the_blend = blends[p];
          goto Found;
        }
 
        if ( design < p_design )
        {
          after = (FT_Int)p;
          break;
        }
 
        before = (FT_Int)p;
      }
 
      /* now interpolate if necessary */
      if ( before < 0 )
        the_blend = blends[0];
 
      else if ( after < 0 )
        the_blend = blends[map->num_points - 1];
 
      else
        the_blend = FT_MulDiv( design         - designs[before],
                               blends [after] - blends [before],
                               designs[after] - designs[before] );
 
    Found:
      final_blends[n] = the_blend;
    }
 
    error = t1_set_mm_blend( face, blend->num_axis, final_blends );
    if ( error )
      return error;
 
    if ( num_coords )
      face->root.face_flags |= FT_FACE_FLAG_VARIATION;
    else
      face->root.face_flags &= ~FT_FACE_FLAG_VARIATION;
 
    return FT_Err_Ok;
  }

Referenced by T1_Set_Var_Design().

T1_Set_MM_WeightVector()

T1_Set_MM_WeightVector	(	T1_Face	face,
		FT_UInt	len,
		FT_Fixed *	weightvector
	)

Definition at line 508 of file t1load.c.

  {
    PS_Blend  blend = face->blend;
    FT_UInt   i, n;
 
 
    if ( !blend )
     return FT_THROW( Invalid_Argument );
 
    if ( !len && !weightvector )
    {
      for ( i = 0; i < blend->num_designs; i++ )
        blend->weight_vector[i] = blend->default_weight_vector[i];
    }
    else
    {
      if ( !weightvector )
        return FT_THROW( Invalid_Argument );
 
      n = len < blend->num_designs ? len : blend->num_designs;
 
      for ( i = 0; i < n; i++ )
        blend->weight_vector[i] = weightvector[i];
 
      for ( ; i < blend->num_designs; i++ )
        blend->weight_vector[i] = (FT_Fixed)0;
 
      if ( len )
        face->root.face_flags |= FT_FACE_FLAG_VARIATION;
      else
        face->root.face_flags &= ~FT_FACE_FLAG_VARIATION;
    }
 
    return FT_Err_Ok;
  }

T1_Set_Var_Design()

T1_Set_Var_Design	(	T1_Face	face,
		FT_UInt	num_coords,
		FT_Fixed *	coords
	)

Definition at line 679 of file t1load.c.

  {
     FT_Long  lcoords[T1_MAX_MM_AXIS];
     FT_UInt  i;
 
 
     if ( num_coords > T1_MAX_MM_AXIS )
       num_coords = T1_MAX_MM_AXIS;
 
     for ( i = 0; i < num_coords; i++ )
       lcoords[i] = FIXED_TO_INT( coords[i] );
 
     return T1_Set_MM_Design( face, num_coords, lcoords );
  }