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 */