thirdparty/freetype-2.3.12/src/sfnt/ttbdf.c

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  ttbdf.c                                                                */
   4 /*                                                                         */
   5 /*    TrueType and OpenType embedded BDF properties (body).                */
   6 /*                                                                         */
   7 /*  Copyright 2005, 2006 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_STREAM_H
  22 #include FT_TRUETYPE_TAGS_H
  23 #include "ttbdf.h"
  24
  25 #include "sferrors.h"
  26
  27
  28 #ifdef TT_CONFIG_OPTION_BDF
  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_ttbdf
  38
  39
  40   FT_LOCAL_DEF( void )
  41   tt_face_free_bdf_props( TT_Face  face )
  42   {
  43     TT_BDF  bdf = &face->bdf;
  44
  45
  46     if ( bdf->loaded )
  47     {
  48       FT_Stream  stream = FT_FACE(face)->stream;
  49
  50
  51       if ( bdf->table != NULL )
  52         FT_FRAME_RELEASE( bdf->table );
  53
  54       bdf->table_end    = NULL;
  55       bdf->strings      = NULL;
  56       bdf->strings_size = 0;
  57     }
  58   }
  59
  60
  61   static FT_Error
  62   tt_face_load_bdf_props( TT_Face    face,
  63                           FT_Stream  stream )
  64   {
  65     TT_BDF    bdf = &face->bdf;
  66     FT_ULong  length;
  67     FT_Error  error;
  68
  69
  70     FT_ZERO( bdf );
  71
  72     error = tt_face_goto_table( face, TTAG_BDF, stream, &length );
  73     if ( error                                  ||
  74          length < 8                             ||
  75          FT_FRAME_EXTRACT( length, bdf->table ) )
  76     {
  77       error = FT_Err_Invalid_Table;
  78       goto Exit;
  79     }
  80
  81     bdf->table_end = bdf->table + length;
  82
  83     {
  84       FT_Byte*   p           = bdf->table;
  85       FT_UInt    version     = FT_NEXT_USHORT( p );
  86       FT_UInt    num_strikes = FT_NEXT_USHORT( p );
  87       FT_ULong   strings     = FT_NEXT_ULONG ( p );
  88       FT_UInt    count;
  89       FT_Byte*   strike;
  90
  91
  92       if ( version != 0x0001                 ||
  93            strings < 8                       ||
  94            ( strings - 8 ) / 4 < num_strikes ||
  95            strings + 1 > length              )
  96       {
  97         goto BadTable;
  98       }
  99
 100       bdf->num_strikes  = num_strikes;
 101       bdf->strings      = bdf->table + strings;
 102       bdf->strings_size = length - strings;
 103
 104       count  = bdf->num_strikes;
 105       p      = bdf->table + 8;
 106       strike = p + count * 4;
 107
 108
 109       for ( ; count > 0; count-- )
 110       {
 111         FT_UInt  num_items = FT_PEEK_USHORT( p + 2 );
 112
 113         /*
 114          *  We don't need to check the value sets themselves, since this
 115          *  is done later.
 116          */
 117         strike += 10 * num_items;
 118
 119         p += 4;
 120       }
 121
 122       if ( strike > bdf->strings )
 123         goto BadTable;
 124     }
 125
 126     bdf->loaded = 1;
 127
 128   Exit:
 129     return error;
 130
 131   BadTable:
 132     FT_FRAME_RELEASE( bdf->table );
 133     FT_ZERO( bdf );
 134     error = FT_Err_Invalid_Table;
 135     goto Exit;
 136   }
 137
 138
 139   FT_LOCAL_DEF( FT_Error )
 140   tt_face_find_bdf_prop( TT_Face           face,
 141                          const char*       property_name,
 142                          BDF_PropertyRec  *aprop )
 143   {
 144     TT_BDF     bdf   = &face->bdf;
 145     FT_Size    size  = FT_FACE(face)->size;
 146     FT_Error   error = 0;
 147     FT_Byte*   p;
 148     FT_UInt    count;
 149     FT_Byte*   strike;
 150     FT_Offset  property_len;
 151
 152
 153     aprop->type = BDF_PROPERTY_TYPE_NONE;
 154
 155     if ( bdf->loaded == 0 )
 156     {
 157       error = tt_face_load_bdf_props( face, FT_FACE( face )->stream );
 158       if ( error )
 159         goto Exit;
 160     }
 161
 162     count  = bdf->num_strikes;
 163     p      = bdf->table + 8;
 164     strike = p + 4 * count;
 165
 166     error = FT_Err_Invalid_Argument;
 167
 168     if ( size == NULL || property_name == NULL )
 169       goto Exit;
 170
 171     property_len = ft_strlen( property_name );
 172     if ( property_len == 0 )
 173       goto Exit;
 174
 175     for ( ; count > 0; count-- )
 176     {
 177       FT_UInt  _ppem  = FT_NEXT_USHORT( p );
 178       FT_UInt  _count = FT_NEXT_USHORT( p );
 179
 180       if ( _ppem == size->metrics.y_ppem )
 181       {
 182         count = _count;
 183         goto FoundStrike;
 184       }
 185
 186       strike += 10 * _count;
 187     }
 188     goto Exit;
 189
 190   FoundStrike:
 191     p = strike;
 192     for ( ; count > 0; count-- )
 193     {
 194       FT_UInt  type = FT_PEEK_USHORT( p + 4 );
 195
 196       if ( ( type & 0x10 ) != 0 )
 197       {
 198         FT_UInt32  name_offset = FT_PEEK_ULONG( p     );
 199         FT_UInt32  value       = FT_PEEK_ULONG( p + 6 );
 200
 201         /* be a bit paranoid for invalid entries here */
 202         if ( name_offset < bdf->strings_size                    &&
 203              property_len < bdf->strings_size - name_offset     &&
 204              ft_strncmp( property_name,
 205                          (const char*)bdf->strings + name_offset,
 206                          bdf->strings_size - name_offset ) == 0 )
 207         {
 208           switch ( type & 0x0F )
 209           {
 210           case 0x00:  /* string */
 211           case 0x01:  /* atoms */
 212             /* check that the content is really 0-terminated */
 213             if ( value < bdf->strings_size &&
 214                  ft_memchr( bdf->strings + value, 0, bdf->strings_size ) )
 215             {
 216               aprop->type   = BDF_PROPERTY_TYPE_ATOM;
 217               aprop->u.atom = (const char*)bdf->strings + value;
 218               error         = 0;
 219               goto Exit;
 220             }
 221             break;
 222
 223           case 0x02:
 224             aprop->type      = BDF_PROPERTY_TYPE_INTEGER;
 225             aprop->u.integer = (FT_Int32)value;
 226             error            = 0;
 227             goto Exit;
 228
 229           case 0x03:
 230             aprop->type       = BDF_PROPERTY_TYPE_CARDINAL;
 231             aprop->u.cardinal = value;
 232             error             = 0;
 233             goto Exit;
 234
 235           default:
 236             ;
 237           }
 238         }
 239       }
 240       p += 10;
 241     }
 242
 243   Exit:
 244     return error;
 245   }
 246
 247 #endif /* TT_CONFIG_OPTION_BDF */
 248
 249
 250 /* END */