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