modules/freetype2/src/type1/t1afm.c

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  t1afm.c                                                                */
   4 /*                                                                         */
   5 /*    AFM support for Type 1 fonts (body).                                 */
   6 /*                                                                         */
   7 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 by             */
   8 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
   9 /*                                                                         */
  10 /*  This file is part of the FreeType project, and may only be used,       */
  11 /*  modified, and distributed under the terms of the FreeType project      */
  12 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  13 /*  this file you indicate that you have read the license and              */
  14 /*  understand and accept it fully.                                        */
  15 /*                                                                         */
  16 /***************************************************************************/
  17
  18
  19 #include <ft2build.h>
  20 #include "t1afm.h"
  21 #include "t1errors.h"
  22 #include FT_INTERNAL_STREAM_H
  23 #include FT_INTERNAL_POSTSCRIPT_AUX_H
  24
  25
  26   /*************************************************************************/
  27   /*                                                                       */
  28   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
  29   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
  30   /* messages during execution.                                            */
  31   /*                                                                       */
  32 #undef  FT_COMPONENT
  33 #define FT_COMPONENT  trace_t1afm
  34
  35
  36   FT_LOCAL_DEF( void )
  37   T1_Done_Metrics( FT_Memory     memory,
  38                    AFM_FontInfo  fi )
  39   {
  40     FT_FREE( fi->KernPairs );
  41     fi->NumKernPair = 0;
  42
  43     FT_FREE( fi->TrackKerns );
  44     fi->NumTrackKern = 0;
  45
  46     FT_FREE( fi );
  47   }
  48
  49
  50   /* read a glyph name and return the equivalent glyph index */
  51   static FT_Int
  52   t1_get_index( const char*  name,
  53                 FT_UInt      len,
  54                 void*        user_data )
  55   {
  56     T1_Font  type1 = (T1_Font)user_data;
  57     FT_Int   n;
  58
  59
  60     for ( n = 0; n < type1->num_glyphs; n++ )
  61     {
  62       char*  gname = (char*)type1->glyph_names[n];
  63
  64
  65       if ( gname && gname[0] == name[0]        &&
  66            ft_strlen( gname ) == len           &&
  67            ft_strncmp( gname, name, len ) == 0 )
  68         return n;
  69     }
  70
  71     return 0;
  72   }
  73
  74
  75 #undef  KERN_INDEX
  76 #define KERN_INDEX( g1, g2 )  ( ( (FT_ULong)(g1) << 16 ) | (g2) )
  77
  78
  79   /* compare two kerning pairs */
  80   FT_CALLBACK_DEF( int )
  81   compare_kern_pairs( const void*  a,
  82                       const void*  b )
  83   {
  84     AFM_KernPair  pair1 = (AFM_KernPair)a;
  85     AFM_KernPair  pair2 = (AFM_KernPair)b;
  86
  87     FT_ULong  index1 = KERN_INDEX( pair1->index1, pair1->index2 );
  88     FT_ULong  index2 = KERN_INDEX( pair2->index1, pair2->index2 );
  89
  90
  91     return (int)( index1 - index2 );
  92   }
  93
  94
  95   /* parse a PFM file -- for now, only read the kerning pairs */
  96   static FT_Error
  97   T1_Read_PFM( FT_Face       t1_face,
  98                FT_Stream     stream,
  99                AFM_FontInfo  fi )
 100   {
 101     FT_Error      error = T1_Err_Ok;
 102     FT_Memory     memory = stream->memory;
 103     FT_Byte*      start;
 104     FT_Byte*      limit;
 105     FT_Byte*      p;
 106     AFM_KernPair  kp;
 107     FT_Int        width_table_length;
 108     FT_CharMap    oldcharmap;
 109     FT_CharMap    charmap;
 110     FT_Int        n;
 111
 112
 113     start = (FT_Byte*)stream->cursor;
 114     limit = (FT_Byte*)stream->limit;
 115     p     = start;
 116
 117     /* Figure out how long the width table is.          */
 118     /* This info is a little-endian short at offset 99. */
 119     p = start + 99;
 120     if ( p + 2 > limit )
 121     {
 122       error = T1_Err_Unknown_File_Format;
 123       goto Exit;
 124     }
 125     width_table_length = FT_PEEK_USHORT_LE( p );
 126
 127     p += 18 + width_table_length;
 128     if ( p + 0x12 > limit || FT_PEEK_USHORT_LE( p ) < 0x12 )
 129       /* extension table is probably optional */
 130       goto Exit;
 131
 132     /* Kerning offset is 14 bytes from start of extensions table. */
 133     p += 14;
 134     p = start + FT_PEEK_ULONG_LE( p );
 135
 136     if ( p == start )
 137       /* zero offset means no table */
 138       goto Exit;
 139
 140     if ( p + 2 > limit )
 141     {
 142       error = T1_Err_Unknown_File_Format;
 143       goto Exit;
 144     }
 145
 146     fi->NumKernPair = FT_PEEK_USHORT_LE( p );
 147     p += 2;
 148     if ( p + 4 * fi->NumKernPair > limit )
 149     {
 150       error = T1_Err_Unknown_File_Format;
 151       goto Exit;
 152     }
 153
 154     /* Actually, kerning pairs are simply optional! */
 155     if ( fi->NumKernPair == 0 )
 156       goto Exit;
 157
 158     /* allocate the pairs */
 159     if ( FT_QNEW_ARRAY( fi->KernPairs, fi->NumKernPair ) )
 160       goto Exit;
 161
 162     /* now, read each kern pair */
 163     kp             = fi->KernPairs;
 164     limit          = p + 4 * fi->NumKernPair;
 165
 166     /* PFM kerning data are stored by encoding rather than glyph index, */
 167     /* so find the PostScript charmap of this font and install it       */
 168     /* temporarily.  If we find no PostScript charmap, then just use    */
 169     /* the default and hope it is the right one.                        */
 170     oldcharmap = t1_face->charmap;
 171     charmap    = NULL;
 172
 173     for ( n = 0; n < t1_face->num_charmaps; n++ )
 174     {
 175       charmap = t1_face->charmaps[n];
 176       /* check against PostScript pseudo platform */
 177       if ( charmap->platform_id == 7 )
 178       {
 179         error = FT_Set_Charmap( t1_face, charmap );
 180         if ( error )
 181           goto Exit;
 182         break;
 183       }
 184     }
 185
 186     /* Kerning info is stored as:             */
 187     /*                                        */
 188     /*   encoding of first glyph (1 byte)     */
 189     /*   encoding of second glyph (1 byte)    */
 190     /*   offset (little-endian short)         */
 191     for ( ; p < limit ; p += 4 )
 192     {
 193       kp->index1 = FT_Get_Char_Index( t1_face, p[0] );
 194       kp->index2 = FT_Get_Char_Index( t1_face, p[1] );
 195
 196       kp->x = (FT_Int)FT_PEEK_SHORT_LE(p + 2);
 197       kp->y = 0;
 198
 199       kp++;
 200     }
 201
 202     if ( oldcharmap != NULL )
 203       error = FT_Set_Charmap( t1_face, oldcharmap );
 204     if ( error )
 205       goto Exit;
 206
 207     /* now, sort the kern pairs according to their glyph indices */
 208     ft_qsort( fi->KernPairs, fi->NumKernPair, sizeof ( AFM_KernPairRec ),
 209               compare_kern_pairs );
 210
 211   Exit:
 212     if ( error )
 213     {
 214       FT_FREE( fi->KernPairs );
 215       fi->NumKernPair = 0;
 216     }
 217
 218     return error;
 219   }
 220
 221
 222   /* parse a metrics file -- either AFM or PFM depending on what */
 223   /* it turns out to be                                          */
 224   FT_LOCAL_DEF( FT_Error )
 225   T1_Read_Metrics( FT_Face    t1_face,
 226                    FT_Stream  stream )
 227   {
 228     PSAux_Service  psaux;
 229     FT_Memory      memory = stream->memory;
 230     AFM_ParserRec  parser;
 231     AFM_FontInfo   fi;
 232     FT_Error       error = T1_Err_Unknown_File_Format;
 233     T1_Font        t1_font = &( (T1_Face)t1_face )->type1;
 234
 235
 236     if ( FT_NEW( fi )                   ||
 237          FT_FRAME_ENTER( stream->size ) )
 238       goto Exit;
 239
 240     fi->FontBBox  = t1_font->font_bbox;
 241     fi->Ascender  = t1_font->font_bbox.yMax;
 242     fi->Descender = t1_font->font_bbox.yMin;
 243
 244     psaux = (PSAux_Service)( (T1_Face)t1_face )->psaux;
 245     if ( psaux && psaux->afm_parser_funcs )
 246     {
 247       error = psaux->afm_parser_funcs->init( &parser,
 248                                              stream->memory,
 249                                              stream->cursor,
 250                                              stream->limit );
 251
 252       if ( !error )
 253       {
 254         parser.FontInfo  = fi;
 255         parser.get_index = t1_get_index;
 256         parser.user_data = t1_font;
 257
 258         error = psaux->afm_parser_funcs->parse( &parser );
 259         psaux->afm_parser_funcs->done( &parser );
 260       }
 261     }
 262
 263     if ( error == T1_Err_Unknown_File_Format )
 264     {
 265       FT_Byte*  start = stream->cursor;
 266
 267
 268       /* MS Windows allows versions up to 0x3FF without complaining */
 269       if ( stream->size > 6                              &&
 270            start[1] < 4                                  &&
 271            FT_PEEK_ULONG_LE( start + 2 ) == stream->size )
 272         error = T1_Read_PFM( t1_face, stream, fi );
 273     }
 274
 275     if ( !error )
 276     {
 277       t1_font->font_bbox = fi->FontBBox;
 278
 279       t1_face->bbox.xMin =   fi->FontBBox.xMin             >> 16;
 280       t1_face->bbox.yMin =   fi->FontBBox.yMin             >> 16;
 281       t1_face->bbox.xMax = ( fi->FontBBox.xMax + 0xFFFFU ) >> 16;
 282       t1_face->bbox.yMax = ( fi->FontBBox.yMax + 0xFFFFU ) >> 16;
 283
 284       t1_face->ascender  = (FT_Short)( ( fi->Ascender  + 0x8000U ) >> 16 );
 285       t1_face->descender = (FT_Short)( ( fi->Descender + 0x8000U ) >> 16 );
 286
 287       if ( fi->NumKernPair )
 288       {
 289         t1_face->face_flags |= FT_FACE_FLAG_KERNING;
 290         ( (T1_Face)t1_face )->afm_data = fi;
 291         fi = NULL;
 292       }
 293     }
 294
 295     FT_FRAME_EXIT();
 296
 297   Exit:
 298     if ( fi != NULL )
 299       T1_Done_Metrics( memory, fi );
 300
 301     return error;
 302   }
 303
 304
 305   /* find the kerning for a given glyph pair */
 306   FT_LOCAL_DEF( void )
 307   T1_Get_Kerning( AFM_FontInfo  fi,
 308                   FT_UInt       glyph1,
 309                   FT_UInt       glyph2,
 310                   FT_Vector*    kerning )
 311   {
 312     AFM_KernPair  min, mid, max;
 313     FT_ULong      idx = KERN_INDEX( glyph1, glyph2 );
 314
 315
 316     /* simple binary search */
 317     min = fi->KernPairs;
 318     max = min + fi->NumKernPair - 1;
 319
 320     while ( min <= max )
 321     {
 322       FT_ULong  midi;
 323
 324
 325       mid  = min + ( max - min ) / 2;
 326       midi = KERN_INDEX( mid->index1, mid->index2 );
 327
 328       if ( midi == idx )
 329       {
 330         kerning->x = mid->x;
 331         kerning->y = mid->y;
 332
 333         return;
 334       }
 335
 336       if ( midi < idx )
 337         min = mid + 1;
 338       else
 339         max = mid - 1;
 340     }
 341
 342     kerning->x = 0;
 343     kerning->y = 0;
 344   }
 345
 346
 347   FT_LOCAL_DEF( FT_Error )
 348   T1_Get_Track_Kerning( FT_Face    face,
 349                         FT_Fixed   ptsize,
 350                         FT_Int     degree,
 351                         FT_Fixed*  kerning )
 352   {
 353     AFM_FontInfo  fi = (AFM_FontInfo)( (T1_Face)face )->afm_data;
 354     FT_Int        i;
 355
 356
 357     if ( !fi )
 358       return T1_Err_Invalid_Argument;
 359
 360     for ( i = 0; i < fi->NumTrackKern; i++ )
 361     {
 362       AFM_TrackKern  tk = fi->TrackKerns + i;
 363
 364
 365       if ( tk->degree != degree )
 366         continue;
 367
 368       if ( ptsize < tk->min_ptsize )
 369         *kerning = tk->min_kern;
 370       else if ( ptsize > tk->max_ptsize )
 371         *kerning = tk->max_kern;
 372       else
 373       {
 374         *kerning = FT_MulDiv( ptsize - tk->min_ptsize,
 375                               tk->max_kern - tk->min_kern,
 376                               tk->max_ptsize - tk->min_ptsize ) +
 377                    tk->min_kern;
 378       }
 379     }
 380
 381     return T1_Err_Ok;
 382   }
 383
 384
 385 /* END */