1 /***************************************************************************/

     2 /*                                                                         */

     3 /*  t1load.c                                                               */

     4 /*                                                                         */

     5 /*    Type 1 font loader (body).                                           */

     6 /*                                                                         */

     7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,   */

     8 /*            2010 by                                                      */

     9 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */

    10 /*                                                                         */

    11 /*  This file is part of the FreeType project, and may only be used,       */

    12 /*  modified, and distributed under the terms of the FreeType project      */

    13 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */

    14 /*  this file you indicate that you have read the license and              */

    15 /*  understand and accept it fully.                                        */

    16 /*                                                                         */

    17 /***************************************************************************/

    18 

    19 

    20   /*************************************************************************/

    21   /*                                                                       */

    22   /* This is the new and improved Type 1 data loader for FreeType 2.  The  */

    23   /* old loader has several problems: it is slow, complex, difficult to    */

    24   /* maintain, and contains incredible hacks to make it accept some        */

    25   /* ill-formed Type 1 fonts without hiccup-ing.  Moreover, about 5% of    */

    26   /* the Type 1 fonts on my machine still aren't loaded correctly by it.   */

    27   /*                                                                       */

    28   /* This version is much simpler, much faster and also easier to read and */

    29   /* maintain by a great order of magnitude.  The idea behind it is to     */

    30   /* _not_ try to read the Type 1 token stream with a state machine (i.e.  */

    31   /* a Postscript-like interpreter) but rather to perform simple pattern   */

    32   /* matching.                                                             */

    33   /*                                                                       */

    34   /* Indeed, nearly all data definitions follow a simple pattern like      */

    35   /*                                                                       */

    36   /*  ... /Field <data> ...                                                */

    37   /*                                                                       */

    38   /* where <data> can be a number, a boolean, a string, or an array of     */

    39   /* numbers.  There are a few exceptions, namely the encoding, font name, */

    40   /* charstrings, and subrs; they are handled with a special pattern       */

    41   /* matching routine.                                                     */

    42   /*                                                                       */

    43   /* All other common cases are handled very simply.  The matching rules   */

    44   /* are defined in the file `t1tokens.h' through the use of several       */

    45   /* macros calls PARSE_XXX.  This file is included twice here; the first  */

    46   /* time to generate parsing callback functions, the second time to       */

    47   /* generate a table of keywords (with pointers to the associated         */

    48   /* callback functions).                                                  */

    49   /*                                                                       */

    50   /* The function `parse_dict' simply scans *linearly* a given dictionary  */

    51   /* (either the top-level or private one) and calls the appropriate       */

    52   /* callback when it encounters an immediate keyword.                     */

    53   /*                                                                       */

    54   /* This is by far the fastest way one can find to parse and read all     */

    55   /* data.                                                                 */

    56   /*                                                                       */

    57   /* This led to tremendous code size reduction.  Note that later, the     */

    58   /* glyph loader will also be _greatly_ simplified, and the automatic     */

    59   /* hinter will replace the clumsy `t1hinter'.                            */

    60   /*                                                                       */

    61   /*************************************************************************/

    62 

    63 

    64 #include <ft2build.h>

    65 #include FT_INTERNAL_DEBUG_H

    66 #include FT_CONFIG_CONFIG_H

    67 #include FT_MULTIPLE_MASTERS_H

    68 #include FT_INTERNAL_TYPE1_TYPES_H

    69 #include FT_INTERNAL_CALC_H

    70 

    71 #include "t1load.h"

    72 #include "t1errors.h"

    73 

    74 

    75   /*************************************************************************/

    76   /*                                                                       */

    77   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */

    78   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */

    79   /* messages during execution.                                            */

    80   /*                                                                       */

    81 #undef  FT_COMPONENT

    82 #define FT_COMPONENT  trace_t1load

    83 

    84 

    85 #ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT

    86 

    87 

    88   /*************************************************************************/

    89   /*************************************************************************/

    90   /*****                                                               *****/

    91   /*****                    MULTIPLE MASTERS SUPPORT                   *****/

    92   /*****                                                               *****/

    93   /*************************************************************************/

    94   /*************************************************************************/

    95 

    96   static FT_Error

    97   t1_allocate_blend( T1_Face  face,

    98                      FT_UInt  num_designs,

    99                      FT_UInt  num_axis )

   100   {

   101     PS_Blend   blend;

   102     FT_Memory  memory = face->root.memory;

   103     FT_Error   error  = T1_Err_Ok;

   104 

   105 

   106     blend = face->blend;

   107     if ( !blend )

   108     {

   109       if ( FT_NEW( blend ) )

   110         goto Exit;

   111 

   112       blend->num_default_design_vector = 0;

   113 

   114       face->blend = blend;

   115     }

   116 

   117     /* allocate design data if needed */

   118     if ( num_designs > 0 )

   119     {

   120       if ( blend->num_designs == 0 )

   121       {

   122         FT_UInt  nn;

   123 

   124 

   125         /* allocate the blend `private' and `font_info' dictionaries */

   126         if ( FT_NEW_ARRAY( blend->font_infos[1], num_designs     ) ||

   127              FT_NEW_ARRAY( blend->privates[1], num_designs       ) ||

   128              FT_NEW_ARRAY( blend->bboxes[1], num_designs         ) ||

   129              FT_NEW_ARRAY( blend->weight_vector, num_designs * 2 ) )

   130           goto Exit;

   131 

   132         blend->default_weight_vector = blend->weight_vector + num_designs;

   133 

   134         blend->font_infos[0] = &face->type1.font_info;

   135         blend->privates  [0] = &face->type1.private_dict;

   136         blend->bboxes    [0] = &face->type1.font_bbox;

   137 

   138         for ( nn = 2; nn <= num_designs; nn++ )

   139         {

   140           blend->privates[nn]   = blend->privates  [nn - 1] + 1;

   141           blend->font_infos[nn] = blend->font_infos[nn - 1] + 1;

   142           blend->bboxes[nn]     = blend->bboxes    [nn - 1] + 1;

   143         }

   144 

   145         blend->num_designs   = num_designs;

   146       }

   147       else if ( blend->num_designs != num_designs )

   148         goto Fail;

   149     }

   150 

   151     /* allocate axis data if needed */

   152     if ( num_axis > 0 )

   153     {

   154       if ( blend->num_axis != 0 && blend->num_axis != num_axis )

   155         goto Fail;

   156 

   157       blend->num_axis = num_axis;

   158     }

   159 

   160     /* allocate the blend design pos table if needed */

   161     num_designs = blend->num_designs;

   162     num_axis    = blend->num_axis;

   163     if ( num_designs && num_axis && blend->design_pos[0] == 0 )

   164     {

   165       FT_UInt  n;

   166 

   167 

   168       if ( FT_NEW_ARRAY( blend->design_pos[0], num_designs * num_axis ) )

   169         goto Exit;

   170 

   171       for ( n = 1; n < num_designs; n++ )

   172         blend->design_pos[n] = blend->design_pos[0] + num_axis * n;

   173     }

   174 

   175   Exit:

   176     return error;

   177 

   178   Fail:

   179     error = T1_Err_Invalid_File_Format;

   180     goto Exit;

   181   }

   182 

   183 

   184   FT_LOCAL_DEF( FT_Error )

   185   T1_Get_Multi_Master( T1_Face           face,

   186                        FT_Multi_Master*  master )

   187   {

   188     PS_Blend  blend = face->blend;

   189     FT_UInt   n;

   190     FT_Error  error;

   191 

   192 

   193     error = T1_Err_Invalid_Argument;

   194 

   195     if ( blend )

   196     {

   197       master->num_axis    = blend->num_axis;

   198       master->num_designs = blend->num_designs;

   199 

   200       for ( n = 0; n < blend->num_axis; n++ )

   201       {

   202         FT_MM_Axis*   axis = master->axis + n;

   203         PS_DesignMap  map = blend->design_map + n;

   204 

   205 

   206         axis->name    = blend->axis_names[n];

   207         axis->minimum = map->design_points[0];

   208         axis->maximum = map->design_points[map->num_points - 1];

   209       }

   210 

   211       error = T1_Err_Ok;

   212     }

   213 

   214     return error;

   215   }

   216 

   217 

   218   /*************************************************************************/

   219   /*                                                                       */

   220   /* Given a normalized (blend) coordinate, figure out the design          */

   221   /* coordinate appropriate for that value.                                */

   222   /*                                                                       */

   223   FT_LOCAL_DEF( FT_Fixed )

   224   mm_axis_unmap( PS_DesignMap  axismap,

   225                  FT_Fixed      ncv )

   226   {

   227     int  j;

   228 

   229 

   230     if ( ncv <= axismap->blend_points[0] )

   231       return INT_TO_FIXED( axismap->design_points[0] );

   232 

   233     for ( j = 1; j < axismap->num_points; ++j )

   234     {

   235       if ( ncv <= axismap->blend_points[j] )

   236       {

   237         FT_Fixed  t = FT_MulDiv( ncv - axismap->blend_points[j - 1],

   238                                  0x10000L,

   239                                  axismap->blend_points[j] -

   240                                    axismap->blend_points[j - 1] );

   241 

   242         return INT_TO_FIXED( axismap->design_points[j - 1] ) +

   243                  FT_MulDiv( t,

   244                             axismap->design_points[j] -

   245                               axismap->design_points[j - 1],

   246                             1L );

   247       }

   248     }

   249 

   250     return INT_TO_FIXED( axismap->design_points[axismap->num_points - 1] );

   251   }

   252 

   253 

   254   /*************************************************************************/

   255   /*                                                                       */

   256   /* Given a vector of weights, one for each design, figure out the        */

   257   /* normalized axis coordinates which gave rise to those weights.         */

   258   /*                                                                       */

   259   FT_LOCAL_DEF( void )

   260   mm_weights_unmap( FT_Fixed*  weights,

   261                     FT_Fixed*  axiscoords,

   262                     FT_UInt    axis_count )

   263   {

   264     FT_ASSERT( axis_count <= T1_MAX_MM_AXIS );

   265 

   266     if ( axis_count == 1 )

   267       axiscoords[0] = weights[1];

   268 

   269     else if ( axis_count == 2 )

   270     {

   271       axiscoords[0] = weights[3] + weights[1];

   272       axiscoords[1] = weights[3] + weights[2];

   273     }

   274 

   275     else if ( axis_count == 3 )

   276     {

   277       axiscoords[0] = weights[7] + weights[5] + weights[3] + weights[1];

   278       axiscoords[1] = weights[7] + weights[6] + weights[3] + weights[2];

   279       axiscoords[2] = weights[7] + weights[6] + weights[5] + weights[4];

   280     }

   281 

   282     else

   283     {

   284       axiscoords[0] = weights[15] + weights[13] + weights[11] + weights[9] +

   285                         weights[7] + weights[5] + weights[3] + weights[1];

   286       axiscoords[1] = weights[15] + weights[14] + weights[11] + weights[10] +

   287                         weights[7] + weights[6] + weights[3] + weights[2];

   288       axiscoords[2] = weights[15] + weights[14] + weights[13] + weights[12] +

   289                         weights[7] + weights[6] + weights[5] + weights[4];

   290       axiscoords[3] = weights[15] + weights[14] + weights[13] + weights[12] +

   291                         weights[11] + weights[10] + weights[9] + weights[8];

   292     }

   293   }

   294 

   295 

   296   /*************************************************************************/

   297   /*                                                                       */

   298   /* Just a wrapper around T1_Get_Multi_Master to support the different    */

   299   /*  arguments needed by the GX var distortable fonts.                    */

   300   /*                                                                       */

   301   FT_LOCAL_DEF( FT_Error )

   302   T1_Get_MM_Var( T1_Face      face,

   303                  FT_MM_Var*  *master )

   304   {

   305     FT_Memory        memory = face->root.memory;

   306     FT_MM_Var       *mmvar;

   307     FT_Multi_Master  mmaster;

   308     FT_Error         error;

   309     FT_UInt          i;

   310     FT_Fixed         axiscoords[T1_MAX_MM_AXIS];

   311     PS_Blend         blend = face->blend;

   312 

   313 

   314     error = T1_Get_Multi_Master( face, &mmaster );

   315     if ( error )

   316       goto Exit;

   317     if ( FT_ALLOC( mmvar,

   318                    sizeof ( FT_MM_Var ) +

   319                      mmaster.num_axis * sizeof ( FT_Var_Axis ) ) )

   320       goto Exit;

   321 

   322     mmvar->num_axis        = mmaster.num_axis;

   323     mmvar->num_designs     = mmaster.num_designs;

   324     mmvar->num_namedstyles = (FT_UInt)-1;                /* Does not apply */

   325     mmvar->axis            = (FT_Var_Axis*)&mmvar[1];

   326                                       /* Point to axes after MM_Var struct */

   327     mmvar->namedstyle      = NULL;

   328 

   329     for ( i = 0 ; i < mmaster.num_axis; ++i )

   330     {

   331       mmvar->axis[i].name    = mmaster.axis[i].name;

   332       mmvar->axis[i].minimum = INT_TO_FIXED( mmaster.axis[i].minimum);

   333       mmvar->axis[i].maximum = INT_TO_FIXED( mmaster.axis[i].maximum);

   334       mmvar->axis[i].def     = ( mmvar->axis[i].minimum +

   335                                    mmvar->axis[i].maximum ) / 2;

   336                             /* Does not apply.  But this value is in range */

   337       mmvar->axis[i].strid   = (FT_UInt)-1;    /* Does not apply */

   338       mmvar->axis[i].tag     = (FT_ULong)-1;   /* Does not apply */

   339 

   340       if ( ft_strcmp( mmvar->axis[i].name, "Weight" ) == 0 )

   341         mmvar->axis[i].tag = FT_MAKE_TAG( 'w', 'g', 'h', 't' );

   342       else if ( ft_strcmp( mmvar->axis[i].name, "Width" ) == 0 )

   343         mmvar->axis[i].tag = FT_MAKE_TAG( 'w', 'd', 't', 'h' );

   344       else if ( ft_strcmp( mmvar->axis[i].name, "OpticalSize" ) == 0 )

   345         mmvar->axis[i].tag = FT_MAKE_TAG( 'o', 'p', 's', 'z' );

   346     }

   347 

   348     if ( blend->num_designs == ( 1U << blend->num_axis ) )

   349     {

   350       mm_weights_unmap( blend->default_weight_vector,

   351                         axiscoords,

   352                         blend->num_axis );

   353 

   354       for ( i = 0; i < mmaster.num_axis; ++i )

   355         mmvar->axis[i].def = mm_axis_unmap( &blend->design_map[i],

   356                                             axiscoords[i] );

   357     }

   358 

   359     *master = mmvar;

   360 

   361   Exit:

   362     return error;

   363   }

   364 

   365 

   366   FT_LOCAL_DEF( FT_Error )

   367   T1_Set_MM_Blend( T1_Face    face,

   368                    FT_UInt    num_coords,

   369                    FT_Fixed*  coords )

   370   {

   371     PS_Blend  blend = face->blend;

   372     FT_Error  error;

   373     FT_UInt   n, m;

   374 

   375 

   376     error = T1_Err_Invalid_Argument;

   377 

   378     if ( blend && blend->num_axis == num_coords )

   379     {

   380       /* recompute the weight vector from the blend coordinates */

   381       error = T1_Err_Ok;

   382 

   383       for ( n = 0; n < blend->num_designs; n++ )

   384       {

   385         FT_Fixed  result = 0x10000L;  /* 1.0 fixed */

   386 

   387 

   388         for ( m = 0; m < blend->num_axis; m++ )

   389         {

   390           FT_Fixed  factor;

   391 

   392 

   393           /* get current blend axis position */

   394           factor = coords[m];

   395           if ( factor < 0 )        factor = 0;

   396           if ( factor > 0x10000L ) factor = 0x10000L;

   397 

   398           if ( ( n & ( 1 << m ) ) == 0 )

   399             factor = 0x10000L - factor;

   400 

   401           result = FT_MulFix( result, factor );

   402         }

   403         blend->weight_vector[n] = result;

   404       }

   405 

   406       error = T1_Err_Ok;

   407     }

   408 

   409     return error;

   410   }

   411 

   412 

   413   FT_LOCAL_DEF( FT_Error )

   414   T1_Set_MM_Design( T1_Face   face,

   415                     FT_UInt   num_coords,

   416                     FT_Long*  coords )

   417   {

   418     PS_Blend  blend = face->blend;

   419     FT_Error  error;

   420     FT_UInt   n, p;

   421 

   422 

   423     error = T1_Err_Invalid_Argument;

   424     if ( blend && blend->num_axis == num_coords )

   425     {

   426       /* compute the blend coordinates through the blend design map */

   427       FT_Fixed  final_blends[T1_MAX_MM_DESIGNS];

   428 

   429 

   430       for ( n = 0; n < blend->num_axis; n++ )

   431       {

   432         FT_Long       design  = coords[n];

   433         FT_Fixed      the_blend;

   434         PS_DesignMap  map     = blend->design_map + n;

   435         FT_Long*      designs = map->design_points;

   436         FT_Fixed*     blends  = map->blend_points;

   437         FT_Int        before  = -1, after = -1;

   438 

   439 

   440         for ( p = 0; p < (FT_UInt)map->num_points; p++ )

   441         {

   442           FT_Long  p_design = designs[p];

   443 

   444 

   445           /* exact match? */

   446           if ( design == p_design )

   447           {

   448             the_blend = blends[p];

   449             goto Found;

   450           }

   451 

   452           if ( design < p_design )

   453           {

   454             after = p;

   455             break;

   456           }

   457 

   458           before = p;

   459         }

   460 

   461         /* now interpolate if necessary */

   462         if ( before < 0 )

   463           the_blend = blends[0];

   464 

   465         else if ( after < 0 )

   466           the_blend = blends[map->num_points - 1];

   467 

   468         else

   469           the_blend = FT_MulDiv( design         - designs[before],

   470                                  blends [after] - blends [before],

   471                                  designs[after] - designs[before] );

   472 

   473       Found:

   474         final_blends[n] = the_blend;

   475       }

   476 

   477       error = T1_Set_MM_Blend( face, num_coords, final_blends );

   478     }

   479 

   480     return error;

   481   }

   482 

   483 

   484   /*************************************************************************/

   485   /*                                                                       */

   486   /* Just a wrapper around T1_Set_MM_Design to support the different       */

   487   /* arguments needed by the GX var distortable fonts.                     */

   488   /*                                                                       */

   489   FT_LOCAL_DEF( FT_Error )

   490   T1_Set_Var_Design( T1_Face    face,

   491                      FT_UInt    num_coords,

   492                      FT_Fixed*  coords )

   493   {

   494      FT_Long   lcoords[4];          /* maximum axis count is 4 */

   495      FT_UInt   i;

   496      FT_Error  error;

   497 

   498 

   499      error = T1_Err_Invalid_Argument;

   500      if ( num_coords <= 4 && num_coords > 0 )

   501      {

   502        for ( i = 0; i < num_coords; ++i )

   503          lcoords[i] = FIXED_TO_INT( coords[i] );

   504        error = T1_Set_MM_Design( face, num_coords, lcoords );

   505      }

   506 

   507      return error;

   508   }

   509 

   510 

   511   FT_LOCAL_DEF( void )

   512   T1_Done_Blend( T1_Face  face )

   513   {

   514     FT_Memory  memory = face->root.memory;

   515     PS_Blend   blend  = face->blend;

   516 

   517 

   518     if ( blend )

   519     {

   520       FT_UInt  num_designs = blend->num_designs;

   521       FT_UInt  num_axis    = blend->num_axis;

   522       FT_UInt  n;

   523 

   524 

   525       /* release design pos table */

   526       FT_FREE( blend->design_pos[0] );

   527       for ( n = 1; n < num_designs; n++ )

   528         blend->design_pos[n] = 0;

   529 

   530       /* release blend `private' and `font info' dictionaries */

   531       FT_FREE( blend->privates[1] );

   532       FT_FREE( blend->font_infos[1] );

   533       FT_FREE( blend->bboxes[1] );

   534 

   535       for ( n = 0; n < num_designs; n++ )

   536       {

   537         blend->privates  [n] = 0;

   538         blend->font_infos[n] = 0;

   539         blend->bboxes    [n] = 0;

   540       }

   541 

   542       /* release weight vectors */

   543       FT_FREE( blend->weight_vector );

   544       blend->default_weight_vector = 0;

   545 

   546       /* release axis names */

   547       for ( n = 0; n < num_axis; n++ )

   548         FT_FREE( blend->axis_names[n] );

   549 

   550       /* release design map */

   551       for ( n = 0; n < num_axis; n++ )

   552       {

   553         PS_DesignMap  dmap = blend->design_map + n;

   554 

   555 

   556         FT_FREE( dmap->design_points );

   557         dmap->num_points = 0;

   558       }

   559 

   560       FT_FREE( face->blend );

   561     }

   562   }

   563 

   564 

   565   static void

   566   parse_blend_axis_types( T1_Face    face,

   567                           T1_Loader  loader )

   568   {

   569     T1_TokenRec  axis_tokens[T1_MAX_MM_AXIS];

   570     FT_Int       n, num_axis;

   571     FT_Error     error = T1_Err_Ok;

   572     PS_Blend     blend;

   573     FT_Memory    memory;

   574 

   575 

   576     /* take an array of objects */

   577     T1_ToTokenArray( &loader->parser, axis_tokens,

   578                      T1_MAX_MM_AXIS, &num_axis );

   579     if ( num_axis < 0 )

   580     {

   581       error = T1_Err_Ignore;

   582       goto Exit;

   583     }

   584     if ( num_axis == 0 || num_axis > T1_MAX_MM_AXIS )

   585     {

   586       FT_ERROR(( "parse_blend_axis_types: incorrect number of axes: %d\n",

   587                  num_axis ));

   588       error = T1_Err_Invalid_File_Format;

   589       goto Exit;

   590     }

   591 

   592     /* allocate blend if necessary */

   593     error = t1_allocate_blend( face, 0, (FT_UInt)num_axis );

   594     if ( error )

   595       goto Exit;

   596 

   597     blend  = face->blend;

   598     memory = face->root.memory;

   599 

   600     /* each token is an immediate containing the name of the axis */

   601     for ( n = 0; n < num_axis; n++ )

   602     {

   603       T1_Token    token = axis_tokens + n;

   604       FT_Byte*    name;

   605       FT_PtrDist  len;

   606 

   607 

   608       /* skip first slash, if any */

   609       if ( token->start[0] == '/' )

   610         token->start++;

   611 

   612       len = token->limit - token->start;

   613       if ( len == 0 )

   614       {

   615         error = T1_Err_Invalid_File_Format;

   616         goto Exit;

   617       }

   618 

   619       if ( FT_ALLOC( blend->axis_names[n], len + 1 ) )

   620         goto Exit;

   621 

   622       name = (FT_Byte*)blend->axis_names[n];

   623       FT_MEM_COPY( name, token->start, len );

   624       name[len] = 0;

   625     }

   626 

   627   Exit:

   628     loader->parser.root.error = error;

   629   }

   630 

   631 

   632   static void

   633   parse_blend_design_positions( T1_Face    face,

   634                                 T1_Loader  loader )

   635   {

   636     T1_TokenRec  design_tokens[T1_MAX_MM_DESIGNS];

   637     FT_Int       num_designs;

   638     FT_Int       num_axis;

   639     T1_Parser    parser = &loader->parser;

   640 

   641     FT_Error     error = T1_Err_Ok;

   642     PS_Blend     blend;

   643 

   644 

   645     /* get the array of design tokens -- compute number of designs */

   646     T1_ToTokenArray( parser, design_tokens,

   647                      T1_MAX_MM_DESIGNS, &num_designs );

   648     if ( num_designs < 0 )

   649     {

   650       error = T1_Err_Ignore;

   651       goto Exit;

   652     }

   653     if ( num_designs == 0 || num_designs > T1_MAX_MM_DESIGNS )

   654     {

   655       FT_ERROR(( "parse_blend_design_positions:"

   656                  " incorrect number of designs: %d\n",

   657                  num_designs ));

   658       error = T1_Err_Invalid_File_Format;

   659       goto Exit;

   660     }

   661 

   662     {

   663       FT_Byte*  old_cursor = parser->root.cursor;

   664       FT_Byte*  old_limit  = parser->root.limit;

   665       FT_Int    n;

   666 

   667 

   668       blend    = face->blend;

   669       num_axis = 0;  /* make compiler happy */

   670 

   671       for ( n = 0; n < num_designs; n++ )

   672       {

   673         T1_TokenRec  axis_tokens[T1_MAX_MM_AXIS];

   674         T1_Token     token;

   675         FT_Int       axis, n_axis;

   676 

   677 

   678         /* read axis/coordinates tokens */

   679         token = design_tokens + n;

   680         parser->root.cursor = token->start;

   681         parser->root.limit  = token->limit;

   682         T1_ToTokenArray( parser, axis_tokens, T1_MAX_MM_AXIS, &n_axis );

   683 

   684         if ( n == 0 )

   685         {

   686           if ( n_axis <= 0 || n_axis > T1_MAX_MM_AXIS )

   687           {

   688             FT_ERROR(( "parse_blend_design_positions:"

   689                        " invalid number of axes: %d\n",

   690                        n_axis ));

   691             error = T1_Err_Invalid_File_Format;

   692             goto Exit;

   693           }

   694 

   695           num_axis = n_axis;

   696           error = t1_allocate_blend( face, num_designs, num_axis );

   697           if ( error )

   698             goto Exit;

   699           blend = face->blend;

   700         }

   701         else if ( n_axis != num_axis )

   702         {

   703           FT_ERROR(( "parse_blend_design_positions: incorrect table\n" ));

   704           error = T1_Err_Invalid_File_Format;

   705           goto Exit;

   706         }

   707 

   708         /* now read each axis token into the design position */

   709         for ( axis = 0; axis < n_axis; axis++ )

   710         {

   711           T1_Token  token2 = axis_tokens + axis;

   712 

   713 

   714           parser->root.cursor = token2->start;

   715           parser->root.limit  = token2->limit;

   716           blend->design_pos[n][axis] = T1_ToFixed( parser, 0 );

   717         }

   718       }

   719 

   720       loader->parser.root.cursor = old_cursor;

   721       loader->parser.root.limit  = old_limit;

   722     }

   723 

   724   Exit:

   725     loader->parser.root.error = error;

   726   }

   727 

   728 

   729   static void

   730   parse_blend_design_map( T1_Face    face,

   731                           T1_Loader  loader )

   732   {

   733     FT_Error     error  = T1_Err_Ok;

   734     T1_Parser    parser = &loader->parser;

   735     PS_Blend     blend;

   736     T1_TokenRec  axis_tokens[T1_MAX_MM_AXIS];

   737     FT_Int       n, num_axis;

   738     FT_Byte*     old_cursor;

   739     FT_Byte*     old_limit;

   740     FT_Memory    memory = face->root.memory;

   741 

   742 

   743     T1_ToTokenArray( parser, axis_tokens,

   744                      T1_MAX_MM_AXIS, &num_axis );

   745     if ( num_axis < 0 )

   746     {

   747       error = T1_Err_Ignore;

   748       goto Exit;

   749     }

   750     if ( num_axis == 0 || num_axis > T1_MAX_MM_AXIS )

   751     {

   752       FT_ERROR(( "parse_blend_design_map: incorrect number of axes: %d\n",

   753                  num_axis ));

   754       error = T1_Err_Invalid_File_Format;

   755       goto Exit;

   756     }

   757 

   758     old_cursor = parser->root.cursor;

   759     old_limit  = parser->root.limit;

   760 

   761     error = t1_allocate_blend( face, 0, num_axis );

   762     if ( error )

   763       goto Exit;

   764     blend = face->blend;

   765 

   766     /* now read each axis design map */

   767     for ( n = 0; n < num_axis; n++ )

   768     {

   769       PS_DesignMap  map = blend->design_map + n;

   770       T1_Token      axis_token;

   771       T1_TokenRec   point_tokens[T1_MAX_MM_MAP_POINTS];

   772       FT_Int        p, num_points;

   773 

   774 

   775       axis_token = axis_tokens + n;

   776 

   777       parser->root.cursor = axis_token->start;

   778       parser->root.limit  = axis_token->limit;

   779       T1_ToTokenArray( parser, point_tokens,

   780                        T1_MAX_MM_MAP_POINTS, &num_points );

   781 

   782       if ( num_points <= 0 || num_points > T1_MAX_MM_MAP_POINTS )

   783       {

   784         FT_ERROR(( "parse_blend_design_map: incorrect table\n" ));

   785         error = T1_Err_Invalid_File_Format;

   786         goto Exit;

   787       }

   788 

   789       /* allocate design map data */

   790       if ( FT_NEW_ARRAY( map->design_points, num_points * 2 ) )

   791         goto Exit;

   792       map->blend_points = map->design_points + num_points;

   793       map->num_points   = (FT_Byte)num_points;

   794 

   795       for ( p = 0; p < num_points; p++ )

   796       {

   797         T1_Token  point_token;

   798 

   799 

   800         point_token = point_tokens + p;

   801 

   802         /* don't include delimiting brackets */

   803         parser->root.cursor = point_token->start + 1;

   804         parser->root.limit  = point_token->limit - 1;

   805 

   806         map->design_points[p] = T1_ToInt( parser );

   807         map->blend_points [p] = T1_ToFixed( parser, 0 );

   808       }

   809     }

   810 

   811     parser->root.cursor = old_cursor;

   812     parser->root.limit  = old_limit;

   813 

   814   Exit:

   815     parser->root.error = error;

   816   }

   817 

   818 

   819   static void

   820   parse_weight_vector( T1_Face    face,

   821                        T1_Loader  loader )

   822   {

   823     T1_TokenRec  design_tokens[T1_MAX_MM_DESIGNS];

   824     FT_Int       num_designs;

   825     FT_Error     error  = T1_Err_Ok;

   826     T1_Parser    parser = &loader->parser;

   827     PS_Blend     blend  = face->blend;

   828     T1_Token     token;

   829     FT_Int       n;

   830     FT_Byte*     old_cursor;

   831     FT_Byte*     old_limit;

   832 

   833 

   834     T1_ToTokenArray( parser, design_tokens,

   835                      T1_MAX_MM_DESIGNS, &num_designs );

   836     if ( num_designs < 0 )

   837     {

   838       error = T1_Err_Ignore;

   839       goto Exit;

   840     }

   841     if ( num_designs == 0 || num_designs > T1_MAX_MM_DESIGNS )

   842     {

   843       FT_ERROR(( "parse_weight_vector:"

   844                  " incorrect number of designs: %d\n",

   845                  num_designs ));

   846       error = T1_Err_Invalid_File_Format;

   847       goto Exit;

   848     }

   849 

   850     if ( !blend || !blend->num_designs )

   851     {

   852       error = t1_allocate_blend( face, num_designs, 0 );

   853       if ( error )

   854         goto Exit;

   855       blend = face->blend;

   856     }

   857     else if ( blend->num_designs != (FT_UInt)num_designs )

   858     {

   859       FT_ERROR(( "parse_weight_vector:"

   860                  " /BlendDesignPosition and /WeightVector have\n"

   861                  "                    "

   862                  " different number of elements\n" ));

   863       error = T1_Err_Invalid_File_Format;

   864       goto Exit;

   865     }

   866 

   867     old_cursor = parser->root.cursor;

   868     old_limit  = parser->root.limit;

   869 

   870     for ( n = 0; n < num_designs; n++ )

   871     {

   872       token = design_tokens + n;

   873       parser->root.cursor = token->start;

   874       parser->root.limit  = token->limit;

   875 

   876       blend->default_weight_vector[n] =

   877       blend->weight_vector[n]         = T1_ToFixed( parser, 0 );

   878     }

   879 

   880     parser->root.cursor = old_cursor;

   881     parser->root.limit  = old_limit;

   882 

   883   Exit:

   884     parser->root.error = error;

   885   }

   886 

   887 

   888   /* e.g., /BuildCharArray [0 0 0 0 0 0 0 0] def           */

   889   /* we're only interested in the number of array elements */

   890   static void

   891   parse_buildchar( T1_Face    face,

   892                    T1_Loader  loader )

   893   {

   894     face->len_buildchar = T1_ToFixedArray( &loader->parser, 0, NULL, 0 );

   895 

   896     return;

   897   }

   898 

   899 

   900 #endif /* T1_CONFIG_OPTION_NO_MM_SUPPORT */

   901 

   902 

   903 

   904 

   905   /*************************************************************************/

   906   /*************************************************************************/

   907   /*****                                                               *****/

   908   /*****                      TYPE 1 SYMBOL PARSING                    *****/

   909   /*****                                                               *****/

   910   /*************************************************************************/

   911   /*************************************************************************/

   912 

   913   static FT_Error

   914   t1_load_keyword( T1_Face         face,

   915                    T1_Loader       loader,

   916                    const T1_Field  field )

   917   {

   918     FT_Error  error;

   919     void*     dummy_object;

   920     void**    objects;

   921     FT_UInt   max_objects;

   922     PS_Blend  blend = face->blend;

   923 

   924 

   925     /* if the keyword has a dedicated callback, call it */

   926     if ( field->type == T1_FIELD_TYPE_CALLBACK )

   927     {

   928       field->reader( (FT_Face)face, loader );

   929       error = loader->parser.root.error;

   930       goto Exit;

   931     }

   932 

   933     /* now, the keyword is either a simple field, or a table of fields; */

   934     /* we are now going to take care of it                              */

   935     switch ( field->location )

   936     {

   937     case T1_FIELD_LOCATION_FONT_INFO:

   938       dummy_object = &face->type1.font_info;

   939       objects      = &dummy_object;

   940       max_objects  = 0;

   941 

   942       if ( blend )

   943       {

   944         objects     = (void**)blend->font_infos;

   945         max_objects = blend->num_designs;

   946       }

   947       break;

   948 

   949     case T1_FIELD_LOCATION_FONT_EXTRA:

   950       dummy_object = &face->type1.font_extra;

   951       objects      = &dummy_object;

   952       max_objects  = 0;

   953       break;

   954 

   955     case T1_FIELD_LOCATION_PRIVATE:

   956       dummy_object = &face->type1.private_dict;

   957       objects      = &dummy_object;

   958       max_objects  = 0;

   959 

   960       if ( blend )

   961       {

   962         objects     = (void**)blend->privates;

   963         max_objects = blend->num_designs;

   964       }

   965       break;

   966 

   967     case T1_FIELD_LOCATION_BBOX:

   968       dummy_object = &face->type1.font_bbox;

   969       objects      = &dummy_object;

   970       max_objects  = 0;

   971 

   972       if ( blend )

   973       {

   974         objects     = (void**)blend->bboxes;

   975         max_objects = blend->num_designs;

   976       }

   977       break;

   978 

   979     case T1_FIELD_LOCATION_LOADER:

   980       dummy_object = loader;

   981       objects      = &dummy_object;

   982       max_objects  = 0;

   983       break;

   984 

   985     case T1_FIELD_LOCATION_FACE:

   986       dummy_object = face;

   987       objects      = &dummy_object;

   988       max_objects  = 0;

   989       break;

   990 

   991 #ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT

   992     case T1_FIELD_LOCATION_BLEND:

   993       dummy_object = face->blend;

   994       objects      = &dummy_object;

   995       max_objects  = 0;

   996       break;

   997 #endif

   998 

   999     default:

  1000       dummy_object = &face->type1;

  1001       objects      = &dummy_object;

  1002       max_objects  = 0;

  1003     }

  1004 

  1005     if ( field->type == T1_FIELD_TYPE_INTEGER_ARRAY ||

  1006          field->type == T1_FIELD_TYPE_FIXED_ARRAY   )

  1007       error = T1_Load_Field_Table( &loader->parser, field,

  1008                                    objects, max_objects, 0 );

  1009     else

  1010       error = T1_Load_Field( &loader->parser, field,

  1011                              objects, max_objects, 0 );

  1012 

  1013   Exit:

  1014     return error;

  1015   }

  1016 

  1017 

  1018   static void

  1019   parse_private( T1_Face    face,

  1020                  T1_Loader  loader )

  1021   {

  1022     FT_UNUSED( face );

  1023 

  1024     loader->keywords_encountered |= T1_PRIVATE;

  1025   }

  1026 

  1027 

  1028   static int

  1029   read_binary_data( T1_Parser  parser,

  1030                     FT_Long*   size,

  1031                     FT_Byte**  base )

  1032   {

  1033     FT_Byte*  cur;

  1034     FT_Byte*  limit = parser->root.limit;

  1035 

  1036 

  1037     /* the binary data has one of the following formats */

  1038     /*                                                  */

  1039     /*   `size' [white*] RD white ....... ND            */

  1040     /*   `size' [white*] -| white ....... |-            */

  1041     /*                                                  */

  1042 

  1043     T1_Skip_Spaces( parser );

  1044 

  1045     cur = parser->root.cursor;

  1046 

  1047     if ( cur < limit && ft_isdigit( *cur ) )

  1048     {

  1049       FT_Long  s = T1_ToInt( parser );

  1050 

  1051 

  1052       T1_Skip_PS_Token( parser );   /* `RD' or `-|' or something else */

  1053 

  1054       /* there is only one whitespace char after the */

  1055       /* `RD' or `-|' token                          */

  1056       *base = parser->root.cursor + 1;

  1057 

  1058       if ( s >= 0 && s < limit - *base )

  1059       {

  1060         parser->root.cursor += s + 1;

  1061         *size = s;

  1062         return !parser->root.error;

  1063       }

  1064     }

  1065 

  1066     FT_ERROR(( "read_binary_data: invalid size field\n" ));

  1067     parser->root.error = T1_Err_Invalid_File_Format;

  1068     return 0;

  1069   }

  1070 

  1071 

  1072   /* We now define the routines to handle the `/Encoding', `/Subrs', */

  1073   /* and `/CharStrings' dictionaries.                                */

  1074 

  1075   static void

  1076   parse_font_matrix( T1_Face    face,

  1077                      T1_Loader  loader )

  1078   {

  1079     T1_Parser   parser = &loader->parser;

  1080     FT_Matrix*  matrix = &face->type1.font_matrix;

  1081     FT_Vector*  offset = &face->type1.font_offset;

  1082     FT_Face     root   = (FT_Face)&face->root;

  1083     FT_Fixed    temp[6];

  1084     FT_Fixed    temp_scale;

  1085     FT_Int      result;

  1086 

  1087 

  1088     result = T1_ToFixedArray( parser, 6, temp, 3 );

  1089 

  1090     if ( result < 0 )

  1091     {

  1092       parser->root.error = T1_Err_Invalid_File_Format;

  1093       return;

  1094     }

  1095 

  1096     temp_scale = FT_ABS( temp[3] );

  1097 

  1098     if ( temp_scale == 0 )

  1099     {

  1100       FT_ERROR(( "parse_font_matrix: invalid font matrix\n" ));

  1101       parser->root.error = T1_Err_Invalid_File_Format;

  1102       return;

  1103     }

  1104 

  1105     /* Set Units per EM based on FontMatrix values.  We set the value to */

  1106     /* 1000 / temp_scale, because temp_scale was already multiplied by   */

  1107     /* 1000 (in t1_tofixed, from psobjs.c).                              */

  1108 

  1109     root->units_per_EM = (FT_UShort)( FT_DivFix( 1000 * 0x10000L,

  1110                                                  temp_scale ) >> 16 );

  1111 

  1112     /* we need to scale the values by 1.0/temp_scale */

  1113     if ( temp_scale != 0x10000L )

  1114     {

  1115       temp[0] = FT_DivFix( temp[0], temp_scale );

  1116       temp[1] = FT_DivFix( temp[1], temp_scale );

  1117       temp[2] = FT_DivFix( temp[2], temp_scale );

  1118       temp[4] = FT_DivFix( temp[4], temp_scale );

  1119       temp[5] = FT_DivFix( temp[5], temp_scale );

  1120       temp[3] = temp[3] < 0 ? -0x10000L : 0x10000L;

  1121     }

  1122 

  1123     matrix->xx = temp[0];

  1124     matrix->yx = temp[1];

  1125     matrix->xy = temp[2];

  1126     matrix->yy = temp[3];

  1127 

  1128     /* note that the offsets must be expressed in integer font units */

  1129     offset->x = temp[4] >> 16;

  1130     offset->y = temp[5] >> 16;

  1131   }

  1132 

  1133 

  1134   static void