ReactOS 0.4.16-dev-1067-ge98bba2
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   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   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:43
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:527
#define FIXED_TO_INT(x)
Definition: ftcalc.h:450
#define INT_TO_FIXED(x)
Definition: ftcalc.h:448
#define FT_TRACE0(varformat)
Definition: ftdebug.h:185
#define FT_THROW(e)
Definition: ftdebug.h:241
#define FT_TRACE1(varformat)
Definition: ftdebug.h:186
#define FT_HINTING_FREETYPE
Definition: ftdriver.h:344
#define FT_ALLOC(ptr, size)
Definition: ftmemory.h:302
#define FT_FREE(ptr)
Definition: ftmemory.h:328
#define FT_FACE(x)
Definition: ftobjs.h:599
#define FT_FACE_DRIVER(x)
Definition: ftobjs.h:603
#define ft_memcpy
Definition: ftstdlib.h:82
#define FT_FRAME_ENTER(size)
Definition: ftstream.h:537
#define FT_STREAM_SEEK(position)
Definition: ftstream.h:514
#define FT_FRAME_EXIT()
Definition: ftstream.h:542
#define FT_STREAM_READ_AT(position, buffer, count)
Definition: ftstream.h:527
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:65
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:604
int FT_Error
Definition: fttypes.h:299
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:350
FT_Matrix font_matrix
Definition: t1tables.h:359
FT_Vector font_offset
Definition: t1tables.h:360
FT_Byte ** code
Definition: t1types.h:136
FT_Int num_subrs
Definition: t1types.h:135
const FT_Byte * pointer
Definition: fttypes.h:415
FT_Int length
Definition: fttypes.h:416
FT_Incremental_FreeGlyphDataFunc free_glyph_data
Definition: ftincrem.h:274
FT_Incremental_GetGlyphDataFunc get_glyph_data
Definition: ftincrem.h:273
FT_Incremental_GetGlyphMetricsFunc get_glyph_metrics
Definition: ftincrem.h:275
const FT_Incremental_FuncsRec * funcs
Definition: ftincrem.h:318
CFF_SubFont current_subfont
Definition: psaux.h:646
FT_Int lenIV
Definition: t1tables.h:140
Definition: parse.h:23
unsigned int size
Definition: parse.h:27
struct CID_FaceRec_ * CID_Face
Definition: t1types.h:200

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 358 of file cidgload.c.

362 {
363 CID_GlyphSlot glyph = (CID_GlyphSlot)cidglyph;
365#ifdef __REACTOS__
366 T1_DecoderRec *decoder_allocated = malloc(sizeof(*decoder_allocated));
367 if (!decoder_allocated) return FT_Err_Out_Of_Memory;
368/* Ugly but it allows us to reduce the diff */
369#define decoder (*decoder_allocated)
370 {
371#else
373#endif
374 CID_Face face = (CID_Face)cidglyph->face;
375 FT_Bool hinting;
376 FT_Bool scaled;
377
378 PSAux_Service psaux = (PSAux_Service)face->psaux;
379 FT_Matrix font_matrix;
380 FT_Vector font_offset;
381 FT_Bool must_finish_decoder = FALSE;
382
383
384 if ( glyph_index >= (FT_UInt)face->root.num_glyphs )
385 {
386 error = FT_THROW( Invalid_Argument );
387 goto Exit;
388 }
389
390 if ( load_flags & FT_LOAD_NO_RECURSE )
391 load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
392
393 glyph->x_scale = cidsize->metrics.x_scale;
394 glyph->y_scale = cidsize->metrics.y_scale;
395
396 cidglyph->outline.n_points = 0;
397 cidglyph->outline.n_contours = 0;
398
399 hinting = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE ) == 0 &&
400 ( load_flags & FT_LOAD_NO_HINTING ) == 0 );
401 scaled = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE ) == 0 );
402
403 glyph->hint = hinting;
404 glyph->scaled = scaled;
406
407 error = psaux->t1_decoder_funcs->init( &decoder,
408 cidglyph->face,
409 cidsize,
410 cidglyph,
411 0, /* glyph names -- XXX */
412 0, /* blend == 0 */
413 hinting,
414 FT_LOAD_TARGET_MODE( load_flags ),
416 if ( error )
417 goto Exit;
418
419 /* TODO: initialize decoder.len_buildchar and decoder.buildchar */
420 /* if we ever support CID-keyed multiple master fonts */
421
422 must_finish_decoder = TRUE;
423
424 /* set up the decoder */
425 decoder.builder.no_recurse = FT_BOOL( load_flags & FT_LOAD_NO_RECURSE );
426
427 error = cid_load_glyph( &decoder, glyph_index );
428 if ( error )
429 goto Exit;
430
431 /* copy flags back for forced scaling */
432 hinting = glyph->hint;
433 scaled = glyph->scaled;
434
435 font_matrix = decoder.font_matrix;
436 font_offset = decoder.font_offset;
437
438 /* save new glyph tables */
439 psaux->t1_decoder_funcs->done( &decoder );
440
441 must_finish_decoder = FALSE;
442
443 /* now set the metrics -- this is rather simple, as */
444 /* the left side bearing is the xMin, and the top side */
445 /* bearing the yMax */
446 cidglyph->outline.flags &= FT_OUTLINE_OWNER;
448
449 /* for composite glyphs, return only left side bearing and */
450 /* advance width */
451 if ( load_flags & FT_LOAD_NO_RECURSE )
452 {
454
455
456 cidglyph->metrics.horiBearingX =
457 FIXED_TO_INT( decoder.builder.left_bearing.x );
458 cidglyph->metrics.horiAdvance =
459 FIXED_TO_INT( decoder.builder.advance.x );
460
461 internal->glyph_matrix = font_matrix;
462 internal->glyph_delta = font_offset;
463 internal->glyph_transformed = 1;
464 }
465 else
466 {
467 FT_BBox cbox;
468 FT_Glyph_Metrics* metrics = &cidglyph->metrics;
469
470
471 /* copy the _unscaled_ advance width */
472 metrics->horiAdvance =
473 FIXED_TO_INT( decoder.builder.advance.x );
474 cidglyph->linearHoriAdvance =
475 FIXED_TO_INT( decoder.builder.advance.x );
476 cidglyph->internal->glyph_transformed = 0;
477
478 /* make up vertical ones */
479 metrics->vertAdvance = ( face->cid.font_bbox.yMax -
480 face->cid.font_bbox.yMin ) >> 16;
481 cidglyph->linearVertAdvance = metrics->vertAdvance;
482
484
485 if ( cidsize->metrics.y_ppem < 24 )
487
488 /* apply the font matrix, if any */
489 if ( font_matrix.xx != 0x10000L || font_matrix.yy != 0x10000L ||
490 font_matrix.xy != 0 || font_matrix.yx != 0 )
491 {
492 FT_Outline_Transform( &cidglyph->outline, &font_matrix );
493
494 metrics->horiAdvance = FT_MulFix( metrics->horiAdvance,
495 font_matrix.xx );
496 metrics->vertAdvance = FT_MulFix( metrics->vertAdvance,
497 font_matrix.yy );
498 }
499
500 if ( font_offset.x || font_offset.y )
501 {
502 FT_Outline_Translate( &cidglyph->outline,
503 font_offset.x,
504 font_offset.y );
505
506 metrics->horiAdvance += font_offset.x;
507 metrics->vertAdvance += font_offset.y;
508 }
509
510 if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 || scaled )
511 {
512 /* scale the outline and the metrics */
513 FT_Int n;
514 FT_Outline* cur = decoder.builder.base;
515 FT_Vector* vec = cur->points;
516 FT_Fixed x_scale = glyph->x_scale;
517 FT_Fixed y_scale = glyph->y_scale;
518
519
520 /* First of all, scale the points */
521 if ( !hinting || !decoder.builder.hints_funcs )
522 for ( n = cur->n_points; n > 0; n--, vec++ )
523 {
524 vec->x = FT_MulFix( vec->x, x_scale );
525 vec->y = FT_MulFix( vec->y, y_scale );
526 }
527
528 /* Then scale the metrics */
529 metrics->horiAdvance = FT_MulFix( metrics->horiAdvance, x_scale );
530 metrics->vertAdvance = FT_MulFix( metrics->vertAdvance, y_scale );
531 }
532
533 /* compute the other metrics */
534 FT_Outline_Get_CBox( &cidglyph->outline, &cbox );
535
536 metrics->width = cbox.xMax - cbox.xMin;
537 metrics->height = cbox.yMax - cbox.yMin;
538
539 metrics->horiBearingX = cbox.xMin;
540 metrics->horiBearingY = cbox.yMax;
541
542 if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )
543 {
544 /* make up vertical ones */
546 metrics->vertAdvance );
547 }
548 }
549
550 Exit:
551
552 if ( must_finish_decoder )
553 psaux->t1_decoder_funcs->done( &decoder );
554
555#ifdef __REACTOS__
556 free(decoder_allocated);
557#undef decoder
558 }
559#endif
560 return error;
561 }
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:3031
#define FT_LOAD_TARGET_MODE(x)
Definition: freetype.h:3159
FT_BEGIN_HEADER struct FT_Glyph_Metrics_ FT_Glyph_Metrics
#define FT_LOAD_NO_SCALE
Definition: freetype.h:3027
#define FT_LOAD_NO_RECURSE
Definition: freetype.h:3036
#define FT_LOAD_NO_HINTING
Definition: freetype.h:3028
FT_MulFix(FT_Long a, FT_Long b)
Definition: ftcalc.c:509
FT_Vector * vec
Definition: ftbbox.c:470
#define FT_OUTLINE_HIGH_PRECISION
Definition: ftimage.h:436
#define FT_OUTLINE_OWNER
Definition: ftimage.h:429
#define FT_OUTLINE_REVERSE_FILL
Definition: ftimage.h:431
ft_synthesize_vertical_metrics(FT_Glyph_Metrics *metrics, FT_Pos advance)
Definition: ftobjs.c:2977
FT_Outline_Translate(const FT_Outline *outline, FT_Pos xOffset, FT_Pos yOffset)
Definition: ftoutln.c:509
FT_Outline_Transform(const FT_Outline *outline, const FT_Matrix *matrix)
Definition: ftoutln.c:698
FT_Outline_Get_CBox(const FT_Outline *outline, FT_BBox *acbox)
Definition: ftoutln.c:459
smooth FT_Module_Constructor FT_Module_Destructor FT_Module_Requester FT_GLYPH_FORMAT_OUTLINE
Definition: ftsmooth.c:465
signed long FT_Fixed
Definition: fttypes.h:287
#define FT_BOOL(x)
Definition: fttypes.h:591
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:121
FT_Pos yMax
Definition: ftimage.h:122
FT_Pos yMin
Definition: ftimage.h:121
FT_Pos xMax
Definition: ftimage.h:122
FT_Outline outline
Definition: freetype.h:1896
FT_Slot_Internal internal
Definition: freetype.h:1909
FT_Fixed linearHoriAdvance
Definition: freetype.h:1886
FT_Fixed linearVertAdvance
Definition: freetype.h:1887
FT_Glyph_Metrics metrics
Definition: freetype.h:1885
FT_Glyph_Format format
Definition: freetype.h:1890
FT_Fixed xx
Definition: fttypes.h:392
FT_Fixed yx
Definition: fttypes.h:393
FT_Fixed yy
Definition: fttypes.h:393
FT_Fixed xy
Definition: fttypes.h:392
short n_contours
Definition: ftimage.h:339
int flags
Definition: ftimage.h:346
short n_points
Definition: ftimage.h:340
FT_Size_Metrics metrics
Definition: freetype.h:1649
FT_Fixed y_scale
Definition: freetype.h:1614
FT_Fixed x_scale
Definition: freetype.h:1613
FT_UShort y_ppem
Definition: freetype.h:1611
FT_Bool glyph_transformed
Definition: ftobjs.h:429
FT_Pos x
Definition: ftimage.h:78
FT_Pos y
Definition: ftimage.h:79