XFA: merge patch from CL 815103002
[pdfium.git] / third_party / freetype / src / sfnt / sfobjs.c
1 /***************************************************************************/
2 /*                                                                         */
3 /*  sfobjs.c                                                               */
4 /*                                                                         */
5 /*    SFNT object management (base).                                       */
6 /*                                                                         */
7 /*  Copyright 1996-2008, 2010-2014 by                                      */
8 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
9 /*                                                                         */
10 /*  This file is part of the FreeType project, and may only be used,       */
11 /*  modified, and distributed under the terms of the FreeType project      */
12 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
13 /*  this file you indicate that you have read the license and              */
14 /*  understand and accept it fully.                                        */
15 /*                                                                         */
16 /***************************************************************************/
17
18
19 #include <ft2build.h>
20 #include "sfobjs.h"
21 #include "ttload.h"
22 #include "ttcmap.h"
23 #include "ttkern.h"
24 #include FT_INTERNAL_SFNT_H
25 #include FT_INTERNAL_DEBUG_H
26 #include FT_TRUETYPE_IDS_H
27 #include FT_TRUETYPE_TAGS_H
28 #include FT_SERVICE_POSTSCRIPT_CMAPS_H
29 #include FT_SFNT_NAMES_H
30 #include FT_GZIP_H
31 #include "sferrors.h"
32
33 #ifdef TT_CONFIG_OPTION_BDF
34 #include "ttbdf.h"
35 #endif
36
37
38   /*************************************************************************/
39   /*                                                                       */
40   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
41   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
42   /* messages during execution.                                            */
43   /*                                                                       */
44 #undef  FT_COMPONENT
45 #define FT_COMPONENT  trace_sfobjs
46
47
48
49   /* convert a UTF-16 name entry to ASCII */
50   static FT_String*
51   tt_name_entry_ascii_from_utf16( TT_NameEntry  entry,
52                                   FT_Memory     memory )
53   {
54     FT_String*  string = NULL;
55     FT_UInt     len, code, n;
56     FT_Byte*    read   = (FT_Byte*)entry->string;
57     FT_Error    error;
58
59
60     len = (FT_UInt)entry->stringLength / 2;
61
62     if ( FT_NEW_ARRAY( string, len + 1 ) )
63       return NULL;
64
65     for ( n = 0; n < len; n++ )
66     {
67       code = FT_NEXT_USHORT( read );
68
69       if ( code == 0 )
70         break;
71
72       if ( code < 32 || code > 127 )
73         code = '?';
74
75       string[n] = (char)code;
76     }
77
78     string[n] = 0;
79
80     return string;
81   }
82
83
84   /* convert an Apple Roman or symbol name entry to ASCII */
85   static FT_String*
86   tt_name_entry_ascii_from_other( TT_NameEntry  entry,
87                                   FT_Memory     memory )
88   {
89     FT_String*  string = NULL;
90     FT_UInt     len, code, n;
91     FT_Byte*    read   = (FT_Byte*)entry->string;
92     FT_Error    error;
93
94
95     len = (FT_UInt)entry->stringLength;
96
97     if ( FT_NEW_ARRAY( string, len + 1 ) )
98       return NULL;
99
100     for ( n = 0; n < len; n++ )
101     {
102       code = *read++;
103
104       if ( code == 0 )
105         break;
106
107       if ( code < 32 || code > 127 )
108         code = '?';
109
110       string[n] = (char)code;
111     }
112
113     string[n] = 0;
114
115     return string;
116   }
117
118
119   typedef FT_String*  (*TT_NameEntry_ConvertFunc)( TT_NameEntry  entry,
120                                                    FT_Memory     memory );
121
122
123   /*************************************************************************/
124   /*                                                                       */
125   /* <Function>                                                            */
126   /*    tt_face_get_name                                                   */
127   /*                                                                       */
128   /* <Description>                                                         */
129   /*    Returns a given ENGLISH name record in ASCII.                      */
130   /*                                                                       */
131   /* <Input>                                                               */
132   /*    face   :: A handle to the source face object.                      */
133   /*                                                                       */
134   /*    nameid :: The name id of the name record to return.                */
135   /*                                                                       */
136   /* <InOut>                                                               */
137   /*    name   :: The address of a string pointer.  NULL if no name is     */
138   /*              present.                                                 */
139   /*                                                                       */
140   /* <Return>                                                              */
141   /*    FreeType error code.  0 means success.                             */
142   /*                                                                       */
143   static FT_Error
144   tt_face_get_name( TT_Face      face,
145                     FT_UShort    nameid,
146                     FT_String**  name )
147   {
148     FT_Memory         memory = face->root.memory;
149     FT_Error          error  = FT_Err_Ok;
150     FT_String*        result = NULL;
151     FT_UShort         n;
152     TT_NameEntryRec*  rec;
153     FT_Int            found_apple         = -1;
154     FT_Int            found_apple_roman   = -1;
155     FT_Int            found_apple_english = -1;
156     FT_Int            found_win           = -1;
157     FT_Int            found_unicode       = -1;
158
159     FT_Bool           is_english = 0;
160
161     TT_NameEntry_ConvertFunc  convert;
162
163
164     FT_ASSERT( name );
165
166     rec = face->name_table.names;
167     for ( n = 0; n < face->num_names; n++, rec++ )
168     {
169       /* According to the OpenType 1.3 specification, only Microsoft or  */
170       /* Apple platform IDs might be used in the `name' table.  The      */
171       /* `Unicode' platform is reserved for the `cmap' table, and the    */
172       /* `ISO' one is deprecated.                                        */
173       /*                                                                 */
174       /* However, the Apple TrueType specification doesn't say the same  */
175       /* thing and goes to suggest that all Unicode `name' table entries */
176       /* should be coded in UTF-16 (in big-endian format I suppose).     */
177       /*                                                                 */
178       if ( rec->nameID == nameid && rec->stringLength > 0 )
179       {
180         switch ( rec->platformID )
181         {
182         case TT_PLATFORM_APPLE_UNICODE:
183         case TT_PLATFORM_ISO:
184           /* there is `languageID' to check there.  We should use this */
185           /* field only as a last solution when nothing else is        */
186           /* available.                                                */
187           /*                                                           */
188           found_unicode = n;
189           break;
190
191         case TT_PLATFORM_MACINTOSH:
192           /* This is a bit special because some fonts will use either    */
193           /* an English language id, or a Roman encoding id, to indicate */
194           /* the English version of its font name.                       */
195           /*                                                             */
196           if ( rec->languageID == TT_MAC_LANGID_ENGLISH )
197             found_apple_english = n;
198           else if ( rec->encodingID == TT_MAC_ID_ROMAN )
199             found_apple_roman = n;
200           break;
201
202         case TT_PLATFORM_MICROSOFT:
203           /* we only take a non-English name when there is nothing */
204           /* else available in the font                            */
205           /*                                                       */
206           if ( found_win == -1 || ( rec->languageID & 0x3FF ) == 0x009 )
207           {
208             switch ( rec->encodingID )
209             {
210             case TT_MS_ID_SYMBOL_CS:
211             case TT_MS_ID_UNICODE_CS:
212             case TT_MS_ID_UCS_4:
213               is_english = FT_BOOL( ( rec->languageID & 0x3FF ) == 0x009 );
214               found_win  = n;
215               break;
216
217             default:
218               ;
219             }
220           }
221           break;
222
223         default:
224           ;
225         }
226       }
227     }
228
229     found_apple = found_apple_roman;
230     if ( found_apple_english >= 0 )
231       found_apple = found_apple_english;
232
233     /* some fonts contain invalid Unicode or Macintosh formatted entries; */
234     /* we will thus favor names encoded in Windows formats if available   */
235     /* (provided it is an English name)                                   */
236     /*                                                                    */
237     convert = NULL;
238     if ( found_win >= 0 && !( found_apple >= 0 && !is_english ) )
239     {
240       rec = face->name_table.names + found_win;
241       switch ( rec->encodingID )
242       {
243         /* all Unicode strings are encoded using UTF-16BE */
244       case TT_MS_ID_UNICODE_CS:
245       case TT_MS_ID_SYMBOL_CS:
246         convert = tt_name_entry_ascii_from_utf16;
247         break;
248
249       case TT_MS_ID_UCS_4:
250         /* Apparently, if this value is found in a name table entry, it is */
251         /* documented as `full Unicode repertoire'.  Experience with the   */
252         /* MsGothic font shipped with Windows Vista shows that this really */
253         /* means UTF-16 encoded names (UCS-4 values are only used within   */
254         /* charmaps).                                                      */
255         convert = tt_name_entry_ascii_from_utf16;
256         break;
257
258       default:
259         ;
260       }
261     }
262     else if ( found_apple >= 0 )
263     {
264       rec     = face->name_table.names + found_apple;
265       convert = tt_name_entry_ascii_from_other;
266     }
267     else if ( found_unicode >= 0 )
268     {
269       rec     = face->name_table.names + found_unicode;
270       convert = tt_name_entry_ascii_from_utf16;
271     }
272
273     if ( rec && convert )
274     {
275       if ( rec->string == NULL )
276       {
277         FT_Stream  stream = face->name_table.stream;
278
279
280         if ( FT_QNEW_ARRAY ( rec->string, rec->stringLength ) ||
281              FT_STREAM_SEEK( rec->stringOffset )              ||
282              FT_STREAM_READ( rec->string, rec->stringLength ) )
283         {
284           FT_FREE( rec->string );
285           rec->stringLength = 0;
286           result            = NULL;
287           goto Exit;
288         }
289       }
290
291       result = convert( rec, memory );
292     }
293
294   Exit:
295     *name = result;
296     return error;
297   }
298
299
300   static FT_Encoding
301   sfnt_find_encoding( int  platform_id,
302                       int  encoding_id )
303   {
304     typedef struct  TEncoding_
305     {
306       int          platform_id;
307       int          encoding_id;
308       FT_Encoding  encoding;
309
310     } TEncoding;
311
312     static
313     const TEncoding  tt_encodings[] =
314     {
315       { TT_PLATFORM_ISO,           -1,                  FT_ENCODING_UNICODE },
316
317       { TT_PLATFORM_APPLE_UNICODE, -1,                  FT_ENCODING_UNICODE },
318
319       { TT_PLATFORM_MACINTOSH,     TT_MAC_ID_ROMAN,     FT_ENCODING_APPLE_ROMAN },
320
321       { TT_PLATFORM_MICROSOFT,     TT_MS_ID_SYMBOL_CS,  FT_ENCODING_MS_SYMBOL },
322       { TT_PLATFORM_MICROSOFT,     TT_MS_ID_UCS_4,      FT_ENCODING_UNICODE },
323       { TT_PLATFORM_MICROSOFT,     TT_MS_ID_UNICODE_CS, FT_ENCODING_UNICODE },
324       { TT_PLATFORM_MICROSOFT,     TT_MS_ID_SJIS,       FT_ENCODING_SJIS },
325       { TT_PLATFORM_MICROSOFT,     TT_MS_ID_GB2312,     FT_ENCODING_GB2312 },
326       { TT_PLATFORM_MICROSOFT,     TT_MS_ID_BIG_5,      FT_ENCODING_BIG5 },
327       { TT_PLATFORM_MICROSOFT,     TT_MS_ID_WANSUNG,    FT_ENCODING_WANSUNG },
328       { TT_PLATFORM_MICROSOFT,     TT_MS_ID_JOHAB,      FT_ENCODING_JOHAB }
329     };
330
331     const TEncoding  *cur, *limit;
332
333
334     cur   = tt_encodings;
335     limit = cur + sizeof ( tt_encodings ) / sizeof ( tt_encodings[0] );
336
337     for ( ; cur < limit; cur++ )
338     {
339       if ( cur->platform_id == platform_id )
340       {
341         if ( cur->encoding_id == encoding_id ||
342              cur->encoding_id == -1          )
343           return cur->encoding;
344       }
345     }
346
347     return FT_ENCODING_NONE;
348   }
349
350
351 #define WRITE_USHORT( p, v )                \
352           do                                \
353           {                                 \
354             *(p)++ = (FT_Byte)( (v) >> 8 ); \
355             *(p)++ = (FT_Byte)( (v) >> 0 ); \
356                                             \
357           } while ( 0 )
358
359 #define WRITE_ULONG( p, v )                  \
360           do                                 \
361           {                                  \
362             *(p)++ = (FT_Byte)( (v) >> 24 ); \
363             *(p)++ = (FT_Byte)( (v) >> 16 ); \
364             *(p)++ = (FT_Byte)( (v) >>  8 ); \
365             *(p)++ = (FT_Byte)( (v) >>  0 ); \
366                                              \
367           } while ( 0 )
368
369
370   static void
371   sfnt_stream_close( FT_Stream  stream )
372   {
373     FT_Memory  memory = stream->memory;
374
375
376     FT_FREE( stream->base );
377
378     stream->size  = 0;
379     stream->base  = 0;
380     stream->close = 0;
381   }
382
383
384   FT_CALLBACK_DEF( int )
385   compare_offsets( const void*  a,
386                    const void*  b )
387   {
388     WOFF_Table  table1 = *(WOFF_Table*)a;
389     WOFF_Table  table2 = *(WOFF_Table*)b;
390
391     FT_ULong  offset1 = table1->Offset;
392     FT_ULong  offset2 = table2->Offset;
393
394
395     if ( offset1 > offset2 )
396       return 1;
397     else if ( offset1 < offset2 )
398       return -1;
399     else
400       return 0;
401   }
402
403
404   /* Replace `face->root.stream' with a stream containing the extracted */
405   /* SFNT of a WOFF font.                                               */
406
407   static FT_Error
408   woff_open_font( FT_Stream  stream,
409                   TT_Face    face )
410   {
411     FT_Memory       memory = stream->memory;
412     FT_Error        error  = FT_Err_Ok;
413
414     WOFF_HeaderRec  woff;
415     WOFF_Table      tables  = NULL;
416     WOFF_Table*     indices = NULL;
417
418     FT_ULong        woff_offset;
419
420     FT_Byte*        sfnt        = NULL;
421     FT_Stream       sfnt_stream = NULL;
422
423     FT_Byte*        sfnt_header;
424     FT_ULong        sfnt_offset;
425
426     FT_Int          nn;
427     FT_ULong        old_tag = 0;
428
429     static const FT_Frame_Field  woff_header_fields[] =
430     {
431 #undef  FT_STRUCTURE
432 #define FT_STRUCTURE  WOFF_HeaderRec
433
434       FT_FRAME_START( 44 ),
435         FT_FRAME_ULONG ( signature ),
436         FT_FRAME_ULONG ( flavor ),
437         FT_FRAME_ULONG ( length ),
438         FT_FRAME_USHORT( num_tables ),
439         FT_FRAME_USHORT( reserved ),
440         FT_FRAME_ULONG ( totalSfntSize ),
441         FT_FRAME_USHORT( majorVersion ),
442         FT_FRAME_USHORT( minorVersion ),
443         FT_FRAME_ULONG ( metaOffset ),
444         FT_FRAME_ULONG ( metaLength ),
445         FT_FRAME_ULONG ( metaOrigLength ),
446         FT_FRAME_ULONG ( privOffset ),
447         FT_FRAME_ULONG ( privLength ),
448       FT_FRAME_END
449     };
450
451
452     FT_ASSERT( stream == face->root.stream );
453     FT_ASSERT( FT_STREAM_POS() == 0 );
454
455     if ( FT_STREAM_READ_FIELDS( woff_header_fields, &woff ) )
456       return error;
457
458     /* Make sure we don't recurse back here or hit TTC code. */
459     if ( woff.flavor == TTAG_wOFF || woff.flavor == TTAG_ttcf )
460       return FT_THROW( Invalid_Table );
461
462     /* Miscellaneous checks. */
463     if ( woff.length != stream->size                              ||
464          woff.num_tables == 0                                     ||
465          44 + woff.num_tables * 20UL >= woff.length               ||
466          12 + woff.num_tables * 16UL >= woff.totalSfntSize        ||
467          ( woff.totalSfntSize & 3 ) != 0                          ||
468          ( woff.metaOffset == 0 && ( woff.metaLength != 0     ||
469                                      woff.metaOrigLength != 0 ) ) ||
470          ( woff.metaLength != 0 && woff.metaOrigLength == 0 )     ||
471          ( woff.privOffset == 0 && woff.privLength != 0 )         )
472       return FT_THROW( Invalid_Table );
473
474     if ( FT_ALLOC( sfnt, woff.totalSfntSize ) ||
475          FT_NEW( sfnt_stream )                )
476       goto Exit;
477
478     sfnt_header = sfnt;
479
480     /* Write sfnt header. */
481     {
482       FT_UInt  searchRange, entrySelector, rangeShift, x;
483
484
485       x             = woff.num_tables;
486       entrySelector = 0;
487       while ( x )
488       {
489         x            >>= 1;
490         entrySelector += 1;
491       }
492       entrySelector--;
493
494       searchRange = ( 1 << entrySelector ) * 16;
495       rangeShift  = woff.num_tables * 16 - searchRange;
496
497       WRITE_ULONG ( sfnt_header, woff.flavor );
498       WRITE_USHORT( sfnt_header, woff.num_tables );
499       WRITE_USHORT( sfnt_header, searchRange );
500       WRITE_USHORT( sfnt_header, entrySelector );
501       WRITE_USHORT( sfnt_header, rangeShift );
502     }
503
504     /* While the entries in the sfnt header must be sorted by the */
505     /* tag value, the tables themselves are not.  We thus have to */
506     /* sort them by offset and check that they don't overlap.     */
507
508     if ( FT_NEW_ARRAY( tables, woff.num_tables )  ||
509          FT_NEW_ARRAY( indices, woff.num_tables ) )
510       goto Exit;
511
512     FT_TRACE2(( "\n"
513                 "  tag    offset    compLen  origLen  checksum\n"
514                 "  -------------------------------------------\n" ));
515
516     if ( FT_FRAME_ENTER( 20L * woff.num_tables ) )
517       goto Exit;
518
519     for ( nn = 0; nn < woff.num_tables; nn++ )
520     {
521       WOFF_Table  table = tables + nn;
522
523       table->Tag        = FT_GET_TAG4();
524       table->Offset     = FT_GET_ULONG();
525       table->CompLength = FT_GET_ULONG();
526       table->OrigLength = FT_GET_ULONG();
527       table->CheckSum   = FT_GET_ULONG();
528
529       FT_TRACE2(( "  %c%c%c%c  %08lx  %08lx  %08lx  %08lx\n",
530                   (FT_Char)( table->Tag >> 24 ),
531                   (FT_Char)( table->Tag >> 16 ),
532                   (FT_Char)( table->Tag >> 8  ),
533                   (FT_Char)( table->Tag       ),
534                   table->Offset,
535                   table->CompLength,
536                   table->OrigLength,
537                   table->CheckSum ));
538
539       if ( table->Tag <= old_tag )
540       {
541         FT_FRAME_EXIT();
542         error = FT_THROW( Invalid_Table );
543         goto Exit;
544       }
545
546       old_tag     = table->Tag;
547       indices[nn] = table;
548     }
549
550     FT_FRAME_EXIT();
551
552     /* Sort by offset. */
553
554     ft_qsort( indices,
555               woff.num_tables,
556               sizeof ( WOFF_Table ),
557               compare_offsets );
558
559     /* Check offsets and lengths. */
560
561     woff_offset = 44 + woff.num_tables * 20L;
562     sfnt_offset = 12 + woff.num_tables * 16L;
563
564     for ( nn = 0; nn < woff.num_tables; nn++ )
565     {
566       WOFF_Table  table = indices[nn];
567
568
569       if ( table->Offset != woff_offset                         ||
570            table->CompLength > woff.length                      ||
571            table->Offset > woff.length - table->CompLength      ||
572            table->OrigLength > woff.totalSfntSize               ||
573            sfnt_offset > woff.totalSfntSize - table->OrigLength ||
574            table->CompLength > table->OrigLength                )
575       {
576         error = FT_THROW( Invalid_Table );
577         goto Exit;
578       }
579
580       table->OrigOffset = sfnt_offset;
581
582       /* The offsets must be multiples of 4. */
583       woff_offset += ( table->CompLength + 3 ) & ~3;
584       sfnt_offset += ( table->OrigLength + 3 ) & ~3;
585     }
586
587     /*
588      * Final checks!
589      *
590      * We don't decode and check the metadata block.
591      * We don't check table checksums either.
592      * But other than those, I think we implement all
593      * `MUST' checks from the spec.
594      */
595
596     if ( woff.metaOffset )
597     {
598       if ( woff.metaOffset != woff_offset                  ||
599            woff.metaOffset + woff.metaLength > woff.length )
600       {
601         error = FT_THROW( Invalid_Table );
602         goto Exit;
603       }
604
605       /* We have padding only ... */
606       woff_offset += woff.metaLength;
607     }
608
609     if ( woff.privOffset )
610     {
611       /* ... if it isn't the last block. */
612       woff_offset = ( woff_offset + 3 ) & ~3;
613
614       if ( woff.privOffset != woff_offset                  ||
615            woff.privOffset + woff.privLength > woff.length )
616       {
617         error = FT_THROW( Invalid_Table );
618         goto Exit;
619       }
620
621       /* No padding for the last block. */
622       woff_offset += woff.privLength;
623     }
624
625     if ( sfnt_offset != woff.totalSfntSize ||
626          woff_offset != woff.length        )
627     {
628       error = FT_THROW( Invalid_Table );
629       goto Exit;
630     }
631
632     /* Write the tables. */
633
634     for ( nn = 0; nn < woff.num_tables; nn++ )
635     {
636       WOFF_Table  table = tables + nn;
637
638
639       /* Write SFNT table entry. */
640       WRITE_ULONG( sfnt_header, table->Tag );
641       WRITE_ULONG( sfnt_header, table->CheckSum );
642       WRITE_ULONG( sfnt_header, table->OrigOffset );
643       WRITE_ULONG( sfnt_header, table->OrigLength );
644
645       /* Write table data. */
646       if ( FT_STREAM_SEEK( table->Offset )     ||
647            FT_FRAME_ENTER( table->CompLength ) )
648         goto Exit;
649
650       if ( table->CompLength == table->OrigLength )
651       {
652         /* Uncompressed data; just copy. */
653         ft_memcpy( sfnt + table->OrigOffset,
654                    stream->cursor,
655                    table->OrigLength );
656       }
657       else
658       {
659 #ifdef FT_CONFIG_OPTION_USE_ZLIB
660
661         /* Uncompress with zlib. */
662         FT_ULong  output_len = table->OrigLength;
663
664
665         error = FT_Gzip_Uncompress( memory,
666                                     sfnt + table->OrigOffset, &output_len,
667                                     stream->cursor, table->CompLength );
668         if ( error )
669           goto Exit;
670         if ( output_len != table->OrigLength )
671         {
672           error = FT_THROW( Invalid_Table );
673           goto Exit;
674         }
675
676 #else /* !FT_CONFIG_OPTION_USE_ZLIB */
677
678         error = FT_THROW( Unimplemented_Feature );
679         goto Exit;
680
681 #endif /* !FT_CONFIG_OPTION_USE_ZLIB */
682       }
683
684       FT_FRAME_EXIT();
685
686       /* We don't check whether the padding bytes in the WOFF file are     */
687       /* actually '\0'.  For the output, however, we do set them properly. */
688       sfnt_offset = table->OrigOffset + table->OrigLength;
689       while ( sfnt_offset & 3 )
690       {
691         sfnt[sfnt_offset] = '\0';
692         sfnt_offset++;
693       }
694     }
695
696     /* Ok!  Finally ready.  Swap out stream and return. */
697     FT_Stream_OpenMemory( sfnt_stream, sfnt, woff.totalSfntSize );
698     sfnt_stream->memory = stream->memory;
699     sfnt_stream->close  = sfnt_stream_close;
700
701     FT_Stream_Free(
702       face->root.stream,
703       ( face->root.face_flags & FT_FACE_FLAG_EXTERNAL_STREAM ) != 0 );
704
705     face->root.stream = sfnt_stream;
706
707     face->root.face_flags &= ~FT_FACE_FLAG_EXTERNAL_STREAM;
708
709   Exit:
710     FT_FREE( tables );
711     FT_FREE( indices );
712
713     if ( error )
714     {
715       FT_FREE( sfnt );
716       FT_Stream_Close( sfnt_stream );
717       FT_FREE( sfnt_stream );
718     }
719
720     return error;
721   }
722
723
724 #undef WRITE_USHORT
725 #undef WRITE_ULONG
726
727
728   /* Fill in face->ttc_header.  If the font is not a TTC, it is */
729   /* synthesized into a TTC with one offset table.              */
730   static FT_Error
731   sfnt_open_font( FT_Stream  stream,
732                   TT_Face    face )
733   {
734     FT_Memory  memory = stream->memory;
735     FT_Error   error;
736     FT_ULong   tag, offset;
737
738     static const FT_Frame_Field  ttc_header_fields[] =
739     {
740 #undef  FT_STRUCTURE
741 #define FT_STRUCTURE  TTC_HeaderRec
742
743       FT_FRAME_START( 8 ),
744         FT_FRAME_LONG( version ),
745         FT_FRAME_LONG( count   ),  /* this is ULong in the specs */
746       FT_FRAME_END
747     };
748
749
750     face->ttc_header.tag     = 0;
751     face->ttc_header.version = 0;
752     face->ttc_header.count   = 0;
753
754   retry:
755     offset = FT_STREAM_POS();
756
757     if ( FT_READ_ULONG( tag ) )
758       return error;
759
760     if ( tag == TTAG_wOFF )
761     {
762       FT_TRACE2(( "sfnt_open_font: file is a WOFF; synthesizing SFNT\n" ));
763
764       if ( FT_STREAM_SEEK( offset ) )
765         return error;
766
767       error = woff_open_font( stream, face );
768       if ( error )
769         return error;
770
771       /* Swap out stream and retry! */
772       stream = face->root.stream;
773       goto retry;
774     }
775
776     if ( tag != 0x00010000UL &&
777          tag != TTAG_ttcf    &&
778          tag != TTAG_OTTO    &&
779          tag != TTAG_true    &&
780          tag != TTAG_typ1    &&
781          tag != 0x00020000UL )
782     {
783       FT_TRACE2(( "  not a font using the SFNT container format\n" ));
784       return FT_THROW( Unknown_File_Format );
785     }
786
787     face->ttc_header.tag = TTAG_ttcf;
788
789     if ( tag == TTAG_ttcf )
790     {
791       FT_Int  n;
792
793
794       FT_TRACE3(( "sfnt_open_font: file is a collection\n" ));
795
796       if ( FT_STREAM_READ_FIELDS( ttc_header_fields, &face->ttc_header ) )
797         return error;
798
799       if ( face->ttc_header.count == 0 )
800         return FT_THROW( Invalid_Table );
801
802       /* a rough size estimate: let's conservatively assume that there   */
803       /* is just a single table info in each subfont header (12 + 16*1 = */
804       /* 28 bytes), thus we have (at least) `12 + 4*count' bytes for the */
805       /* size of the TTC header plus `28*count' bytes for all subfont    */
806       /* headers                                                         */
807       if ( (FT_ULong)face->ttc_header.count > stream->size / ( 28 + 4 ) )
808         return FT_THROW( Array_Too_Large );
809
810       /* now read the offsets of each font in the file */
811       if ( FT_NEW_ARRAY( face->ttc_header.offsets, face->ttc_header.count ) )
812         return error;
813
814       if ( FT_FRAME_ENTER( face->ttc_header.count * 4L ) )
815         return error;
816
817       for ( n = 0; n < face->ttc_header.count; n++ )
818         face->ttc_header.offsets[n] = FT_GET_ULONG();
819
820       FT_FRAME_EXIT();
821     }
822     else
823     {
824       FT_TRACE3(( "sfnt_open_font: synthesize TTC\n" ));
825
826       face->ttc_header.version = 1 << 16;
827       face->ttc_header.count   = 1;
828
829       if ( FT_NEW( face->ttc_header.offsets ) )
830         return error;
831
832       face->ttc_header.offsets[0] = offset;
833     }
834
835     return error;
836   }
837
838
839   FT_LOCAL_DEF( FT_Error )
840   sfnt_init_face( FT_Stream      stream,
841                   TT_Face        face,
842                   FT_Int         face_index,
843                   FT_Int         num_params,
844                   FT_Parameter*  params )
845   {
846     FT_Error        error;
847     FT_Library      library = face->root.driver->root.library;
848     SFNT_Service    sfnt;
849
850
851     /* for now, parameters are unused */
852     FT_UNUSED( num_params );
853     FT_UNUSED( params );
854
855
856     sfnt = (SFNT_Service)face->sfnt;
857     if ( !sfnt )
858     {
859       sfnt = (SFNT_Service)FT_Get_Module_Interface( library, "sfnt" );
860       if ( !sfnt )
861       {
862         FT_ERROR(( "sfnt_init_face: cannot access `sfnt' module\n" ));
863         return FT_THROW( Missing_Module );
864       }
865
866       face->sfnt       = sfnt;
867       face->goto_table = sfnt->goto_table;
868     }
869
870     FT_FACE_FIND_GLOBAL_SERVICE( face, face->psnames, POSTSCRIPT_CMAPS );
871
872     FT_TRACE2(( "SFNT driver\n" ));
873
874     error = sfnt_open_font( stream, face );
875     if ( error )
876       return error;
877
878     /* Stream may have changed in sfnt_open_font. */
879     stream = face->root.stream;
880
881     FT_TRACE2(( "sfnt_init_face: %08p, %ld\n", face, face_index ));
882
883     if ( face_index < 0 )
884       face_index = 0;
885
886     if ( face_index >= face->ttc_header.count )
887       return FT_THROW( Invalid_Argument );
888
889     if ( FT_STREAM_SEEK( face->ttc_header.offsets[face_index] ) )
890       return error;
891
892     /* check that we have a valid TrueType file */
893     error = sfnt->load_font_dir( face, stream );
894     if ( error )
895       return error;
896
897     face->root.num_faces  = face->ttc_header.count;
898     face->root.face_index = face_index;
899
900     return error;
901   }
902
903
904 #define LOAD_( x )                                          \
905   do                                                        \
906   {                                                         \
907     FT_TRACE2(( "`" #x "' " ));                             \
908     FT_TRACE3(( "-->\n" ));                                 \
909                                                             \
910     error = sfnt->load_ ## x( face, stream );               \
911                                                             \
912     FT_TRACE2(( "%s\n", ( !error )                          \
913                         ? "loaded"                          \
914                         : FT_ERR_EQ( error, Table_Missing ) \
915                           ? "missing"                       \
916                           : "failed to load" ));            \
917     FT_TRACE3(( "\n" ));                                    \
918   } while ( 0 )
919
920 #define LOADM_( x, vertical )                               \
921   do                                                        \
922   {                                                         \
923     FT_TRACE2(( "`%s" #x "' ",                              \
924                 vertical ? "vertical " : "" ));             \
925     FT_TRACE3(( "-->\n" ));                                 \
926                                                             \
927     error = sfnt->load_ ## x( face, stream, vertical );     \
928                                                             \
929     FT_TRACE2(( "%s\n", ( !error )                          \
930                         ? "loaded"                          \
931                         : FT_ERR_EQ( error, Table_Missing ) \
932                           ? "missing"                       \
933                           : "failed to load" ));            \
934     FT_TRACE3(( "\n" ));                                    \
935   } while ( 0 )
936
937 #define GET_NAME( id, field )                                   \
938   do                                                            \
939   {                                                             \
940     error = tt_face_get_name( face, TT_NAME_ID_ ## id, field ); \
941     if ( error )                                                \
942       goto Exit;                                                \
943   } while ( 0 )
944
945
946   FT_LOCAL_DEF( FT_Error )
947   sfnt_load_face( FT_Stream      stream,
948                   TT_Face        face,
949                   FT_Int         face_index,
950                   FT_Int         num_params,
951                   FT_Parameter*  params )
952   {
953     FT_Error      error;
954 #ifdef TT_CONFIG_OPTION_POSTSCRIPT_NAMES
955     FT_Error      psnames_error;
956 #endif
957     FT_Bool       has_outline;
958     FT_Bool       is_apple_sbit;
959     FT_Bool       is_apple_sbix;
960     FT_Bool       ignore_preferred_family    = FALSE;
961     FT_Bool       ignore_preferred_subfamily = FALSE;
962
963     SFNT_Service  sfnt = (SFNT_Service)face->sfnt;
964
965     FT_UNUSED( face_index );
966
967
968     /* Check parameters */
969
970     {
971       FT_Int  i;
972
973
974       for ( i = 0; i < num_params; i++ )
975       {
976         if ( params[i].tag == FT_PARAM_TAG_IGNORE_PREFERRED_FAMILY )
977           ignore_preferred_family = TRUE;
978         else if ( params[i].tag == FT_PARAM_TAG_IGNORE_PREFERRED_SUBFAMILY )
979           ignore_preferred_subfamily = TRUE;
980       }
981     }
982
983     /* Load tables */
984
985     /* We now support two SFNT-based bitmapped font formats.  They */
986     /* are recognized easily as they do not include a `glyf'       */
987     /* table.                                                      */
988     /*                                                             */
989     /* The first format comes from Apple, and uses a table named   */
990     /* `bhed' instead of `head' to store the font header (using    */
991     /* the same format).  It also doesn't include horizontal and   */
992     /* vertical metrics tables (i.e. `hhea' and `vhea' tables are  */
993     /* missing).                                                   */
994     /*                                                             */
995     /* The other format comes from Microsoft, and is used with     */
996     /* WinCE/PocketPC.  It looks like a standard TTF, except that  */
997     /* it doesn't contain outlines.                                */
998     /*                                                             */
999
1000     FT_TRACE2(( "sfnt_load_face: %08p\n\n", face ));
1001
1002     /* do we have outlines in there? */
1003 #ifdef FT_CONFIG_OPTION_INCREMENTAL
1004     has_outline = FT_BOOL( face->root.internal->incremental_interface != 0 ||
1005                            tt_face_lookup_table( face, TTAG_glyf )    != 0 ||
1006                            tt_face_lookup_table( face, TTAG_CFF )     != 0 );
1007 #else
1008     has_outline = FT_BOOL( tt_face_lookup_table( face, TTAG_glyf ) != 0 ||
1009                            tt_face_lookup_table( face, TTAG_CFF )  != 0 );
1010 #endif
1011
1012     is_apple_sbit = 0;
1013     is_apple_sbix = !face->goto_table( face, TTAG_sbix, stream, 0 );
1014
1015     /* Apple 'sbix' color bitmaps are rendered scaled and then the 'glyf'
1016      * outline rendered on top.  We don't support that yet, so just ignore
1017      * the 'glyf' outline and advertise it as a bitmap-only font. */
1018     if ( is_apple_sbix )
1019       has_outline = FALSE;
1020
1021     /* if this font doesn't contain outlines, we try to load */
1022     /* a `bhed' table                                        */
1023     if ( !has_outline && sfnt->load_bhed )
1024     {
1025       LOAD_( bhed );
1026       is_apple_sbit = FT_BOOL( !error );
1027     }
1028
1029     /* load the font header (`head' table) if this isn't an Apple */
1030     /* sbit font file                                             */
1031     if ( !is_apple_sbit || is_apple_sbix )
1032     {
1033       LOAD_( head );
1034       if ( error )
1035         goto Exit;
1036     }
1037
1038     if ( face->header.Units_Per_EM == 0 )
1039     {
1040       error = FT_THROW( Invalid_Table );
1041
1042       goto Exit;
1043     }
1044
1045     /* the following tables are often not present in embedded TrueType */
1046     /* fonts within PDF documents, so don't check for them.            */
1047     LOAD_( maxp );
1048     LOAD_( cmap );
1049
1050     /* the following tables are optional in PCL fonts -- */
1051     /* don't check for errors                            */
1052     LOAD_( name );
1053     LOAD_( post );
1054
1055 #ifdef TT_CONFIG_OPTION_POSTSCRIPT_NAMES
1056     psnames_error = error;
1057 #endif
1058
1059     /* do not load the metrics headers and tables if this is an Apple */
1060     /* sbit font file                                                 */
1061     if ( !is_apple_sbit )
1062     {
1063       /* load the `hhea' and `hmtx' tables */
1064       LOADM_( hhea, 0 );
1065       if ( !error )
1066       {
1067         LOADM_( hmtx, 0 );
1068         if ( FT_ERR_EQ( error, Table_Missing ) )
1069         {
1070           error = FT_THROW( Hmtx_Table_Missing );
1071
1072 #ifdef FT_CONFIG_OPTION_INCREMENTAL
1073           /* If this is an incrementally loaded font and there are */
1074           /* overriding metrics, tolerate a missing `hmtx' table.  */
1075           if ( face->root.internal->incremental_interface          &&
1076                face->root.internal->incremental_interface->funcs->
1077                  get_glyph_metrics                                 )
1078           {
1079             face->horizontal.number_Of_HMetrics = 0;
1080             error                               = FT_Err_Ok;
1081           }
1082 #endif
1083         }
1084       }
1085       else if ( FT_ERR_EQ( error, Table_Missing ) )
1086       {
1087         /* No `hhea' table necessary for SFNT Mac fonts. */
1088         if ( face->format_tag == TTAG_true )
1089         {
1090           FT_TRACE2(( "This is an SFNT Mac font.\n" ));
1091
1092           has_outline = 0;
1093           error       = FT_Err_Ok;
1094         }
1095         else
1096         {
1097           error = FT_THROW( Horiz_Header_Missing );
1098
1099 #ifdef FT_CONFIG_OPTION_INCREMENTAL
1100           /* If this is an incrementally loaded font and there are */
1101           /* overriding metrics, tolerate a missing `hhea' table.  */
1102           if ( face->root.internal->incremental_interface          &&
1103                face->root.internal->incremental_interface->funcs->
1104                  get_glyph_metrics                                 )
1105           {
1106             face->horizontal.number_Of_HMetrics = 0;
1107             error                               = FT_Err_Ok;
1108           }
1109 #endif
1110
1111         }
1112       }
1113
1114       if ( error )
1115         goto Exit;
1116
1117       /* try to load the `vhea' and `vmtx' tables */
1118       LOADM_( hhea, 1 );
1119       if ( !error )
1120       {
1121         LOADM_( hmtx, 1 );
1122         if ( !error )
1123           face->vertical_info = 1;
1124       }
1125
1126       if ( error && FT_ERR_NEQ( error, Table_Missing ) )
1127         goto Exit;
1128
1129       LOAD_( os2 );
1130       if ( error )
1131       {
1132         /* we treat the table as missing if there are any errors */
1133         face->os2.version = 0xFFFFU;
1134       }
1135     }
1136
1137     /* the optional tables */
1138
1139     /* embedded bitmap support */
1140     if ( sfnt->load_eblc )
1141     {
1142       LOAD_( eblc );
1143       if ( error )
1144       {
1145         /* a font which contains neither bitmaps nor outlines is */
1146         /* still valid (although rather useless in most cases);  */
1147         /* however, you can find such stripped fonts in PDFs     */
1148         if ( FT_ERR_EQ( error, Table_Missing ) )
1149           error = FT_Err_Ok;
1150         else
1151           goto Exit;
1152       }
1153     }
1154
1155     LOAD_( pclt );
1156     if ( error )
1157     {
1158       if ( FT_ERR_NEQ( error, Table_Missing ) )
1159         goto Exit;
1160
1161       face->pclt.Version = 0;
1162     }
1163
1164     /* consider the kerning and gasp tables as optional */
1165     LOAD_( gasp );
1166     LOAD_( kern );
1167
1168     face->root.num_glyphs = face->max_profile.numGlyphs;
1169
1170     /* Bit 8 of the `fsSelection' field in the `OS/2' table denotes  */
1171     /* a WWS-only font face.  `WWS' stands for `weight', width', and */
1172     /* `slope', a term used by Microsoft's Windows Presentation      */
1173     /* Foundation (WPF).  This flag has been introduced in version   */
1174     /* 1.5 of the OpenType specification (May 2008).                 */
1175
1176     face->root.family_name = NULL;
1177     face->root.style_name  = NULL;
1178     if ( face->os2.version != 0xFFFFU && face->os2.fsSelection & 256 )
1179     {
1180       if ( !ignore_preferred_family )
1181         GET_NAME( PREFERRED_FAMILY, &face->root.family_name );
1182       if ( !face->root.family_name )
1183         GET_NAME( FONT_FAMILY, &face->root.family_name );
1184
1185       if ( !ignore_preferred_subfamily )
1186         GET_NAME( PREFERRED_SUBFAMILY, &face->root.style_name );
1187       if ( !face->root.style_name )
1188         GET_NAME( FONT_SUBFAMILY, &face->root.style_name );
1189     }
1190     else
1191     {
1192       GET_NAME( WWS_FAMILY, &face->root.family_name );
1193       if ( !face->root.family_name && !ignore_preferred_family )
1194         GET_NAME( PREFERRED_FAMILY, &face->root.family_name );
1195       if ( !face->root.family_name )
1196         GET_NAME( FONT_FAMILY, &face->root.family_name );
1197
1198       GET_NAME( WWS_SUBFAMILY, &face->root.style_name );
1199       if ( !face->root.style_name && !ignore_preferred_subfamily )
1200         GET_NAME( PREFERRED_SUBFAMILY, &face->root.style_name );
1201       if ( !face->root.style_name )
1202         GET_NAME( FONT_SUBFAMILY, &face->root.style_name );
1203     }
1204
1205     /* now set up root fields */
1206     {
1207       FT_Face  root  = &face->root;
1208       FT_Long  flags = root->face_flags;
1209
1210
1211       /*********************************************************************/
1212       /*                                                                   */
1213       /* Compute face flags.                                               */
1214       /*                                                                   */
1215       if ( face->sbit_table_type == TT_SBIT_TABLE_TYPE_CBLC ||
1216            face->sbit_table_type == TT_SBIT_TABLE_TYPE_SBIX )
1217         flags |= FT_FACE_FLAG_COLOR;      /* color glyphs */
1218
1219       if ( has_outline == TRUE )
1220         flags |= FT_FACE_FLAG_SCALABLE;   /* scalable outlines */
1221
1222       /* The sfnt driver only supports bitmap fonts natively, thus we */
1223       /* don't set FT_FACE_FLAG_HINTER.                               */
1224       flags |= FT_FACE_FLAG_SFNT       |  /* SFNT file format  */
1225                FT_FACE_FLAG_HORIZONTAL;   /* horizontal data   */
1226
1227 #ifdef TT_CONFIG_OPTION_POSTSCRIPT_NAMES
1228       if ( !psnames_error                             &&
1229            face->postscript.FormatType != 0x00030000L )
1230         flags |= FT_FACE_FLAG_GLYPH_NAMES;
1231 #endif
1232
1233       /* fixed width font? */
1234       if ( face->postscript.isFixedPitch )
1235         flags |= FT_FACE_FLAG_FIXED_WIDTH;
1236
1237       /* vertical information? */
1238       if ( face->vertical_info )
1239         flags |= FT_FACE_FLAG_VERTICAL;
1240
1241       /* kerning available ? */
1242       if ( TT_FACE_HAS_KERNING( face ) )
1243         flags |= FT_FACE_FLAG_KERNING;
1244
1245 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
1246       /* Don't bother to load the tables unless somebody asks for them. */
1247       /* No need to do work which will (probably) not be used.          */
1248       if ( tt_face_lookup_table( face, TTAG_glyf ) != 0 &&
1249            tt_face_lookup_table( face, TTAG_fvar ) != 0 &&
1250            tt_face_lookup_table( face, TTAG_gvar ) != 0 )
1251         flags |= FT_FACE_FLAG_MULTIPLE_MASTERS;
1252 #endif
1253
1254       root->face_flags = flags;
1255
1256       /*********************************************************************/
1257       /*                                                                   */
1258       /* Compute style flags.                                              */
1259       /*                                                                   */
1260
1261       flags = 0;
1262       if ( has_outline == TRUE && face->os2.version != 0xFFFFU )
1263       {
1264         /* We have an OS/2 table; use the `fsSelection' field.  Bit 9 */
1265         /* indicates an oblique font face.  This flag has been        */
1266         /* introduced in version 1.5 of the OpenType specification.   */
1267
1268         if ( face->os2.fsSelection & 512 )       /* bit 9 */
1269           flags |= FT_STYLE_FLAG_ITALIC;
1270         else if ( face->os2.fsSelection & 1 )    /* bit 0 */
1271           flags |= FT_STYLE_FLAG_ITALIC;
1272
1273         if ( face->os2.fsSelection & 32 )        /* bit 5 */
1274           flags |= FT_STYLE_FLAG_BOLD;
1275       }
1276       else
1277       {
1278         /* this is an old Mac font, use the header field */
1279
1280         if ( face->header.Mac_Style & 1 )
1281           flags |= FT_STYLE_FLAG_BOLD;
1282
1283         if ( face->header.Mac_Style & 2 )
1284           flags |= FT_STYLE_FLAG_ITALIC;
1285       }
1286
1287       root->style_flags = flags;
1288
1289       /*********************************************************************/
1290       /*                                                                   */
1291       /* Polish the charmaps.                                              */
1292       /*                                                                   */
1293       /*   Try to set the charmap encoding according to the platform &     */
1294       /*   encoding ID of each charmap.                                    */
1295       /*                                                                   */
1296
1297       tt_face_build_cmaps( face );  /* ignore errors */
1298
1299
1300       /* set the encoding fields */
1301       {
1302         FT_Int  m;
1303
1304
1305         for ( m = 0; m < root->num_charmaps; m++ )
1306         {
1307           FT_CharMap  charmap = root->charmaps[m];
1308
1309
1310           charmap->encoding = sfnt_find_encoding( charmap->platform_id,
1311                                                   charmap->encoding_id );
1312
1313 #if 0
1314           if ( root->charmap     == NULL &&
1315                charmap->encoding == FT_ENCODING_UNICODE )
1316           {
1317             /* set 'root->charmap' to the first Unicode encoding we find */
1318             root->charmap = charmap;
1319           }
1320 #endif
1321         }
1322       }
1323
1324 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
1325
1326       /*
1327        *  Now allocate the root array of FT_Bitmap_Size records and
1328        *  populate them.  Unfortunately, it isn't possible to indicate bit
1329        *  depths in the FT_Bitmap_Size record.  This is a design error.
1330        */
1331       {
1332         FT_UInt  i, count;
1333
1334
1335         count = face->sbit_num_strikes;
1336
1337         if ( count > 0 )
1338         {
1339           FT_Memory        memory   = face->root.stream->memory;
1340           FT_UShort        em_size  = face->header.Units_Per_EM;
1341           FT_Short         avgwidth = face->os2.xAvgCharWidth;
1342           FT_Size_Metrics  metrics;
1343
1344
1345           if ( em_size == 0 || face->os2.version == 0xFFFFU )
1346           {
1347             avgwidth = 1;
1348             em_size = 1;
1349           }
1350
1351           if ( FT_NEW_ARRAY( root->available_sizes, count ) )
1352             goto Exit;
1353
1354           for ( i = 0; i < count; i++ )
1355           {
1356             FT_Bitmap_Size*  bsize = root->available_sizes + i;
1357
1358
1359             error = sfnt->load_strike_metrics( face, i, &metrics );
1360             if ( error )
1361               goto Exit;
1362
1363             bsize->height = (FT_Short)( metrics.height >> 6 );
1364             bsize->width = (FT_Short)(
1365                 ( avgwidth * metrics.x_ppem + em_size / 2 ) / em_size );
1366
1367             bsize->x_ppem = metrics.x_ppem << 6;
1368             bsize->y_ppem = metrics.y_ppem << 6;
1369
1370             /* assume 72dpi */
1371             bsize->size   = metrics.y_ppem << 6;
1372           }
1373
1374           root->face_flags     |= FT_FACE_FLAG_FIXED_SIZES;
1375           root->num_fixed_sizes = (FT_Int)count;
1376         }
1377       }
1378
1379 #endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
1380
1381       /* a font with no bitmaps and no outlines is scalable; */
1382       /* it has only empty glyphs then                       */
1383       if ( !FT_HAS_FIXED_SIZES( root ) && !FT_IS_SCALABLE( root ) )
1384         root->face_flags |= FT_FACE_FLAG_SCALABLE;
1385
1386
1387       /*********************************************************************/
1388       /*                                                                   */
1389       /*  Set up metrics.                                                  */
1390       /*                                                                   */
1391       if ( FT_IS_SCALABLE( root ) )
1392       {
1393         /* XXX What about if outline header is missing */
1394         /*     (e.g. sfnt wrapped bitmap)?             */
1395         root->bbox.xMin    = face->header.xMin;
1396         root->bbox.yMin    = face->header.yMin;
1397         root->bbox.xMax    = face->header.xMax;
1398         root->bbox.yMax    = face->header.yMax;
1399         root->units_per_EM = face->header.Units_Per_EM;
1400
1401
1402         /* XXX: Computing the ascender/descender/height is very different */
1403         /*      from what the specification tells you.  Apparently, we    */
1404         /*      must be careful because                                   */
1405         /*                                                                */
1406         /*      - not all fonts have an OS/2 table; in this case, we take */
1407         /*        the values in the horizontal header.  However, these    */
1408         /*        values very often are not reliable.                     */
1409         /*                                                                */
1410         /*      - otherwise, the correct typographic values are in the    */
1411         /*        sTypoAscender, sTypoDescender & sTypoLineGap fields.    */
1412         /*                                                                */
1413         /*        However, certain fonts have these fields set to 0.      */
1414         /*        Rather, they have usWinAscent & usWinDescent correctly  */
1415         /*        set (but with different values).                        */
1416         /*                                                                */
1417         /*      As an example, Arial Narrow is implemented through four   */
1418         /*      files ARIALN.TTF, ARIALNI.TTF, ARIALNB.TTF & ARIALNBI.TTF */
1419         /*                                                                */
1420         /*      Strangely, all fonts have the same values in their        */
1421         /*      sTypoXXX fields, except ARIALNB which sets them to 0.     */
1422         /*                                                                */
1423         /*      On the other hand, they all have different                */
1424         /*      usWinAscent/Descent values -- as a conclusion, the OS/2   */
1425         /*      table cannot be used to compute the text height reliably! */
1426         /*                                                                */
1427
1428         /* The ascender and descender are taken from the `hhea' table. */
1429         /* If zero, they are taken from the `OS/2' table.              */
1430
1431         root->ascender  = face->horizontal.Ascender;
1432         root->descender = face->horizontal.Descender;
1433
1434         root->height = (FT_Short)( root->ascender - root->descender +
1435                                    face->horizontal.Line_Gap );
1436
1437         if ( !( root->ascender || root->descender ) )
1438         {
1439           if ( face->os2.version != 0xFFFFU )
1440           {
1441             if ( face->os2.sTypoAscender || face->os2.sTypoDescender )
1442             {
1443               root->ascender  = face->os2.sTypoAscender;
1444               root->descender = face->os2.sTypoDescender;
1445
1446               root->height = (FT_Short)( root->ascender - root->descender +
1447                                          face->os2.sTypoLineGap );
1448             }
1449             else
1450             {
1451               root->ascender  =  (FT_Short)face->os2.usWinAscent;
1452               root->descender = -(FT_Short)face->os2.usWinDescent;
1453
1454               root->height = (FT_UShort)( root->ascender - root->descender );
1455             }
1456           }
1457         }
1458
1459         root->max_advance_width  = face->horizontal.advance_Width_Max;
1460         root->max_advance_height = (FT_Short)( face->vertical_info
1461                                      ? face->vertical.advance_Height_Max
1462                                      : root->height );
1463
1464         /* See http://www.microsoft.com/OpenType/OTSpec/post.htm -- */
1465         /* Adjust underline position from top edge to centre of     */
1466         /* stroke to convert TrueType meaning to FreeType meaning.  */
1467         root->underline_position  = face->postscript.underlinePosition -
1468                                     face->postscript.underlineThickness / 2;
1469         root->underline_thickness = face->postscript.underlineThickness;
1470       }
1471
1472     }
1473
1474   Exit:
1475     FT_TRACE2(( "sfnt_load_face: done\n" ));
1476
1477     return error;
1478   }
1479
1480
1481 #undef LOAD_
1482 #undef LOADM_
1483 #undef GET_NAME
1484
1485
1486   FT_LOCAL_DEF( void )
1487   sfnt_done_face( TT_Face  face )
1488   {
1489     FT_Memory     memory;
1490     SFNT_Service  sfnt;
1491
1492
1493     if ( !face )
1494       return;
1495
1496     memory = face->root.memory;
1497     sfnt   = (SFNT_Service)face->sfnt;
1498
1499     if ( sfnt )
1500     {
1501       /* destroy the postscript names table if it is loaded */
1502       if ( sfnt->free_psnames )
1503         sfnt->free_psnames( face );
1504
1505       /* destroy the embedded bitmaps table if it is loaded */
1506       if ( sfnt->free_eblc )
1507         sfnt->free_eblc( face );
1508     }
1509
1510 #ifdef TT_CONFIG_OPTION_BDF
1511     /* freeing the embedded BDF properties */
1512     tt_face_free_bdf_props( face );
1513 #endif
1514
1515     /* freeing the kerning table */
1516     tt_face_done_kern( face );
1517
1518     /* freeing the collection table */
1519     FT_FREE( face->ttc_header.offsets );
1520     face->ttc_header.count = 0;
1521
1522     /* freeing table directory */
1523     FT_FREE( face->dir_tables );
1524     face->num_tables = 0;
1525
1526     {
1527       FT_Stream  stream = FT_FACE_STREAM( face );
1528
1529
1530       /* simply release the 'cmap' table frame */
1531       FT_FRAME_RELEASE( face->cmap_table );
1532       face->cmap_size = 0;
1533     }
1534
1535     /* freeing the horizontal metrics */
1536     {
1537       FT_Stream  stream = FT_FACE_STREAM( face );
1538
1539
1540       FT_FRAME_RELEASE( face->horz_metrics );
1541       FT_FRAME_RELEASE( face->vert_metrics );
1542       face->horz_metrics_size = 0;
1543       face->vert_metrics_size = 0;
1544     }
1545
1546     /* freeing the vertical ones, if any */
1547     if ( face->vertical_info )
1548     {
1549       FT_FREE( face->vertical.long_metrics  );
1550       FT_FREE( face->vertical.short_metrics );
1551       face->vertical_info = 0;
1552     }
1553
1554     /* freeing the gasp table */
1555     FT_FREE( face->gasp.gaspRanges );
1556     face->gasp.numRanges = 0;
1557
1558     /* freeing the name table */
1559     if ( sfnt )
1560       sfnt->free_name( face );
1561
1562     /* freeing family and style name */
1563     FT_FREE( face->root.family_name );
1564     FT_FREE( face->root.style_name );
1565
1566     /* freeing sbit size table */
1567     FT_FREE( face->root.available_sizes );
1568     face->root.num_fixed_sizes = 0;
1569
1570     FT_FREE( face->postscript_name );
1571
1572     face->sfnt = 0;
1573   }
1574
1575
1576 /* END */