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