ReactOS  0.4.14-dev-49-gfb4591c
cidgload.c
Go to the documentation of this file.
1 /***************************************************************************/
2 /* */
3 /* cidgload.c */
4 /* */
5 /* CID-keyed Type1 Glyph Loader (body). */
6 /* */
7 /* Copyright 1996-2018 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 "cidload.h"
21 #include "cidgload.h"
22 #include FT_INTERNAL_DEBUG_H
23 #include FT_INTERNAL_STREAM_H
24 #include FT_OUTLINE_H
25 #include FT_INTERNAL_CALC_H
26 
27 #include FT_INTERNAL_POSTSCRIPT_AUX_H
28 #include FT_INTERNAL_CFF_TYPES_H
29 #include FT_DRIVER_H
30 
31 #include "ciderrs.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_cidgload
42 
43 
46  FT_UInt glyph_index )
47  {
48  CID_Face face = (CID_Face)decoder->builder.face;
49  CID_FaceInfo cid = &face->cid;
50  FT_Byte* p;
51  FT_ULong fd_select;
52  FT_Stream stream = face->cid_stream;
54  FT_Byte* charstring = NULL;
55  FT_Memory memory = face->root.memory;
56  FT_ULong glyph_length = 0;
57  PSAux_Service psaux = (PSAux_Service)face->psaux;
58 
59  FT_Bool force_scaling = FALSE;
60 
61 #ifdef FT_CONFIG_OPTION_INCREMENTAL
63  face->root.internal->incremental_interface;
64 #endif
65 
66 
67  FT_TRACE1(( "cid_load_glyph: glyph index %d\n", glyph_index ));
68 
69 #ifdef FT_CONFIG_OPTION_INCREMENTAL
70 
71  /* For incremental fonts get the character data using */
72  /* the callback function. */
73  if ( inc )
74  {
75  FT_Data glyph_data;
76 
77 
78  error = inc->funcs->get_glyph_data( inc->object,
79  glyph_index, &glyph_data );
80  if ( error )
81  goto Exit;
82 
83  p = (FT_Byte*)glyph_data.pointer;
84  fd_select = cid_get_offset( &p, (FT_Byte)cid->fd_bytes );
85 
86  if ( glyph_data.length != 0 )
87  {
88  glyph_length = (FT_ULong)( glyph_data.length - cid->fd_bytes );
89  (void)FT_ALLOC( charstring, glyph_length );
90  if ( !error )
91  ft_memcpy( charstring, glyph_data.pointer + cid->fd_bytes,
92  glyph_length );
93  }
94 
95  inc->funcs->free_glyph_data( inc->object, &glyph_data );
96 
97  if ( error )
98  goto Exit;
99  }
100 
101  else
102 
103 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
104 
105  /* For ordinary fonts read the CID font dictionary index */
106  /* and charstring offset from the CIDMap. */
107  {
108  FT_UInt entry_len = (FT_UInt)( cid->fd_bytes + cid->gd_bytes );
109  FT_ULong off1, off2;
110 
111 
112  if ( FT_STREAM_SEEK( cid->data_offset + cid->cidmap_offset +
113  glyph_index * entry_len ) ||
114  FT_FRAME_ENTER( 2 * entry_len ) )
115  goto Exit;
116 
117  p = (FT_Byte*)stream->cursor;
118  fd_select = cid_get_offset( &p, (FT_Byte)cid->fd_bytes );
119  off1 = cid_get_offset( &p, (FT_Byte)cid->gd_bytes );
120  p += cid->fd_bytes;
121  off2 = cid_get_offset( &p, (FT_Byte)cid->gd_bytes );
122  FT_FRAME_EXIT();
123 
124  if ( fd_select >= (FT_ULong)cid->num_dicts ||
125  off2 > stream->size ||
126  off1 > off2 )
127  {
128  FT_TRACE0(( "cid_load_glyph: invalid glyph stream offsets\n" ));
129  error = FT_THROW( Invalid_Offset );
130  goto Exit;
131  }
132 
133  glyph_length = off2 - off1;
134  if ( glyph_length == 0 )
135  goto Exit;
136  if ( FT_ALLOC( charstring, glyph_length ) )
137  goto Exit;
138  if ( FT_STREAM_READ_AT( cid->data_offset + off1,
139  charstring, glyph_length ) )
140  goto Exit;
141  }
142 
143  /* Now set up the subrs array and parse the charstrings. */
144  {
145  CID_FaceDict dict;
146  CID_Subrs cid_subrs = face->subrs + fd_select;
147  FT_UInt cs_offset;
148 
149 
150  /* Set up subrs */
151  decoder->num_subrs = cid_subrs->num_subrs;
152  decoder->subrs = cid_subrs->code;
153  decoder->subrs_len = 0;
154  decoder->subrs_hash = NULL;
155 
156  /* Set up font matrix */
157  dict = cid->font_dicts + fd_select;
158 
159  decoder->font_matrix = dict->font_matrix;
160  decoder->font_offset = dict->font_offset;
161  decoder->lenIV = dict->private_dict.lenIV;
162 
163  /* Decode the charstring. */
164 
165  /* Adjustment for seed bytes. */
166  cs_offset = decoder->lenIV >= 0 ? (FT_UInt)decoder->lenIV : 0;
167  if ( cs_offset > glyph_length )
168  {
169  FT_TRACE0(( "cid_load_glyph: invalid glyph stream offsets\n" ));
170  error = FT_THROW( Invalid_Offset );
171  goto Exit;
172  }
173 
174  /* Decrypt only if lenIV >= 0. */
175  if ( decoder->lenIV >= 0 )
176  psaux->t1_decrypt( charstring, glyph_length, 4330 );
177 
178  /* choose which renderer to use */
179 #ifdef T1_CONFIG_OPTION_OLD_ENGINE
180  if ( ( (PS_Driver)FT_FACE_DRIVER( face ) )->hinting_engine ==
182  decoder->builder.metrics_only )
183  error = psaux->t1_decoder_funcs->parse_charstrings_old(
184  decoder,
185  charstring + cs_offset,
186  glyph_length - cs_offset );
187 #else
188  if ( decoder->builder.metrics_only )
189  error = psaux->t1_decoder_funcs->parse_metrics(
190  decoder,
191  charstring + cs_offset,
192  glyph_length - cs_offset );
193 #endif
194  else
195  {
196  PS_Decoder psdecoder;
197  CFF_SubFontRec subfont;
198 
199 
200  psaux->ps_decoder_init( &psdecoder, decoder, TRUE );
201 
202  psaux->t1_make_subfont( FT_FACE( face ),
203  &dict->private_dict,
204  &subfont );
205  psdecoder.current_subfont = &subfont;
206 
207  error = psaux->t1_decoder_funcs->parse_charstrings(
208  &psdecoder,
209  charstring + cs_offset,
210  glyph_length - cs_offset );
211 
212  /* Adobe's engine uses 16.16 numbers everywhere; */
213  /* as a consequence, glyphs larger than 2000ppem get rejected */
214  if ( FT_ERR_EQ( error, Glyph_Too_Big ) )
215  {
216  /* this time, we retry unhinted and scale up the glyph later on */
217  /* (the engine uses and sets the hardcoded value 0x10000 / 64 = */
218  /* 0x400 for both `x_scale' and `y_scale' in this case) */
219  ((CID_GlyphSlot)decoder->builder.glyph)->hint = FALSE;
220 
221  force_scaling = TRUE;
222 
223  error = psaux->t1_decoder_funcs->parse_charstrings(
224  &psdecoder,
225  charstring + cs_offset,
226  glyph_length - cs_offset );
227  }
228  }
229  }
230 
231 #ifdef FT_CONFIG_OPTION_INCREMENTAL
232 
233  /* Incremental fonts can optionally override the metrics. */
234  if ( !error && inc && inc->funcs->get_glyph_metrics )
235  {
237 
238 
239  metrics.bearing_x = FIXED_TO_INT( decoder->builder.left_bearing.x );
240  metrics.bearing_y = 0;
241  metrics.advance = FIXED_TO_INT( decoder->builder.advance.x );
242  metrics.advance_v = FIXED_TO_INT( decoder->builder.advance.y );
243 
244  error = inc->funcs->get_glyph_metrics( inc->object,
245  glyph_index, FALSE, &metrics );
246 
247  decoder->builder.left_bearing.x = INT_TO_FIXED( metrics.bearing_x );
248  decoder->builder.advance.x = INT_TO_FIXED( metrics.advance );
249  decoder->builder.advance.y = INT_TO_FIXED( metrics.advance_v );
250  }
251 
252 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
253 
254  Exit:
255  FT_FREE( charstring );
256 
257  ((CID_GlyphSlot)decoder->builder.glyph)->scaled = force_scaling;
258 
259  return error;
260  }
261 
262 
263 #if 0
264 
265 
266  /*************************************************************************/
267  /*************************************************************************/
268  /*************************************************************************/
269  /********** *********/
270  /********** *********/
271  /********** COMPUTE THE MAXIMUM ADVANCE WIDTH *********/
272  /********** *********/
273  /********** The following code is in charge of computing *********/
274  /********** the maximum advance width of the font. It *********/
275  /********** quickly processes each glyph charstring to *********/
276  /********** extract the value from either a `sbw' or `seac' *********/
277  /********** operator. *********/
278  /********** *********/
279  /*************************************************************************/
280  /*************************************************************************/
281  /*************************************************************************/
282 
283 
285  cid_face_compute_max_advance( CID_Face face,
286  FT_Int* max_advance )
287  {
288  FT_Error error;
289  T1_DecoderRec decoder;
290  FT_Int glyph_index;
291 
292  PSAux_Service psaux = (PSAux_Service)face->psaux;
293 
294 
295  *max_advance = 0;
296 
297  /* Initialize load decoder */
298  error = psaux->t1_decoder_funcs->init( &decoder,
299  (FT_Face)face,
300  0, /* size */
301  0, /* glyph slot */
302  0, /* glyph names! XXX */
303  0, /* blend == 0 */
304  0, /* hinting == 0 */
305  cid_load_glyph );
306  if ( error )
307  return error;
308 
309  /* TODO: initialize decoder.len_buildchar and decoder.buildchar */
310  /* if we ever support CID-keyed multiple master fonts */
311 
312  decoder.builder.metrics_only = 1;
313  decoder.builder.load_points = 0;
314 
315  /* for each glyph, parse the glyph charstring and extract */
316  /* the advance width */
317  for ( glyph_index = 0; glyph_index < face->root.num_glyphs;
318  glyph_index++ )
319  {
320  /* now get load the unscaled outline */
321  error = cid_load_glyph( &decoder, glyph_index );
322  /* ignore the error if one occurred - skip to next glyph */
323  }
324 
325  *max_advance = FIXED_TO_INT( decoder.builder.advance.x );
326 
327  psaux->t1_decoder_funcs->done( &decoder );
328 
329  return FT_Err_Ok;
330  }
331 
332 
333 #endif /* 0 */
334 
335 
337  cid_slot_load_glyph( FT_GlyphSlot cidglyph, /* CID_GlyphSlot */
338  FT_Size cidsize, /* CID_Size */
339  FT_UInt glyph_index,
340  FT_Int32 load_flags )
341  {
342  CID_GlyphSlot glyph = (CID_GlyphSlot)cidglyph;
343  FT_Error error;
344 #ifdef __REACTOS__
345  T1_DecoderRec *decoder = malloc(sizeof(T1_DecoderRec));
346  if (!decoder) return FT_Err_Out_Of_Memory;
347 /* Ugly but it allows us to reduce the diff */
348 #define decoder (*decoder)
349  {
350 #else
351  T1_DecoderRec decoder;
352 #endif
353  CID_Face face = (CID_Face)cidglyph->face;
354  FT_Bool hinting;
355  FT_Bool scaled;
356 
357  PSAux_Service psaux = (PSAux_Service)face->psaux;
358  FT_Matrix font_matrix;
359  FT_Vector font_offset;
360  FT_Bool must_finish_decoder = FALSE;
361 
362 
363  if ( glyph_index >= (FT_UInt)face->root.num_glyphs )
364  {
365  error = FT_THROW( Invalid_Argument );
366  goto Exit;
367  }
368 
369  if ( load_flags & FT_LOAD_NO_RECURSE )
370  load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
371 
372  glyph->x_scale = cidsize->metrics.x_scale;
373  glyph->y_scale = cidsize->metrics.y_scale;
374 
375  cidglyph->outline.n_points = 0;
376  cidglyph->outline.n_contours = 0;
377 
378  hinting = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE ) == 0 &&
379  ( load_flags & FT_LOAD_NO_HINTING ) == 0 );
380  scaled = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE ) == 0 );
381 
382  glyph->hint = hinting;
383  glyph->scaled = scaled;
384  cidglyph->format = FT_GLYPH_FORMAT_OUTLINE;
385 
386  error = psaux->t1_decoder_funcs->init( &decoder,
387  cidglyph->face,
388  cidsize,
389  cidglyph,
390  0, /* glyph names -- XXX */
391  0, /* blend == 0 */
392  hinting,
393  FT_LOAD_TARGET_MODE( load_flags ),
394  cid_load_glyph );
395  if ( error )
396  goto Exit;
397 
398  /* TODO: initialize decoder.len_buildchar and decoder.buildchar */
399  /* if we ever support CID-keyed multiple master fonts */
400 
401  must_finish_decoder = TRUE;
402 
403  /* set up the decoder */
404  decoder.builder.no_recurse = FT_BOOL(
405  ( ( load_flags & FT_LOAD_NO_RECURSE ) != 0 ) );
406 
407  error = cid_load_glyph( &decoder, glyph_index );
408  if ( error )
409  goto Exit;
410 
411  /* copy flags back for forced scaling */
412  hinting = glyph->hint;
413  scaled = glyph->scaled;
414 
415  font_matrix = decoder.font_matrix;
416  font_offset = decoder.font_offset;
417 
418  /* save new glyph tables */
419  psaux->t1_decoder_funcs->done( &decoder );
420 
421  must_finish_decoder = FALSE;
422 
423  /* now set the metrics -- this is rather simple, as */
424  /* the left side bearing is the xMin, and the top side */
425  /* bearing the yMax */
426  cidglyph->outline.flags &= FT_OUTLINE_OWNER;
427  cidglyph->outline.flags |= FT_OUTLINE_REVERSE_FILL;
428 
429  /* for composite glyphs, return only left side bearing and */
430  /* advance width */
431  if ( load_flags & FT_LOAD_NO_RECURSE )
432  {
433  FT_Slot_Internal internal = cidglyph->internal;
434 
435 
436  cidglyph->metrics.horiBearingX =
437  FIXED_TO_INT( decoder.builder.left_bearing.x );
438  cidglyph->metrics.horiAdvance =
439  FIXED_TO_INT( decoder.builder.advance.x );
440 
441  internal->glyph_matrix = font_matrix;
442  internal->glyph_delta = font_offset;
443  internal->glyph_transformed = 1;
444  }
445  else
446  {
447  FT_BBox cbox;
448  FT_Glyph_Metrics* metrics = &cidglyph->metrics;
449 
450 
451  /* copy the _unscaled_ advance width */
452  metrics->horiAdvance =
453  FIXED_TO_INT( decoder.builder.advance.x );
454  cidglyph->linearHoriAdvance =
455  FIXED_TO_INT( decoder.builder.advance.x );
456  cidglyph->internal->glyph_transformed = 0;
457 
458  /* make up vertical ones */
459  metrics->vertAdvance = ( face->cid.font_bbox.yMax -
460  face->cid.font_bbox.yMin ) >> 16;
461  cidglyph->linearVertAdvance = metrics->vertAdvance;
462 
463  cidglyph->format = FT_GLYPH_FORMAT_OUTLINE;
464 
465  if ( cidsize->metrics.y_ppem < 24 )
466  cidglyph->outline.flags |= FT_OUTLINE_HIGH_PRECISION;
467 
468  /* apply the font matrix, if any */
469  if ( font_matrix.xx != 0x10000L || font_matrix.yy != 0x10000L ||
470  font_matrix.xy != 0 || font_matrix.yx != 0 )
471  {
472  FT_Outline_Transform( &cidglyph->outline, &font_matrix );
473 
474  metrics->horiAdvance = FT_MulFix( metrics->horiAdvance,
475  font_matrix.xx );
476  metrics->vertAdvance = FT_MulFix( metrics->vertAdvance,
477  font_matrix.yy );
478  }
479 
480  if ( font_offset.x || font_offset.y )
481  {
482  FT_Outline_Translate( &cidglyph->outline,
483  font_offset.x,
484  font_offset.y );
485 
486  metrics->horiAdvance += font_offset.x;
487  metrics->vertAdvance += font_offset.y;
488  }
489 
490  if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 || scaled )
491  {
492  /* scale the outline and the metrics */
493  FT_Int n;
494  FT_Outline* cur = decoder.builder.base;
495  FT_Vector* vec = cur->points;
496  FT_Fixed x_scale = glyph->x_scale;
497  FT_Fixed y_scale = glyph->y_scale;
498 
499 
500  /* First of all, scale the points */
501  if ( !hinting || !decoder.builder.hints_funcs )
502  for ( n = cur->n_points; n > 0; n--, vec++ )
503  {
504  vec->x = FT_MulFix( vec->x, x_scale );
505  vec->y = FT_MulFix( vec->y, y_scale );
506  }
507 
508  /* Then scale the metrics */
509  metrics->horiAdvance = FT_MulFix( metrics->horiAdvance, x_scale );
510  metrics->vertAdvance = FT_MulFix( metrics->vertAdvance, y_scale );
511  }
512 
513  /* compute the other metrics */
514  FT_Outline_Get_CBox( &cidglyph->outline, &cbox );
515 
516  metrics->width = cbox.xMax - cbox.xMin;
517  metrics->height = cbox.yMax - cbox.yMin;
518 
519  metrics->horiBearingX = cbox.xMin;
520  metrics->horiBearingY = cbox.yMax;
521 
522  if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )
523  {
524  /* make up vertical ones */
526  metrics->vertAdvance );
527  }
528  }
529 
530  Exit:
531 
532  if ( must_finish_decoder )
533  psaux->t1_decoder_funcs->done( &decoder );
534 
535 #ifdef __REACTOS__
536  free(&decoder);
537 #undef decoder
538  }
539 #endif
540  return error;
541  }
542 
543 
544 /* END */
#define FT_ALLOC(ptr, size)
Definition: ftmemory.h:303
#define FIXED_TO_INT(x)
Definition: ftcalc.h:406
FT_Int length
Definition: fttypes.h:409
int FT_Error
Definition: fttypes.h:300
#define FT_LOAD_VERTICAL_LAYOUT
Definition: freetype.h:3013
FT_Pos y
Definition: ftimage.h:77
#define TRUE
Definition: types.h:120
FT_Matrix font_matrix
Definition: t1tables.h:352
struct CID_FaceRec_ * CID_Face
Definition: t1types.h:197
unsigned long FT_ULong
Definition: fttypes.h:253
FT_Vector advance
Definition: psaux.h:793
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
#define FT_HINTING_FREETYPE
Definition: ftdriver.h:345
ft_synthesize_vertical_metrics(FT_Glyph_Metrics *metrics, FT_Pos advance)
Definition: ftobjs.c:2933
#define error(str)
Definition: mkdosfs.c:1605
GLsizei GLenum const GLvoid GLuint GLsizei GLfloat * metrics
Definition: glext.h:11745
FT_Outline * base
Definition: psaux.h:786
FT_Pos x
Definition: ftimage.h:76
signed int FT_Int
Definition: fttypes.h:220
#define free
Definition: debug_ros.c:5
#define FT_LOAD_NO_HINTING
Definition: freetype.h:3010
CFF_SubFont current_subfont
Definition: psaux.h:614
FT_Bool metrics_only
Definition: psaux.h:800
GLdouble n
Definition: glext.h:7729
FT_Vector font_offset
Definition: t1tables.h:353
#define FT_LOAD_NO_RECURSE
Definition: freetype.h:3018
FT_Byte ** code
Definition: t1types.h:133
const FT_Byte * pointer
Definition: fttypes.h:408
void(* done)(T1_Decoder decoder)
Definition: psaux.h:870
return FT_Err_Ok
Definition: ftbbox.c:511
static char memory[1024 *256]
Definition: process.c:116
FT_Int lenIV
Definition: t1tables.h:141
FT_Incremental_GetGlyphDataFunc get_glyph_data
Definition: ftincrem.h:272
FT_BEGIN_HEADER struct PS_DriverRec_ * PS_Driver
#define FT_FACE_DRIVER(x)
Definition: ftobjs.h:634
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:108
#define FT_LOAD_NO_SCALE
Definition: freetype.h:3009
FT_Bool no_recurse
Definition: psaux.h:798
#define FT_TRACE1(varformat)
Definition: ftdebug.h:158
FT_Vector * points
Definition: ftimage.h:339
static TfClientId cid
FT_Fixed xx
Definition: fttypes.h:387
const T1_Decoder_FuncsRec * t1_decoder_funcs
Definition: psaux.h:1284
unsigned char FT_Byte
Definition: fttypes.h:154
#define FT_THROW(e)
Definition: ftdebug.h:213
FT_Bool scaled
Definition: cidobjs.h:106
FT_Outline_Get_CBox(const FT_Outline *outline, FT_BBox *acbox)
Definition: ftoutln.c:478
smooth NULL
Definition: ftsmooth.c:416
FT_Pos yMax
Definition: ftimage.h:118
#define FT_FREE(ptr)
Definition: ftmemory.h:329
FT_Outline_Transform(const FT_Outline *outline, const FT_Matrix *matrix)
Definition: ftoutln.c:711
cid_slot_load_glyph(FT_GlyphSlot cidglyph, FT_Size cidsize, FT_UInt glyph_index, FT_Int32 load_flags)
Definition: cidgload.c:337
#define FT_LOCAL_DEF(x)
Definition: ftconfig.h:388
FT_Fixed y_scale
Definition: cidobjs.h:109
#define FT_STREAM_READ_AT(position, buffer, count)
Definition: ftstream.h:502
#define FT_TRACE0(varformat)
Definition: ftdebug.h:157
FT_Int num_subrs
Definition: t1types.h:132
#define FT_OUTLINE_HIGH_PRECISION
Definition: ftimage.h:435
smooth FT_Module_Constructor FT_Module_Destructor FT_Module_Requester FT_GLYPH_FORMAT_OUTLINE
Definition: ftsmooth.c:416
FT_Pos xMin
Definition: ftimage.h:117
if(!(yy_init))
Definition: macro.lex.yy.c:714
struct PSAux_ServiceRec_ * PSAux_Service
static void Exit(void)
Definition: sock.c:1331
FT_Fixed x_scale
Definition: cidobjs.h:108
#define FT_ERR_EQ(x, e)
Definition: fttypes.h:591
FT_Pos xMax
Definition: ftimage.h:118
T1_BuilderRec builder
Definition: psaux.h:895
FT_Incremental_GetGlyphMetricsFunc get_glyph_metrics
Definition: ftincrem.h:274
FT_Vector * vec
Definition: ftbbox.c:448
#define FT_CALLBACK_DEF(x)
Definition: ftconfig.h:533
#define FT_OUTLINE_OWNER
Definition: ftimage.h:428
FT_Vector left_bearing
Definition: psaux.h:792
struct CID_GlyphSlotRec_ * CID_GlyphSlot
Definition: cidobjs.h:67
unsigned int size
Definition: parse.h:27
Definition: parse.h:22
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
PS_PrivateRec private_dict
Definition: t1tables.h:343
#define FT_BOOL(x)
Definition: fttypes.h:578
FT_Error(* init)(T1_Decoder decoder, FT_Face face, FT_Size size, FT_GlyphSlot slot, FT_Byte **glyph_names, PS_Blend blend, FT_Bool hinting, FT_Render_Mode hint_mode, T1_Decoder_Callback callback)
Definition: psaux.h:859
#define FT_FRAME_EXIT()
Definition: ftstream.h:517
#define FT_STREAM_SEEK(position)
Definition: ftstream.h:489
FT_MulFix(FT_Long a, FT_Long b)
Definition: ftcalc.c:509
void * hints_funcs
Definition: psaux.h:802
FT_Matrix font_matrix
Definition: psaux.h:913
FT_Incremental_FreeGlyphDataFunc free_glyph_data
Definition: ftincrem.h:273
signed long FT_Fixed
Definition: fttypes.h:288
short n_points
Definition: ftimage.h:337
FT_BEGIN_HEADER struct FT_Glyph_Metrics_ FT_Glyph_Metrics
#define FT_FACE(x)
Definition: ftobjs.h:630
unsigned int FT_UInt
Definition: fttypes.h:231
FT_Fixed xy
Definition: fttypes.h:387
FT_Pos yMin
Definition: ftimage.h:117
FT_Bool hint
Definition: cidobjs.h:105
FT_Bool load_points
Definition: psaux.h:797
FT_Outline_Translate(const FT_Outline *outline, FT_Pos xOffset, FT_Pos yOffset)
Definition: ftoutln.c:528
#define FT_FRAME_ENTER(size)
Definition: ftstream.h:512
#define malloc
Definition: debug_ros.c:4
FT_Fixed yx
Definition: fttypes.h:388
FT_Fixed yy
Definition: fttypes.h:388
FT_Vector font_offset
Definition: psaux.h:914
GLfloat GLfloat p
Definition: glext.h:8902
#define INT_TO_FIXED(x)
Definition: ftcalc.h:404
#define ft_memcpy
Definition: ftstdlib.h:82
cid_get_offset(FT_Byte **start, FT_Byte offsize)
Definition: cidload.c:42
const FT_Incremental_FuncsRec * funcs
Definition: ftincrem.h:317
cid_load_glyph(T1_Decoder decoder, FT_UInt glyph_index)
Definition: cidgload.c:45
GLenum GLuint GLint GLenum face
Definition: glext.h:7025
#define FT_OUTLINE_REVERSE_FILL
Definition: ftimage.h:430
#define FT_LOAD_TARGET_MODE(x)
Definition: freetype.h:3137