1 /***************************************************************************/
5 /* OpenType and CFF data/program tables loader (body). */
7 /* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, */
9 /* David Turner, Robert Wilhelm, and Werner Lemberg. */
11 /* This file is part of the FreeType project, and may only be used, */
12 /* modified, and distributed under the terms of the FreeType project */
13 /* license, LICENSE.TXT. By continuing to use, modify, or distribute */
14 /* this file you indicate that you have read the license and */
15 /* understand and accept it fully. */
17 /***************************************************************************/
21 #include FT_INTERNAL_DEBUG_H
22 #include FT_INTERNAL_OBJECTS_H
23 #include FT_INTERNAL_STREAM_H
24 #include FT_TRUETYPE_TAGS_H
25 #include FT_TYPE1_TABLES_H
35 static const FT_UShort cff_isoadobe_charset
[229] =
37 0, 1, 2, 3, 4, 5, 6, 7,
38 8, 9, 10, 11, 12, 13, 14, 15,
39 16, 17, 18, 19, 20, 21, 22, 23,
40 24, 25, 26, 27, 28, 29, 30, 31,
41 32, 33, 34, 35, 36, 37, 38, 39,
42 40, 41, 42, 43, 44, 45, 46, 47,
43 48, 49, 50, 51, 52, 53, 54, 55,
44 56, 57, 58, 59, 60, 61, 62, 63,
45 64, 65, 66, 67, 68, 69, 70, 71,
46 72, 73, 74, 75, 76, 77, 78, 79,
47 80, 81, 82, 83, 84, 85, 86, 87,
48 88, 89, 90, 91, 92, 93, 94, 95,
49 96, 97, 98, 99, 100, 101, 102, 103,
50 104, 105, 106, 107, 108, 109, 110, 111,
51 112, 113, 114, 115, 116, 117, 118, 119,
52 120, 121, 122, 123, 124, 125, 126, 127,
53 128, 129, 130, 131, 132, 133, 134, 135,
54 136, 137, 138, 139, 140, 141, 142, 143,
55 144, 145, 146, 147, 148, 149, 150, 151,
56 152, 153, 154, 155, 156, 157, 158, 159,
57 160, 161, 162, 163, 164, 165, 166, 167,
58 168, 169, 170, 171, 172, 173, 174, 175,
59 176, 177, 178, 179, 180, 181, 182, 183,
60 184, 185, 186, 187, 188, 189, 190, 191,
61 192, 193, 194, 195, 196, 197, 198, 199,
62 200, 201, 202, 203, 204, 205, 206, 207,
63 208, 209, 210, 211, 212, 213, 214, 215,
64 216, 217, 218, 219, 220, 221, 222, 223,
65 224, 225, 226, 227, 228
68 static const FT_UShort cff_expert_charset
[166] =
70 0, 1, 229, 230, 231, 232, 233, 234,
71 235, 236, 237, 238, 13, 14, 15, 99,
72 239, 240, 241, 242, 243, 244, 245, 246,
73 247, 248, 27, 28, 249, 250, 251, 252,
74 253, 254, 255, 256, 257, 258, 259, 260,
75 261, 262, 263, 264, 265, 266, 109, 110,
76 267, 268, 269, 270, 271, 272, 273, 274,
77 275, 276, 277, 278, 279, 280, 281, 282,
78 283, 284, 285, 286, 287, 288, 289, 290,
79 291, 292, 293, 294, 295, 296, 297, 298,
80 299, 300, 301, 302, 303, 304, 305, 306,
81 307, 308, 309, 310, 311, 312, 313, 314,
82 315, 316, 317, 318, 158, 155, 163, 319,
83 320, 321, 322, 323, 324, 325, 326, 150,
84 164, 169, 327, 328, 329, 330, 331, 332,
85 333, 334, 335, 336, 337, 338, 339, 340,
86 341, 342, 343, 344, 345, 346, 347, 348,
87 349, 350, 351, 352, 353, 354, 355, 356,
88 357, 358, 359, 360, 361, 362, 363, 364,
89 365, 366, 367, 368, 369, 370, 371, 372,
90 373, 374, 375, 376, 377, 378
93 static const FT_UShort cff_expertsubset_charset
[87] =
95 0, 1, 231, 232, 235, 236, 237, 238,
96 13, 14, 15, 99, 239, 240, 241, 242,
97 243, 244, 245, 246, 247, 248, 27, 28,
98 249, 250, 251, 253, 254, 255, 256, 257,
99 258, 259, 260, 261, 262, 263, 264, 265,
100 266, 109, 110, 267, 268, 269, 270, 272,
101 300, 301, 302, 305, 314, 315, 158, 155,
102 163, 320, 321, 322, 323, 324, 325, 326,
103 150, 164, 169, 327, 328, 329, 330, 331,
104 332, 333, 334, 335, 336, 337, 338, 339,
105 340, 341, 342, 343, 344, 345, 346
108 static const FT_UShort cff_standard_encoding
[256] =
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 0, 0, 0, 0, 0, 0, 0, 0,
114 1, 2, 3, 4, 5, 6, 7, 8,
115 9, 10, 11, 12, 13, 14, 15, 16,
116 17, 18, 19, 20, 21, 22, 23, 24,
117 25, 26, 27, 28, 29, 30, 31, 32,
118 33, 34, 35, 36, 37, 38, 39, 40,
119 41, 42, 43, 44, 45, 46, 47, 48,
120 49, 50, 51, 52, 53, 54, 55, 56,
121 57, 58, 59, 60, 61, 62, 63, 64,
122 65, 66, 67, 68, 69, 70, 71, 72,
123 73, 74, 75, 76, 77, 78, 79, 80,
124 81, 82, 83, 84, 85, 86, 87, 88,
125 89, 90, 91, 92, 93, 94, 95, 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, 0, 0, 0, 0, 0, 0, 0,
130 0, 96, 97, 98, 99, 100, 101, 102,
131 103, 104, 105, 106, 107, 108, 109, 110,
132 0, 111, 112, 113, 114, 0, 115, 116,
133 117, 118, 119, 120, 121, 122, 0, 123,
134 0, 124, 125, 126, 127, 128, 129, 130,
135 131, 0, 132, 133, 0, 134, 135, 136,
136 137, 0, 0, 0, 0, 0, 0, 0,
137 0, 0, 0, 0, 0, 0, 0, 0,
138 0, 138, 0, 139, 0, 0, 0, 0,
139 140, 141, 142, 143, 0, 0, 0, 0,
140 0, 144, 0, 0, 0, 145, 0, 0,
141 146, 147, 148, 149, 0, 0, 0, 0
144 static const FT_UShort cff_expert_encoding
[256] =
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 0, 0, 0, 0, 0, 0, 0, 0,
150 1, 229, 230, 0, 231, 232, 233, 234,
151 235, 236, 237, 238, 13, 14, 15, 99,
152 239, 240, 241, 242, 243, 244, 245, 246,
153 247, 248, 27, 28, 249, 250, 251, 252,
154 0, 253, 254, 255, 256, 257, 0, 0,
155 0, 258, 0, 0, 259, 260, 261, 262,
156 0, 0, 263, 264, 265, 0, 266, 109,
157 110, 267, 268, 269, 0, 270, 271, 272,
158 273, 274, 275, 276, 277, 278, 279, 280,
159 281, 282, 283, 284, 285, 286, 287, 288,
160 289, 290, 291, 292, 293, 294, 295, 296,
161 297, 298, 299, 300, 301, 302, 303, 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, 0, 0, 0, 0, 0, 0, 0,
166 0, 304, 305, 306, 0, 0, 307, 308,
167 309, 310, 311, 0, 312, 0, 0, 312,
168 0, 0, 314, 315, 0, 0, 316, 317,
169 318, 0, 0, 0, 158, 155, 163, 319,
170 320, 321, 322, 323, 324, 325, 0, 0,
171 326, 150, 164, 169, 327, 328, 329, 330,
172 331, 332, 333, 334, 335, 336, 337, 338,
173 339, 340, 341, 342, 343, 344, 345, 346,
174 347, 348, 349, 350, 351, 352, 353, 354,
175 355, 356, 357, 358, 359, 360, 361, 362,
176 363, 364, 365, 366, 367, 368, 369, 370,
177 371, 372, 373, 374, 375, 376, 377, 378
183 FT_LOCAL_DEF( FT_UShort
)
184 cff_get_standard_encoding( FT_UInt charcode
)
186 return (FT_UShort
)( charcode
< 256 ? cff_standard_encoding
[charcode
]
191 /*************************************************************************/
193 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
194 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
195 /* messages during execution. */
198 #define FT_COMPONENT trace_cffload
201 /* read an offset from the index's stream current position */
203 cff_index_read_offset( CFF_Index idx
,
207 FT_Stream stream
= idx
->stream
;
212 if ( !FT_STREAM_READ( tmp
, idx
->off_size
) )
217 for ( nn
= 0; nn
< idx
->off_size
; nn
++ )
218 result
= ( result
<< 8 ) | tmp
[nn
];
227 cff_index_init( CFF_Index idx
,
232 FT_Memory memory
= stream
->memory
;
236 FT_MEM_ZERO( idx
, sizeof ( *idx
) );
238 idx
->stream
= stream
;
239 idx
->start
= FT_STREAM_POS();
240 if ( !FT_READ_USHORT( count
) &&
247 /* there is at least one element; read the offset size, */
248 /* then access the offset table to compute the index's total size */
249 if ( FT_READ_BYTE( offsize
) )
252 if ( offsize
< 1 || offsize
> 4 )
254 error
= CFF_Err_Invalid_Table
;
259 idx
->off_size
= offsize
;
260 size
= (FT_ULong
)( count
+ 1 ) * offsize
;
262 idx
->data_offset
= idx
->start
+ 3 + size
;
264 if ( FT_STREAM_SKIP( size
- offsize
) )
267 size
= cff_index_read_offset( idx
, &error
);
273 error
= CFF_Err_Invalid_Table
;
277 idx
->data_size
= --size
;
282 if ( FT_FRAME_EXTRACT( size
, idx
->bytes
) )
288 if ( FT_STREAM_SKIP( size
) )
295 FT_FREE( idx
->offsets
);
302 cff_index_done( CFF_Index idx
)
306 FT_Stream stream
= idx
->stream
;
307 FT_Memory memory
= stream
->memory
;
311 FT_FRAME_RELEASE( idx
->bytes
);
313 FT_FREE( idx
->offsets
);
314 FT_MEM_ZERO( idx
, sizeof ( *idx
) );
320 cff_index_load_offsets( CFF_Index idx
)
322 FT_Error error
= CFF_Err_Ok
;
323 FT_Stream stream
= idx
->stream
;
324 FT_Memory memory
= stream
->memory
;
327 if ( idx
->count
> 0 && idx
->offsets
== NULL
)
329 FT_Byte offsize
= idx
->off_size
;
336 data_size
= (FT_ULong
)( idx
->count
+ 1 ) * offsize
;
338 if ( FT_NEW_ARRAY( idx
->offsets
, idx
->count
+ 1 ) ||
339 FT_STREAM_SEEK( idx
->start
+ 3 ) ||
340 FT_FRAME_ENTER( data_size
) )
344 p
= (FT_Byte
*)stream
->cursor
;
345 p_end
= p
+ data_size
;
350 for ( ; p
< p_end
; p
++, poff
++ )
355 for ( ; p
< p_end
; p
+= 2, poff
++ )
356 poff
[0] = FT_PEEK_USHORT( p
);
360 for ( ; p
< p_end
; p
+= 3, poff
++ )
361 poff
[0] = FT_PEEK_OFF3( p
);
365 for ( ; p
< p_end
; p
+= 4, poff
++ )
366 poff
[0] = FT_PEEK_ULONG( p
);
374 FT_FREE( idx
->offsets
);
380 /* Allocate a table containing pointers to an index's elements. */
381 /* The `pool' argument makes this function convert the index */
382 /* entries to C-style strings (this is, NULL-terminated). */
384 cff_index_get_pointers( CFF_Index idx
,
388 FT_Error error
= CFF_Err_Ok
;
389 FT_Memory memory
= idx
->stream
->memory
;
391 FT_Byte
* new_bytes
= NULL
;
396 if ( idx
->offsets
== NULL
)
398 error
= cff_index_load_offsets( idx
);
403 if ( idx
->count
> 0 &&
404 !FT_NEW_ARRAY( t
, idx
->count
+ 1 ) &&
405 ( !pool
|| !FT_ALLOC( new_bytes
,
406 idx
->data_size
+ idx
->count
) ) )
408 FT_ULong n
, cur_offset
;
410 FT_Byte
* org_bytes
= idx
->bytes
;
413 /* at this point, `idx->offsets' can't be NULL */
414 cur_offset
= idx
->offsets
[0] - 1;
417 if ( cur_offset
>= idx
->data_size
)
419 FT_TRACE0(( "cff_index_get_pointers:"
420 " invalid first offset value %d set to zero\n",
426 t
[0] = org_bytes
+ cur_offset
;
428 t
[0] = new_bytes
+ cur_offset
;
430 for ( n
= 1; n
<= idx
->count
; n
++ )
432 FT_ULong next_offset
= idx
->offsets
[n
] - 1;
435 /* empty slot + two sanity checks for invalid offset tables */
436 if ( next_offset
== 0 ||
437 next_offset
< cur_offset
||
438 ( next_offset
>= idx
->data_size
&& n
< idx
->count
) )
439 next_offset
= cur_offset
;
442 t
[n
] = org_bytes
+ next_offset
;
445 t
[n
] = new_bytes
+ next_offset
+ extra
;
447 if ( next_offset
!= cur_offset
)
449 FT_MEM_COPY( t
[n
- 1], org_bytes
+ cur_offset
, t
[n
] - t
[n
- 1] );
456 cur_offset
= next_offset
;
469 FT_LOCAL_DEF( FT_Error
)
470 cff_index_access_element( CFF_Index idx
,
473 FT_ULong
* pbyte_len
)
475 FT_Error error
= CFF_Err_Ok
;
478 if ( idx
&& idx
->count
> element
)
480 /* compute start and end offsets */
481 FT_Stream stream
= idx
->stream
;
482 FT_ULong off1
, off2
= 0;
485 /* load offsets from file or the offset table */
488 FT_ULong pos
= element
* idx
->off_size
;
491 if ( FT_STREAM_SEEK( idx
->start
+ 3 + pos
) )
494 off1
= cff_index_read_offset( idx
, &error
);
503 off2
= cff_index_read_offset( idx
, &error
);
505 while ( off2
== 0 && element
< idx
->count
);
508 else /* use offsets table */
510 off1
= idx
->offsets
[element
];
516 off2
= idx
->offsets
[element
];
518 } while ( off2
== 0 && element
< idx
->count
);
522 /* XXX: should check off2 does not exceed the end of this entry; */
523 /* at present, only truncate off2 at the end of this stream */
524 if ( off2
> stream
->size
+ 1 ||
525 idx
->data_offset
> stream
->size
- off2
+ 1 )
527 FT_ERROR(( "cff_index_access_element:"
528 " offset to next entry (%d)"
529 " exceeds the end of stream (%d)\n",
530 off2
, stream
->size
- idx
->data_offset
+ 1 ));
531 off2
= stream
->size
- idx
->data_offset
+ 1;
535 if ( off1
&& off2
> off1
)
537 *pbyte_len
= off2
- off1
;
541 /* this index was completely loaded in memory, that's easy */
542 *pbytes
= idx
->bytes
+ off1
- 1;
546 /* this index is still on disk/file, access it through a frame */
547 if ( FT_STREAM_SEEK( idx
->data_offset
+ off1
- 1 ) ||
548 FT_FRAME_EXTRACT( off2
- off1
, *pbytes
) )
554 /* empty index element */
560 error
= CFF_Err_Invalid_Argument
;
568 cff_index_forget_element( CFF_Index idx
,
571 if ( idx
->bytes
== 0 )
573 FT_Stream stream
= idx
->stream
;
576 FT_FRAME_RELEASE( *pbytes
);
581 /* get an entry from Name INDEX */
582 FT_LOCAL_DEF( FT_String
* )
583 cff_index_get_name( CFF_Font font
,
586 CFF_Index idx
= &font
->name_index
;
587 FT_Memory memory
= idx
->stream
->memory
;
594 error
= cff_index_access_element( idx
, element
, &bytes
, &byte_len
);
598 if ( !FT_ALLOC( name
, byte_len
+ 1 ) )
600 FT_MEM_COPY( name
, bytes
, byte_len
);
603 cff_index_forget_element( idx
, &bytes
);
610 /* get an entry from String INDEX */
611 FT_LOCAL_DEF( FT_String
* )
612 cff_index_get_string( CFF_Font font
,
615 return ( element
< font
->num_strings
)
616 ? (FT_String
*)font
->strings
[element
]
621 FT_LOCAL_DEF( FT_String
* )
622 cff_index_get_sid_string( CFF_Font font
,
625 /* value 0xFFFFU indicates a missing dictionary entry */
626 if ( sid
== 0xFFFFU
)
629 /* if it is not a standard string, return it */
631 return cff_index_get_string( font
, sid
- 391 );
633 /* CID-keyed CFF fonts don't have glyph names */
634 if ( !font
->psnames
)
637 /* this is a standard string */
638 return (FT_String
*)font
->psnames
->adobe_std_strings( sid
);
642 /*************************************************************************/
643 /*************************************************************************/
645 /*** FD Select table support ***/
647 /*************************************************************************/
648 /*************************************************************************/
652 CFF_Done_FD_Select( CFF_FDSelect fdselect
,
655 if ( fdselect
->data
)
656 FT_FRAME_RELEASE( fdselect
->data
);
658 fdselect
->data_size
= 0;
659 fdselect
->format
= 0;
660 fdselect
->range_count
= 0;
665 CFF_Load_FD_Select( CFF_FDSelect fdselect
,
676 if ( FT_STREAM_SEEK( offset
) || FT_READ_BYTE( format
) )
679 fdselect
->format
= format
;
680 fdselect
->cache_count
= 0; /* clear cache */
684 case 0: /* format 0, that's simple */
685 fdselect
->data_size
= num_glyphs
;
688 case 3: /* format 3, a tad more complex */
689 if ( FT_READ_USHORT( num_ranges
) )
692 fdselect
->data_size
= num_ranges
* 3 + 2;
695 if ( FT_FRAME_EXTRACT( fdselect
->data_size
, fdselect
->data
) )
699 default: /* hmm... that's wrong */
700 error
= CFF_Err_Invalid_File_Format
;
708 FT_LOCAL_DEF( FT_Byte
)
709 cff_fd_select_get( CFF_FDSelect fdselect
,
710 FT_UInt glyph_index
)
715 switch ( fdselect
->format
)
718 fd
= fdselect
->data
[glyph_index
];
722 /* first, compare to cache */
723 if ( (FT_UInt
)( glyph_index
- fdselect
->cache_first
) <
724 fdselect
->cache_count
)
726 fd
= fdselect
->cache_fd
;
730 /* then, lookup the ranges array */
732 FT_Byte
* p
= fdselect
->data
;
733 FT_Byte
* p_limit
= p
+ fdselect
->data_size
;
735 FT_UInt first
, limit
;
738 first
= FT_NEXT_USHORT( p
);
741 if ( glyph_index
< first
)
745 limit
= FT_NEXT_USHORT( p
);
747 if ( glyph_index
< limit
)
752 fdselect
->cache_first
= first
;
753 fdselect
->cache_count
= limit
-first
;
754 fdselect
->cache_fd
= fd2
;
759 } while ( p
< p_limit
);
771 /*************************************************************************/
772 /*************************************************************************/
774 /*** CFF font support ***/
776 /*************************************************************************/
777 /*************************************************************************/
780 cff_charset_compute_cids( CFF_Charset charset
,
784 FT_Error error
= CFF_Err_Ok
;
787 FT_UShort max_cid
= 0;
790 if ( charset
->max_cid
> 0 )
793 for ( i
= 0; i
< num_glyphs
; i
++ )
795 if ( charset
->sids
[i
] > max_cid
)
796 max_cid
= charset
->sids
[i
];
799 if ( FT_NEW_ARRAY( charset
->cids
, (FT_ULong
)max_cid
+ 1 ) )
802 /* When multiple GIDs map to the same CID, we choose the lowest */
803 /* GID. This is not described in any spec, but it matches the */
804 /* behaviour of recent Acroread versions. */
805 for ( j
= num_glyphs
- 1; j
>= 0 ; j
-- )
806 charset
->cids
[charset
->sids
[j
]] = (FT_UShort
)j
;
808 charset
->max_cid
= max_cid
;
809 charset
->num_glyphs
= num_glyphs
;
816 FT_LOCAL_DEF( FT_UInt
)
817 cff_charset_cid_to_gindex( CFF_Charset charset
,
823 if ( cid
<= charset
->max_cid
)
824 result
= charset
->cids
[cid
];
831 cff_charset_free_cids( CFF_Charset charset
,
834 FT_FREE( charset
->cids
);
835 charset
->max_cid
= 0;
840 cff_charset_done( CFF_Charset charset
,
843 FT_Memory memory
= stream
->memory
;
846 cff_charset_free_cids( charset
, memory
);
848 FT_FREE( charset
->sids
);
855 cff_charset_load( CFF_Charset charset
,
858 FT_ULong base_offset
,
862 FT_Memory memory
= stream
->memory
;
863 FT_Error error
= CFF_Err_Ok
;
867 /* If the the offset is greater than 2, we have to parse the */
874 charset
->offset
= base_offset
+ offset
;
876 /* Get the format of the table. */
877 if ( FT_STREAM_SEEK( charset
->offset
) ||
878 FT_READ_BYTE( charset
->format
) )
881 /* Allocate memory for sids. */
882 if ( FT_NEW_ARRAY( charset
->sids
, num_glyphs
) )
885 /* assign the .notdef glyph */
886 charset
->sids
[0] = 0;
888 switch ( charset
->format
)
891 if ( num_glyphs
> 0 )
893 if ( FT_FRAME_ENTER( ( num_glyphs
- 1 ) * 2 ) )
896 for ( j
= 1; j
< num_glyphs
; j
++ )
897 charset
->sids
[j
] = FT_GET_USHORT();
912 while ( j
< num_glyphs
)
914 /* Read the first glyph sid of the range. */
915 if ( FT_READ_USHORT( glyph_sid
) )
918 /* Read the number of glyphs in the range. */
919 if ( charset
->format
== 2 )
921 if ( FT_READ_USHORT( nleft
) )
926 if ( FT_READ_BYTE( nleft
) )
930 /* try to rescue some of the SIDs if `nleft' is too large */
931 if ( glyph_sid
> 0xFFFFL
- nleft
)
933 FT_ERROR(( "cff_charset_load: invalid SID range trimmed"
934 " nleft=%d -> %d\n", nleft
, 0xFFFFL
- glyph_sid
));
935 nleft
= ( FT_UInt
)( 0xFFFFL
- glyph_sid
);
938 /* Fill in the range of sids -- `nleft + 1' glyphs. */
939 for ( i
= 0; j
< num_glyphs
&& i
<= nleft
; i
++, j
++, glyph_sid
++ )
940 charset
->sids
[j
] = glyph_sid
;
946 FT_ERROR(( "cff_charset_load: invalid table format\n" ));
947 error
= CFF_Err_Invalid_File_Format
;
953 /* Parse default tables corresponding to offset == 0, 1, or 2. */
954 /* CFF specification intimates the following: */
956 /* In order to use a predefined charset, the following must be */
957 /* true: The charset constructed for the glyphs in the font's */
958 /* charstrings dictionary must match the predefined charset in */
959 /* the first num_glyphs. */
961 charset
->offset
= offset
; /* record charset type */
963 switch ( (FT_UInt
)offset
)
966 if ( num_glyphs
> 229 )
968 FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
969 "predefined charset (Adobe ISO-Latin)\n" ));
970 error
= CFF_Err_Invalid_File_Format
;
974 /* Allocate memory for sids. */
975 if ( FT_NEW_ARRAY( charset
->sids
, num_glyphs
) )
978 /* Copy the predefined charset into the allocated memory. */
979 FT_ARRAY_COPY( charset
->sids
, cff_isoadobe_charset
, num_glyphs
);
984 if ( num_glyphs
> 166 )
986 FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
987 "predefined charset (Adobe Expert)\n" ));
988 error
= CFF_Err_Invalid_File_Format
;
992 /* Allocate memory for sids. */
993 if ( FT_NEW_ARRAY( charset
->sids
, num_glyphs
) )
996 /* Copy the predefined charset into the allocated memory. */
997 FT_ARRAY_COPY( charset
->sids
, cff_expert_charset
, num_glyphs
);
1002 if ( num_glyphs
> 87 )
1004 FT_ERROR(( "cff_charset_load: implicit charset larger than\n"
1005 "predefined charset (Adobe Expert Subset)\n" ));
1006 error
= CFF_Err_Invalid_File_Format
;
1010 /* Allocate memory for sids. */
1011 if ( FT_NEW_ARRAY( charset
->sids
, num_glyphs
) )
1014 /* Copy the predefined charset into the allocated memory. */
1015 FT_ARRAY_COPY( charset
->sids
, cff_expertsubset_charset
, num_glyphs
);
1020 error
= CFF_Err_Invalid_File_Format
;
1025 /* we have to invert the `sids' array for subsetted CID-keyed fonts */
1027 error
= cff_charset_compute_cids( charset
, num_glyphs
, memory
);
1030 /* Clean up if there was an error. */
1033 FT_FREE( charset
->sids
);
1034 FT_FREE( charset
->cids
);
1035 charset
->format
= 0;
1036 charset
->offset
= 0;
1045 cff_encoding_done( CFF_Encoding encoding
)
1047 encoding
->format
= 0;
1048 encoding
->offset
= 0;
1049 encoding
->count
= 0;
1054 cff_encoding_load( CFF_Encoding encoding
,
1055 CFF_Charset charset
,
1058 FT_ULong base_offset
,
1061 FT_Error error
= CFF_Err_Ok
;
1064 FT_UShort glyph_sid
;
1068 /* Check for charset->sids. If we do not have this, we fail. */
1069 if ( !charset
->sids
)
1071 error
= CFF_Err_Invalid_File_Format
;
1075 /* Zero out the code to gid/sid mappings. */
1076 for ( j
= 0; j
< 256; j
++ )
1078 encoding
->sids
[j
] = 0;
1079 encoding
->codes
[j
] = 0;
1082 /* Note: The encoding table in a CFF font is indexed by glyph index; */
1083 /* the first encoded glyph index is 1. Hence, we read the character */
1084 /* code (`glyph_code') at index j and make the assignment: */
1086 /* encoding->codes[glyph_code] = j + 1 */
1088 /* We also make the assignment: */
1090 /* encoding->sids[glyph_code] = charset->sids[j + 1] */
1092 /* This gives us both a code to GID and a code to SID mapping. */
1096 encoding
->offset
= base_offset
+ offset
;
1098 /* we need to parse the table to determine its size */
1099 if ( FT_STREAM_SEEK( encoding
->offset
) ||
1100 FT_READ_BYTE( encoding
->format
) ||
1101 FT_READ_BYTE( count
) )
1104 switch ( encoding
->format
& 0x7F )
1111 /* By convention, GID 0 is always ".notdef" and is never */
1112 /* coded in the font. Hence, the number of codes found */
1113 /* in the table is `count+1'. */
1115 encoding
->count
= count
+ 1;
1117 if ( FT_FRAME_ENTER( count
) )
1120 p
= (FT_Byte
*)stream
->cursor
;
1122 for ( j
= 1; j
<= count
; j
++ )
1126 /* Make sure j is not too big. */
1127 if ( j
< num_glyphs
)
1129 /* Assign code to GID mapping. */
1130 encoding
->codes
[glyph_code
] = (FT_UShort
)j
;
1132 /* Assign code to SID mapping. */
1133 encoding
->sids
[glyph_code
] = charset
->sids
[j
];
1148 encoding
->count
= 0;
1150 /* Parse the Format1 ranges. */
1151 for ( j
= 0; j
< count
; j
++, i
+= nleft
)
1153 /* Read the first glyph code of the range. */
1154 if ( FT_READ_BYTE( glyph_code
) )
1157 /* Read the number of codes in the range. */
1158 if ( FT_READ_BYTE( nleft
) )
1161 /* Increment nleft, so we read `nleft + 1' codes/sids. */
1164 /* compute max number of character codes */
1165 if ( (FT_UInt
)nleft
> encoding
->count
)
1166 encoding
->count
= nleft
;
1168 /* Fill in the range of codes/sids. */
1169 for ( k
= i
; k
< nleft
+ i
; k
++, glyph_code
++ )
1171 /* Make sure k is not too big. */
1172 if ( k
< num_glyphs
&& glyph_code
< 256 )
1174 /* Assign code to GID mapping. */
1175 encoding
->codes
[glyph_code
] = (FT_UShort
)k
;
1177 /* Assign code to SID mapping. */
1178 encoding
->sids
[glyph_code
] = charset
->sids
[k
];
1183 /* simple check; one never knows what can be found in a font */
1184 if ( encoding
->count
> 256 )
1185 encoding
->count
= 256;
1190 FT_ERROR(( "cff_encoding_load: invalid table format\n" ));
1191 error
= CFF_Err_Invalid_File_Format
;
1195 /* Parse supplemental encodings, if any. */
1196 if ( encoding
->format
& 0x80 )
1201 /* count supplements */
1202 if ( FT_READ_BYTE( count
) )
1205 for ( j
= 0; j
< count
; j
++ )
1207 /* Read supplemental glyph code. */
1208 if ( FT_READ_BYTE( glyph_code
) )
1211 /* Read the SID associated with this glyph code. */
1212 if ( FT_READ_USHORT( glyph_sid
) )
1215 /* Assign code to SID mapping. */
1216 encoding
->sids
[glyph_code
] = glyph_sid
;
1218 /* First, look up GID which has been assigned to */
1219 /* SID glyph_sid. */
1220 for ( gindex
= 0; gindex
< num_glyphs
; gindex
++ )
1222 if ( charset
->sids
[gindex
] == glyph_sid
)
1224 encoding
->codes
[glyph_code
] = (FT_UShort
)gindex
;
1233 /* We take into account the fact a CFF font can use a predefined */
1234 /* encoding without containing all of the glyphs encoded by this */
1235 /* encoding (see the note at the end of section 12 in the CFF */
1236 /* specification). */
1238 switch ( (FT_UInt
)offset
)
1241 /* First, copy the code to SID mapping. */
1242 FT_ARRAY_COPY( encoding
->sids
, cff_standard_encoding
, 256 );
1246 /* First, copy the code to SID mapping. */
1247 FT_ARRAY_COPY( encoding
->sids
, cff_expert_encoding
, 256 );
1250 /* Construct code to GID mapping from code to SID mapping */
1253 encoding
->count
= 0;
1255 error
= cff_charset_compute_cids( charset
, num_glyphs
,
1260 for ( j
= 0; j
< 256; j
++ )
1262 FT_UInt sid
= encoding
->sids
[j
];
1267 gid
= cff_charset_cid_to_gindex( charset
, sid
);
1271 encoding
->codes
[j
] = (FT_UShort
)gid
;
1272 encoding
->count
= j
+ 1;
1276 encoding
->codes
[j
] = 0;
1277 encoding
->sids
[j
] = 0;
1283 FT_ERROR(( "cff_encoding_load: invalid table format\n" ));
1284 error
= CFF_Err_Invalid_File_Format
;
1291 /* Clean up if there was an error. */
1297 cff_subfont_load( CFF_SubFont font
,
1301 FT_ULong base_offset
,
1302 FT_Library library
)
1305 CFF_ParserRec parser
;
1306 FT_Byte
* dict
= NULL
;
1308 CFF_FontRecDict top
= &font
->font_dict
;
1309 CFF_Private priv
= &font
->private_dict
;
1312 cff_parser_init( &parser
, CFF_CODE_TOPDICT
, &font
->font_dict
, library
);
1315 FT_MEM_ZERO( top
, sizeof ( *top
) );
1317 top
->underline_position
= -100L << 16;
1318 top
->underline_thickness
= 50L << 16;
1319 top
->charstring_type
= 2;
1320 top
->font_matrix
.xx
= 0x10000L
;
1321 top
->font_matrix
.yy
= 0x10000L
;
1322 top
->cid_count
= 8720;
1324 /* we use the implementation specific SID value 0xFFFF to indicate */
1325 /* missing entries */
1326 top
->version
= 0xFFFFU
;
1327 top
->notice
= 0xFFFFU
;
1328 top
->copyright
= 0xFFFFU
;
1329 top
->full_name
= 0xFFFFU
;
1330 top
->family_name
= 0xFFFFU
;
1331 top
->weight
= 0xFFFFU
;
1332 top
->embedded_postscript
= 0xFFFFU
;
1334 top
->cid_registry
= 0xFFFFU
;
1335 top
->cid_ordering
= 0xFFFFU
;
1336 top
->cid_font_name
= 0xFFFFU
;
1338 error
= cff_index_access_element( idx
, font_index
, &dict
, &dict_len
);
1340 error
= cff_parser_run( &parser
, dict
, dict
+ dict_len
);
1342 cff_index_forget_element( idx
, &dict
);
1347 /* if it is a CID font, we stop there */
1348 if ( top
->cid_registry
!= 0xFFFFU
)
1351 /* parse the private dictionary, if any */
1352 if ( top
->private_offset
&& top
->private_size
)
1355 FT_MEM_ZERO( priv
, sizeof ( *priv
) );
1357 priv
->blue_shift
= 7;
1358 priv
->blue_fuzz
= 1;
1360 priv
->expansion_factor
= (FT_Fixed
)( 0.06 * 0x10000L
);
1361 priv
->blue_scale
= (FT_Fixed
)( 0.039625 * 0x10000L
* 1000 );
1363 cff_parser_init( &parser
, CFF_CODE_PRIVATE
, priv
, library
);
1365 if ( FT_STREAM_SEEK( base_offset
+ font
->font_dict
.private_offset
) ||
1366 FT_FRAME_ENTER( font
->font_dict
.private_size
) )
1369 error
= cff_parser_run( &parser
,
1370 (FT_Byte
*)stream
->cursor
,
1371 (FT_Byte
*)stream
->limit
);
1376 /* ensure that `num_blue_values' is even */
1377 priv
->num_blue_values
&= ~1;
1380 /* read the local subrs, if any */
1381 if ( priv
->local_subrs_offset
)
1383 if ( FT_STREAM_SEEK( base_offset
+ top
->private_offset
+
1384 priv
->local_subrs_offset
) )
1387 error
= cff_index_init( &font
->local_subrs_index
, stream
, 1 );
1391 error
= cff_index_get_pointers( &font
->local_subrs_index
,
1392 &font
->local_subrs
, NULL
);
1403 cff_subfont_done( FT_Memory memory
,
1404 CFF_SubFont subfont
)
1408 cff_index_done( &subfont
->local_subrs_index
);
1409 FT_FREE( subfont
->local_subrs
);
1414 FT_LOCAL_DEF( FT_Error
)
1415 cff_font_load( FT_Library library
,
1421 static const FT_Frame_Field cff_header_fields
[] =
1424 #define FT_STRUCTURE CFF_FontRec
1426 FT_FRAME_START( 4 ),
1427 FT_FRAME_BYTE( version_major
),
1428 FT_FRAME_BYTE( version_minor
),
1429 FT_FRAME_BYTE( header_size
),
1430 FT_FRAME_BYTE( absolute_offsize
),
1435 FT_Memory memory
= stream
->memory
;
1436 FT_ULong base_offset
;
1437 CFF_FontRecDict dict
;
1438 CFF_IndexRec string_index
;
1442 FT_ZERO( &string_index
);
1444 font
->stream
= stream
;
1445 font
->memory
= memory
;
1446 dict
= &font
->top_font
.font_dict
;
1447 base_offset
= FT_STREAM_POS();
1449 /* read CFF font header */
1450 if ( FT_STREAM_READ_FIELDS( cff_header_fields
, font
) )
1454 if ( font
->version_major
!= 1 ||
1455 font
->header_size
< 4 ||
1456 font
->absolute_offsize
> 4 )
1458 FT_TRACE2(( "[not a CFF font header]\n" ));
1459 error
= CFF_Err_Unknown_File_Format
;
1463 /* skip the rest of the header */
1464 if ( FT_STREAM_SKIP( font
->header_size
- 4 ) )
1467 /* read the name, top dict, string and global subrs index */
1468 if ( FT_SET_ERROR( cff_index_init( &font
->name_index
,
1470 FT_SET_ERROR( cff_index_init( &font
->font_dict_index
,
1472 FT_SET_ERROR( cff_index_init( &string_index
,
1474 FT_SET_ERROR( cff_index_init( &font
->global_subrs_index
,
1476 FT_SET_ERROR( cff_index_get_pointers( &string_index
,
1478 &font
->string_pool
) ) )
1481 font
->num_strings
= string_index
.count
;
1483 /* well, we don't really forget the `disabled' fonts... */
1484 font
->num_faces
= font
->name_index
.count
;
1485 if ( face_index
>= (FT_Int
)font
->num_faces
)
1487 FT_ERROR(( "cff_font_load: incorrect face index = %d\n",
1489 error
= CFF_Err_Invalid_Argument
;
1492 /* in case of a font format check, simply exit now */
1493 if ( face_index
< 0 )
1496 /* now, parse the top-level font dictionary */
1497 error
= cff_subfont_load( &font
->top_font
,
1498 &font
->font_dict_index
,
1506 if ( FT_STREAM_SEEK( base_offset
+ dict
->charstrings_offset
) )
1509 error
= cff_index_init( &font
->charstrings_index
, stream
, 0 );
1513 /* now, check for a CID font */
1514 if ( dict
->cid_registry
!= 0xFFFFU
)
1516 CFF_IndexRec fd_index
;
1521 /* this is a CID-keyed font, we must now allocate a table of */
1522 /* sub-fonts, then load each of them separately */
1523 if ( FT_STREAM_SEEK( base_offset
+ dict
->cid_fd_array_offset
) )
1526 error
= cff_index_init( &fd_index
, stream
, 0 );
1530 if ( fd_index
.count
> CFF_MAX_CID_FONTS
)
1532 FT_TRACE0(( "cff_font_load: FD array too large in CID font\n" ));
1536 /* allocate & read each font dict independently */
1537 font
->num_subfonts
= fd_index
.count
;
1538 if ( FT_NEW_ARRAY( sub
, fd_index
.count
) )
1541 /* set up pointer table */
1542 for ( idx
= 0; idx
< fd_index
.count
; idx
++ )
1543 font
->subfonts
[idx
] = sub
+ idx
;
1545 /* now load each subfont independently */
1546 for ( idx
= 0; idx
< fd_index
.count
; idx
++ )
1548 sub
= font
->subfonts
[idx
];
1549 error
= cff_subfont_load( sub
, &fd_index
, idx
,
1550 stream
, base_offset
, library
);
1555 /* now load the FD Select array */
1556 error
= CFF_Load_FD_Select( &font
->fd_select
,
1557 font
->charstrings_index
.count
,
1559 base_offset
+ dict
->cid_fd_select_offset
);
1562 cff_index_done( &fd_index
);
1568 font
->num_subfonts
= 0;
1570 /* read the charstrings index now */
1571 if ( dict
->charstrings_offset
== 0 )
1573 FT_ERROR(( "cff_font_load: no charstrings offset\n" ));
1574 error
= CFF_Err_Unknown_File_Format
;
1578 font
->num_glyphs
= font
->charstrings_index
.count
;
1580 error
= cff_index_get_pointers( &font
->global_subrs_index
,
1581 &font
->global_subrs
, NULL
);
1586 /* read the Charset and Encoding tables if available */
1587 if ( font
->num_glyphs
> 0 )
1589 FT_Bool invert
= FT_BOOL( dict
->cid_registry
!= 0xFFFFU
&& pure_cff
);
1592 error
= cff_charset_load( &font
->charset
, font
->num_glyphs
, stream
,
1593 base_offset
, dict
->charset_offset
, invert
);
1597 /* CID-keyed CFFs don't have an encoding */
1598 if ( dict
->cid_registry
== 0xFFFFU
)
1600 error
= cff_encoding_load( &font
->encoding
,
1605 dict
->encoding_offset
);
1611 /* get the font name (/CIDFontName for CID-keyed fonts, */
1612 /* /FontName otherwise) */
1613 font
->font_name
= cff_index_get_name( font
, face_index
);
1616 cff_index_done( &string_index
);
1622 FT_LOCAL_DEF( void )
1623 cff_font_done( CFF_Font font
)
1625 FT_Memory memory
= font
->memory
;
1629 cff_index_done( &font
->global_subrs_index
);
1630 cff_index_done( &font
->font_dict_index
);
1631 cff_index_done( &font
->name_index
);
1632 cff_index_done( &font
->charstrings_index
);
1634 /* release font dictionaries, but only if working with */
1635 /* a CID keyed CFF font */
1636 if ( font
->num_subfonts
> 0 )
1638 for ( idx
= 0; idx
< font
->num_subfonts
; idx
++ )
1639 cff_subfont_done( memory
, font
->subfonts
[idx
] );
1641 /* the subfonts array has been allocated as a single block */
1642 FT_FREE( font
->subfonts
[0] );
1645 cff_encoding_done( &font
->encoding
);
1646 cff_charset_done( &font
->charset
, font
->stream
);
1648 cff_subfont_done( memory
, &font
->top_font
);
1650 CFF_Done_FD_Select( &font
->fd_select
, font
->stream
);
1652 FT_FREE( font
->font_info
);
1654 FT_FREE( font
->font_name
);
1655 FT_FREE( font
->global_subrs
);
1656 FT_FREE( font
->strings
);
1657 FT_FREE( font
->string_pool
);