1 /***************************************************************************/ 2 /* */ 3 /* cffload.c */ 4 /* */ 5 /* OpenType and CFF data/program tables loader (body). */ 6 /* */ 7 /* Copyright 1996-2013 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 FT_INTERNAL_DEBUG_H 21 #include FT_INTERNAL_OBJECTS_H 22 #include FT_INTERNAL_STREAM_H 23 #include FT_TRUETYPE_TAGS_H 24 #include FT_TYPE1_TABLES_H 25 26 #include "cffload.h" 27 #include "cffparse.h" 28 29 #include "cfferrs.h" 30 31 32 #if 1 33 34 static const FT_UShort cff_isoadobe_charset[229] = 35 { 36 0, 1, 2, 3, 4, 5, 6, 7, 37 8, 9, 10, 11, 12, 13, 14, 15, 38 16, 17, 18, 19, 20, 21, 22, 23, 39 24, 25, 26, 27, 28, 29, 30, 31, 40 32, 33, 34, 35, 36, 37, 38, 39, 41 40, 41, 42, 43, 44, 45, 46, 47, 42 48, 49, 50, 51, 52, 53, 54, 55, 43 56, 57, 58, 59, 60, 61, 62, 63, 44 64, 65, 66, 67, 68, 69, 70, 71, 45 72, 73, 74, 75, 76, 77, 78, 79, 46 80, 81, 82, 83, 84, 85, 86, 87, 47 88, 89, 90, 91, 92, 93, 94, 95, 48 96, 97, 98, 99, 100, 101, 102, 103, 49 104, 105, 106, 107, 108, 109, 110, 111, 50 112, 113, 114, 115, 116, 117, 118, 119, 51 120, 121, 122, 123, 124, 125, 126, 127, 52 128, 129, 130, 131, 132, 133, 134, 135, 53 136, 137, 138, 139, 140, 141, 142, 143, 54 144, 145, 146, 147, 148, 149, 150, 151, 55 152, 153, 154, 155, 156, 157, 158, 159, 56 160, 161, 162, 163, 164, 165, 166, 167, 57 168, 169, 170, 171, 172, 173, 174, 175, 58 176, 177, 178, 179, 180, 181, 182, 183, 59 184, 185, 186, 187, 188, 189, 190, 191, 60 192, 193, 194, 195, 196, 197, 198, 199, 61 200, 201, 202, 203, 204, 205, 206, 207, 62 208, 209, 210, 211, 212, 213, 214, 215, 63 216, 217, 218, 219, 220, 221, 222, 223, 64 224, 225, 226, 227, 228 65 }; 66 67 static const FT_UShort cff_expert_charset[166] = 68 { 69 0, 1, 229, 230, 231, 232, 233, 234, 70 235, 236, 237, 238, 13, 14, 15, 99, 71 239, 240, 241, 242, 243, 244, 245, 246, 72 247, 248, 27, 28, 249, 250, 251, 252, 73 253, 254, 255, 256, 257, 258, 259, 260, 74 261, 262, 263, 264, 265, 266, 109, 110, 75 267, 268, 269, 270, 271, 272, 273, 274, 76 275, 276, 277, 278, 279, 280, 281, 282, 77 283, 284, 285, 286, 287, 288, 289, 290, 78 291, 292, 293, 294, 295, 296, 297, 298, 79 299, 300, 301, 302, 303, 304, 305, 306, 80 307, 308, 309, 310, 311, 312, 313, 314, 81 315, 316, 317, 318, 158, 155, 163, 319, 82 320, 321, 322, 323, 324, 325, 326, 150, 83 164, 169, 327, 328, 329, 330, 331, 332, 84 333, 334, 335, 336, 337, 338, 339, 340, 85 341, 342, 343, 344, 345, 346, 347, 348, 86 349, 350, 351, 352, 353, 354, 355, 356, 87 357, 358, 359, 360, 361, 362, 363, 364, 88 365, 366, 367, 368, 369, 370, 371, 372, 89 373, 374, 375, 376, 377, 378 90 }; 91 92 static const FT_UShort cff_expertsubset_charset[87] = 93 { 94 0, 1, 231, 232, 235, 236, 237, 238, 95 13, 14, 15, 99, 239, 240, 241, 242, 96 243, 244, 245, 246, 247, 248, 27, 28, 97 249, 250, 251, 253, 254, 255, 256, 257, 98 258, 259, 260, 261, 262, 263, 264, 265, 99 266, 109, 110, 267, 268, 269, 270, 272, 100 300, 301, 302, 305, 314, 315, 158, 155, 101 163, 320, 321, 322, 323, 324, 325, 326, 102 150, 164, 169, 327, 328, 329, 330, 331, 103 332, 333, 334, 335, 336, 337, 338, 339, 104 340, 341, 342, 343, 344, 345, 346 105 }; 106 107 static const FT_UShort cff_standard_encoding[256] = 108 { 109 0, 0, 0, 0, 0, 0, 0, 0, 110 0, 0, 0, 0, 0, 0, 0, 0, 111 0, 0, 0, 0, 0, 0, 0, 0, 112 0, 0, 0, 0, 0, 0, 0, 0, 113 1, 2, 3, 4, 5, 6, 7, 8, 114 9, 10, 11, 12, 13, 14, 15, 16, 115 17, 18, 19, 20, 21, 22, 23, 24, 116 25, 26, 27, 28, 29, 30, 31, 32, 117 33, 34, 35, 36, 37, 38, 39, 40, 118 41, 42, 43, 44, 45, 46, 47, 48, 119 49, 50, 51, 52, 53, 54, 55, 56, 120 57, 58, 59, 60, 61, 62, 63, 64, 121 65, 66, 67, 68, 69, 70, 71, 72, 122 73, 74, 75, 76, 77, 78, 79, 80, 123 81, 82, 83, 84, 85, 86, 87, 88, 124 89, 90, 91, 92, 93, 94, 95, 0, 125 0, 0, 0, 0, 0, 0, 0, 0, 126 0, 0, 0, 0, 0, 0, 0, 0, 127 0, 0, 0, 0, 0, 0, 0, 0, 128 0, 0, 0, 0, 0, 0, 0, 0, 129 0, 96, 97, 98, 99, 100, 101, 102, 130 103, 104, 105, 106, 107, 108, 109, 110, 131 0, 111, 112, 113, 114, 0, 115, 116, 132 117, 118, 119, 120, 121, 122, 0, 123, 133 0, 124, 125, 126, 127, 128, 129, 130, 134 131, 0, 132, 133, 0, 134, 135, 136, 135 137, 0, 0, 0, 0, 0, 0, 0, 136 0, 0, 0, 0, 0, 0, 0, 0, 137 0, 138, 0, 139, 0, 0, 0, 0, 138 140, 141, 142, 143, 0, 0, 0, 0, 139 0, 144, 0, 0, 0, 145, 0, 0, 140 146, 147, 148, 149, 0, 0, 0, 0 141 }; 142 143 static const FT_UShort cff_expert_encoding[256] = 144 { 145 0, 0, 0, 0, 0, 0, 0, 0, 146 0, 0, 0, 0, 0, 0, 0, 0, 147 0, 0, 0, 0, 0, 0, 0, 0, 148 0, 0, 0, 0, 0, 0, 0, 0, 149 1, 229, 230, 0, 231, 232, 233, 234, 150 235, 236, 237, 238, 13, 14, 15, 99, 151 239, 240, 241, 242, 243, 244, 245, 246, 152 247, 248, 27, 28, 249, 250, 251, 252, 153 0, 253, 254, 255, 256, 257, 0, 0, 154 0, 258, 0, 0, 259, 260, 261, 262, 155 0, 0, 263, 264, 265, 0, 266, 109, 156 110, 267, 268, 269, 0, 270, 271, 272, 157 273, 274, 275, 276, 277, 278, 279, 280, 158 281, 282, 283, 284, 285, 286, 287, 288, 159 289, 290, 291, 292, 293, 294, 295, 296, 160 297, 298, 299, 300, 301, 302, 303, 0, 161 0, 0, 0, 0, 0, 0, 0, 0, 162 0, 0, 0, 0, 0, 0, 0, 0, 163 0, 0, 0, 0, 0, 0, 0, 0, 164 0, 0, 0, 0, 0, 0, 0, 0, 165 0, 304, 305, 306, 0, 0, 307, 308, 166 309, 310, 311, 0, 312, 0, 0, 312, 167 0, 0, 314, 315, 0, 0, 316, 317, 168 318, 0, 0, 0, 158, 155, 163, 319, 169 320, 321, 322, 323, 324, 325, 0, 0, 170 326, 150, 164, 169, 327, 328, 329, 330, 171 331, 332, 333, 334, 335, 336, 337, 338, 172 339, 340, 341, 342, 343, 344, 345, 346, 173 347, 348, 349, 350, 351, 352, 353, 354, 174 355, 356, 357, 358, 359, 360, 361, 362, 175 363, 364, 365, 366, 367, 368, 369, 370, 176 371, 372, 373, 374, 375, 376, 377, 378 177 }; 178 179 #endif /* 1 */ 180 181 182 FT_LOCAL_DEF( FT_UShort ) 183 cff_get_standard_encoding( FT_UInt charcode ) 184 { 185 return (FT_UShort)( charcode < 256 ? cff_standard_encoding[charcode] 186 : 0 ); 187 } 188 189 190 /*************************************************************************/ 191 /* */ 192 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ 193 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ 194 /* messages during execution. */ 195 /* */ 196 #undef FT_COMPONENT 197 #define FT_COMPONENT trace_cffload 198 199 200 /* read an offset from the index's stream current position */ 201 static FT_ULong 202 cff_index_read_offset( CFF_Index idx, 203 FT_Error *errorp ) 204 { 205 FT_Error error; 206 FT_Stream stream = idx->stream; 207 FT_Byte tmp[4]; 208 FT_ULong result = 0; 209 210 211 if ( !FT_STREAM_READ( tmp, idx->off_size ) ) 212 { 213 FT_Int nn; 214 215 216 for ( nn = 0; nn < idx->off_size; nn++ ) 217 result = ( result << 8 ) | tmp[nn]; 218 } 219 220 *errorp = error; 221 return result; 222 } 223 224 225 static FT_Error 226 cff_index_init( CFF_Index idx, 227 FT_Stream stream, 228 FT_Bool load ) 229 { 230 FT_Error error; 231 FT_Memory memory = stream->memory; 232 FT_UShort count; 233 234 235 FT_MEM_ZERO( idx, sizeof ( *idx ) ); 236 237 idx->stream = stream; 238 idx->start = FT_STREAM_POS(); 239 if ( !FT_READ_USHORT( count ) && 240 count > 0 ) 241 { 242 FT_Byte offsize; 243 FT_ULong size; 244 245 246 /* there is at least one element; read the offset size, */ 247 /* then access the offset table to compute the index's total size */ 248 if ( FT_READ_BYTE( offsize ) ) 249 goto Exit; 250 251 if ( offsize < 1 || offsize > 4 ) 252 { 253 error = FT_THROW( Invalid_Table ); 254 goto Exit; 255 } 256 257 idx->count = count; 258 idx->off_size = offsize; 259 size = (FT_ULong)( count + 1 ) * offsize; 260 261 idx->data_offset = idx->start + 3 + size; 262 263 if ( FT_STREAM_SKIP( size - offsize ) ) 264 goto Exit; 265 266 size = cff_index_read_offset( idx, &error ); 267 if ( error ) 268 goto Exit; 269 270 if ( size == 0 ) 271 { 272 error = FT_THROW( Invalid_Table ); 273 goto Exit; 274 } 275 276 idx->data_size = --size; 277 278 if ( load ) 279 { 280 /* load the data */ 281 if ( FT_FRAME_EXTRACT( size, idx->bytes ) ) 282 goto Exit; 283 } 284 else 285 { 286 /* skip the data */ 287 if ( FT_STREAM_SKIP( size ) ) 288 goto Exit; 289 } 290 } 291 292 Exit: 293 if ( error ) 294 FT_FREE( idx->offsets ); 295 296 return error; 297 } 298 299 300 static void 301 cff_index_done( CFF_Index idx ) 302 { 303 if ( idx->stream ) 304 { 305 FT_Stream stream = idx->stream; 306 FT_Memory memory = stream->memory; 307 308 309 if ( idx->bytes ) 310 FT_FRAME_RELEASE( idx->bytes ); 311 312 FT_FREE( idx->offsets ); 313 FT_MEM_ZERO( idx, sizeof ( *idx ) ); 314 } 315 } 316 317 318 static FT_Error 319 cff_index_load_offsets( CFF_Index idx ) 320 { 321 FT_Error error = FT_Err_Ok; 322 FT_Stream stream = idx->stream; 323 FT_Memory memory = stream->memory; 324 325 326 if ( idx->count > 0 && idx->offsets == NULL ) 327 { 328 FT_Byte offsize = idx->off_size; 329 FT_ULong data_size; 330 FT_Byte* p; 331 FT_Byte* p_end; 332 FT_ULong* poff; 333 334 335 data_size = (FT_ULong)( idx->count + 1 ) * offsize; 336 337 if ( FT_NEW_ARRAY( idx->offsets, idx->count + 1 ) || 338 FT_STREAM_SEEK( idx->start + 3 ) || 339 FT_FRAME_ENTER( data_size ) ) 340 goto Exit; 341 342 poff = idx->offsets; 343 p = (FT_Byte*)stream->cursor; 344 p_end = p + data_size; 345 346 switch ( offsize ) 347 { 348 case 1: 349 for ( ; p < p_end; p++, poff++ ) 350 poff[0] = p[0]; 351 break; 352 353 case 2: 354 for ( ; p < p_end; p += 2, poff++ ) 355 poff[0] = FT_PEEK_USHORT( p ); 356 break; 357 358 case 3: 359 for ( ; p < p_end; p += 3, poff++ ) 360 poff[0] = FT_PEEK_OFF3( p ); 361 break; 362 363 default: 364 for ( ; p < p_end; p += 4, poff++ ) 365 poff[0] = FT_PEEK_ULONG( p ); 366 } 367 368 FT_FRAME_EXIT(); 369 } 370 371 Exit: 372 if ( error ) 373 FT_FREE( idx->offsets ); 374 375 return error; 376 } 377 378 379 /* Allocate a table containing pointers to an index's elements. */ 380 /* The `pool' argument makes this function convert the index */ 381 /* entries to C-style strings (this is, NULL-terminated). */ 382 static FT_Error 383 cff_index_get_pointers( CFF_Index idx, 384 FT_Byte*** table, 385 FT_Byte** pool ) 386 { 387 FT_Error error = FT_Err_Ok; 388 FT_Memory memory = idx->stream->memory; 389 390 FT_Byte** t = NULL; 391 FT_Byte* new_bytes = NULL; 392 393 394 *table = NULL; 395 396 if ( idx->offsets == NULL ) 397 { 398 error = cff_index_load_offsets( idx ); 399 if ( error ) 400 goto Exit; 401 } 402 403 if ( idx->count > 0 && 404 !FT_NEW_ARRAY( t, idx->count + 1 ) && 405 ( !pool || !FT_ALLOC( new_bytes, 406 idx->data_size + idx->count ) ) ) 407 { 408 FT_ULong n, cur_offset; 409 FT_ULong extra = 0; 410 FT_Byte* org_bytes = idx->bytes; 411 412 413 /* at this point, `idx->offsets' can't be NULL */ 414 cur_offset = idx->offsets[0] - 1; 415 416 /* sanity check */ 417 if ( cur_offset >= idx->data_size ) 418 { 419 FT_TRACE0(( "cff_index_get_pointers:" 420 " invalid first offset value %d set to zero\n", 421 cur_offset )); 422 cur_offset = 0; 423 } 424 425 if ( !pool ) 426 t[0] = org_bytes + cur_offset; 427 else 428 t[0] = new_bytes + cur_offset; 429 430 for ( n = 1; n <= idx->count; n++ ) 431 { 432 FT_ULong next_offset = idx->offsets[n] - 1; 433 434 435 /* empty slot + two sanity checks for invalid offset tables */ 436 if ( next_offset == 0 || 437 next_offset < cur_offset || 438 ( next_offset >= idx->data_size && n < idx->count ) ) 439 next_offset = cur_offset; 440 441 if ( !pool ) 442 t[n] = org_bytes + next_offset; 443 else 444 { 445 t[n] = new_bytes + next_offset + extra; 446 447 if ( next_offset != cur_offset ) 448 { 449 FT_MEM_COPY( t[n - 1], org_bytes + cur_offset, t[n] - t[n - 1] ); 450 t[n][0] = '\0'; 451 t[n] += 1; 452 extra++; 453 } 454 } 455 456 cur_offset = next_offset; 457 } 458 *table = t; 459 460 if ( pool ) 461 *pool = new_bytes; 462 } 463 464 Exit: 465 return error; 466 } 467 468 469 FT_LOCAL_DEF( FT_Error ) 470 cff_index_access_element( CFF_Index idx, 471 FT_UInt element, 472 FT_Byte** pbytes, 473 FT_ULong* pbyte_len ) 474 { 475 FT_Error error = FT_Err_Ok; 476 477 478 if ( idx && idx->count > element ) 479 { 480 /* compute start and end offsets */ 481 FT_Stream stream = idx->stream; 482 FT_ULong off1, off2 = 0; 483 484 485 /* load offsets from file or the offset table */ 486 if ( !idx->offsets ) 487 { 488 FT_ULong pos = element * idx->off_size; 489 490 491 if ( FT_STREAM_SEEK( idx->start + 3 + pos ) ) 492 goto Exit; 493 494 off1 = cff_index_read_offset( idx, &error ); 495 if ( error ) 496 goto Exit; 497 498 if ( off1 != 0 ) 499 { 500 do 501 { 502 element++; 503 off2 = cff_index_read_offset( idx, &error ); 504 } 505 while ( off2 == 0 && element < idx->count ); 506 } 507 } 508 else /* use offsets table */ 509 { 510 off1 = idx->offsets[element]; 511 if ( off1 ) 512 { 513 do 514 { 515 element++; 516 off2 = idx->offsets[element]; 517 518 } while ( off2 == 0 && element < idx->count ); 519 } 520 } 521 522 /* XXX: should check off2 does not exceed the end of this entry; */ 523 /* at present, only truncate off2 at the end of this stream */ 524 if ( off2 > stream->size + 1 || 525 idx->data_offset > stream->size - off2 + 1 ) 526 { 527 FT_ERROR(( "cff_index_access_element:" 528 " offset to next entry (%d)" 529 " exceeds the end of stream (%d)\n", 530 off2, stream->size - idx->data_offset + 1 )); 531 off2 = stream->size - idx->data_offset + 1; 532 } 533 534 /* access element */ 535 if ( off1 && off2 > off1 ) 536 { 537 *pbyte_len = off2 - off1; 538 539 if ( idx->bytes ) 540 { 541 /* this index was completely loaded in memory, that's easy */ 542 *pbytes = idx->bytes + off1 - 1; 543 } 544 else 545 { 546 /* this index is still on disk/file, access it through a frame */ 547 if ( FT_STREAM_SEEK( idx->data_offset + off1 - 1 ) || 548 FT_FRAME_EXTRACT( off2 - off1, *pbytes ) ) 549 goto Exit; 550 } 551 } 552 else 553 { 554 /* empty index element */ 555 *pbytes = 0; 556 *pbyte_len = 0; 557 } 558 } 559 else 560 error = FT_THROW( Invalid_Argument ); 561 562 Exit: 563 return error; 564 } 565 566 567 FT_LOCAL_DEF( void ) 568 cff_index_forget_element( CFF_Index idx, 569 FT_Byte** pbytes ) 570 { 571 if ( idx->bytes == 0 ) 572 { 573 FT_Stream stream = idx->stream; 574 575 576 FT_FRAME_RELEASE( *pbytes ); 577 } 578 } 579 580 581 /* get an entry from Name INDEX */ 582 FT_LOCAL_DEF( FT_String* ) 583 cff_index_get_name( CFF_Font font, 584 FT_UInt element ) 585 { 586 CFF_Index idx = &font->name_index; 587 FT_Memory memory = idx->stream->memory; 588 FT_Byte* bytes; 589 FT_ULong byte_len; 590 FT_Error error; 591 FT_String* name = 0; 592 593 594 error = cff_index_access_element( idx, element, &bytes, &byte_len ); 595 if ( error ) 596 goto Exit; 597 598 if ( !FT_ALLOC( name, byte_len + 1 ) ) 599 { 600 FT_MEM_COPY( name, bytes, byte_len ); 601 name[byte_len] = 0; 602 } 603 cff_index_forget_element( idx, &bytes ); 604 605 Exit: 606 return name; 607 } 608 609 610 /* get an entry from String INDEX */ 611 FT_LOCAL_DEF( FT_String* ) 612 cff_index_get_string( CFF_Font font, 613 FT_UInt element ) 614 { 615 return ( element < font->num_strings ) 616 ? (FT_String*)font->strings[element] 617 : NULL; 618 } 619 620 621 FT_LOCAL_DEF( FT_String* ) 622 cff_index_get_sid_string( CFF_Font font, 623 FT_UInt sid ) 624 { 625 /* value 0xFFFFU indicates a missing dictionary entry */ 626 if ( sid == 0xFFFFU ) 627 return NULL; 628 629 /* if it is not a standard string, return it */ 630 if ( sid > 390 ) 631 return cff_index_get_string( font, sid - 391 ); 632 633 /* CID-keyed CFF fonts don't have glyph names */ 634 if ( !font->psnames ) 635 return NULL; 636 637 /* this is a standard string */ 638 return (FT_String *)font->psnames->adobe_std_strings( sid ); 639 } 640 641 642 /*************************************************************************/ 643 /*************************************************************************/ 644 /*** ***/ 645 /*** FD Select table support ***/ 646 /*** ***/ 647 /*************************************************************************/ 648 /*************************************************************************/ 649 650 651 static void 652 CFF_Done_FD_Select( CFF_FDSelect fdselect, 653 FT_Stream stream ) 654 { 655 if ( fdselect->data ) 656 FT_FRAME_RELEASE( fdselect->data ); 657 658 fdselect->data_size = 0; 659 fdselect->format = 0; 660 fdselect->range_count = 0; 661 } 662 663 664 static FT_Error 665 CFF_Load_FD_Select( CFF_FDSelect fdselect, 666 FT_UInt num_glyphs, 667 FT_Stream stream, 668 FT_ULong offset ) 669 { 670 FT_Error error; 671 FT_Byte format; 672 FT_UInt num_ranges; 673 674 675 /* read format */ 676 if ( FT_STREAM_SEEK( offset ) || FT_READ_BYTE( format ) ) 677 goto Exit; 678 679 fdselect->format = format; 680 fdselect->cache_count = 0; /* clear cache */ 681 682 switch ( format ) 683 { 684 case 0: /* format 0, that's simple */ 685 fdselect->data_size = num_glyphs; 686 goto Load_Data; 687 688 case 3: /* format 3, a tad more complex */ 689 if ( FT_READ_USHORT( num_ranges ) ) 690 goto Exit; 691 692 fdselect->data_size = num_ranges * 3 + 2; 693 694 Load_Data: 695 if ( FT_FRAME_EXTRACT( fdselect->data_size, fdselect->data ) ) 696 goto Exit; 697 break; 698 699 default: /* hmm... that's wrong */ 700 error = FT_THROW( Invalid_File_Format ); 701 } 702 703 Exit: 704 return error; 705 } 706 707 708 FT_LOCAL_DEF( FT_Byte ) 709 cff_fd_select_get( CFF_FDSelect fdselect, 710 FT_UInt glyph_index ) 711 { 712 FT_Byte fd = 0; 713 714 715 switch ( fdselect->format ) 716 { 717 case 0: 718 fd = fdselect->data[glyph_index]; 719 break; 720 721 case 3: 722 /* first, compare to cache */ 723 if ( (FT_UInt)( glyph_index - fdselect->cache_first ) < 724 fdselect->cache_count ) 725 { 726 fd = fdselect->cache_fd; 727 break; 728 } 729 730 /* then, lookup the ranges array */ 731 { 732 FT_Byte* p = fdselect->data; 733 FT_Byte* p_limit = p + fdselect->data_size; 734 FT_Byte fd2; 735 FT_UInt first, limit; 736 737 738 first = FT_NEXT_USHORT( p ); 739 do 740 { 741 if ( glyph_index < first ) 742 break; 743 744 fd2 = *p++; 745 limit = FT_NEXT_USHORT( p ); 746 747 if ( glyph_index < limit ) 748 { 749 fd = fd2; 750 751 /* update cache */ 752 fdselect->cache_first = first; 753 fdselect->cache_count = limit-first; 754 fdselect->cache_fd = fd2; 755 break; 756 } 757 first = limit; 758 759 } while ( p < p_limit ); 760 } 761 break; 762 763 default: 764 ; 765 } 766 767 return fd; 768 } 769 770 771 /*************************************************************************/ 772 /*************************************************************************/ 773 /*** ***/ 774 /*** CFF font support ***/ 775 /*** ***/ 776 /*************************************************************************/ 777 /*************************************************************************/ 778 779 static FT_Error 780 cff_charset_compute_cids( CFF_Charset charset, 781 FT_UInt num_glyphs, 782 FT_Memory memory ) 783 { 784 FT_Error error = FT_Err_Ok; 785 FT_UInt i; 786 FT_Long j; 787 FT_UShort max_cid = 0; 788 789 790 if ( charset->max_cid > 0 ) 791 goto Exit; 792 793 for ( i = 0; i < num_glyphs; i++ ) 794 { 795 if ( charset->sids[i] > max_cid ) 796 max_cid = charset->sids[i]; 797 } 798 799 if ( FT_NEW_ARRAY( charset->cids, (FT_ULong)max_cid + 1 ) ) 800 goto Exit; 801 802 /* When multiple GIDs map to the same CID, we choose the lowest */ 803 /* GID. This is not described in any spec, but it matches the */ 804 /* behaviour of recent Acroread versions. */ 805 for ( j = num_glyphs - 1; j >= 0 ; j-- ) 806 charset->cids[charset->sids[j]] = (FT_UShort)j; 807 808 charset->max_cid = max_cid; 809 charset->num_glyphs = num_glyphs; 810 811 Exit: 812 return error; 813 } 814 815 816 FT_LOCAL_DEF( FT_UInt ) 817 cff_charset_cid_to_gindex( CFF_Charset charset, 818 FT_UInt cid ) 819 { 820 FT_UInt result = 0; 821 822 823 if ( cid <= charset->max_cid ) 824 result = charset->cids[cid]; 825 826 return result; 827 } 828 829 830 static void 831 cff_charset_free_cids( CFF_Charset charset, 832 FT_Memory memory ) 833 { 834 FT_FREE( charset->cids ); 835 charset->max_cid = 0; 836 } 837 838 839 static void 840 cff_charset_done( CFF_Charset charset, 841 FT_Stream stream ) 842 { 843 FT_Memory memory = stream->memory; 844 845 846 cff_charset_free_cids( charset, memory ); 847 848 FT_FREE( charset->sids ); 849 charset->format = 0; 850 charset->offset = 0; 851 } 852 853 854 static FT_Error 855 cff_charset_load( CFF_Charset charset, 856 FT_UInt num_glyphs, 857 FT_Stream stream, 858 FT_ULong base_offset, 859 FT_ULong offset, 860 FT_Bool invert ) 861 { 862 FT_Memory memory = stream->memory; 863 FT_Error error = FT_Err_Ok; 864 FT_UShort glyph_sid; 865 866 867 /* If the the offset is greater than 2, we have to parse the */ 868 /* charset table. */ 869 if ( offset > 2 ) 870 { 871 FT_UInt j; 872 873 874 charset->offset = base_offset + offset; 875 876 /* Get the format of the table. */ 877 if ( FT_STREAM_SEEK( charset->offset ) || 878 FT_READ_BYTE( charset->format ) ) 879 goto Exit; 880 881 /* Allocate memory for sids. */ 882 if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) ) 883 goto Exit; 884 885 /* assign the .notdef glyph */ 886 charset->sids[0] = 0; 887 888 switch ( charset->format ) 889 { 890 case 0: 891 if ( num_glyphs > 0 ) 892 { 893 if ( FT_FRAME_ENTER( ( num_glyphs - 1 ) * 2 ) ) 894 goto Exit; 895 896 for ( j = 1; j < num_glyphs; j++ ) 897 charset->sids[j] = FT_GET_USHORT(); 898 899 FT_FRAME_EXIT(); 900 } 901 break; 902 903 case 1: 904 case 2: 905 { 906 FT_UInt nleft; 907 FT_UInt i; 908 909 910 j = 1; 911 912 while ( j < num_glyphs ) 913 { 914 /* Read the first glyph sid of the range. */ 915 if ( FT_READ_USHORT( glyph_sid ) ) 916 goto Exit; 917 918 /* Read the number of glyphs in the range. */ 919 if ( charset->format == 2 ) 920 { 921 if ( FT_READ_USHORT( nleft ) ) 922 goto Exit; 923 } 924 else 925 { 926 if ( FT_READ_BYTE( nleft ) ) 927 goto Exit; 928 } 929 930 /* try to rescue some of the SIDs if `nleft' is too large */ 931 if ( glyph_sid > 0xFFFFL - nleft ) 932 { 933 FT_ERROR(( "cff_charset_load: invalid SID range trimmed" 934 " nleft=%d -> %d\n", nleft, 0xFFFFL - glyph_sid )); 935 nleft = ( FT_UInt )( 0xFFFFL - glyph_sid ); 936 } 937 938 /* Fill in the range of sids -- `nleft + 1' glyphs. */ 939 for ( i = 0; j < num_glyphs && i <= nleft; i++, j++, glyph_sid++ ) 940 charset->sids[j] = glyph_sid; 941 } 942 } 943 break; 944 945 default: 946 FT_ERROR(( "cff_charset_load: invalid table format\n" )); 947 error = FT_THROW( Invalid_File_Format ); 948 goto Exit; 949 } 950 } 951 else 952 { 953 /* Parse default tables corresponding to offset == 0, 1, or 2. */ 954 /* CFF specification intimates the following: */ 955 /* */ 956 /* In order to use a predefined charset, the following must be */ 957 /* true: The charset constructed for the glyphs in the font's */ 958 /* charstrings dictionary must match the predefined charset in */ 959 /* the first num_glyphs. */ 960 961 charset->offset = offset; /* record charset type */ 962 963 switch ( (FT_UInt)offset ) 964 { 965 case 0: 966 if ( num_glyphs > 229 ) 967 { 968 FT_ERROR(( "cff_charset_load: implicit charset larger than\n" 969 "predefined charset (Adobe ISO-Latin)\n" )); 970 error = FT_THROW( Invalid_File_Format ); 971 goto Exit; 972 } 973 974 /* Allocate memory for sids. */ 975 if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) ) 976 goto Exit; 977 978 /* Copy the predefined charset into the allocated memory. */ 979 FT_ARRAY_COPY( charset->sids, cff_isoadobe_charset, num_glyphs ); 980 981 break; 982 983 case 1: 984 if ( num_glyphs > 166 ) 985 { 986 FT_ERROR(( "cff_charset_load: implicit charset larger than\n" 987 "predefined charset (Adobe Expert)\n" )); 988 error = FT_THROW( Invalid_File_Format ); 989 goto Exit; 990 } 991 992 /* Allocate memory for sids. */ 993 if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) ) 994 goto Exit; 995 996 /* Copy the predefined charset into the allocated memory. */ 997 FT_ARRAY_COPY( charset->sids, cff_expert_charset, num_glyphs ); 998 999 break; 1000 1001 case 2: 1002 if ( num_glyphs > 87 ) 1003 { 1004 FT_ERROR(( "cff_charset_load: implicit charset larger than\n" 1005 "predefined charset (Adobe Expert Subset)\n" )); 1006 error = FT_THROW( Invalid_File_Format ); 1007 goto Exit; 1008 } 1009 1010 /* Allocate memory for sids. */ 1011 if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) ) 1012 goto Exit; 1013 1014 /* Copy the predefined charset into the allocated memory. */ 1015 FT_ARRAY_COPY( charset->sids, cff_expertsubset_charset, num_glyphs ); 1016 1017 break; 1018 1019 default: 1020 error = FT_THROW( Invalid_File_Format ); 1021 goto Exit; 1022 } 1023 } 1024 1025 /* we have to invert the `sids' array for subsetted CID-keyed fonts */ 1026 if ( invert ) 1027 error = cff_charset_compute_cids( charset, num_glyphs, memory ); 1028 1029 Exit: 1030 /* Clean up if there was an error. */ 1031 if ( error ) 1032 { 1033 FT_FREE( charset->sids ); 1034 FT_FREE( charset->cids ); 1035 charset->format = 0; 1036 charset->offset = 0; 1037 charset->sids = 0; 1038 } 1039 1040 return error; 1041 } 1042 1043 1044 static void 1045 cff_encoding_done( CFF_Encoding encoding ) 1046 { 1047 encoding->format = 0; 1048 encoding->offset = 0; 1049 encoding->count = 0; 1050 } 1051 1052 1053 static FT_Error 1054 cff_encoding_load( CFF_Encoding encoding, 1055 CFF_Charset charset, 1056 FT_UInt num_glyphs, 1057 FT_Stream stream, 1058 FT_ULong base_offset, 1059 FT_ULong offset ) 1060 { 1061 FT_Error error = FT_Err_Ok; 1062 FT_UInt count; 1063 FT_UInt j; 1064 FT_UShort glyph_sid; 1065 FT_UInt glyph_code; 1066 1067 1068 /* Check for charset->sids. If we do not have this, we fail. */ 1069 if ( !charset->sids ) 1070 { 1071 error = FT_THROW( Invalid_File_Format ); 1072 goto Exit; 1073 } 1074 1075 /* Zero out the code to gid/sid mappings. */ 1076 for ( j = 0; j < 256; j++ ) 1077 { 1078 encoding->sids [j] = 0; 1079 encoding->codes[j] = 0; 1080 } 1081 1082 /* Note: The encoding table in a CFF font is indexed by glyph index; */ 1083 /* the first encoded glyph index is 1. Hence, we read the character */ 1084 /* code (`glyph_code') at index j and make the assignment: */ 1085 /* */ 1086 /* encoding->codes[glyph_code] = j + 1 */ 1087 /* */ 1088 /* We also make the assignment: */ 1089 /* */ 1090 /* encoding->sids[glyph_code] = charset->sids[j + 1] */ 1091 /* */ 1092 /* This gives us both a code to GID and a code to SID mapping. */ 1093 1094 if ( offset > 1 ) 1095 { 1096 encoding->offset = base_offset + offset; 1097 1098 /* we need to parse the table to determine its size */ 1099 if ( FT_STREAM_SEEK( encoding->offset ) || 1100 FT_READ_BYTE( encoding->format ) || 1101 FT_READ_BYTE( count ) ) 1102 goto Exit; 1103 1104 switch ( encoding->format & 0x7F ) 1105 { 1106 case 0: 1107 { 1108 FT_Byte* p; 1109 1110 1111 /* By convention, GID 0 is always ".notdef" and is never */ 1112 /* coded in the font. Hence, the number of codes found */ 1113 /* in the table is `count+1'. */ 1114 /* */ 1115 encoding->count = count + 1; 1116 1117 if ( FT_FRAME_ENTER( count ) ) 1118 goto Exit; 1119 1120 p = (FT_Byte*)stream->cursor; 1121 1122 for ( j = 1; j <= count; j++ ) 1123 { 1124 glyph_code = *p++; 1125 1126 /* Make sure j is not too big. */ 1127 if ( j < num_glyphs ) 1128 { 1129 /* Assign code to GID mapping. */ 1130 encoding->codes[glyph_code] = (FT_UShort)j; 1131 1132 /* Assign code to SID mapping. */ 1133 encoding->sids[glyph_code] = charset->sids[j]; 1134 } 1135 } 1136 1137 FT_FRAME_EXIT(); 1138 } 1139 break; 1140 1141 case 1: 1142 { 1143 FT_UInt nleft; 1144 FT_UInt i = 1; 1145 FT_UInt k; 1146 1147 1148 encoding->count = 0; 1149 1150 /* Parse the Format1 ranges. */ 1151 for ( j = 0; j < count; j++, i += nleft ) 1152 { 1153 /* Read the first glyph code of the range. */ 1154 if ( FT_READ_BYTE( glyph_code ) ) 1155 goto Exit; 1156 1157 /* Read the number of codes in the range. */ 1158 if ( FT_READ_BYTE( nleft ) ) 1159 goto Exit; 1160 1161 /* Increment nleft, so we read `nleft + 1' codes/sids. */ 1162 nleft++; 1163 1164 /* compute max number of character codes */ 1165 if ( (FT_UInt)nleft > encoding->count ) 1166 encoding->count = nleft; 1167 1168 /* Fill in the range of codes/sids. */ 1169 for ( k = i; k < nleft + i; k++, glyph_code++ ) 1170 { 1171 /* Make sure k is not too big. */ 1172 if ( k < num_glyphs && glyph_code < 256 ) 1173 { 1174 /* Assign code to GID mapping. */ 1175 encoding->codes[glyph_code] = (FT_UShort)k; 1176 1177 /* Assign code to SID mapping. */ 1178 encoding->sids[glyph_code] = charset->sids[k]; 1179 } 1180 } 1181 } 1182 1183 /* simple check; one never knows what can be found in a font */ 1184 if ( encoding->count > 256 ) 1185 encoding->count = 256; 1186 } 1187 break; 1188 1189 default: 1190 FT_ERROR(( "cff_encoding_load: invalid table format\n" )); 1191 error = FT_THROW( Invalid_File_Format ); 1192 goto Exit; 1193 } 1194 1195 /* Parse supplemental encodings, if any. */ 1196 if ( encoding->format & 0x80 ) 1197 { 1198 FT_UInt gindex; 1199 1200 1201 /* count supplements */ 1202 if ( FT_READ_BYTE( count ) ) 1203 goto Exit; 1204 1205 for ( j = 0; j < count; j++ ) 1206 { 1207 /* Read supplemental glyph code. */ 1208 if ( FT_READ_BYTE( glyph_code ) ) 1209 goto Exit; 1210 1211 /* Read the SID associated with this glyph code. */ 1212 if ( FT_READ_USHORT( glyph_sid ) ) 1213 goto Exit; 1214 1215 /* Assign code to SID mapping. */ 1216 encoding->sids[glyph_code] = glyph_sid; 1217 1218 /* First, look up GID which has been assigned to */ 1219 /* SID glyph_sid. */ 1220 for ( gindex = 0; gindex < num_glyphs; gindex++ ) 1221 { 1222 if ( charset->sids[gindex] == glyph_sid ) 1223 { 1224 encoding->codes[glyph_code] = (FT_UShort)gindex; 1225 break; 1226 } 1227 } 1228 } 1229 } 1230 } 1231 else 1232 { 1233 /* We take into account the fact a CFF font can use a predefined */ 1234 /* encoding without containing all of the glyphs encoded by this */ 1235 /* encoding (see the note at the end of section 12 in the CFF */ 1236 /* specification). */ 1237 1238 switch ( (FT_UInt)offset ) 1239 { 1240 case 0: 1241 /* First, copy the code to SID mapping. */ 1242 FT_ARRAY_COPY( encoding->sids, cff_standard_encoding, 256 ); 1243 goto Populate; 1244 1245 case 1: 1246 /* First, copy the code to SID mapping. */ 1247 FT_ARRAY_COPY( encoding->sids, cff_expert_encoding, 256 ); 1248 1249 Populate: 1250 /* Construct code to GID mapping from code to SID mapping */ 1251 /* and charset. */ 1252 1253 encoding->count = 0; 1254 1255 error = cff_charset_compute_cids( charset, num_glyphs, 1256 stream->memory ); 1257 if ( error ) 1258 goto Exit; 1259 1260 for ( j = 0; j < 256; j++ ) 1261 { 1262 FT_UInt sid = encoding->sids[j]; 1263 FT_UInt gid = 0; 1264 1265 1266 if ( sid ) 1267 gid = cff_charset_cid_to_gindex( charset, sid ); 1268 1269 if ( gid != 0 ) 1270 { 1271 encoding->codes[j] = (FT_UShort)gid; 1272 encoding->count = j + 1; 1273 } 1274 else 1275 { 1276 encoding->codes[j] = 0; 1277 encoding->sids [j] = 0; 1278 } 1279 } 1280 break; 1281 1282 default: 1283 FT_ERROR(( "cff_encoding_load: invalid table format\n" )); 1284 error = FT_THROW( Invalid_File_Format ); 1285 goto Exit; 1286 } 1287 } 1288 1289 Exit: 1290 1291 /* Clean up if there was an error. */ 1292 return error; 1293 } 1294 1295 1296 static FT_Error 1297 cff_subfont_load( CFF_SubFont font, 1298 CFF_Index idx, 1299 FT_UInt font_index, 1300 FT_Stream stream, 1301 FT_ULong base_offset, 1302 FT_Library library ) 1303 { 1304 FT_Error error; 1305 CFF_ParserRec parser; 1306 FT_Byte* dict = NULL; 1307 FT_ULong dict_len; 1308 CFF_FontRecDict top = &font->font_dict; 1309 CFF_Private priv = &font->private_dict; 1310 1311 1312 cff_parser_init( &parser, CFF_CODE_TOPDICT, &font->font_dict, library ); 1313 1314 /* set defaults */ 1315 FT_MEM_ZERO( top, sizeof ( *top ) ); 1316 1317 top->underline_position = -( 100L << 16 ); 1318 top->underline_thickness = 50L << 16; 1319 top->charstring_type = 2; 1320 top->font_matrix.xx = 0x10000L; 1321 top->font_matrix.yy = 0x10000L; 1322 top->cid_count = 8720; 1323 1324 /* we use the implementation specific SID value 0xFFFF to indicate */ 1325 /* missing entries */ 1326 top->version = 0xFFFFU; 1327 top->notice = 0xFFFFU; 1328 top->copyright = 0xFFFFU; 1329 top->full_name = 0xFFFFU; 1330 top->family_name = 0xFFFFU; 1331 top->weight = 0xFFFFU; 1332 top->embedded_postscript = 0xFFFFU; 1333 1334 top->cid_registry = 0xFFFFU; 1335 top->cid_ordering = 0xFFFFU; 1336 top->cid_font_name = 0xFFFFU; 1337 1338 error = cff_index_access_element( idx, font_index, &dict, &dict_len ); 1339 if ( !error ) 1340 { 1341 FT_TRACE4(( " top dictionary:\n" )); 1342 error = cff_parser_run( &parser, dict, dict + dict_len ); 1343 } 1344 1345 cff_index_forget_element( idx, &dict ); 1346 1347 if ( error ) 1348 goto Exit; 1349 1350 /* if it is a CID font, we stop there */ 1351 if ( top->cid_registry != 0xFFFFU ) 1352 goto Exit; 1353 1354 /* parse the private dictionary, if any */ 1355 if ( top->private_offset && top->private_size ) 1356 { 1357 /* set defaults */ 1358 FT_MEM_ZERO( priv, sizeof ( *priv ) ); 1359 1360 priv->blue_shift = 7; 1361 priv->blue_fuzz = 1; 1362 priv->lenIV = -1; 1363 priv->expansion_factor = (FT_Fixed)( 0.06 * 0x10000L ); 1364 priv->blue_scale = (FT_Fixed)( 0.039625 * 0x10000L * 1000 ); 1365 1366 cff_parser_init( &parser, CFF_CODE_PRIVATE, priv, library ); 1367 1368 if ( FT_STREAM_SEEK( base_offset + font->font_dict.private_offset ) || 1369 FT_FRAME_ENTER( font->font_dict.private_size ) ) 1370 goto Exit; 1371 1372 FT_TRACE4(( " private dictionary:\n" )); 1373 error = cff_parser_run( &parser, 1374 (FT_Byte*)stream->cursor, 1375 (FT_Byte*)stream->limit ); 1376 FT_FRAME_EXIT(); 1377 if ( error ) 1378 goto Exit; 1379 1380 /* ensure that `num_blue_values' is even */ 1381 priv->num_blue_values &= ~1; 1382 } 1383 1384 /* read the local subrs, if any */ 1385 if ( priv->local_subrs_offset ) 1386 { 1387 if ( FT_STREAM_SEEK( base_offset + top->private_offset + 1388 priv->local_subrs_offset ) ) 1389 goto Exit; 1390 1391 error = cff_index_init( &font->local_subrs_index, stream, 1 ); 1392 if ( error ) 1393 goto Exit; 1394 1395 error = cff_index_get_pointers( &font->local_subrs_index, 1396 &font->local_subrs, NULL ); 1397 if ( error ) 1398 goto Exit; 1399 } 1400 1401 Exit: 1402 return error; 1403 } 1404 1405 1406 static void 1407 cff_subfont_done( FT_Memory memory, 1408 CFF_SubFont subfont ) 1409 { 1410 if ( subfont ) 1411 { 1412 cff_index_done( &subfont->local_subrs_index ); 1413 FT_FREE( subfont->local_subrs ); 1414 } 1415 } 1416 1417 1418 FT_LOCAL_DEF( FT_Error ) 1419 cff_font_load( FT_Library library, 1420 FT_Stream stream, 1421 FT_Int face_index, 1422 CFF_Font font, 1423 FT_Bool pure_cff ) 1424 { 1425 static const FT_Frame_Field cff_header_fields[] = 1426 { 1427 #undef FT_STRUCTURE 1428 #define FT_STRUCTURE CFF_FontRec 1429 1430 FT_FRAME_START( 4 ), 1431 FT_FRAME_BYTE( version_major ), 1432 FT_FRAME_BYTE( version_minor ), 1433 FT_FRAME_BYTE( header_size ), 1434 FT_FRAME_BYTE( absolute_offsize ), 1435 FT_FRAME_END 1436 }; 1437 1438 FT_Error error; 1439 FT_Memory memory = stream->memory; 1440 FT_ULong base_offset; 1441 CFF_FontRecDict dict; 1442 CFF_IndexRec string_index; 1443 FT_Int subfont_index; 1444 1445 1446 FT_ZERO( font ); 1447 FT_ZERO( &string_index ); 1448 1449 font->stream = stream; 1450 font->memory = memory; 1451 dict = &font->top_font.font_dict; 1452 base_offset = FT_STREAM_POS(); 1453 1454 /* read CFF font header */ 1455 if ( FT_STREAM_READ_FIELDS( cff_header_fields, font ) ) 1456 goto Exit; 1457 1458 /* check format */ 1459 if ( font->version_major != 1 || 1460 font->header_size < 4 || 1461 font->absolute_offsize > 4 ) 1462 { 1463 FT_TRACE2(( " not a CFF font header\n" )); 1464 error = FT_THROW( Unknown_File_Format ); 1465 goto Exit; 1466 } 1467 1468 /* skip the rest of the header */ 1469 if ( FT_STREAM_SKIP( font->header_size - 4 ) ) 1470 goto Exit; 1471 1472 /* read the name, top dict, string and global subrs index */ 1473 if ( FT_SET_ERROR( cff_index_init( &font->name_index, 1474 stream, 0 ) ) || 1475 FT_SET_ERROR( cff_index_init( &font->font_dict_index, 1476 stream, 0 ) ) || 1477 FT_SET_ERROR( cff_index_init( &string_index, 1478 stream, 1 ) ) || 1479 FT_SET_ERROR( cff_index_init( &font->global_subrs_index, 1480 stream, 1 ) ) || 1481 FT_SET_ERROR( cff_index_get_pointers( &string_index, 1482 &font->strings, 1483 &font->string_pool ) ) ) 1484 goto Exit; 1485 1486 font->num_strings = string_index.count; 1487 1488 if ( pure_cff ) 1489 { 1490 /* well, we don't really forget the `disabled' fonts... */ 1491 subfont_index = face_index; 1492 1493 if ( subfont_index >= (FT_Int)font->name_index.count ) 1494 { 1495 FT_ERROR(( "cff_font_load:" 1496 " invalid subfont index for pure CFF font (%d)\n", 1497 subfont_index )); 1498 error = FT_THROW( Invalid_Argument ); 1499 goto Exit; 1500 } 1501 1502 font->num_faces = font->name_index.count; 1503 } 1504 else 1505 { 1506 subfont_index = 0; 1507 1508 if ( font->name_index.count > 1 ) 1509 { 1510 FT_ERROR(( "cff_font_load:" 1511 " invalid CFF font with multiple subfonts\n" 1512 " " 1513 " in SFNT wrapper\n" )); 1514 error = FT_THROW( Invalid_File_Format ); 1515 goto Exit; 1516 } 1517 } 1518 1519 /* in case of a font format check, simply exit now */ 1520 if ( face_index < 0 ) 1521 goto Exit; 1522 1523 /* now, parse the top-level font dictionary */ 1524 FT_TRACE4(( "parsing top-level\n" )); 1525 error = cff_subfont_load( &font->top_font, 1526 &font->font_dict_index, 1527 subfont_index, 1528 stream, 1529 base_offset, 1530 library ); 1531 if ( error ) 1532 goto Exit; 1533 1534 if ( FT_STREAM_SEEK( base_offset + dict->charstrings_offset ) ) 1535 goto Exit; 1536 1537 error = cff_index_init( &font->charstrings_index, stream, 0 ); 1538 if ( error ) 1539 goto Exit; 1540 1541 /* now, check for a CID font */ 1542 if ( dict->cid_registry != 0xFFFFU ) 1543 { 1544 CFF_IndexRec fd_index; 1545 CFF_SubFont sub = NULL; 1546 FT_UInt idx; 1547 1548 1549 /* this is a CID-keyed font, we must now allocate a table of */ 1550 /* sub-fonts, then load each of them separately */ 1551 if ( FT_STREAM_SEEK( base_offset + dict->cid_fd_array_offset ) ) 1552 goto Exit; 1553 1554 error = cff_index_init( &fd_index, stream, 0 ); 1555 if ( error ) 1556 goto Exit; 1557 1558 if ( fd_index.count > CFF_MAX_CID_FONTS ) 1559 { 1560 FT_TRACE0(( "cff_font_load: FD array too large in CID font\n" )); 1561 goto Fail_CID; 1562 } 1563 1564 /* allocate & read each font dict independently */ 1565 font->num_subfonts = fd_index.count; 1566 if ( FT_NEW_ARRAY( sub, fd_index.count ) ) 1567 goto Fail_CID; 1568 1569 /* set up pointer table */ 1570 for ( idx = 0; idx < fd_index.count; idx++ ) 1571 font->subfonts[idx] = sub + idx; 1572 1573 /* now load each subfont independently */ 1574 for ( idx = 0; idx < fd_index.count; idx++ ) 1575 { 1576 sub = font->subfonts[idx]; 1577 FT_TRACE4(( "parsing subfont %u\n", idx )); 1578 error = cff_subfont_load( sub, &fd_index, idx, 1579 stream, base_offset, library ); 1580 if ( error ) 1581 goto Fail_CID; 1582 } 1583 1584 /* now load the FD Select array */ 1585 error = CFF_Load_FD_Select( &font->fd_select, 1586 font->charstrings_index.count, 1587 stream, 1588 base_offset + dict->cid_fd_select_offset ); 1589 1590 Fail_CID: 1591 cff_index_done( &fd_index ); 1592 1593 if ( error ) 1594 goto Exit; 1595 } 1596 else 1597 font->num_subfonts = 0; 1598 1599 /* read the charstrings index now */ 1600 if ( dict->charstrings_offset == 0 ) 1601 { 1602 FT_ERROR(( "cff_font_load: no charstrings offset\n" )); 1603 error = FT_THROW( Invalid_File_Format ); 1604 goto Exit; 1605 } 1606 1607 font->num_glyphs = font->charstrings_index.count; 1608 1609 error = cff_index_get_pointers( &font->global_subrs_index, 1610 &font->global_subrs, NULL ); 1611 1612 if ( error ) 1613 goto Exit; 1614 1615 /* read the Charset and Encoding tables if available */ 1616 if ( font->num_glyphs > 0 ) 1617 { 1618 FT_Bool invert = FT_BOOL( dict->cid_registry != 0xFFFFU && pure_cff ); 1619 1620 1621 error = cff_charset_load( &font->charset, font->num_glyphs, stream, 1622 base_offset, dict->charset_offset, invert ); 1623 if ( error ) 1624 goto Exit; 1625 1626 /* CID-keyed CFFs don't have an encoding */ 1627 if ( dict->cid_registry == 0xFFFFU ) 1628 { 1629 error = cff_encoding_load( &font->encoding, 1630 &font->charset, 1631 font->num_glyphs, 1632 stream, 1633 base_offset, 1634 dict->encoding_offset ); 1635 if ( error ) 1636 goto Exit; 1637 } 1638 } 1639 1640 /* get the font name (/CIDFontName for CID-keyed fonts, */ 1641 /* /FontName otherwise) */ 1642 font->font_name = cff_index_get_name( font, subfont_index ); 1643 1644 Exit: 1645 cff_index_done( &string_index ); 1646 1647 return error; 1648 } 1649 1650 1651 FT_LOCAL_DEF( void ) 1652 cff_font_done( CFF_Font font ) 1653 { 1654 FT_Memory memory = font->memory; 1655 FT_UInt idx; 1656 1657 1658 cff_index_done( &font->global_subrs_index ); 1659 cff_index_done( &font->font_dict_index ); 1660 cff_index_done( &font->name_index ); 1661 cff_index_done( &font->charstrings_index ); 1662 1663 /* release font dictionaries, but only if working with */ 1664 /* a CID keyed CFF font */ 1665 if ( font->num_subfonts > 0 ) 1666 { 1667 for ( idx = 0; idx < font->num_subfonts; idx++ ) 1668 cff_subfont_done( memory, font->subfonts[idx] ); 1669 1670 /* the subfonts array has been allocated as a single block */ 1671 FT_FREE( font->subfonts[0] ); 1672 } 1673 1674 cff_encoding_done( &font->encoding ); 1675 cff_charset_done( &font->charset, font->stream ); 1676 1677 cff_subfont_done( memory, &font->top_font ); 1678 1679 CFF_Done_FD_Select( &font->fd_select, font->stream ); 1680 1681 FT_FREE( font->font_info ); 1682 1683 FT_FREE( font->font_name ); 1684 FT_FREE( font->global_subrs ); 1685 FT_FREE( font->strings ); 1686 FT_FREE( font->string_pool ); 1687 1688 if ( font->cf2_instance.finalizer ) 1689 { 1690 font->cf2_instance.finalizer( font->cf2_instance.data ); 1691 FT_FREE( font->cf2_instance.data ); 1692 } 1693 } 1694 1695 1696 /* END */ 1697