|
1 /***************************************************************************/ |
|
2 /* */ |
|
3 /* ttgload.c */ |
|
4 /* */ |
|
5 /* TrueType Glyph Loader (body). */ |
|
6 /* */ |
|
7 /* Copyright 1996-2011 */ |
|
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_CALC_H |
|
22 #include FT_INTERNAL_STREAM_H |
|
23 #include FT_INTERNAL_SFNT_H |
|
24 #include FT_TRUETYPE_TAGS_H |
|
25 #include FT_OUTLINE_H |
|
26 |
|
27 #include "ttgload.h" |
|
28 #include "ttpload.h" |
|
29 |
|
30 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT |
|
31 #include "ttgxvar.h" |
|
32 #endif |
|
33 |
|
34 #include "tterrors.h" |
|
35 |
|
36 |
|
37 /*************************************************************************/ |
|
38 /* */ |
|
39 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ |
|
40 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ |
|
41 /* messages during execution. */ |
|
42 /* */ |
|
43 #undef FT_COMPONENT |
|
44 #define FT_COMPONENT trace_ttgload |
|
45 |
|
46 |
|
47 /*************************************************************************/ |
|
48 /* */ |
|
49 /* Composite glyph flags. */ |
|
50 /* */ |
|
51 #define ARGS_ARE_WORDS 0x0001 |
|
52 #define ARGS_ARE_XY_VALUES 0x0002 |
|
53 #define ROUND_XY_TO_GRID 0x0004 |
|
54 #define WE_HAVE_A_SCALE 0x0008 |
|
55 /* reserved 0x0010 */ |
|
56 #define MORE_COMPONENTS 0x0020 |
|
57 #define WE_HAVE_AN_XY_SCALE 0x0040 |
|
58 #define WE_HAVE_A_2X2 0x0080 |
|
59 #define WE_HAVE_INSTR 0x0100 |
|
60 #define USE_MY_METRICS 0x0200 |
|
61 #define OVERLAP_COMPOUND 0x0400 |
|
62 #define SCALED_COMPONENT_OFFSET 0x0800 |
|
63 #define UNSCALED_COMPONENT_OFFSET 0x1000 |
|
64 |
|
65 |
|
66 /*************************************************************************/ |
|
67 /* */ |
|
68 /* Return the horizontal metrics in font units for a given glyph. */ |
|
69 /* */ |
|
70 FT_LOCAL_DEF( void ) |
|
71 TT_Get_HMetrics( TT_Face face, |
|
72 FT_UInt idx, |
|
73 FT_Short* lsb, |
|
74 FT_UShort* aw ) |
|
75 { |
|
76 ( (SFNT_Service)face->sfnt )->get_metrics( face, 0, idx, lsb, aw ); |
|
77 |
|
78 FT_TRACE5(( " advance width (font units): %d\n", *aw )); |
|
79 FT_TRACE5(( " left side bearing (font units): %d\n", *lsb )); |
|
80 } |
|
81 |
|
82 |
|
83 /*************************************************************************/ |
|
84 /* */ |
|
85 /* Return the vertical metrics in font units for a given glyph. */ |
|
86 /* Greg Hitchcock from Microsoft told us that if there were no `vmtx' */ |
|
87 /* table, typoAscender/Descender from the `OS/2' table would be used */ |
|
88 /* instead, and if there were no `OS/2' table, use ascender/descender */ |
|
89 /* from the `hhea' table. But that is not what Microsoft's rasterizer */ |
|
90 /* apparently does: It uses the ppem value as the advance height, and */ |
|
91 /* sets the top side bearing to be zero. */ |
|
92 /* */ |
|
93 FT_LOCAL_DEF( void ) |
|
94 TT_Get_VMetrics( TT_Face face, |
|
95 FT_UInt idx, |
|
96 FT_Short* tsb, |
|
97 FT_UShort* ah ) |
|
98 { |
|
99 if ( face->vertical_info ) |
|
100 ( (SFNT_Service)face->sfnt )->get_metrics( face, 1, idx, tsb, ah ); |
|
101 |
|
102 #if 1 /* Empirically determined, at variance with what MS said */ |
|
103 |
|
104 else |
|
105 { |
|
106 *tsb = 0; |
|
107 *ah = face->root.units_per_EM; |
|
108 } |
|
109 |
|
110 #else /* This is what MS said to do. It isn't what they do, however. */ |
|
111 |
|
112 else if ( face->os2.version != 0xFFFFU ) |
|
113 { |
|
114 *tsb = face->os2.sTypoAscender; |
|
115 *ah = face->os2.sTypoAscender - face->os2.sTypoDescender; |
|
116 } |
|
117 else |
|
118 { |
|
119 *tsb = face->horizontal.Ascender; |
|
120 *ah = face->horizontal.Ascender - face->horizontal.Descender; |
|
121 } |
|
122 |
|
123 #endif |
|
124 |
|
125 FT_TRACE5(( " advance height (font units): %d\n", *ah )); |
|
126 FT_TRACE5(( " top side bearing (font units): %d\n", *tsb )); |
|
127 } |
|
128 |
|
129 |
|
130 static void |
|
131 tt_get_metrics( TT_Loader loader, |
|
132 FT_UInt glyph_index ) |
|
133 { |
|
134 TT_Face face = (TT_Face)loader->face; |
|
135 |
|
136 FT_Short left_bearing = 0, top_bearing = 0; |
|
137 FT_UShort advance_width = 0, advance_height = 0; |
|
138 |
|
139 |
|
140 TT_Get_HMetrics( face, glyph_index, |
|
141 &left_bearing, |
|
142 &advance_width ); |
|
143 TT_Get_VMetrics( face, glyph_index, |
|
144 &top_bearing, |
|
145 &advance_height ); |
|
146 |
|
147 loader->left_bearing = left_bearing; |
|
148 loader->advance = advance_width; |
|
149 loader->top_bearing = top_bearing; |
|
150 loader->vadvance = advance_height; |
|
151 |
|
152 if ( !loader->linear_def ) |
|
153 { |
|
154 loader->linear_def = 1; |
|
155 loader->linear = advance_width; |
|
156 } |
|
157 } |
|
158 |
|
159 |
|
160 #ifdef FT_CONFIG_OPTION_INCREMENTAL |
|
161 |
|
162 static void |
|
163 tt_get_metrics_incr_overrides( TT_Loader loader, |
|
164 FT_UInt glyph_index ) |
|
165 { |
|
166 TT_Face face = (TT_Face)loader->face; |
|
167 |
|
168 FT_Short left_bearing = 0, top_bearing = 0; |
|
169 FT_UShort advance_width = 0, advance_height = 0; |
|
170 |
|
171 |
|
172 /* If this is an incrementally loaded font check whether there are */ |
|
173 /* overriding metrics for this glyph. */ |
|
174 if ( face->root.internal->incremental_interface && |
|
175 face->root.internal->incremental_interface->funcs->get_glyph_metrics ) |
|
176 { |
|
177 FT_Incremental_MetricsRec metrics; |
|
178 FT_Error error; |
|
179 |
|
180 |
|
181 metrics.bearing_x = loader->left_bearing; |
|
182 metrics.bearing_y = 0; |
|
183 metrics.advance = loader->advance; |
|
184 metrics.advance_v = 0; |
|
185 |
|
186 error = face->root.internal->incremental_interface->funcs->get_glyph_metrics( |
|
187 face->root.internal->incremental_interface->object, |
|
188 glyph_index, FALSE, &metrics ); |
|
189 if ( error ) |
|
190 goto Exit; |
|
191 |
|
192 left_bearing = (FT_Short)metrics.bearing_x; |
|
193 advance_width = (FT_UShort)metrics.advance; |
|
194 |
|
195 #if 0 |
|
196 |
|
197 /* GWW: Do I do the same for vertical metrics? */ |
|
198 metrics.bearing_x = 0; |
|
199 metrics.bearing_y = loader->top_bearing; |
|
200 metrics.advance = loader->vadvance; |
|
201 |
|
202 error = face->root.internal->incremental_interface->funcs->get_glyph_metrics( |
|
203 face->root.internal->incremental_interface->object, |
|
204 glyph_index, TRUE, &metrics ); |
|
205 if ( error ) |
|
206 goto Exit; |
|
207 |
|
208 top_bearing = (FT_Short)metrics.bearing_y; |
|
209 advance_height = (FT_UShort)metrics.advance; |
|
210 |
|
211 #endif /* 0 */ |
|
212 |
|
213 loader->left_bearing = left_bearing; |
|
214 loader->advance = advance_width; |
|
215 loader->top_bearing = top_bearing; |
|
216 loader->vadvance = advance_height; |
|
217 |
|
218 if ( !loader->linear_def ) |
|
219 { |
|
220 loader->linear_def = 1; |
|
221 loader->linear = advance_width; |
|
222 } |
|
223 } |
|
224 |
|
225 Exit: |
|
226 return; |
|
227 } |
|
228 |
|
229 #endif /* FT_CONFIG_OPTION_INCREMENTAL */ |
|
230 |
|
231 |
|
232 /*************************************************************************/ |
|
233 /* */ |
|
234 /* Translates an array of coordinates. */ |
|
235 /* */ |
|
236 static void |
|
237 translate_array( FT_UInt n, |
|
238 FT_Vector* coords, |
|
239 FT_Pos delta_x, |
|
240 FT_Pos delta_y ) |
|
241 { |
|
242 FT_UInt k; |
|
243 |
|
244 |
|
245 if ( delta_x ) |
|
246 for ( k = 0; k < n; k++ ) |
|
247 coords[k].x += delta_x; |
|
248 |
|
249 if ( delta_y ) |
|
250 for ( k = 0; k < n; k++ ) |
|
251 coords[k].y += delta_y; |
|
252 } |
|
253 |
|
254 |
|
255 #undef IS_HINTED |
|
256 #define IS_HINTED( flags ) ( ( flags & FT_LOAD_NO_HINTING ) == 0 ) |
|
257 |
|
258 |
|
259 /*************************************************************************/ |
|
260 /* */ |
|
261 /* The following functions are used by default with TrueType fonts. */ |
|
262 /* However, they can be replaced by alternatives if we need to support */ |
|
263 /* TrueType-compressed formats (like MicroType) in the future. */ |
|
264 /* */ |
|
265 /*************************************************************************/ |
|
266 |
|
267 FT_CALLBACK_DEF( FT_Error ) |
|
268 TT_Access_Glyph_Frame( TT_Loader loader, |
|
269 FT_UInt glyph_index, |
|
270 FT_ULong offset, |
|
271 FT_UInt byte_count ) |
|
272 { |
|
273 FT_Error error; |
|
274 FT_Stream stream = loader->stream; |
|
275 |
|
276 /* for non-debug mode */ |
|
277 FT_UNUSED( glyph_index ); |
|
278 |
|
279 |
|
280 FT_TRACE4(( "Glyph %ld\n", glyph_index )); |
|
281 |
|
282 /* the following line sets the `error' variable through macros! */ |
|
283 if ( FT_STREAM_SEEK( offset ) || FT_FRAME_ENTER( byte_count ) ) |
|
284 return error; |
|
285 |
|
286 loader->cursor = stream->cursor; |
|
287 loader->limit = stream->limit; |
|
288 |
|
289 return TT_Err_Ok; |
|
290 } |
|
291 |
|
292 |
|
293 FT_CALLBACK_DEF( void ) |
|
294 TT_Forget_Glyph_Frame( TT_Loader loader ) |
|
295 { |
|
296 FT_Stream stream = loader->stream; |
|
297 |
|
298 |
|
299 FT_FRAME_EXIT(); |
|
300 } |
|
301 |
|
302 |
|
303 FT_CALLBACK_DEF( FT_Error ) |
|
304 TT_Load_Glyph_Header( TT_Loader loader ) |
|
305 { |
|
306 FT_Byte* p = loader->cursor; |
|
307 FT_Byte* limit = loader->limit; |
|
308 |
|
309 |
|
310 if ( p + 10 > limit ) |
|
311 return TT_Err_Invalid_Outline; |
|
312 |
|
313 loader->n_contours = FT_NEXT_SHORT( p ); |
|
314 |
|
315 loader->bbox.xMin = FT_NEXT_SHORT( p ); |
|
316 loader->bbox.yMin = FT_NEXT_SHORT( p ); |
|
317 loader->bbox.xMax = FT_NEXT_SHORT( p ); |
|
318 loader->bbox.yMax = FT_NEXT_SHORT( p ); |
|
319 |
|
320 FT_TRACE5(( " # of contours: %d\n", loader->n_contours )); |
|
321 FT_TRACE5(( " xMin: %4d xMax: %4d\n", loader->bbox.xMin, |
|
322 loader->bbox.xMax )); |
|
323 FT_TRACE5(( " yMin: %4d yMax: %4d\n", loader->bbox.yMin, |
|
324 loader->bbox.yMax )); |
|
325 loader->cursor = p; |
|
326 |
|
327 return TT_Err_Ok; |
|
328 } |
|
329 |
|
330 |
|
331 FT_CALLBACK_DEF( FT_Error ) |
|
332 TT_Load_Simple_Glyph( TT_Loader load ) |
|
333 { |
|
334 FT_Error error; |
|
335 FT_Byte* p = load->cursor; |
|
336 FT_Byte* limit = load->limit; |
|
337 FT_GlyphLoader gloader = load->gloader; |
|
338 FT_Int n_contours = load->n_contours; |
|
339 FT_Outline* outline; |
|
340 TT_Face face = (TT_Face)load->face; |
|
341 FT_UShort n_ins; |
|
342 FT_Int n_points; |
|
343 |
|
344 FT_Byte *flag, *flag_limit; |
|
345 FT_Byte c, count; |
|
346 FT_Vector *vec, *vec_limit; |
|
347 FT_Pos x; |
|
348 FT_Short *cont, *cont_limit, prev_cont; |
|
349 FT_Int xy_size = 0; |
|
350 |
|
351 |
|
352 /* check that we can add the contours to the glyph */ |
|
353 error = FT_GLYPHLOADER_CHECK_POINTS( gloader, 0, n_contours ); |
|
354 if ( error ) |
|
355 goto Fail; |
|
356 |
|
357 /* reading the contours' endpoints & number of points */ |
|
358 cont = gloader->current.outline.contours; |
|
359 cont_limit = cont + n_contours; |
|
360 |
|
361 /* check space for contours array + instructions count */ |
|
362 if ( n_contours >= 0xFFF || p + ( n_contours + 1 ) * 2 > limit ) |
|
363 goto Invalid_Outline; |
|
364 |
|
365 prev_cont = FT_NEXT_USHORT( p ); |
|
366 |
|
367 if ( n_contours > 0 ) |
|
368 cont[0] = prev_cont; |
|
369 |
|
370 for ( cont++; cont < cont_limit; cont++ ) |
|
371 { |
|
372 cont[0] = FT_NEXT_USHORT( p ); |
|
373 if ( cont[0] <= prev_cont ) |
|
374 { |
|
375 /* unordered contours: this is invalid */ |
|
376 error = TT_Err_Invalid_Table; |
|
377 goto Fail; |
|
378 } |
|
379 prev_cont = cont[0]; |
|
380 } |
|
381 |
|
382 n_points = 0; |
|
383 if ( n_contours > 0 ) |
|
384 { |
|
385 n_points = cont[-1] + 1; |
|
386 if ( n_points < 0 ) |
|
387 goto Invalid_Outline; |
|
388 } |
|
389 |
|
390 /* note that we will add four phantom points later */ |
|
391 error = FT_GLYPHLOADER_CHECK_POINTS( gloader, n_points + 4, 0 ); |
|
392 if ( error ) |
|
393 goto Fail; |
|
394 |
|
395 /* we'd better check the contours table right now */ |
|
396 outline = &gloader->current.outline; |
|
397 |
|
398 for ( cont = outline->contours + 1; cont < cont_limit; cont++ ) |
|
399 if ( cont[-1] >= cont[0] ) |
|
400 goto Invalid_Outline; |
|
401 |
|
402 /* reading the bytecode instructions */ |
|
403 load->glyph->control_len = 0; |
|
404 load->glyph->control_data = 0; |
|
405 |
|
406 if ( p + 2 > limit ) |
|
407 goto Invalid_Outline; |
|
408 |
|
409 n_ins = FT_NEXT_USHORT( p ); |
|
410 |
|
411 FT_TRACE5(( " Instructions size: %u\n", n_ins )); |
|
412 |
|
413 if ( n_ins > face->max_profile.maxSizeOfInstructions ) |
|
414 { |
|
415 FT_TRACE0(( "TT_Load_Simple_Glyph: too many instructions (%d)\n", |
|
416 n_ins )); |
|
417 error = TT_Err_Too_Many_Hints; |
|
418 goto Fail; |
|
419 } |
|
420 |
|
421 if ( ( limit - p ) < n_ins ) |
|
422 { |
|
423 FT_TRACE0(( "TT_Load_Simple_Glyph: instruction count mismatch\n" )); |
|
424 error = TT_Err_Too_Many_Hints; |
|
425 goto Fail; |
|
426 } |
|
427 |
|
428 #ifdef TT_USE_BYTECODE_INTERPRETER |
|
429 |
|
430 if ( IS_HINTED( load->load_flags ) ) |
|
431 { |
|
432 load->glyph->control_len = n_ins; |
|
433 load->glyph->control_data = load->exec->glyphIns; |
|
434 |
|
435 FT_MEM_COPY( load->exec->glyphIns, p, (FT_Long)n_ins ); |
|
436 } |
|
437 |
|
438 #endif /* TT_USE_BYTECODE_INTERPRETER */ |
|
439 |
|
440 p += n_ins; |
|
441 |
|
442 /* reading the point tags */ |
|
443 flag = (FT_Byte*)outline->tags; |
|
444 flag_limit = flag + n_points; |
|
445 |
|
446 FT_ASSERT( flag != NULL ); |
|
447 |
|
448 while ( flag < flag_limit ) |
|
449 { |
|
450 if ( p + 1 > limit ) |
|
451 goto Invalid_Outline; |
|
452 |
|
453 *flag++ = c = FT_NEXT_BYTE( p ); |
|
454 if ( c & 8 ) |
|
455 { |
|
456 if ( p + 1 > limit ) |
|
457 goto Invalid_Outline; |
|
458 |
|
459 count = FT_NEXT_BYTE( p ); |
|
460 if ( flag + (FT_Int)count > flag_limit ) |
|
461 goto Invalid_Outline; |
|
462 |
|
463 for ( ; count > 0; count-- ) |
|
464 *flag++ = c; |
|
465 } |
|
466 } |
|
467 |
|
468 /* reading the X coordinates */ |
|
469 |
|
470 vec = outline->points; |
|
471 vec_limit = vec + n_points; |
|
472 flag = (FT_Byte*)outline->tags; |
|
473 x = 0; |
|
474 |
|
475 if ( p + xy_size > limit ) |
|
476 goto Invalid_Outline; |
|
477 |
|
478 for ( ; vec < vec_limit; vec++, flag++ ) |
|
479 { |
|
480 FT_Pos y = 0; |
|
481 FT_Byte f = *flag; |
|
482 |
|
483 |
|
484 if ( f & 2 ) |
|
485 { |
|
486 if ( p + 1 > limit ) |
|
487 goto Invalid_Outline; |
|
488 |
|
489 y = (FT_Pos)FT_NEXT_BYTE( p ); |
|
490 if ( ( f & 16 ) == 0 ) |
|
491 y = -y; |
|
492 } |
|
493 else if ( ( f & 16 ) == 0 ) |
|
494 { |
|
495 if ( p + 2 > limit ) |
|
496 goto Invalid_Outline; |
|
497 |
|
498 y = (FT_Pos)FT_NEXT_SHORT( p ); |
|
499 } |
|
500 |
|
501 x += y; |
|
502 vec->x = x; |
|
503 /* the cast is for stupid compilers */ |
|
504 *flag = (FT_Byte)( f & ~( 2 | 16 ) ); |
|
505 } |
|
506 |
|
507 /* reading the Y coordinates */ |
|
508 |
|
509 vec = gloader->current.outline.points; |
|
510 vec_limit = vec + n_points; |
|
511 flag = (FT_Byte*)outline->tags; |
|
512 x = 0; |
|
513 |
|
514 for ( ; vec < vec_limit; vec++, flag++ ) |
|
515 { |
|
516 FT_Pos y = 0; |
|
517 FT_Byte f = *flag; |
|
518 |
|
519 |
|
520 if ( f & 4 ) |
|
521 { |
|
522 if ( p + 1 > limit ) |
|
523 goto Invalid_Outline; |
|
524 |
|
525 y = (FT_Pos)FT_NEXT_BYTE( p ); |
|
526 if ( ( f & 32 ) == 0 ) |
|
527 y = -y; |
|
528 } |
|
529 else if ( ( f & 32 ) == 0 ) |
|
530 { |
|
531 if ( p + 2 > limit ) |
|
532 goto Invalid_Outline; |
|
533 |
|
534 y = (FT_Pos)FT_NEXT_SHORT( p ); |
|
535 } |
|
536 |
|
537 x += y; |
|
538 vec->y = x; |
|
539 /* the cast is for stupid compilers */ |
|
540 *flag = (FT_Byte)( f & FT_CURVE_TAG_ON ); |
|
541 } |
|
542 |
|
543 outline->n_points = (FT_UShort)n_points; |
|
544 outline->n_contours = (FT_Short) n_contours; |
|
545 |
|
546 load->cursor = p; |
|
547 |
|
548 Fail: |
|
549 return error; |
|
550 |
|
551 Invalid_Outline: |
|
552 error = TT_Err_Invalid_Outline; |
|
553 goto Fail; |
|
554 } |
|
555 |
|
556 |
|
557 FT_CALLBACK_DEF( FT_Error ) |
|
558 TT_Load_Composite_Glyph( TT_Loader loader ) |
|
559 { |
|
560 FT_Error error; |
|
561 FT_Byte* p = loader->cursor; |
|
562 FT_Byte* limit = loader->limit; |
|
563 FT_GlyphLoader gloader = loader->gloader; |
|
564 FT_SubGlyph subglyph; |
|
565 FT_UInt num_subglyphs; |
|
566 |
|
567 |
|
568 num_subglyphs = 0; |
|
569 |
|
570 do |
|
571 { |
|
572 FT_Fixed xx, xy, yy, yx; |
|
573 FT_UInt count; |
|
574 |
|
575 |
|
576 /* check that we can load a new subglyph */ |
|
577 error = FT_GlyphLoader_CheckSubGlyphs( gloader, num_subglyphs + 1 ); |
|
578 if ( error ) |
|
579 goto Fail; |
|
580 |
|
581 /* check space */ |
|
582 if ( p + 4 > limit ) |
|
583 goto Invalid_Composite; |
|
584 |
|
585 subglyph = gloader->current.subglyphs + num_subglyphs; |
|
586 |
|
587 subglyph->arg1 = subglyph->arg2 = 0; |
|
588 |
|
589 subglyph->flags = FT_NEXT_USHORT( p ); |
|
590 subglyph->index = FT_NEXT_USHORT( p ); |
|
591 |
|
592 /* check space */ |
|
593 count = 2; |
|
594 if ( subglyph->flags & ARGS_ARE_WORDS ) |
|
595 count += 2; |
|
596 if ( subglyph->flags & WE_HAVE_A_SCALE ) |
|
597 count += 2; |
|
598 else if ( subglyph->flags & WE_HAVE_AN_XY_SCALE ) |
|
599 count += 4; |
|
600 else if ( subglyph->flags & WE_HAVE_A_2X2 ) |
|
601 count += 8; |
|
602 |
|
603 if ( p + count > limit ) |
|
604 goto Invalid_Composite; |
|
605 |
|
606 /* read arguments */ |
|
607 if ( subglyph->flags & ARGS_ARE_WORDS ) |
|
608 { |
|
609 subglyph->arg1 = FT_NEXT_SHORT( p ); |
|
610 subglyph->arg2 = FT_NEXT_SHORT( p ); |
|
611 } |
|
612 else |
|
613 { |
|
614 subglyph->arg1 = FT_NEXT_CHAR( p ); |
|
615 subglyph->arg2 = FT_NEXT_CHAR( p ); |
|
616 } |
|
617 |
|
618 /* read transform */ |
|
619 xx = yy = 0x10000L; |
|
620 xy = yx = 0; |
|
621 |
|
622 if ( subglyph->flags & WE_HAVE_A_SCALE ) |
|
623 { |
|
624 xx = (FT_Fixed)FT_NEXT_SHORT( p ) << 2; |
|
625 yy = xx; |
|
626 } |
|
627 else if ( subglyph->flags & WE_HAVE_AN_XY_SCALE ) |
|
628 { |
|
629 xx = (FT_Fixed)FT_NEXT_SHORT( p ) << 2; |
|
630 yy = (FT_Fixed)FT_NEXT_SHORT( p ) << 2; |
|
631 } |
|
632 else if ( subglyph->flags & WE_HAVE_A_2X2 ) |
|
633 { |
|
634 xx = (FT_Fixed)FT_NEXT_SHORT( p ) << 2; |
|
635 yx = (FT_Fixed)FT_NEXT_SHORT( p ) << 2; |
|
636 xy = (FT_Fixed)FT_NEXT_SHORT( p ) << 2; |
|
637 yy = (FT_Fixed)FT_NEXT_SHORT( p ) << 2; |
|
638 } |
|
639 |
|
640 subglyph->transform.xx = xx; |
|
641 subglyph->transform.xy = xy; |
|
642 subglyph->transform.yx = yx; |
|
643 subglyph->transform.yy = yy; |
|
644 |
|
645 num_subglyphs++; |
|
646 |
|
647 } while ( subglyph->flags & MORE_COMPONENTS ); |
|
648 |
|
649 gloader->current.num_subglyphs = num_subglyphs; |
|
650 |
|
651 #ifdef TT_USE_BYTECODE_INTERPRETER |
|
652 |
|
653 { |
|
654 FT_Stream stream = loader->stream; |
|
655 |
|
656 |
|
657 /* we must undo the FT_FRAME_ENTER in order to point */ |
|
658 /* to the composite instructions, if we find some. */ |
|
659 /* We will process them later. */ |
|
660 /* */ |
|
661 loader->ins_pos = (FT_ULong)( FT_STREAM_POS() + |
|
662 p - limit ); |
|
663 } |
|
664 |
|
665 #endif |
|
666 |
|
667 loader->cursor = p; |
|
668 |
|
669 Fail: |
|
670 return error; |
|
671 |
|
672 Invalid_Composite: |
|
673 error = TT_Err_Invalid_Composite; |
|
674 goto Fail; |
|
675 } |
|
676 |
|
677 |
|
678 FT_LOCAL_DEF( void ) |
|
679 TT_Init_Glyph_Loading( TT_Face face ) |
|
680 { |
|
681 face->access_glyph_frame = TT_Access_Glyph_Frame; |
|
682 face->read_glyph_header = TT_Load_Glyph_Header; |
|
683 face->read_simple_glyph = TT_Load_Simple_Glyph; |
|
684 face->read_composite_glyph = TT_Load_Composite_Glyph; |
|
685 face->forget_glyph_frame = TT_Forget_Glyph_Frame; |
|
686 } |
|
687 |
|
688 |
|
689 static void |
|
690 tt_prepare_zone( TT_GlyphZone zone, |
|
691 FT_GlyphLoad load, |
|
692 FT_UInt start_point, |
|
693 FT_UInt start_contour ) |
|
694 { |
|
695 zone->n_points = (FT_UShort)( load->outline.n_points - start_point ); |
|
696 zone->n_contours = (FT_Short) ( load->outline.n_contours - |
|
697 start_contour ); |
|
698 zone->org = load->extra_points + start_point; |
|
699 zone->cur = load->outline.points + start_point; |
|
700 zone->orus = load->extra_points2 + start_point; |
|
701 zone->tags = (FT_Byte*)load->outline.tags + start_point; |
|
702 zone->contours = (FT_UShort*)load->outline.contours + start_contour; |
|
703 zone->first_point = (FT_UShort)start_point; |
|
704 } |
|
705 |
|
706 |
|
707 /*************************************************************************/ |
|
708 /* */ |
|
709 /* <Function> */ |
|
710 /* TT_Hint_Glyph */ |
|
711 /* */ |
|
712 /* <Description> */ |
|
713 /* Hint the glyph using the zone prepared by the caller. Note that */ |
|
714 /* the zone is supposed to include four phantom points. */ |
|
715 /* */ |
|
716 static FT_Error |
|
717 TT_Hint_Glyph( TT_Loader loader, |
|
718 FT_Bool is_composite ) |
|
719 { |
|
720 TT_GlyphZone zone = &loader->zone; |
|
721 FT_Pos origin; |
|
722 |
|
723 #ifdef TT_USE_BYTECODE_INTERPRETER |
|
724 FT_UInt n_ins; |
|
725 #else |
|
726 FT_UNUSED( is_composite ); |
|
727 #endif |
|
728 |
|
729 |
|
730 #ifdef TT_USE_BYTECODE_INTERPRETER |
|
731 if ( loader->glyph->control_len > 0xFFFFL ) |
|
732 { |
|
733 FT_TRACE1(( "TT_Hint_Glyph: too long instructions " )); |
|
734 FT_TRACE1(( "(0x%lx byte) is truncated\n", |
|
735 loader->glyph->control_len )); |
|
736 } |
|
737 n_ins = (FT_UInt)( loader->glyph->control_len ); |
|
738 #endif |
|
739 |
|
740 origin = zone->cur[zone->n_points - 4].x; |
|
741 origin = FT_PIX_ROUND( origin ) - origin; |
|
742 if ( origin ) |
|
743 translate_array( zone->n_points, zone->cur, origin, 0 ); |
|
744 |
|
745 #ifdef TT_USE_BYTECODE_INTERPRETER |
|
746 /* save original point position in org */ |
|
747 if ( n_ins > 0 ) |
|
748 FT_ARRAY_COPY( zone->org, zone->cur, zone->n_points ); |
|
749 |
|
750 /* Reset graphics state. */ |
|
751 loader->exec->GS = ((TT_Size)loader->size)->GS; |
|
752 |
|
753 /* XXX: UNDOCUMENTED! Hinting instructions of a composite glyph */ |
|
754 /* completely refer to the (already) hinted subglyphs. */ |
|
755 if ( is_composite ) |
|
756 { |
|
757 loader->exec->metrics.x_scale = 1 << 16; |
|
758 loader->exec->metrics.y_scale = 1 << 16; |
|
759 |
|
760 FT_ARRAY_COPY( zone->orus, zone->cur, zone->n_points ); |
|
761 } |
|
762 else |
|
763 { |
|
764 loader->exec->metrics.x_scale = |
|
765 ((TT_Size)loader->size)->metrics.x_scale; |
|
766 loader->exec->metrics.y_scale = |
|
767 ((TT_Size)loader->size)->metrics.y_scale; |
|
768 } |
|
769 #endif |
|
770 |
|
771 /* round pp2 and pp4 */ |
|
772 zone->cur[zone->n_points - 3].x = |
|
773 FT_PIX_ROUND( zone->cur[zone->n_points - 3].x ); |
|
774 zone->cur[zone->n_points - 1].y = |
|
775 FT_PIX_ROUND( zone->cur[zone->n_points - 1].y ); |
|
776 |
|
777 #ifdef TT_USE_BYTECODE_INTERPRETER |
|
778 |
|
779 if ( n_ins > 0 ) |
|
780 { |
|
781 FT_Bool debug; |
|
782 FT_Error error; |
|
783 |
|
784 FT_GlyphLoader gloader = loader->gloader; |
|
785 FT_Outline current_outline = gloader->current.outline; |
|
786 |
|
787 |
|
788 error = TT_Set_CodeRange( loader->exec, tt_coderange_glyph, |
|
789 loader->exec->glyphIns, n_ins ); |
|
790 if ( error ) |
|
791 return error; |
|
792 |
|
793 loader->exec->is_composite = is_composite; |
|
794 loader->exec->pts = *zone; |
|
795 |
|
796 debug = FT_BOOL( !( loader->load_flags & FT_LOAD_NO_SCALE ) && |
|
797 ((TT_Size)loader->size)->debug ); |
|
798 |
|
799 error = TT_Run_Context( loader->exec, debug ); |
|
800 if ( error && loader->exec->pedantic_hinting ) |
|
801 return error; |
|
802 |
|
803 /* store drop-out mode in bits 5-7; set bit 2 also as a marker */ |
|
804 current_outline.tags[0] |= |
|
805 ( loader->exec->GS.scan_type << 5 ) | FT_CURVE_TAG_HAS_SCANMODE; |
|
806 } |
|
807 |
|
808 #endif |
|
809 |
|
810 /* save glyph phantom points */ |
|
811 if ( !loader->preserve_pps ) |
|
812 { |
|
813 loader->pp1 = zone->cur[zone->n_points - 4]; |
|
814 loader->pp2 = zone->cur[zone->n_points - 3]; |
|
815 loader->pp3 = zone->cur[zone->n_points - 2]; |
|
816 loader->pp4 = zone->cur[zone->n_points - 1]; |
|
817 } |
|
818 |
|
819 return TT_Err_Ok; |
|
820 } |
|
821 |
|
822 |
|
823 /*************************************************************************/ |
|
824 /* */ |
|
825 /* <Function> */ |
|
826 /* TT_Process_Simple_Glyph */ |
|
827 /* */ |
|
828 /* <Description> */ |
|
829 /* Once a simple glyph has been loaded, it needs to be processed. */ |
|
830 /* Usually, this means scaling and hinting through bytecode */ |
|
831 /* interpretation. */ |
|
832 /* */ |
|
833 static FT_Error |
|
834 TT_Process_Simple_Glyph( TT_Loader loader ) |
|
835 { |
|
836 FT_GlyphLoader gloader = loader->gloader; |
|
837 FT_Error error = TT_Err_Ok; |
|
838 FT_Outline* outline; |
|
839 FT_Int n_points; |
|
840 |
|
841 |
|
842 outline = &gloader->current.outline; |
|
843 n_points = outline->n_points; |
|
844 |
|
845 /* set phantom points */ |
|
846 |
|
847 outline->points[n_points ] = loader->pp1; |
|
848 outline->points[n_points + 1] = loader->pp2; |
|
849 outline->points[n_points + 2] = loader->pp3; |
|
850 outline->points[n_points + 3] = loader->pp4; |
|
851 |
|
852 outline->tags[n_points ] = 0; |
|
853 outline->tags[n_points + 1] = 0; |
|
854 outline->tags[n_points + 2] = 0; |
|
855 outline->tags[n_points + 3] = 0; |
|
856 |
|
857 n_points += 4; |
|
858 |
|
859 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT |
|
860 |
|
861 if ( ((TT_Face)loader->face)->doblend ) |
|
862 { |
|
863 /* Deltas apply to the unscaled data. */ |
|
864 FT_Vector* deltas; |
|
865 FT_Memory memory = loader->face->memory; |
|
866 FT_Int i; |
|
867 |
|
868 |
|
869 error = TT_Vary_Get_Glyph_Deltas( (TT_Face)(loader->face), |
|
870 loader->glyph_index, |
|
871 &deltas, |
|
872 n_points ); |
|
873 if ( error ) |
|
874 return error; |
|
875 |
|
876 for ( i = 0; i < n_points; ++i ) |
|
877 { |
|
878 outline->points[i].x += deltas[i].x; |
|
879 outline->points[i].y += deltas[i].y; |
|
880 } |
|
881 |
|
882 FT_FREE( deltas ); |
|
883 } |
|
884 |
|
885 #endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */ |
|
886 |
|
887 if ( IS_HINTED( loader->load_flags ) ) |
|
888 { |
|
889 tt_prepare_zone( &loader->zone, &gloader->current, 0, 0 ); |
|
890 |
|
891 FT_ARRAY_COPY( loader->zone.orus, loader->zone.cur, |
|
892 loader->zone.n_points + 4 ); |
|
893 } |
|
894 |
|
895 /* scale the glyph */ |
|
896 if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 ) |
|
897 { |
|
898 FT_Vector* vec = outline->points; |
|
899 FT_Vector* limit = outline->points + n_points; |
|
900 FT_Fixed x_scale = ((TT_Size)loader->size)->metrics.x_scale; |
|
901 FT_Fixed y_scale = ((TT_Size)loader->size)->metrics.y_scale; |
|
902 |
|
903 |
|
904 for ( ; vec < limit; vec++ ) |
|
905 { |
|
906 vec->x = FT_MulFix( vec->x, x_scale ); |
|
907 vec->y = FT_MulFix( vec->y, y_scale ); |
|
908 } |
|
909 |
|
910 loader->pp1 = outline->points[n_points - 4]; |
|
911 loader->pp2 = outline->points[n_points - 3]; |
|
912 loader->pp3 = outline->points[n_points - 2]; |
|
913 loader->pp4 = outline->points[n_points - 1]; |
|
914 } |
|
915 |
|
916 if ( IS_HINTED( loader->load_flags ) ) |
|
917 { |
|
918 loader->zone.n_points += 4; |
|
919 |
|
920 error = TT_Hint_Glyph( loader, 0 ); |
|
921 } |
|
922 |
|
923 return error; |
|
924 } |
|
925 |
|
926 |
|
927 /*************************************************************************/ |
|
928 /* */ |
|
929 /* <Function> */ |
|
930 /* TT_Process_Composite_Component */ |
|
931 /* */ |
|
932 /* <Description> */ |
|
933 /* Once a composite component has been loaded, it needs to be */ |
|
934 /* processed. Usually, this means transforming and translating. */ |
|
935 /* */ |
|
936 static FT_Error |
|
937 TT_Process_Composite_Component( TT_Loader loader, |
|
938 FT_SubGlyph subglyph, |
|
939 FT_UInt start_point, |
|
940 FT_UInt num_base_points ) |
|
941 { |
|
942 FT_GlyphLoader gloader = loader->gloader; |
|
943 FT_Vector* base_vec = gloader->base.outline.points; |
|
944 FT_UInt num_points = gloader->base.outline.n_points; |
|
945 FT_Bool have_scale; |
|
946 FT_Pos x, y; |
|
947 |
|
948 |
|
949 have_scale = FT_BOOL( subglyph->flags & ( WE_HAVE_A_SCALE | |
|
950 WE_HAVE_AN_XY_SCALE | |
|
951 WE_HAVE_A_2X2 ) ); |
|
952 |
|
953 /* perform the transform required for this subglyph */ |
|
954 if ( have_scale ) |
|
955 { |
|
956 FT_UInt i; |
|
957 |
|
958 |
|
959 for ( i = num_base_points; i < num_points; i++ ) |
|
960 FT_Vector_Transform( base_vec + i, &subglyph->transform ); |
|
961 } |
|
962 |
|
963 /* get offset */ |
|
964 if ( !( subglyph->flags & ARGS_ARE_XY_VALUES ) ) |
|
965 { |
|
966 FT_UInt k = subglyph->arg1; |
|
967 FT_UInt l = subglyph->arg2; |
|
968 FT_Vector* p1; |
|
969 FT_Vector* p2; |
|
970 |
|
971 |
|
972 /* match l-th point of the newly loaded component to the k-th point */ |
|
973 /* of the previously loaded components. */ |
|
974 |
|
975 /* change to the point numbers used by our outline */ |
|
976 k += start_point; |
|
977 l += num_base_points; |
|
978 if ( k >= num_base_points || |
|
979 l >= num_points ) |
|
980 return TT_Err_Invalid_Composite; |
|
981 |
|
982 p1 = gloader->base.outline.points + k; |
|
983 p2 = gloader->base.outline.points + l; |
|
984 |
|
985 x = p1->x - p2->x; |
|
986 y = p1->y - p2->y; |
|
987 } |
|
988 else |
|
989 { |
|
990 x = subglyph->arg1; |
|
991 y = subglyph->arg2; |
|
992 |
|
993 if ( !x && !y ) |
|
994 return TT_Err_Ok; |
|
995 |
|
996 /* Use a default value dependent on */ |
|
997 /* TT_CONFIG_OPTION_COMPONENT_OFFSET_SCALED. This is useful for old TT */ |
|
998 /* fonts which don't set the xxx_COMPONENT_OFFSET bit. */ |
|
999 |
|
1000 if ( have_scale && |
|
1001 #ifdef TT_CONFIG_OPTION_COMPONENT_OFFSET_SCALED |
|
1002 !( subglyph->flags & UNSCALED_COMPONENT_OFFSET ) ) |
|
1003 #else |
|
1004 ( subglyph->flags & SCALED_COMPONENT_OFFSET ) ) |
|
1005 #endif |
|
1006 { |
|
1007 |
|
1008 #if 0 |
|
1009 |
|
1010 /*************************************************************************/ |
|
1011 /* */ |
|
1012 /* This algorithm is what Apple documents. But it doesn't work. */ |
|
1013 /* */ |
|
1014 int a = subglyph->transform.xx > 0 ? subglyph->transform.xx |
|
1015 : -subglyph->transform.xx; |
|
1016 int b = subglyph->transform.yx > 0 ? subglyph->transform.yx |
|
1017 : -subglyph->transform.yx; |
|
1018 int c = subglyph->transform.xy > 0 ? subglyph->transform.xy |
|
1019 : -subglyph->transform.xy; |
|
1020 int d = subglyph->transform.yy > 0 ? subglyph->transform.yy |
|
1021 : -subglyph->transform.yy; |
|
1022 int m = a > b ? a : b; |
|
1023 int n = c > d ? c : d; |
|
1024 |
|
1025 |
|
1026 if ( a - b <= 33 && a - b >= -33 ) |
|
1027 m *= 2; |
|
1028 if ( c - d <= 33 && c - d >= -33 ) |
|
1029 n *= 2; |
|
1030 x = FT_MulFix( x, m ); |
|
1031 y = FT_MulFix( y, n ); |
|
1032 |
|
1033 #else /* 0 */ |
|
1034 |
|
1035 /*************************************************************************/ |
|
1036 /* */ |
|
1037 /* This algorithm is a guess and works much better than the above. */ |
|
1038 /* */ |
|
1039 FT_Fixed mac_xscale = FT_SqrtFixed( |
|
1040 (FT_Int32)FT_MulFix( subglyph->transform.xx, |
|
1041 subglyph->transform.xx ) + |
|
1042 (FT_Int32)FT_MulFix( subglyph->transform.xy, |
|
1043 subglyph->transform.xy ) ); |
|
1044 FT_Fixed mac_yscale = FT_SqrtFixed( |
|
1045 (FT_Int32)FT_MulFix( subglyph->transform.yy, |
|
1046 subglyph->transform.yy ) + |
|
1047 (FT_Int32)FT_MulFix( subglyph->transform.yx, |
|
1048 subglyph->transform.yx ) ); |
|
1049 |
|
1050 |
|
1051 x = FT_MulFix( x, mac_xscale ); |
|
1052 y = FT_MulFix( y, mac_yscale ); |
|
1053 |
|
1054 #endif /* 0 */ |
|
1055 |
|
1056 } |
|
1057 |
|
1058 if ( !( loader->load_flags & FT_LOAD_NO_SCALE ) ) |
|
1059 { |
|
1060 FT_Fixed x_scale = ((TT_Size)loader->size)->metrics.x_scale; |
|
1061 FT_Fixed y_scale = ((TT_Size)loader->size)->metrics.y_scale; |
|
1062 |
|
1063 |
|
1064 x = FT_MulFix( x, x_scale ); |
|
1065 y = FT_MulFix( y, y_scale ); |
|
1066 |
|
1067 if ( subglyph->flags & ROUND_XY_TO_GRID ) |
|
1068 { |
|
1069 x = FT_PIX_ROUND( x ); |
|
1070 y = FT_PIX_ROUND( y ); |
|
1071 } |
|
1072 } |
|
1073 } |
|
1074 |
|
1075 if ( x || y ) |
|
1076 translate_array( num_points - num_base_points, |
|
1077 base_vec + num_base_points, |
|
1078 x, y ); |
|
1079 |
|
1080 return TT_Err_Ok; |
|
1081 } |
|
1082 |
|
1083 |
|
1084 /*************************************************************************/ |
|
1085 /* */ |
|
1086 /* <Function> */ |
|
1087 /* TT_Process_Composite_Glyph */ |
|
1088 /* */ |
|
1089 /* <Description> */ |
|
1090 /* This is slightly different from TT_Process_Simple_Glyph, in that */ |
|
1091 /* its sole purpose is to hint the glyph. Thus this function is */ |
|
1092 /* only available when bytecode interpreter is enabled. */ |
|
1093 /* */ |
|
1094 static FT_Error |
|
1095 TT_Process_Composite_Glyph( TT_Loader loader, |
|
1096 FT_UInt start_point, |
|
1097 FT_UInt start_contour ) |
|
1098 { |
|
1099 FT_Error error; |
|
1100 FT_Outline* outline; |
|
1101 FT_UInt i; |
|
1102 |
|
1103 |
|
1104 outline = &loader->gloader->base.outline; |
|
1105 |
|
1106 /* make room for phantom points */ |
|
1107 error = FT_GLYPHLOADER_CHECK_POINTS( loader->gloader, |
|
1108 outline->n_points + 4, |
|
1109 0 ); |
|
1110 if ( error ) |
|
1111 return error; |
|
1112 |
|
1113 outline->points[outline->n_points ] = loader->pp1; |
|
1114 outline->points[outline->n_points + 1] = loader->pp2; |
|
1115 outline->points[outline->n_points + 2] = loader->pp3; |
|
1116 outline->points[outline->n_points + 3] = loader->pp4; |
|
1117 |
|
1118 outline->tags[outline->n_points ] = 0; |
|
1119 outline->tags[outline->n_points + 1] = 0; |
|
1120 outline->tags[outline->n_points + 2] = 0; |
|
1121 outline->tags[outline->n_points + 3] = 0; |
|
1122 |
|
1123 #ifdef TT_USE_BYTECODE_INTERPRETER |
|
1124 |
|
1125 { |
|
1126 FT_Stream stream = loader->stream; |
|
1127 FT_UShort n_ins, max_ins; |
|
1128 FT_ULong tmp; |
|
1129 |
|
1130 |
|
1131 /* TT_Load_Composite_Glyph only gives us the offset of instructions */ |
|
1132 /* so we read them here */ |
|
1133 if ( FT_STREAM_SEEK( loader->ins_pos ) || |
|
1134 FT_READ_USHORT( n_ins ) ) |
|
1135 return error; |
|
1136 |
|
1137 FT_TRACE5(( " Instructions size = %d\n", n_ins )); |
|
1138 |
|
1139 /* check it */ |
|
1140 max_ins = ((TT_Face)loader->face)->max_profile.maxSizeOfInstructions; |
|
1141 if ( n_ins > max_ins ) |
|
1142 { |
|
1143 /* acroread ignores this field, so we only do a rough safety check */ |
|
1144 if ( (FT_Int)n_ins > loader->byte_len ) |
|
1145 { |
|
1146 FT_TRACE1(( "TT_Process_Composite_Glyph: " |
|
1147 "too many instructions (%d) for glyph with length %d\n", |
|
1148 n_ins, loader->byte_len )); |
|
1149 return TT_Err_Too_Many_Hints; |
|
1150 } |
|
1151 |
|
1152 tmp = loader->exec->glyphSize; |
|
1153 error = Update_Max( loader->exec->memory, |
|
1154 &tmp, |
|
1155 sizeof ( FT_Byte ), |
|
1156 (void*)&loader->exec->glyphIns, |
|
1157 n_ins ); |
|
1158 loader->exec->glyphSize = (FT_UShort)tmp; |
|
1159 if ( error ) |
|
1160 return error; |
|
1161 } |
|
1162 else if ( n_ins == 0 ) |
|
1163 return TT_Err_Ok; |
|
1164 |
|
1165 if ( FT_STREAM_READ( loader->exec->glyphIns, n_ins ) ) |
|
1166 return error; |
|
1167 |
|
1168 loader->glyph->control_data = loader->exec->glyphIns; |
|
1169 loader->glyph->control_len = n_ins; |
|
1170 } |
|
1171 |
|
1172 #endif |
|
1173 |
|
1174 tt_prepare_zone( &loader->zone, &loader->gloader->base, |
|
1175 start_point, start_contour ); |
|
1176 |
|
1177 /* Some points are likely touched during execution of */ |
|
1178 /* instructions on components. So let's untouch them. */ |
|
1179 for ( i = start_point; i < loader->zone.n_points; i++ ) |
|
1180 loader->zone.tags[i] &= ~FT_CURVE_TAG_TOUCH_BOTH; |
|
1181 |
|
1182 loader->zone.n_points += 4; |
|
1183 |
|
1184 return TT_Hint_Glyph( loader, 1 ); |
|
1185 } |
|
1186 |
|
1187 |
|
1188 /* Calculate the four phantom points. */ |
|
1189 /* The first two stand for horizontal origin and advance. */ |
|
1190 /* The last two stand for vertical origin and advance. */ |
|
1191 #define TT_LOADER_SET_PP( loader ) \ |
|
1192 do { \ |
|
1193 (loader)->pp1.x = (loader)->bbox.xMin - (loader)->left_bearing; \ |
|
1194 (loader)->pp1.y = 0; \ |
|
1195 (loader)->pp2.x = (loader)->pp1.x + (loader)->advance; \ |
|
1196 (loader)->pp2.y = 0; \ |
|
1197 (loader)->pp3.x = 0; \ |
|
1198 (loader)->pp3.y = (loader)->top_bearing + (loader)->bbox.yMax; \ |
|
1199 (loader)->pp4.x = 0; \ |
|
1200 (loader)->pp4.y = (loader)->pp3.y - (loader)->vadvance; \ |
|
1201 } while ( 0 ) |
|
1202 |
|
1203 |
|
1204 /*************************************************************************/ |
|
1205 /* */ |
|
1206 /* <Function> */ |
|
1207 /* load_truetype_glyph */ |
|
1208 /* */ |
|
1209 /* <Description> */ |
|
1210 /* Loads a given truetype glyph. Handles composites and uses a */ |
|
1211 /* TT_Loader object. */ |
|
1212 /* */ |
|
1213 static FT_Error |
|
1214 load_truetype_glyph( TT_Loader loader, |
|
1215 FT_UInt glyph_index, |
|
1216 FT_UInt recurse_count, |
|
1217 FT_Bool header_only ) |
|
1218 { |
|
1219 FT_Error error = TT_Err_Ok; |
|
1220 FT_Fixed x_scale, y_scale; |
|
1221 FT_ULong offset; |
|
1222 TT_Face face = (TT_Face)loader->face; |
|
1223 FT_GlyphLoader gloader = loader->gloader; |
|
1224 FT_Bool opened_frame = 0; |
|
1225 |
|
1226 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT |
|
1227 FT_Vector* deltas = NULL; |
|
1228 #endif |
|
1229 |
|
1230 #ifdef FT_CONFIG_OPTION_INCREMENTAL |
|
1231 FT_StreamRec inc_stream; |
|
1232 FT_Data glyph_data; |
|
1233 FT_Bool glyph_data_loaded = 0; |
|
1234 #endif |
|
1235 |
|
1236 |
|
1237 /* some fonts have an incorrect value of `maxComponentDepth', */ |
|
1238 /* thus we allow depth 1 to catch the majority of them */ |
|
1239 if ( recurse_count > 1 && |
|
1240 recurse_count > face->max_profile.maxComponentDepth ) |
|
1241 { |
|
1242 error = TT_Err_Invalid_Composite; |
|
1243 goto Exit; |
|
1244 } |
|
1245 |
|
1246 /* check glyph index */ |
|
1247 if ( glyph_index >= (FT_UInt)face->root.num_glyphs ) |
|
1248 { |
|
1249 error = TT_Err_Invalid_Glyph_Index; |
|
1250 goto Exit; |
|
1251 } |
|
1252 |
|
1253 loader->glyph_index = glyph_index; |
|
1254 |
|
1255 if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 ) |
|
1256 { |
|
1257 x_scale = ((TT_Size)loader->size)->metrics.x_scale; |
|
1258 y_scale = ((TT_Size)loader->size)->metrics.y_scale; |
|
1259 } |
|
1260 else |
|
1261 { |
|
1262 x_scale = 0x10000L; |
|
1263 y_scale = 0x10000L; |
|
1264 } |
|
1265 |
|
1266 tt_get_metrics( loader, glyph_index ); |
|
1267 |
|
1268 /* Set `offset' to the start of the glyph relative to the start of */ |
|
1269 /* the `glyf' table, and `byte_len' to the length of the glyph in */ |
|
1270 /* bytes. */ |
|
1271 |
|
1272 #ifdef FT_CONFIG_OPTION_INCREMENTAL |
|
1273 |
|
1274 /* If we are loading glyph data via the incremental interface, set */ |
|
1275 /* the loader stream to a memory stream reading the data returned */ |
|
1276 /* by the interface. */ |
|
1277 if ( face->root.internal->incremental_interface ) |
|
1278 { |
|
1279 error = face->root.internal->incremental_interface->funcs->get_glyph_data( |
|
1280 face->root.internal->incremental_interface->object, |
|
1281 glyph_index, &glyph_data ); |
|
1282 if ( error ) |
|
1283 goto Exit; |
|
1284 |
|
1285 glyph_data_loaded = 1; |
|
1286 offset = 0; |
|
1287 loader->byte_len = glyph_data.length; |
|
1288 |
|
1289 FT_MEM_ZERO( &inc_stream, sizeof ( inc_stream ) ); |
|
1290 FT_Stream_OpenMemory( &inc_stream, |
|
1291 glyph_data.pointer, glyph_data.length ); |
|
1292 |
|
1293 loader->stream = &inc_stream; |
|
1294 } |
|
1295 else |
|
1296 |
|
1297 #endif /* FT_CONFIG_OPTION_INCREMENTAL */ |
|
1298 |
|
1299 offset = tt_face_get_location( face, glyph_index, |
|
1300 (FT_UInt*)&loader->byte_len ); |
|
1301 |
|
1302 if ( loader->byte_len > 0 ) |
|
1303 { |
|
1304 #ifdef FT_CONFIG_OPTION_INCREMENTAL |
|
1305 /* for the incremental interface, `glyf_offset' is always zero */ |
|
1306 if ( !loader->glyf_offset && |
|
1307 !face->root.internal->incremental_interface ) |
|
1308 #else |
|
1309 if ( !loader->glyf_offset ) |
|
1310 #endif /* FT_CONFIG_OPTION_INCREMENTAL */ |
|
1311 { |
|
1312 FT_TRACE2(( "no `glyf' table but non-zero `loca' entry\n" )); |
|
1313 error = TT_Err_Invalid_Table; |
|
1314 goto Exit; |
|
1315 } |
|
1316 |
|
1317 error = face->access_glyph_frame( loader, glyph_index, |
|
1318 loader->glyf_offset + offset, |
|
1319 loader->byte_len ); |
|
1320 if ( error ) |
|
1321 goto Exit; |
|
1322 |
|
1323 opened_frame = 1; |
|
1324 |
|
1325 /* read glyph header first */ |
|
1326 error = face->read_glyph_header( loader ); |
|
1327 if ( error || header_only ) |
|
1328 goto Exit; |
|
1329 } |
|
1330 |
|
1331 if ( loader->byte_len == 0 || loader->n_contours == 0 ) |
|
1332 { |
|
1333 loader->bbox.xMin = 0; |
|
1334 loader->bbox.xMax = 0; |
|
1335 loader->bbox.yMin = 0; |
|
1336 loader->bbox.yMax = 0; |
|
1337 |
|
1338 if ( header_only ) |
|
1339 goto Exit; |
|
1340 |
|
1341 /* must initialize points before (possibly) overriding */ |
|
1342 /* glyph metrics from the incremental interface */ |
|
1343 TT_LOADER_SET_PP( loader ); |
|
1344 |
|
1345 #ifdef FT_CONFIG_OPTION_INCREMENTAL |
|
1346 tt_get_metrics_incr_overrides( loader, glyph_index ); |
|
1347 #endif |
|
1348 |
|
1349 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT |
|
1350 |
|
1351 if ( ((TT_Face)(loader->face))->doblend ) |
|
1352 { |
|
1353 /* this must be done before scaling */ |
|
1354 FT_Memory memory = loader->face->memory; |
|
1355 |
|
1356 |
|
1357 error = TT_Vary_Get_Glyph_Deltas( (TT_Face)(loader->face), |
|
1358 glyph_index, &deltas, 4 ); |
|
1359 if ( error ) |
|
1360 goto Exit; |
|
1361 |
|
1362 loader->pp1.x += deltas[0].x; loader->pp1.y += deltas[0].y; |
|
1363 loader->pp2.x += deltas[1].x; loader->pp2.y += deltas[1].y; |
|
1364 loader->pp3.x += deltas[2].x; loader->pp3.y += deltas[2].y; |
|
1365 loader->pp4.x += deltas[3].x; loader->pp4.y += deltas[3].y; |
|
1366 |
|
1367 FT_FREE( deltas ); |
|
1368 } |
|
1369 |
|
1370 #endif |
|
1371 |
|
1372 if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 ) |
|
1373 { |
|
1374 loader->pp1.x = FT_MulFix( loader->pp1.x, x_scale ); |
|
1375 loader->pp2.x = FT_MulFix( loader->pp2.x, x_scale ); |
|
1376 loader->pp3.y = FT_MulFix( loader->pp3.y, y_scale ); |
|
1377 loader->pp4.y = FT_MulFix( loader->pp4.y, y_scale ); |
|
1378 } |
|
1379 |
|
1380 error = TT_Err_Ok; |
|
1381 goto Exit; |
|
1382 } |
|
1383 |
|
1384 /* must initialize points before (possibly) overriding */ |
|
1385 /* glyph metrics from the incremental interface */ |
|
1386 TT_LOADER_SET_PP( loader ); |
|
1387 |
|
1388 #ifdef FT_CONFIG_OPTION_INCREMENTAL |
|
1389 tt_get_metrics_incr_overrides( loader, glyph_index ); |
|
1390 #endif |
|
1391 |
|
1392 /***********************************************************************/ |
|
1393 /***********************************************************************/ |
|
1394 /***********************************************************************/ |
|
1395 |
|
1396 /* if it is a simple glyph, load it */ |
|
1397 |
|
1398 if ( loader->n_contours > 0 ) |
|
1399 { |
|
1400 error = face->read_simple_glyph( loader ); |
|
1401 if ( error ) |
|
1402 goto Exit; |
|
1403 |
|
1404 /* all data have been read */ |
|
1405 face->forget_glyph_frame( loader ); |
|
1406 opened_frame = 0; |
|
1407 |
|
1408 error = TT_Process_Simple_Glyph( loader ); |
|
1409 if ( error ) |
|
1410 goto Exit; |
|
1411 |
|
1412 FT_GlyphLoader_Add( gloader ); |
|
1413 } |
|
1414 |
|
1415 /***********************************************************************/ |
|
1416 /***********************************************************************/ |
|
1417 /***********************************************************************/ |
|
1418 |
|
1419 /* otherwise, load a composite! */ |
|
1420 else if ( loader->n_contours == -1 ) |
|
1421 { |
|
1422 FT_UInt start_point; |
|
1423 FT_UInt start_contour; |
|
1424 FT_ULong ins_pos; /* position of composite instructions, if any */ |
|
1425 |
|
1426 |
|
1427 start_point = gloader->base.outline.n_points; |
|
1428 start_contour = gloader->base.outline.n_contours; |
|
1429 |
|
1430 /* for each subglyph, read composite header */ |
|
1431 error = face->read_composite_glyph( loader ); |
|
1432 if ( error ) |
|
1433 goto Exit; |
|
1434 |
|
1435 /* store the offset of instructions */ |
|
1436 ins_pos = loader->ins_pos; |
|
1437 |
|
1438 /* all data we need are read */ |
|
1439 face->forget_glyph_frame( loader ); |
|
1440 opened_frame = 0; |
|
1441 |
|
1442 #ifdef TT_CONFIG_OPTION_GX_VAR_SUPPORT |
|
1443 |
|
1444 if ( face->doblend ) |
|
1445 { |
|
1446 FT_Int i, limit; |
|
1447 FT_SubGlyph subglyph; |
|
1448 FT_Memory memory = face->root.memory; |
|
1449 |
|
1450 |
|
1451 /* this provides additional offsets */ |
|
1452 /* for each component's translation */ |
|
1453 |
|
1454 if ( ( error = TT_Vary_Get_Glyph_Deltas( |
|
1455 face, |
|
1456 glyph_index, |
|
1457 &deltas, |
|
1458 gloader->current.num_subglyphs + 4 )) != 0 ) |
|
1459 goto Exit; |
|
1460 |
|
1461 subglyph = gloader->current.subglyphs + gloader->base.num_subglyphs; |
|
1462 limit = gloader->current.num_subglyphs; |
|
1463 |
|
1464 for ( i = 0; i < limit; ++i, ++subglyph ) |
|
1465 { |
|
1466 if ( subglyph->flags & ARGS_ARE_XY_VALUES ) |
|
1467 { |
|
1468 /* XXX: overflow check for subglyph->{arg1,arg2}. */ |
|
1469 /* deltas[i].{x,y} must be within signed 16-bit, */ |
|
1470 /* but the restriction of summed delta is not clear */ |
|
1471 subglyph->arg1 += (FT_Int16)deltas[i].x; |
|
1472 subglyph->arg2 += (FT_Int16)deltas[i].y; |
|
1473 } |
|
1474 } |
|
1475 |
|
1476 loader->pp1.x += deltas[i + 0].x; loader->pp1.y += deltas[i + 0].y; |
|
1477 loader->pp2.x += deltas[i + 1].x; loader->pp2.y += deltas[i + 1].y; |
|
1478 loader->pp3.x += deltas[i + 2].x; loader->pp3.y += deltas[i + 2].y; |
|
1479 loader->pp4.x += deltas[i + 3].x; loader->pp4.y += deltas[i + 3].y; |
|
1480 |
|
1481 FT_FREE( deltas ); |
|
1482 } |
|
1483 |
|
1484 #endif /* TT_CONFIG_OPTION_GX_VAR_SUPPORT */ |
|
1485 |
|
1486 if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 ) |
|
1487 { |
|
1488 loader->pp1.x = FT_MulFix( loader->pp1.x, x_scale ); |
|
1489 loader->pp2.x = FT_MulFix( loader->pp2.x, x_scale ); |
|
1490 loader->pp3.y = FT_MulFix( loader->pp3.y, y_scale ); |
|
1491 loader->pp4.y = FT_MulFix( loader->pp4.y, y_scale ); |
|
1492 } |
|
1493 |
|
1494 /* if the flag FT_LOAD_NO_RECURSE is set, we return the subglyph */ |
|
1495 /* `as is' in the glyph slot (the client application will be */ |
|
1496 /* responsible for interpreting these data)... */ |
|
1497 if ( loader->load_flags & FT_LOAD_NO_RECURSE ) |
|
1498 { |
|
1499 FT_GlyphLoader_Add( gloader ); |
|
1500 loader->glyph->format = FT_GLYPH_FORMAT_COMPOSITE; |
|
1501 |
|
1502 goto Exit; |
|
1503 } |
|
1504 |
|
1505 /*********************************************************************/ |
|
1506 /*********************************************************************/ |
|
1507 /*********************************************************************/ |
|
1508 |
|
1509 { |
|
1510 FT_UInt n, num_base_points; |
|
1511 FT_SubGlyph subglyph = 0; |
|
1512 |
|
1513 FT_UInt num_points = start_point; |
|
1514 FT_UInt num_subglyphs = gloader->current.num_subglyphs; |
|
1515 FT_UInt num_base_subgs = gloader->base.num_subglyphs; |
|
1516 |
|
1517 FT_Stream old_stream = loader->stream; |
|
1518 FT_Int old_byte_len = loader->byte_len; |
|
1519 |
|
1520 |
|
1521 FT_GlyphLoader_Add( gloader ); |
|
1522 |
|
1523 /* read each subglyph independently */ |
|
1524 for ( n = 0; n < num_subglyphs; n++ ) |
|
1525 { |
|
1526 FT_Vector pp[4]; |
|
1527 |
|
1528 |
|
1529 /* Each time we call load_truetype_glyph in this loop, the */ |
|
1530 /* value of `gloader.base.subglyphs' can change due to table */ |
|
1531 /* reallocations. We thus need to recompute the subglyph */ |
|
1532 /* pointer on each iteration. */ |
|
1533 subglyph = gloader->base.subglyphs + num_base_subgs + n; |
|
1534 |
|
1535 pp[0] = loader->pp1; |
|
1536 pp[1] = loader->pp2; |
|
1537 pp[2] = loader->pp3; |
|
1538 pp[3] = loader->pp4; |
|
1539 |
|
1540 num_base_points = gloader->base.outline.n_points; |
|
1541 |
|
1542 error = load_truetype_glyph( loader, subglyph->index, |
|
1543 recurse_count + 1, FALSE ); |
|
1544 if ( error ) |
|
1545 goto Exit; |
|
1546 |
|
1547 /* restore subglyph pointer */ |
|
1548 subglyph = gloader->base.subglyphs + num_base_subgs + n; |
|
1549 |
|
1550 if ( !( subglyph->flags & USE_MY_METRICS ) ) |
|
1551 { |
|
1552 loader->pp1 = pp[0]; |
|
1553 loader->pp2 = pp[1]; |
|
1554 loader->pp3 = pp[2]; |
|
1555 loader->pp4 = pp[3]; |
|
1556 } |
|
1557 |
|
1558 num_points = gloader->base.outline.n_points; |
|
1559 |
|
1560 if ( num_points == num_base_points ) |
|
1561 continue; |
|
1562 |
|
1563 /* gloader->base.outline consists of three parts: */ |
|
1564 /* 0 -(1)-> start_point -(2)-> num_base_points -(3)-> n_points. */ |
|
1565 /* */ |
|
1566 /* (1): exists from the beginning */ |
|
1567 /* (2): components that have been loaded so far */ |
|
1568 /* (3): the newly loaded component */ |
|
1569 TT_Process_Composite_Component( loader, subglyph, start_point, |
|
1570 num_base_points ); |
|
1571 } |
|
1572 |
|
1573 loader->stream = old_stream; |
|
1574 loader->byte_len = old_byte_len; |
|
1575 |
|
1576 /* process the glyph */ |
|
1577 loader->ins_pos = ins_pos; |
|
1578 if ( IS_HINTED( loader->load_flags ) && |
|
1579 |
|
1580 #ifdef TT_USE_BYTECODE_INTERPRETER |
|
1581 |
|
1582 subglyph->flags & WE_HAVE_INSTR && |
|
1583 |
|
1584 #endif |
|
1585 |
|
1586 num_points > start_point ) |
|
1587 TT_Process_Composite_Glyph( loader, start_point, start_contour ); |
|
1588 |
|
1589 } |
|
1590 } |
|
1591 else |
|
1592 { |
|
1593 /* invalid composite count (negative but not -1) */ |
|
1594 error = TT_Err_Invalid_Outline; |
|
1595 goto Exit; |
|
1596 } |
|
1597 |
|
1598 /***********************************************************************/ |
|
1599 /***********************************************************************/ |
|
1600 /***********************************************************************/ |
|
1601 |
|
1602 Exit: |
|
1603 |
|
1604 if ( opened_frame ) |
|
1605 face->forget_glyph_frame( loader ); |
|
1606 |
|
1607 #ifdef FT_CONFIG_OPTION_INCREMENTAL |
|
1608 |
|
1609 if ( glyph_data_loaded ) |
|
1610 face->root.internal->incremental_interface->funcs->free_glyph_data( |
|
1611 face->root.internal->incremental_interface->object, |
|
1612 &glyph_data ); |
|
1613 |
|
1614 #endif |
|
1615 |
|
1616 return error; |
|
1617 } |
|
1618 |
|
1619 |
|
1620 static FT_Error |
|
1621 compute_glyph_metrics( TT_Loader loader, |
|
1622 FT_UInt glyph_index ) |
|
1623 { |
|
1624 FT_BBox bbox; |
|
1625 TT_Face face = (TT_Face)loader->face; |
|
1626 FT_Fixed y_scale; |
|
1627 TT_GlyphSlot glyph = loader->glyph; |
|
1628 TT_Size size = (TT_Size)loader->size; |
|
1629 |
|
1630 |
|
1631 y_scale = 0x10000L; |
|
1632 if ( ( loader->load_flags & FT_LOAD_NO_SCALE ) == 0 ) |
|
1633 y_scale = size->root.metrics.y_scale; |
|
1634 |
|
1635 if ( glyph->format != FT_GLYPH_FORMAT_COMPOSITE ) |
|
1636 FT_Outline_Get_CBox( &glyph->outline, &bbox ); |
|
1637 else |
|
1638 bbox = loader->bbox; |
|
1639 |
|
1640 /* get the device-independent horizontal advance; it is scaled later */ |
|
1641 /* by the base layer. */ |
|
1642 glyph->linearHoriAdvance = loader->linear; |
|
1643 |
|
1644 glyph->metrics.horiBearingX = bbox.xMin; |
|
1645 glyph->metrics.horiBearingY = bbox.yMax; |
|
1646 glyph->metrics.horiAdvance = loader->pp2.x - loader->pp1.x; |
|
1647 |
|
1648 /* adjust advance width to the value contained in the hdmx table */ |
|
1649 if ( !face->postscript.isFixedPitch && |
|
1650 IS_HINTED( loader->load_flags ) ) |
|
1651 { |
|
1652 FT_Byte* widthp; |
|
1653 |
|
1654 |
|
1655 widthp = tt_face_get_device_metrics( face, |
|
1656 size->root.metrics.x_ppem, |
|
1657 glyph_index ); |
|
1658 |
|
1659 if ( widthp ) |
|
1660 glyph->metrics.horiAdvance = *widthp << 6; |
|
1661 } |
|
1662 |
|
1663 /* set glyph dimensions */ |
|
1664 glyph->metrics.width = bbox.xMax - bbox.xMin; |
|
1665 glyph->metrics.height = bbox.yMax - bbox.yMin; |
|
1666 |
|
1667 /* Now take care of vertical metrics. In the case where there is */ |
|
1668 /* no vertical information within the font (relatively common), */ |
|
1669 /* create some metrics manually */ |
|
1670 { |
|
1671 FT_Pos top; /* scaled vertical top side bearing */ |
|
1672 FT_Pos advance; /* scaled vertical advance height */ |
|
1673 |
|
1674 |
|
1675 /* Get the unscaled top bearing and advance height. */ |
|
1676 if ( face->vertical_info && |
|
1677 face->vertical.number_Of_VMetrics > 0 ) |
|
1678 { |
|
1679 top = (FT_Short)FT_DivFix( loader->pp3.y - bbox.yMax, |
|
1680 y_scale ); |
|
1681 |
|
1682 if ( loader->pp3.y <= loader->pp4.y ) |
|
1683 advance = 0; |
|
1684 else |
|
1685 advance = (FT_UShort)FT_DivFix( loader->pp3.y - loader->pp4.y, |
|
1686 y_scale ); |
|
1687 } |
|
1688 else |
|
1689 { |
|
1690 FT_Pos height; |
|
1691 |
|
1692 |
|
1693 /* XXX Compute top side bearing and advance height in */ |
|
1694 /* Get_VMetrics instead of here. */ |
|
1695 |
|
1696 /* NOTE: The OS/2 values are the only `portable' ones, */ |
|
1697 /* which is why we use them, if there is an OS/2 */ |
|
1698 /* table in the font. Otherwise, we use the */ |
|
1699 /* values defined in the horizontal header. */ |
|
1700 |
|
1701 height = (FT_Short)FT_DivFix( bbox.yMax - bbox.yMin, |
|
1702 y_scale ); |
|
1703 if ( face->os2.version != 0xFFFFU ) |
|
1704 advance = (FT_Pos)( face->os2.sTypoAscender - |
|
1705 face->os2.sTypoDescender ); |
|
1706 else |
|
1707 advance = (FT_Pos)( face->horizontal.Ascender - |
|
1708 face->horizontal.Descender ); |
|
1709 |
|
1710 top = ( advance - height ) / 2; |
|
1711 } |
|
1712 |
|
1713 #ifdef FT_CONFIG_OPTION_INCREMENTAL |
|
1714 { |
|
1715 FT_Incremental_InterfaceRec* incr; |
|
1716 FT_Incremental_MetricsRec metrics; |
|
1717 FT_Error error; |
|
1718 |
|
1719 |
|
1720 incr = face->root.internal->incremental_interface; |
|
1721 |
|
1722 /* If this is an incrementally loaded font see if there are */ |
|
1723 /* overriding metrics for this glyph. */ |
|
1724 if ( incr && incr->funcs->get_glyph_metrics ) |
|
1725 { |
|
1726 metrics.bearing_x = 0; |
|
1727 metrics.bearing_y = top; |
|
1728 metrics.advance = advance; |
|
1729 |
|
1730 error = incr->funcs->get_glyph_metrics( incr->object, |
|
1731 glyph_index, |
|
1732 TRUE, |
|
1733 &metrics ); |
|
1734 if ( error ) |
|
1735 return error; |
|
1736 |
|
1737 top = metrics.bearing_y; |
|
1738 advance = metrics.advance; |
|
1739 } |
|
1740 } |
|
1741 |
|
1742 /* GWW: Do vertical metrics get loaded incrementally too? */ |
|
1743 |
|
1744 #endif /* FT_CONFIG_OPTION_INCREMENTAL */ |
|
1745 |
|
1746 glyph->linearVertAdvance = advance; |
|
1747 |
|
1748 /* scale the metrics */ |
|
1749 if ( !( loader->load_flags & FT_LOAD_NO_SCALE ) ) |
|
1750 { |
|
1751 top = FT_MulFix( top, y_scale ); |
|
1752 advance = FT_MulFix( advance, y_scale ); |
|
1753 } |
|
1754 |
|
1755 /* XXX: for now, we have no better algorithm for the lsb, but it */ |
|
1756 /* should work fine. */ |
|
1757 /* */ |
|
1758 glyph->metrics.vertBearingX = glyph->metrics.horiBearingX - |
|
1759 glyph->metrics.horiAdvance / 2; |
|
1760 glyph->metrics.vertBearingY = top; |
|
1761 glyph->metrics.vertAdvance = advance; |
|
1762 } |
|
1763 |
|
1764 return 0; |
|
1765 } |
|
1766 |
|
1767 |
|
1768 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS |
|
1769 |
|
1770 static FT_Error |
|
1771 load_sbit_image( TT_Size size, |
|
1772 TT_GlyphSlot glyph, |
|
1773 FT_UInt glyph_index, |
|
1774 FT_Int32 load_flags ) |
|
1775 { |
|
1776 TT_Face face; |
|
1777 SFNT_Service sfnt; |
|
1778 FT_Stream stream; |
|
1779 FT_Error error; |
|
1780 TT_SBit_MetricsRec metrics; |
|
1781 |
|
1782 |
|
1783 face = (TT_Face)glyph->face; |
|
1784 sfnt = (SFNT_Service)face->sfnt; |
|
1785 stream = face->root.stream; |
|
1786 |
|
1787 error = sfnt->load_sbit_image( face, |
|
1788 size->strike_index, |
|
1789 glyph_index, |
|
1790 (FT_Int)load_flags, |
|
1791 stream, |
|
1792 &glyph->bitmap, |
|
1793 &metrics ); |
|
1794 if ( !error ) |
|
1795 { |
|
1796 glyph->outline.n_points = 0; |
|
1797 glyph->outline.n_contours = 0; |
|
1798 |
|
1799 glyph->metrics.width = (FT_Pos)metrics.width << 6; |
|
1800 glyph->metrics.height = (FT_Pos)metrics.height << 6; |
|
1801 |
|
1802 glyph->metrics.horiBearingX = (FT_Pos)metrics.horiBearingX << 6; |
|
1803 glyph->metrics.horiBearingY = (FT_Pos)metrics.horiBearingY << 6; |
|
1804 glyph->metrics.horiAdvance = (FT_Pos)metrics.horiAdvance << 6; |
|
1805 |
|
1806 glyph->metrics.vertBearingX = (FT_Pos)metrics.vertBearingX << 6; |
|
1807 glyph->metrics.vertBearingY = (FT_Pos)metrics.vertBearingY << 6; |
|
1808 glyph->metrics.vertAdvance = (FT_Pos)metrics.vertAdvance << 6; |
|
1809 |
|
1810 glyph->format = FT_GLYPH_FORMAT_BITMAP; |
|
1811 |
|
1812 if ( load_flags & FT_LOAD_VERTICAL_LAYOUT ) |
|
1813 { |
|
1814 glyph->bitmap_left = metrics.vertBearingX; |
|
1815 glyph->bitmap_top = metrics.vertBearingY; |
|
1816 } |
|
1817 else |
|
1818 { |
|
1819 glyph->bitmap_left = metrics.horiBearingX; |
|
1820 glyph->bitmap_top = metrics.horiBearingY; |
|
1821 } |
|
1822 } |
|
1823 |
|
1824 return error; |
|
1825 } |
|
1826 |
|
1827 #endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */ |
|
1828 |
|
1829 |
|
1830 static FT_Error |
|
1831 tt_loader_init( TT_Loader loader, |
|
1832 TT_Size size, |
|
1833 TT_GlyphSlot glyph, |
|
1834 FT_Int32 load_flags, |
|
1835 FT_Bool glyf_table_only ) |
|
1836 { |
|
1837 TT_Face face; |
|
1838 FT_Stream stream; |
|
1839 FT_Bool pedantic = FT_BOOL( load_flags & FT_LOAD_PEDANTIC ); |
|
1840 |
|
1841 |
|
1842 face = (TT_Face)glyph->face; |
|
1843 stream = face->root.stream; |
|
1844 |
|
1845 FT_MEM_ZERO( loader, sizeof ( TT_LoaderRec ) ); |
|
1846 |
|
1847 #ifdef TT_USE_BYTECODE_INTERPRETER |
|
1848 |
|
1849 /* load execution context */ |
|
1850 if ( IS_HINTED( load_flags ) && !glyf_table_only ) |
|
1851 { |
|
1852 TT_ExecContext exec; |
|
1853 FT_Bool grayscale; |
|
1854 |
|
1855 |
|
1856 if ( !size->cvt_ready ) |
|
1857 { |
|
1858 FT_Error error = tt_size_ready_bytecode( size, pedantic ); |
|
1859 |
|
1860 |
|
1861 if ( error ) |
|
1862 return error; |
|
1863 } |
|
1864 |
|
1865 /* query new execution context */ |
|
1866 exec = size->debug ? size->context |
|
1867 : ( (TT_Driver)FT_FACE_DRIVER( face ) )->context; |
|
1868 if ( !exec ) |
|
1869 return TT_Err_Could_Not_Find_Context; |
|
1870 |
|
1871 grayscale = |
|
1872 FT_BOOL( FT_LOAD_TARGET_MODE( load_flags ) != FT_RENDER_MODE_MONO ); |
|
1873 |
|
1874 TT_Load_Context( exec, face, size ); |
|
1875 |
|
1876 /* a change from mono to grayscale rendering (and vice versa) */ |
|
1877 /* requires a re-execution of the CVT program */ |
|
1878 if ( grayscale != exec->grayscale ) |
|
1879 { |
|
1880 FT_UInt i; |
|
1881 |
|
1882 |
|
1883 FT_TRACE4(( "tt_loader_init: grayscale change," |
|
1884 " re-executing `prep' table\n" )); |
|
1885 |
|
1886 exec->grayscale = grayscale; |
|
1887 |
|
1888 for ( i = 0; i < size->cvt_size; i++ ) |
|
1889 size->cvt[i] = FT_MulFix( face->cvt[i], size->ttmetrics.scale ); |
|
1890 tt_size_run_prep( size, pedantic ); |
|
1891 } |
|
1892 |
|
1893 /* see whether the cvt program has disabled hinting */ |
|
1894 if ( exec->GS.instruct_control & 1 ) |
|
1895 load_flags |= FT_LOAD_NO_HINTING; |
|
1896 |
|
1897 /* load default graphics state -- if needed */ |
|
1898 if ( exec->GS.instruct_control & 2 ) |
|
1899 exec->GS = tt_default_graphics_state; |
|
1900 |
|
1901 exec->pedantic_hinting = FT_BOOL( load_flags & FT_LOAD_PEDANTIC ); |
|
1902 loader->exec = exec; |
|
1903 loader->instructions = exec->glyphIns; |
|
1904 } |
|
1905 |
|
1906 #endif /* TT_USE_BYTECODE_INTERPRETER */ |
|
1907 |
|
1908 /* seek to the beginning of the glyph table -- for Type 42 fonts */ |
|
1909 /* the table might be accessed from a Postscript stream or something */ |
|
1910 /* else... */ |
|
1911 |
|
1912 #ifdef FT_CONFIG_OPTION_INCREMENTAL |
|
1913 |
|
1914 if ( face->root.internal->incremental_interface ) |
|
1915 loader->glyf_offset = 0; |
|
1916 else |
|
1917 |
|
1918 #endif |
|
1919 |
|
1920 { |
|
1921 FT_Error error = face->goto_table( face, TTAG_glyf, stream, 0 ); |
|
1922 |
|
1923 |
|
1924 if ( error == TT_Err_Table_Missing ) |
|
1925 loader->glyf_offset = 0; |
|
1926 else if ( error ) |
|
1927 { |
|
1928 FT_ERROR(( "tt_loader_init: could not access glyph table\n" )); |
|
1929 return error; |
|
1930 } |
|
1931 else |
|
1932 loader->glyf_offset = FT_STREAM_POS(); |
|
1933 } |
|
1934 |
|
1935 /* get face's glyph loader */ |
|
1936 if ( !glyf_table_only ) |
|
1937 { |
|
1938 FT_GlyphLoader gloader = glyph->internal->loader; |
|
1939 |
|
1940 |
|
1941 FT_GlyphLoader_Rewind( gloader ); |
|
1942 loader->gloader = gloader; |
|
1943 } |
|
1944 |
|
1945 loader->load_flags = load_flags; |
|
1946 |
|
1947 loader->face = (FT_Face)face; |
|
1948 loader->size = (FT_Size)size; |
|
1949 loader->glyph = (FT_GlyphSlot)glyph; |
|
1950 loader->stream = stream; |
|
1951 |
|
1952 return TT_Err_Ok; |
|
1953 } |
|
1954 |
|
1955 |
|
1956 /*************************************************************************/ |
|
1957 /* */ |
|
1958 /* <Function> */ |
|
1959 /* TT_Load_Glyph */ |
|
1960 /* */ |
|
1961 /* <Description> */ |
|
1962 /* A function used to load a single glyph within a given glyph slot, */ |
|
1963 /* for a given size. */ |
|
1964 /* */ |
|
1965 /* <Input> */ |
|
1966 /* glyph :: A handle to a target slot object where the glyph */ |
|
1967 /* will be loaded. */ |
|
1968 /* */ |
|
1969 /* size :: A handle to the source face size at which the glyph */ |
|
1970 /* must be scaled/loaded. */ |
|
1971 /* */ |
|
1972 /* glyph_index :: The index of the glyph in the font file. */ |
|
1973 /* */ |
|
1974 /* load_flags :: A flag indicating what to load for this glyph. The */ |
|
1975 /* FT_LOAD_XXX constants can be used to control the */ |
|
1976 /* glyph loading process (e.g., whether the outline */ |
|
1977 /* should be scaled, whether to load bitmaps or not, */ |
|
1978 /* whether to hint the outline, etc). */ |
|
1979 /* */ |
|
1980 /* <Return> */ |
|
1981 /* FreeType error code. 0 means success. */ |
|
1982 /* */ |
|
1983 FT_LOCAL_DEF( FT_Error ) |
|
1984 TT_Load_Glyph( TT_Size size, |
|
1985 TT_GlyphSlot glyph, |
|
1986 FT_UInt glyph_index, |
|
1987 FT_Int32 load_flags ) |
|
1988 { |
|
1989 TT_Face face; |
|
1990 FT_Error error; |
|
1991 TT_LoaderRec loader; |
|
1992 |
|
1993 |
|
1994 face = (TT_Face)glyph->face; |
|
1995 error = TT_Err_Ok; |
|
1996 |
|
1997 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS |
|
1998 |
|
1999 /* try to load embedded bitmap if any */ |
|
2000 /* */ |
|
2001 /* XXX: The convention should be emphasized in */ |
|
2002 /* the documents because it can be confusing. */ |
|
2003 if ( size->strike_index != 0xFFFFFFFFUL && |
|
2004 ( load_flags & FT_LOAD_NO_BITMAP ) == 0 ) |
|
2005 { |
|
2006 error = load_sbit_image( size, glyph, glyph_index, load_flags ); |
|
2007 if ( !error ) |
|
2008 { |
|
2009 FT_Face root = &face->root; |
|
2010 |
|
2011 |
|
2012 if ( FT_IS_SCALABLE( root ) ) |
|
2013 { |
|
2014 /* for the bbox we need the header only */ |
|
2015 (void)tt_loader_init( &loader, size, glyph, load_flags, TRUE ); |
|
2016 (void)load_truetype_glyph( &loader, glyph_index, 0, TRUE ); |
|
2017 glyph->linearHoriAdvance = loader.linear; |
|
2018 glyph->linearVertAdvance = loader.top_bearing + loader.bbox.yMax - |
|
2019 loader.vadvance; |
|
2020 } |
|
2021 |
|
2022 return TT_Err_Ok; |
|
2023 } |
|
2024 } |
|
2025 |
|
2026 #endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */ |
|
2027 |
|
2028 /* if FT_LOAD_NO_SCALE is not set, `ttmetrics' must be valid */ |
|
2029 if ( !( load_flags & FT_LOAD_NO_SCALE ) && !size->ttmetrics.valid ) |
|
2030 return TT_Err_Invalid_Size_Handle; |
|
2031 |
|
2032 if ( load_flags & FT_LOAD_SBITS_ONLY ) |
|
2033 return TT_Err_Invalid_Argument; |
|
2034 |
|
2035 error = tt_loader_init( &loader, size, glyph, load_flags, FALSE ); |
|
2036 if ( error ) |
|
2037 return error; |
|
2038 |
|
2039 glyph->format = FT_GLYPH_FORMAT_OUTLINE; |
|
2040 glyph->num_subglyphs = 0; |
|
2041 glyph->outline.flags = 0; |
|
2042 |
|
2043 /* main loading loop */ |
|
2044 error = load_truetype_glyph( &loader, glyph_index, 0, FALSE ); |
|
2045 if ( !error ) |
|
2046 { |
|
2047 if ( glyph->format == FT_GLYPH_FORMAT_COMPOSITE ) |
|
2048 { |
|
2049 glyph->num_subglyphs = loader.gloader->base.num_subglyphs; |
|
2050 glyph->subglyphs = loader.gloader->base.subglyphs; |
|
2051 } |
|
2052 else |
|
2053 { |
|
2054 glyph->outline = loader.gloader->base.outline; |
|
2055 glyph->outline.flags &= ~FT_OUTLINE_SINGLE_PASS; |
|
2056 |
|
2057 /* Translate array so that (0,0) is the glyph's origin. Note */ |
|
2058 /* that this behaviour is independent on the value of bit 1 of */ |
|
2059 /* the `flags' field in the `head' table -- at least major */ |
|
2060 /* applications like Acroread indicate that. */ |
|
2061 if ( loader.pp1.x ) |
|
2062 FT_Outline_Translate( &glyph->outline, -loader.pp1.x, 0 ); |
|
2063 } |
|
2064 |
|
2065 #ifdef TT_USE_BYTECODE_INTERPRETER |
|
2066 |
|
2067 if ( IS_HINTED( load_flags ) ) |
|
2068 { |
|
2069 if ( loader.exec->GS.scan_control ) |
|
2070 { |
|
2071 /* convert scan conversion mode to FT_OUTLINE_XXX flags */ |
|
2072 switch ( loader.exec->GS.scan_type ) |
|
2073 { |
|
2074 case 0: /* simple drop-outs including stubs */ |
|
2075 glyph->outline.flags |= FT_OUTLINE_INCLUDE_STUBS; |
|
2076 break; |
|
2077 case 1: /* simple drop-outs excluding stubs */ |
|
2078 /* nothing; it's the default rendering mode */ |
|
2079 break; |
|
2080 case 4: /* smart drop-outs including stubs */ |
|
2081 glyph->outline.flags |= FT_OUTLINE_SMART_DROPOUTS | |
|
2082 FT_OUTLINE_INCLUDE_STUBS; |
|
2083 break; |
|
2084 case 5: /* smart drop-outs excluding stubs */ |
|
2085 glyph->outline.flags |= FT_OUTLINE_SMART_DROPOUTS; |
|
2086 break; |
|
2087 |
|
2088 default: /* no drop-out control */ |
|
2089 glyph->outline.flags |= FT_OUTLINE_IGNORE_DROPOUTS; |
|
2090 break; |
|
2091 } |
|
2092 } |
|
2093 else |
|
2094 glyph->outline.flags |= FT_OUTLINE_IGNORE_DROPOUTS; |
|
2095 } |
|
2096 |
|
2097 #endif /* TT_USE_BYTECODE_INTERPRETER */ |
|
2098 |
|
2099 compute_glyph_metrics( &loader, glyph_index ); |
|
2100 } |
|
2101 |
|
2102 /* Set the `high precision' bit flag. */ |
|
2103 /* This is _critical_ to get correct output for monochrome */ |
|
2104 /* TrueType glyphs at all sizes using the bytecode interpreter. */ |
|
2105 /* */ |
|
2106 if ( !( load_flags & FT_LOAD_NO_SCALE ) && |
|
2107 size->root.metrics.y_ppem < 24 ) |
|
2108 glyph->outline.flags |= FT_OUTLINE_HIGH_PRECISION; |
|
2109 |
|
2110 return error; |
|
2111 } |
|
2112 |
|
2113 |
|
2114 /* END */ |