Visualization Library 2.0.0-b5

A lightweight C++ OpenGL middleware for 2D/3D graphics

VL     Star     Watch     Fork     Issue

[Download] [Tutorials] [All Classes] [Grouped Classes]
ttbdf.c
Go to the documentation of this file.
1 /***************************************************************************/
2 /* */
3 /* ttbdf.c */
4 /* */
5 /* TrueType and OpenType embedded BDF properties (body). */
6 /* */
7 /* Copyright 2005, 2006, 2010, 2013 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 )
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,
64  {
65  TT_BDF bdf = &face->bdf;
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_THROW( Invalid_Table );
78  goto Exit;
79  }
80 
81  bdf->table_end = bdf->table + length;
82 
83  {
84  FT_Byte* p = bdf->table;
86  FT_UInt num_strikes = FT_NEXT_USHORT( 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_THROW( Invalid_Table );
135  goto Exit;
136  }
137 
138 
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 = FT_Err_Ok;
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 = FT_Err_Ok;
219  goto Exit;
220  }
221  break;
222 
223  case 0x02:
225  aprop->u.integer = (FT_Int32)value;
226  error = FT_Err_Ok;
227  goto Exit;
228 
229  case 0x03:
231  aprop->u.cardinal = value;
232  error = FT_Err_Ok;
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 */
GLenum GLuint GLenum GLsizei length
int FT_Error
Definition: fttypes.h:296
GLuint GLuint stream
#define ft_strncmp
Definition: ftstdlib.h:88
unsigned long FT_ULong
Definition: fttypes.h:249
GLfloat GLfloat p
FT_BEGIN_HEADER tt_face_free_bdf_props(TT_Face face)
#define NULL
Definition: ftobjs.h:61
#define ft_memchr
Definition: ftstdlib.h:79
GLsizei const GLchar *const * strings
return FT_THROW(Missing_Property)
unsigned int FT_UInt32
Definition: ftconfig.h:133
return FT_Err_Ok
Definition: ftbbox.c:645
GLenum GLuint GLint GLenum face
unsigned char FT_Byte
Definition: fttypes.h:150
FT_Int32 integer
Definition: ftbdf.h:122
#define FT_PEEK_ULONG(p)
Definition: ftstream.h:179
#define FT_ERR(e)
Definition: fttypes.h:582
FT_Error error
Definition: cffdrivr.c:411
#define FT_ZERO(p)
Definition: ftmemory.h:210
const char * atom
Definition: ftbdf.h:121
signed int FT_Int32
Definition: ftconfig.h:132
int const char * version
Definition: zlib.h:813
#define FT_PEEK_USHORT(p)
Definition: ftstream.h:171
GLsizei const GLfloat * value
#define TTAG_BDF
Definition: tttags.h:39
BDF_PropertyType type
Definition: ftbdf.h:119
#define FT_NEXT_USHORT(buffer)
Definition: ftstream.h:226
#define FT_FRAME_RELEASE(bytes)
Definition: ftstream.h:522
GLenum type
#define FT_FACE(x)
Definition: ftobjs.h:557
unsigned int FT_UInt
Definition: fttypes.h:227
#define FT_NEXT_ULONG(buffer)
Definition: ftstream.h:238
#define FT_FRAME_EXTRACT(size, bytes)
Definition: ftstream.h:517
GLuint GLuint GLsizei count
const char * property_name
Definition: cffdrivr.c:581
GLsizeiptr size
tt_face_goto_table(TT_Face face, FT_ULong tag, FT_Stream stream, FT_ULong *length)
Definition: ttload.c:126
#define ft_strlen
Definition: ftstdlib.h:87
FT_Size_Metrics metrics
Definition: freetype.h:1406
#define FT_LOCAL_DEF(x)
Definition: ftconfig.h:236
tt_face_find_bdf_prop(TT_Face face, const char *property_name, BDF_PropertyRec *aprop)
size_t FT_Offset
Definition: fttypes.h:320
FT_UShort y_ppem
Definition: freetype.h:1370
union BDF_PropertyRec_::@0 u
FT_UInt32 cardinal
Definition: ftbdf.h:123