misc/libfreetype/src/pcf/pcfread.c
changeset 5172 88f2e05288ba
equal deleted inserted replaced
5171:f9283dc4860d 5172:88f2e05288ba
       
     1 /*  pcfread.c
       
     2 
       
     3     FreeType font driver for pcf fonts
       
     4 
       
     5   Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
       
     6             2010 by
       
     7   Francesco Zappa Nardelli
       
     8 
       
     9 Permission is hereby granted, free of charge, to any person obtaining a copy
       
    10 of this software and associated documentation files (the "Software"), to deal
       
    11 in the Software without restriction, including without limitation the rights
       
    12 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
       
    13 copies of the Software, and to permit persons to whom the Software is
       
    14 furnished to do so, subject to the following conditions:
       
    15 
       
    16 The above copyright notice and this permission notice shall be included in
       
    17 all copies or substantial portions of the Software.
       
    18 
       
    19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
       
    20 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
       
    21 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
       
    22 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
       
    23 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
       
    24 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
       
    25 THE SOFTWARE.
       
    26 */
       
    27 
       
    28 
       
    29 #include <ft2build.h>
       
    30 
       
    31 #include FT_INTERNAL_DEBUG_H
       
    32 #include FT_INTERNAL_STREAM_H
       
    33 #include FT_INTERNAL_OBJECTS_H
       
    34 
       
    35 #include "pcf.h"
       
    36 #include "pcfread.h"
       
    37 
       
    38 #include "pcferror.h"
       
    39 
       
    40 
       
    41   /*************************************************************************/
       
    42   /*                                                                       */
       
    43   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
       
    44   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
       
    45   /* messages during execution.                                            */
       
    46   /*                                                                       */
       
    47 #undef  FT_COMPONENT
       
    48 #define FT_COMPONENT  trace_pcfread
       
    49 
       
    50 
       
    51 #ifdef FT_DEBUG_LEVEL_TRACE
       
    52   static const char* const  tableNames[] =
       
    53   {
       
    54     "prop", "accl", "mtrcs", "bmps", "imtrcs",
       
    55     "enc", "swidth", "names", "accel"
       
    56   };
       
    57 #endif
       
    58 
       
    59 
       
    60   static
       
    61   const FT_Frame_Field  pcf_toc_header[] =
       
    62   {
       
    63 #undef  FT_STRUCTURE
       
    64 #define FT_STRUCTURE  PCF_TocRec
       
    65 
       
    66     FT_FRAME_START( 8 ),
       
    67       FT_FRAME_ULONG_LE( version ),
       
    68       FT_FRAME_ULONG_LE( count ),
       
    69     FT_FRAME_END
       
    70   };
       
    71 
       
    72 
       
    73   static
       
    74   const FT_Frame_Field  pcf_table_header[] =
       
    75   {
       
    76 #undef  FT_STRUCTURE
       
    77 #define FT_STRUCTURE  PCF_TableRec
       
    78 
       
    79     FT_FRAME_START( 16  ),
       
    80       FT_FRAME_ULONG_LE( type ),
       
    81       FT_FRAME_ULONG_LE( format ),
       
    82       FT_FRAME_ULONG_LE( size ),
       
    83       FT_FRAME_ULONG_LE( offset ),
       
    84     FT_FRAME_END
       
    85   };
       
    86 
       
    87 
       
    88   static FT_Error
       
    89   pcf_read_TOC( FT_Stream  stream,
       
    90                 PCF_Face   face )
       
    91   {
       
    92     FT_Error   error;
       
    93     PCF_Toc    toc = &face->toc;
       
    94     PCF_Table  tables;
       
    95 
       
    96     FT_Memory  memory = FT_FACE(face)->memory;
       
    97     FT_UInt    n;
       
    98 
       
    99 
       
   100     if ( FT_STREAM_SEEK ( 0 )                          ||
       
   101          FT_STREAM_READ_FIELDS ( pcf_toc_header, toc ) )
       
   102       return PCF_Err_Cannot_Open_Resource;
       
   103 
       
   104     if ( toc->version != PCF_FILE_VERSION                 ||
       
   105          toc->count   >  FT_ARRAY_MAX( face->toc.tables ) ||
       
   106          toc->count   == 0                                )
       
   107       return PCF_Err_Invalid_File_Format;
       
   108 
       
   109     if ( FT_NEW_ARRAY( face->toc.tables, toc->count ) )
       
   110       return PCF_Err_Out_Of_Memory;
       
   111 
       
   112     tables = face->toc.tables;
       
   113     for ( n = 0; n < toc->count; n++ )
       
   114     {
       
   115       if ( FT_STREAM_READ_FIELDS( pcf_table_header, tables ) )
       
   116         goto Exit;
       
   117       tables++;
       
   118     }
       
   119 
       
   120     /* Sort tables and check for overlaps.  Because they are almost      */
       
   121     /* always ordered already, an in-place bubble sort with simultaneous */
       
   122     /* boundary checking seems appropriate.                              */
       
   123     tables = face->toc.tables;
       
   124 
       
   125     for ( n = 0; n < toc->count - 1; n++ )
       
   126     {
       
   127       FT_UInt  i, have_change;
       
   128 
       
   129 
       
   130       have_change = 0;
       
   131 
       
   132       for ( i = 0; i < toc->count - 1 - n; i++ )
       
   133       {
       
   134         PCF_TableRec  tmp;
       
   135 
       
   136 
       
   137         if ( tables[i].offset > tables[i + 1].offset )
       
   138         {
       
   139           tmp           = tables[i];
       
   140           tables[i]     = tables[i + 1];
       
   141           tables[i + 1] = tmp;
       
   142 
       
   143           have_change = 1;
       
   144         }
       
   145 
       
   146         if ( ( tables[i].size   > tables[i + 1].offset )                  ||
       
   147              ( tables[i].offset > tables[i + 1].offset - tables[i].size ) )
       
   148           return PCF_Err_Invalid_Offset;
       
   149       }
       
   150 
       
   151       if ( !have_change )
       
   152         break;
       
   153     }
       
   154 
       
   155 #ifdef FT_DEBUG_LEVEL_TRACE
       
   156 
       
   157     {
       
   158       FT_UInt      i, j;
       
   159       const char*  name = "?";
       
   160 
       
   161 
       
   162       FT_TRACE4(( "pcf_read_TOC:\n" ));
       
   163 
       
   164       FT_TRACE4(( "  number of tables: %ld\n", face->toc.count ));
       
   165 
       
   166       tables = face->toc.tables;
       
   167       for ( i = 0; i < toc->count; i++ )
       
   168       {
       
   169         for ( j = 0; j < sizeof ( tableNames ) / sizeof ( tableNames[0] );
       
   170               j++ )
       
   171           if ( tables[i].type == (FT_UInt)( 1 << j ) )
       
   172             name = tableNames[j];
       
   173 
       
   174         FT_TRACE4(( "  %d: type=%s, format=0x%X, "
       
   175                     "size=%ld (0x%lX), offset=%ld (0x%lX)\n",
       
   176                     i, name,
       
   177                     tables[i].format,
       
   178                     tables[i].size, tables[i].size,
       
   179                     tables[i].offset, tables[i].offset ));
       
   180       }
       
   181     }
       
   182 
       
   183 #endif
       
   184 
       
   185     return PCF_Err_Ok;
       
   186 
       
   187   Exit:
       
   188     FT_FREE( face->toc.tables );
       
   189     return error;
       
   190   }
       
   191 
       
   192 
       
   193 #define PCF_METRIC_SIZE  12
       
   194 
       
   195   static
       
   196   const FT_Frame_Field  pcf_metric_header[] =
       
   197   {
       
   198 #undef  FT_STRUCTURE
       
   199 #define FT_STRUCTURE  PCF_MetricRec
       
   200 
       
   201     FT_FRAME_START( PCF_METRIC_SIZE ),
       
   202       FT_FRAME_SHORT_LE( leftSideBearing ),
       
   203       FT_FRAME_SHORT_LE( rightSideBearing ),
       
   204       FT_FRAME_SHORT_LE( characterWidth ),
       
   205       FT_FRAME_SHORT_LE( ascent ),
       
   206       FT_FRAME_SHORT_LE( descent ),
       
   207       FT_FRAME_SHORT_LE( attributes ),
       
   208     FT_FRAME_END
       
   209   };
       
   210 
       
   211 
       
   212   static
       
   213   const FT_Frame_Field  pcf_metric_msb_header[] =
       
   214   {
       
   215 #undef  FT_STRUCTURE
       
   216 #define FT_STRUCTURE  PCF_MetricRec
       
   217 
       
   218     FT_FRAME_START( PCF_METRIC_SIZE ),
       
   219       FT_FRAME_SHORT( leftSideBearing ),
       
   220       FT_FRAME_SHORT( rightSideBearing ),
       
   221       FT_FRAME_SHORT( characterWidth ),
       
   222       FT_FRAME_SHORT( ascent ),
       
   223       FT_FRAME_SHORT( descent ),
       
   224       FT_FRAME_SHORT( attributes ),
       
   225     FT_FRAME_END
       
   226   };
       
   227 
       
   228 
       
   229 #define PCF_COMPRESSED_METRIC_SIZE  5
       
   230 
       
   231   static
       
   232   const FT_Frame_Field  pcf_compressed_metric_header[] =
       
   233   {
       
   234 #undef  FT_STRUCTURE
       
   235 #define FT_STRUCTURE  PCF_Compressed_MetricRec
       
   236 
       
   237     FT_FRAME_START( PCF_COMPRESSED_METRIC_SIZE ),
       
   238       FT_FRAME_BYTE( leftSideBearing ),
       
   239       FT_FRAME_BYTE( rightSideBearing ),
       
   240       FT_FRAME_BYTE( characterWidth ),
       
   241       FT_FRAME_BYTE( ascent ),
       
   242       FT_FRAME_BYTE( descent ),
       
   243     FT_FRAME_END
       
   244   };
       
   245 
       
   246 
       
   247   static FT_Error
       
   248   pcf_get_metric( FT_Stream   stream,
       
   249                   FT_ULong    format,
       
   250                   PCF_Metric  metric )
       
   251   {
       
   252     FT_Error  error = PCF_Err_Ok;
       
   253 
       
   254 
       
   255     if ( PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
       
   256     {
       
   257       const FT_Frame_Field*  fields;
       
   258 
       
   259 
       
   260       /* parsing normal metrics */
       
   261       fields = PCF_BYTE_ORDER( format ) == MSBFirst
       
   262                ? pcf_metric_msb_header
       
   263                : pcf_metric_header;
       
   264 
       
   265       /* the following sets `error' but doesn't return in case of failure */
       
   266       (void)FT_STREAM_READ_FIELDS( fields, metric );
       
   267     }
       
   268     else
       
   269     {
       
   270       PCF_Compressed_MetricRec  compr;
       
   271 
       
   272 
       
   273       /* parsing compressed metrics */
       
   274       if ( FT_STREAM_READ_FIELDS( pcf_compressed_metric_header, &compr ) )
       
   275         goto Exit;
       
   276 
       
   277       metric->leftSideBearing  = (FT_Short)( compr.leftSideBearing  - 0x80 );
       
   278       metric->rightSideBearing = (FT_Short)( compr.rightSideBearing - 0x80 );
       
   279       metric->characterWidth   = (FT_Short)( compr.characterWidth   - 0x80 );
       
   280       metric->ascent           = (FT_Short)( compr.ascent           - 0x80 );
       
   281       metric->descent          = (FT_Short)( compr.descent          - 0x80 );
       
   282       metric->attributes       = 0;
       
   283     }
       
   284 
       
   285   Exit:
       
   286     return error;
       
   287   }
       
   288 
       
   289 
       
   290   static FT_Error
       
   291   pcf_seek_to_table_type( FT_Stream  stream,
       
   292                           PCF_Table  tables,
       
   293                           FT_ULong   ntables, /* same as PCF_Toc->count */
       
   294                           FT_ULong   type,
       
   295                           FT_ULong  *aformat,
       
   296                           FT_ULong  *asize )
       
   297   {
       
   298     FT_Error  error = PCF_Err_Invalid_File_Format;
       
   299     FT_ULong  i;
       
   300 
       
   301 
       
   302     for ( i = 0; i < ntables; i++ )
       
   303       if ( tables[i].type == type )
       
   304       {
       
   305         if ( stream->pos > tables[i].offset )
       
   306         {
       
   307           error = PCF_Err_Invalid_Stream_Skip;
       
   308           goto Fail;
       
   309         }
       
   310 
       
   311         if ( FT_STREAM_SKIP( tables[i].offset - stream->pos ) )
       
   312         {
       
   313           error = PCF_Err_Invalid_Stream_Skip;
       
   314           goto Fail;
       
   315         }
       
   316 
       
   317         *asize   = tables[i].size;
       
   318         *aformat = tables[i].format;
       
   319 
       
   320         return PCF_Err_Ok;
       
   321       }
       
   322 
       
   323   Fail:
       
   324     *asize = 0;
       
   325     return error;
       
   326   }
       
   327 
       
   328 
       
   329   static FT_Bool
       
   330   pcf_has_table_type( PCF_Table  tables,
       
   331                       FT_ULong   ntables, /* same as PCF_Toc->count */
       
   332                       FT_ULong   type )
       
   333   {
       
   334     FT_ULong  i;
       
   335 
       
   336 
       
   337     for ( i = 0; i < ntables; i++ )
       
   338       if ( tables[i].type == type )
       
   339         return TRUE;
       
   340 
       
   341     return FALSE;
       
   342   }
       
   343 
       
   344 
       
   345 #define PCF_PROPERTY_SIZE  9
       
   346 
       
   347   static
       
   348   const FT_Frame_Field  pcf_property_header[] =
       
   349   {
       
   350 #undef  FT_STRUCTURE
       
   351 #define FT_STRUCTURE  PCF_ParsePropertyRec
       
   352 
       
   353     FT_FRAME_START( PCF_PROPERTY_SIZE ),
       
   354       FT_FRAME_LONG_LE( name ),
       
   355       FT_FRAME_BYTE   ( isString ),
       
   356       FT_FRAME_LONG_LE( value ),
       
   357     FT_FRAME_END
       
   358   };
       
   359 
       
   360 
       
   361   static
       
   362   const FT_Frame_Field  pcf_property_msb_header[] =
       
   363   {
       
   364 #undef  FT_STRUCTURE
       
   365 #define FT_STRUCTURE  PCF_ParsePropertyRec
       
   366 
       
   367     FT_FRAME_START( PCF_PROPERTY_SIZE ),
       
   368       FT_FRAME_LONG( name ),
       
   369       FT_FRAME_BYTE( isString ),
       
   370       FT_FRAME_LONG( value ),
       
   371     FT_FRAME_END
       
   372   };
       
   373 
       
   374 
       
   375   FT_LOCAL_DEF( PCF_Property )
       
   376   pcf_find_property( PCF_Face          face,
       
   377                      const FT_String*  prop )
       
   378   {
       
   379     PCF_Property  properties = face->properties;
       
   380     FT_Bool       found      = 0;
       
   381     int           i;
       
   382 
       
   383 
       
   384     for ( i = 0 ; i < face->nprops && !found; i++ )
       
   385     {
       
   386       if ( !ft_strcmp( properties[i].name, prop ) )
       
   387         found = 1;
       
   388     }
       
   389 
       
   390     if ( found )
       
   391       return properties + i - 1;
       
   392     else
       
   393       return NULL;
       
   394   }
       
   395 
       
   396 
       
   397   static FT_Error
       
   398   pcf_get_properties( FT_Stream  stream,
       
   399                       PCF_Face   face )
       
   400   {
       
   401     PCF_ParseProperty  props      = 0;
       
   402     PCF_Property       properties;
       
   403     FT_ULong           nprops, i;
       
   404     FT_ULong           format, size;
       
   405     FT_Error           error;
       
   406     FT_Memory          memory     = FT_FACE(face)->memory;
       
   407     FT_ULong           string_size;
       
   408     FT_String*         strings    = 0;
       
   409 
       
   410 
       
   411     error = pcf_seek_to_table_type( stream,
       
   412                                     face->toc.tables,
       
   413                                     face->toc.count,
       
   414                                     PCF_PROPERTIES,
       
   415                                     &format,
       
   416                                     &size );
       
   417     if ( error )
       
   418       goto Bail;
       
   419 
       
   420     if ( FT_READ_ULONG_LE( format ) )
       
   421       goto Bail;
       
   422 
       
   423     FT_TRACE4(( "pcf_get_properties:\n" ));
       
   424 
       
   425     FT_TRACE4(( "  format = %ld\n", format ));
       
   426 
       
   427     if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
       
   428       goto Bail;
       
   429 
       
   430     if ( PCF_BYTE_ORDER( format ) == MSBFirst )
       
   431       (void)FT_READ_ULONG( nprops );
       
   432     else
       
   433       (void)FT_READ_ULONG_LE( nprops );
       
   434     if ( error )
       
   435       goto Bail;
       
   436 
       
   437     FT_TRACE4(( "  nprop = %d (truncate %d props)\n",
       
   438                 (int)nprops, nprops - (int)nprops ));
       
   439 
       
   440     nprops = (int)nprops;
       
   441 
       
   442     /* rough estimate */
       
   443     if ( nprops > size / PCF_PROPERTY_SIZE )
       
   444     {
       
   445       error = PCF_Err_Invalid_Table;
       
   446       goto Bail;
       
   447     }
       
   448 
       
   449     face->nprops = (int)nprops;
       
   450 
       
   451     if ( FT_NEW_ARRAY( props, nprops ) )
       
   452       goto Bail;
       
   453 
       
   454     for ( i = 0; i < nprops; i++ )
       
   455     {
       
   456       if ( PCF_BYTE_ORDER( format ) == MSBFirst )
       
   457       {
       
   458         if ( FT_STREAM_READ_FIELDS( pcf_property_msb_header, props + i ) )
       
   459           goto Bail;
       
   460       }
       
   461       else
       
   462       {
       
   463         if ( FT_STREAM_READ_FIELDS( pcf_property_header, props + i ) )
       
   464           goto Bail;
       
   465       }
       
   466     }
       
   467 
       
   468     /* pad the property array                                            */
       
   469     /*                                                                   */
       
   470     /* clever here - nprops is the same as the number of odd-units read, */
       
   471     /* as only isStringProp are odd length   (Keith Packard)             */
       
   472     /*                                                                   */
       
   473     if ( nprops & 3 )
       
   474     {
       
   475       i = 4 - ( nprops & 3 );
       
   476       if ( FT_STREAM_SKIP( i ) )
       
   477       {
       
   478         error = PCF_Err_Invalid_Stream_Skip;
       
   479         goto Bail;
       
   480       }
       
   481     }
       
   482 
       
   483     if ( PCF_BYTE_ORDER( format ) == MSBFirst )
       
   484       (void)FT_READ_ULONG( string_size );
       
   485     else
       
   486       (void)FT_READ_ULONG_LE( string_size );
       
   487     if ( error )
       
   488       goto Bail;
       
   489 
       
   490     FT_TRACE4(( "  string_size = %ld\n", string_size ));
       
   491 
       
   492     /* rough estimate */
       
   493     if ( string_size > size - nprops * PCF_PROPERTY_SIZE )
       
   494     {
       
   495       error = PCF_Err_Invalid_Table;
       
   496       goto Bail;
       
   497     }
       
   498 
       
   499     if ( FT_NEW_ARRAY( strings, string_size ) )
       
   500       goto Bail;
       
   501 
       
   502     error = FT_Stream_Read( stream, (FT_Byte*)strings, string_size );
       
   503     if ( error )
       
   504       goto Bail;
       
   505 
       
   506     if ( FT_NEW_ARRAY( properties, nprops ) )
       
   507       goto Bail;
       
   508 
       
   509     face->properties = properties;
       
   510 
       
   511     for ( i = 0; i < nprops; i++ )
       
   512     {
       
   513       FT_Long  name_offset = props[i].name;
       
   514 
       
   515 
       
   516       if ( ( name_offset < 0 )                     ||
       
   517            ( (FT_ULong)name_offset > string_size ) )
       
   518       {
       
   519         error = PCF_Err_Invalid_Offset;
       
   520         goto Bail;
       
   521       }
       
   522 
       
   523       if ( FT_STRDUP( properties[i].name, strings + name_offset ) )
       
   524         goto Bail;
       
   525 
       
   526       FT_TRACE4(( "  %s:", properties[i].name ));
       
   527 
       
   528       properties[i].isString = props[i].isString;
       
   529 
       
   530       if ( props[i].isString )
       
   531       {
       
   532         FT_Long  value_offset = props[i].value;
       
   533 
       
   534 
       
   535         if ( ( value_offset < 0 )                     ||
       
   536              ( (FT_ULong)value_offset > string_size ) )
       
   537         {
       
   538           error = PCF_Err_Invalid_Offset;
       
   539           goto Bail;
       
   540         }
       
   541 
       
   542         if ( FT_STRDUP( properties[i].value.atom, strings + value_offset ) )
       
   543           goto Bail;
       
   544 
       
   545         FT_TRACE4(( " `%s'\n", properties[i].value.atom ));
       
   546       }
       
   547       else
       
   548       {
       
   549         properties[i].value.l = props[i].value;
       
   550 
       
   551         FT_TRACE4(( " %d\n", properties[i].value.l ));
       
   552       }
       
   553     }
       
   554 
       
   555     error = PCF_Err_Ok;
       
   556 
       
   557   Bail:
       
   558     FT_FREE( props );
       
   559     FT_FREE( strings );
       
   560 
       
   561     return error;
       
   562   }
       
   563 
       
   564 
       
   565   static FT_Error
       
   566   pcf_get_metrics( FT_Stream  stream,
       
   567                    PCF_Face   face )
       
   568   {
       
   569     FT_Error    error    = PCF_Err_Ok;
       
   570     FT_Memory   memory   = FT_FACE(face)->memory;
       
   571     FT_ULong    format, size;
       
   572     PCF_Metric  metrics  = 0;
       
   573     FT_ULong    nmetrics, i;
       
   574 
       
   575 
       
   576     error = pcf_seek_to_table_type( stream,
       
   577                                     face->toc.tables,
       
   578                                     face->toc.count,
       
   579                                     PCF_METRICS,
       
   580                                     &format,
       
   581                                     &size );
       
   582     if ( error )
       
   583       return error;
       
   584 
       
   585     if ( FT_READ_ULONG_LE( format ) )
       
   586       goto Bail;
       
   587 
       
   588     if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT )     &&
       
   589          !PCF_FORMAT_MATCH( format, PCF_COMPRESSED_METRICS ) )
       
   590       return PCF_Err_Invalid_File_Format;
       
   591 
       
   592     if ( PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
       
   593     {
       
   594       if ( PCF_BYTE_ORDER( format ) == MSBFirst )
       
   595         (void)FT_READ_ULONG( nmetrics );
       
   596       else
       
   597         (void)FT_READ_ULONG_LE( nmetrics );
       
   598     }
       
   599     else
       
   600     {
       
   601       if ( PCF_BYTE_ORDER( format ) == MSBFirst )
       
   602         (void)FT_READ_USHORT( nmetrics );
       
   603       else
       
   604         (void)FT_READ_USHORT_LE( nmetrics );
       
   605     }
       
   606     if ( error )
       
   607       return PCF_Err_Invalid_File_Format;
       
   608 
       
   609     face->nmetrics = nmetrics;
       
   610 
       
   611     if ( !nmetrics )
       
   612       return PCF_Err_Invalid_Table;
       
   613 
       
   614     FT_TRACE4(( "pcf_get_metrics:\n" ));
       
   615 
       
   616     FT_TRACE4(( "  number of metrics: %d\n", nmetrics ));
       
   617 
       
   618     /* rough estimate */
       
   619     if ( PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
       
   620     {
       
   621       if ( nmetrics > size / PCF_METRIC_SIZE )
       
   622         return PCF_Err_Invalid_Table;
       
   623     }
       
   624     else
       
   625     {
       
   626       if ( nmetrics > size / PCF_COMPRESSED_METRIC_SIZE )
       
   627         return PCF_Err_Invalid_Table;
       
   628     }
       
   629 
       
   630     if ( FT_NEW_ARRAY( face->metrics, nmetrics ) )
       
   631       return PCF_Err_Out_Of_Memory;
       
   632 
       
   633     metrics = face->metrics;
       
   634     for ( i = 0; i < nmetrics; i++ )
       
   635     {
       
   636       error = pcf_get_metric( stream, format, metrics + i );
       
   637 
       
   638       metrics[i].bits = 0;
       
   639 
       
   640       FT_TRACE5(( "  idx %d: width=%d, "
       
   641                   "lsb=%d, rsb=%d, ascent=%d, descent=%d, swidth=%d\n",
       
   642                   i,
       
   643                   ( metrics + i )->characterWidth,
       
   644                   ( metrics + i )->leftSideBearing,
       
   645                   ( metrics + i )->rightSideBearing,
       
   646                   ( metrics + i )->ascent,
       
   647                   ( metrics + i )->descent,
       
   648                   ( metrics + i )->attributes ));
       
   649 
       
   650       if ( error )
       
   651         break;
       
   652     }
       
   653 
       
   654     if ( error )
       
   655       FT_FREE( face->metrics );
       
   656 
       
   657   Bail:
       
   658     return error;
       
   659   }
       
   660 
       
   661 
       
   662   static FT_Error
       
   663   pcf_get_bitmaps( FT_Stream  stream,
       
   664                    PCF_Face   face )
       
   665   {
       
   666     FT_Error   error  = PCF_Err_Ok;
       
   667     FT_Memory  memory = FT_FACE(face)->memory;
       
   668     FT_Long*   offsets;
       
   669     FT_Long    bitmapSizes[GLYPHPADOPTIONS];
       
   670     FT_ULong   format, size;
       
   671     FT_ULong   nbitmaps, i, sizebitmaps = 0;
       
   672 
       
   673 
       
   674     error = pcf_seek_to_table_type( stream,
       
   675                                     face->toc.tables,
       
   676                                     face->toc.count,
       
   677                                     PCF_BITMAPS,
       
   678                                     &format,
       
   679                                     &size );
       
   680     if ( error )
       
   681       return error;
       
   682 
       
   683     error = FT_Stream_EnterFrame( stream, 8 );
       
   684     if ( error )
       
   685       return error;
       
   686 
       
   687     format = FT_GET_ULONG_LE();
       
   688     if ( PCF_BYTE_ORDER( format ) == MSBFirst )
       
   689       nbitmaps  = FT_GET_ULONG();
       
   690     else
       
   691       nbitmaps  = FT_GET_ULONG_LE();
       
   692 
       
   693     FT_Stream_ExitFrame( stream );
       
   694 
       
   695     if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
       
   696       return PCF_Err_Invalid_File_Format;
       
   697 
       
   698     FT_TRACE4(( "pcf_get_bitmaps:\n" ));
       
   699 
       
   700     FT_TRACE4(( "  number of bitmaps: %d\n", nbitmaps ));
       
   701 
       
   702     /* XXX: PCF_Face->nmetrics is singed FT_Long, see pcf.h */
       
   703     if ( face->nmetrics < 0 || nbitmaps != ( FT_ULong )face->nmetrics )
       
   704       return PCF_Err_Invalid_File_Format;
       
   705 
       
   706     if ( FT_NEW_ARRAY( offsets, nbitmaps ) )
       
   707       return error;
       
   708 
       
   709     for ( i = 0; i < nbitmaps; i++ )
       
   710     {
       
   711       if ( PCF_BYTE_ORDER( format ) == MSBFirst )
       
   712         (void)FT_READ_LONG( offsets[i] );
       
   713       else
       
   714         (void)FT_READ_LONG_LE( offsets[i] );
       
   715 
       
   716       FT_TRACE5(( "  bitmap %d: offset %ld (0x%lX)\n",
       
   717                   i, offsets[i], offsets[i] ));
       
   718     }
       
   719     if ( error )
       
   720       goto Bail;
       
   721 
       
   722     for ( i = 0; i < GLYPHPADOPTIONS; i++ )
       
   723     {
       
   724       if ( PCF_BYTE_ORDER( format ) == MSBFirst )
       
   725         (void)FT_READ_LONG( bitmapSizes[i] );
       
   726       else
       
   727         (void)FT_READ_LONG_LE( bitmapSizes[i] );
       
   728       if ( error )
       
   729         goto Bail;
       
   730 
       
   731       sizebitmaps = bitmapSizes[PCF_GLYPH_PAD_INDEX( format )];
       
   732 
       
   733       FT_TRACE4(( "  padding %d implies a size of %ld\n", i, bitmapSizes[i] ));
       
   734     }
       
   735 
       
   736     FT_TRACE4(( "  %d bitmaps, padding index %ld\n",
       
   737                 nbitmaps,
       
   738                 PCF_GLYPH_PAD_INDEX( format ) ));
       
   739     FT_TRACE4(( "  bitmap size = %d\n", sizebitmaps ));
       
   740 
       
   741     FT_UNUSED( sizebitmaps );       /* only used for debugging */
       
   742 
       
   743     for ( i = 0; i < nbitmaps; i++ )
       
   744     {
       
   745       /* rough estimate */
       
   746       if ( ( offsets[i] < 0 )              ||
       
   747            ( (FT_ULong)offsets[i] > size ) )
       
   748       {
       
   749         FT_TRACE0(( "pcf_get_bitmaps:"
       
   750                     " invalid offset to bitmap data of glyph %d\n", i ));
       
   751       }
       
   752       else
       
   753         face->metrics[i].bits = stream->pos + offsets[i];
       
   754     }
       
   755 
       
   756     face->bitmapsFormat = format;
       
   757 
       
   758   Bail:
       
   759     FT_FREE( offsets );
       
   760     return error;
       
   761   }
       
   762 
       
   763 
       
   764   static FT_Error
       
   765   pcf_get_encodings( FT_Stream  stream,
       
   766                      PCF_Face   face )
       
   767   {
       
   768     FT_Error      error  = PCF_Err_Ok;
       
   769     FT_Memory     memory = FT_FACE(face)->memory;
       
   770     FT_ULong      format, size;
       
   771     int           firstCol, lastCol;
       
   772     int           firstRow, lastRow;
       
   773     int           nencoding, encodingOffset;
       
   774     int           i, j;
       
   775     PCF_Encoding  tmpEncoding, encoding = 0;
       
   776 
       
   777 
       
   778     error = pcf_seek_to_table_type( stream,
       
   779                                     face->toc.tables,
       
   780                                     face->toc.count,
       
   781                                     PCF_BDF_ENCODINGS,
       
   782                                     &format,
       
   783                                     &size );
       
   784     if ( error )
       
   785       return error;
       
   786 
       
   787     error = FT_Stream_EnterFrame( stream, 14 );
       
   788     if ( error )
       
   789       return error;
       
   790 
       
   791     format = FT_GET_ULONG_LE();
       
   792 
       
   793     if ( PCF_BYTE_ORDER( format ) == MSBFirst )
       
   794     {
       
   795       firstCol          = FT_GET_SHORT();
       
   796       lastCol           = FT_GET_SHORT();
       
   797       firstRow          = FT_GET_SHORT();
       
   798       lastRow           = FT_GET_SHORT();
       
   799       face->defaultChar = FT_GET_SHORT();
       
   800     }
       
   801     else
       
   802     {
       
   803       firstCol          = FT_GET_SHORT_LE();
       
   804       lastCol           = FT_GET_SHORT_LE();
       
   805       firstRow          = FT_GET_SHORT_LE();
       
   806       lastRow           = FT_GET_SHORT_LE();
       
   807       face->defaultChar = FT_GET_SHORT_LE();
       
   808     }
       
   809 
       
   810     FT_Stream_ExitFrame( stream );
       
   811 
       
   812     if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )
       
   813       return PCF_Err_Invalid_File_Format;
       
   814 
       
   815     FT_TRACE4(( "pdf_get_encodings:\n" ));
       
   816 
       
   817     FT_TRACE4(( "  firstCol %d, lastCol %d, firstRow %d, lastRow %d\n",
       
   818                 firstCol, lastCol, firstRow, lastRow ));
       
   819 
       
   820     nencoding = ( lastCol - firstCol + 1 ) * ( lastRow - firstRow + 1 );
       
   821 
       
   822     if ( FT_NEW_ARRAY( tmpEncoding, nencoding ) )
       
   823       return PCF_Err_Out_Of_Memory;
       
   824 
       
   825     error = FT_Stream_EnterFrame( stream, 2 * nencoding );
       
   826     if ( error )
       
   827       goto Bail;
       
   828 
       
   829     for ( i = 0, j = 0 ; i < nencoding; i++ )
       
   830     {
       
   831       if ( PCF_BYTE_ORDER( format ) == MSBFirst )
       
   832         encodingOffset = FT_GET_SHORT();
       
   833       else
       
   834         encodingOffset = FT_GET_SHORT_LE();
       
   835 
       
   836       if ( encodingOffset != -1 )
       
   837       {
       
   838         tmpEncoding[j].enc = ( ( ( i / ( lastCol - firstCol + 1 ) ) +
       
   839                                  firstRow ) * 256 ) +
       
   840                                ( ( i % ( lastCol - firstCol + 1 ) ) +
       
   841                                  firstCol );
       
   842 
       
   843         tmpEncoding[j].glyph = (FT_Short)encodingOffset;
       
   844 
       
   845         FT_TRACE5(( "  code %d (0x%04X): idx %d\n",
       
   846                     tmpEncoding[j].enc, tmpEncoding[j].enc,
       
   847                     tmpEncoding[j].glyph ));
       
   848 
       
   849         j++;
       
   850       }
       
   851     }
       
   852     FT_Stream_ExitFrame( stream );
       
   853 
       
   854     if ( FT_NEW_ARRAY( encoding, j ) )
       
   855       goto Bail;
       
   856 
       
   857     for ( i = 0; i < j; i++ )
       
   858     {
       
   859       encoding[i].enc   = tmpEncoding[i].enc;
       
   860       encoding[i].glyph = tmpEncoding[i].glyph;
       
   861     }
       
   862 
       
   863     face->nencodings = j;
       
   864     face->encodings  = encoding;
       
   865     FT_FREE( tmpEncoding );
       
   866 
       
   867     return error;
       
   868 
       
   869   Bail:
       
   870     FT_FREE( encoding );
       
   871     FT_FREE( tmpEncoding );
       
   872     return error;
       
   873   }
       
   874 
       
   875 
       
   876   static
       
   877   const FT_Frame_Field  pcf_accel_header[] =
       
   878   {
       
   879 #undef  FT_STRUCTURE
       
   880 #define FT_STRUCTURE  PCF_AccelRec
       
   881 
       
   882     FT_FRAME_START( 20 ),
       
   883       FT_FRAME_BYTE      ( noOverlap ),
       
   884       FT_FRAME_BYTE      ( constantMetrics ),
       
   885       FT_FRAME_BYTE      ( terminalFont ),
       
   886       FT_FRAME_BYTE      ( constantWidth ),
       
   887       FT_FRAME_BYTE      ( inkInside ),
       
   888       FT_FRAME_BYTE      ( inkMetrics ),
       
   889       FT_FRAME_BYTE      ( drawDirection ),
       
   890       FT_FRAME_SKIP_BYTES( 1 ),
       
   891       FT_FRAME_LONG_LE   ( fontAscent ),
       
   892       FT_FRAME_LONG_LE   ( fontDescent ),
       
   893       FT_FRAME_LONG_LE   ( maxOverlap ),
       
   894     FT_FRAME_END
       
   895   };
       
   896 
       
   897 
       
   898   static
       
   899   const FT_Frame_Field  pcf_accel_msb_header[] =
       
   900   {
       
   901 #undef  FT_STRUCTURE
       
   902 #define FT_STRUCTURE  PCF_AccelRec
       
   903 
       
   904     FT_FRAME_START( 20 ),
       
   905       FT_FRAME_BYTE      ( noOverlap ),
       
   906       FT_FRAME_BYTE      ( constantMetrics ),
       
   907       FT_FRAME_BYTE      ( terminalFont ),
       
   908       FT_FRAME_BYTE      ( constantWidth ),
       
   909       FT_FRAME_BYTE      ( inkInside ),
       
   910       FT_FRAME_BYTE      ( inkMetrics ),
       
   911       FT_FRAME_BYTE      ( drawDirection ),
       
   912       FT_FRAME_SKIP_BYTES( 1 ),
       
   913       FT_FRAME_LONG      ( fontAscent ),
       
   914       FT_FRAME_LONG      ( fontDescent ),
       
   915       FT_FRAME_LONG      ( maxOverlap ),
       
   916     FT_FRAME_END
       
   917   };
       
   918 
       
   919 
       
   920   static FT_Error
       
   921   pcf_get_accel( FT_Stream  stream,
       
   922                  PCF_Face   face,
       
   923                  FT_ULong   type )
       
   924   {
       
   925     FT_ULong   format, size;
       
   926     FT_Error   error = PCF_Err_Ok;
       
   927     PCF_Accel  accel = &face->accel;
       
   928 
       
   929 
       
   930     error = pcf_seek_to_table_type( stream,
       
   931                                     face->toc.tables,
       
   932                                     face->toc.count,
       
   933                                     type,
       
   934                                     &format,
       
   935                                     &size );
       
   936     if ( error )
       
   937       goto Bail;
       
   938 
       
   939     if ( FT_READ_ULONG_LE( format ) )
       
   940       goto Bail;
       
   941 
       
   942     if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT )    &&
       
   943          !PCF_FORMAT_MATCH( format, PCF_ACCEL_W_INKBOUNDS ) )
       
   944       goto Bail;
       
   945 
       
   946     if ( PCF_BYTE_ORDER( format ) == MSBFirst )
       
   947     {
       
   948       if ( FT_STREAM_READ_FIELDS( pcf_accel_msb_header, accel ) )
       
   949         goto Bail;
       
   950     }
       
   951     else
       
   952     {
       
   953       if ( FT_STREAM_READ_FIELDS( pcf_accel_header, accel ) )
       
   954         goto Bail;
       
   955     }
       
   956 
       
   957     error = pcf_get_metric( stream,
       
   958                             format & ( ~PCF_FORMAT_MASK ),
       
   959                             &(accel->minbounds) );
       
   960     if ( error )
       
   961       goto Bail;
       
   962 
       
   963     error = pcf_get_metric( stream,
       
   964                             format & ( ~PCF_FORMAT_MASK ),
       
   965                             &(accel->maxbounds) );
       
   966     if ( error )
       
   967       goto Bail;
       
   968 
       
   969     if ( PCF_FORMAT_MATCH( format, PCF_ACCEL_W_INKBOUNDS ) )
       
   970     {
       
   971       error = pcf_get_metric( stream,
       
   972                               format & ( ~PCF_FORMAT_MASK ),
       
   973                               &(accel->ink_minbounds) );
       
   974       if ( error )
       
   975         goto Bail;
       
   976 
       
   977       error = pcf_get_metric( stream,
       
   978                               format & ( ~PCF_FORMAT_MASK ),
       
   979                               &(accel->ink_maxbounds) );
       
   980       if ( error )
       
   981         goto Bail;
       
   982     }
       
   983     else
       
   984     {
       
   985       accel->ink_minbounds = accel->minbounds; /* I'm not sure about this */
       
   986       accel->ink_maxbounds = accel->maxbounds;
       
   987     }
       
   988 
       
   989   Bail:
       
   990     return error;
       
   991   }
       
   992 
       
   993 
       
   994   static FT_Error
       
   995   pcf_interpret_style( PCF_Face  pcf )
       
   996   {
       
   997     FT_Error   error  = PCF_Err_Ok;
       
   998     FT_Face    face   = FT_FACE( pcf );
       
   999     FT_Memory  memory = face->memory;
       
  1000 
       
  1001     PCF_Property  prop;
       
  1002 
       
  1003     size_t  nn, len;
       
  1004     char*   strings[4] = { NULL, NULL, NULL, NULL };
       
  1005     size_t  lengths[4];
       
  1006 
       
  1007 
       
  1008     face->style_flags = 0;
       
  1009 
       
  1010     prop = pcf_find_property( pcf, "SLANT" );
       
  1011     if ( prop && prop->isString                                       &&
       
  1012          ( *(prop->value.atom) == 'O' || *(prop->value.atom) == 'o' ||
       
  1013            *(prop->value.atom) == 'I' || *(prop->value.atom) == 'i' ) )
       
  1014     {
       
  1015       face->style_flags |= FT_STYLE_FLAG_ITALIC;
       
  1016       strings[2] = ( *(prop->value.atom) == 'O' ||
       
  1017                      *(prop->value.atom) == 'o' ) ? (char *)"Oblique"
       
  1018                                                   : (char *)"Italic";
       
  1019     }
       
  1020 
       
  1021     prop = pcf_find_property( pcf, "WEIGHT_NAME" );
       
  1022     if ( prop && prop->isString                                       &&
       
  1023          ( *(prop->value.atom) == 'B' || *(prop->value.atom) == 'b' ) )
       
  1024     {
       
  1025       face->style_flags |= FT_STYLE_FLAG_BOLD;
       
  1026       strings[1] = (char *)"Bold";
       
  1027     }
       
  1028 
       
  1029     prop = pcf_find_property( pcf, "SETWIDTH_NAME" );
       
  1030     if ( prop && prop->isString                                        &&
       
  1031          *(prop->value.atom)                                           &&
       
  1032          !( *(prop->value.atom) == 'N' || *(prop->value.atom) == 'n' ) )
       
  1033       strings[3] = (char *)(prop->value.atom);
       
  1034 
       
  1035     prop = pcf_find_property( pcf, "ADD_STYLE_NAME" );
       
  1036     if ( prop && prop->isString                                        &&
       
  1037          *(prop->value.atom)                                           &&
       
  1038          !( *(prop->value.atom) == 'N' || *(prop->value.atom) == 'n' ) )
       
  1039       strings[0] = (char *)(prop->value.atom);
       
  1040 
       
  1041     for ( len = 0, nn = 0; nn < 4; nn++ )
       
  1042     {
       
  1043       lengths[nn] = 0;
       
  1044       if ( strings[nn] )
       
  1045       {
       
  1046         lengths[nn] = ft_strlen( strings[nn] );
       
  1047         len        += lengths[nn] + 1;
       
  1048       }
       
  1049     }
       
  1050 
       
  1051     if ( len == 0 )
       
  1052     {
       
  1053       strings[0] = (char *)"Regular";
       
  1054       lengths[0] = ft_strlen( strings[0] );
       
  1055       len        = lengths[0] + 1;
       
  1056     }
       
  1057 
       
  1058     {
       
  1059       char*  s;
       
  1060 
       
  1061 
       
  1062       if ( FT_ALLOC( face->style_name, len ) )
       
  1063         return error;
       
  1064 
       
  1065       s = face->style_name;
       
  1066 
       
  1067       for ( nn = 0; nn < 4; nn++ )
       
  1068       {
       
  1069         char*  src = strings[nn];
       
  1070 
       
  1071 
       
  1072         len = lengths[nn];
       
  1073 
       
  1074         if ( src == NULL )
       
  1075           continue;
       
  1076 
       
  1077         /* separate elements with a space */
       
  1078         if ( s != face->style_name )
       
  1079           *s++ = ' ';
       
  1080 
       
  1081         ft_memcpy( s, src, len );
       
  1082 
       
  1083         /* need to convert spaces to dashes for */
       
  1084         /* add_style_name and setwidth_name     */
       
  1085         if ( nn == 0 || nn == 3 )
       
  1086         {
       
  1087           size_t  mm;
       
  1088 
       
  1089 
       
  1090           for ( mm = 0; mm < len; mm++ )
       
  1091             if (s[mm] == ' ')
       
  1092               s[mm] = '-';
       
  1093         }
       
  1094 
       
  1095         s += len;
       
  1096       }
       
  1097       *s = 0;
       
  1098     }
       
  1099 
       
  1100     return error;
       
  1101   }
       
  1102 
       
  1103 
       
  1104   FT_LOCAL_DEF( FT_Error )
       
  1105   pcf_load_font( FT_Stream  stream,
       
  1106                  PCF_Face   face )
       
  1107   {
       
  1108     FT_Error   error  = PCF_Err_Ok;
       
  1109     FT_Memory  memory = FT_FACE(face)->memory;
       
  1110     FT_Bool    hasBDFAccelerators;
       
  1111 
       
  1112 
       
  1113     error = pcf_read_TOC( stream, face );
       
  1114     if ( error )
       
  1115       goto Exit;
       
  1116 
       
  1117     error = pcf_get_properties( stream, face );
       
  1118     if ( error )
       
  1119       goto Exit;
       
  1120 
       
  1121     /* Use the old accelerators if no BDF accelerators are in the file. */
       
  1122     hasBDFAccelerators = pcf_has_table_type( face->toc.tables,
       
  1123                                              face->toc.count,
       
  1124                                              PCF_BDF_ACCELERATORS );
       
  1125     if ( !hasBDFAccelerators )
       
  1126     {
       
  1127       error = pcf_get_accel( stream, face, PCF_ACCELERATORS );
       
  1128       if ( error )
       
  1129         goto Exit;
       
  1130     }
       
  1131 
       
  1132     /* metrics */
       
  1133     error = pcf_get_metrics( stream, face );
       
  1134     if ( error )
       
  1135       goto Exit;
       
  1136 
       
  1137     /* bitmaps */
       
  1138     error = pcf_get_bitmaps( stream, face );
       
  1139     if ( error )
       
  1140       goto Exit;
       
  1141 
       
  1142     /* encodings */
       
  1143     error = pcf_get_encodings( stream, face );
       
  1144     if ( error )
       
  1145       goto Exit;
       
  1146 
       
  1147     /* BDF style accelerators (i.e. bounds based on encoded glyphs) */
       
  1148     if ( hasBDFAccelerators )
       
  1149     {
       
  1150       error = pcf_get_accel( stream, face, PCF_BDF_ACCELERATORS );
       
  1151       if ( error )
       
  1152         goto Exit;
       
  1153     }
       
  1154 
       
  1155     /* XXX: TO DO: inkmetrics and glyph_names are missing */
       
  1156 
       
  1157     /* now construct the face object */
       
  1158     {
       
  1159       FT_Face       root = FT_FACE( face );
       
  1160       PCF_Property  prop;
       
  1161 
       
  1162 
       
  1163       root->num_faces  = 1;
       
  1164       root->face_index = 0;
       
  1165       root->face_flags = FT_FACE_FLAG_FIXED_SIZES |
       
  1166                          FT_FACE_FLAG_HORIZONTAL  |
       
  1167                          FT_FACE_FLAG_FAST_GLYPHS;
       
  1168 
       
  1169       if ( face->accel.constantWidth )
       
  1170         root->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
       
  1171 
       
  1172       if ( ( error = pcf_interpret_style( face ) ) != 0 )
       
  1173          goto Exit;
       
  1174 
       
  1175       prop = pcf_find_property( face, "FAMILY_NAME" );
       
  1176       if ( prop && prop->isString )
       
  1177       {
       
  1178         if ( FT_STRDUP( root->family_name, prop->value.atom ) )
       
  1179           goto Exit;
       
  1180       }
       
  1181       else
       
  1182         root->family_name = NULL;
       
  1183 
       
  1184       /*
       
  1185        * Note: We shift all glyph indices by +1 since we must
       
  1186        * respect the convention that glyph 0 always corresponds
       
  1187        * to the `missing glyph'.
       
  1188        *
       
  1189        * This implies bumping the number of `available' glyphs by 1.
       
  1190        */
       
  1191       root->num_glyphs = face->nmetrics + 1;
       
  1192 
       
  1193       root->num_fixed_sizes = 1;
       
  1194       if ( FT_NEW_ARRAY( root->available_sizes, 1 ) )
       
  1195         goto Exit;
       
  1196 
       
  1197       {
       
  1198         FT_Bitmap_Size*  bsize = root->available_sizes;
       
  1199         FT_Short         resolution_x = 0, resolution_y = 0;
       
  1200 
       
  1201 
       
  1202         FT_MEM_ZERO( bsize, sizeof ( FT_Bitmap_Size ) );
       
  1203 
       
  1204 #if 0
       
  1205         bsize->height = face->accel.maxbounds.ascent << 6;
       
  1206 #endif
       
  1207         bsize->height = (FT_Short)( face->accel.fontAscent +
       
  1208                                     face->accel.fontDescent );
       
  1209 
       
  1210         prop = pcf_find_property( face, "AVERAGE_WIDTH" );
       
  1211         if ( prop )
       
  1212           bsize->width = (FT_Short)( ( prop->value.l + 5 ) / 10 );
       
  1213         else
       
  1214           bsize->width = (FT_Short)( bsize->height * 2/3 );
       
  1215 
       
  1216         prop = pcf_find_property( face, "POINT_SIZE" );
       
  1217         if ( prop )
       
  1218           /* convert from 722.7 decipoints to 72 points per inch */
       
  1219           bsize->size =
       
  1220             (FT_Pos)( ( prop->value.l * 64 * 7200 + 36135L ) / 72270L );
       
  1221 
       
  1222         prop = pcf_find_property( face, "PIXEL_SIZE" );
       
  1223         if ( prop )
       
  1224           bsize->y_ppem = (FT_Short)prop->value.l << 6;
       
  1225 
       
  1226         prop = pcf_find_property( face, "RESOLUTION_X" );
       
  1227         if ( prop )
       
  1228           resolution_x = (FT_Short)prop->value.l;
       
  1229 
       
  1230         prop = pcf_find_property( face, "RESOLUTION_Y" );
       
  1231         if ( prop )
       
  1232           resolution_y = (FT_Short)prop->value.l;
       
  1233 
       
  1234         if ( bsize->y_ppem == 0 )
       
  1235         {
       
  1236           bsize->y_ppem = bsize->size;
       
  1237           if ( resolution_y )
       
  1238             bsize->y_ppem = bsize->y_ppem * resolution_y / 72;
       
  1239         }
       
  1240         if ( resolution_x && resolution_y )
       
  1241           bsize->x_ppem = bsize->y_ppem * resolution_x / resolution_y;
       
  1242         else
       
  1243           bsize->x_ppem = bsize->y_ppem;
       
  1244       }
       
  1245 
       
  1246       /* set up charset */
       
  1247       {
       
  1248         PCF_Property  charset_registry = 0, charset_encoding = 0;
       
  1249 
       
  1250 
       
  1251         charset_registry = pcf_find_property( face, "CHARSET_REGISTRY" );
       
  1252         charset_encoding = pcf_find_property( face, "CHARSET_ENCODING" );
       
  1253 
       
  1254         if ( charset_registry && charset_registry->isString &&
       
  1255              charset_encoding && charset_encoding->isString )
       
  1256         {
       
  1257           if ( FT_STRDUP( face->charset_encoding,
       
  1258                           charset_encoding->value.atom ) ||
       
  1259                FT_STRDUP( face->charset_registry,
       
  1260                           charset_registry->value.atom ) )
       
  1261             goto Exit;
       
  1262         }
       
  1263       }
       
  1264     }
       
  1265 
       
  1266   Exit:
       
  1267     if ( error )
       
  1268     {
       
  1269       /* This is done to respect the behaviour of the original */
       
  1270       /* PCF font driver.                                      */
       
  1271       error = PCF_Err_Invalid_File_Format;
       
  1272     }
       
  1273 
       
  1274     return error;
       
  1275   }
       
  1276 
       
  1277 
       
  1278 /* END */