1 /****************************************************************************
2 *
3 * ttload.c
4 *
5 * Load the basic TrueType tables, i.e., tables that can be either in
6 * TTF or OTF fonts (body).
7 *
8 * Copyright (C) 1996-2023 by
9 * David Turner, Robert Wilhelm, and Werner Lemberg.
10 *
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.
16 *
17 */
18
19
20 #include <freetype/internal/ftdebug.h>
21 #include <freetype/internal/ftstream.h>
22 #include <freetype/tttags.h>
23 #include "ttload.h"
24
25 #include "sferrors.h"
26
27
28 /**************************************************************************
29 *
30 * The macro FT_COMPONENT is used in trace mode. It is an implicit
31 * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
32 * messages during execution.
33 */
34 #undef FT_COMPONENT
35 #define FT_COMPONENT ttload
36
37
38 /**************************************************************************
39 *
40 * @Function:
41 * tt_face_lookup_table
42 *
43 * @Description:
44 * Looks for a TrueType table by name.
45 *
46 * @Input:
47 * face ::
48 * A face object handle.
49 *
50 * tag ::
51 * The searched tag.
52 *
53 * @Return:
54 * A pointer to the table directory entry. 0 if not found.
55 */
56 FT_LOCAL_DEF( TT_Table )
57 tt_face_lookup_table( TT_Face face,
58 FT_ULong tag )
59 {
60 TT_Table entry;
61 TT_Table limit;
62 #ifdef FT_DEBUG_LEVEL_TRACE
63 FT_Bool zero_length = FALSE;
64 #endif
65
66
67 FT_TRACE4(( "tt_face_lookup_table: %p, `%c%c%c%c' -- ",
68 (void *)face,
69 (FT_Char)( tag >> 24 ),
70 (FT_Char)( tag >> 16 ),
71 (FT_Char)( tag >> 8 ),
72 (FT_Char)( tag ) ));
73
74 entry = face->dir_tables;
75 limit = entry + face->num_tables;
76
77 for ( ; entry < limit; entry++ )
78 {
79 /* For compatibility with Windows, we consider */
80 /* zero-length tables the same as missing tables. */
81 if ( entry->Tag == tag )
82 {
83 if ( entry->Length != 0 )
84 {
85 FT_TRACE4(( "found table.\n" ));
86 return entry;
87 }
88 #ifdef FT_DEBUG_LEVEL_TRACE
89 zero_length = TRUE;
90 #endif
91 }
92 }
93
94 #ifdef FT_DEBUG_LEVEL_TRACE
95 if ( zero_length )
96 FT_TRACE4(( "ignoring empty table\n" ));
97 else
98 FT_TRACE4(( "could not find table\n" ));
99 #endif
100
101 return NULL;
102 }
103
104
105 /**************************************************************************
106 *
107 * @Function:
108 * tt_face_goto_table
109 *
110 * @Description:
111 * Looks for a TrueType table by name, then seek a stream to it.
112 *
113 * @Input:
114 * face ::
115 * A face object handle.
116 *
117 * tag ::
118 * The searched tag.
119 *
120 * stream ::
121 * The stream to seek when the table is found.
122 *
123 * @Output:
124 * length ::
125 * The length of the table if found, undefined otherwise.
126 *
127 * @Return:
128 * FreeType error code. 0 means success.
129 */
130 FT_LOCAL_DEF( FT_Error )
131 tt_face_goto_table( TT_Face face,
132 FT_ULong tag,
133 FT_Stream stream,
134 FT_ULong* length )
135 {
136 TT_Table table;
137 FT_Error error;
138
139
140 table = tt_face_lookup_table( face, tag );
141 if ( table )
142 {
143 if ( length )
144 *length = table->Length;
145
146 if ( FT_STREAM_SEEK( table->Offset ) )
147 goto Exit;
148 }
149 else
150 error = FT_THROW( Table_Missing );
151
152 Exit:
153 return error;
154 }
155
156
157 /* Here, we */
158 /* */
159 /* - check that `num_tables' is valid (and adjust it if necessary); */
160 /* also return the number of valid table entries */
161 /* */
162 /* - look for a `head' table, check its size, and parse it to check */
163 /* whether its `magic' field is correctly set */
164 /* */
165 /* - errors (except errors returned by stream handling) */
166 /* */
167 /* SFNT_Err_Unknown_File_Format: */
168 /* no table is defined in directory, it is not sfnt-wrapped */
169 /* data */
170 /* SFNT_Err_Table_Missing: */
171 /* table directory is valid, but essential tables */
172 /* (head/bhed/SING) are missing */
173 /* */
174 static FT_Error
175 check_table_dir( SFNT_Header sfnt,
176 FT_Stream stream,
177 FT_UShort* valid )
178 {
179 FT_Error error;
180 FT_UShort nn, valid_entries = 0;
181 FT_UInt has_head = 0, has_sing = 0, has_meta = 0;
182 FT_ULong offset = sfnt->offset + 12;
183
184 static const FT_Frame_Field table_dir_entry_fields[] =
185 {
186 #undef FT_STRUCTURE
187 #define FT_STRUCTURE TT_TableRec
188
189 FT_FRAME_START( 16 ),
190 FT_FRAME_ULONG( Tag ),
191 FT_FRAME_ULONG( CheckSum ),
192 FT_FRAME_ULONG( Offset ),
193 FT_FRAME_ULONG( Length ),
194 FT_FRAME_END
195 };
196
197
198 if ( FT_STREAM_SEEK( offset ) )
199 goto Exit;
200
201 for ( nn = 0; nn < sfnt->num_tables; nn++ )
202 {
203 TT_TableRec table;
204
205
206 if ( FT_STREAM_READ_FIELDS( table_dir_entry_fields, &table ) )
207 {
208 FT_TRACE2(( "check_table_dir:"
209 " can read only %hu table%s in font (instead of %hu)\n",
210 nn, nn == 1 ? "" : "s", sfnt->num_tables ));
211 sfnt->num_tables = nn;
212 break;
213 }
214
215 /* we ignore invalid tables */
216
217 if ( table.Offset > stream->size )
218 {
219 FT_TRACE2(( "check_table_dir: table entry %hu invalid\n", nn ));
220 continue;
221 }
222 else if ( table.Length > stream->size - table.Offset )
223 {
224 /* Some tables have such a simple structure that clipping its */
225 /* contents is harmless. This also makes FreeType less sensitive */
226 /* to invalid table lengths (which programs like Acroread seem to */
227 /* ignore in general). */
228
229 if ( table.Tag == TTAG_hmtx ||
230 table.Tag == TTAG_vmtx )
231 valid_entries++;
232 else
233 {
234 FT_TRACE2(( "check_table_dir: table entry %hu invalid\n", nn ));
235 continue;
236 }
237 }
238 else
239 valid_entries++;
240
241 if ( table.Tag == TTAG_head || table.Tag == TTAG_bhed )
242 {
243 FT_UInt32 magic;
244
245
246 #ifndef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
247 if ( table.Tag == TTAG_head )
248 #endif
249 has_head = 1;
250
251 /*
252 * The table length should be 0x36, but certain font tools make it
253 * 0x38, so we will just check that it is greater.
254 *
255 * Note that according to the specification, the table must be
256 * padded to 32-bit lengths, but this doesn't apply to the value of
257 * its `Length' field!
258 *
259 */
260 if ( table.Length < 0x36 )
261 {
262 FT_TRACE2(( "check_table_dir:"
263 " `head' or `bhed' table too small\n" ));
264 error = FT_THROW( Table_Missing );
265 goto Exit;
266 }
267
268 if ( FT_STREAM_SEEK( table.Offset + 12 ) ||
269 FT_READ_ULONG( magic ) )
270 goto Exit;
271
272 if ( magic != 0x5F0F3CF5UL )
273 FT_TRACE2(( "check_table_dir:"
274 " invalid magic number in `head' or `bhed' table\n"));
275
276 if ( FT_STREAM_SEEK( offset + ( nn + 1 ) * 16 ) )
277 goto Exit;
278 }
279 else if ( table.Tag == TTAG_SING )
280 has_sing = 1;
281 else if ( table.Tag == TTAG_META )
282 has_meta = 1;
283 }
284
285 *valid = valid_entries;
286
287 if ( !valid_entries )
288 {
289 FT_TRACE2(( "check_table_dir: no valid tables found\n" ));
290 error = FT_THROW( Unknown_File_Format );
291 goto Exit;
292 }
293
294 /* if `sing' and `meta' tables are present, there is no `head' table */
295 if ( has_head || ( has_sing && has_meta ) )
296 {
297 error = FT_Err_Ok;
298 goto Exit;
299 }
300 else
301 {
302 FT_TRACE2(( "check_table_dir:" ));
303 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
304 FT_TRACE2(( " neither `head', `bhed', nor `sing' table found\n" ));
305 #else
306 FT_TRACE2(( " neither `head' nor `sing' table found\n" ));
307 #endif
308 error = FT_THROW( Table_Missing );
309 }
310
311 Exit:
312 return error;
313 }
314
315
316 /**************************************************************************
317 *
318 * @Function:
319 * tt_face_load_font_dir
320 *
321 * @Description:
322 * Loads the header of a SFNT font file.
323 *
324 * @Input:
325 * face ::
326 * A handle to the target face object.
327 *
328 * stream ::
329 * The input stream.
330 *
331 * @Output:
332 * sfnt ::
333 * The SFNT header.
334 *
335 * @Return:
336 * FreeType error code. 0 means success.
337 *
338 * @Note:
339 * The stream cursor must be at the beginning of the font directory.
340 */
341 FT_LOCAL_DEF( FT_Error )
342 tt_face_load_font_dir( TT_Face face,
343 FT_Stream stream )
344 {
345 SFNT_HeaderRec sfnt;
346 FT_Error error;
347 FT_Memory memory = stream->memory;
348 FT_UShort nn, valid_entries = 0;
349
350 static const FT_Frame_Field offset_table_fields[] =
351 {
352 #undef FT_STRUCTURE
353 #define FT_STRUCTURE SFNT_HeaderRec
354
355 FT_FRAME_START( 8 ),
356 FT_FRAME_USHORT( num_tables ),
357 FT_FRAME_USHORT( search_range ),
358 FT_FRAME_USHORT( entry_selector ),
359 FT_FRAME_USHORT( range_shift ),
360 FT_FRAME_END
361 };
362
363
364 FT_TRACE2(( "tt_face_load_font_dir: %p\n", (void *)face ));
365
366 /* read the offset table */
367
368 sfnt.offset = FT_STREAM_POS();
369
370 if ( FT_READ_ULONG( sfnt.format_tag ) ||
371 FT_STREAM_READ_FIELDS( offset_table_fields, &sfnt ) )
372 goto Exit;
373
374 /* many fonts don't have these fields set correctly */
375 #if 0
376 if ( sfnt.search_range != 1 << ( sfnt.entry_selector + 4 ) ||
377 sfnt.search_range + sfnt.range_shift != sfnt.num_tables << 4 )
378 return FT_THROW( Unknown_File_Format );
379 #endif
380
381 /* load the table directory */
382
383 FT_TRACE2(( "-- Number of tables: %10hu\n", sfnt.num_tables ));
384 FT_TRACE2(( "-- Format version: 0x%08lx\n", sfnt.format_tag ));
385
386 if ( sfnt.format_tag != TTAG_OTTO )
387 {
388 /* check first */
389 error = check_table_dir( &sfnt, stream, &valid_entries );
390 if ( error )
391 {
392 FT_TRACE2(( "tt_face_load_font_dir:"
393 " invalid table directory for TrueType\n" ));
394 goto Exit;
395 }
396 }
397 else
398 {
399 valid_entries = sfnt.num_tables;
400 if ( !valid_entries )
401 {
402 FT_TRACE2(( "tt_face_load_font_dir: no valid tables found\n" ));
403 error = FT_THROW( Unknown_File_Format );
404 goto Exit;
405 }
406 }
407
408 face->num_tables = valid_entries;
409 face->format_tag = sfnt.format_tag;
410
411 if ( FT_QNEW_ARRAY( face->dir_tables, face->num_tables ) )
412 goto Exit;
413
414 if ( FT_STREAM_SEEK( sfnt.offset + 12 ) ||
415 FT_FRAME_ENTER( sfnt.num_tables * 16L ) )
416 goto Exit;
417
418 FT_TRACE2(( "\n" ));
419 FT_TRACE2(( " tag offset length checksum\n" ));
420 FT_TRACE2(( " ----------------------------------\n" ));
421
422 valid_entries = 0;
423 for ( nn = 0; nn < sfnt.num_tables; nn++ )
424 {
425 TT_TableRec entry;
426 FT_UShort i;
427 FT_Bool duplicate;
428
429
430 entry.Tag = FT_GET_TAG4();
431 entry.CheckSum = FT_GET_ULONG();
432 entry.Offset = FT_GET_ULONG();
433 entry.Length = FT_GET_ULONG();
434
435 /* ignore invalid tables that can't be sanitized */
436
437 if ( entry.Offset > stream->size )
438 continue;
439 else if ( entry.Length > stream->size - entry.Offset )
440 {
441 if ( entry.Tag == TTAG_hmtx ||
442 entry.Tag == TTAG_vmtx )
443 {
444 #ifdef FT_DEBUG_LEVEL_TRACE
445 FT_ULong old_length = entry.Length;
446 #endif
447
448
449 /* make metrics table length a multiple of 4 */
450 entry.Length = ( stream->size - entry.Offset ) & ~3U;
451
452 FT_TRACE2(( " %c%c%c%c %08lx %08lx %08lx"
453 " (sanitized; original length %08lx)",
454 (FT_Char)( entry.Tag >> 24 ),
455 (FT_Char)( entry.Tag >> 16 ),
456 (FT_Char)( entry.Tag >> 8 ),
457 (FT_Char)( entry.Tag ),
458 entry.Offset,
459 entry.Length,
460 entry.CheckSum,
461 old_length ));
462 }
463 else
464 continue;
465 }
466 #ifdef FT_DEBUG_LEVEL_TRACE
467 else
468 FT_TRACE2(( " %c%c%c%c %08lx %08lx %08lx",
469 (FT_Char)( entry.Tag >> 24 ),
470 (FT_Char)( entry.Tag >> 16 ),
471 (FT_Char)( entry.Tag >> 8 ),
472 (FT_Char)( entry.Tag ),
473 entry.Offset,
474 entry.Length,
475 entry.CheckSum ));
476 #endif
477
478 /* ignore duplicate tables – the first one wins */
479 duplicate = 0;
480 for ( i = 0; i < valid_entries; i++ )
481 {
482 if ( face->dir_tables[i].Tag == entry.Tag )
483 {
484 duplicate = 1;
485 break;
486 }
487 }
488 if ( duplicate )
489 {
490 FT_TRACE2(( " (duplicate, ignored)\n" ));
491 continue;
492 }
493 else
494 {
495 FT_TRACE2(( "\n" ));
496
497 /* we finally have a valid entry */
498 face->dir_tables[valid_entries++] = entry;
499 }
500 }
501
502 /* final adjustment to number of tables */
503 face->num_tables = valid_entries;
504
505 FT_FRAME_EXIT();
506
507 if ( !valid_entries )
508 {
509 FT_TRACE2(( "tt_face_load_font_dir: no valid tables found\n" ));
510 error = FT_THROW( Unknown_File_Format );
511 goto Exit;
512 }
513
514 FT_TRACE2(( "table directory loaded\n" ));
515 FT_TRACE2(( "\n" ));
516
517 Exit:
518 return error;
519 }
520
521
522 /**************************************************************************
523 *
524 * @Function:
525 * tt_face_load_any
526 *
527 * @Description:
528 * Loads any font table into client memory.
529 *
530 * @Input:
531 * face ::
532 * The face object to look for.
533 *
534 * tag ::
535 * The tag of table to load. Use the value 0 if you want
536 * to access the whole font file, else set this parameter
537 * to a valid TrueType table tag that you can forge with
538 * the MAKE_TT_TAG macro.
539 *
540 * offset ::
541 * The starting offset in the table (or the file if
542 * tag == 0).
543 *
544 * length ::
545 * The address of the decision variable:
546 *
547 * If length == NULL:
548 * Loads the whole table. Returns an error if
549 * `offset' == 0!
550 *
551 * If *length == 0:
552 * Exits immediately; returning the length of the given
553 * table or of the font file, depending on the value of
554 * `tag'.
555 *
556 * If *length != 0:
557 * Loads the next `length' bytes of table or font,
558 * starting at offset `offset' (in table or font too).
559 *
560 * @Output:
561 * buffer ::
562 * The address of target buffer.
563 *
564 * @Return:
565 * FreeType error code. 0 means success.
566 */
567 FT_LOCAL_DEF( FT_Error )
568 tt_face_load_any( TT_Face face,
569 FT_ULong tag,
570 FT_Long offset,
571 FT_Byte* buffer,
572 FT_ULong* length )
573 {
574 FT_Error error;
575 FT_Stream stream;
576 TT_Table table;
577 FT_ULong size;
578
579
580 if ( tag != 0 )
581 {
582 /* look for tag in font directory */
583 table = tt_face_lookup_table( face, tag );
584 if ( !table )
585 {
586 error = FT_THROW( Table_Missing );
587 goto Exit;
588 }
589
590 offset += table->Offset;
591 size = table->Length;
592 }
593 else
594 /* tag == 0 -- the user wants to access the font file directly */
595 size = face->root.stream->size;
596
597 if ( length && *length == 0 )
598 {
599 *length = size;
600
601 return FT_Err_Ok;
602 }
603
604 if ( length )
605 size = *length;
606
607 stream = face->root.stream;
608 /* the `if' is syntactic sugar for picky compilers */
609 if ( FT_STREAM_READ_AT( offset, buffer, size ) )
610 goto Exit;
611
612 Exit:
613 return error;
614 }
615
616
617 /**************************************************************************
618 *
619 * @Function:
620 * tt_face_load_generic_header
621 *
622 * @Description:
623 * Loads the TrueType table `head' or `bhed'.
624 *
625 * @Input:
626 * face ::
627 * A handle to the target face object.
628 *
629 * stream ::
630 * The input stream.
631 *
632 * @Return:
633 * FreeType error code. 0 means success.
634 */
635 static FT_Error
636 tt_face_load_generic_header( TT_Face face,
637 FT_Stream stream,
638 FT_ULong tag )
639 {
640 FT_Error error;
641 TT_Header* header;
642
643 static const FT_Frame_Field header_fields[] =
644 {
645 #undef FT_STRUCTURE
646 #define FT_STRUCTURE TT_Header
647
648 FT_FRAME_START( 54 ),
649 FT_FRAME_ULONG ( Table_Version ),
650 FT_FRAME_ULONG ( Font_Revision ),
651 FT_FRAME_LONG ( CheckSum_Adjust ),
652 FT_FRAME_LONG ( Magic_Number ),
653 FT_FRAME_USHORT( Flags ),
654 FT_FRAME_USHORT( Units_Per_EM ),
655 FT_FRAME_ULONG ( Created[0] ),
656 FT_FRAME_ULONG ( Created[1] ),
657 FT_FRAME_ULONG ( Modified[0] ),
658 FT_FRAME_ULONG ( Modified[1] ),
659 FT_FRAME_SHORT ( xMin ),
660 FT_FRAME_SHORT ( yMin ),
661 FT_FRAME_SHORT ( xMax ),
662 FT_FRAME_SHORT ( yMax ),
663 FT_FRAME_USHORT( Mac_Style ),
664 FT_FRAME_USHORT( Lowest_Rec_PPEM ),
665 FT_FRAME_SHORT ( Font_Direction ),
666 FT_FRAME_SHORT ( Index_To_Loc_Format ),
667 FT_FRAME_SHORT ( Glyph_Data_Format ),
668 FT_FRAME_END
669 };
670
671
672 error = face->goto_table( face, tag, stream, 0 );
673 if ( error )
674 goto Exit;
675
676 header = &face->header;
677
678 if ( FT_STREAM_READ_FIELDS( header_fields, header ) )
679 goto Exit;
680
681 FT_TRACE3(( "Units per EM: %4hu\n", header->Units_Per_EM ));
682 FT_TRACE3(( "IndexToLoc: %4hd\n", header->Index_To_Loc_Format ));
683
684 Exit:
685 return error;
686 }
687
688
689 FT_LOCAL_DEF( FT_Error )
690 tt_face_load_head( TT_Face face,
691 FT_Stream stream )
692 {
693 return tt_face_load_generic_header( face, stream, TTAG_head );
694 }
695
696
697 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
698
699 FT_LOCAL_DEF( FT_Error )
700 tt_face_load_bhed( TT_Face face,
701 FT_Stream stream )
702 {
703 return tt_face_load_generic_header( face, stream, TTAG_bhed );
704 }
705
706 #endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
707
708
709 /**************************************************************************
710 *
711 * @Function:
712 * tt_face_load_maxp
713 *
714 * @Description:
715 * Loads the maximum profile into a face object.
716 *
717 * @Input:
718 * face ::
719 * A handle to the target face object.
720 *
721 * stream ::
722 * The input stream.
723 *
724 * @Return:
725 * FreeType error code. 0 means success.
726 */
727 FT_LOCAL_DEF( FT_Error )
728 tt_face_load_maxp( TT_Face face,
729 FT_Stream stream )
730 {
731 FT_Error error;
732 TT_MaxProfile* maxProfile = &face->max_profile;
733
734 static const FT_Frame_Field maxp_fields[] =
735 {
736 #undef FT_STRUCTURE
737 #define FT_STRUCTURE TT_MaxProfile
738
739 FT_FRAME_START( 6 ),
740 FT_FRAME_LONG ( version ),
741 FT_FRAME_USHORT( numGlyphs ),
742 FT_FRAME_END
743 };
744
745 static const FT_Frame_Field maxp_fields_extra[] =
746 {
747 FT_FRAME_START( 26 ),
748 FT_FRAME_USHORT( maxPoints ),
749 FT_FRAME_USHORT( maxContours ),
750 FT_FRAME_USHORT( maxCompositePoints ),
751 FT_FRAME_USHORT( maxCompositeContours ),
752 FT_FRAME_USHORT( maxZones ),
753 FT_FRAME_USHORT( maxTwilightPoints ),
754 FT_FRAME_USHORT( maxStorage ),
755 FT_FRAME_USHORT( maxFunctionDefs ),
756 FT_FRAME_USHORT( maxInstructionDefs ),
757 FT_FRAME_USHORT( maxStackElements ),
758 FT_FRAME_USHORT( maxSizeOfInstructions ),
759 FT_FRAME_USHORT( maxComponentElements ),
760 FT_FRAME_USHORT( maxComponentDepth ),
761 FT_FRAME_END
762 };
763
764
765 error = face->goto_table( face, TTAG_maxp, stream, 0 );
766 if ( error )
767 goto Exit;
768
769 if ( FT_STREAM_READ_FIELDS( maxp_fields, maxProfile ) )
770 goto Exit;
771
772 maxProfile->maxPoints = 0;
773 maxProfile->maxContours = 0;
774 maxProfile->maxCompositePoints = 0;
775 maxProfile->maxCompositeContours = 0;
776 maxProfile->maxZones = 0;
777 maxProfile->maxTwilightPoints = 0;
778 maxProfile->maxStorage = 0;
779 maxProfile->maxFunctionDefs = 0;
780 maxProfile->maxInstructionDefs = 0;
781 maxProfile->maxStackElements = 0;
782 maxProfile->maxSizeOfInstructions = 0;
783 maxProfile->maxComponentElements = 0;
784 maxProfile->maxComponentDepth = 0;
785
786 if ( maxProfile->version >= 0x10000L )
787 {
788 if ( FT_STREAM_READ_FIELDS( maxp_fields_extra, maxProfile ) )
789 goto Exit;
790
791 /* XXX: an adjustment that is necessary to load certain */
792 /* broken fonts like `Keystrokes MT' :-( */
793 /* */
794 /* We allocate 64 function entries by default when */
795 /* the maxFunctionDefs value is smaller. */
796
797 if ( maxProfile->maxFunctionDefs < 64 )
798 maxProfile->maxFunctionDefs = 64;
799
800 /* we add 4 phantom points later */
801 if ( maxProfile->maxTwilightPoints > ( 0xFFFFU - 4 ) )
802 {
803 FT_TRACE0(( "tt_face_load_maxp:"
804 " too much twilight points in `maxp' table;\n" ));
805 FT_TRACE0(( " "
806 " some glyphs might be rendered incorrectly\n" ));
807
808 maxProfile->maxTwilightPoints = 0xFFFFU - 4;
809 }
810 }
811
812 FT_TRACE3(( "numGlyphs: %hu\n", maxProfile->numGlyphs ));
813
814 Exit:
815 return error;
816 }
817
818
819 /**************************************************************************
820 *
821 * @Function:
822 * tt_face_load_name
823 *
824 * @Description:
825 * Loads the name records.
826 *
827 * @Input:
828 * face ::
829 * A handle to the target face object.
830 *
831 * stream ::
832 * The input stream.
833 *
834 * @Return:
835 * FreeType error code. 0 means success.
836 */
837 FT_LOCAL_DEF( FT_Error )
838 tt_face_load_name( TT_Face face,
839 FT_Stream stream )
840 {
841 FT_Error error;
842 FT_Memory memory = stream->memory;
843 FT_ULong table_pos, table_len;
844 FT_ULong storage_start, storage_limit;
845 TT_NameTable table;
846 TT_Name names = NULL;
847 TT_LangTag langTags = NULL;
848
849 static const FT_Frame_Field name_table_fields[] =
850 {
851 #undef FT_STRUCTURE
852 #define FT_STRUCTURE TT_NameTableRec
853
854 FT_FRAME_START( 6 ),
855 FT_FRAME_USHORT( format ),
856 FT_FRAME_USHORT( numNameRecords ),
857 FT_FRAME_USHORT( storageOffset ),
858 FT_FRAME_END
859 };
860
861 static const FT_Frame_Field name_record_fields[] =
862 {
863 #undef FT_STRUCTURE
864 #define FT_STRUCTURE TT_NameRec
865
866 /* no FT_FRAME_START */
867 FT_FRAME_USHORT( platformID ),
868 FT_FRAME_USHORT( encodingID ),
869 FT_FRAME_USHORT( languageID ),
870 FT_FRAME_USHORT( nameID ),
871 FT_FRAME_USHORT( stringLength ),
872 FT_FRAME_USHORT( stringOffset ),
873 FT_FRAME_END
874 };
875
876 static const FT_Frame_Field langTag_record_fields[] =
877 {
878 #undef FT_STRUCTURE
879 #define FT_STRUCTURE TT_LangTagRec
880
881 /* no FT_FRAME_START */
882 FT_FRAME_USHORT( stringLength ),
883 FT_FRAME_USHORT( stringOffset ),
884 FT_FRAME_END
885 };
886
887
888 table = &face->name_table;
889 table->stream = stream;
890
891 error = face->goto_table( face, TTAG_name, stream, &table_len );
892 if ( error )
893 goto Exit;
894
895 table_pos = FT_STREAM_POS();
896
897 if ( FT_STREAM_READ_FIELDS( name_table_fields, table ) )
898 goto Exit;
899
900 /* Some popular Asian fonts have an invalid `storageOffset' value (it */
901 /* should be at least `6 + 12*numNameRecords'). However, the string */
902 /* offsets, computed as `storageOffset + entry->stringOffset', are */
903 /* valid pointers within the name table... */
904 /* */
905 /* We thus can't check `storageOffset' right now. */
906 /* */
907 storage_start = table_pos + 6 + 12 * table->numNameRecords;
908 storage_limit = table_pos + table_len;
909
910 if ( storage_start > storage_limit )
911 {
912 FT_ERROR(( "tt_face_load_name: invalid `name' table\n" ));
913 error = FT_THROW( Name_Table_Missing );
914 goto Exit;
915 }
916
917 /* `name' format 1 contains additional language tag records, */
918 /* which we load first */
919 if ( table->format == 1 )
920 {
921 if ( FT_STREAM_SEEK( storage_start ) ||
922 FT_READ_USHORT( table->numLangTagRecords ) )
923 goto Exit;
924
925 storage_start += 2 + 4 * table->numLangTagRecords;
926
927 /* allocate language tag records array */
928 if ( FT_QNEW_ARRAY( langTags, table->numLangTagRecords ) ||
929 FT_FRAME_ENTER( table->numLangTagRecords * 4 ) )
930 goto Exit;
931
932 /* load language tags */
933 {
934 TT_LangTag entry = langTags;
935 TT_LangTag limit = FT_OFFSET( entry, table->numLangTagRecords );
936
937
938 for ( ; entry < limit; entry++ )
939 {
940 (void)FT_STREAM_READ_FIELDS( langTag_record_fields, entry );
941
942 /* check that the langTag string is within the table */
943 entry->stringOffset += table_pos + table->storageOffset;
944 if ( entry->stringOffset < storage_start ||
945 entry->stringOffset + entry->stringLength > storage_limit )
946 {
947 /* invalid entry; ignore it */
948 entry->stringLength = 0;
949 }
950
951 /* mark the string as not yet loaded */
952 entry->string = NULL;
953 }
954
955 table->langTags = langTags;
956 langTags = NULL;
957 }
958
959 FT_FRAME_EXIT();
960
961 (void)FT_STREAM_SEEK( table_pos + 6 );
962 }
963
964 /* allocate name records array */
965 if ( FT_QNEW_ARRAY( names, table->numNameRecords ) ||
966 FT_FRAME_ENTER( table->numNameRecords * 12 ) )
967 goto Exit;
968
969 /* load name records */
970 {
971 TT_Name entry = names;
972 FT_UInt count = table->numNameRecords;
973 FT_UInt valid = 0;
974
975
976 for ( ; count > 0; count-- )
977 {
978 if ( FT_STREAM_READ_FIELDS( name_record_fields, entry ) )
979 continue;
980
981 /* check that the name is not empty */
982 if ( entry->stringLength == 0 )
983 continue;
984
985 /* check that the name string is within the table */
986 entry->stringOffset += table_pos + table->storageOffset;
987 if ( entry->stringOffset < storage_start ||
988 entry->stringOffset + entry->stringLength > storage_limit )
989 {
990 /* invalid entry; ignore it */
991 continue;
992 }
993
994 /* assure that we have a valid language tag ID, and */
995 /* that the corresponding langTag entry is valid, too */
996 if ( table->format == 1 && entry->languageID >= 0x8000U )
997 {
998 if ( entry->languageID - 0x8000U >= table->numLangTagRecords ||
999 !table->langTags[entry->languageID - 0x8000U].stringLength )
1000 {
1001 /* invalid entry; ignore it */
1002 continue;
1003 }
1004 }
1005
1006 /* mark the string as not yet converted */
1007 entry->string = NULL;
1008
1009 valid++;
1010 entry++;
1011 }
1012
1013 /* reduce array size to the actually used elements */
1014 FT_MEM_QRENEW_ARRAY( names,
1015 table->numNameRecords,
1016 valid );
1017 table->names = names;
1018 names = NULL;
1019 table->numNameRecords = valid;
1020 }
1021
1022 FT_FRAME_EXIT();
1023
1024 /* everything went well, update face->num_names */
1025 face->num_names = (FT_UShort)table->numNameRecords;
1026
1027 Exit:
1028 FT_FREE( names );
1029 FT_FREE( langTags );
1030 return error;
1031 }
1032
1033
1034 /**************************************************************************
1035 *
1036 * @Function:
1037 * tt_face_free_name
1038 *
1039 * @Description:
1040 * Frees the name records.
1041 *
1042 * @Input:
1043 * face ::
1044 * A handle to the target face object.
1045 */
1046 FT_LOCAL_DEF( void )
1047 tt_face_free_name( TT_Face face )
1048 {
1049 FT_Memory memory = face->root.driver->root.memory;
1050 TT_NameTable table = &face->name_table;
1051
1052
1053 if ( table->names )
1054 {
1055 TT_Name entry = table->names;
1056 TT_Name limit = entry + table->numNameRecords;
1057
1058
1059 for ( ; entry < limit; entry++ )
1060 FT_FREE( entry->string );
1061
1062 FT_FREE( table->names );
1063 }
1064
1065 if ( table->langTags )
1066 {
1067 TT_LangTag entry = table->langTags;
1068 TT_LangTag limit = entry + table->numLangTagRecords;
1069
1070
1071 for ( ; entry < limit; entry++ )
1072 FT_FREE( entry->string );
1073
1074 FT_FREE( table->langTags );
1075 }
1076
1077 table->numNameRecords = 0;
1078 table->numLangTagRecords = 0;
1079 table->format = 0;
1080 table->storageOffset = 0;
1081 }
1082
1083
1084 /**************************************************************************
1085 *
1086 * @Function:
1087 * tt_face_load_cmap
1088 *
1089 * @Description:
1090 * Loads the cmap directory in a face object. The cmaps themselves
1091 * are loaded on demand in the `ttcmap.c' module.
1092 *
1093 * @Input:
1094 * face ::
1095 * A handle to the target face object.
1096 *
1097 * stream ::
1098 * A handle to the input stream.
1099 *
1100 * @Return:
1101 * FreeType error code. 0 means success.
1102 */
1103
1104 FT_LOCAL_DEF( FT_Error )
1105 tt_face_load_cmap( TT_Face face,
1106 FT_Stream stream )
1107 {
1108 FT_Error error;
1109
1110
1111 error = face->goto_table( face, TTAG_cmap, stream, &face->cmap_size );
1112 if ( error )
1113 goto Exit;
1114
1115 if ( FT_FRAME_EXTRACT( face->cmap_size, face->cmap_table ) )
1116 face->cmap_size = 0;
1117
1118 Exit:
1119 return error;
1120 }
1121
1122
1123
1124 /**************************************************************************
1125 *
1126 * @Function:
1127 * tt_face_load_os2
1128 *
1129 * @Description:
1130 * Loads the OS2 table.
1131 *
1132 * @Input:
1133 * face ::
1134 * A handle to the target face object.
1135 *
1136 * stream ::
1137 * A handle to the input stream.
1138 *
1139 * @Return:
1140 * FreeType error code. 0 means success.
1141 */
1142 FT_LOCAL_DEF( FT_Error )
1143 tt_face_load_os2( TT_Face face,
1144 FT_Stream stream )
1145 {
1146 FT_Error error;
1147 TT_OS2* os2;
1148
1149 static const FT_Frame_Field os2_fields[] =
1150 {
1151 #undef FT_STRUCTURE
1152 #define FT_STRUCTURE TT_OS2
1153
1154 FT_FRAME_START( 78 ),
1155 FT_FRAME_USHORT( version ),
1156 FT_FRAME_SHORT ( xAvgCharWidth ),
1157 FT_FRAME_USHORT( usWeightClass ),
1158 FT_FRAME_USHORT( usWidthClass ),
1159 FT_FRAME_SHORT ( fsType ),
1160 FT_FRAME_SHORT ( ySubscriptXSize ),
1161 FT_FRAME_SHORT ( ySubscriptYSize ),
1162 FT_FRAME_SHORT ( ySubscriptXOffset ),
1163 FT_FRAME_SHORT ( ySubscriptYOffset ),
1164 FT_FRAME_SHORT ( ySuperscriptXSize ),
1165 FT_FRAME_SHORT ( ySuperscriptYSize ),
1166 FT_FRAME_SHORT ( ySuperscriptXOffset ),
1167 FT_FRAME_SHORT ( ySuperscriptYOffset ),
1168 FT_FRAME_SHORT ( yStrikeoutSize ),
1169 FT_FRAME_SHORT ( yStrikeoutPosition ),
1170 FT_FRAME_SHORT ( sFamilyClass ),
1171 FT_FRAME_BYTE ( panose[0] ),
1172 FT_FRAME_BYTE ( panose[1] ),
1173 FT_FRAME_BYTE ( panose[2] ),
1174 FT_FRAME_BYTE ( panose[3] ),
1175 FT_FRAME_BYTE ( panose[4] ),
1176 FT_FRAME_BYTE ( panose[5] ),
1177 FT_FRAME_BYTE ( panose[6] ),
1178 FT_FRAME_BYTE ( panose[7] ),
1179 FT_FRAME_BYTE ( panose[8] ),
1180 FT_FRAME_BYTE ( panose[9] ),
1181 FT_FRAME_ULONG ( ulUnicodeRange1 ),
1182 FT_FRAME_ULONG ( ulUnicodeRange2 ),
1183 FT_FRAME_ULONG ( ulUnicodeRange3 ),
1184 FT_FRAME_ULONG ( ulUnicodeRange4 ),
1185 FT_FRAME_BYTE ( achVendID[0] ),
1186 FT_FRAME_BYTE ( achVendID[1] ),
1187 FT_FRAME_BYTE ( achVendID[2] ),
1188 FT_FRAME_BYTE ( achVendID[3] ),
1189
1190 FT_FRAME_USHORT( fsSelection ),
1191 FT_FRAME_USHORT( usFirstCharIndex ),
1192 FT_FRAME_USHORT( usLastCharIndex ),
1193 FT_FRAME_SHORT ( sTypoAscender ),
1194 FT_FRAME_SHORT ( sTypoDescender ),
1195 FT_FRAME_SHORT ( sTypoLineGap ),
1196 FT_FRAME_USHORT( usWinAscent ),
1197 FT_FRAME_USHORT( usWinDescent ),
1198 FT_FRAME_END
1199 };
1200
1201 /* `OS/2' version 1 and newer */
1202 static const FT_Frame_Field os2_fields_extra1[] =
1203 {
1204 FT_FRAME_START( 8 ),
1205 FT_FRAME_ULONG( ulCodePageRange1 ),
1206 FT_FRAME_ULONG( ulCodePageRange2 ),
1207 FT_FRAME_END
1208 };
1209
1210 /* `OS/2' version 2 and newer */
1211 static const FT_Frame_Field os2_fields_extra2[] =
1212 {
1213 FT_FRAME_START( 10 ),
1214 FT_FRAME_SHORT ( sxHeight ),
1215 FT_FRAME_SHORT ( sCapHeight ),
1216 FT_FRAME_USHORT( usDefaultChar ),
1217 FT_FRAME_USHORT( usBreakChar ),
1218 FT_FRAME_USHORT( usMaxContext ),
1219 FT_FRAME_END
1220 };
1221
1222 /* `OS/2' version 5 and newer */
1223 static const FT_Frame_Field os2_fields_extra5[] =
1224 {
1225 FT_FRAME_START( 4 ),
1226 FT_FRAME_USHORT( usLowerOpticalPointSize ),
1227 FT_FRAME_USHORT( usUpperOpticalPointSize ),
1228 FT_FRAME_END
1229 };
1230
1231
1232 /* We now support old Mac fonts where the OS/2 table doesn't */
1233 /* exist. Simply put, we set the `version' field to 0xFFFF */
1234 /* and test this value each time we need to access the table. */
1235 error = face->goto_table( face, TTAG_OS2, stream, 0 );
1236 if ( error )
1237 goto Exit;
1238
1239 os2 = &face->os2;
1240
1241 if ( FT_STREAM_READ_FIELDS( os2_fields, os2 ) )
1242 goto Exit;
1243
1244 os2->ulCodePageRange1 = 0;
1245 os2->ulCodePageRange2 = 0;
1246 os2->sxHeight = 0;
1247 os2->sCapHeight = 0;
1248 os2->usDefaultChar = 0;
1249 os2->usBreakChar = 0;
1250 os2->usMaxContext = 0;
1251 os2->usLowerOpticalPointSize = 0;
1252 os2->usUpperOpticalPointSize = 0xFFFF;
1253
1254 if ( os2->version >= 0x0001 )
1255 {
1256 /* only version 1 tables */
1257 if ( FT_STREAM_READ_FIELDS( os2_fields_extra1, os2 ) )
1258 goto Exit;
1259
1260 if ( os2->version >= 0x0002 )
1261 {
1262 /* only version 2 tables */
1263 if ( FT_STREAM_READ_FIELDS( os2_fields_extra2, os2 ) )
1264 goto Exit;
1265
1266 if ( os2->version >= 0x0005 )
1267 {
1268 /* only version 5 tables */
1269 if ( FT_STREAM_READ_FIELDS( os2_fields_extra5, os2 ) )
1270 goto Exit;
1271 }
1272 }
1273 }
1274
1275 FT_TRACE3(( "sTypoAscender: %4hd\n", os2->sTypoAscender ));
1276 FT_TRACE3(( "sTypoDescender: %4hd\n", os2->sTypoDescender ));
1277 FT_TRACE3(( "usWinAscent: %4hu\n", os2->usWinAscent ));
1278 FT_TRACE3(( "usWinDescent: %4hu\n", os2->usWinDescent ));
1279 FT_TRACE3(( "fsSelection: 0x%2hx\n", os2->fsSelection ));
1280
1281 Exit:
1282 return error;
1283 }
1284
1285
1286 /**************************************************************************
1287 *
1288 * @Function:
1289 * tt_face_load_postscript
1290 *
1291 * @Description:
1292 * Loads the Postscript table.
1293 *
1294 * @Input:
1295 * face ::
1296 * A handle to the target face object.
1297 *
1298 * stream ::
1299 * A handle to the input stream.
1300 *
1301 * @Return:
1302 * FreeType error code. 0 means success.
1303 */
1304 FT_LOCAL_DEF( FT_Error )
1305 tt_face_load_post( TT_Face face,
1306 FT_Stream stream )
1307 {
1308 FT_Error error;
1309 TT_Postscript* post = &face->postscript;
1310
1311 static const FT_Frame_Field post_fields[] =
1312 {
1313 #undef FT_STRUCTURE
1314 #define FT_STRUCTURE TT_Postscript
1315
1316 FT_FRAME_START( 32 ),
1317 FT_FRAME_LONG ( FormatType ),
1318 FT_FRAME_LONG ( italicAngle ),
1319 FT_FRAME_SHORT( underlinePosition ),
1320 FT_FRAME_SHORT( underlineThickness ),
1321 FT_FRAME_ULONG( isFixedPitch ),
1322 FT_FRAME_ULONG( minMemType42 ),
1323 FT_FRAME_ULONG( maxMemType42 ),
1324 FT_FRAME_ULONG( minMemType1 ),
1325 FT_FRAME_ULONG( maxMemType1 ),
1326 FT_FRAME_END
1327 };
1328
1329
1330 error = face->goto_table( face, TTAG_post, stream, 0 );
1331 if ( error )
1332 return error;
1333
1334 if ( FT_STREAM_READ_FIELDS( post_fields, post ) )
1335 return error;
1336
1337 if ( post->FormatType != 0x00030000L &&
1338 post->FormatType != 0x00025000L &&
1339 post->FormatType != 0x00020000L &&
1340 post->FormatType != 0x00010000L )
1341 return FT_THROW( Invalid_Post_Table_Format );
1342
1343 /* we don't load the glyph names, we do that in another */
1344 /* module (ttpost). */
1345
1346 FT_TRACE3(( "FormatType: 0x%lx\n", post->FormatType ));
1347 FT_TRACE3(( "isFixedPitch: %s\n", post->isFixedPitch
1348 ? " yes" : " no" ));
1349
1350 return FT_Err_Ok;
1351 }
1352
1353
1354 /**************************************************************************
1355 *
1356 * @Function:
1357 * tt_face_load_pclt
1358 *
1359 * @Description:
1360 * Loads the PCL 5 Table.
1361 *
1362 * @Input:
1363 * face ::
1364 * A handle to the target face object.
1365 *
1366 * stream ::
1367 * A handle to the input stream.
1368 *
1369 * @Return:
1370 * FreeType error code. 0 means success.
1371 */
1372 FT_LOCAL_DEF( FT_Error )
1373 tt_face_load_pclt( TT_Face face,
1374 FT_Stream stream )
1375 {
1376 static const FT_Frame_Field pclt_fields[] =
1377 {
1378 #undef FT_STRUCTURE
1379 #define FT_STRUCTURE TT_PCLT
1380
1381 FT_FRAME_START( 54 ),
1382 FT_FRAME_ULONG ( Version ),
1383 FT_FRAME_ULONG ( FontNumber ),
1384 FT_FRAME_USHORT( Pitch ),
1385 FT_FRAME_USHORT( xHeight ),
1386 FT_FRAME_USHORT( Style ),
1387 FT_FRAME_USHORT( TypeFamily ),
1388 FT_FRAME_USHORT( CapHeight ),
1389 FT_FRAME_USHORT( SymbolSet ),
1390 FT_FRAME_BYTES ( TypeFace, 16 ),
1391 FT_FRAME_BYTES ( CharacterComplement, 8 ),
1392 FT_FRAME_BYTES ( FileName, 6 ),
1393 FT_FRAME_CHAR ( StrokeWeight ),
1394 FT_FRAME_CHAR ( WidthType ),
1395 FT_FRAME_BYTE ( SerifStyle ),
1396 FT_FRAME_BYTE ( Reserved ),
1397 FT_FRAME_END
1398 };
1399
1400 FT_Error error;
1401 TT_PCLT* pclt = &face->pclt;
1402
1403
1404 /* optional table */
1405 error = face->goto_table( face, TTAG_PCLT, stream, 0 );
1406 if ( error )
1407 goto Exit;
1408
1409 if ( FT_STREAM_READ_FIELDS( pclt_fields, pclt ) )
1410 goto Exit;
1411
1412 Exit:
1413 return error;
1414 }
1415
1416
1417 /**************************************************************************
1418 *
1419 * @Function:
1420 * tt_face_load_gasp
1421 *
1422 * @Description:
1423 * Loads the `gasp' table into a face object.
1424 *
1425 * @Input:
1426 * face ::
1427 * A handle to the target face object.
1428 *
1429 * stream ::
1430 * The input stream.
1431 *
1432 * @Return:
1433 * FreeType error code. 0 means success.
1434 */
1435 FT_LOCAL_DEF( FT_Error )
1436 tt_face_load_gasp( TT_Face face,
1437 FT_Stream stream )
1438 {
1439 FT_Error error;
1440 FT_Memory memory = stream->memory;
1441
1442 FT_UShort j, num_ranges;
1443 TT_GaspRange gasp_ranges = NULL;
1444
1445
1446 /* the gasp table is optional */
1447 error = face->goto_table( face, TTAG_gasp, stream, 0 );
1448 if ( error )
1449 goto Exit;
1450
1451 if ( FT_FRAME_ENTER( 4L ) )
1452 goto Exit;
1453
1454 face->gasp.version = FT_GET_USHORT();
1455 num_ranges = FT_GET_USHORT();
1456
1457 FT_FRAME_EXIT();
1458
1459 /* only support versions 0 and 1 of the table */
1460 if ( face->gasp.version >= 2 )
1461 {
1462 face->gasp.numRanges = 0;
1463 error = FT_THROW( Invalid_Table );
1464 goto Exit;
1465 }
1466
1467 FT_TRACE3(( "numRanges: %hu\n", num_ranges ));
1468
1469 if ( FT_QNEW_ARRAY( gasp_ranges, num_ranges ) ||
1470 FT_FRAME_ENTER( num_ranges * 4L ) )
1471 goto Exit;
1472
1473 for ( j = 0; j < num_ranges; j++ )
1474 {
1475 gasp_ranges[j].maxPPEM = FT_GET_USHORT();
1476 gasp_ranges[j].gaspFlag = FT_GET_USHORT();
1477
1478 FT_TRACE3(( "gaspRange %hu: rangeMaxPPEM %5hu, rangeGaspBehavior 0x%hx\n",
1479 j,
1480 gasp_ranges[j].maxPPEM,
1481 gasp_ranges[j].gaspFlag ));
1482 }
1483
1484 face->gasp.gaspRanges = gasp_ranges;
1485 gasp_ranges = NULL;
1486 face->gasp.numRanges = num_ranges;
1487
1488 FT_FRAME_EXIT();
1489
1490 Exit:
1491 FT_FREE( gasp_ranges );
1492 return error;
1493 }
1494
1495
1496 /* END */