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