misc/libfreetype/src/truetype/ttpload.c
changeset 9372 915436ff64ab
parent 9371 f3840de881bd
child 9373 b769a8e38cbd
equal deleted inserted replaced
9371:f3840de881bd 9372:915436ff64ab
     1 /***************************************************************************/
       
     2 /*                                                                         */
       
     3 /*  ttpload.c                                                              */
       
     4 /*                                                                         */
       
     5 /*    TrueType-specific tables loader (body).                              */
       
     6 /*                                                                         */
       
     7 /*  Copyright 1996-2002, 2004-2011 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 FT_INTERNAL_DEBUG_H
       
    21 #include FT_INTERNAL_OBJECTS_H
       
    22 #include FT_INTERNAL_STREAM_H
       
    23 #include FT_TRUETYPE_TAGS_H
       
    24 
       
    25 #include "ttpload.h"
       
    26 
       
    27 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
       
    28 #include "ttgxvar.h"
       
    29 #endif
       
    30 
       
    31 #include "tterrors.h"
       
    32 
       
    33 
       
    34   /*************************************************************************/
       
    35   /*                                                                       */
       
    36   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
       
    37   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
       
    38   /* messages during execution.                                            */
       
    39   /*                                                                       */
       
    40 #undef  FT_COMPONENT
       
    41 #define FT_COMPONENT  trace_ttpload
       
    42 
       
    43 
       
    44   /*************************************************************************/
       
    45   /*                                                                       */
       
    46   /* <Function>                                                            */
       
    47   /*    tt_face_load_loca                                                  */
       
    48   /*                                                                       */
       
    49   /* <Description>                                                         */
       
    50   /*    Load the locations table.                                          */
       
    51   /*                                                                       */
       
    52   /* <InOut>                                                               */
       
    53   /*    face   :: A handle to the target face object.                      */
       
    54   /*                                                                       */
       
    55   /* <Input>                                                               */
       
    56   /*    stream :: The input stream.                                        */
       
    57   /*                                                                       */
       
    58   /* <Return>                                                              */
       
    59   /*    FreeType error code.  0 means success.                             */
       
    60   /*                                                                       */
       
    61   FT_LOCAL_DEF( FT_Error )
       
    62   tt_face_load_loca( TT_Face    face,
       
    63                      FT_Stream  stream )
       
    64   {
       
    65     FT_Error  error;
       
    66     FT_ULong  table_len;
       
    67     FT_Int    shift;
       
    68 
       
    69 
       
    70     /* we need the size of the `glyf' table for malformed `loca' tables */
       
    71     error = face->goto_table( face, TTAG_glyf, stream, &face->glyf_len );
       
    72 
       
    73     /* it is possible that a font doesn't have a glyf table at all */
       
    74     /* or its size is zero                                         */
       
    75     if ( error == TT_Err_Table_Missing )
       
    76       face->glyf_len = 0;
       
    77     else if ( error )
       
    78       goto Exit;
       
    79 
       
    80     FT_TRACE2(( "Locations " ));
       
    81     error = face->goto_table( face, TTAG_loca, stream, &table_len );
       
    82     if ( error )
       
    83     {
       
    84       error = TT_Err_Locations_Missing;
       
    85       goto Exit;
       
    86     }
       
    87 
       
    88     if ( face->header.Index_To_Loc_Format != 0 )
       
    89     {
       
    90       shift = 2;
       
    91 
       
    92       if ( table_len >= 0x40000L )
       
    93       {
       
    94         FT_TRACE2(( "table too large\n" ));
       
    95         error = TT_Err_Invalid_Table;
       
    96         goto Exit;
       
    97       }
       
    98       face->num_locations = table_len >> shift;
       
    99     }
       
   100     else
       
   101     {
       
   102       shift = 1;
       
   103 
       
   104       if ( table_len >= 0x20000L )
       
   105       {
       
   106         FT_TRACE2(( "table too large\n" ));
       
   107         error = TT_Err_Invalid_Table;
       
   108         goto Exit;
       
   109       }
       
   110       face->num_locations = table_len >> shift;
       
   111     }
       
   112 
       
   113     if ( face->num_locations != (FT_ULong)face->root.num_glyphs + 1 )
       
   114     {
       
   115       FT_TRACE2(( "glyph count mismatch!  loca: %d, maxp: %d\n",
       
   116                   face->num_locations - 1, face->root.num_glyphs ));
       
   117 
       
   118       /* we only handle the case where `maxp' gives a larger value */
       
   119       if ( face->num_locations <= (FT_ULong)face->root.num_glyphs )
       
   120       {
       
   121         FT_Long   new_loca_len =
       
   122                     ( (FT_Long)( face->root.num_glyphs ) + 1 ) << shift;
       
   123 
       
   124         TT_Table  entry = face->dir_tables;
       
   125         TT_Table  limit = entry + face->num_tables;
       
   126 
       
   127         FT_Long   pos  = FT_Stream_Pos( stream );
       
   128         FT_Long   dist = 0x7FFFFFFFL;
       
   129 
       
   130 
       
   131         /* compute the distance to next table in font file */
       
   132         for ( ; entry < limit; entry++ )
       
   133         {
       
   134           FT_Long  diff = entry->Offset - pos;
       
   135 
       
   136 
       
   137           if ( diff > 0 && diff < dist )
       
   138             dist = diff;
       
   139         }
       
   140 
       
   141         if ( entry == limit )
       
   142         {
       
   143           /* `loca' is the last table */
       
   144           dist = stream->size - pos;
       
   145         }
       
   146 
       
   147         if ( new_loca_len <= dist )
       
   148         {
       
   149           face->num_locations = face->root.num_glyphs + 1;
       
   150           table_len           = new_loca_len;
       
   151 
       
   152           FT_TRACE2(( "adjusting num_locations to %d\n",
       
   153                       face->num_locations ));
       
   154         }
       
   155       }
       
   156     }
       
   157 
       
   158     /*
       
   159      * Extract the frame.  We don't need to decompress it since
       
   160      * we are able to parse it directly.
       
   161      */
       
   162     if ( FT_FRAME_EXTRACT( table_len, face->glyph_locations ) )
       
   163       goto Exit;
       
   164 
       
   165     FT_TRACE2(( "loaded\n" ));
       
   166 
       
   167   Exit:
       
   168     return error;
       
   169   }
       
   170 
       
   171 
       
   172   FT_LOCAL_DEF( FT_ULong )
       
   173   tt_face_get_location( TT_Face   face,
       
   174                         FT_UInt   gindex,
       
   175                         FT_UInt  *asize )
       
   176   {
       
   177     FT_ULong  pos1, pos2;
       
   178     FT_Byte*  p;
       
   179     FT_Byte*  p_limit;
       
   180 
       
   181 
       
   182     pos1 = pos2 = 0;
       
   183 
       
   184     if ( gindex < face->num_locations )
       
   185     {
       
   186       if ( face->header.Index_To_Loc_Format != 0 )
       
   187       {
       
   188         p       = face->glyph_locations + gindex * 4;
       
   189         p_limit = face->glyph_locations + face->num_locations * 4;
       
   190 
       
   191         pos1 = FT_NEXT_ULONG( p );
       
   192         pos2 = pos1;
       
   193 
       
   194         if ( p + 4 <= p_limit )
       
   195           pos2 = FT_NEXT_ULONG( p );
       
   196       }
       
   197       else
       
   198       {
       
   199         p       = face->glyph_locations + gindex * 2;
       
   200         p_limit = face->glyph_locations + face->num_locations * 2;
       
   201 
       
   202         pos1 = FT_NEXT_USHORT( p );
       
   203         pos2 = pos1;
       
   204 
       
   205         if ( p + 2 <= p_limit )
       
   206           pos2 = FT_NEXT_USHORT( p );
       
   207 
       
   208         pos1 <<= 1;
       
   209         pos2 <<= 1;
       
   210       }
       
   211     }
       
   212 
       
   213     /* Check broken location data */
       
   214     if ( pos1 >= face->glyf_len )
       
   215     {
       
   216       FT_TRACE1(( "tt_face_get_location:"
       
   217                  " too large offset=0x%08lx found for gid=0x%04lx,"
       
   218                  " exceeding the end of glyf table (0x%08lx)\n",
       
   219                  pos1, gindex, face->glyf_len ));
       
   220       *asize = 0;
       
   221       return 0;
       
   222     }
       
   223 
       
   224     if ( pos2 >= face->glyf_len )
       
   225     {
       
   226       FT_TRACE1(( "tt_face_get_location:"
       
   227                  " too large offset=0x%08lx found for gid=0x%04lx,"
       
   228                  " truncate at the end of glyf table (0x%08lx)\n",
       
   229                  pos2, gindex + 1, face->glyf_len ));
       
   230       pos2 = face->glyf_len;
       
   231     }
       
   232 
       
   233     /* The `loca' table must be ordered; it refers to the length of */
       
   234     /* an entry as the difference between the current and the next  */
       
   235     /* position.  However, there do exist (malformed) fonts which   */
       
   236     /* don't obey this rule, so we are only able to provide an      */
       
   237     /* upper bound for the size.                                    */
       
   238     /*                                                              */
       
   239     /* We get (intentionally) a wrong, non-zero result in case the  */
       
   240     /* `glyf' table is missing.                                     */
       
   241     if ( pos2 >= pos1 )
       
   242       *asize = (FT_UInt)( pos2 - pos1 );
       
   243     else
       
   244       *asize = (FT_UInt)( face->glyf_len - pos1 );
       
   245 
       
   246     return pos1;
       
   247   }
       
   248 
       
   249 
       
   250   FT_LOCAL_DEF( void )
       
   251   tt_face_done_loca( TT_Face  face )
       
   252   {
       
   253     FT_Stream  stream = face->root.stream;
       
   254 
       
   255 
       
   256     FT_FRAME_RELEASE( face->glyph_locations );
       
   257     face->num_locations = 0;
       
   258   }
       
   259 
       
   260 
       
   261 
       
   262   /*************************************************************************/
       
   263   /*                                                                       */
       
   264   /* <Function>                                                            */
       
   265   /*    tt_face_load_cvt                                                   */
       
   266   /*                                                                       */
       
   267   /* <Description>                                                         */
       
   268   /*    Load the control value table into a face object.                   */
       
   269   /*                                                                       */
       
   270   /* <InOut>                                                               */
       
   271   /*    face   :: A handle to the target face object.                      */
       
   272   /*                                                                       */
       
   273   /* <Input>                                                               */
       
   274   /*    stream :: A handle to the input stream.                            */
       
   275   /*                                                                       */
       
   276   /* <Return>                                                              */
       
   277   /*    FreeType error code.  0 means success.                             */
       
   278   /*                                                                       */
       
   279   FT_LOCAL_DEF( FT_Error )
       
   280   tt_face_load_cvt( TT_Face    face,
       
   281                     FT_Stream  stream )
       
   282   {
       
   283 #ifdef TT_USE_BYTECODE_INTERPRETER
       
   284 
       
   285     FT_Error   error;
       
   286     FT_Memory  memory = stream->memory;
       
   287     FT_ULong   table_len;
       
   288 
       
   289 
       
   290     FT_TRACE2(( "CVT " ));
       
   291 
       
   292     error = face->goto_table( face, TTAG_cvt, stream, &table_len );
       
   293     if ( error )
       
   294     {
       
   295       FT_TRACE2(( "is missing\n" ));
       
   296 
       
   297       face->cvt_size = 0;
       
   298       face->cvt      = NULL;
       
   299       error          = TT_Err_Ok;
       
   300 
       
   301       goto Exit;
       
   302     }
       
   303 
       
   304     face->cvt_size = table_len / 2;
       
   305 
       
   306     if ( FT_NEW_ARRAY( face->cvt, face->cvt_size ) )
       
   307       goto Exit;
       
   308 
       
   309     if ( FT_FRAME_ENTER( face->cvt_size * 2L ) )
       
   310       goto Exit;
       
   311 
       
   312     {
       
   313       FT_Short*  cur   = face->cvt;
       
   314       FT_Short*  limit = cur + face->cvt_size;
       
   315 
       
   316 
       
   317       for ( ; cur < limit; cur++ )
       
   318         *cur = FT_GET_SHORT();
       
   319     }
       
   320 
       
   321     FT_FRAME_EXIT();
       
   322     FT_TRACE2(( "loaded\n" ));
       
   323 
       
   324 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT
       
   325     if ( face->doblend )
       
   326       error = tt_face_vary_cvt( face, stream );
       
   327 #endif
       
   328 
       
   329   Exit:
       
   330     return error;
       
   331 
       
   332 #else /* !TT_USE_BYTECODE_INTERPRETER */
       
   333 
       
   334     FT_UNUSED( face   );
       
   335     FT_UNUSED( stream );
       
   336 
       
   337     return TT_Err_Ok;
       
   338 
       
   339 #endif
       
   340   }
       
   341 
       
   342 
       
   343   /*************************************************************************/
       
   344   /*                                                                       */
       
   345   /* <Function>                                                            */
       
   346   /*    tt_face_load_fpgm                                                  */
       
   347   /*                                                                       */
       
   348   /* <Description>                                                         */
       
   349   /*    Load the font program.                                             */
       
   350   /*                                                                       */
       
   351   /* <InOut>                                                               */
       
   352   /*    face   :: A handle to the target face object.                      */
       
   353   /*                                                                       */
       
   354   /* <Input>                                                               */
       
   355   /*    stream :: A handle to the input stream.                            */
       
   356   /*                                                                       */
       
   357   /* <Return>                                                              */
       
   358   /*    FreeType error code.  0 means success.                             */
       
   359   /*                                                                       */
       
   360   FT_LOCAL_DEF( FT_Error )
       
   361   tt_face_load_fpgm( TT_Face    face,
       
   362                      FT_Stream  stream )
       
   363   {
       
   364 #ifdef TT_USE_BYTECODE_INTERPRETER
       
   365 
       
   366     FT_Error  error;
       
   367     FT_ULong  table_len;
       
   368 
       
   369 
       
   370     FT_TRACE2(( "Font program " ));
       
   371 
       
   372     /* The font program is optional */
       
   373     error = face->goto_table( face, TTAG_fpgm, stream, &table_len );
       
   374     if ( error )
       
   375     {
       
   376       face->font_program      = NULL;
       
   377       face->font_program_size = 0;
       
   378       error                   = TT_Err_Ok;
       
   379 
       
   380       FT_TRACE2(( "is missing\n" ));
       
   381     }
       
   382     else
       
   383     {
       
   384       face->font_program_size = table_len;
       
   385       if ( FT_FRAME_EXTRACT( table_len, face->font_program ) )
       
   386         goto Exit;
       
   387 
       
   388       FT_TRACE2(( "loaded, %12d bytes\n", face->font_program_size ));
       
   389     }
       
   390 
       
   391   Exit:
       
   392     return error;
       
   393 
       
   394 #else /* !TT_USE_BYTECODE_INTERPRETER */
       
   395 
       
   396     FT_UNUSED( face   );
       
   397     FT_UNUSED( stream );
       
   398 
       
   399     return TT_Err_Ok;
       
   400 
       
   401 #endif
       
   402   }
       
   403 
       
   404 
       
   405   /*************************************************************************/
       
   406   /*                                                                       */
       
   407   /* <Function>                                                            */
       
   408   /*    tt_face_load_prep                                                  */
       
   409   /*                                                                       */
       
   410   /* <Description>                                                         */
       
   411   /*    Load the cvt program.                                              */
       
   412   /*                                                                       */
       
   413   /* <InOut>                                                               */
       
   414   /*    face   :: A handle to the target face object.                      */
       
   415   /*                                                                       */
       
   416   /* <Input>                                                               */
       
   417   /*    stream :: A handle to the input stream.                            */
       
   418   /*                                                                       */
       
   419   /* <Return>                                                              */
       
   420   /*    FreeType error code.  0 means success.                             */
       
   421   /*                                                                       */
       
   422   FT_LOCAL_DEF( FT_Error )
       
   423   tt_face_load_prep( TT_Face    face,
       
   424                      FT_Stream  stream )
       
   425   {
       
   426 #ifdef TT_USE_BYTECODE_INTERPRETER
       
   427 
       
   428     FT_Error  error;
       
   429     FT_ULong  table_len;
       
   430 
       
   431 
       
   432     FT_TRACE2(( "Prep program " ));
       
   433 
       
   434     error = face->goto_table( face, TTAG_prep, stream, &table_len );
       
   435     if ( error )
       
   436     {
       
   437       face->cvt_program      = NULL;
       
   438       face->cvt_program_size = 0;
       
   439       error                  = TT_Err_Ok;
       
   440 
       
   441       FT_TRACE2(( "is missing\n" ));
       
   442     }
       
   443     else
       
   444     {
       
   445       face->cvt_program_size = table_len;
       
   446       if ( FT_FRAME_EXTRACT( table_len, face->cvt_program ) )
       
   447         goto Exit;
       
   448 
       
   449       FT_TRACE2(( "loaded, %12d bytes\n", face->cvt_program_size ));
       
   450     }
       
   451 
       
   452   Exit:
       
   453     return error;
       
   454 
       
   455 #else /* !TT_USE_BYTECODE_INTERPRETER */
       
   456 
       
   457     FT_UNUSED( face   );
       
   458     FT_UNUSED( stream );
       
   459 
       
   460     return TT_Err_Ok;
       
   461 
       
   462 #endif
       
   463   }
       
   464 
       
   465 
       
   466   /*************************************************************************/
       
   467   /*                                                                       */
       
   468   /* <Function>                                                            */
       
   469   /*    tt_face_load_hdmx                                                  */
       
   470   /*                                                                       */
       
   471   /* <Description>                                                         */
       
   472   /*    Load the `hdmx' table into the face object.                        */
       
   473   /*                                                                       */
       
   474   /* <Input>                                                               */
       
   475   /*    face   :: A handle to the target face object.                      */
       
   476   /*                                                                       */
       
   477   /*    stream :: A handle to the input stream.                            */
       
   478   /*                                                                       */
       
   479   /* <Return>                                                              */
       
   480   /*    FreeType error code.  0 means success.                             */
       
   481   /*                                                                       */
       
   482 
       
   483   FT_LOCAL_DEF( FT_Error )
       
   484   tt_face_load_hdmx( TT_Face    face,
       
   485                      FT_Stream  stream )
       
   486   {
       
   487     FT_Error   error;
       
   488     FT_Memory  memory = stream->memory;
       
   489     FT_UInt    version, nn, num_records;
       
   490     FT_ULong   table_size, record_size;
       
   491     FT_Byte*   p;
       
   492     FT_Byte*   limit;
       
   493 
       
   494 
       
   495     /* this table is optional */
       
   496     error = face->goto_table( face, TTAG_hdmx, stream, &table_size );
       
   497     if ( error || table_size < 8 )
       
   498       return TT_Err_Ok;
       
   499 
       
   500     if ( FT_FRAME_EXTRACT( table_size, face->hdmx_table ) )
       
   501       goto Exit;
       
   502 
       
   503     p     = face->hdmx_table;
       
   504     limit = p + table_size;
       
   505 
       
   506     version     = FT_NEXT_USHORT( p );
       
   507     num_records = FT_NEXT_USHORT( p );
       
   508     record_size = FT_NEXT_ULONG( p );
       
   509 
       
   510     /* The maximum number of bytes in an hdmx device record is the */
       
   511     /* maximum number of glyphs + 2; this is 0xFFFF + 2; this is   */
       
   512     /* the reason why `record_size' is a long (which we read as    */
       
   513     /* unsigned long for convenience).  In practice, two bytes     */
       
   514     /* sufficient to hold the size value.                          */
       
   515     /*                                                             */
       
   516     /* There are at least two fonts, HANNOM-A and HANNOM-B version */
       
   517     /* 2.0 (2005), which get this wrong: The upper two bytes of    */
       
   518     /* the size value are set to 0xFF instead of 0x00.  We catch   */
       
   519     /* and fix this.                                               */
       
   520 
       
   521     if ( record_size >= 0xFFFF0000UL )
       
   522       record_size &= 0xFFFFU;
       
   523 
       
   524     /* The limit for `num_records' is a heuristic value. */
       
   525 
       
   526     if ( version != 0 || num_records > 255 || record_size > 0x10001L )
       
   527     {
       
   528       error = TT_Err_Invalid_File_Format;
       
   529       goto Fail;
       
   530     }
       
   531 
       
   532     if ( FT_NEW_ARRAY( face->hdmx_record_sizes, num_records ) )
       
   533       goto Fail;
       
   534 
       
   535     for ( nn = 0; nn < num_records; nn++ )
       
   536     {
       
   537       if ( p + record_size > limit )
       
   538         break;
       
   539 
       
   540       face->hdmx_record_sizes[nn] = p[0];
       
   541       p                          += record_size;
       
   542     }
       
   543 
       
   544     face->hdmx_record_count = nn;
       
   545     face->hdmx_table_size   = table_size;
       
   546     face->hdmx_record_size  = record_size;
       
   547 
       
   548   Exit:
       
   549     return error;
       
   550 
       
   551   Fail:
       
   552     FT_FRAME_RELEASE( face->hdmx_table );
       
   553     face->hdmx_table_size = 0;
       
   554     goto Exit;
       
   555   }
       
   556 
       
   557 
       
   558   FT_LOCAL_DEF( void )
       
   559   tt_face_free_hdmx( TT_Face  face )
       
   560   {
       
   561     FT_Stream  stream = face->root.stream;
       
   562     FT_Memory  memory = stream->memory;
       
   563 
       
   564 
       
   565     FT_FREE( face->hdmx_record_sizes );
       
   566     FT_FRAME_RELEASE( face->hdmx_table );
       
   567   }
       
   568 
       
   569 
       
   570   /*************************************************************************/
       
   571   /*                                                                       */
       
   572   /* Return the advance width table for a given pixel size if it is found  */
       
   573   /* in the font's `hdmx' table (if any).                                  */
       
   574   /*                                                                       */
       
   575   FT_LOCAL_DEF( FT_Byte* )
       
   576   tt_face_get_device_metrics( TT_Face  face,
       
   577                               FT_UInt  ppem,
       
   578                               FT_UInt  gindex )
       
   579   {
       
   580     FT_UInt   nn;
       
   581     FT_Byte*  result      = NULL;
       
   582     FT_ULong  record_size = face->hdmx_record_size;
       
   583     FT_Byte*  record      = face->hdmx_table + 8;
       
   584 
       
   585 
       
   586     for ( nn = 0; nn < face->hdmx_record_count; nn++ )
       
   587       if ( face->hdmx_record_sizes[nn] == ppem )
       
   588       {
       
   589         gindex += 2;
       
   590         if ( gindex < record_size )
       
   591           result = record + nn * record_size + gindex;
       
   592         break;
       
   593       }
       
   594 
       
   595     return result;
       
   596   }
       
   597 
       
   598 
       
   599 /* END */