XFA: merge patch from CL 815103002
[pdfium.git] / third_party / 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-2010, 2012-2014 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   /*                                                                  */
156   /* - look for a `head' table, check its size, and parse it to check */
157   /*   whether its `magic' field is correctly set                     */
158   /*                                                                  */
159   /* - errors (except errors returned by stream handling)             */
160   /*                                                                  */
161   /*     SFNT_Err_Unknown_File_Format:                                */
162   /*       no table is defined in directory, it is not sfnt-wrapped   */
163   /*       data                                                       */
164   /*     SFNT_Err_Table_Missing:                                      */
165   /*       table directory is valid, but essential tables             */
166   /*       (head/bhed/SING) are missing                               */
167   /*                                                                  */
168   static FT_Error
169   check_table_dir( SFNT_Header  sfnt,
170                    FT_Stream    stream )
171   {
172     FT_Error   error;
173     FT_UShort  nn, valid_entries = 0;
174     FT_UInt    has_head = 0, has_sing = 0, has_meta = 0;
175     FT_ULong   offset = sfnt->offset + 12;
176
177     static const FT_Frame_Field  table_dir_entry_fields[] =
178     {
179 #undef  FT_STRUCTURE
180 #define FT_STRUCTURE  TT_TableRec
181
182       FT_FRAME_START( 16 ),
183         FT_FRAME_ULONG( Tag ),
184         FT_FRAME_ULONG( CheckSum ),
185         FT_FRAME_ULONG( Offset ),
186         FT_FRAME_ULONG( Length ),
187       FT_FRAME_END
188     };
189
190
191     if ( FT_STREAM_SEEK( offset ) )
192       goto Exit;
193
194     for ( nn = 0; nn < sfnt->num_tables; nn++ )
195     {
196       TT_TableRec  table;
197
198
199       if ( FT_STREAM_READ_FIELDS( table_dir_entry_fields, &table ) )
200       {
201         nn--;
202         FT_TRACE2(( "check_table_dir:"
203                     " can read only %d table%s in font (instead of %d)\n",
204                     nn, nn == 1 ? "" : "s", sfnt->num_tables ));
205         sfnt->num_tables = nn;
206         break;
207       }
208
209       /* we ignore invalid tables */
210
211       /* table.Offset + table.Length > stream->size ? */
212       if ( table.Length > stream->size                ||
213            table.Offset > stream->size - table.Length )
214       {
215         FT_TRACE2(( "check_table_dir: table entry %d invalid\n", nn ));
216         continue;
217       }
218       else
219         valid_entries++;
220
221       if ( table.Tag == TTAG_head || table.Tag == TTAG_bhed )
222       {
223         FT_UInt32  magic;
224
225
226 #ifndef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
227         if ( table.Tag == TTAG_head )
228 #endif
229           has_head = 1;
230
231         /*
232          * The table length should be 0x36, but certain font tools make it
233          * 0x38, so we will just check that it is greater.
234          *
235          * Note that according to the specification, the table must be
236          * padded to 32-bit lengths, but this doesn't apply to the value of
237          * its `Length' field!
238          *
239          */
240         if ( table.Length < 0x36 )
241         {
242           FT_TRACE2(( "check_table_dir:"
243                       " `head' or `bhed' table too small\n" ));
244           error = FT_THROW( Table_Missing );
245           goto Exit;
246         }
247
248         if ( FT_STREAM_SEEK( table.Offset + 12 ) ||
249              FT_READ_ULONG( magic )              )
250           goto Exit;
251
252         if ( magic != 0x5F0F3CF5UL )
253           FT_TRACE2(( "check_table_dir:"
254                       " invalid magic number in `head' or `bhed' table\n"));
255
256         if ( FT_STREAM_SEEK( offset + ( nn + 1 ) * 16 ) )
257           goto Exit;
258       }
259       else if ( table.Tag == TTAG_SING )
260         has_sing = 1;
261       else if ( table.Tag == TTAG_META )
262         has_meta = 1;
263     }
264
265     sfnt->num_tables = valid_entries;
266
267     if ( sfnt->num_tables == 0 )
268     {
269       FT_TRACE2(( "check_table_dir: no tables found\n" ));
270       error = FT_THROW( Unknown_File_Format );
271       goto Exit;
272     }
273
274     /* if `sing' and `meta' tables are present, there is no `head' table */
275     if ( has_head || ( has_sing && has_meta ) )
276     {
277       error = FT_Err_Ok;
278       goto Exit;
279     }
280     else
281     {
282       FT_TRACE2(( "check_table_dir:" ));
283 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
284       FT_TRACE2(( " neither `head', `bhed', nor `sing' table found\n" ));
285 #else
286       FT_TRACE2(( " neither `head' nor `sing' table found\n" ));
287 #endif
288       error = FT_THROW( Table_Missing );
289     }
290
291   Exit:
292     return error;
293   }
294
295
296   /*************************************************************************/
297   /*                                                                       */
298   /* <Function>                                                            */
299   /*    tt_face_load_font_dir                                              */
300   /*                                                                       */
301   /* <Description>                                                         */
302   /*    Loads the header of a SFNT font file.                              */
303   /*                                                                       */
304   /* <Input>                                                               */
305   /*    face       :: A handle to the target face object.                  */
306   /*                                                                       */
307   /*    stream     :: The input stream.                                    */
308   /*                                                                       */
309   /* <Output>                                                              */
310   /*    sfnt       :: The SFNT header.                                     */
311   /*                                                                       */
312   /* <Return>                                                              */
313   /*    FreeType error code.  0 means success.                             */
314   /*                                                                       */
315   /* <Note>                                                                */
316   /*    The stream cursor must be at the beginning of the font directory.  */
317   /*                                                                       */
318   FT_LOCAL_DEF( FT_Error )
319   tt_face_load_font_dir( TT_Face    face,
320                          FT_Stream  stream )
321   {
322     SFNT_HeaderRec  sfnt;
323     FT_Error        error;
324     FT_Memory       memory = stream->memory;
325     TT_TableRec*    entry;
326     FT_Int          nn;
327
328     static const FT_Frame_Field  offset_table_fields[] =
329     {
330 #undef  FT_STRUCTURE
331 #define FT_STRUCTURE  SFNT_HeaderRec
332
333       FT_FRAME_START( 8 ),
334         FT_FRAME_USHORT( num_tables ),
335         FT_FRAME_USHORT( search_range ),
336         FT_FRAME_USHORT( entry_selector ),
337         FT_FRAME_USHORT( range_shift ),
338       FT_FRAME_END
339     };
340
341
342     FT_TRACE2(( "tt_face_load_font_dir: %08p\n", face ));
343
344     /* read the offset table */
345
346     sfnt.offset = FT_STREAM_POS();
347
348     if ( FT_READ_ULONG( sfnt.format_tag )                    ||
349          FT_STREAM_READ_FIELDS( offset_table_fields, &sfnt ) )
350       goto Exit;
351
352     /* many fonts don't have these fields set correctly */
353 #if 0
354     if ( sfnt.search_range != 1 << ( sfnt.entry_selector + 4 )        ||
355          sfnt.search_range + sfnt.range_shift != sfnt.num_tables << 4 )
356       return FT_THROW( Unknown_File_Format );
357 #endif
358
359     /* load the table directory */
360
361     FT_TRACE2(( "-- Number of tables: %10u\n",    sfnt.num_tables ));
362     FT_TRACE2(( "-- Format version:   0x%08lx\n", sfnt.format_tag ));
363
364     if ( sfnt.format_tag != TTAG_OTTO )
365     {
366       /* check first */
367       error = check_table_dir( &sfnt, stream );
368       if ( error )
369       {
370         FT_TRACE2(( "tt_face_load_font_dir:"
371                     " invalid table directory for TrueType\n" ));
372
373         goto Exit;
374       }
375     }
376
377     face->num_tables = sfnt.num_tables;
378     face->format_tag = sfnt.format_tag;
379
380     if ( FT_QNEW_ARRAY( face->dir_tables, face->num_tables ) )
381       goto Exit;
382
383     if ( FT_STREAM_SEEK( sfnt.offset + 12 )       ||
384          FT_FRAME_ENTER( face->num_tables * 16L ) )
385       goto Exit;
386
387     entry = face->dir_tables;
388
389     FT_TRACE2(( "\n"
390                 "  tag    offset    length   checksum\n"
391                 "  ----------------------------------\n" ));
392
393     for ( nn = 0; nn < sfnt.num_tables; nn++ )
394     {
395       entry->Tag      = FT_GET_TAG4();
396       entry->CheckSum = FT_GET_ULONG();
397       entry->Offset   = FT_GET_ULONG();
398       entry->Length   = FT_GET_ULONG();
399
400       /* ignore invalid tables */
401
402       /* entry->Offset + entry->Length > stream->size ? */
403       if ( entry->Length > stream->size                 ||
404            entry->Offset > stream->size - entry->Length )
405         continue;
406       else
407       {
408         FT_TRACE2(( "  %c%c%c%c  %08lx  %08lx  %08lx\n",
409                     (FT_Char)( entry->Tag >> 24 ),
410                     (FT_Char)( entry->Tag >> 16 ),
411                     (FT_Char)( entry->Tag >> 8  ),
412                     (FT_Char)( entry->Tag       ),
413                     entry->Offset,
414                     entry->Length,
415                     entry->CheckSum ));
416         entry++;
417       }
418     }
419
420     FT_FRAME_EXIT();
421
422     FT_TRACE2(( "table directory loaded\n\n" ));
423
424   Exit:
425     return error;
426   }
427
428
429   /*************************************************************************/
430   /*                                                                       */
431   /* <Function>                                                            */
432   /*    tt_face_load_any                                                   */
433   /*                                                                       */
434   /* <Description>                                                         */
435   /*    Loads any font table into client memory.                           */
436   /*                                                                       */
437   /* <Input>                                                               */
438   /*    face   :: The face object to look for.                             */
439   /*                                                                       */
440   /*    tag    :: The tag of table to load.  Use the value 0 if you want   */
441   /*              to access the whole font file, else set this parameter   */
442   /*              to a valid TrueType table tag that you can forge with    */
443   /*              the MAKE_TT_TAG macro.                                   */
444   /*                                                                       */
445   /*    offset :: The starting offset in the table (or the file if         */
446   /*              tag == 0).                                               */
447   /*                                                                       */
448   /*    length :: The address of the decision variable:                    */
449   /*                                                                       */
450   /*                If length == NULL:                                     */
451   /*                  Loads the whole table.  Returns an error if          */
452   /*                  `offset' == 0!                                       */
453   /*                                                                       */
454   /*                If *length == 0:                                       */
455   /*                  Exits immediately; returning the length of the given */
456   /*                  table or of the font file, depending on the value of */
457   /*                  `tag'.                                               */
458   /*                                                                       */
459   /*                If *length != 0:                                       */
460   /*                  Loads the next `length' bytes of table or font,      */
461   /*                  starting at offset `offset' (in table or font too).  */
462   /*                                                                       */
463   /* <Output>                                                              */
464   /*    buffer :: The address of target buffer.                            */
465   /*                                                                       */
466   /* <Return>                                                              */
467   /*    FreeType error code.  0 means success.                             */
468   /*                                                                       */
469   FT_LOCAL_DEF( FT_Error )
470   tt_face_load_any( TT_Face    face,
471                     FT_ULong   tag,
472                     FT_Long    offset,
473                     FT_Byte*   buffer,
474                     FT_ULong*  length )
475   {
476     FT_Error   error;
477     FT_Stream  stream;
478     TT_Table   table;
479     FT_ULong   size;
480
481
482     if ( tag != 0 )
483     {
484       /* look for tag in font directory */
485       table = tt_face_lookup_table( face, tag );
486       if ( !table )
487       {
488         error = FT_THROW( Table_Missing );
489         goto Exit;
490       }
491
492       offset += table->Offset;
493       size    = table->Length;
494     }
495     else
496       /* tag == 0 -- the user wants to access the font file directly */
497       size = face->root.stream->size;
498
499     if ( length && *length == 0 )
500     {
501       *length = size;
502
503       return FT_Err_Ok;
504     }
505
506     if ( length )
507       size = *length;
508
509     stream = face->root.stream;
510     /* the `if' is syntactic sugar for picky compilers */
511     if ( FT_STREAM_READ_AT( offset, buffer, size ) )
512       goto Exit;
513
514   Exit:
515     return error;
516   }
517
518
519   /*************************************************************************/
520   /*                                                                       */
521   /* <Function>                                                            */
522   /*    tt_face_load_generic_header                                        */
523   /*                                                                       */
524   /* <Description>                                                         */
525   /*    Loads the TrueType table `head' or `bhed'.                         */
526   /*                                                                       */
527   /* <Input>                                                               */
528   /*    face   :: A handle to the target face object.                      */
529   /*                                                                       */
530   /*    stream :: The input stream.                                        */
531   /*                                                                       */
532   /* <Return>                                                              */
533   /*    FreeType error code.  0 means success.                             */
534   /*                                                                       */
535   static FT_Error
536   tt_face_load_generic_header( TT_Face    face,
537                                FT_Stream  stream,
538                                FT_ULong   tag )
539   {
540     FT_Error    error;
541     TT_Header*  header;
542
543     static const FT_Frame_Field  header_fields[] =
544     {
545 #undef  FT_STRUCTURE
546 #define FT_STRUCTURE  TT_Header
547
548       FT_FRAME_START( 54 ),
549         FT_FRAME_ULONG ( Table_Version ),
550         FT_FRAME_ULONG ( Font_Revision ),
551         FT_FRAME_LONG  ( CheckSum_Adjust ),
552         FT_FRAME_LONG  ( Magic_Number ),
553         FT_FRAME_USHORT( Flags ),
554         FT_FRAME_USHORT( Units_Per_EM ),
555         FT_FRAME_LONG  ( Created[0] ),
556         FT_FRAME_LONG  ( Created[1] ),
557         FT_FRAME_LONG  ( Modified[0] ),
558         FT_FRAME_LONG  ( Modified[1] ),
559         FT_FRAME_SHORT ( xMin ),
560         FT_FRAME_SHORT ( yMin ),
561         FT_FRAME_SHORT ( xMax ),
562         FT_FRAME_SHORT ( yMax ),
563         FT_FRAME_USHORT( Mac_Style ),
564         FT_FRAME_USHORT( Lowest_Rec_PPEM ),
565         FT_FRAME_SHORT ( Font_Direction ),
566         FT_FRAME_SHORT ( Index_To_Loc_Format ),
567         FT_FRAME_SHORT ( Glyph_Data_Format ),
568       FT_FRAME_END
569     };
570
571
572     error = face->goto_table( face, tag, stream, 0 );
573     if ( error )
574       goto Exit;
575
576     header = &face->header;
577
578     if ( FT_STREAM_READ_FIELDS( header_fields, header ) )
579       goto Exit;
580
581     FT_TRACE3(( "Units per EM: %4u\n", header->Units_Per_EM ));
582     FT_TRACE3(( "IndexToLoc:   %4d\n", header->Index_To_Loc_Format ));
583
584   Exit:
585     return error;
586   }
587
588
589   FT_LOCAL_DEF( FT_Error )
590   tt_face_load_head( TT_Face    face,
591                      FT_Stream  stream )
592   {
593     return tt_face_load_generic_header( face, stream, TTAG_head );
594   }
595
596
597 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
598
599   FT_LOCAL_DEF( FT_Error )
600   tt_face_load_bhed( TT_Face    face,
601                      FT_Stream  stream )
602   {
603     return tt_face_load_generic_header( face, stream, TTAG_bhed );
604   }
605
606 #endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
607
608
609   /*************************************************************************/
610   /*                                                                       */
611   /* <Function>                                                            */
612   /*    tt_face_load_max_profile                                           */
613   /*                                                                       */
614   /* <Description>                                                         */
615   /*    Loads the maximum profile into a face object.                      */
616   /*                                                                       */
617   /* <Input>                                                               */
618   /*    face   :: A handle to the target face object.                      */
619   /*                                                                       */
620   /*    stream :: The input stream.                                        */
621   /*                                                                       */
622   /* <Return>                                                              */
623   /*    FreeType error code.  0 means success.                             */
624   /*                                                                       */
625   FT_LOCAL_DEF( FT_Error )
626   tt_face_load_maxp( TT_Face    face,
627                      FT_Stream  stream )
628   {
629     FT_Error        error;
630     TT_MaxProfile*  maxProfile = &face->max_profile;
631
632     static const FT_Frame_Field  maxp_fields[] =
633     {
634 #undef  FT_STRUCTURE
635 #define FT_STRUCTURE  TT_MaxProfile
636
637       FT_FRAME_START( 6 ),
638         FT_FRAME_LONG  ( version ),
639         FT_FRAME_USHORT( numGlyphs ),
640       FT_FRAME_END
641     };
642
643     static const FT_Frame_Field  maxp_fields_extra[] =
644     {
645       FT_FRAME_START( 26 ),
646         FT_FRAME_USHORT( maxPoints ),
647         FT_FRAME_USHORT( maxContours ),
648         FT_FRAME_USHORT( maxCompositePoints ),
649         FT_FRAME_USHORT( maxCompositeContours ),
650         FT_FRAME_USHORT( maxZones ),
651         FT_FRAME_USHORT( maxTwilightPoints ),
652         FT_FRAME_USHORT( maxStorage ),
653         FT_FRAME_USHORT( maxFunctionDefs ),
654         FT_FRAME_USHORT( maxInstructionDefs ),
655         FT_FRAME_USHORT( maxStackElements ),
656         FT_FRAME_USHORT( maxSizeOfInstructions ),
657         FT_FRAME_USHORT( maxComponentElements ),
658         FT_FRAME_USHORT( maxComponentDepth ),
659       FT_FRAME_END
660     };
661
662
663     error = face->goto_table( face, TTAG_maxp, stream, 0 );
664     if ( error )
665       goto Exit;
666
667     if ( FT_STREAM_READ_FIELDS( maxp_fields, maxProfile ) )
668       goto Exit;
669
670     maxProfile->maxPoints             = 0;
671     maxProfile->maxContours           = 0;
672     maxProfile->maxCompositePoints    = 0;
673     maxProfile->maxCompositeContours  = 0;
674     maxProfile->maxZones              = 0;
675     maxProfile->maxTwilightPoints     = 0;
676     maxProfile->maxStorage            = 0;
677     maxProfile->maxFunctionDefs       = 0;
678     maxProfile->maxInstructionDefs    = 0;
679     maxProfile->maxStackElements      = 0;
680     maxProfile->maxSizeOfInstructions = 0;
681     maxProfile->maxComponentElements  = 0;
682     maxProfile->maxComponentDepth     = 0;
683
684     if ( maxProfile->version >= 0x10000L )
685     {
686       if ( FT_STREAM_READ_FIELDS( maxp_fields_extra, maxProfile ) )
687         goto Exit;
688
689       /* XXX: an adjustment that is necessary to load certain */
690       /*      broken fonts like `Keystrokes MT' :-(           */
691       /*                                                      */
692       /*   We allocate 64 function entries by default when    */
693       /*   the maxFunctionDefs value is smaller.              */
694
695       if ( maxProfile->maxFunctionDefs < 64 )
696         maxProfile->maxFunctionDefs = 64;
697
698       /* we add 4 phantom points later */
699       if ( maxProfile->maxTwilightPoints > ( 0xFFFFU - 4 ) )
700       {
701         FT_TRACE0(( "tt_face_load_maxp:"
702                     " too much twilight points in `maxp' table;\n"
703                     "                  "
704                     " some glyphs might be rendered incorrectly\n" ));
705
706         maxProfile->maxTwilightPoints = 0xFFFFU - 4;
707       }
708
709       /* we arbitrarily limit recursion to avoid stack exhaustion */
710       if ( maxProfile->maxComponentDepth > 100 )
711       {
712         FT_TRACE0(( "tt_face_load_maxp:"
713                     " abnormally large component depth (%d) set to 100\n",
714                     maxProfile->maxComponentDepth ));
715         maxProfile->maxComponentDepth = 100;
716       }
717     }
718
719     FT_TRACE3(( "numGlyphs: %u\n", maxProfile->numGlyphs ));
720
721   Exit:
722     return error;
723   }
724
725
726   /*************************************************************************/
727   /*                                                                       */
728   /* <Function>                                                            */
729   /*    tt_face_load_name                                                  */
730   /*                                                                       */
731   /* <Description>                                                         */
732   /*    Loads the name records.                                            */
733   /*                                                                       */
734   /* <Input>                                                               */
735   /*    face   :: A handle to the target face object.                      */
736   /*                                                                       */
737   /*    stream :: The input stream.                                        */
738   /*                                                                       */
739   /* <Return>                                                              */
740   /*    FreeType error code.  0 means success.                             */
741   /*                                                                       */
742   FT_LOCAL_DEF( FT_Error )
743   tt_face_load_name( TT_Face    face,
744                      FT_Stream  stream )
745   {
746     FT_Error      error;
747     FT_Memory     memory = stream->memory;
748     FT_ULong      table_pos, table_len;
749     FT_ULong      storage_start, storage_limit;
750     FT_UInt       count;
751     TT_NameTable  table;
752
753     static const FT_Frame_Field  name_table_fields[] =
754     {
755 #undef  FT_STRUCTURE
756 #define FT_STRUCTURE  TT_NameTableRec
757
758       FT_FRAME_START( 6 ),
759         FT_FRAME_USHORT( format ),
760         FT_FRAME_USHORT( numNameRecords ),
761         FT_FRAME_USHORT( storageOffset ),
762       FT_FRAME_END
763     };
764
765     static const FT_Frame_Field  name_record_fields[] =
766     {
767 #undef  FT_STRUCTURE
768 #define FT_STRUCTURE  TT_NameEntryRec
769
770       /* no FT_FRAME_START */
771         FT_FRAME_USHORT( platformID ),
772         FT_FRAME_USHORT( encodingID ),
773         FT_FRAME_USHORT( languageID ),
774         FT_FRAME_USHORT( nameID ),
775         FT_FRAME_USHORT( stringLength ),
776         FT_FRAME_USHORT( stringOffset ),
777       FT_FRAME_END
778     };
779
780
781     table         = &face->name_table;
782     table->stream = stream;
783
784     error = face->goto_table( face, TTAG_name, stream, &table_len );
785     if ( error )
786       goto Exit;
787
788     table_pos = FT_STREAM_POS();
789
790
791     if ( FT_STREAM_READ_FIELDS( name_table_fields, table ) )
792       goto Exit;
793
794     /* Some popular Asian fonts have an invalid `storageOffset' value   */
795     /* (it should be at least "6 + 12*num_names").  However, the string */
796     /* offsets, computed as "storageOffset + entry->stringOffset", are  */
797     /* valid pointers within the name table...                          */
798     /*                                                                  */
799     /* We thus can't check `storageOffset' right now.                   */
800     /*                                                                  */
801     storage_start = table_pos + 6 + 12*table->numNameRecords;
802     storage_limit = table_pos + table_len;
803
804     if ( storage_start > storage_limit )
805     {
806       FT_ERROR(( "tt_face_load_name: invalid `name' table\n" ));
807       error = FT_THROW( Name_Table_Missing );
808       goto Exit;
809     }
810
811     /* Allocate the array of name records. */
812     count                 = table->numNameRecords;
813     table->numNameRecords = 0;
814
815     if ( FT_NEW_ARRAY( table->names, count ) ||
816          FT_FRAME_ENTER( count * 12 )        )
817       goto Exit;
818
819     /* Load the name records and determine how much storage is needed */
820     /* to hold the strings themselves.                                */
821     {
822       TT_NameEntryRec*  entry = table->names;
823
824
825       for ( ; count > 0; count-- )
826       {
827         if ( FT_STREAM_READ_FIELDS( name_record_fields, entry ) )
828           continue;
829
830         /* check that the name is not empty */
831         if ( entry->stringLength == 0 )
832           continue;
833
834         /* check that the name string is within the table */
835         entry->stringOffset += table_pos + table->storageOffset;
836         if ( entry->stringOffset                       < storage_start ||
837              entry->stringOffset + entry->stringLength > storage_limit )
838         {
839           /* invalid entry - ignore it */
840           entry->stringOffset = 0;
841           entry->stringLength = 0;
842           continue;
843         }
844
845         entry++;
846       }
847
848       table->numNameRecords = (FT_UInt)( entry - table->names );
849     }
850
851     FT_FRAME_EXIT();
852
853     /* everything went well, update face->num_names */
854     face->num_names = (FT_UShort) table->numNameRecords;
855
856   Exit:
857     return error;
858   }
859
860
861   /*************************************************************************/
862   /*                                                                       */
863   /* <Function>                                                            */
864   /*    tt_face_free_names                                                 */
865   /*                                                                       */
866   /* <Description>                                                         */
867   /*    Frees the name records.                                            */
868   /*                                                                       */
869   /* <Input>                                                               */
870   /*    face :: A handle to the target face object.                        */
871   /*                                                                       */
872   FT_LOCAL_DEF( void )
873   tt_face_free_name( TT_Face  face )
874   {
875     FT_Memory     memory = face->root.driver->root.memory;
876     TT_NameTable  table  = &face->name_table;
877     TT_NameEntry  entry  = table->names;
878     FT_UInt       count  = table->numNameRecords;
879
880
881     if ( table->names )
882     {
883       for ( ; count > 0; count--, entry++ )
884       {
885         FT_FREE( entry->string );
886         entry->stringLength = 0;
887       }
888
889       /* free strings table */
890       FT_FREE( table->names );
891     }
892
893     table->numNameRecords = 0;
894     table->format         = 0;
895     table->storageOffset  = 0;
896   }
897
898
899   /*************************************************************************/
900   /*                                                                       */
901   /* <Function>                                                            */
902   /*    tt_face_load_cmap                                                  */
903   /*                                                                       */
904   /* <Description>                                                         */
905   /*    Loads the cmap directory in a face object.  The cmaps themselves   */
906   /*    are loaded on demand in the `ttcmap.c' module.                     */
907   /*                                                                       */
908   /* <Input>                                                               */
909   /*    face   :: A handle to the target face object.                      */
910   /*                                                                       */
911   /*    stream :: A handle to the input stream.                            */
912   /*                                                                       */
913   /* <Return>                                                              */
914   /*    FreeType error code.  0 means success.                             */
915   /*                                                                       */
916
917   FT_LOCAL_DEF( FT_Error )
918   tt_face_load_cmap( TT_Face    face,
919                      FT_Stream  stream )
920   {
921     FT_Error  error;
922
923
924     error = face->goto_table( face, TTAG_cmap, stream, &face->cmap_size );
925     if ( error )
926       goto Exit;
927
928     if ( FT_FRAME_EXTRACT( face->cmap_size, face->cmap_table ) )
929       face->cmap_size = 0;
930
931   Exit:
932     return error;
933   }
934
935
936
937   /*************************************************************************/
938   /*                                                                       */
939   /* <Function>                                                            */
940   /*    tt_face_load_os2                                                   */
941   /*                                                                       */
942   /* <Description>                                                         */
943   /*    Loads the OS2 table.                                               */
944   /*                                                                       */
945   /* <Input>                                                               */
946   /*    face   :: A handle to the target face object.                      */
947   /*                                                                       */
948   /*    stream :: A handle to the input stream.                            */
949   /*                                                                       */
950   /* <Return>                                                              */
951   /*    FreeType error code.  0 means success.                             */
952   /*                                                                       */
953   FT_LOCAL_DEF( FT_Error )
954   tt_face_load_os2( TT_Face    face,
955                     FT_Stream  stream )
956   {
957     FT_Error  error;
958     TT_OS2*   os2;
959
960     static const FT_Frame_Field  os2_fields[] =
961     {
962 #undef  FT_STRUCTURE
963 #define FT_STRUCTURE  TT_OS2
964
965       FT_FRAME_START( 78 ),
966         FT_FRAME_USHORT( version ),
967         FT_FRAME_SHORT ( xAvgCharWidth ),
968         FT_FRAME_USHORT( usWeightClass ),
969         FT_FRAME_USHORT( usWidthClass ),
970         FT_FRAME_SHORT ( fsType ),
971         FT_FRAME_SHORT ( ySubscriptXSize ),
972         FT_FRAME_SHORT ( ySubscriptYSize ),
973         FT_FRAME_SHORT ( ySubscriptXOffset ),
974         FT_FRAME_SHORT ( ySubscriptYOffset ),
975         FT_FRAME_SHORT ( ySuperscriptXSize ),
976         FT_FRAME_SHORT ( ySuperscriptYSize ),
977         FT_FRAME_SHORT ( ySuperscriptXOffset ),
978         FT_FRAME_SHORT ( ySuperscriptYOffset ),
979         FT_FRAME_SHORT ( yStrikeoutSize ),
980         FT_FRAME_SHORT ( yStrikeoutPosition ),
981         FT_FRAME_SHORT ( sFamilyClass ),
982         FT_FRAME_BYTE  ( panose[0] ),
983         FT_FRAME_BYTE  ( panose[1] ),
984         FT_FRAME_BYTE  ( panose[2] ),
985         FT_FRAME_BYTE  ( panose[3] ),
986         FT_FRAME_BYTE  ( panose[4] ),
987         FT_FRAME_BYTE  ( panose[5] ),
988         FT_FRAME_BYTE  ( panose[6] ),
989         FT_FRAME_BYTE  ( panose[7] ),
990         FT_FRAME_BYTE  ( panose[8] ),
991         FT_FRAME_BYTE  ( panose[9] ),
992         FT_FRAME_ULONG ( ulUnicodeRange1 ),
993         FT_FRAME_ULONG ( ulUnicodeRange2 ),
994         FT_FRAME_ULONG ( ulUnicodeRange3 ),
995         FT_FRAME_ULONG ( ulUnicodeRange4 ),
996         FT_FRAME_BYTE  ( achVendID[0] ),
997         FT_FRAME_BYTE  ( achVendID[1] ),
998         FT_FRAME_BYTE  ( achVendID[2] ),
999         FT_FRAME_BYTE  ( achVendID[3] ),
1000
1001         FT_FRAME_USHORT( fsSelection ),
1002         FT_FRAME_USHORT( usFirstCharIndex ),
1003         FT_FRAME_USHORT( usLastCharIndex ),
1004         FT_FRAME_SHORT ( sTypoAscender ),
1005         FT_FRAME_SHORT ( sTypoDescender ),
1006         FT_FRAME_SHORT ( sTypoLineGap ),
1007         FT_FRAME_USHORT( usWinAscent ),
1008         FT_FRAME_USHORT( usWinDescent ),
1009       FT_FRAME_END
1010     };
1011
1012     /* `OS/2' version 1 and newer */
1013     static const FT_Frame_Field  os2_fields_extra1[] =
1014     {
1015       FT_FRAME_START( 8 ),
1016         FT_FRAME_ULONG( ulCodePageRange1 ),
1017         FT_FRAME_ULONG( ulCodePageRange2 ),
1018       FT_FRAME_END
1019     };
1020
1021     /* `OS/2' version 2 and newer */
1022     static const FT_Frame_Field  os2_fields_extra2[] =
1023     {
1024       FT_FRAME_START( 10 ),
1025         FT_FRAME_SHORT ( sxHeight ),
1026         FT_FRAME_SHORT ( sCapHeight ),
1027         FT_FRAME_USHORT( usDefaultChar ),
1028         FT_FRAME_USHORT( usBreakChar ),
1029         FT_FRAME_USHORT( usMaxContext ),
1030       FT_FRAME_END
1031     };
1032
1033     /* `OS/2' version 5 and newer */
1034     static const FT_Frame_Field  os2_fields_extra5[] =
1035     {
1036       FT_FRAME_START( 4 ),
1037         FT_FRAME_USHORT( usLowerOpticalPointSize ),
1038         FT_FRAME_USHORT( usUpperOpticalPointSize ),
1039       FT_FRAME_END
1040     };
1041
1042
1043     /* We now support old Mac fonts where the OS/2 table doesn't  */
1044     /* exist.  Simply put, we set the `version' field to 0xFFFF   */
1045     /* and test this value each time we need to access the table. */
1046     error = face->goto_table( face, TTAG_OS2, stream, 0 );
1047     if ( error )
1048       goto Exit;
1049
1050     os2 = &face->os2;
1051
1052     if ( FT_STREAM_READ_FIELDS( os2_fields, os2 ) )
1053       goto Exit;
1054
1055     os2->ulCodePageRange1        = 0;
1056     os2->ulCodePageRange2        = 0;
1057     os2->sxHeight                = 0;
1058     os2->sCapHeight              = 0;
1059     os2->usDefaultChar           = 0;
1060     os2->usBreakChar             = 0;
1061     os2->usMaxContext            = 0;
1062     os2->usLowerOpticalPointSize = 0;
1063     os2->usUpperOpticalPointSize = 0xFFFF;
1064
1065     if ( os2->version >= 0x0001 )
1066     {
1067       /* only version 1 tables */
1068       if ( FT_STREAM_READ_FIELDS( os2_fields_extra1, os2 ) )
1069         goto Exit;
1070
1071       if ( os2->version >= 0x0002 )
1072       {
1073         /* only version 2 tables */
1074         if ( FT_STREAM_READ_FIELDS( os2_fields_extra2, os2 ) )
1075           goto Exit;
1076
1077         if ( os2->version >= 0x0005 )
1078         {
1079           /* only version 5 tables */
1080           if ( FT_STREAM_READ_FIELDS( os2_fields_extra5, os2 ) )
1081             goto Exit;
1082         }
1083       }
1084     }
1085
1086     FT_TRACE3(( "sTypoAscender:  %4d\n",   os2->sTypoAscender ));
1087     FT_TRACE3(( "sTypoDescender: %4d\n",   os2->sTypoDescender ));
1088     FT_TRACE3(( "usWinAscent:    %4u\n",   os2->usWinAscent ));
1089     FT_TRACE3(( "usWinDescent:   %4u\n",   os2->usWinDescent ));
1090     FT_TRACE3(( "fsSelection:    0x%2x\n", os2->fsSelection ));
1091
1092   Exit:
1093     return error;
1094   }
1095
1096
1097   /*************************************************************************/
1098   /*                                                                       */
1099   /* <Function>                                                            */
1100   /*    tt_face_load_postscript                                            */
1101   /*                                                                       */
1102   /* <Description>                                                         */
1103   /*    Loads the Postscript table.                                        */
1104   /*                                                                       */
1105   /* <Input>                                                               */
1106   /*    face   :: A handle to the target face object.                      */
1107   /*                                                                       */
1108   /*    stream :: A handle to the input stream.                            */
1109   /*                                                                       */
1110   /* <Return>                                                              */
1111   /*    FreeType error code.  0 means success.                             */
1112   /*                                                                       */
1113   FT_LOCAL_DEF( FT_Error )
1114   tt_face_load_post( TT_Face    face,
1115                      FT_Stream  stream )
1116   {
1117     FT_Error        error;
1118     TT_Postscript*  post = &face->postscript;
1119
1120     static const FT_Frame_Field  post_fields[] =
1121     {
1122 #undef  FT_STRUCTURE
1123 #define FT_STRUCTURE  TT_Postscript
1124
1125       FT_FRAME_START( 32 ),
1126         FT_FRAME_ULONG( FormatType ),
1127         FT_FRAME_ULONG( italicAngle ),
1128         FT_FRAME_SHORT( underlinePosition ),
1129         FT_FRAME_SHORT( underlineThickness ),
1130         FT_FRAME_ULONG( isFixedPitch ),
1131         FT_FRAME_ULONG( minMemType42 ),
1132         FT_FRAME_ULONG( maxMemType42 ),
1133         FT_FRAME_ULONG( minMemType1 ),
1134         FT_FRAME_ULONG( maxMemType1 ),
1135       FT_FRAME_END
1136     };
1137
1138
1139     error = face->goto_table( face, TTAG_post, stream, 0 );
1140     if ( error )
1141       return error;
1142
1143     if ( FT_STREAM_READ_FIELDS( post_fields, post ) )
1144       return error;
1145
1146     /* we don't load the glyph names, we do that in another */
1147     /* module (ttpost).                                     */
1148
1149     FT_TRACE3(( "FormatType:   0x%x\n", post->FormatType ));
1150     FT_TRACE3(( "isFixedPitch:   %s\n", post->isFixedPitch
1151                                         ? "  yes" : "   no" ));
1152
1153     return FT_Err_Ok;
1154   }
1155
1156
1157   /*************************************************************************/
1158   /*                                                                       */
1159   /* <Function>                                                            */
1160   /*    tt_face_load_pclt                                                  */
1161   /*                                                                       */
1162   /* <Description>                                                         */
1163   /*    Loads the PCL 5 Table.                                             */
1164   /*                                                                       */
1165   /* <Input>                                                               */
1166   /*    face   :: A handle to the target face object.                      */
1167   /*                                                                       */
1168   /*    stream :: A handle to the input stream.                            */
1169   /*                                                                       */
1170   /* <Return>                                                              */
1171   /*    FreeType error code.  0 means success.                             */
1172   /*                                                                       */
1173   FT_LOCAL_DEF( FT_Error )
1174   tt_face_load_pclt( TT_Face    face,
1175                      FT_Stream  stream )
1176   {
1177     static const FT_Frame_Field  pclt_fields[] =
1178     {
1179 #undef  FT_STRUCTURE
1180 #define FT_STRUCTURE  TT_PCLT
1181
1182       FT_FRAME_START( 54 ),
1183         FT_FRAME_ULONG ( Version ),
1184         FT_FRAME_ULONG ( FontNumber ),
1185         FT_FRAME_USHORT( Pitch ),
1186         FT_FRAME_USHORT( xHeight ),
1187         FT_FRAME_USHORT( Style ),
1188         FT_FRAME_USHORT( TypeFamily ),
1189         FT_FRAME_USHORT( CapHeight ),
1190         FT_FRAME_USHORT( SymbolSet ),
1191         FT_FRAME_BYTES ( TypeFace, 16 ),
1192         FT_FRAME_BYTES ( CharacterComplement, 8 ),
1193         FT_FRAME_BYTES ( FileName, 6 ),
1194         FT_FRAME_CHAR  ( StrokeWeight ),
1195         FT_FRAME_CHAR  ( WidthType ),
1196         FT_FRAME_BYTE  ( SerifStyle ),
1197         FT_FRAME_BYTE  ( Reserved ),
1198       FT_FRAME_END
1199     };
1200
1201     FT_Error  error;
1202     TT_PCLT*  pclt = &face->pclt;
1203
1204
1205     /* optional table */
1206     error = face->goto_table( face, TTAG_PCLT, stream, 0 );
1207     if ( error )
1208       goto Exit;
1209
1210     if ( FT_STREAM_READ_FIELDS( pclt_fields, pclt ) )
1211       goto Exit;
1212
1213   Exit:
1214     return error;
1215   }
1216
1217
1218   /*************************************************************************/
1219   /*                                                                       */
1220   /* <Function>                                                            */
1221   /*    tt_face_load_gasp                                                  */
1222   /*                                                                       */
1223   /* <Description>                                                         */
1224   /*    Loads the `gasp' table into a face object.                         */
1225   /*                                                                       */
1226   /* <Input>                                                               */
1227   /*    face   :: A handle to the target face object.                      */
1228   /*                                                                       */
1229   /*    stream :: The input stream.                                        */
1230   /*                                                                       */
1231   /* <Return>                                                              */
1232   /*    FreeType error code.  0 means success.                             */
1233   /*                                                                       */
1234   FT_LOCAL_DEF( FT_Error )
1235   tt_face_load_gasp( TT_Face    face,
1236                      FT_Stream  stream )
1237   {
1238     FT_Error   error;
1239     FT_Memory  memory = stream->memory;
1240
1241     FT_UInt        j,num_ranges;
1242     TT_GaspRange   gaspranges = NULL;
1243
1244
1245     /* the gasp table is optional */
1246     error = face->goto_table( face, TTAG_gasp, stream, 0 );
1247     if ( error )
1248       goto Exit;
1249
1250     if ( FT_FRAME_ENTER( 4L ) )
1251       goto Exit;
1252
1253     face->gasp.version   = FT_GET_USHORT();
1254     face->gasp.numRanges = FT_GET_USHORT();
1255
1256     FT_FRAME_EXIT();
1257
1258     /* only support versions 0 and 1 of the table */
1259     if ( face->gasp.version >= 2 )
1260     {
1261       face->gasp.numRanges = 0;
1262       error = FT_THROW( Invalid_Table );
1263       goto Exit;
1264     }
1265
1266     num_ranges = face->gasp.numRanges;
1267     FT_TRACE3(( "numRanges: %u\n", num_ranges ));
1268
1269     if ( FT_QNEW_ARRAY( face->gasp.gaspRanges, num_ranges ) ||
1270          FT_FRAME_ENTER( num_ranges * 4L )                  )
1271       goto Exit;
1272
1273     gaspranges = face->gasp.gaspRanges;
1274
1275     for ( j = 0; j < num_ranges; j++ )
1276     {
1277       gaspranges[j].maxPPEM  = FT_GET_USHORT();
1278       gaspranges[j].gaspFlag = FT_GET_USHORT();
1279
1280       FT_TRACE3(( "gaspRange %d: rangeMaxPPEM %5d, rangeGaspBehavior 0x%x\n",
1281                   j,
1282                   gaspranges[j].maxPPEM,
1283                   gaspranges[j].gaspFlag ));
1284     }
1285
1286     FT_FRAME_EXIT();
1287
1288   Exit:
1289     return error;
1290   }
1291
1292
1293 /* END */