1 /***************************************************************************/
5 /* OpenType and CFF data/program tables loader (body). */
7 /* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 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_SERVICE_POSTSCRIPT_CMAPS_H
24 #include FT_TRUETYPE_TAGS_H
25 #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
181 FT_LOCAL_DEF( FT_UShort
)
182 cff_get_standard_encoding( FT_UInt charcode
)
184 return (FT_UShort
)(charcode
< 256 ? cff_standard_encoding
[charcode
] : 0);
188 /*************************************************************************/
190 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
191 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
192 /* messages during execution. */
195 #define FT_COMPONENT trace_cffload
198 /* read an offset from the index's stream current position */
200 cff_index_read_offset( CFF_Index idx
,
204 FT_Stream stream
= idx
->stream
;
209 if ( !FT_STREAM_READ( tmp
, idx
->off_size
) )
214 for ( nn
= 0; nn
< idx
->off_size
; nn
++ )
215 result
= ( result
<< 8 ) | tmp
[nn
];
224 cff_index_init( CFF_Index idx
,
229 FT_Memory memory
= stream
->memory
;
233 FT_MEM_ZERO( idx
, sizeof ( *idx
) );
235 idx
->stream
= stream
;
236 idx
->start
= FT_STREAM_POS();
237 if ( !FT_READ_USHORT( count
) &&
244 /* there is at least one element; read the offset size, */
245 /* then access the offset table to compute the index's total size */
246 if ( FT_READ_BYTE( offsize
) )
249 if ( offsize
< 1 || offsize
> 4 )
251 error
= FT_Err_Invalid_Table
;
256 idx
->off_size
= offsize
;
257 size
= (FT_ULong
)( count
+ 1 ) * offsize
;
259 idx
->data_offset
= idx
->start
+ 3 + size
;
261 if ( FT_STREAM_SKIP( size
- offsize
) )
264 size
= cff_index_read_offset( idx
, &error
);
270 error
= CFF_Err_Invalid_Table
;
274 idx
->data_size
= --size
;
279 if ( FT_FRAME_EXTRACT( size
, idx
->bytes
) )
285 if ( FT_STREAM_SKIP( size
) )
292 FT_FREE( idx
->offsets
);
299 cff_index_done( CFF_Index idx
)
303 FT_Stream stream
= idx
->stream
;
304 FT_Memory memory
= stream
->memory
;
308 FT_FRAME_RELEASE( idx
->bytes
);
310 FT_FREE( idx
->offsets
);
311 FT_MEM_ZERO( idx
, sizeof ( *idx
) );
317 cff_index_load_offsets( CFF_Index idx
)
320 FT_Stream stream
= idx
->stream
;
321 FT_Memory memory
= stream
->memory
;
324 if ( idx
->count
> 0 && idx
->offsets
== NULL
)
326 FT_Byte offsize
= idx
->off_size
;
333 data_size
= (FT_ULong
)( idx
->count
+ 1 ) * offsize
;
335 if ( FT_NEW_ARRAY( idx
->offsets
, idx
->count
+ 1 ) ||
336 FT_STREAM_SEEK( idx
->start
+ 3 ) ||
337 FT_FRAME_ENTER( data_size
) )
341 p
= (FT_Byte
*)stream
->cursor
;
342 p_end
= p
+ data_size
;
347 for ( ; p
< p_end
; p
++, poff
++ )
352 for ( ; p
< p_end
; p
+= 2, poff
++ )
353 poff
[0] = FT_PEEK_USHORT( p
);
357 for ( ; p
< p_end
; p
+= 3, poff
++ )
358 poff
[0] = FT_PEEK_OFF3( p
);
362 for ( ; p
< p_end
; p
+= 4, poff
++ )
363 poff
[0] = FT_PEEK_ULONG( p
);
371 FT_FREE( idx
->offsets
);
377 /* allocate a table containing pointers to an index's elements */
379 cff_index_get_pointers( CFF_Index idx
,
382 FT_Error error
= CFF_Err_Ok
;
383 FT_Memory memory
= idx
->stream
->memory
;
384 FT_ULong n
, offset
, old_offset
;
390 if ( idx
->offsets
== NULL
)
392 error
= cff_index_load_offsets( idx
);
397 if ( idx
->count
> 0 && !FT_NEW_ARRAY( t
, idx
->count
+ 1 ) )
400 for ( n
= 0; n
<= idx
->count
; n
++ )
402 offset
= idx
->offsets
[n
];
406 /* two sanity checks for invalid offset tables */
407 else if ( offset
< old_offset
)
410 else if ( offset
- 1 >= idx
->data_size
&& n
< idx
->count
)
413 t
[n
] = idx
->bytes
+ offset
- 1;
425 FT_LOCAL_DEF( FT_Error
)
426 cff_index_access_element( CFF_Index idx
,
429 FT_ULong
* pbyte_len
)
431 FT_Error error
= CFF_Err_Ok
;
434 if ( idx
&& idx
->count
> element
)
436 /* compute start and end offsets */
437 FT_Stream stream
= idx
->stream
;
438 FT_ULong off1
, off2
= 0;
441 /* load offsets from file or the offset table */
444 FT_ULong pos
= element
* idx
->off_size
;
447 if ( FT_STREAM_SEEK( idx
->start
+ 3 + pos
) )
450 off1
= cff_index_read_offset( idx
, &error
);
459 off2
= cff_index_read_offset( idx
, &error
);
461 while ( off2
== 0 && element
< idx
->count
);
464 else /* use offsets table */
466 off1
= idx
->offsets
[element
];
472 off2
= idx
->offsets
[element
];
474 } while ( off2
== 0 && element
< idx
->count
);
479 if ( off1
&& off2
> off1
)
481 *pbyte_len
= off2
- off1
;
485 /* this index was completely loaded in memory, that's easy */
486 *pbytes
= idx
->bytes
+ off1
- 1;
490 /* this index is still on disk/file, access it through a frame */
491 if ( FT_STREAM_SEEK( idx
->data_offset
+ off1
- 1 ) ||
492 FT_FRAME_EXTRACT( off2
- off1
, *pbytes
) )
498 /* empty index element */
504 error
= CFF_Err_Invalid_Argument
;
512 cff_index_forget_element( CFF_Index idx
,
515 if ( idx
->bytes
== 0 )
517 FT_Stream stream
= idx
->stream
;
520 FT_FRAME_RELEASE( *pbytes
);
525 FT_LOCAL_DEF( FT_String
* )
526 cff_index_get_name( CFF_Index idx
,
529 FT_Memory memory
= idx
->stream
->memory
;
536 error
= cff_index_access_element( idx
, element
, &bytes
, &byte_len
);
540 if ( !FT_ALLOC( name
, byte_len
+ 1 ) )
542 FT_MEM_COPY( name
, bytes
, byte_len
);
545 cff_index_forget_element( idx
, &bytes
);
552 FT_LOCAL_DEF( FT_String
* )
553 cff_index_get_sid_string( CFF_Index idx
,
555 FT_Service_PsCMaps psnames
)
557 /* value 0xFFFFU indicates a missing dictionary entry */
558 if ( sid
== 0xFFFFU
)
561 /* if it is not a standard string, return it */
563 return cff_index_get_name( idx
, sid
- 391 );
565 /* CID-keyed CFF fonts don't have glyph names */
569 /* that's a standard string, fetch a copy from the PSName module */
572 const char* adobe_name
= psnames
->adobe_std_strings( sid
);
577 FT_Memory memory
= idx
->stream
->memory
;
581 (void)FT_STRDUP( name
, adobe_name
);
591 /*************************************************************************/
592 /*************************************************************************/
594 /*** FD Select table support ***/
596 /*************************************************************************/
597 /*************************************************************************/
601 CFF_Done_FD_Select( CFF_FDSelect fdselect
,
604 if ( fdselect
->data
)
605 FT_FRAME_RELEASE( fdselect
->data
);
607 fdselect
->data_size
= 0;
608 fdselect
->format
= 0;
609 fdselect
->range_count
= 0;
614 CFF_Load_FD_Select( CFF_FDSelect fdselect
,
625 if ( FT_STREAM_SEEK( offset
) || FT_READ_BYTE( format
) )
628 fdselect
->format
= format
;
629 fdselect
->cache_count
= 0; /* clear cache */
633 case 0: /* format 0, that's simple */
634 fdselect
->data_size
= num_glyphs
;
637 case 3: /* format 3, a tad more complex */
638 if ( FT_READ_USHORT( num_ranges
) )
641 fdselect
->data_size
= num_ranges
* 3 + 2;
644 if ( FT_FRAME_EXTRACT( fdselect
->data_size
, fdselect
->data
) )
648 default: /* hmm... that's wrong */
649 error
= CFF_Err_Invalid_File_Format
;
657 FT_LOCAL_DEF( FT_Byte
)
658 cff_fd_select_get( CFF_FDSelect fdselect
,
659 FT_UInt glyph_index
)
664 switch ( fdselect
->format
)
667 fd
= fdselect
->data
[glyph_index
];
671 /* first, compare to cache */
672 if ( (FT_UInt
)( glyph_index
- fdselect
->cache_first
) <
673 fdselect
->cache_count
)
675 fd
= fdselect
->cache_fd
;
679 /* then, lookup the ranges array */
681 FT_Byte
* p
= fdselect
->data
;
682 FT_Byte
* p_limit
= p
+ fdselect
->data_size
;
684 FT_UInt first
, limit
;
687 first
= FT_NEXT_USHORT( p
);
690 if ( glyph_index
< first
)
694 limit
= FT_NEXT_USHORT( p
);
696 if ( glyph_index
< limit
)
701 fdselect
->cache_first
= first
;
702 fdselect
->cache_count
= limit
-first
;
703 fdselect
->cache_fd
= fd2
;
708 } while ( p
< p_limit
);
720 /*************************************************************************/
721 /*************************************************************************/
723 /*** CFF font support ***/
725 /*************************************************************************/
726 /*************************************************************************/
729 cff_charset_compute_cids( CFF_Charset charset
,
733 FT_Error error
= FT_Err_Ok
;
735 FT_UShort max_cid
= 0;
738 if ( charset
->max_cid
> 0 )
741 for ( i
= 0; i
< num_glyphs
; i
++ )
742 if ( charset
->sids
[i
] > max_cid
)
743 max_cid
= charset
->sids
[i
];
746 if ( FT_NEW_ARRAY( charset
->cids
, max_cid
) )
749 for ( i
= 0; i
< num_glyphs
; i
++ )
750 charset
->cids
[charset
->sids
[i
]] = (FT_UShort
)i
;
752 charset
->max_cid
= max_cid
;
753 charset
->num_glyphs
= num_glyphs
;
760 FT_LOCAL_DEF( FT_UInt
)
761 cff_charset_cid_to_gindex( CFF_Charset charset
,
767 if ( cid
< charset
->max_cid
)
768 result
= charset
->cids
[cid
];
775 cff_charset_free_cids( CFF_Charset charset
,
778 FT_FREE( charset
->cids
);
779 charset
->max_cid
= 0;
784 cff_charset_done( CFF_Charset charset
,
787 FT_Memory memory
= stream
->memory
;
790 cff_charset_free_cids( charset
, memory
);
792 FT_FREE( charset
->sids
);
799 cff_charset_load( CFF_Charset charset
,
802 FT_ULong base_offset
,
806 FT_Memory memory
= stream
->memory
;
807 FT_Error error
= CFF_Err_Ok
;
811 /* If the the offset is greater than 2, we have to parse the */
818 charset
->offset
= base_offset
+ offset
;
820 /* Get the format of the table. */
821 if ( FT_STREAM_SEEK( charset
->offset
) ||
822 FT_READ_BYTE( charset
->format
) )
825 /* Allocate memory for sids. */
826 if ( FT_NEW_ARRAY( charset
->sids
, num_glyphs
) )
829 /* assign the .notdef glyph */
830 charset
->sids
[0] = 0;
832 switch ( charset
->format
)
835 if ( num_glyphs
> 0 )
837 if ( FT_FRAME_ENTER( ( num_glyphs
- 1 ) * 2 ) )
840 for ( j
= 1; j
< num_glyphs
; j
++ )
841 charset
->sids
[j
] = FT_GET_USHORT();
856 while ( j
< num_glyphs
)
858 /* Read the first glyph sid of the range. */
859 if ( FT_READ_USHORT( glyph_sid
) )
862 /* Read the number of glyphs in the range. */
863 if ( charset
->format
== 2 )
865 if ( FT_READ_USHORT( nleft
) )
870 if ( FT_READ_BYTE( nleft
) )
874 /* Fill in the range of sids -- `nleft + 1' glyphs. */
875 for ( i
= 0; j
< num_glyphs
&& i
<= nleft
; i
++, j
++, glyph_sid
++ )
876 charset
->sids
[j
] = glyph_sid
;
882 FT_ERROR(( "cff_charset_load: invalid table format!\n" ));
883 error
= CFF_Err_Invalid_File_Format
;
889 /* Parse default tables corresponding to offset == 0, 1, or 2. */
890 /* CFF specification intimates the following: */
892 /* In order to use a predefined charset, the following must be */
893 /* true: The charset constructed for the glyphs in the font's */
894 /* charstrings dictionary must match the predefined charset in */
895 /* the first num_glyphs. */
897 charset
->offset
= offset
; /* record charset type */
899 switch ( (FT_UInt
)offset
)
902 if ( num_glyphs
> 229 )
904 FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
905 "predefined charset (Adobe ISO-Latin)!\n" ));
906 error
= CFF_Err_Invalid_File_Format
;
910 /* Allocate memory for sids. */
911 if ( FT_NEW_ARRAY( charset
->sids
, num_glyphs
) )
914 /* Copy the predefined charset into the allocated memory. */
915 FT_ARRAY_COPY( charset
->sids
, cff_isoadobe_charset
, num_glyphs
);
920 if ( num_glyphs
> 166 )
922 FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
923 "predefined charset (Adobe Expert)!\n" ));
924 error
= CFF_Err_Invalid_File_Format
;
928 /* Allocate memory for sids. */
929 if ( FT_NEW_ARRAY( charset
->sids
, num_glyphs
) )
932 /* Copy the predefined charset into the allocated memory. */
933 FT_ARRAY_COPY( charset
->sids
, cff_expert_charset
, num_glyphs
);
938 if ( num_glyphs
> 87 )
940 FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
941 "predefined charset (Adobe Expert Subset)!\n" ));
942 error
= CFF_Err_Invalid_File_Format
;
946 /* Allocate memory for sids. */
947 if ( FT_NEW_ARRAY( charset
->sids
, num_glyphs
) )
950 /* Copy the predefined charset into the allocated memory. */
951 FT_ARRAY_COPY( charset
->sids
, cff_expertsubset_charset
, num_glyphs
);
956 error
= CFF_Err_Invalid_File_Format
;
961 /* we have to invert the `sids' array for subsetted CID-keyed fonts */
963 error
= cff_charset_compute_cids( charset
, num_glyphs
, memory
);
966 /* Clean up if there was an error. */
969 FT_FREE( charset
->sids
);
970 FT_FREE( charset
->cids
);
981 cff_encoding_done( CFF_Encoding encoding
)
983 encoding
->format
= 0;
984 encoding
->offset
= 0;
990 cff_encoding_load( CFF_Encoding encoding
,
994 FT_ULong base_offset
,
997 FT_Error error
= CFF_Err_Ok
;
1000 FT_UShort glyph_sid
;
1004 /* Check for charset->sids. If we do not have this, we fail. */
1005 if ( !charset
->sids
)
1007 error
= CFF_Err_Invalid_File_Format
;
1011 /* Zero out the code to gid/sid mappings. */
1012 for ( j
= 0; j
< 256; j
++ )
1014 encoding
->sids
[j
] = 0;
1015 encoding
->codes
[j
] = 0;
1018 /* Note: The encoding table in a CFF font is indexed by glyph index; */
1019 /* the first encoded glyph index is 1. Hence, we read the character */
1020 /* code (`glyph_code') at index j and make the assignment: */
1022 /* encoding->codes[glyph_code] = j + 1 */
1024 /* We also make the assignment: */
1026 /* encoding->sids[glyph_code] = charset->sids[j + 1] */
1028 /* This gives us both a code to GID and a code to SID mapping. */
1032 encoding
->offset
= base_offset
+ offset
;
1034 /* we need to parse the table to determine its size */
1035 if ( FT_STREAM_SEEK( encoding
->offset
) ||
1036 FT_READ_BYTE( encoding
->format
) ||
1037 FT_READ_BYTE( count
) )
1040 switch ( encoding
->format
& 0x7F )
1047 /* By convention, GID 0 is always ".notdef" and is never */
1048 /* coded in the font. Hence, the number of codes found */
1049 /* in the table is `count+1'. */
1051 encoding
->count
= count
+ 1;
1053 if ( FT_FRAME_ENTER( count
) )
1056 p
= (FT_Byte
*)stream
->cursor
;
1058 for ( j
= 1; j
<= count
; j
++ )
1062 /* Make sure j is not too big. */
1063 if ( j
< num_glyphs
)
1065 /* Assign code to GID mapping. */
1066 encoding
->codes
[glyph_code
] = (FT_UShort
)j
;
1068 /* Assign code to SID mapping. */
1069 encoding
->sids
[glyph_code
] = charset
->sids
[j
];
1084 encoding
->count
= 0;
1086 /* Parse the Format1 ranges. */
1087 for ( j
= 0; j
< count
; j
++, i
+= nleft
)
1089 /* Read the first glyph code of the range. */
1090 if ( FT_READ_BYTE( glyph_code
) )
1093 /* Read the number of codes in the range. */
1094 if ( FT_READ_BYTE( nleft
) )
1097 /* Increment nleft, so we read `nleft + 1' codes/sids. */
1100 /* compute max number of character codes */
1101 if ( (FT_UInt
)nleft
> encoding
->count
)
1102 encoding
->count
= nleft
;
1104 /* Fill in the range of codes/sids. */
1105 for ( k
= i
; k
< nleft
+ i
; k
++, glyph_code
++ )
1107 /* Make sure k is not too big. */
1108 if ( k
< num_glyphs
&& glyph_code
< 256 )
1110 /* Assign code to GID mapping. */
1111 encoding
->codes
[glyph_code
] = (FT_UShort
)k
;
1113 /* Assign code to SID mapping. */
1114 encoding
->sids
[glyph_code
] = charset
->sids
[k
];
1119 /* simple check; one never knows what can be found in a font */
1120 if ( encoding
->count
> 256 )
1121 encoding
->count
= 256;
1126 FT_ERROR(( "cff_encoding_load: invalid table format!\n" ));
1127 error
= CFF_Err_Invalid_File_Format
;
1131 /* Parse supplemental encodings, if any. */
1132 if ( encoding
->format
& 0x80 )
1137 /* count supplements */
1138 if ( FT_READ_BYTE( count
) )
1141 for ( j
= 0; j
< count
; j
++ )
1143 /* Read supplemental glyph code. */
1144 if ( FT_READ_BYTE( glyph_code
) )
1147 /* Read the SID associated with this glyph code. */
1148 if ( FT_READ_USHORT( glyph_sid
) )
1151 /* Assign code to SID mapping. */
1152 encoding
->sids
[glyph_code
] = glyph_sid
;
1154 /* First, look up GID which has been assigned to */
1155 /* SID glyph_sid. */
1156 for ( gindex
= 0; gindex
< num_glyphs
; gindex
++ )
1158 if ( charset
->sids
[gindex
] == glyph_sid
)
1160 encoding
->codes
[glyph_code
] = (FT_UShort
)gindex
;
1169 /* We take into account the fact a CFF font can use a predefined */
1170 /* encoding without containing all of the glyphs encoded by this */
1171 /* encoding (see the note at the end of section 12 in the CFF */
1172 /* specification). */
1174 switch ( (FT_UInt
)offset
)
1177 /* First, copy the code to SID mapping. */
1178 FT_ARRAY_COPY( encoding
->sids
, cff_standard_encoding
, 256 );
1182 /* First, copy the code to SID mapping. */
1183 FT_ARRAY_COPY( encoding
->sids
, cff_expert_encoding
, 256 );
1186 /* Construct code to GID mapping from code to SID mapping */
1189 encoding
->count
= 0;
1191 error
= cff_charset_compute_cids( charset
, num_glyphs
,
1196 for ( j
= 0; j
< 256; j
++ )
1198 FT_UInt sid
= encoding
->sids
[j
];
1203 gid
= cff_charset_cid_to_gindex( charset
, sid
);
1207 encoding
->codes
[j
] = (FT_UShort
)gid
;
1209 if ( encoding
->count
< j
+ 1 )
1210 encoding
->count
= j
+ 1;
1214 encoding
->codes
[j
] = 0;
1215 encoding
->sids
[j
] = 0;
1221 FT_ERROR(( "cff_encoding_load: invalid table format!\n" ));
1222 error
= CFF_Err_Invalid_File_Format
;
1229 /* Clean up if there was an error. */
1235 cff_subfont_load( CFF_SubFont font
,
1239 FT_ULong base_offset
)
1242 CFF_ParserRec parser
;
1243 FT_Byte
* dict
= NULL
;
1245 CFF_FontRecDict top
= &font
->font_dict
;
1246 CFF_Private priv
= &font
->private_dict
;
1249 cff_parser_init( &parser
, CFF_CODE_TOPDICT
, &font
->font_dict
);
1252 FT_MEM_ZERO( top
, sizeof ( *top
) );
1254 top
->underline_position
= -100L << 16;
1255 top
->underline_thickness
= 50L << 16;
1256 top
->charstring_type
= 2;
1257 top
->font_matrix
.xx
= 0x10000L
;
1258 top
->font_matrix
.yy
= 0x10000L
;
1259 top
->cid_count
= 8720;
1261 /* we use the implementation specific SID value 0xFFFF to indicate */
1262 /* missing entries */
1263 top
->version
= 0xFFFFU
;
1264 top
->notice
= 0xFFFFU
;
1265 top
->copyright
= 0xFFFFU
;
1266 top
->full_name
= 0xFFFFU
;
1267 top
->family_name
= 0xFFFFU
;
1268 top
->weight
= 0xFFFFU
;
1269 top
->embedded_postscript
= 0xFFFFU
;
1271 top
->cid_registry
= 0xFFFFU
;
1272 top
->cid_ordering
= 0xFFFFU
;
1273 top
->cid_font_name
= 0xFFFFU
;
1275 error
= cff_index_access_element( idx
, font_index
, &dict
, &dict_len
) ||
1276 cff_parser_run( &parser
, dict
, dict
+ dict_len
);
1278 cff_index_forget_element( idx
, &dict
);
1283 /* if it is a CID font, we stop there */
1284 if ( top
->cid_registry
!= 0xFFFFU
)
1287 /* parse the private dictionary, if any */
1288 if ( top
->private_offset
&& top
->private_size
)
1291 FT_MEM_ZERO( priv
, sizeof ( *priv
) );
1293 priv
->blue_shift
= 7;
1294 priv
->blue_fuzz
= 1;
1296 priv
->expansion_factor
= (FT_Fixed
)( 0.06 * 0x10000L
);
1297 priv
->blue_scale
= (FT_Fixed
)( 0.039625 * 0x10000L
* 1000 );
1299 cff_parser_init( &parser
, CFF_CODE_PRIVATE
, priv
);
1301 if ( FT_STREAM_SEEK( base_offset
+ font
->font_dict
.private_offset
) ||
1302 FT_FRAME_ENTER( font
->font_dict
.private_size
) )
1305 error
= cff_parser_run( &parser
,
1306 (FT_Byte
*)stream
->cursor
,
1307 (FT_Byte
*)stream
->limit
);
1312 /* ensure that `num_blue_values' is even */
1313 priv
->num_blue_values
&= ~1;
1316 /* read the local subrs, if any */
1317 if ( priv
->local_subrs_offset
)
1319 if ( FT_STREAM_SEEK( base_offset
+ top
->private_offset
+
1320 priv
->local_subrs_offset
) )
1323 error
= cff_index_init( &font
->local_subrs_index
, stream
, 1 );
1327 font
->num_local_subrs
= font
->local_subrs_index
.count
;
1328 error
= cff_index_get_pointers( &font
->local_subrs_index
,
1329 &font
->local_subrs
);
1340 cff_subfont_done( FT_Memory memory
,
1341 CFF_SubFont subfont
)
1345 cff_index_done( &subfont
->local_subrs_index
);
1346 FT_FREE( subfont
->local_subrs
);
1351 FT_LOCAL_DEF( FT_Error
)
1352 cff_font_load( FT_Stream stream
,
1356 static const FT_Frame_Field cff_header_fields
[] =
1359 #define FT_STRUCTURE CFF_FontRec
1361 FT_FRAME_START( 4 ),
1362 FT_FRAME_BYTE( version_major
),
1363 FT_FRAME_BYTE( version_minor
),
1364 FT_FRAME_BYTE( header_size
),
1365 FT_FRAME_BYTE( absolute_offsize
),
1370 FT_Memory memory
= stream
->memory
;
1371 FT_ULong base_offset
;
1372 CFF_FontRecDict dict
;
1377 font
->stream
= stream
;
1378 font
->memory
= memory
;
1379 dict
= &font
->top_font
.font_dict
;
1380 base_offset
= FT_STREAM_POS();
1382 /* read CFF font header */
1383 if ( FT_STREAM_READ_FIELDS( cff_header_fields
, font
) )
1387 if ( font
->version_major
!= 1 ||
1388 font
->header_size
< 4 ||
1389 font
->absolute_offsize
> 4 )
1391 FT_TRACE2(( "[not a CFF font header!]\n" ));
1392 error
= CFF_Err_Unknown_File_Format
;
1396 /* skip the rest of the header */
1397 if ( FT_STREAM_SKIP( font
->header_size
- 4 ) )
1400 /* read the name, top dict, string and global subrs index */
1401 if ( FT_SET_ERROR( cff_index_init( &font
->name_index
,
1403 FT_SET_ERROR( cff_index_init( &font
->font_dict_index
,
1405 FT_SET_ERROR( cff_index_init( &font
->string_index
,
1407 FT_SET_ERROR( cff_index_init( &font
->global_subrs_index
,
1411 /* well, we don't really forget the `disabled' fonts... */
1412 font
->num_faces
= font
->name_index
.count
;
1413 if ( face_index
>= (FT_Int
)font
->num_faces
)
1415 FT_ERROR(( "cff_font_load: incorrect face index = %d\n",
1417 error
= CFF_Err_Invalid_Argument
;
1420 /* in case of a font format check, simply exit now */
1421 if ( face_index
< 0 )
1424 /* now, parse the top-level font dictionary */
1425 error
= cff_subfont_load( &font
->top_font
,
1426 &font
->font_dict_index
,
1433 if ( FT_STREAM_SEEK( base_offset
+ dict
->charstrings_offset
) )
1436 error
= cff_index_init( &font
->charstrings_index
, stream
, 0 );
1440 /* now, check for a CID font */
1441 if ( dict
->cid_registry
!= 0xFFFFU
)
1443 CFF_IndexRec fd_index
;
1448 /* this is a CID-keyed font, we must now allocate a table of */
1449 /* sub-fonts, then load each of them separately */
1450 if ( FT_STREAM_SEEK( base_offset
+ dict
->cid_fd_array_offset
) )
1453 error
= cff_index_init( &fd_index
, stream
, 0 );
1457 if ( fd_index
.count
> CFF_MAX_CID_FONTS
)
1459 FT_ERROR(( "cff_font_load: FD array too large in CID font\n" ));
1463 /* allocate & read each font dict independently */
1464 font
->num_subfonts
= fd_index
.count
;
1465 if ( FT_NEW_ARRAY( sub
, fd_index
.count
) )
1468 /* set up pointer table */
1469 for ( idx
= 0; idx
< fd_index
.count
; idx
++ )
1470 font
->subfonts
[idx
] = sub
+ idx
;
1472 /* now load each subfont independently */
1473 for ( idx
= 0; idx
< fd_index
.count
; idx
++ )
1475 sub
= font
->subfonts
[idx
];
1476 error
= cff_subfont_load( sub
, &fd_index
, idx
,
1477 stream
, base_offset
);
1482 /* now load the FD Select array */
1483 error
= CFF_Load_FD_Select( &font
->fd_select
,
1484 font
->charstrings_index
.count
,
1486 base_offset
+ dict
->cid_fd_select_offset
);
1489 cff_index_done( &fd_index
);
1495 font
->num_subfonts
= 0;
1497 /* read the charstrings index now */
1498 if ( dict
->charstrings_offset
== 0 )
1500 FT_ERROR(( "cff_font_load: no charstrings offset!\n" ));
1501 error
= CFF_Err_Unknown_File_Format
;
1505 /* explicit the global subrs */
1506 font
->num_global_subrs
= font
->global_subrs_index
.count
;
1507 font
->num_glyphs
= font
->charstrings_index
.count
;
1509 error
= cff_index_get_pointers( &font
->global_subrs_index
,
1510 &font
->global_subrs
) ;
1515 /* read the Charset and Encoding tables if available */
1516 if ( font
->num_glyphs
> 0 )
1518 FT_Bool invert
= FT_BOOL( dict
->cid_registry
!= 0xFFFFU
);
1521 error
= cff_charset_load( &font
->charset
, font
->num_glyphs
, stream
,
1522 base_offset
, dict
->charset_offset
, invert
);
1526 /* CID-keyed CFFs don't have an encoding */
1527 if ( dict
->cid_registry
== 0xFFFFU
)
1529 error
= cff_encoding_load( &font
->encoding
,
1534 dict
->encoding_offset
);
1539 /* CID-keyed fonts only need CIDs */
1540 FT_FREE( font
->charset
.sids
);
1543 /* get the font name (/CIDFontName for CID-keyed fonts, */
1544 /* /FontName otherwise) */
1545 font
->font_name
= cff_index_get_name( &font
->name_index
, face_index
);
1552 FT_LOCAL_DEF( void )
1553 cff_font_done( CFF_Font font
)
1555 FT_Memory memory
= font
->memory
;
1559 cff_index_done( &font
->global_subrs_index
);
1560 cff_index_done( &font
->string_index
);
1561 cff_index_done( &font
->font_dict_index
);
1562 cff_index_done( &font
->name_index
);
1563 cff_index_done( &font
->charstrings_index
);
1565 /* release font dictionaries, but only if working with */
1566 /* a CID keyed CFF font */
1567 if ( font
->num_subfonts
> 0 )
1569 for ( idx
= 0; idx
< font
->num_subfonts
; idx
++ )
1570 cff_subfont_done( memory
, font
->subfonts
[idx
] );
1572 /* the subfonts array has been allocated as a single block */
1573 FT_FREE( font
->subfonts
[0] );
1576 cff_encoding_done( &font
->encoding
);
1577 cff_charset_done( &font
->charset
, font
->stream
);
1579 cff_subfont_done( memory
, &font
->top_font
);
1581 CFF_Done_FD_Select( &font
->fd_select
, font
->stream
);
1583 if (font
->font_info
!= NULL
)
1585 FT_FREE( font
->font_info
->version
);
1586 FT_FREE( font
->font_info
->notice
);
1587 FT_FREE( font
->font_info
->full_name
);
1588 FT_FREE( font
->font_info
->family_name
);
1589 FT_FREE( font
->font_info
->weight
);
1590 FT_FREE( font
->font_info
);
1593 FT_FREE( font
->global_subrs
);
1594 FT_FREE( font
->font_name
);