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