1 /***************************************************************************/
5 /* OpenType and CFF data/program tables loader (body). */
7 /* Copyright 1996-2011 by */
8 /* David Turner, Robert Wilhelm, and Werner Lemberg. */
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. */
16 /***************************************************************************/
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
34 static const FT_UShort cff_isoadobe_charset[229] =
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
67 static const FT_UShort cff_expert_charset[166] =
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
92 static const FT_UShort cff_expertsubset_charset[87] =
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
107 static const FT_UShort cff_standard_encoding[256] =
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
143 static const FT_UShort cff_expert_encoding[256] =
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
182 FT_LOCAL_DEF( FT_UShort )
183 cff_get_standard_encoding( FT_UInt charcode )
185 return (FT_UShort)( charcode < 256 ? cff_standard_encoding[charcode]
190 /*************************************************************************/
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. */
197 #define FT_COMPONENT trace_cffload
200 /* read an offset from the index's stream current position */
202 cff_index_read_offset( CFF_Index idx,
206 FT_Stream stream = idx->stream;
211 if ( !FT_STREAM_READ( tmp, idx->off_size ) )
216 for ( nn = 0; nn < idx->off_size; nn++ )
217 result = ( result << 8 ) | tmp[nn];
226 cff_index_init( CFF_Index idx,
231 FT_Memory memory = stream->memory;
235 FT_MEM_ZERO( idx, sizeof ( *idx ) );
237 idx->stream = stream;
238 idx->start = FT_STREAM_POS();
239 if ( !FT_READ_USHORT( count ) &&
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 ) )
251 if ( offsize < 1 || offsize > 4 )
253 error = CFF_Err_Invalid_Table;
258 idx->off_size = offsize;
259 size = (FT_ULong)( count + 1 ) * offsize;
261 idx->data_offset = idx->start + 3 + size;
263 if ( FT_STREAM_SKIP( size - offsize ) )
266 size = cff_index_read_offset( idx, &error );
272 error = CFF_Err_Invalid_Table;
276 idx->data_size = --size;
281 if ( FT_FRAME_EXTRACT( size, idx->bytes ) )
287 if ( FT_STREAM_SKIP( size ) )
294 FT_FREE( idx->offsets );
301 cff_index_done( CFF_Index idx )
305 FT_Stream stream = idx->stream;
306 FT_Memory memory = stream->memory;
310 FT_FRAME_RELEASE( idx->bytes );
312 FT_FREE( idx->offsets );
313 FT_MEM_ZERO( idx, sizeof ( *idx ) );
319 cff_index_load_offsets( CFF_Index idx )
321 FT_Error error = CFF_Err_Ok;
322 FT_Stream stream = idx->stream;
323 FT_Memory memory = stream->memory;
326 if ( idx->count > 0 && idx->offsets == NULL )
328 FT_Byte offsize = idx->off_size;
335 data_size = (FT_ULong)( idx->count + 1 ) * offsize;
337 if ( FT_NEW_ARRAY( idx->offsets, idx->count + 1 ) ||
338 FT_STREAM_SEEK( idx->start + 3 ) ||
339 FT_FRAME_ENTER( data_size ) )
343 p = (FT_Byte*)stream->cursor;
344 p_end = p + data_size;
349 for ( ; p < p_end; p++, poff++ )
354 for ( ; p < p_end; p += 2, poff++ )
355 poff[0] = FT_PEEK_USHORT( p );
359 for ( ; p < p_end; p += 3, poff++ )
360 poff[0] = FT_PEEK_OFF3( p );
364 for ( ; p < p_end; p += 4, poff++ )
365 poff[0] = FT_PEEK_ULONG( p );
373 FT_FREE( idx->offsets );
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). */
383 cff_index_get_pointers( CFF_Index idx,
387 FT_Error error = CFF_Err_Ok;
388 FT_Memory memory = idx->stream->memory;
390 FT_Byte* new_bytes = NULL;
395 if ( idx->offsets == NULL )
397 error = cff_index_load_offsets( idx );
402 if ( idx->count > 0 &&
403 !FT_NEW_ARRAY( t, idx->count + 1 ) &&
404 ( !pool || !FT_ALLOC( new_bytes,
405 idx->data_size + idx->count ) ) )
407 FT_ULong n, cur_offset;
409 FT_Byte* org_bytes = idx->bytes;
412 /* at this point, `idx->offsets' can't be NULL */
413 cur_offset = idx->offsets[0] - 1;
416 if ( cur_offset >= idx->data_size )
418 FT_TRACE0(( "cff_index_get_pointers:"
419 " invalid first offset value %d set to zero\n",
425 t[0] = org_bytes + cur_offset;
427 t[0] = new_bytes + cur_offset;
429 for ( n = 1; n <= idx->count; n++ )
431 FT_ULong next_offset = idx->offsets[n] - 1;
434 /* empty slot + two sanity checks for invalid offset tables */
435 if ( next_offset == 0 ||
436 next_offset < cur_offset ||
437 ( next_offset >= idx->data_size && n < idx->count ) )
438 next_offset = cur_offset;
441 t[n] = org_bytes + next_offset;
444 t[n] = new_bytes + next_offset + extra;
446 if ( next_offset != cur_offset )
448 FT_MEM_COPY( t[n - 1], org_bytes + cur_offset, t[n] - t[n - 1] );
455 cur_offset = next_offset;
468 FT_LOCAL_DEF( FT_Error )
469 cff_index_access_element( CFF_Index idx,
472 FT_ULong* pbyte_len )
474 FT_Error error = CFF_Err_Ok;
477 if ( idx && idx->count > element )
479 /* compute start and end offsets */
480 FT_Stream stream = idx->stream;
481 FT_ULong off1, off2 = 0;
484 /* load offsets from file or the offset table */
487 FT_ULong pos = element * idx->off_size;
490 if ( FT_STREAM_SEEK( idx->start + 3 + pos ) )
493 off1 = cff_index_read_offset( idx, &error );
502 off2 = cff_index_read_offset( idx, &error );
504 while ( off2 == 0 && element < idx->count );
507 else /* use offsets table */
509 off1 = idx->offsets[element];
515 off2 = idx->offsets[element];
517 } while ( off2 == 0 && element < idx->count );
521 /* XXX: should check off2 does not exceed the end of this entry; */
522 /* at present, only truncate off2 at the end of this stream */
523 if ( off2 > stream->size + 1 ||
524 idx->data_offset > stream->size - off2 + 1 )
526 FT_ERROR(( "cff_index_access_element:"
527 " offset to next entry (%d)"
528 " exceeds the end of stream (%d)\n",
529 off2, stream->size - idx->data_offset + 1 ));
530 off2 = stream->size - idx->data_offset + 1;
534 if ( off1 && off2 > off1 )
536 *pbyte_len = off2 - off1;
540 /* this index was completely loaded in memory, that's easy */
541 *pbytes = idx->bytes + off1 - 1;
545 /* this index is still on disk/file, access it through a frame */
546 if ( FT_STREAM_SEEK( idx->data_offset + off1 - 1 ) ||
547 FT_FRAME_EXTRACT( off2 - off1, *pbytes ) )
553 /* empty index element */
559 error = CFF_Err_Invalid_Argument;
567 cff_index_forget_element( CFF_Index idx,
570 if ( idx->bytes == 0 )
572 FT_Stream stream = idx->stream;
575 FT_FRAME_RELEASE( *pbytes );
580 /* get an entry from Name INDEX */
581 FT_LOCAL_DEF( FT_String* )
582 cff_index_get_name( CFF_Font font,
585 CFF_Index idx = &font->name_index;
586 FT_Memory memory = idx->stream->memory;
593 error = cff_index_access_element( idx, element, &bytes, &byte_len );
597 if ( !FT_ALLOC( name, byte_len + 1 ) )
599 FT_MEM_COPY( name, bytes, byte_len );
602 cff_index_forget_element( idx, &bytes );
609 /* get an entry from String INDEX */
610 FT_LOCAL_DEF( FT_String* )
611 cff_index_get_string( CFF_Font font,
614 return ( element < font->num_strings )
615 ? (FT_String*)font->strings[element]
620 FT_LOCAL_DEF( FT_String* )
621 cff_index_get_sid_string( CFF_Font font,
624 /* value 0xFFFFU indicates a missing dictionary entry */
625 if ( sid == 0xFFFFU )
628 /* if it is not a standard string, return it */
630 return cff_index_get_string( font, sid - 391 );
632 /* CID-keyed CFF fonts don't have glyph names */
633 if ( !font->psnames )
636 /* this is a standard string */
637 return (FT_String *)font->psnames->adobe_std_strings( sid );
641 /*************************************************************************/
642 /*************************************************************************/
644 /*** FD Select table support ***/
646 /*************************************************************************/
647 /*************************************************************************/
651 CFF_Done_FD_Select( CFF_FDSelect fdselect,
654 if ( fdselect->data )
655 FT_FRAME_RELEASE( fdselect->data );
657 fdselect->data_size = 0;
658 fdselect->format = 0;
659 fdselect->range_count = 0;
664 CFF_Load_FD_Select( CFF_FDSelect fdselect,
675 if ( FT_STREAM_SEEK( offset ) || FT_READ_BYTE( format ) )
678 fdselect->format = format;
679 fdselect->cache_count = 0; /* clear cache */
683 case 0: /* format 0, that's simple */
684 fdselect->data_size = num_glyphs;
687 case 3: /* format 3, a tad more complex */
688 if ( FT_READ_USHORT( num_ranges ) )
691 fdselect->data_size = num_ranges * 3 + 2;
694 if ( FT_FRAME_EXTRACT( fdselect->data_size, fdselect->data ) )
698 default: /* hmm... that's wrong */
699 error = CFF_Err_Invalid_File_Format;
707 FT_LOCAL_DEF( FT_Byte )
708 cff_fd_select_get( CFF_FDSelect fdselect,
709 FT_UInt glyph_index )
714 switch ( fdselect->format )
717 fd = fdselect->data[glyph_index];
721 /* first, compare to cache */
722 if ( (FT_UInt)( glyph_index - fdselect->cache_first ) <
723 fdselect->cache_count )
725 fd = fdselect->cache_fd;
729 /* then, lookup the ranges array */
731 FT_Byte* p = fdselect->data;
732 FT_Byte* p_limit = p + fdselect->data_size;
734 FT_UInt first, limit;
737 first = FT_NEXT_USHORT( p );
740 if ( glyph_index < first )
744 limit = FT_NEXT_USHORT( p );
746 if ( glyph_index < limit )
751 fdselect->cache_first = first;
752 fdselect->cache_count = limit-first;
753 fdselect->cache_fd = fd2;
758 } while ( p < p_limit );
770 /*************************************************************************/
771 /*************************************************************************/
773 /*** CFF font support ***/
775 /*************************************************************************/
776 /*************************************************************************/
779 cff_charset_compute_cids( CFF_Charset charset,
783 FT_Error error = CFF_Err_Ok;
786 FT_UShort max_cid = 0;
789 if ( charset->max_cid > 0 )
792 for ( i = 0; i < num_glyphs; i++ )
794 if ( charset->sids[i] > max_cid )
795 max_cid = charset->sids[i];
798 if ( FT_NEW_ARRAY( charset->cids, (FT_ULong)max_cid + 1 ) )
801 /* When multiple GIDs map to the same CID, we choose the lowest */
802 /* GID. This is not described in any spec, but it matches the */
803 /* behaviour of recent Acroread versions. */
804 for ( j = num_glyphs - 1; j >= 0 ; j-- )
805 charset->cids[charset->sids[j]] = (FT_UShort)j;
807 charset->max_cid = max_cid;
808 charset->num_glyphs = num_glyphs;
815 FT_LOCAL_DEF( FT_UInt )
816 cff_charset_cid_to_gindex( CFF_Charset charset,
822 if ( cid <= charset->max_cid )
823 result = charset->cids[cid];
830 cff_charset_free_cids( CFF_Charset charset,
833 FT_FREE( charset->cids );
834 charset->max_cid = 0;
839 cff_charset_done( CFF_Charset charset,
842 FT_Memory memory = stream->memory;
845 cff_charset_free_cids( charset, memory );
847 FT_FREE( charset->sids );
854 cff_charset_load( CFF_Charset charset,
857 FT_ULong base_offset,
861 FT_Memory memory = stream->memory;
862 FT_Error error = CFF_Err_Ok;
866 /* If the the offset is greater than 2, we have to parse the */
873 charset->offset = base_offset + offset;
875 /* Get the format of the table. */
876 if ( FT_STREAM_SEEK( charset->offset ) ||
877 FT_READ_BYTE( charset->format ) )
880 /* Allocate memory for sids. */
881 if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
884 /* assign the .notdef glyph */
885 charset->sids[0] = 0;
887 switch ( charset->format )
890 if ( num_glyphs > 0 )
892 if ( FT_FRAME_ENTER( ( num_glyphs - 1 ) * 2 ) )
895 for ( j = 1; j < num_glyphs; j++ )
896 charset->sids[j] = FT_GET_USHORT();
911 while ( j < num_glyphs )
913 /* Read the first glyph sid of the range. */
914 if ( FT_READ_USHORT( glyph_sid ) )
917 /* Read the number of glyphs in the range. */
918 if ( charset->format == 2 )
920 if ( FT_READ_USHORT( nleft ) )
925 if ( FT_READ_BYTE( nleft ) )
929 /* try to rescue some of the SIDs if `nleft' is too large */
930 if ( glyph_sid > 0xFFFFL - nleft )
932 FT_ERROR(( "cff_charset_load: invalid SID range trimmed"
933 " nleft=%d -> %d\n", nleft, 0xFFFFL - glyph_sid ));
934 nleft = ( FT_UInt )( 0xFFFFL - glyph_sid );
937 /* Fill in the range of sids -- `nleft + 1' glyphs. */
938 for ( i = 0; j < num_glyphs && i <= nleft; i++, j++, glyph_sid++ )
939 charset->sids[j] = glyph_sid;
945 FT_ERROR(( "cff_charset_load: invalid table format\n" ));
946 error = CFF_Err_Invalid_File_Format;
952 /* Parse default tables corresponding to offset == 0, 1, or 2. */
953 /* CFF specification intimates the following: */
955 /* In order to use a predefined charset, the following must be */
956 /* true: The charset constructed for the glyphs in the font's */
957 /* charstrings dictionary must match the predefined charset in */
958 /* the first num_glyphs. */
960 charset->offset = offset; /* record charset type */
962 switch ( (FT_UInt)offset )
965 if ( num_glyphs > 229 )
967 FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
968 "predefined charset (Adobe ISO-Latin)\n" ));
969 error = CFF_Err_Invalid_File_Format;
973 /* Allocate memory for sids. */
974 if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
977 /* Copy the predefined charset into the allocated memory. */
978 FT_ARRAY_COPY( charset->sids, cff_isoadobe_charset, num_glyphs );
983 if ( num_glyphs > 166 )
985 FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
986 "predefined charset (Adobe Expert)\n" ));
987 error = CFF_Err_Invalid_File_Format;
991 /* Allocate memory for sids. */
992 if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
995 /* Copy the predefined charset into the allocated memory. */
996 FT_ARRAY_COPY( charset->sids, cff_expert_charset, num_glyphs );
1001 if ( num_glyphs > 87 )
1003 FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
1004 "predefined charset (Adobe Expert Subset)\n" ));
1005 error = CFF_Err_Invalid_File_Format;
1009 /* Allocate memory for sids. */
1010 if ( FT_NEW_ARRAY( charset->sids, num_glyphs ) )
1013 /* Copy the predefined charset into the allocated memory. */
1014 FT_ARRAY_COPY( charset->sids, cff_expertsubset_charset, num_glyphs );
1019 error = CFF_Err_Invalid_File_Format;
1024 /* we have to invert the `sids' array for subsetted CID-keyed fonts */
1026 error = cff_charset_compute_cids( charset, num_glyphs, memory );
1029 /* Clean up if there was an error. */
1032 FT_FREE( charset->sids );
1033 FT_FREE( charset->cids );
1034 charset->format = 0;
1035 charset->offset = 0;
1044 cff_encoding_done( CFF_Encoding encoding )
1046 encoding->format = 0;
1047 encoding->offset = 0;
1048 encoding->count = 0;
1053 cff_encoding_load( CFF_Encoding encoding,
1054 CFF_Charset charset,
1057 FT_ULong base_offset,
1060 FT_Error error = CFF_Err_Ok;
1063 FT_UShort glyph_sid;
1067 /* Check for charset->sids. If we do not have this, we fail. */
1068 if ( !charset->sids )
1070 error = CFF_Err_Invalid_File_Format;
1074 /* Zero out the code to gid/sid mappings. */
1075 for ( j = 0; j < 256; j++ )
1077 encoding->sids [j] = 0;
1078 encoding->codes[j] = 0;
1081 /* Note: The encoding table in a CFF font is indexed by glyph index; */
1082 /* the first encoded glyph index is 1. Hence, we read the character */
1083 /* code (`glyph_code') at index j and make the assignment: */
1085 /* encoding->codes[glyph_code] = j + 1 */
1087 /* We also make the assignment: */
1089 /* encoding->sids[glyph_code] = charset->sids[j + 1] */
1091 /* This gives us both a code to GID and a code to SID mapping. */
1095 encoding->offset = base_offset + offset;
1097 /* we need to parse the table to determine its size */
1098 if ( FT_STREAM_SEEK( encoding->offset ) ||
1099 FT_READ_BYTE( encoding->format ) ||
1100 FT_READ_BYTE( count ) )
1103 switch ( encoding->format & 0x7F )
1110 /* By convention, GID 0 is always ".notdef" and is never */
1111 /* coded in the font. Hence, the number of codes found */
1112 /* in the table is `count+1'. */
1114 encoding->count = count + 1;
1116 if ( FT_FRAME_ENTER( count ) )
1119 p = (FT_Byte*)stream->cursor;
1121 for ( j = 1; j <= count; j++ )
1125 /* Make sure j is not too big. */
1126 if ( j < num_glyphs )
1128 /* Assign code to GID mapping. */
1129 encoding->codes[glyph_code] = (FT_UShort)j;
1131 /* Assign code to SID mapping. */
1132 encoding->sids[glyph_code] = charset->sids[j];
1147 encoding->count = 0;
1149 /* Parse the Format1 ranges. */
1150 for ( j = 0; j < count; j++, i += nleft )
1152 /* Read the first glyph code of the range. */
1153 if ( FT_READ_BYTE( glyph_code ) )
1156 /* Read the number of codes in the range. */
1157 if ( FT_READ_BYTE( nleft ) )
1160 /* Increment nleft, so we read `nleft + 1' codes/sids. */
1163 /* compute max number of character codes */
1164 if ( (FT_UInt)nleft > encoding->count )
1165 encoding->count = nleft;
1167 /* Fill in the range of codes/sids. */
1168 for ( k = i; k < nleft + i; k++, glyph_code++ )
1170 /* Make sure k is not too big. */
1171 if ( k < num_glyphs && glyph_code < 256 )
1173 /* Assign code to GID mapping. */
1174 encoding->codes[glyph_code] = (FT_UShort)k;
1176 /* Assign code to SID mapping. */
1177 encoding->sids[glyph_code] = charset->sids[k];
1182 /* simple check; one never knows what can be found in a font */
1183 if ( encoding->count > 256 )
1184 encoding->count = 256;
1189 FT_ERROR(( "cff_encoding_load: invalid table format\n" ));
1190 error = CFF_Err_Invalid_File_Format;
1194 /* Parse supplemental encodings, if any. */
1195 if ( encoding->format & 0x80 )
1200 /* count supplements */
1201 if ( FT_READ_BYTE( count ) )
1204 for ( j = 0; j < count; j++ )
1206 /* Read supplemental glyph code. */
1207 if ( FT_READ_BYTE( glyph_code ) )
1210 /* Read the SID associated with this glyph code. */
1211 if ( FT_READ_USHORT( glyph_sid ) )
1214 /* Assign code to SID mapping. */
1215 encoding->sids[glyph_code] = glyph_sid;
1217 /* First, look up GID which has been assigned to */
1218 /* SID glyph_sid. */
1219 for ( gindex = 0; gindex < num_glyphs; gindex++ )
1221 if ( charset->sids[gindex] == glyph_sid )
1223 encoding->codes[glyph_code] = (FT_UShort)gindex;
1232 /* We take into account the fact a CFF font can use a predefined */
1233 /* encoding without containing all of the glyphs encoded by this */
1234 /* encoding (see the note at the end of section 12 in the CFF */
1235 /* specification). */
1237 switch ( (FT_UInt)offset )
1240 /* First, copy the code to SID mapping. */
1241 FT_ARRAY_COPY( encoding->sids, cff_standard_encoding, 256 );
1245 /* First, copy the code to SID mapping. */
1246 FT_ARRAY_COPY( encoding->sids, cff_expert_encoding, 256 );
1249 /* Construct code to GID mapping from code to SID mapping */
1252 encoding->count = 0;
1254 error = cff_charset_compute_cids( charset, num_glyphs,
1259 for ( j = 0; j < 256; j++ )
1261 FT_UInt sid = encoding->sids[j];
1266 gid = cff_charset_cid_to_gindex( charset, sid );
1270 encoding->codes[j] = (FT_UShort)gid;
1271 encoding->count = j + 1;
1275 encoding->codes[j] = 0;
1276 encoding->sids [j] = 0;
1282 FT_ERROR(( "cff_encoding_load: invalid table format\n" ));
1283 error = CFF_Err_Invalid_File_Format;
1290 /* Clean up if there was an error. */
1296 cff_subfont_load( CFF_SubFont font,
1300 FT_ULong base_offset,
1301 FT_Library library )
1304 CFF_ParserRec parser;
1305 FT_Byte* dict = NULL;
1307 CFF_FontRecDict top = &font->font_dict;
1308 CFF_Private priv = &font->private_dict;
1311 cff_parser_init( &parser, CFF_CODE_TOPDICT, &font->font_dict, library );
1314 FT_MEM_ZERO( top, sizeof ( *top ) );
1316 top->underline_position = -100L << 16;
1317 top->underline_thickness = 50L << 16;
1318 top->charstring_type = 2;
1319 top->font_matrix.xx = 0x10000L;
1320 top->font_matrix.yy = 0x10000L;
1321 top->cid_count = 8720;
1323 /* we use the implementation specific SID value 0xFFFF to indicate */
1324 /* missing entries */
1325 top->version = 0xFFFFU;
1326 top->notice = 0xFFFFU;
1327 top->copyright = 0xFFFFU;
1328 top->full_name = 0xFFFFU;
1329 top->family_name = 0xFFFFU;
1330 top->weight = 0xFFFFU;
1331 top->embedded_postscript = 0xFFFFU;
1333 top->cid_registry = 0xFFFFU;
1334 top->cid_ordering = 0xFFFFU;
1335 top->cid_font_name = 0xFFFFU;
1337 error = cff_index_access_element( idx, font_index, &dict, &dict_len );
1340 FT_TRACE4(( " top dictionary:\n" ));
1341 error = cff_parser_run( &parser, dict, dict + dict_len );
1344 cff_index_forget_element( idx, &dict );
1349 /* if it is a CID font, we stop there */
1350 if ( top->cid_registry != 0xFFFFU )
1353 /* parse the private dictionary, if any */
1354 if ( top->private_offset && top->private_size )
1357 FT_MEM_ZERO( priv, sizeof ( *priv ) );
1359 priv->blue_shift = 7;
1360 priv->blue_fuzz = 1;
1362 priv->expansion_factor = (FT_Fixed)( 0.06 * 0x10000L );
1363 priv->blue_scale = (FT_Fixed)( 0.039625 * 0x10000L * 1000 );
1365 cff_parser_init( &parser, CFF_CODE_PRIVATE, priv, library );
1367 if ( FT_STREAM_SEEK( base_offset + font->font_dict.private_offset ) ||
1368 FT_FRAME_ENTER( font->font_dict.private_size ) )
1371 FT_TRACE4(( " private dictionary:\n" ));
1372 error = cff_parser_run( &parser,
1373 (FT_Byte*)stream->cursor,
1374 (FT_Byte*)stream->limit );
1379 /* ensure that `num_blue_values' is even */
1380 priv->num_blue_values &= ~1;
1383 /* read the local subrs, if any */
1384 if ( priv->local_subrs_offset )
1386 if ( FT_STREAM_SEEK( base_offset + top->private_offset +
1387 priv->local_subrs_offset ) )
1390 error = cff_index_init( &font->local_subrs_index, stream, 1 );
1394 error = cff_index_get_pointers( &font->local_subrs_index,
1395 &font->local_subrs, NULL );
1406 cff_subfont_done( FT_Memory memory,
1407 CFF_SubFont subfont )
1411 cff_index_done( &subfont->local_subrs_index );
1412 FT_FREE( subfont->local_subrs );
1417 FT_LOCAL_DEF( FT_Error )
1418 cff_font_load( FT_Library library,
1424 static const FT_Frame_Field cff_header_fields[] =
1427 #define FT_STRUCTURE CFF_FontRec
1429 FT_FRAME_START( 4 ),
1430 FT_FRAME_BYTE( version_major ),
1431 FT_FRAME_BYTE( version_minor ),
1432 FT_FRAME_BYTE( header_size ),
1433 FT_FRAME_BYTE( absolute_offsize ),
1438 FT_Memory memory = stream->memory;
1439 FT_ULong base_offset;
1440 CFF_FontRecDict dict;
1441 CFF_IndexRec string_index;
1445 FT_ZERO( &string_index );
1447 font->stream = stream;
1448 font->memory = memory;
1449 dict = &font->top_font.font_dict;
1450 base_offset = FT_STREAM_POS();
1452 /* read CFF font header */
1453 if ( FT_STREAM_READ_FIELDS( cff_header_fields, font ) )
1457 if ( font->version_major != 1 ||
1458 font->header_size < 4 ||
1459 font->absolute_offsize > 4 )
1461 FT_TRACE2(( " not a CFF font header\n" ));
1462 error = CFF_Err_Unknown_File_Format;
1466 /* skip the rest of the header */
1467 if ( FT_STREAM_SKIP( font->header_size - 4 ) )
1470 /* read the name, top dict, string and global subrs index */
1471 if ( FT_SET_ERROR( cff_index_init( &font->name_index,
1473 FT_SET_ERROR( cff_index_init( &font->font_dict_index,
1475 FT_SET_ERROR( cff_index_init( &string_index,
1477 FT_SET_ERROR( cff_index_init( &font->global_subrs_index,
1479 FT_SET_ERROR( cff_index_get_pointers( &string_index,
1481 &font->string_pool ) ) )
1484 font->num_strings = string_index.count;
1486 /* well, we don't really forget the `disabled' fonts... */
1487 font->num_faces = font->name_index.count;
1488 if ( face_index >= (FT_Int)font->num_faces )
1490 FT_ERROR(( "cff_font_load: incorrect face index = %d\n",
1492 error = CFF_Err_Invalid_Argument;
1495 /* in case of a font format check, simply exit now */
1496 if ( face_index < 0 )
1499 /* now, parse the top-level font dictionary */
1500 FT_TRACE4(( "parsing top-level\n" ));
1501 error = cff_subfont_load( &font->top_font,
1502 &font->font_dict_index,
1510 if ( FT_STREAM_SEEK( base_offset + dict->charstrings_offset ) )
1513 error = cff_index_init( &font->charstrings_index, stream, 0 );
1517 /* now, check for a CID font */
1518 if ( dict->cid_registry != 0xFFFFU )
1520 CFF_IndexRec fd_index;
1521 CFF_SubFont sub = NULL;
1525 /* this is a CID-keyed font, we must now allocate a table of */
1526 /* sub-fonts, then load each of them separately */
1527 if ( FT_STREAM_SEEK( base_offset + dict->cid_fd_array_offset ) )
1530 error = cff_index_init( &fd_index, stream, 0 );
1534 if ( fd_index.count > CFF_MAX_CID_FONTS )
1536 FT_TRACE0(( "cff_font_load: FD array too large in CID font\n" ));
1540 /* allocate & read each font dict independently */
1541 font->num_subfonts = fd_index.count;
1542 if ( FT_NEW_ARRAY( sub, fd_index.count ) )
1545 /* set up pointer table */
1546 for ( idx = 0; idx < fd_index.count; idx++ )
1547 font->subfonts[idx] = sub + idx;
1549 /* now load each subfont independently */
1550 for ( idx = 0; idx < fd_index.count; idx++ )
1552 sub = font->subfonts[idx];
1553 FT_TRACE4(( "parsing subfont %u\n", idx ));
1554 error = cff_subfont_load( sub, &fd_index, idx,
1555 stream, base_offset, library );
1560 /* now load the FD Select array */
1561 error = CFF_Load_FD_Select( &font->fd_select,
1562 font->charstrings_index.count,
1564 base_offset + dict->cid_fd_select_offset );
1567 cff_index_done( &fd_index );
1573 font->num_subfonts = 0;
1575 /* read the charstrings index now */
1576 if ( dict->charstrings_offset == 0 )
1578 FT_ERROR(( "cff_font_load: no charstrings offset\n" ));
1579 error = CFF_Err_Invalid_File_Format;
1583 font->num_glyphs = font->charstrings_index.count;
1585 error = cff_index_get_pointers( &font->global_subrs_index,
1586 &font->global_subrs, NULL );
1591 /* read the Charset and Encoding tables if available */
1592 if ( font->num_glyphs > 0 )
1594 FT_Bool invert = FT_BOOL( dict->cid_registry != 0xFFFFU && pure_cff );
1597 error = cff_charset_load( &font->charset, font->num_glyphs, stream,
1598 base_offset, dict->charset_offset, invert );
1602 /* CID-keyed CFFs don't have an encoding */
1603 if ( dict->cid_registry == 0xFFFFU )
1605 error = cff_encoding_load( &font->encoding,
1610 dict->encoding_offset );
1616 /* get the font name (/CIDFontName for CID-keyed fonts, */
1617 /* /FontName otherwise) */
1618 font->font_name = cff_index_get_name( font, face_index );
1621 cff_index_done( &string_index );
1627 FT_LOCAL_DEF( void )
1628 cff_font_done( CFF_Font font )
1630 FT_Memory memory = font->memory;
1634 cff_index_done( &font->global_subrs_index );
1635 cff_index_done( &font->font_dict_index );
1636 cff_index_done( &font->name_index );
1637 cff_index_done( &font->charstrings_index );
1639 /* release font dictionaries, but only if working with */
1640 /* a CID keyed CFF font */
1641 if ( font->num_subfonts > 0 )
1643 for ( idx = 0; idx < font->num_subfonts; idx++ )
1644 cff_subfont_done( memory, font->subfonts[idx] );
1646 /* the subfonts array has been allocated as a single block */
1647 FT_FREE( font->subfonts[0] );
1650 cff_encoding_done( &font->encoding );
1651 cff_charset_done( &font->charset, font->stream );
1653 cff_subfont_done( memory, &font->top_font );
1655 CFF_Done_FD_Select( &font->fd_select, font->stream );
1657 FT_FREE( font->font_info );
1659 FT_FREE( font->font_name );
1660 FT_FREE( font->global_subrs );
1661 FT_FREE( font->strings );
1662 FT_FREE( font->string_pool );