1 /**************************************************************************** 2 * 3 * ttload.c 4 * 5 * Load the basic TrueType tables, i.e., tables that can be either in 6 * TTF or OTF fonts (body). 7 * 8 * Copyright (C) 1996-2020 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 #include <ft2build.h> 21 #include FT_INTERNAL_DEBUG_H 22 #include FT_INTERNAL_STREAM_H 23 #include FT_TRUETYPE_TAGS_H 24 #include "ttload.h" 25 26 #include "sferrors.h" 27 28 29 /************************************************************************** 30 * 31 * The macro FT_COMPONENT is used in trace mode. It is an implicit 32 * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log 33 * messages during execution. 34 */ 35 #undef FT_COMPONENT 36 #define FT_COMPONENT ttload 37 38 39 /************************************************************************** 40 * 41 * @Function: 42 * tt_face_lookup_table 43 * 44 * @Description: 45 * Looks for a TrueType table by name. 46 * 47 * @Input: 48 * face :: 49 * A face object handle. 50 * 51 * tag :: 52 * The searched tag. 53 * 54 * @Return: 55 * A pointer to the table directory entry. 0 if not found. 56 */ 57 FT_LOCAL_DEF( TT_Table ) tt_face_lookup_table(TT_Face face,FT_ULong tag)58 tt_face_lookup_table( TT_Face face, 59 FT_ULong tag ) 60 { 61 TT_Table entry; 62 TT_Table limit; 63 #ifdef FT_DEBUG_LEVEL_TRACE 64 FT_Bool zero_length = FALSE; 65 #endif 66 67 68 FT_TRACE4(( "tt_face_lookup_table: %08p, `%c%c%c%c' -- ", 69 face, 70 (FT_Char)( tag >> 24 ), 71 (FT_Char)( tag >> 16 ), 72 (FT_Char)( tag >> 8 ), 73 (FT_Char)( tag ) )); 74 75 entry = face->dir_tables; 76 limit = entry + face->num_tables; 77 78 for ( ; entry < limit; entry++ ) 79 { 80 /* For compatibility with Windows, we consider */ 81 /* zero-length tables the same as missing tables. */ 82 if ( entry->Tag == tag ) 83 { 84 if ( entry->Length != 0 ) 85 { 86 FT_TRACE4(( "found table.\n" )); 87 return entry; 88 } 89 #ifdef FT_DEBUG_LEVEL_TRACE 90 zero_length = TRUE; 91 #endif 92 } 93 } 94 95 #ifdef FT_DEBUG_LEVEL_TRACE 96 if ( zero_length ) 97 FT_TRACE4(( "ignoring empty table\n" )); 98 else 99 FT_TRACE4(( "could not find table\n" )); 100 #endif 101 102 return NULL; 103 } 104 105 106 /************************************************************************** 107 * 108 * @Function: 109 * tt_face_goto_table 110 * 111 * @Description: 112 * Looks for a TrueType table by name, then seek a stream to it. 113 * 114 * @Input: 115 * face :: 116 * A face object handle. 117 * 118 * tag :: 119 * The searched tag. 120 * 121 * stream :: 122 * The stream to seek when the table is found. 123 * 124 * @Output: 125 * length :: 126 * The length of the table if found, undefined otherwise. 127 * 128 * @Return: 129 * FreeType error code. 0 means success. 130 */ 131 FT_LOCAL_DEF( FT_Error ) tt_face_goto_table(TT_Face face,FT_ULong tag,FT_Stream stream,FT_ULong * length)132 tt_face_goto_table( TT_Face face, 133 FT_ULong tag, 134 FT_Stream stream, 135 FT_ULong* length ) 136 { 137 TT_Table table; 138 FT_Error error; 139 140 141 table = tt_face_lookup_table( face, tag ); 142 if ( table ) 143 { 144 if ( length ) 145 *length = table->Length; 146 147 if ( FT_STREAM_SEEK( table->Offset ) ) 148 goto Exit; 149 } 150 else 151 error = FT_THROW( Table_Missing ); 152 153 Exit: 154 return error; 155 } 156 157 158 /* Here, we */ 159 /* */ 160 /* - check that `num_tables' is valid (and adjust it if necessary); */ 161 /* also return the number of valid table entries */ 162 /* */ 163 /* - look for a `head' table, check its size, and parse it to check */ 164 /* whether its `magic' field is correctly set */ 165 /* */ 166 /* - errors (except errors returned by stream handling) */ 167 /* */ 168 /* SFNT_Err_Unknown_File_Format: */ 169 /* no table is defined in directory, it is not sfnt-wrapped */ 170 /* data */ 171 /* SFNT_Err_Table_Missing: */ 172 /* table directory is valid, but essential tables */ 173 /* (head/bhed/SING) are missing */ 174 /* */ 175 static FT_Error check_table_dir(SFNT_Header sfnt,FT_Stream stream,FT_UShort * valid)176 check_table_dir( SFNT_Header sfnt, 177 FT_Stream stream, 178 FT_UShort* valid ) 179 { 180 FT_Error error; 181 FT_UShort nn, valid_entries = 0; 182 FT_UInt has_head = 0, has_sing = 0, has_meta = 0; 183 FT_ULong offset = sfnt->offset + 12; 184 185 static const FT_Frame_Field table_dir_entry_fields[] = 186 { 187 #undef FT_STRUCTURE 188 #define FT_STRUCTURE TT_TableRec 189 190 FT_FRAME_START( 16 ), 191 FT_FRAME_ULONG( Tag ), 192 FT_FRAME_ULONG( CheckSum ), 193 FT_FRAME_ULONG( Offset ), 194 FT_FRAME_ULONG( Length ), 195 FT_FRAME_END 196 }; 197 198 199 if ( FT_STREAM_SEEK( offset ) ) 200 goto Exit; 201 202 for ( nn = 0; nn < sfnt->num_tables; nn++ ) 203 { 204 TT_TableRec table; 205 206 207 if ( FT_STREAM_READ_FIELDS( table_dir_entry_fields, &table ) ) 208 { 209 nn--; 210 FT_TRACE2(( "check_table_dir:" 211 " can read only %d table%s in font (instead of %d)\n", 212 nn, nn == 1 ? "" : "s", sfnt->num_tables )); 213 sfnt->num_tables = nn; 214 break; 215 } 216 217 /* we ignore invalid tables */ 218 219 if ( table.Offset > stream->size ) 220 { 221 FT_TRACE2(( "check_table_dir: table entry %d invalid\n", nn )); 222 continue; 223 } 224 else if ( table.Length > stream->size - table.Offset ) 225 { 226 /* Some tables have such a simple structure that clipping its */ 227 /* contents is harmless. This also makes FreeType less sensitive */ 228 /* to invalid table lengths (which programs like Acroread seem to */ 229 /* ignore in general). */ 230 231 if ( table.Tag == TTAG_hmtx || 232 table.Tag == TTAG_vmtx ) 233 valid_entries++; 234 else 235 { 236 FT_TRACE2(( "check_table_dir: table entry %d invalid\n", nn )); 237 continue; 238 } 239 } 240 else 241 valid_entries++; 242 243 if ( table.Tag == TTAG_head || table.Tag == TTAG_bhed ) 244 { 245 FT_UInt32 magic; 246 247 248 #ifndef TT_CONFIG_OPTION_EMBEDDED_BITMAPS 249 if ( table.Tag == TTAG_head ) 250 #endif 251 has_head = 1; 252 253 /* 254 * The table length should be 0x36, but certain font tools make it 255 * 0x38, so we will just check that it is greater. 256 * 257 * Note that according to the specification, the table must be 258 * padded to 32-bit lengths, but this doesn't apply to the value of 259 * its `Length' field! 260 * 261 */ 262 if ( table.Length < 0x36 ) 263 { 264 FT_TRACE2(( "check_table_dir:" 265 " `head' or `bhed' table too small\n" )); 266 error = FT_THROW( Table_Missing ); 267 goto Exit; 268 } 269 270 if ( FT_STREAM_SEEK( table.Offset + 12 ) || 271 FT_READ_ULONG( magic ) ) 272 goto Exit; 273 274 if ( magic != 0x5F0F3CF5UL ) 275 FT_TRACE2(( "check_table_dir:" 276 " invalid magic number in `head' or `bhed' table\n")); 277 278 if ( FT_STREAM_SEEK( offset + ( nn + 1 ) * 16 ) ) 279 goto Exit; 280 } 281 else if ( table.Tag == TTAG_SING ) 282 has_sing = 1; 283 else if ( table.Tag == TTAG_META ) 284 has_meta = 1; 285 } 286 287 *valid = valid_entries; 288 289 if ( !valid_entries ) 290 { 291 FT_TRACE2(( "check_table_dir: no valid tables found\n" )); 292 error = FT_THROW( Unknown_File_Format ); 293 goto Exit; 294 } 295 296 /* if `sing' and `meta' tables are present, there is no `head' table */ 297 if ( has_head || ( has_sing && has_meta ) ) 298 { 299 error = FT_Err_Ok; 300 goto Exit; 301 } 302 else 303 { 304 FT_TRACE2(( "check_table_dir:" )); 305 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS 306 FT_TRACE2(( " neither `head', `bhed', nor `sing' table found\n" )); 307 #else 308 FT_TRACE2(( " neither `head' nor `sing' table found\n" )); 309 #endif 310 error = FT_THROW( Table_Missing ); 311 } 312 313 Exit: 314 return error; 315 } 316 317 318 /************************************************************************** 319 * 320 * @Function: 321 * tt_face_load_font_dir 322 * 323 * @Description: 324 * Loads the header of a SFNT font file. 325 * 326 * @Input: 327 * face :: 328 * A handle to the target face object. 329 * 330 * stream :: 331 * The input stream. 332 * 333 * @Output: 334 * sfnt :: 335 * The SFNT header. 336 * 337 * @Return: 338 * FreeType error code. 0 means success. 339 * 340 * @Note: 341 * The stream cursor must be at the beginning of the font directory. 342 */ 343 FT_LOCAL_DEF( FT_Error ) tt_face_load_font_dir(TT_Face face,FT_Stream stream)344 tt_face_load_font_dir( TT_Face face, 345 FT_Stream stream ) 346 { 347 SFNT_HeaderRec sfnt; 348 FT_Error error; 349 FT_Memory memory = stream->memory; 350 FT_UShort nn, valid_entries = 0; 351 352 static const FT_Frame_Field offset_table_fields[] = 353 { 354 #undef FT_STRUCTURE 355 #define FT_STRUCTURE SFNT_HeaderRec 356 357 FT_FRAME_START( 8 ), 358 FT_FRAME_USHORT( num_tables ), 359 FT_FRAME_USHORT( search_range ), 360 FT_FRAME_USHORT( entry_selector ), 361 FT_FRAME_USHORT( range_shift ), 362 FT_FRAME_END 363 }; 364 365 366 FT_TRACE2(( "tt_face_load_font_dir: %08p\n", face )); 367 368 /* read the offset table */ 369 370 sfnt.offset = FT_STREAM_POS(); 371 372 if ( FT_READ_ULONG( sfnt.format_tag ) || 373 FT_STREAM_READ_FIELDS( offset_table_fields, &sfnt ) ) 374 goto Exit; 375 376 /* many fonts don't have these fields set correctly */ 377 #if 0 378 if ( sfnt.search_range != 1 << ( sfnt.entry_selector + 4 ) || 379 sfnt.search_range + sfnt.range_shift != sfnt.num_tables << 4 ) 380 return FT_THROW( Unknown_File_Format ); 381 #endif 382 383 /* load the table directory */ 384 385 FT_TRACE2(( "-- Number of tables: %10u\n", sfnt.num_tables )); 386 FT_TRACE2(( "-- Format version: 0x%08lx\n", sfnt.format_tag )); 387 388 if ( sfnt.format_tag != TTAG_OTTO ) 389 { 390 /* check first */ 391 error = check_table_dir( &sfnt, stream, &valid_entries ); 392 if ( error ) 393 { 394 FT_TRACE2(( "tt_face_load_font_dir:" 395 " invalid table directory for TrueType\n" )); 396 goto Exit; 397 } 398 } 399 else 400 { 401 valid_entries = sfnt.num_tables; 402 if ( !valid_entries ) 403 { 404 FT_TRACE2(( "tt_face_load_font_dir: no valid tables found\n" )); 405 error = FT_THROW( Unknown_File_Format ); 406 goto Exit; 407 } 408 } 409 410 face->num_tables = valid_entries; 411 face->format_tag = sfnt.format_tag; 412 413 if ( FT_QNEW_ARRAY( face->dir_tables, face->num_tables ) ) 414 goto Exit; 415 416 if ( FT_STREAM_SEEK( sfnt.offset + 12 ) || 417 FT_FRAME_ENTER( sfnt.num_tables * 16L ) ) 418 goto Exit; 419 420 FT_TRACE2(( "\n" 421 " tag offset length checksum\n" 422 " ----------------------------------\n" )); 423 424 valid_entries = 0; 425 for ( nn = 0; nn < sfnt.num_tables; nn++ ) 426 { 427 TT_TableRec entry; 428 FT_UShort i; 429 FT_Bool duplicate; 430 431 432 entry.Tag = FT_GET_TAG4(); 433 entry.CheckSum = FT_GET_ULONG(); 434 entry.Offset = FT_GET_ULONG(); 435 entry.Length = FT_GET_ULONG(); 436 437 /* ignore invalid tables that can't be sanitized */ 438 439 if ( entry.Offset > stream->size ) 440 continue; 441 else if ( entry.Length > stream->size - entry.Offset ) 442 { 443 if ( entry.Tag == TTAG_hmtx || 444 entry.Tag == TTAG_vmtx ) 445 { 446 #ifdef FT_DEBUG_LEVEL_TRACE 447 FT_ULong old_length = entry.Length; 448 #endif 449 450 451 /* make metrics table length a multiple of 4 */ 452 entry.Length = ( stream->size - entry.Offset ) & ~3U; 453 454 FT_TRACE2(( " %c%c%c%c %08lx %08lx %08lx" 455 " (sanitized; original length %08lx)", 456 (FT_Char)( entry.Tag >> 24 ), 457 (FT_Char)( entry.Tag >> 16 ), 458 (FT_Char)( entry.Tag >> 8 ), 459 (FT_Char)( entry.Tag ), 460 entry.Offset, 461 entry.Length, 462 entry.CheckSum, 463 old_length )); 464 } 465 else 466 continue; 467 } 468 #ifdef FT_DEBUG_LEVEL_TRACE 469 else 470 FT_TRACE2(( " %c%c%c%c %08lx %08lx %08lx", 471 (FT_Char)( entry.Tag >> 24 ), 472 (FT_Char)( entry.Tag >> 16 ), 473 (FT_Char)( entry.Tag >> 8 ), 474 (FT_Char)( entry.Tag ), 475 entry.Offset, 476 entry.Length, 477 entry.CheckSum )); 478 #endif 479 480 /* ignore duplicate tables – the first one wins */ 481 duplicate = 0; 482 for ( i = 0; i < valid_entries; i++ ) 483 { 484 if ( face->dir_tables[i].Tag == entry.Tag ) 485 { 486 duplicate = 1; 487 break; 488 } 489 } 490 if ( duplicate ) 491 { 492 FT_TRACE2(( " (duplicate, ignored)\n" )); 493 continue; 494 } 495 else 496 { 497 FT_TRACE2(( "\n" )); 498 499 /* we finally have a valid entry */ 500 face->dir_tables[valid_entries++] = entry; 501 } 502 } 503 504 /* final adjustment to number of tables */ 505 face->num_tables = valid_entries; 506 507 FT_FRAME_EXIT(); 508 509 FT_TRACE2(( "table directory loaded\n\n" )); 510 511 Exit: 512 return error; 513 } 514 515 516 /************************************************************************** 517 * 518 * @Function: 519 * tt_face_load_any 520 * 521 * @Description: 522 * Loads any font table into client memory. 523 * 524 * @Input: 525 * face :: 526 * The face object to look for. 527 * 528 * tag :: 529 * The tag of table to load. Use the value 0 if you want 530 * to access the whole font file, else set this parameter 531 * to a valid TrueType table tag that you can forge with 532 * the MAKE_TT_TAG macro. 533 * 534 * offset :: 535 * The starting offset in the table (or the file if 536 * tag == 0). 537 * 538 * length :: 539 * The address of the decision variable: 540 * 541 * If length == NULL: 542 * Loads the whole table. Returns an error if 543 * `offset' == 0! 544 * 545 * If *length == 0: 546 * Exits immediately; returning the length of the given 547 * table or of the font file, depending on the value of 548 * `tag'. 549 * 550 * If *length != 0: 551 * Loads the next `length' bytes of table or font, 552 * starting at offset `offset' (in table or font too). 553 * 554 * @Output: 555 * buffer :: 556 * The address of target buffer. 557 * 558 * @Return: 559 * FreeType error code. 0 means success. 560 */ 561 FT_LOCAL_DEF( FT_Error ) tt_face_load_any(TT_Face face,FT_ULong tag,FT_Long offset,FT_Byte * buffer,FT_ULong * length)562 tt_face_load_any( TT_Face face, 563 FT_ULong tag, 564 FT_Long offset, 565 FT_Byte* buffer, 566 FT_ULong* length ) 567 { 568 FT_Error error; 569 FT_Stream stream; 570 TT_Table table; 571 FT_ULong size; 572 573 574 if ( tag != 0 ) 575 { 576 /* look for tag in font directory */ 577 table = tt_face_lookup_table( face, tag ); 578 if ( !table ) 579 { 580 error = FT_THROW( Table_Missing ); 581 goto Exit; 582 } 583 584 offset += table->Offset; 585 size = table->Length; 586 } 587 else 588 /* tag == 0 -- the user wants to access the font file directly */ 589 size = face->root.stream->size; 590 591 if ( length && *length == 0 ) 592 { 593 *length = size; 594 595 return FT_Err_Ok; 596 } 597 598 if ( length ) 599 size = *length; 600 601 stream = face->root.stream; 602 /* the `if' is syntactic sugar for picky compilers */ 603 if ( FT_STREAM_READ_AT( offset, buffer, size ) ) 604 goto Exit; 605 606 Exit: 607 return error; 608 } 609 610 611 /************************************************************************** 612 * 613 * @Function: 614 * tt_face_load_generic_header 615 * 616 * @Description: 617 * Loads the TrueType table `head' or `bhed'. 618 * 619 * @Input: 620 * face :: 621 * A handle to the target face object. 622 * 623 * stream :: 624 * The input stream. 625 * 626 * @Return: 627 * FreeType error code. 0 means success. 628 */ 629 static FT_Error tt_face_load_generic_header(TT_Face face,FT_Stream stream,FT_ULong tag)630 tt_face_load_generic_header( TT_Face face, 631 FT_Stream stream, 632 FT_ULong tag ) 633 { 634 FT_Error error; 635 TT_Header* header; 636 637 static const FT_Frame_Field header_fields[] = 638 { 639 #undef FT_STRUCTURE 640 #define FT_STRUCTURE TT_Header 641 642 FT_FRAME_START( 54 ), 643 FT_FRAME_ULONG ( Table_Version ), 644 FT_FRAME_ULONG ( Font_Revision ), 645 FT_FRAME_LONG ( CheckSum_Adjust ), 646 FT_FRAME_LONG ( Magic_Number ), 647 FT_FRAME_USHORT( Flags ), 648 FT_FRAME_USHORT( Units_Per_EM ), 649 FT_FRAME_ULONG ( Created[0] ), 650 FT_FRAME_ULONG ( Created[1] ), 651 FT_FRAME_ULONG ( Modified[0] ), 652 FT_FRAME_ULONG ( Modified[1] ), 653 FT_FRAME_SHORT ( xMin ), 654 FT_FRAME_SHORT ( yMin ), 655 FT_FRAME_SHORT ( xMax ), 656 FT_FRAME_SHORT ( yMax ), 657 FT_FRAME_USHORT( Mac_Style ), 658 FT_FRAME_USHORT( Lowest_Rec_PPEM ), 659 FT_FRAME_SHORT ( Font_Direction ), 660 FT_FRAME_SHORT ( Index_To_Loc_Format ), 661 FT_FRAME_SHORT ( Glyph_Data_Format ), 662 FT_FRAME_END 663 }; 664 665 666 error = face->goto_table( face, tag, stream, 0 ); 667 if ( error ) 668 goto Exit; 669 670 header = &face->header; 671 672 if ( FT_STREAM_READ_FIELDS( header_fields, header ) ) 673 goto Exit; 674 675 FT_TRACE3(( "Units per EM: %4u\n", header->Units_Per_EM )); 676 FT_TRACE3(( "IndexToLoc: %4d\n", header->Index_To_Loc_Format )); 677 678 Exit: 679 return error; 680 } 681 682 683 FT_LOCAL_DEF( FT_Error ) tt_face_load_head(TT_Face face,FT_Stream stream)684 tt_face_load_head( TT_Face face, 685 FT_Stream stream ) 686 { 687 return tt_face_load_generic_header( face, stream, TTAG_head ); 688 } 689 690 691 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS 692 693 FT_LOCAL_DEF( FT_Error ) tt_face_load_bhed(TT_Face face,FT_Stream stream)694 tt_face_load_bhed( TT_Face face, 695 FT_Stream stream ) 696 { 697 return tt_face_load_generic_header( face, stream, TTAG_bhed ); 698 } 699 700 #endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */ 701 702 703 /************************************************************************** 704 * 705 * @Function: 706 * tt_face_load_maxp 707 * 708 * @Description: 709 * Loads the maximum profile into a face object. 710 * 711 * @Input: 712 * face :: 713 * A handle to the target face object. 714 * 715 * stream :: 716 * The input stream. 717 * 718 * @Return: 719 * FreeType error code. 0 means success. 720 */ 721 FT_LOCAL_DEF( FT_Error ) tt_face_load_maxp(TT_Face face,FT_Stream stream)722 tt_face_load_maxp( TT_Face face, 723 FT_Stream stream ) 724 { 725 FT_Error error; 726 TT_MaxProfile* maxProfile = &face->max_profile; 727 728 static const FT_Frame_Field maxp_fields[] = 729 { 730 #undef FT_STRUCTURE 731 #define FT_STRUCTURE TT_MaxProfile 732 733 FT_FRAME_START( 6 ), 734 FT_FRAME_LONG ( version ), 735 FT_FRAME_USHORT( numGlyphs ), 736 FT_FRAME_END 737 }; 738 739 static const FT_Frame_Field maxp_fields_extra[] = 740 { 741 FT_FRAME_START( 26 ), 742 FT_FRAME_USHORT( maxPoints ), 743 FT_FRAME_USHORT( maxContours ), 744 FT_FRAME_USHORT( maxCompositePoints ), 745 FT_FRAME_USHORT( maxCompositeContours ), 746 FT_FRAME_USHORT( maxZones ), 747 FT_FRAME_USHORT( maxTwilightPoints ), 748 FT_FRAME_USHORT( maxStorage ), 749 FT_FRAME_USHORT( maxFunctionDefs ), 750 FT_FRAME_USHORT( maxInstructionDefs ), 751 FT_FRAME_USHORT( maxStackElements ), 752 FT_FRAME_USHORT( maxSizeOfInstructions ), 753 FT_FRAME_USHORT( maxComponentElements ), 754 FT_FRAME_USHORT( maxComponentDepth ), 755 FT_FRAME_END 756 }; 757 758 759 error = face->goto_table( face, TTAG_maxp, stream, 0 ); 760 if ( error ) 761 goto Exit; 762 763 if ( FT_STREAM_READ_FIELDS( maxp_fields, maxProfile ) ) 764 goto Exit; 765 766 maxProfile->maxPoints = 0; 767 maxProfile->maxContours = 0; 768 maxProfile->maxCompositePoints = 0; 769 maxProfile->maxCompositeContours = 0; 770 maxProfile->maxZones = 0; 771 maxProfile->maxTwilightPoints = 0; 772 maxProfile->maxStorage = 0; 773 maxProfile->maxFunctionDefs = 0; 774 maxProfile->maxInstructionDefs = 0; 775 maxProfile->maxStackElements = 0; 776 maxProfile->maxSizeOfInstructions = 0; 777 maxProfile->maxComponentElements = 0; 778 maxProfile->maxComponentDepth = 0; 779 780 if ( maxProfile->version >= 0x10000L ) 781 { 782 if ( FT_STREAM_READ_FIELDS( maxp_fields_extra, maxProfile ) ) 783 goto Exit; 784 785 /* XXX: an adjustment that is necessary to load certain */ 786 /* broken fonts like `Keystrokes MT' :-( */ 787 /* */ 788 /* We allocate 64 function entries by default when */ 789 /* the maxFunctionDefs value is smaller. */ 790 791 if ( maxProfile->maxFunctionDefs < 64 ) 792 maxProfile->maxFunctionDefs = 64; 793 794 /* we add 4 phantom points later */ 795 if ( maxProfile->maxTwilightPoints > ( 0xFFFFU - 4 ) ) 796 { 797 FT_TRACE0(( "tt_face_load_maxp:" 798 " too much twilight points in `maxp' table;\n" 799 " " 800 " some glyphs might be rendered incorrectly\n" )); 801 802 maxProfile->maxTwilightPoints = 0xFFFFU - 4; 803 } 804 } 805 806 FT_TRACE3(( "numGlyphs: %u\n", maxProfile->numGlyphs )); 807 808 Exit: 809 return error; 810 } 811 812 813 /************************************************************************** 814 * 815 * @Function: 816 * tt_face_load_name 817 * 818 * @Description: 819 * Loads the name records. 820 * 821 * @Input: 822 * face :: 823 * A handle to the target face object. 824 * 825 * stream :: 826 * The input stream. 827 * 828 * @Return: 829 * FreeType error code. 0 means success. 830 */ 831 FT_LOCAL_DEF( FT_Error ) tt_face_load_name(TT_Face face,FT_Stream stream)832 tt_face_load_name( TT_Face face, 833 FT_Stream stream ) 834 { 835 FT_Error error; 836 FT_Memory memory = stream->memory; 837 FT_ULong table_pos, table_len; 838 FT_ULong storage_start, storage_limit; 839 TT_NameTable table; 840 841 static const FT_Frame_Field name_table_fields[] = 842 { 843 #undef FT_STRUCTURE 844 #define FT_STRUCTURE TT_NameTableRec 845 846 FT_FRAME_START( 6 ), 847 FT_FRAME_USHORT( format ), 848 FT_FRAME_USHORT( numNameRecords ), 849 FT_FRAME_USHORT( storageOffset ), 850 FT_FRAME_END 851 }; 852 853 static const FT_Frame_Field name_record_fields[] = 854 { 855 #undef FT_STRUCTURE 856 #define FT_STRUCTURE TT_NameRec 857 858 /* no FT_FRAME_START */ 859 FT_FRAME_USHORT( platformID ), 860 FT_FRAME_USHORT( encodingID ), 861 FT_FRAME_USHORT( languageID ), 862 FT_FRAME_USHORT( nameID ), 863 FT_FRAME_USHORT( stringLength ), 864 FT_FRAME_USHORT( stringOffset ), 865 FT_FRAME_END 866 }; 867 868 static const FT_Frame_Field langTag_record_fields[] = 869 { 870 #undef FT_STRUCTURE 871 #define FT_STRUCTURE TT_LangTagRec 872 873 /* no FT_FRAME_START */ 874 FT_FRAME_USHORT( stringLength ), 875 FT_FRAME_USHORT( stringOffset ), 876 FT_FRAME_END 877 }; 878 879 880 table = &face->name_table; 881 table->stream = stream; 882 883 error = face->goto_table( face, TTAG_name, stream, &table_len ); 884 if ( error ) 885 goto Exit; 886 887 table_pos = FT_STREAM_POS(); 888 889 if ( FT_STREAM_READ_FIELDS( name_table_fields, table ) ) 890 goto Exit; 891 892 /* Some popular Asian fonts have an invalid `storageOffset' value (it */ 893 /* should be at least `6 + 12*numNameRecords'). However, the string */ 894 /* offsets, computed as `storageOffset + entry->stringOffset', are */ 895 /* valid pointers within the name table... */ 896 /* */ 897 /* We thus can't check `storageOffset' right now. */ 898 /* */ 899 storage_start = table_pos + 6 + 12 * table->numNameRecords; 900 storage_limit = table_pos + table_len; 901 902 if ( storage_start > storage_limit ) 903 { 904 FT_ERROR(( "tt_face_load_name: invalid `name' table\n" )); 905 error = FT_THROW( Name_Table_Missing ); 906 goto Exit; 907 } 908 909 /* `name' format 1 contains additional language tag records, */ 910 /* which we load first */ 911 if ( table->format == 1 ) 912 { 913 if ( FT_STREAM_SEEK( storage_start ) || 914 FT_READ_USHORT( table->numLangTagRecords ) ) 915 goto Exit; 916 917 storage_start += 2 + 4 * table->numLangTagRecords; 918 919 /* allocate language tag records array */ 920 if ( FT_NEW_ARRAY( table->langTags, table->numLangTagRecords ) || 921 FT_FRAME_ENTER( table->numLangTagRecords * 4 ) ) 922 goto Exit; 923 924 /* load language tags */ 925 { 926 TT_LangTag entry = table->langTags; 927 TT_LangTag limit = FT_OFFSET( entry, table->numLangTagRecords ); 928 929 930 for ( ; entry < limit; entry++ ) 931 { 932 (void)FT_STREAM_READ_FIELDS( langTag_record_fields, entry ); 933 934 /* check that the langTag string is within the table */ 935 entry->stringOffset += table_pos + table->storageOffset; 936 if ( entry->stringOffset < storage_start || 937 entry->stringOffset + entry->stringLength > storage_limit ) 938 { 939 /* invalid entry; ignore it */ 940 entry->stringLength = 0; 941 } 942 } 943 } 944 945 FT_FRAME_EXIT(); 946 947 (void)FT_STREAM_SEEK( table_pos + 6 ); 948 } 949 950 /* allocate name records array */ 951 if ( FT_NEW_ARRAY( table->names, table->numNameRecords ) || 952 FT_FRAME_ENTER( table->numNameRecords * 12 ) ) 953 goto Exit; 954 955 /* load name records */ 956 { 957 TT_Name entry = table->names; 958 FT_UInt count = table->numNameRecords; 959 960 961 for ( ; count > 0; count-- ) 962 { 963 if ( FT_STREAM_READ_FIELDS( name_record_fields, entry ) ) 964 continue; 965 966 /* check that the name is not empty */ 967 if ( entry->stringLength == 0 ) 968 continue; 969 970 /* check that the name string is within the table */ 971 entry->stringOffset += table_pos + table->storageOffset; 972 if ( entry->stringOffset < storage_start || 973 entry->stringOffset + entry->stringLength > storage_limit ) 974 { 975 /* invalid entry; ignore it */ 976 continue; 977 } 978 979 /* assure that we have a valid language tag ID, and */ 980 /* that the corresponding langTag entry is valid, too */ 981 if ( table->format == 1 && entry->languageID >= 0x8000U ) 982 { 983 if ( entry->languageID - 0x8000U >= table->numLangTagRecords || 984 !table->langTags[entry->languageID - 0x8000U].stringLength ) 985 { 986 /* invalid entry; ignore it */ 987 continue; 988 } 989 } 990 991 entry++; 992 } 993 994 /* reduce array size to the actually used elements */ 995 count = (FT_UInt)( entry - table->names ); 996 (void)FT_RENEW_ARRAY( table->names, 997 table->numNameRecords, 998 count ); 999 table->numNameRecords = count; 1000 } 1001 1002 FT_FRAME_EXIT(); 1003 1004 /* everything went well, update face->num_names */ 1005 face->num_names = (FT_UShort)table->numNameRecords; 1006 1007 Exit: 1008 return error; 1009 } 1010 1011 1012 /************************************************************************** 1013 * 1014 * @Function: 1015 * tt_face_free_name 1016 * 1017 * @Description: 1018 * Frees the name records. 1019 * 1020 * @Input: 1021 * face :: 1022 * A handle to the target face object. 1023 */ 1024 FT_LOCAL_DEF( void ) tt_face_free_name(TT_Face face)1025 tt_face_free_name( TT_Face face ) 1026 { 1027 FT_Memory memory = face->root.driver->root.memory; 1028 TT_NameTable table = &face->name_table; 1029 1030 1031 if ( table->names ) 1032 { 1033 TT_Name entry = table->names; 1034 TT_Name limit = entry + table->numNameRecords; 1035 1036 1037 for ( ; entry < limit; entry++ ) 1038 FT_FREE( entry->string ); 1039 1040 FT_FREE( table->names ); 1041 } 1042 1043 if ( table->langTags ) 1044 { 1045 TT_LangTag entry = table->langTags; 1046 TT_LangTag limit = entry + table->numLangTagRecords; 1047 1048 1049 for ( ; entry < limit; entry++ ) 1050 FT_FREE( entry->string ); 1051 1052 FT_FREE( table->langTags ); 1053 } 1054 1055 table->numNameRecords = 0; 1056 table->numLangTagRecords = 0; 1057 table->format = 0; 1058 table->storageOffset = 0; 1059 } 1060 1061 1062 /************************************************************************** 1063 * 1064 * @Function: 1065 * tt_face_load_cmap 1066 * 1067 * @Description: 1068 * Loads the cmap directory in a face object. The cmaps themselves 1069 * are loaded on demand in the `ttcmap.c' module. 1070 * 1071 * @Input: 1072 * face :: 1073 * A handle to the target face object. 1074 * 1075 * stream :: 1076 * A handle to the input stream. 1077 * 1078 * @Return: 1079 * FreeType error code. 0 means success. 1080 */ 1081 1082 FT_LOCAL_DEF( FT_Error ) tt_face_load_cmap(TT_Face face,FT_Stream stream)1083 tt_face_load_cmap( TT_Face face, 1084 FT_Stream stream ) 1085 { 1086 FT_Error error; 1087 1088 1089 error = face->goto_table( face, TTAG_cmap, stream, &face->cmap_size ); 1090 if ( error ) 1091 goto Exit; 1092 1093 if ( FT_FRAME_EXTRACT( face->cmap_size, face->cmap_table ) ) 1094 face->cmap_size = 0; 1095 1096 Exit: 1097 return error; 1098 } 1099 1100 1101 1102 /************************************************************************** 1103 * 1104 * @Function: 1105 * tt_face_load_os2 1106 * 1107 * @Description: 1108 * Loads the OS2 table. 1109 * 1110 * @Input: 1111 * face :: 1112 * A handle to the target face object. 1113 * 1114 * stream :: 1115 * A handle to the input stream. 1116 * 1117 * @Return: 1118 * FreeType error code. 0 means success. 1119 */ 1120 FT_LOCAL_DEF( FT_Error ) tt_face_load_os2(TT_Face face,FT_Stream stream)1121 tt_face_load_os2( TT_Face face, 1122 FT_Stream stream ) 1123 { 1124 FT_Error error; 1125 TT_OS2* os2; 1126 1127 static const FT_Frame_Field os2_fields[] = 1128 { 1129 #undef FT_STRUCTURE 1130 #define FT_STRUCTURE TT_OS2 1131 1132 FT_FRAME_START( 78 ), 1133 FT_FRAME_USHORT( version ), 1134 FT_FRAME_SHORT ( xAvgCharWidth ), 1135 FT_FRAME_USHORT( usWeightClass ), 1136 FT_FRAME_USHORT( usWidthClass ), 1137 FT_FRAME_SHORT ( fsType ), 1138 FT_FRAME_SHORT ( ySubscriptXSize ), 1139 FT_FRAME_SHORT ( ySubscriptYSize ), 1140 FT_FRAME_SHORT ( ySubscriptXOffset ), 1141 FT_FRAME_SHORT ( ySubscriptYOffset ), 1142 FT_FRAME_SHORT ( ySuperscriptXSize ), 1143 FT_FRAME_SHORT ( ySuperscriptYSize ), 1144 FT_FRAME_SHORT ( ySuperscriptXOffset ), 1145 FT_FRAME_SHORT ( ySuperscriptYOffset ), 1146 FT_FRAME_SHORT ( yStrikeoutSize ), 1147 FT_FRAME_SHORT ( yStrikeoutPosition ), 1148 FT_FRAME_SHORT ( sFamilyClass ), 1149 FT_FRAME_BYTE ( panose[0] ), 1150 FT_FRAME_BYTE ( panose[1] ), 1151 FT_FRAME_BYTE ( panose[2] ), 1152 FT_FRAME_BYTE ( panose[3] ), 1153 FT_FRAME_BYTE ( panose[4] ), 1154 FT_FRAME_BYTE ( panose[5] ), 1155 FT_FRAME_BYTE ( panose[6] ), 1156 FT_FRAME_BYTE ( panose[7] ), 1157 FT_FRAME_BYTE ( panose[8] ), 1158 FT_FRAME_BYTE ( panose[9] ), 1159 FT_FRAME_ULONG ( ulUnicodeRange1 ), 1160 FT_FRAME_ULONG ( ulUnicodeRange2 ), 1161 FT_FRAME_ULONG ( ulUnicodeRange3 ), 1162 FT_FRAME_ULONG ( ulUnicodeRange4 ), 1163 FT_FRAME_BYTE ( achVendID[0] ), 1164 FT_FRAME_BYTE ( achVendID[1] ), 1165 FT_FRAME_BYTE ( achVendID[2] ), 1166 FT_FRAME_BYTE ( achVendID[3] ), 1167 1168 FT_FRAME_USHORT( fsSelection ), 1169 FT_FRAME_USHORT( usFirstCharIndex ), 1170 FT_FRAME_USHORT( usLastCharIndex ), 1171 FT_FRAME_SHORT ( sTypoAscender ), 1172 FT_FRAME_SHORT ( sTypoDescender ), 1173 FT_FRAME_SHORT ( sTypoLineGap ), 1174 FT_FRAME_USHORT( usWinAscent ), 1175 FT_FRAME_USHORT( usWinDescent ), 1176 FT_FRAME_END 1177 }; 1178 1179 /* `OS/2' version 1 and newer */ 1180 static const FT_Frame_Field os2_fields_extra1[] = 1181 { 1182 FT_FRAME_START( 8 ), 1183 FT_FRAME_ULONG( ulCodePageRange1 ), 1184 FT_FRAME_ULONG( ulCodePageRange2 ), 1185 FT_FRAME_END 1186 }; 1187 1188 /* `OS/2' version 2 and newer */ 1189 static const FT_Frame_Field os2_fields_extra2[] = 1190 { 1191 FT_FRAME_START( 10 ), 1192 FT_FRAME_SHORT ( sxHeight ), 1193 FT_FRAME_SHORT ( sCapHeight ), 1194 FT_FRAME_USHORT( usDefaultChar ), 1195 FT_FRAME_USHORT( usBreakChar ), 1196 FT_FRAME_USHORT( usMaxContext ), 1197 FT_FRAME_END 1198 }; 1199 1200 /* `OS/2' version 5 and newer */ 1201 static const FT_Frame_Field os2_fields_extra5[] = 1202 { 1203 FT_FRAME_START( 4 ), 1204 FT_FRAME_USHORT( usLowerOpticalPointSize ), 1205 FT_FRAME_USHORT( usUpperOpticalPointSize ), 1206 FT_FRAME_END 1207 }; 1208 1209 1210 /* We now support old Mac fonts where the OS/2 table doesn't */ 1211 /* exist. Simply put, we set the `version' field to 0xFFFF */ 1212 /* and test this value each time we need to access the table. */ 1213 error = face->goto_table( face, TTAG_OS2, stream, 0 ); 1214 if ( error ) 1215 goto Exit; 1216 1217 os2 = &face->os2; 1218 1219 if ( FT_STREAM_READ_FIELDS( os2_fields, os2 ) ) 1220 goto Exit; 1221 1222 os2->ulCodePageRange1 = 0; 1223 os2->ulCodePageRange2 = 0; 1224 os2->sxHeight = 0; 1225 os2->sCapHeight = 0; 1226 os2->usDefaultChar = 0; 1227 os2->usBreakChar = 0; 1228 os2->usMaxContext = 0; 1229 os2->usLowerOpticalPointSize = 0; 1230 os2->usUpperOpticalPointSize = 0xFFFF; 1231 1232 if ( os2->version >= 0x0001 ) 1233 { 1234 /* only version 1 tables */ 1235 if ( FT_STREAM_READ_FIELDS( os2_fields_extra1, os2 ) ) 1236 goto Exit; 1237 1238 if ( os2->version >= 0x0002 ) 1239 { 1240 /* only version 2 tables */ 1241 if ( FT_STREAM_READ_FIELDS( os2_fields_extra2, os2 ) ) 1242 goto Exit; 1243 1244 if ( os2->version >= 0x0005 ) 1245 { 1246 /* only version 5 tables */ 1247 if ( FT_STREAM_READ_FIELDS( os2_fields_extra5, os2 ) ) 1248 goto Exit; 1249 } 1250 } 1251 } 1252 1253 FT_TRACE3(( "sTypoAscender: %4d\n", os2->sTypoAscender )); 1254 FT_TRACE3(( "sTypoDescender: %4d\n", os2->sTypoDescender )); 1255 FT_TRACE3(( "usWinAscent: %4u\n", os2->usWinAscent )); 1256 FT_TRACE3(( "usWinDescent: %4u\n", os2->usWinDescent )); 1257 FT_TRACE3(( "fsSelection: 0x%2x\n", os2->fsSelection )); 1258 1259 Exit: 1260 return error; 1261 } 1262 1263 1264 /************************************************************************** 1265 * 1266 * @Function: 1267 * tt_face_load_postscript 1268 * 1269 * @Description: 1270 * Loads the Postscript table. 1271 * 1272 * @Input: 1273 * face :: 1274 * A handle to the target face object. 1275 * 1276 * stream :: 1277 * A handle to the input stream. 1278 * 1279 * @Return: 1280 * FreeType error code. 0 means success. 1281 */ 1282 FT_LOCAL_DEF( FT_Error ) tt_face_load_post(TT_Face face,FT_Stream stream)1283 tt_face_load_post( TT_Face face, 1284 FT_Stream stream ) 1285 { 1286 FT_Error error; 1287 TT_Postscript* post = &face->postscript; 1288 1289 static const FT_Frame_Field post_fields[] = 1290 { 1291 #undef FT_STRUCTURE 1292 #define FT_STRUCTURE TT_Postscript 1293 1294 FT_FRAME_START( 32 ), 1295 FT_FRAME_LONG ( FormatType ), 1296 FT_FRAME_LONG ( italicAngle ), 1297 FT_FRAME_SHORT( underlinePosition ), 1298 FT_FRAME_SHORT( underlineThickness ), 1299 FT_FRAME_ULONG( isFixedPitch ), 1300 FT_FRAME_ULONG( minMemType42 ), 1301 FT_FRAME_ULONG( maxMemType42 ), 1302 FT_FRAME_ULONG( minMemType1 ), 1303 FT_FRAME_ULONG( maxMemType1 ), 1304 FT_FRAME_END 1305 }; 1306 1307 1308 error = face->goto_table( face, TTAG_post, stream, 0 ); 1309 if ( error ) 1310 return error; 1311 1312 if ( FT_STREAM_READ_FIELDS( post_fields, post ) ) 1313 return error; 1314 1315 /* we don't load the glyph names, we do that in another */ 1316 /* module (ttpost). */ 1317 1318 FT_TRACE3(( "FormatType: 0x%x\n", post->FormatType )); 1319 FT_TRACE3(( "isFixedPitch: %s\n", post->isFixedPitch 1320 ? " yes" : " no" )); 1321 1322 return FT_Err_Ok; 1323 } 1324 1325 1326 /************************************************************************** 1327 * 1328 * @Function: 1329 * tt_face_load_pclt 1330 * 1331 * @Description: 1332 * Loads the PCL 5 Table. 1333 * 1334 * @Input: 1335 * face :: 1336 * A handle to the target face object. 1337 * 1338 * stream :: 1339 * A handle to the input stream. 1340 * 1341 * @Return: 1342 * FreeType error code. 0 means success. 1343 */ 1344 FT_LOCAL_DEF( FT_Error ) tt_face_load_pclt(TT_Face face,FT_Stream stream)1345 tt_face_load_pclt( TT_Face face, 1346 FT_Stream stream ) 1347 { 1348 static const FT_Frame_Field pclt_fields[] = 1349 { 1350 #undef FT_STRUCTURE 1351 #define FT_STRUCTURE TT_PCLT 1352 1353 FT_FRAME_START( 54 ), 1354 FT_FRAME_ULONG ( Version ), 1355 FT_FRAME_ULONG ( FontNumber ), 1356 FT_FRAME_USHORT( Pitch ), 1357 FT_FRAME_USHORT( xHeight ), 1358 FT_FRAME_USHORT( Style ), 1359 FT_FRAME_USHORT( TypeFamily ), 1360 FT_FRAME_USHORT( CapHeight ), 1361 FT_FRAME_USHORT( SymbolSet ), 1362 FT_FRAME_BYTES ( TypeFace, 16 ), 1363 FT_FRAME_BYTES ( CharacterComplement, 8 ), 1364 FT_FRAME_BYTES ( FileName, 6 ), 1365 FT_FRAME_CHAR ( StrokeWeight ), 1366 FT_FRAME_CHAR ( WidthType ), 1367 FT_FRAME_BYTE ( SerifStyle ), 1368 FT_FRAME_BYTE ( Reserved ), 1369 FT_FRAME_END 1370 }; 1371 1372 FT_Error error; 1373 TT_PCLT* pclt = &face->pclt; 1374 1375 1376 /* optional table */ 1377 error = face->goto_table( face, TTAG_PCLT, stream, 0 ); 1378 if ( error ) 1379 goto Exit; 1380 1381 if ( FT_STREAM_READ_FIELDS( pclt_fields, pclt ) ) 1382 goto Exit; 1383 1384 Exit: 1385 return error; 1386 } 1387 1388 1389 /************************************************************************** 1390 * 1391 * @Function: 1392 * tt_face_load_gasp 1393 * 1394 * @Description: 1395 * Loads the `gasp' table into a face object. 1396 * 1397 * @Input: 1398 * face :: 1399 * A handle to the target face object. 1400 * 1401 * stream :: 1402 * The input stream. 1403 * 1404 * @Return: 1405 * FreeType error code. 0 means success. 1406 */ 1407 FT_LOCAL_DEF( FT_Error ) tt_face_load_gasp(TT_Face face,FT_Stream stream)1408 tt_face_load_gasp( TT_Face face, 1409 FT_Stream stream ) 1410 { 1411 FT_Error error; 1412 FT_Memory memory = stream->memory; 1413 1414 FT_UInt j,num_ranges; 1415 TT_GaspRange gaspranges = NULL; 1416 1417 1418 /* the gasp table is optional */ 1419 error = face->goto_table( face, TTAG_gasp, stream, 0 ); 1420 if ( error ) 1421 goto Exit; 1422 1423 if ( FT_FRAME_ENTER( 4L ) ) 1424 goto Exit; 1425 1426 face->gasp.version = FT_GET_USHORT(); 1427 face->gasp.numRanges = FT_GET_USHORT(); 1428 1429 FT_FRAME_EXIT(); 1430 1431 /* only support versions 0 and 1 of the table */ 1432 if ( face->gasp.version >= 2 ) 1433 { 1434 face->gasp.numRanges = 0; 1435 error = FT_THROW( Invalid_Table ); 1436 goto Exit; 1437 } 1438 1439 num_ranges = face->gasp.numRanges; 1440 FT_TRACE3(( "numRanges: %u\n", num_ranges )); 1441 1442 if ( FT_QNEW_ARRAY( face->gasp.gaspRanges, num_ranges ) || 1443 FT_FRAME_ENTER( num_ranges * 4L ) ) 1444 goto Exit; 1445 1446 gaspranges = face->gasp.gaspRanges; 1447 1448 for ( j = 0; j < num_ranges; j++ ) 1449 { 1450 gaspranges[j].maxPPEM = FT_GET_USHORT(); 1451 gaspranges[j].gaspFlag = FT_GET_USHORT(); 1452 1453 FT_TRACE3(( "gaspRange %d: rangeMaxPPEM %5d, rangeGaspBehavior 0x%x\n", 1454 j, 1455 gaspranges[j].maxPPEM, 1456 gaspranges[j].gaspFlag )); 1457 } 1458 1459 FT_FRAME_EXIT(); 1460 1461 Exit: 1462 return error; 1463 } 1464 1465 1466 /* END */ 1467