ReactOS 0.4.15-dev-8349-g6f277e9
cidgload.c File Reference
#include <ft2build.h>
#include "cidload.h"
#include "cidgload.h"
#include "ciderrs.h"
Include dependency graph for cidgload.c:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define FT_COMPONENT   trace_cidgload
 

Functions

 cid_load_glyph (T1_Decoder decoder, FT_UInt glyph_index)
 
 cid_slot_load_glyph (FT_GlyphSlot cidglyph, FT_Size cidsize, FT_UInt glyph_index, FT_Int32 load_flags)
 

Macro Definition Documentation

◆ FT_COMPONENT

#define FT_COMPONENT   trace_cidgload

Definition at line 41 of file cidgload.c.

Function Documentation

◆ cid_load_glyph()

cid_load_glyph ( T1_Decoder  decoder,
FT_UInt  glyph_index 
)

Definition at line 45 of file cidgload.c.

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 );
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 }
cid_get_offset(FT_Byte **start, FT_Byte offsize)
Definition: cidload.c:42
struct CID_GlyphSlotRec_ * CID_GlyphSlot
Definition: cidobjs.h:67
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
return FT_Err_Ok
Definition: ftbbox.c:511
#define FIXED_TO_INT(x)
Definition: ftcalc.h:406
#define INT_TO_FIXED(x)
Definition: ftcalc.h:404
#define FT_TRACE0(varformat)
Definition: ftdebug.h:157
#define FT_THROW(e)
Definition: ftdebug.h:213
#define FT_TRACE1(varformat)
Definition: ftdebug.h:158
#define FT_HINTING_FREETYPE
Definition: ftdriver.h:345
#define FT_ALLOC(ptr, size)
Definition: ftmemory.h:303
#define FT_FREE(ptr)
Definition: ftmemory.h:329
#define FT_FACE(x)
Definition: ftobjs.h:630
#define FT_FACE_DRIVER(x)
Definition: ftobjs.h:634
#define ft_memcpy
Definition: ftstdlib.h:82
#define FT_FRAME_ENTER(size)
Definition: ftstream.h:512
#define FT_STREAM_SEEK(position)
Definition: ftstream.h:489
#define FT_FRAME_EXIT()
Definition: ftstream.h:517
#define FT_STREAM_READ_AT(position, buffer, count)
Definition: ftstream.h:502
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:108
unsigned long FT_ULong
Definition: fttypes.h:253
unsigned char FT_Byte
Definition: fttypes.h:154
#define FT_ERR_EQ(x, e)
Definition: fttypes.h:591
int FT_Error
Definition: fttypes.h:300
unsigned int FT_UInt
Definition: fttypes.h:231
GLenum GLuint GLint GLenum face
Definition: glext.h:7025
GLsizei GLenum const GLvoid GLuint GLsizei GLfloat * metrics
Definition: glext.h:11745
GLfloat GLfloat p
Definition: glext.h:8902
if(dx< 0)
Definition: linetemp.h:194
#define error(str)
Definition: mkdosfs.c:1605
static char memory[1024 *256]
Definition: process.c:116
static TfClientId cid
FT_BEGIN_HEADER struct PS_DriverRec_ * PS_Driver
static void Exit(void)
Definition: sock.c:1330
PS_PrivateRec private_dict
Definition: t1tables.h:343
FT_Matrix font_matrix
Definition: t1tables.h:352
FT_Vector font_offset
Definition: t1tables.h:353
FT_Byte ** code
Definition: t1types.h:133
FT_Int num_subrs
Definition: t1types.h:132
const FT_Byte * pointer
Definition: fttypes.h:408
FT_Int length
Definition: fttypes.h:409
FT_Incremental_FreeGlyphDataFunc free_glyph_data
Definition: ftincrem.h:273
FT_Incremental_GetGlyphDataFunc get_glyph_data
Definition: ftincrem.h:272
FT_Incremental_GetGlyphMetricsFunc get_glyph_metrics
Definition: ftincrem.h:274
const FT_Incremental_FuncsRec * funcs
Definition: ftincrem.h:317
FT_Pos x
Definition: ftimage.h:76
FT_Pos y
Definition: ftimage.h:77
CFF_SubFont current_subfont
Definition: psaux.h:614
FT_Int lenIV
Definition: t1tables.h:141
FT_GlyphSlot glyph
Definition: psaux.h:784
FT_Vector advance
Definition: psaux.h:793
FT_Face face
Definition: psaux.h:783
FT_Vector left_bearing
Definition: psaux.h:792
FT_Bool metrics_only
Definition: psaux.h:800
FT_Byte ** subrs
Definition: psaux.h:909
FT_Matrix font_matrix
Definition: psaux.h:913
FT_UInt * subrs_len
Definition: psaux.h:910
FT_Int num_subrs
Definition: psaux.h:908
T1_BuilderRec builder
Definition: psaux.h:895
FT_Vector font_offset
Definition: psaux.h:914
FT_Hash subrs_hash
Definition: psaux.h:911
FT_Int lenIV
Definition: psaux.h:907
Definition: parse.h:23
unsigned int size
Definition: parse.h:27
struct CID_FaceRec_ * CID_Face
Definition: t1types.h:197

Referenced by cid_slot_load_glyph().

◆ cid_slot_load_glyph()

cid_slot_load_glyph ( FT_GlyphSlot  cidglyph,
FT_Size  cidsize,
FT_UInt  glyph_index,
FT_Int32  load_flags 
)

Definition at line 337 of file cidgload.c.

341 {
342 CID_GlyphSlot glyph = (CID_GlyphSlot)cidglyph;
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;
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 ),
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;
428
429 /* for composite glyphs, return only left side bearing and */
430 /* advance width */
431 if ( load_flags & FT_LOAD_NO_RECURSE )
432 {
434
435
436 cidglyph->metrics.horiBearingX =
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
464
465 if ( cidsize->metrics.y_ppem < 24 )
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 }
ios_base &_STLP_CALL internal(ios_base &__s)
Definition: _ios_base.h:311
cid_load_glyph(T1_Decoder decoder, FT_UInt glyph_index)
Definition: cidgload.c:45
#define free
Definition: debug_ros.c:5
#define malloc
Definition: debug_ros.c:4
#define FT_LOAD_VERTICAL_LAYOUT
Definition: freetype.h:3013
#define FT_LOAD_TARGET_MODE(x)
Definition: freetype.h:3137
FT_BEGIN_HEADER struct FT_Glyph_Metrics_ FT_Glyph_Metrics
#define FT_LOAD_NO_SCALE
Definition: freetype.h:3009
#define FT_LOAD_NO_RECURSE
Definition: freetype.h:3018
#define FT_LOAD_NO_HINTING
Definition: freetype.h:3010
FT_MulFix(FT_Long a, FT_Long b)
Definition: ftcalc.c:509
FT_Vector * vec
Definition: ftbbox.c:448
#define FT_OUTLINE_HIGH_PRECISION
Definition: ftimage.h:435
#define FT_OUTLINE_OWNER
Definition: ftimage.h:428
#define FT_OUTLINE_REVERSE_FILL
Definition: ftimage.h:430
ft_synthesize_vertical_metrics(FT_Glyph_Metrics *metrics, FT_Pos advance)
Definition: ftobjs.c:2933
FT_Outline_Translate(const FT_Outline *outline, FT_Pos xOffset, FT_Pos yOffset)
Definition: ftoutln.c:528
FT_Outline_Transform(const FT_Outline *outline, const FT_Matrix *matrix)
Definition: ftoutln.c:711
FT_Outline_Get_CBox(const FT_Outline *outline, FT_BBox *acbox)
Definition: ftoutln.c:478
smooth FT_Module_Constructor FT_Module_Destructor FT_Module_Requester FT_GLYPH_FORMAT_OUTLINE
Definition: ftsmooth.c:426
signed long FT_Fixed
Definition: fttypes.h:288
#define FT_BOOL(x)
Definition: fttypes.h:578
signed int FT_Int
Definition: fttypes.h:220
FxCollectionEntry * cur
GLdouble n
Definition: glext.h:7729
FT_Fixed x_scale
Definition: cidobjs.h:108
FT_Bool hint
Definition: cidobjs.h:105
FT_Fixed y_scale
Definition: cidobjs.h:109
FT_Bool scaled
Definition: cidobjs.h:106
FT_Pos xMin
Definition: ftimage.h:117
FT_Pos yMax
Definition: ftimage.h:118
FT_Pos yMin
Definition: ftimage.h:117
FT_Pos xMax
Definition: ftimage.h:118
FT_Outline outline
Definition: freetype.h:1927
FT_Slot_Internal internal
Definition: freetype.h:1940
FT_Fixed linearHoriAdvance
Definition: freetype.h:1917
FT_Fixed linearVertAdvance
Definition: freetype.h:1918
FT_Glyph_Metrics metrics
Definition: freetype.h:1916
FT_Glyph_Format format
Definition: freetype.h:1921
FT_Fixed xx
Definition: fttypes.h:387
FT_Fixed yx
Definition: fttypes.h:388
FT_Fixed yy
Definition: fttypes.h:388
FT_Fixed xy
Definition: fttypes.h:387
short n_contours
Definition: ftimage.h:336
int flags
Definition: ftimage.h:343
short n_points
Definition: ftimage.h:337
FT_Size_Metrics metrics
Definition: freetype.h:1677
FT_Fixed y_scale
Definition: freetype.h:1644
FT_Fixed x_scale
Definition: freetype.h:1643
FT_UShort y_ppem
Definition: freetype.h:1641
FT_Bool glyph_transformed
Definition: ftobjs.h:469
FT_Bool no_recurse
Definition: psaux.h:798
FT_Outline * base
Definition: psaux.h:786
void * hints_funcs
Definition: psaux.h:802