PageRenderTime 63ms CodeModel.GetById 12ms app.highlight 43ms RepoModel.GetById 1ms app.codeStats 0ms

/src/freetype/src/sfnt/ttload.c

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