Sync with trunk head (part 1 of x)
[reactos.git] / lib / 3rdparty / freetype / src / cid / cidgload.c
1 /***************************************************************************/
2 /* */
3 /* cidgload.c */
4 /* */
5 /* CID-keyed Type1 Glyph Loader (body). */
6 /* */
7 /* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 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
26 #include "ciderrs.h"
27
28
29 /*************************************************************************/
30 /* */
31 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
32 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
33 /* messages during execution. */
34 /* */
35 #undef FT_COMPONENT
36 #define FT_COMPONENT trace_cidgload
37
38
39 FT_CALLBACK_DEF( FT_Error )
40 cid_load_glyph( T1_Decoder decoder,
41 FT_UInt glyph_index )
42 {
43 CID_Face face = (CID_Face)decoder->builder.face;
44 CID_FaceInfo cid = &face->cid;
45 FT_Byte* p;
46 FT_UInt fd_select;
47 FT_Stream stream = face->cid_stream;
48 FT_Error error = CID_Err_Ok;
49 FT_Byte* charstring = 0;
50 FT_Memory memory = face->root.memory;
51 FT_ULong glyph_length = 0;
52 PSAux_Service psaux = (PSAux_Service)face->psaux;
53
54
55 #ifdef FT_CONFIG_OPTION_INCREMENTAL
56
57 /* For incremental fonts get the character data using */
58 /* the callback function. */
59 if ( face->root.internal->incremental_interface )
60 {
61 FT_Data glyph_data;
62
63
64 error = face->root.internal->incremental_interface->funcs->get_glyph_data(
65 face->root.internal->incremental_interface->object,
66 glyph_index,
67 &glyph_data );
68 if ( error )
69 goto Exit;
70
71 p = (FT_Byte*)glyph_data.pointer;
72 fd_select = (FT_UInt)cid_get_offset( &p, (FT_Byte)cid->fd_bytes );
73
74 if ( glyph_data.length != 0 )
75 {
76 glyph_length = glyph_data.length - cid->fd_bytes;
77 FT_ALLOC( charstring, glyph_length );
78 if ( !error )
79 ft_memcpy( charstring, glyph_data.pointer + cid->fd_bytes,
80 glyph_length );
81 }
82
83 face->root.internal->incremental_interface->funcs->free_glyph_data(
84 face->root.internal->incremental_interface->object,
85 &glyph_data );
86
87 if ( error )
88 goto Exit;
89 }
90
91 else
92
93 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
94
95 /* For ordinary fonts read the CID font dictionary index */
96 /* and charstring offset from the CIDMap. */
97 {
98 FT_UInt entry_len = cid->fd_bytes + cid->gd_bytes;
99 FT_ULong off1;
100
101
102 if ( FT_STREAM_SEEK( cid->data_offset + cid->cidmap_offset +
103 glyph_index * entry_len ) ||
104 FT_FRAME_ENTER( 2 * entry_len ) )
105 goto Exit;
106
107 p = (FT_Byte*)stream->cursor;
108 fd_select = (FT_UInt) cid_get_offset( &p, (FT_Byte)cid->fd_bytes );
109 off1 = (FT_ULong)cid_get_offset( &p, (FT_Byte)cid->gd_bytes );
110 p += cid->fd_bytes;
111 glyph_length = cid_get_offset( &p, (FT_Byte)cid->gd_bytes ) - off1;
112 FT_FRAME_EXIT();
113
114 if ( fd_select >= (FT_UInt)cid->num_dicts )
115 {
116 error = CID_Err_Invalid_Offset;
117 goto Exit;
118 }
119 if ( glyph_length == 0 )
120 goto Exit;
121 if ( FT_ALLOC( charstring, glyph_length ) )
122 goto Exit;
123 if ( FT_STREAM_READ_AT( cid->data_offset + off1,
124 charstring, glyph_length ) )
125 goto Exit;
126 }
127
128 /* Now set up the subrs array and parse the charstrings. */
129 {
130 CID_FaceDict dict;
131 CID_Subrs cid_subrs = face->subrs + fd_select;
132 FT_Int cs_offset;
133
134
135 /* Set up subrs */
136 decoder->num_subrs = cid_subrs->num_subrs;
137 decoder->subrs = cid_subrs->code;
138 decoder->subrs_len = 0;
139
140 /* Set up font matrix */
141 dict = cid->font_dicts + fd_select;
142
143 decoder->font_matrix = dict->font_matrix;
144 decoder->font_offset = dict->font_offset;
145 decoder->lenIV = dict->private_dict.lenIV;
146
147 /* Decode the charstring. */
148
149 /* Adjustment for seed bytes. */
150 cs_offset = ( decoder->lenIV >= 0 ? decoder->lenIV : 0 );
151
152 /* Decrypt only if lenIV >= 0. */
153 if ( decoder->lenIV >= 0 )
154 psaux->t1_decrypt( charstring, glyph_length, 4330 );
155
156 error = decoder->funcs.parse_charstrings(
157 decoder, charstring + cs_offset,
158 (FT_Int)glyph_length - cs_offset );
159 }
160
161 FT_FREE( charstring );
162
163 #ifdef FT_CONFIG_OPTION_INCREMENTAL
164
165 /* Incremental fonts can optionally override the metrics. */
166 if ( !error &&
167 face->root.internal->incremental_interface &&
168 face->root.internal->incremental_interface->funcs->get_glyph_metrics )
169 {
170 FT_Incremental_MetricsRec metrics;
171
172
173 metrics.bearing_x = decoder->builder.left_bearing.x;
174 metrics.bearing_y = decoder->builder.left_bearing.y;
175 metrics.advance = decoder->builder.advance.x;
176 error = face->root.internal->incremental_interface->funcs->get_glyph_metrics(
177 face->root.internal->incremental_interface->object,
178 glyph_index, FALSE, &metrics );
179 decoder->builder.left_bearing.x = metrics.bearing_x;
180 decoder->builder.left_bearing.y = metrics.bearing_y;
181 decoder->builder.advance.x = metrics.advance;
182 decoder->builder.advance.y = 0;
183 }
184
185 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
186
187 Exit:
188 return error;
189 }
190
191
192 #if 0
193
194
195 /*************************************************************************/
196 /*************************************************************************/
197 /*************************************************************************/
198 /********** *********/
199 /********** *********/
200 /********** COMPUTE THE MAXIMUM ADVANCE WIDTH *********/
201 /********** *********/
202 /********** The following code is in charge of computing *********/
203 /********** the maximum advance width of the font. It *********/
204 /********** quickly processes each glyph charstring to *********/
205 /********** extract the value from either a `sbw' or `seac' *********/
206 /********** operator. *********/
207 /********** *********/
208 /*************************************************************************/
209 /*************************************************************************/
210 /*************************************************************************/
211
212
213 FT_LOCAL_DEF( FT_Error )
214 cid_face_compute_max_advance( CID_Face face,
215 FT_Int* max_advance )
216 {
217 FT_Error error;
218 T1_DecoderRec decoder;
219 FT_Int glyph_index;
220
221 PSAux_Service psaux = (PSAux_Service)face->psaux;
222
223
224 *max_advance = 0;
225
226 /* Initialize load decoder */
227 error = psaux->t1_decoder_funcs->init( &decoder,
228 (FT_Face)face,
229 0, /* size */
230 0, /* glyph slot */
231 0, /* glyph names! XXX */
232 0, /* blend == 0 */
233 0, /* hinting == 0 */
234 cid_load_glyph );
235 if ( error )
236 return error;
237
238 /* TODO: initialize decoder.len_buildchar and decoder.buildchar */
239 /* if we ever support CID-keyed multiple master fonts */
240
241 decoder.builder.metrics_only = 1;
242 decoder.builder.load_points = 0;
243
244 /* for each glyph, parse the glyph charstring and extract */
245 /* the advance width */
246 for ( glyph_index = 0; glyph_index < face->root.num_glyphs;
247 glyph_index++ )
248 {
249 /* now get load the unscaled outline */
250 error = cid_load_glyph( &decoder, glyph_index );
251 /* ignore the error if one occurred - skip to next glyph */
252 }
253
254 *max_advance = decoder.builder.advance.x;
255
256 psaux->t1_decoder_funcs->done( &decoder );
257
258 return CID_Err_Ok;
259 }
260
261
262 #endif /* 0 */
263
264
265 FT_LOCAL_DEF( FT_Error )
266 cid_slot_load_glyph( FT_GlyphSlot cidglyph, /* CID_GlyphSlot */
267 FT_Size cidsize, /* CID_Size */
268 FT_UInt glyph_index,
269 FT_Int32 load_flags )
270 {
271 CID_GlyphSlot glyph = (CID_GlyphSlot)cidglyph;
272 CID_Size size = (CID_Size)cidsize;
273 FT_Error error;
274 T1_DecoderRec decoder;
275 CID_Face face = (CID_Face)cidglyph->face;
276 FT_Bool hinting;
277
278 PSAux_Service psaux = (PSAux_Service)face->psaux;
279 FT_Matrix font_matrix;
280 FT_Vector font_offset;
281
282
283 if ( glyph_index >= (FT_UInt)face->root.num_glyphs )
284 {
285 error = CID_Err_Invalid_Argument;
286 goto Exit;
287 }
288
289 if ( load_flags & FT_LOAD_NO_RECURSE )
290 load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
291
292 glyph->x_scale = cidsize->metrics.x_scale;
293 glyph->y_scale = cidsize->metrics.y_scale;
294
295 cidglyph->outline.n_points = 0;
296 cidglyph->outline.n_contours = 0;
297
298 hinting = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE ) == 0 &&
299 ( load_flags & FT_LOAD_NO_HINTING ) == 0 );
300
301 cidglyph->format = FT_GLYPH_FORMAT_OUTLINE;
302
303 error = psaux->t1_decoder_funcs->init( &decoder,
304 cidglyph->face,
305 cidsize,
306 cidglyph,
307 0, /* glyph names -- XXX */
308 0, /* blend == 0 */
309 hinting,
310 FT_LOAD_TARGET_MODE( load_flags ),
311 cid_load_glyph );
312 if ( error )
313 goto Exit;
314
315 /* TODO: initialize decoder.len_buildchar and decoder.buildchar */
316 /* if we ever support CID-keyed multiple master fonts */
317
318 /* set up the decoder */
319 decoder.builder.no_recurse = FT_BOOL(
320 ( ( load_flags & FT_LOAD_NO_RECURSE ) != 0 ) );
321
322 error = cid_load_glyph( &decoder, glyph_index );
323 if ( error )
324 goto Exit;
325
326 font_matrix = decoder.font_matrix;
327 font_offset = decoder.font_offset;
328
329 /* save new glyph tables */
330 psaux->t1_decoder_funcs->done( &decoder );
331
332 /* now set the metrics -- this is rather simple, as */
333 /* the left side bearing is the xMin, and the top side */
334 /* bearing the yMax */
335 cidglyph->outline.flags &= FT_OUTLINE_OWNER;
336 cidglyph->outline.flags |= FT_OUTLINE_REVERSE_FILL;
337
338 /* for composite glyphs, return only left side bearing and */
339 /* advance width */
340 if ( load_flags & FT_LOAD_NO_RECURSE )
341 {
342 FT_Slot_Internal internal = cidglyph->internal;
343
344
345 cidglyph->metrics.horiBearingX = decoder.builder.left_bearing.x;
346 cidglyph->metrics.horiAdvance = decoder.builder.advance.x;
347
348 internal->glyph_matrix = font_matrix;
349 internal->glyph_delta = font_offset;
350 internal->glyph_transformed = 1;
351 }
352 else
353 {
354 FT_BBox cbox;
355 FT_Glyph_Metrics* metrics = &cidglyph->metrics;
356 FT_Vector advance;
357
358
359 /* copy the _unscaled_ advance width */
360 metrics->horiAdvance = decoder.builder.advance.x;
361 cidglyph->linearHoriAdvance = decoder.builder.advance.x;
362 cidglyph->internal->glyph_transformed = 0;
363
364 /* make up vertical ones */
365 metrics->vertAdvance = ( face->cid.font_bbox.yMax -
366 face->cid.font_bbox.yMin ) >> 16;
367 cidglyph->linearVertAdvance = metrics->vertAdvance;
368
369 cidglyph->format = FT_GLYPH_FORMAT_OUTLINE;
370
371 if ( size && cidsize->metrics.y_ppem < 24 )
372 cidglyph->outline.flags |= FT_OUTLINE_HIGH_PRECISION;
373
374 /* apply the font matrix */
375 FT_Outline_Transform( &cidglyph->outline, &font_matrix );
376
377 FT_Outline_Translate( &cidglyph->outline,
378 font_offset.x,
379 font_offset.y );
380
381 advance.x = metrics->horiAdvance;
382 advance.y = 0;
383 FT_Vector_Transform( &advance, &font_matrix );
384 metrics->horiAdvance = advance.x + font_offset.x;
385
386 advance.x = 0;
387 advance.y = metrics->vertAdvance;
388 FT_Vector_Transform( &advance, &font_matrix );
389 metrics->vertAdvance = advance.y + font_offset.y;
390
391 if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 )
392 {
393 /* scale the outline and the metrics */
394 FT_Int n;
395 FT_Outline* cur = decoder.builder.base;
396 FT_Vector* vec = cur->points;
397 FT_Fixed x_scale = glyph->x_scale;
398 FT_Fixed y_scale = glyph->y_scale;
399
400
401 /* First of all, scale the points */
402 if ( !hinting || !decoder.builder.hints_funcs )
403 for ( n = cur->n_points; n > 0; n--, vec++ )
404 {
405 vec->x = FT_MulFix( vec->x, x_scale );
406 vec->y = FT_MulFix( vec->y, y_scale );
407 }
408
409 /* Then scale the metrics */
410 metrics->horiAdvance = FT_MulFix( metrics->horiAdvance, x_scale );
411 metrics->vertAdvance = FT_MulFix( metrics->vertAdvance, y_scale );
412 }
413
414 /* compute the other metrics */
415 FT_Outline_Get_CBox( &cidglyph->outline, &cbox );
416
417 metrics->width = cbox.xMax - cbox.xMin;
418 metrics->height = cbox.yMax - cbox.yMin;
419
420 metrics->horiBearingX = cbox.xMin;
421 metrics->horiBearingY = cbox.yMax;
422
423 /* make up vertical ones */
424 ft_synthesize_vertical_metrics( metrics,
425 metrics->vertAdvance );
426 }
427
428 Exit:
429 return error;
430 }
431
432
433 /* END */