zenilib: zenilib/jni/external/freetype2/src/cff/cffgload.c Source File

zenilib 0.5.3.0

- Main Page
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
cffgload.c
Go to the documentation of this file.
1 /***************************************************************************/
2 /* */
3 /* cffgload.c */
4 /* */
5 /* OpenType Glyph Loader (body). */
6 /* */
7 /* Copyright 1996-2012 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 FT_INTERNAL_DEBUG_H
21 #include FT_INTERNAL_STREAM_H
22 #include FT_INTERNAL_SFNT_H
23 #include FT_OUTLINE_H
24
25 #include "cffobjs.h"
26 #include "cffload.h"
27 #include "cffgload.h"
28
29 #include "cfferrs.h"
30
31
32 /*************************************************************************/
33 /* */
34 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
35 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
36 /* messages during execution. */
37 /* */
38 #undef FT_COMPONENT
39 #define FT_COMPONENT trace_cffgload
40
41
42 typedef enum CFF_Operator_
43 {
44 cff_op_unknown = 0,
45
46 cff_op_rmoveto,
47 cff_op_hmoveto,
48 cff_op_vmoveto,
49
50 cff_op_rlineto,
51 cff_op_hlineto,
52 cff_op_vlineto,
53
54 cff_op_rrcurveto,
55 cff_op_hhcurveto,
56 cff_op_hvcurveto,
57 cff_op_rcurveline,
58 cff_op_rlinecurve,
59 cff_op_vhcurveto,
60 cff_op_vvcurveto,
61
62 cff_op_flex,
63 cff_op_hflex,
64 cff_op_hflex1,
65 cff_op_flex1,
66
67 cff_op_endchar,
68
69 cff_op_hstem,
70 cff_op_vstem,
71 cff_op_hstemhm,
72 cff_op_vstemhm,
73
74 cff_op_hintmask,
75 cff_op_cntrmask,
76 cff_op_dotsection, /* deprecated, acts as no-op */
77
78 cff_op_abs,
79 cff_op_add,
80 cff_op_sub,
81 cff_op_div,
82 cff_op_neg,
83 cff_op_random,
84 cff_op_mul,
85 cff_op_sqrt,
86
87 cff_op_blend,
88
89 cff_op_drop,
90 cff_op_exch,
91 cff_op_index,
92 cff_op_roll,
93 cff_op_dup,
94
95 cff_op_put,
96 cff_op_get,
97 cff_op_store,
98 cff_op_load,
99
100 cff_op_and,
101 cff_op_or,
102 cff_op_not,
103 cff_op_eq,
104 cff_op_ifelse,
105
106 cff_op_callsubr,
107 cff_op_callgsubr,
108 cff_op_return,
109
110 /* Type 1 opcodes: invalid but seen in real life */
111 cff_op_hsbw,
112 cff_op_closepath,
113 cff_op_callothersubr,
114 cff_op_pop,
115 cff_op_seac,
116 cff_op_sbw,
117 cff_op_setcurrentpoint,
118
119 /* do not remove */
120 cff_op_max
121
122 } CFF_Operator;
123
124
125 #define CFF_COUNT_CHECK_WIDTH 0x80
126 #define CFF_COUNT_EXACT 0x40
127 #define CFF_COUNT_CLEAR_STACK 0x20
128
129 /* count values which have the `CFF_COUNT_CHECK_WIDTH' flag set are */
130 /* used for checking the width and requested numbers of arguments */
131 /* only; they are set to zero afterwards */
132
133 /* the other two flags are informative only and unused currently */
134
135 static const FT_Byte cff_argument_counts[] =
136 {
137 0, /* unknown */
138
139 2 | CFF_COUNT_CHECK_WIDTH | CFF_COUNT_EXACT, /* rmoveto */
140 1 | CFF_COUNT_CHECK_WIDTH | CFF_COUNT_EXACT,
141 1 | CFF_COUNT_CHECK_WIDTH | CFF_COUNT_EXACT,
142
143 0 | CFF_COUNT_CLEAR_STACK, /* rlineto */
144 0 | CFF_COUNT_CLEAR_STACK,
145 0 | CFF_COUNT_CLEAR_STACK,
146
147 0 | CFF_COUNT_CLEAR_STACK, /* rrcurveto */
148 0 | CFF_COUNT_CLEAR_STACK,
149 0 | CFF_COUNT_CLEAR_STACK,
150 0 | CFF_COUNT_CLEAR_STACK,
151 0 | CFF_COUNT_CLEAR_STACK,
152 0 | CFF_COUNT_CLEAR_STACK,
153 0 | CFF_COUNT_CLEAR_STACK,
154
155 13, /* flex */
156 7,
157 9,
158 11,
159
160 0 | CFF_COUNT_CHECK_WIDTH, /* endchar */
161
162 2 | CFF_COUNT_CHECK_WIDTH, /* hstem */
163 2 | CFF_COUNT_CHECK_WIDTH,
164 2 | CFF_COUNT_CHECK_WIDTH,
165 2 | CFF_COUNT_CHECK_WIDTH,
166
167 0 | CFF_COUNT_CHECK_WIDTH, /* hintmask */
168 0 | CFF_COUNT_CHECK_WIDTH, /* cntrmask */
169 0, /* dotsection */
170
171 1, /* abs */
172 2,
173 2,
174 2,
175 1,
176 0,
177 2,
178 1,
179
180 1, /* blend */
181
182 1, /* drop */
183 2,
184 1,
185 2,
186 1,
187
188 2, /* put */
189 1,
190 4,
191 3,
192
193 2, /* and */
194 2,
195 1,
196 2,
197 4,
198
199 1, /* callsubr */
200 1,
201 0,
202
203 2, /* hsbw */
204 0,
205 0,
206 0,
207 5, /* seac */
208 4, /* sbw */
209 2 /* setcurrentpoint */
210 };
211
212
213 /*************************************************************************/
214 /*************************************************************************/
215 /*************************************************************************/
216 /********** *********/
217 /********** *********/
218 /********** GENERIC CHARSTRING PARSING *********/
219 /********** *********/
220 /********** *********/
221 /*************************************************************************/
222 /*************************************************************************/
223 /*************************************************************************/
224
225
226 /*************************************************************************/
227 /* */
228 /* <Function> */
229 /* cff_builder_init */
230 /* */
231 /* <Description> */
232 /* Initializes a given glyph builder. */
233 /* */
234 /* <InOut> */
235 /* builder :: A pointer to the glyph builder to initialize. */
236 /* */
237 /* <Input> */
238 /* face :: The current face object. */
239 /* */
240 /* size :: The current size object. */
241 /* */
242 /* glyph :: The current glyph object. */
243 /* */
244 /* hinting :: Whether hinting is active. */
245 /* */
246 static void
247 cff_builder_init( CFF_Builder* builder,
248 TT_Face face,
249 CFF_Size size,
250 CFF_GlyphSlot glyph,
251 FT_Bool hinting )
252 {
253 builder->path_begun = 0;
254 builder->load_points = 1;
255
256 builder->face = face;
257 builder->glyph = glyph;
258 builder->memory = face->root.memory;
259
260 if ( glyph )
261 {
262 FT_GlyphLoader loader = glyph->root.internal->loader;
263
264
265 builder->loader = loader;
266 builder->base = &loader->base.outline;
267 builder->current = &loader->current.outline;
268 FT_GlyphLoader_Rewind( loader );
269
270 builder->hints_globals = 0;
271 builder->hints_funcs = 0;
272
273 if ( hinting && size )
274 {
275 CFF_Internal internal = (CFF_Internal)size->root.internal;
276
277
278 builder->hints_globals = (void *)internal->topfont;
279 builder->hints_funcs = glyph->root.internal->glyph_hints;
280 }
281 }
282
283 builder->pos_x = 0;
284 builder->pos_y = 0;
285
286 builder->left_bearing.x = 0;
287 builder->left_bearing.y = 0;
288 builder->advance.x = 0;
289 builder->advance.y = 0;
290 }
291
292
293 /*************************************************************************/
294 /* */
295 /* <Function> */
296 /* cff_builder_done */
297 /* */
298 /* <Description> */
299 /* Finalizes a given glyph builder. Its contents can still be used */
300 /* after the call, but the function saves important information */
301 /* within the corresponding glyph slot. */
302 /* */
303 /* <Input> */
304 /* builder :: A pointer to the glyph builder to finalize. */
305 /* */
306 static void
307 cff_builder_done( CFF_Builder* builder )
308 {
309 CFF_GlyphSlot glyph = builder->glyph;
310
311
312 if ( glyph )
313 glyph->root.outline = *builder->base;
314 }
315
316
317 /*************************************************************************/
318 /* */
319 /* <Function> */
320 /* cff_compute_bias */
321 /* */
322 /* <Description> */
323 /* Computes the bias value in dependence of the number of glyph */
324 /* subroutines. */
325 /* */
326 /* <Input> */
327 /* in_charstring_type :: The `CharstringType' value of the top DICT */
328 /* dictionary. */
329 /* */
330 /* num_subrs :: The number of glyph subroutines. */
331 /* */
332 /* <Return> */
333 /* The bias value. */
334 static FT_Int
335 cff_compute_bias( FT_Int in_charstring_type,
336 FT_UInt num_subrs )
337 {
338 FT_Int result;
339
340
341 if ( in_charstring_type == 1 )
342 result = 0;
343 else if ( num_subrs < 1240 )
344 result = 107;
345 else if ( num_subrs < 33900U )
346 result = 1131;
347 else
348 result = 32768U;
349
350 return result;
351 }
352
353
354 /*************************************************************************/
355 /* */
356 /* <Function> */
357 /* cff_decoder_init */
358 /* */
359 /* <Description> */
360 /* Initializes a given glyph decoder. */
361 /* */
362 /* <InOut> */
363 /* decoder :: A pointer to the glyph builder to initialize. */
364 /* */
365 /* <Input> */
366 /* face :: The current face object. */
367 /* */
368 /* size :: The current size object. */
369 /* */
370 /* slot :: The current glyph object. */
371 /* */
372 /* hinting :: Whether hinting is active. */
373 /* */
374 /* hint_mode :: The hinting mode. */
375 /* */
376 FT_LOCAL_DEF( void )
377 cff_decoder_init( CFF_Decoder* decoder,
378 TT_Face face,
379 CFF_Size size,
380 CFF_GlyphSlot slot,
381 FT_Bool hinting,
382 FT_Render_Mode hint_mode )
383 {
384 CFF_Font cff = (CFF_Font)face->extra.data;
385
386
387 /* clear everything */
388 FT_MEM_ZERO( decoder, sizeof ( *decoder ) );
389
390 /* initialize builder */
391 cff_builder_init( &decoder->builder, face, size, slot, hinting );
392
393 /* initialize Type2 decoder */
394 decoder->cff = cff;
395 decoder->num_globals = cff->global_subrs_index.count;
396 decoder->globals = cff->global_subrs;
397 decoder->globals_bias = cff_compute_bias(
398 cff->top_font.font_dict.charstring_type,
399 decoder->num_globals );
400
401 decoder->hint_mode = hint_mode;
402 }
403
404
405 /* this function is used to select the subfont */
406 /* and the locals subrs array */
407 FT_LOCAL_DEF( FT_Error )
408 cff_decoder_prepare( CFF_Decoder* decoder,
409 CFF_Size size,
410 FT_UInt glyph_index )
411 {
412 CFF_Builder *builder = &decoder->builder;
413 CFF_Font cff = (CFF_Font)builder->face->extra.data;
414 CFF_SubFont sub = &cff->top_font;
415 FT_Error error = CFF_Err_Ok;
416
417
418 /* manage CID fonts */
419 if ( cff->num_subfonts )
420 {
421 FT_Byte fd_index = cff_fd_select_get( &cff->fd_select, glyph_index );
422
423
424 if ( fd_index >= cff->num_subfonts )
425 {
426 FT_TRACE4(( "cff_decoder_prepare: invalid CID subfont index\n" ));
427 error = CFF_Err_Invalid_File_Format;
428 goto Exit;
429 }
430
431 FT_TRACE3(( "glyph index %d (subfont %d):\n", glyph_index, fd_index ));
432
433 sub = cff->subfonts[fd_index];
434
435 if ( builder->hints_funcs && size )
436 {
437 CFF_Internal internal = (CFF_Internal)size->root.internal;
438
439
440 /* for CFFs without subfonts, this value has already been set */
441 builder->hints_globals = (void *)internal->subfonts[fd_index];
442 }
443 }
444 #ifdef FT_DEBUG_LEVEL_TRACE
445 else
446 FT_TRACE3(( "glyph index %d:\n", glyph_index ));
447 #endif
448
449 decoder->num_locals = sub->local_subrs_index.count;
450 decoder->locals = sub->local_subrs;
451 decoder->locals_bias = cff_compute_bias(
452 decoder->cff->top_font.font_dict.charstring_type,
453 decoder->num_locals );
454
455 decoder->glyph_width = sub->private_dict.default_width;
456 decoder->nominal_width = sub->private_dict.nominal_width;
457
458 Exit:
459 return error;
460 }
461
462
463 /* check that there is enough space for `count' more points */
464 static FT_Error
465 check_points( CFF_Builder* builder,
466 FT_Int count )
467 {
468 return FT_GLYPHLOADER_CHECK_POINTS( builder->loader, count, 0 );
469 }
470
471
472 /* add a new point, do not check space */
473 static void
474 cff_builder_add_point( CFF_Builder* builder,
475 FT_Pos x,
476 FT_Pos y,
477 FT_Byte flag )
478 {
479 FT_Outline* outline = builder->current;
480
481
482 if ( builder->load_points )
483 {
484 FT_Vector* point = outline->points + outline->n_points;
485 FT_Byte* control = (FT_Byte*)outline->tags + outline->n_points;
486
487
488 point->x = x >> 16;
489 point->y = y >> 16;
490 *control = (FT_Byte)( flag ? FT_CURVE_TAG_ON : FT_CURVE_TAG_CUBIC );
491 }
492
493 outline->n_points++;
494 }
495
496
497 /* check space for a new on-curve point, then add it */
498 static FT_Error
499 cff_builder_add_point1( CFF_Builder* builder,
500 FT_Pos x,
501 FT_Pos y )
502 {
503 FT_Error error;
504
505
506 error = check_points( builder, 1 );
507 if ( !error )
508 cff_builder_add_point( builder, x, y, 1 );
509
510 return error;
511 }
512
513
514 /* check space for a new contour, then add it */
515 static FT_Error
516 cff_builder_add_contour( CFF_Builder* builder )
517 {
518 FT_Outline* outline = builder->current;
519 FT_Error error;
520
521
522 if ( !builder->load_points )
523 {
524 outline->n_contours++;
525 return CFF_Err_Ok;
526 }
527
528 error = FT_GLYPHLOADER_CHECK_POINTS( builder->loader, 0, 1 );
529 if ( !error )
530 {
531 if ( outline->n_contours > 0 )
532 outline->contours[outline->n_contours - 1] =
533 (short)( outline->n_points - 1 );
534
535 outline->n_contours++;
536 }
537
538 return error;
539 }
540
541
542 /* if a path was begun, add its first on-curve point */
543 static FT_Error
544 cff_builder_start_point( CFF_Builder* builder,
545 FT_Pos x,
546 FT_Pos y )
547 {
548 FT_Error error = CFF_Err_Ok;
549
550
551 /* test whether we are building a new contour */
552 if ( !builder->path_begun )
553 {
554 builder->path_begun = 1;
555 error = cff_builder_add_contour( builder );
556 if ( !error )
557 error = cff_builder_add_point1( builder, x, y );
558 }
559
560 return error;
561 }
562
563
564 /* close the current contour */
565 static void
566 cff_builder_close_contour( CFF_Builder* builder )
567 {
568 FT_Outline* outline = builder->current;
569 FT_Int first;
570
571
572 if ( !outline )
573 return;
574
575 first = outline->n_contours <= 1
576 ? 0 : outline->contours[outline->n_contours - 2] + 1;
577
578 /* We must not include the last point in the path if it */
579 /* is located on the first point. */
580 if ( outline->n_points > 1 )
581 {
582 FT_Vector* p1 = outline->points + first;
583 FT_Vector* p2 = outline->points + outline->n_points - 1;
584 FT_Byte* control = (FT_Byte*)outline->tags + outline->n_points - 1;
585
586
587 /* `delete' last point only if it coincides with the first */
588 /* point and if it is not a control point (which can happen). */
589 if ( p1->x == p2->x && p1->y == p2->y )
590 if ( *control == FT_CURVE_TAG_ON )
591 outline->n_points--;
592 }
593
594 if ( outline->n_contours > 0 )
595 {
596 /* Don't add contours only consisting of one point, i.e., */
597 /* check whether begin point and last point are the same. */
598 if ( first == outline->n_points - 1 )
599 {
600 outline->n_contours--;
601 outline->n_points--;
602 }
603 else
604 outline->contours[outline->n_contours - 1] =
605 (short)( outline->n_points - 1 );
606 }
607 }
608
609
610 static FT_Int
611 cff_lookup_glyph_by_stdcharcode( CFF_Font cff,
612 FT_Int charcode )
613 {
614 FT_UInt n;
615 FT_UShort glyph_sid;
616
617
618 /* CID-keyed fonts don't have glyph names */
619 if ( !cff->charset.sids )
620 return -1;
621
622 /* check range of standard char code */
623 if ( charcode < 0 || charcode > 255 )
624 return -1;
625
626 /* Get code to SID mapping from `cff_standard_encoding'. */
627 glyph_sid = cff_get_standard_encoding( (FT_UInt)charcode );
628
629 for ( n = 0; n < cff->num_glyphs; n++ )
630 {
631 if ( cff->charset.sids[n] == glyph_sid )
632 return n;
633 }
634
635 return -1;
636 }
637
638
639 static FT_Error
640 cff_get_glyph_data( TT_Face face,
641 FT_UInt glyph_index,
642 FT_Byte** pointer,
643 FT_ULong* length )
644 {
645 #ifdef FT_CONFIG_OPTION_INCREMENTAL
646 /* For incremental fonts get the character data using the */
647 /* callback function. */
648 if ( face->root.internal->incremental_interface )
649 {
650 FT_Data data;
651 FT_Error error =
652 face->root.internal->incremental_interface->funcs->get_glyph_data(
653 face->root.internal->incremental_interface->object,
654 glyph_index, &data );
655
656
657 *pointer = (FT_Byte*)data.pointer;
658 *length = data.length;
659
660 return error;
661 }
662 else
663 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
664
665 {
666 CFF_Font cff = (CFF_Font)(face->extra.data);
667
668
669 return cff_index_access_element( &cff->charstrings_index, glyph_index,
670 pointer, length );
671 }
672 }
673
674
675 static void
676 cff_free_glyph_data( TT_Face face,
677 FT_Byte** pointer,
678 FT_ULong length )
679 {
680 #ifndef FT_CONFIG_OPTION_INCREMENTAL
681 FT_UNUSED( length );
682 #endif
683
684 #ifdef FT_CONFIG_OPTION_INCREMENTAL
685 /* For incremental fonts get the character data using the */
686 /* callback function. */
687 if ( face->root.internal->incremental_interface )
688 {
689 FT_Data data;
690
691
692 data.pointer = *pointer;
693 data.length = length;
694
695 face->root.internal->incremental_interface->funcs->free_glyph_data(
696 face->root.internal->incremental_interface->object, &data );
697 }
698 else
699 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
700
701 {
702 CFF_Font cff = (CFF_Font)(face->extra.data);
703
704
705 cff_index_forget_element( &cff->charstrings_index, pointer );
706 }
707 }
708
709
710 static FT_Error
711 cff_operator_seac( CFF_Decoder* decoder,
712 FT_Pos asb,
713 FT_Pos adx,
714 FT_Pos ady,
715 FT_Int bchar,
716 FT_Int achar )
717 {
718 FT_Error error;
719 CFF_Builder* builder = &decoder->builder;
720 FT_Int bchar_index, achar_index;
721 TT_Face face = decoder->builder.face;
722 FT_Vector left_bearing, advance;
723 FT_Byte* charstring;
724 FT_ULong charstring_len;
725 FT_Pos glyph_width;
726
727
728 if ( decoder->seac )
729 {
730 FT_ERROR(( "cff_operator_seac: invalid nested seac\n" ));
731 return CFF_Err_Syntax_Error;
732 }
733
734 adx += decoder->builder.left_bearing.x;
735 ady += decoder->builder.left_bearing.y;
736
737 #ifdef FT_CONFIG_OPTION_INCREMENTAL
738 /* Incremental fonts don't necessarily have valid charsets. */
739 /* They use the character code, not the glyph index, in this case. */
740 if ( face->root.internal->incremental_interface )
741 {
742 bchar_index = bchar;
743 achar_index = achar;
744 }
745 else
746 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
747 {
748 CFF_Font cff = (CFF_Font)(face->extra.data);
749
750
751 bchar_index = cff_lookup_glyph_by_stdcharcode( cff, bchar );
752 achar_index = cff_lookup_glyph_by_stdcharcode( cff, achar );
753 }
754
755 if ( bchar_index < 0 || achar_index < 0 )
756 {
757 FT_ERROR(( "cff_operator_seac:"
758 " invalid seac character code arguments\n" ));
759 return CFF_Err_Syntax_Error;
760 }
761
762 /* If we are trying to load a composite glyph, do not load the */
763 /* accent character and return the array of subglyphs. */
764 if ( builder->no_recurse )
765 {
766 FT_GlyphSlot glyph = (FT_GlyphSlot)builder->glyph;
767 FT_GlyphLoader loader = glyph->internal->loader;
768 FT_SubGlyph subg;
769
770
771 /* reallocate subglyph array if necessary */
772 error = FT_GlyphLoader_CheckSubGlyphs( loader, 2 );
773 if ( error )
774 goto Exit;
775
776 subg = loader->current.subglyphs;
777
778 /* subglyph 0 = base character */
779 subg->index = bchar_index;
780 subg->flags = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES |
781 FT_SUBGLYPH_FLAG_USE_MY_METRICS;
782 subg->arg1 = 0;
783 subg->arg2 = 0;
784 subg++;
785
786 /* subglyph 1 = accent character */
787 subg->index = achar_index;
788 subg->flags = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES;
789 subg->arg1 = (FT_Int)( adx >> 16 );
790 subg->arg2 = (FT_Int)( ady >> 16 );
791
792 /* set up remaining glyph fields */
793 glyph->num_subglyphs = 2;
794 glyph->subglyphs = loader->base.subglyphs;
795 glyph->format = FT_GLYPH_FORMAT_COMPOSITE;
796
797 loader->current.num_subglyphs = 2;
798 }
799
800 FT_GlyphLoader_Prepare( builder->loader );
801
802 /* First load `bchar' in builder */
803 error = cff_get_glyph_data( face, bchar_index,
804 &charstring, &charstring_len );
805 if ( !error )
806 {
807 /* the seac operator must not be nested */
808 decoder->seac = TRUE;
809 error = cff_decoder_parse_charstrings( decoder, charstring,
810 charstring_len );
811 decoder->seac = FALSE;
812
813 cff_free_glyph_data( face, &charstring, charstring_len );
814
815 if ( error )
816 goto Exit;
817 }
818
819 /* Save the left bearing, advance and glyph width of the base */
820 /* character as they will be erased by the next load. */
821
822 left_bearing = builder->left_bearing;
823 advance = builder->advance;
824 glyph_width = decoder->glyph_width;
825
826 builder->left_bearing.x = 0;
827 builder->left_bearing.y = 0;
828
829 builder->pos_x = adx - asb;
830 builder->pos_y = ady;
831
832 /* Now load `achar' on top of the base outline. */
833 error = cff_get_glyph_data( face, achar_index,
834 &charstring, &charstring_len );
835 if ( !error )
836 {
837 /* the seac operator must not be nested */
838 decoder->seac = TRUE;
839 error = cff_decoder_parse_charstrings( decoder, charstring,
840 charstring_len );
841 decoder->seac = FALSE;
842
843 cff_free_glyph_data( face, &charstring, charstring_len );
844
845 if ( error )
846 goto Exit;
847 }
848
849 /* Restore the left side bearing, advance and glyph width */
850 /* of the base character. */
851 builder->left_bearing = left_bearing;
852 builder->advance = advance;
853 decoder->glyph_width = glyph_width;
854
855 builder->pos_x = 0;
856 builder->pos_y = 0;
857
858 Exit:
859 return error;
860 }
861
862
863 /*************************************************************************/
864 /* */
865 /* <Function> */
866 /* cff_decoder_parse_charstrings */
867 /* */
868 /* <Description> */
869 /* Parses a given Type 2 charstrings program. */
870 /* */
871 /* <InOut> */
872 /* decoder :: The current Type 1 decoder. */
873 /* */
874 /* <Input> */
875 /* charstring_base :: The base of the charstring stream. */
876 /* */
877 /* charstring_len :: The length in bytes of the charstring stream. */
878 /* */
879 /* <Return> */
880 /* FreeType error code. 0 means success. */
881 /* */
882 FT_LOCAL_DEF( FT_Error )
883 cff_decoder_parse_charstrings( CFF_Decoder* decoder,
884 FT_Byte* charstring_base,
885 FT_ULong charstring_len )
886 {
887 FT_Error error;
888 CFF_Decoder_Zone* zone;
889 FT_Byte* ip;
890 FT_Byte* limit;
891 CFF_Builder* builder = &decoder->builder;
892 FT_Pos x, y;
893 FT_Fixed seed;
894 FT_Fixed* stack;
895 FT_Int charstring_type =
896 decoder->cff->top_font.font_dict.charstring_type;
897
898 T2_Hints_Funcs hinter;
899
900
901 /* set default width */
902 decoder->num_hints = 0;
903 decoder->read_width = 1;
904
905 /* compute random seed from stack address of parameter */
906 seed = (FT_Fixed)( ( (FT_PtrDist)(char*)&seed ^
907 (FT_PtrDist)(char*)&decoder ^
908 (FT_PtrDist)(char*)&charstring_base ) &
909 FT_ULONG_MAX ) ;
910 seed = ( seed ^ ( seed >> 10 ) ^ ( seed >> 20 ) ) & 0xFFFFL;
911 if ( seed == 0 )
912 seed = 0x7384;
913
914 /* initialize the decoder */
915 decoder->top = decoder->stack;
916 decoder->zone = decoder->zones;
917 zone = decoder->zones;
918 stack = decoder->top;
919
920 hinter = (T2_Hints_Funcs)builder->hints_funcs;
921
922 builder->path_begun = 0;
923
924 zone->base = charstring_base;
925 limit = zone->limit = charstring_base + charstring_len;
926 ip = zone->cursor = zone->base;
927
928 error = CFF_Err_Ok;
929
930 x = builder->pos_x;
931 y = builder->pos_y;
932
933 /* begin hints recording session, if any */
934 if ( hinter )
935 hinter->open( hinter->hints );
936
937 /* now execute loop */
938 while ( ip < limit )
939 {
940 CFF_Operator op;
941 FT_Byte v;
942
943
944 /********************************************************************/
945 /* */
946 /* Decode operator or operand */
947 /* */
948 v = *ip++;
949 if ( v >= 32 || v == 28 )
950 {
951 FT_Int shift = 16;
952 FT_Int32 val;
953
954
955 /* this is an operand, push it on the stack */
956 if ( v == 28 )
957 {
958 if ( ip + 1 >= limit )
959 goto Syntax_Error;
960 val = (FT_Short)( ( (FT_Short)ip[0] << 8 ) | ip[1] );
961 ip += 2;
962 }
963 else if ( v < 247 )
964 val = (FT_Int32)v - 139;
965 else if ( v < 251 )
966 {
967 if ( ip >= limit )
968 goto Syntax_Error;
969 val = ( (FT_Int32)v - 247 ) * 256 + *ip++ + 108;
970 }
971 else if ( v < 255 )
972 {
973 if ( ip >= limit )
974 goto Syntax_Error;
975 val = -( (FT_Int32)v - 251 ) * 256 - *ip++ - 108;
976 }
977 else
978 {
979 if ( ip + 3 >= limit )
980 goto Syntax_Error;
981 val = ( (FT_Int32)ip[0] << 24 ) |
982 ( (FT_Int32)ip[1] << 16 ) |
983 ( (FT_Int32)ip[2] << 8 ) |
984 ip[3];
985 ip += 4;
986 if ( charstring_type == 2 )
987 shift = 0;
988 }
989 if ( decoder->top - stack >= CFF_MAX_OPERANDS )
990 goto Stack_Overflow;
991
992 val <<= shift;
993 *decoder->top++ = val;
994
995 #ifdef FT_DEBUG_LEVEL_TRACE
996 if ( !( val & 0xFFFFL ) )
997 FT_TRACE4(( " %ld", (FT_Int32)( val >> 16 ) ));
998 else
999 FT_TRACE4(( " %.2f", val / 65536.0 ));
1000 #endif
1001
1002 }
1003 else
1004 {
1005 /* The specification says that normally arguments are to be taken */
1006 /* from the bottom of the stack. However, this seems not to be */
1007 /* correct, at least for Acroread 7.0.8 on GNU/Linux: It pops the */
1008 /* arguments similar to a PS interpreter. */
1009
1010 FT_Fixed* args = decoder->top;
1011 FT_Int num_args = (FT_Int)( args - decoder->stack );
1012 FT_Int req_args;
1013
1014
1015 /* find operator */
1016 op = cff_op_unknown;
1017
1018 switch ( v )
1019 {
1020 case 1:
1021 op = cff_op_hstem;
1022 break;
1023 case 3:
1024 op = cff_op_vstem;
1025 break;
1026 case 4:
1027 op = cff_op_vmoveto;
1028 break;
1029 case 5:
1030 op = cff_op_rlineto;
1031 break;
1032 case 6:
1033 op = cff_op_hlineto;
1034 break;
1035 case 7:
1036 op = cff_op_vlineto;
1037 break;
1038 case 8:
1039 op = cff_op_rrcurveto;
1040 break;
1041 case 9:
1042 op = cff_op_closepath;
1043 break;
1044 case 10:
1045 op = cff_op_callsubr;
1046 break;
1047 case 11:
1048 op = cff_op_return;
1049 break;
1050 case 12:
1051 {
1052 if ( ip >= limit )
1053 goto Syntax_Error;
1054 v = *ip++;
1055
1056 switch ( v )
1057 {
1058 case 0:
1059 op = cff_op_dotsection;
1060 break;
1061 case 1: /* this is actually the Type1 vstem3 operator */
1062 op = cff_op_vstem;
1063 break;
1064 case 2: /* this is actually the Type1 hstem3 operator */
1065 op = cff_op_hstem;
1066 break;
1067 case 3:
1068 op = cff_op_and;
1069 break;
1070 case 4:
1071 op = cff_op_or;
1072 break;
1073 case 5:
1074 op = cff_op_not;
1075 break;
1076 case 6:
1077 op = cff_op_seac;
1078 break;
1079 case 7:
1080 op = cff_op_sbw;
1081 break;
1082 case 8:
1083 op = cff_op_store;
1084 break;
1085 case 9:
1086 op = cff_op_abs;
1087 break;
1088 case 10:
1089 op = cff_op_add;
1090 break;
1091 case 11:
1092 op = cff_op_sub;
1093 break;
1094 case 12:
1095 op = cff_op_div;
1096 break;
1097 case 13:
1098 op = cff_op_load;
1099 break;
1100 case 14:
1101 op = cff_op_neg;
1102 break;
1103 case 15:
1104 op = cff_op_eq;
1105 break;
1106 case 16:
1107 op = cff_op_callothersubr;
1108 break;
1109 case 17:
1110 op = cff_op_pop;
1111 break;
1112 case 18:
1113 op = cff_op_drop;
1114 break;
1115 case 20:
1116 op = cff_op_put;
1117 break;
1118 case 21:
1119 op = cff_op_get;
1120 break;
1121 case 22:
1122 op = cff_op_ifelse;
1123 break;
1124 case 23:
1125 op = cff_op_random;
1126 break;
1127 case 24:
1128 op = cff_op_mul;
1129 break;
1130 case 26:
1131 op = cff_op_sqrt;
1132 break;
1133 case 27:
1134 op = cff_op_dup;
1135 break;
1136 case 28:
1137 op = cff_op_exch;
1138 break;
1139 case 29:
1140 op = cff_op_index;
1141 break;
1142 case 30:
1143 op = cff_op_roll;
1144 break;
1145 case 33:
1146 op = cff_op_setcurrentpoint;
1147 break;
1148 case 34:
1149 op = cff_op_hflex;
1150 break;
1151 case 35:
1152 op = cff_op_flex;
1153 break;
1154 case 36:
1155 op = cff_op_hflex1;
1156 break;
1157 case 37:
1158 op = cff_op_flex1;
1159 break;
1160 default:
1161 FT_TRACE4(( " unknown op (12, %d)\n", v ));
1162 break;
1163 }
1164 }
1165 break;
1166 case 13:
1167 op = cff_op_hsbw;
1168 break;
1169 case 14:
1170 op = cff_op_endchar;
1171 break;
1172 case 16:
1173 op = cff_op_blend;
1174 break;
1175 case 18:
1176 op = cff_op_hstemhm;
1177 break;
1178 case 19:
1179 op = cff_op_hintmask;
1180 break;
1181 case 20:
1182 op = cff_op_cntrmask;
1183 break;
1184 case 21:
1185 op = cff_op_rmoveto;
1186 break;
1187 case 22:
1188 op = cff_op_hmoveto;
1189 break;
1190 case 23:
1191 op = cff_op_vstemhm;
1192 break;
1193 case 24:
1194 op = cff_op_rcurveline;
1195 break;
1196 case 25:
1197 op = cff_op_rlinecurve;
1198 break;
1199 case 26:
1200 op = cff_op_vvcurveto;
1201 break;
1202 case 27:
1203 op = cff_op_hhcurveto;
1204 break;
1205 case 29:
1206 op = cff_op_callgsubr;
1207 break;
1208 case 30:
1209 op = cff_op_vhcurveto;
1210 break;
1211 case 31:
1212 op = cff_op_hvcurveto;
1213 break;
1214 default:
1215 FT_TRACE4(( " unknown op (%d)\n", v ));
1216 break;
1217 }
1218
1219 if ( op == cff_op_unknown )
1220 continue;
1221
1222 /* check arguments */
1223 req_args = cff_argument_counts[op];
1224 if ( req_args & CFF_COUNT_CHECK_WIDTH )
1225 {
1226 if ( num_args > 0 && decoder->read_width )
1227 {
1228 /* If `nominal_width' is non-zero, the number is really a */
1229 /* difference against `nominal_width'. Else, the number here */
1230 /* is truly a width, not a difference against `nominal_width'. */
1231 /* If the font does not set `nominal_width', then */
1232 /* `nominal_width' defaults to zero, and so we can set */
1233 /* `glyph_width' to `nominal_width' plus number on the stack */
1234 /* -- for either case. */
1235
1236 FT_Int set_width_ok;
1237
1238
1239 switch ( op )
1240 {
1241 case cff_op_hmoveto:
1242 case cff_op_vmoveto:
1243 set_width_ok = num_args & 2;
1244 break;
1245
1246 case cff_op_hstem:
1247 case cff_op_vstem:
1248 case cff_op_hstemhm:
1249 case cff_op_vstemhm:
1250 case cff_op_rmoveto:
1251 case cff_op_hintmask:
1252 case cff_op_cntrmask:
1253 set_width_ok = num_args & 1;
1254 break;
1255
1256 case cff_op_endchar:
1257 /* If there is a width specified for endchar, we either have */
1258 /* 1 argument or 5 arguments. We like to argue. */
1259 set_width_ok = ( num_args == 5 ) || ( num_args == 1 );
1260 break;
1261
1262 default:
1263 set_width_ok = 0;
1264 break;
1265 }
1266
1267 if ( set_width_ok )
1268 {
1269 decoder->glyph_width = decoder->nominal_width +
1270 ( stack[0] >> 16 );
1271
1272 if ( decoder->width_only )
1273 {
1274 /* we only want the advance width; stop here */
1275 break;
1276 }
1277
1278 /* Consumed an argument. */
1279 num_args--;
1280 }
1281 }
1282
1283 decoder->read_width = 0;
1284 req_args = 0;
1285 }
1286
1287 req_args &= 0x000F;
1288 if ( num_args < req_args )
1289 goto Stack_Underflow;
1290 args -= req_args;
1291 num_args -= req_args;
1292
1293 /* At this point, `args' points to the first argument of the */
1294 /* operand in case `req_args' isn't zero. Otherwise, we have */
1295 /* to adjust `args' manually. */
1296
1297 /* Note that we only pop arguments from the stack which we */
1298 /* really need and can digest so that we can continue in case */
1299 /* of superfluous stack elements. */
1300
1301 switch ( op )
1302 {
1303 case cff_op_hstem:
1304 case cff_op_vstem:
1305 case cff_op_hstemhm:
1306 case cff_op_vstemhm:
1307 /* the number of arguments is always even here */
1308 FT_TRACE4((
1309 op == cff_op_hstem ? " hstem\n" :
1310 ( op == cff_op_vstem ? " vstem\n" :
1311 ( op == cff_op_hstemhm ? " hstemhm\n" : " vstemhm\n" ) ) ));
1312
1313 if ( hinter )
1314 hinter->stems( hinter->hints,
1315 ( op == cff_op_hstem || op == cff_op_hstemhm ),
1316 num_args / 2,
1317 args - ( num_args & ~1 ) );
1318
1319 decoder->num_hints += num_args / 2;
1320 args = stack;
1321 break;
1322
1323 case cff_op_hintmask:
1324 case cff_op_cntrmask:
1325 FT_TRACE4(( op == cff_op_hintmask ? " hintmask" : " cntrmask" ));
1326
1327 /* implement vstem when needed -- */
1328 /* the specification doesn't say it, but this also works */
1329 /* with the 'cntrmask' operator */
1330 /* */
1331 if ( num_args > 0 )
1332 {
1333 if ( hinter )
1334 hinter->stems( hinter->hints,
1335 0,
1336 num_args / 2,
1337 args - ( num_args & ~1 ) );
1338
1339 decoder->num_hints += num_args / 2;
1340 }
1341
1342 /* In a valid charstring there must be at least one byte */
1343 /* after `hintmask' or `cntrmask' (e.g., for a `return' */
1344 /* instruction). Additionally, there must be space for */
1345 /* `num_hints' bits. */
1346
1347 if ( ( ip + ( ( decoder->num_hints + 7 ) >> 3 ) ) >= limit )
1348 goto Syntax_Error;
1349
1350 if ( hinter )
1351 {
1352 if ( op == cff_op_hintmask )
1353 hinter->hintmask( hinter->hints,
1354 builder->current->n_points,
1355 decoder->num_hints,
1356 ip );
1357 else
1358 hinter->counter( hinter->hints,
1359 decoder->num_hints,
1360 ip );
1361 }
1362
1363 #ifdef FT_DEBUG_LEVEL_TRACE
1364 {
1365 FT_UInt maskbyte;
1366
1367
1368 FT_TRACE4(( " (maskbytes:" ));
1369
1370 for ( maskbyte = 0;
1371 maskbyte < (FT_UInt)( ( decoder->num_hints + 7 ) >> 3 );
1372 maskbyte++, ip++ )
1373 FT_TRACE4(( " 0x%02X", *ip ));
1374
1375 FT_TRACE4(( ")\n" ));
1376 }
1377 #else
1378 ip += ( decoder->num_hints + 7 ) >> 3;
1379 #endif
1380 args = stack;
1381 break;
1382
1383 case cff_op_rmoveto:
1384 FT_TRACE4(( " rmoveto\n" ));
1385
1386 cff_builder_close_contour( builder );
1387 builder->path_begun = 0;
1388 x += args[-2];
1389 y += args[-1];
1390 args = stack;
1391 break;
1392
1393 case cff_op_vmoveto:
1394 FT_TRACE4(( " vmoveto\n" ));
1395
1396 cff_builder_close_contour( builder );
1397 builder->path_begun = 0;
1398 y += args[-1];
1399 args = stack;
1400 break;
1401
1402 case cff_op_hmoveto:
1403 FT_TRACE4(( " hmoveto\n" ));
1404
1405 cff_builder_close_contour( builder );
1406 builder->path_begun = 0;
1407 x += args[-1];
1408 args = stack;
1409 break;
1410
1411 case cff_op_rlineto:
1412 FT_TRACE4(( " rlineto\n" ));
1413
1414 if ( cff_builder_start_point ( builder, x, y ) ||
1415 check_points( builder, num_args / 2 ) )
1416 goto Fail;
1417
1418 if ( num_args < 2 )
1419 goto Stack_Underflow;
1420
1421 args -= num_args & ~1;
1422 while ( args < decoder->top )
1423 {
1424 x += args[0];
1425 y += args[1];
1426 cff_builder_add_point( builder, x, y, 1 );
1427 args += 2;
1428 }
1429 args = stack;
1430 break;
1431
1432 case cff_op_hlineto:
1433 case cff_op_vlineto:
1434 {
1435 FT_Int phase = ( op == cff_op_hlineto );
1436
1437
1438 FT_TRACE4(( op == cff_op_hlineto ? " hlineto\n"
1439 : " vlineto\n" ));
1440
1441 if ( num_args < 0 )
1442 goto Stack_Underflow;
1443
1444 /* there exist subsetted fonts (found in PDFs) */
1445 /* which call `hlineto' without arguments */
1446 if ( num_args == 0 )
1447 break;
1448
1449 if ( cff_builder_start_point ( builder, x, y ) ||
1450 check_points( builder, num_args ) )
1451 goto Fail;
1452
1453 args = stack;
1454 while ( args < decoder->top )
1455 {
1456 if ( phase )
1457 x += args[0];
1458 else
1459 y += args[0];
1460
1461 if ( cff_builder_add_point1( builder, x, y ) )
1462 goto Fail;
1463
1464 args++;
1465 phase ^= 1;
1466 }
1467 args = stack;
1468 }
1469 break;
1470
1471 case cff_op_rrcurveto:
1472 {
1473 FT_Int nargs;
1474
1475
1476 FT_TRACE4(( " rrcurveto\n" ));
1477
1478 if ( num_args < 6 )
1479 goto Stack_Underflow;
1480
1481 nargs = num_args - num_args % 6;
1482
1483 if ( cff_builder_start_point ( builder, x, y ) ||
1484 check_points( builder, nargs / 2 ) )
1485 goto Fail;
1486
1487 args -= nargs;
1488 while ( args < decoder->top )
1489 {
1490 x += args[0];
1491 y += args[1];
1492 cff_builder_add_point( builder, x, y, 0 );
1493 x += args[2];
1494 y += args[3];
1495 cff_builder_add_point( builder, x, y, 0 );
1496 x += args[4];
1497 y += args[5];
1498 cff_builder_add_point( builder, x, y, 1 );
1499 args += 6;
1500 }
1501 args = stack;
1502 }
1503 break;
1504
1505 case cff_op_vvcurveto:
1506 {
1507 FT_Int nargs;
1508
1509
1510 FT_TRACE4(( " vvcurveto\n" ));
1511
1512 if ( num_args < 4 )
1513 goto Stack_Underflow;
1514
1515 /* if num_args isn't of the form 4n or 4n+1, */
1516 /* we enforce it by clearing the second bit */
1517
1518 nargs = num_args & ~2;
1519
1520 if ( cff_builder_start_point( builder, x, y ) )
1521 goto Fail;
1522
1523 args -= nargs;
1524
1525 if ( nargs & 1 )
1526 {
1527 x += args[0];
1528 args++;
1529 nargs--;
1530 }
1531
1532 if ( check_points( builder, 3 * ( nargs / 4 ) ) )
1533 goto Fail;
1534
1535 while ( args < decoder->top )
1536 {
1537 y += args[0];
1538 cff_builder_add_point( builder, x, y, 0 );
1539 x += args[1];
1540 y += args[2];
1541 cff_builder_add_point( builder, x, y, 0 );
1542 y += args[3];
1543 cff_builder_add_point( builder, x, y, 1 );
1544 args += 4;
1545 }
1546 args = stack;
1547 }
1548 break;
1549
1550 case cff_op_hhcurveto:
1551 {
1552 FT_Int nargs;
1553
1554
1555 FT_TRACE4(( " hhcurveto\n" ));
1556
1557 if ( num_args < 4 )
1558 goto Stack_Underflow;
1559
1560 /* if num_args isn't of the form 4n or 4n+1, */
1561 /* we enforce it by clearing the second bit */
1562
1563 nargs = num_args & ~2;
1564
1565 if ( cff_builder_start_point( builder, x, y ) )
1566 goto Fail;
1567
1568 args -= nargs;
1569 if ( nargs & 1 )
1570 {
1571 y += args[0];
1572 args++;
1573 nargs--;
1574 }
1575
1576 if ( check_points( builder, 3 * ( nargs / 4 ) ) )
1577 goto Fail;
1578
1579 while ( args < decoder->top )
1580 {
1581 x += args[0];
1582 cff_builder_add_point( builder, x, y, 0 );
1583 x += args[1];
1584 y += args[2];
1585 cff_builder_add_point( builder, x, y, 0 );
1586 x += args[3];
1587 cff_builder_add_point( builder, x, y, 1 );
1588 args += 4;
1589 }
1590 args = stack;
1591 }
1592 break;
1593
1594 case cff_op_vhcurveto:
1595 case cff_op_hvcurveto:
1596 {
1597 FT_Int phase;
1598 FT_Int nargs;
1599
1600
1601 FT_TRACE4(( op == cff_op_vhcurveto ? " vhcurveto\n"
1602 : " hvcurveto\n" ));
1603
1604 if ( cff_builder_start_point( builder, x, y ) )
1605 goto Fail;
1606
1607 if ( num_args < 4 )
1608 goto Stack_Underflow;
1609
1610 /* if num_args isn't of the form 8n, 8n+1, 8n+4, or 8n+5, */
1611 /* we enforce it by clearing the second bit */
1612
1613 nargs = num_args & ~2;
1614
1615 args -= nargs;
1616 if ( check_points( builder, ( nargs / 4 ) * 3 ) )
1617 goto Stack_Underflow;
1618
1619 phase = ( op == cff_op_hvcurveto );
1620
1621 while ( nargs >= 4 )
1622 {
1623 nargs -= 4;
1624 if ( phase )
1625 {
1626 x += args[0];
1627 cff_builder_add_point( builder, x, y, 0 );
1628 x += args[1];
1629 y += args[2];
1630 cff_builder_add_point( builder, x, y, 0 );
1631 y += args[3];
1632 if ( nargs == 1 )
1633 x += args[4];
1634 cff_builder_add_point( builder, x, y, 1 );
1635 }
1636 else
1637 {
1638 y += args[0];
1639 cff_builder_add_point( builder, x, y, 0 );
1640 x += args[1];
1641 y += args[2];
1642 cff_builder_add_point( builder, x, y, 0 );
1643 x += args[3];
1644 if ( nargs == 1 )
1645 y += args[4];
1646 cff_builder_add_point( builder, x, y, 1 );
1647 }
1648 args += 4;
1649 phase ^= 1;
1650 }
1651 args = stack;
1652 }
1653 break;
1654
1655 case cff_op_rlinecurve:
1656 {
1657 FT_Int num_lines;
1658 FT_Int nargs;
1659
1660
1661 FT_TRACE4(( " rlinecurve\n" ));
1662
1663 if ( num_args < 8 )
1664 goto Stack_Underflow;
1665
1666 nargs = num_args & ~1;
1667 num_lines = ( nargs - 6 ) / 2;
1668
1669 if ( cff_builder_start_point( builder, x, y ) ||
1670 check_points( builder, num_lines + 3 ) )
1671 goto Fail;
1672
1673 args -= nargs;
1674
1675 /* first, add the line segments */
1676 while ( num_lines > 0 )
1677 {
1678 x += args[0];
1679 y += args[1];
1680 cff_builder_add_point( builder, x, y, 1 );
1681 args += 2;
1682 num_lines--;
1683 }
1684
1685 /* then the curve */
1686 x += args[0];
1687 y += args[1];
1688 cff_builder_add_point( builder, x, y, 0 );
1689 x += args[2];
1690 y += args[3];
1691 cff_builder_add_point( builder, x, y, 0 );
1692 x += args[4];
1693 y += args[5];
1694 cff_builder_add_point( builder, x, y, 1 );
1695 args = stack;
1696 }
1697 break;
1698
1699 case cff_op_rcurveline:
1700 {
1701 FT_Int num_curves;
1702 FT_Int nargs;
1703
1704
1705 FT_TRACE4(( " rcurveline\n" ));
1706
1707 if ( num_args < 8 )
1708 goto Stack_Underflow;
1709
1710 nargs = num_args - 2;
1711 nargs = nargs - nargs % 6 + 2;
1712 num_curves = ( nargs - 2 ) / 6;
1713
1714 if ( cff_builder_start_point ( builder, x, y ) ||
1715 check_points( builder, num_curves * 3 + 2 ) )
1716 goto Fail;
1717
1718 args -= nargs;
1719
1720 /* first, add the curves */
1721 while ( num_curves > 0 )
1722 {
1723 x += args[0];
1724 y += args[1];
1725 cff_builder_add_point( builder, x, y, 0 );
1726 x += args[2];
1727 y += args[3];
1728 cff_builder_add_point( builder, x, y, 0 );
1729 x += args[4];
1730 y += args[5];
1731 cff_builder_add_point( builder, x, y, 1 );
1732 args += 6;
1733 num_curves--;
1734 }
1735
1736 /* then the final line */
1737 x += args[0];
1738 y += args[1];
1739 cff_builder_add_point( builder, x, y, 1 );
1740 args = stack;
1741 }
1742 break;
1743
1744 case cff_op_hflex1:
1745 {
1746 FT_Pos start_y;
1747
1748
1749 FT_TRACE4(( " hflex1\n" ));
1750
1751 /* adding five more points: 4 control points, 1 on-curve point */
1752 /* -- make sure we have enough space for the start point if it */
1753 /* needs to be added */
1754 if ( cff_builder_start_point( builder, x, y ) ||
1755 check_points( builder, 6 ) )
1756 goto Fail;
1757
1758 /* record the starting point's y position for later use */
1759 start_y = y;
1760
1761 /* first control point */
1762 x += args[0];
1763 y += args[1];
1764 cff_builder_add_point( builder, x, y, 0 );
1765
1766 /* second control point */
1767 x += args[2];
1768 y += args[3];
1769 cff_builder_add_point( builder, x, y, 0 );
1770
1771 /* join point; on curve, with y-value the same as the last */
1772 /* control point's y-value */
1773 x += args[4];
1774 cff_builder_add_point( builder, x, y, 1 );
1775
1776 /* third control point, with y-value the same as the join */
1777 /* point's y-value */
1778 x += args[5];
1779 cff_builder_add_point( builder, x, y, 0 );
1780
1781 /* fourth control point */
1782 x += args[6];
1783 y += args[7];
1784 cff_builder_add_point( builder, x, y, 0 );
1785
1786 /* ending point, with y-value the same as the start */
1787 x += args[8];
1788 y = start_y;
1789 cff_builder_add_point( builder, x, y, 1 );
1790
1791 args = stack;
1792 break;
1793 }
1794
1795 case cff_op_hflex:
1796 {
1797 FT_Pos start_y;
1798
1799
1800 FT_TRACE4(( " hflex\n" ));
1801
1802 /* adding six more points; 4 control points, 2 on-curve points */
1803 if ( cff_builder_start_point( builder, x, y ) ||
1804 check_points( builder, 6 ) )
1805 goto Fail;
1806
1807 /* record the starting point's y-position for later use */
1808 start_y = y;
1809
1810 /* first control point */
1811 x += args[0];
1812 cff_builder_add_point( builder, x, y, 0 );
1813
1814 /* second control point */
1815 x += args[1];
1816 y += args[2];
1817 cff_builder_add_point( builder, x, y, 0 );
1818
1819 /* join point; on curve, with y-value the same as the last */
1820 /* control point's y-value */
1821 x += args[3];
1822 cff_builder_add_point( builder, x, y, 1 );
1823
1824 /* third control point, with y-value the same as the join */
1825 /* point's y-value */
1826 x += args[4];
1827 cff_builder_add_point( builder, x, y, 0 );
1828
1829 /* fourth control point */
1830 x += args[5];
1831 y = start_y;
1832 cff_builder_add_point( builder, x, y, 0 );
1833
1834 /* ending point, with y-value the same as the start point's */
1835 /* y-value -- we don't add this point, though */
1836 x += args[6];
1837 cff_builder_add_point( builder, x, y, 1 );
1838
1839 args = stack;
1840 break;
1841 }
1842
1843 case cff_op_flex1:
1844 {
1845 FT_Pos start_x, start_y; /* record start x, y values for */
1846 /* alter use */
1847 FT_Fixed dx = 0, dy = 0; /* used in horizontal/vertical */
1848 /* algorithm below */
1849 FT_Int horizontal, count;
1850 FT_Fixed* temp;
1851
1852
1853 FT_TRACE4(( " flex1\n" ));
1854
1855 /* adding six more points; 4 control points, 2 on-curve points */
1856 if ( cff_builder_start_point( builder, x, y ) ||
1857 check_points( builder, 6 ) )
1858 goto Fail;
1859
1860 /* record the starting point's x, y position for later use */
1861 start_x = x;
1862 start_y = y;
1863
1864 /* XXX: figure out whether this is supposed to be a horizontal */
1865 /* or vertical flex; the Type 2 specification is vague... */
1866
1867 temp = args;
1868
1869 /* grab up to the last argument */
1870 for ( count = 5; count > 0; count-- )
1871 {
1872 dx += temp[0];
1873 dy += temp[1];
1874 temp += 2;
1875 }
1876
1877 if ( dx < 0 )
1878 dx = -dx;
1879 if ( dy < 0 )
1880 dy = -dy;
1881
1882 /* strange test, but here it is... */
1883 horizontal = ( dx > dy );
1884
1885 for ( count = 5; count > 0; count-- )
1886 {
1887 x += args[0];
1888 y += args[1];
1889 cff_builder_add_point( builder, x, y,
1890 (FT_Bool)( count == 3 ) );
1891 args += 2;
1892 }
1893
1894 /* is last operand an x- or y-delta? */
1895 if ( horizontal )
1896 {
1897 x += args[0];
1898 y = start_y;
1899 }
1900 else
1901 {
1902 x = start_x;
1903 y += args[0];
1904 }
1905
1906 cff_builder_add_point( builder, x, y, 1 );
1907
1908 args = stack;
1909 break;
1910 }
1911
1912 case cff_op_flex:
1913 {
1914 FT_UInt count;
1915
1916
1917 FT_TRACE4(( " flex\n" ));
1918
1919 if ( cff_builder_start_point( builder, x, y ) ||
1920 check_points( builder, 6 ) )
1921 goto Fail;
1922
1923 for ( count = 6; count > 0; count-- )
1924 {
1925 x += args[0];
1926 y += args[1];
1927 cff_builder_add_point( builder, x, y,
1928 (FT_Bool)( count == 4 || count == 1 ) );
1929 args += 2;
1930 }
1931
1932 args = stack;
1933 }
1934 break;
1935
1936 case cff_op_seac:
1937 FT_TRACE4(( " seac\n" ));
1938
1939 error = cff_operator_seac( decoder,
1940 args[0], args[1], args[2],
1941 (FT_Int)( args[3] >> 16 ),
1942 (FT_Int)( args[4] >> 16 ) );
1943
1944 /* add current outline to the glyph slot */
1945 FT_GlyphLoader_Add( builder->loader );
1946
1947 /* return now! */
1948 FT_TRACE4(( "\n" ));
1949 return error;
1950
1951 case cff_op_endchar:
1952 FT_TRACE4(( " endchar\n" ));
1953
1954 /* We are going to emulate the seac operator. */
1955 if ( num_args >= 4 )
1956 {
1957 /* Save glyph width so that the subglyphs don't overwrite it. */
1958 FT_Pos glyph_width = decoder->glyph_width;
1959
1960
1961 error = cff_operator_seac( decoder,
1962 0L, args[-4], args[-3],
1963 (FT_Int)( args[-2] >> 16 ),
1964 (FT_Int)( args[-1] >> 16 ) );
1965
1966 decoder->glyph_width = glyph_width;
1967 }
1968 else
1969 {
1970 if ( !error )
1971 error = CFF_Err_Ok;
1972
1973 cff_builder_close_contour( builder );
1974
1975 /* close hints recording session */
1976 if ( hinter )
1977 {
1978 if ( hinter->close( hinter->hints,
1979 builder->current->n_points ) )
1980 goto Syntax_Error;
1981
1982 /* apply hints to the loaded glyph outline now */
1983 hinter->apply( hinter->hints,
1984 builder->current,
1985 (PSH_Globals)builder->hints_globals,
1986 decoder->hint_mode );
1987 }
1988
1989 /* add current outline to the glyph slot */
1990 FT_GlyphLoader_Add( builder->loader );
1991 }
1992
1993 /* return now! */
1994 FT_TRACE4(( "\n" ));
1995 return error;
1996
1997 case cff_op_abs:
1998 FT_TRACE4(( " abs\n" ));
1999
2000 if ( args[0] < 0 )
2001 args[0] = -args[0];
2002 args++;
2003 break;
2004
2005 case cff_op_add:
2006 FT_TRACE4(( " add\n" ));
2007
2008 args[0] += args[1];
2009 args++;
2010 break;
2011
2012 case cff_op_sub:
2013 FT_TRACE4(( " sub\n" ));
2014
2015 args[0] -= args[1];
2016 args++;
2017 break;
2018
2019 case cff_op_div:
2020 FT_TRACE4(( " div\n" ));
2021
2022 args[0] = FT_DivFix( args[0], args[1] );
2023 args++;
2024 break;
2025
2026 case cff_op_neg:
2027 FT_TRACE4(( " neg\n" ));
2028
2029 args[0] = -args[0];
2030 args++;
2031 break;
2032
2033 case cff_op_random:
2034 {
2035 FT_Fixed Rand;
2036
2037
2038 FT_TRACE4(( " rand\n" ));
2039
2040 Rand = seed;
2041 if ( Rand >= 0x8000L )
2042 Rand++;
2043
2044 args[0] = Rand;
2045 seed = FT_MulFix( seed, 0x10000L - seed );
2046 if ( seed == 0 )
2047 seed += 0x2873;
2048 args++;
2049 }
2050 break;
2051
2052 case cff_op_mul:
2053 FT_TRACE4(( " mul\n" ));
2054
2055 args[0] = FT_MulFix( args[0], args[1] );
2056 args++;
2057 break;
2058
2059 case cff_op_sqrt:
2060 FT_TRACE4(( " sqrt\n" ));
2061
2062 if ( args[0] > 0 )
2063 {
2064 FT_Int count = 9;
2065 FT_Fixed root = args[0];
2066 FT_Fixed new_root;
2067
2068
2069 for (;;)
2070 {
2071 new_root = ( root + FT_DivFix( args[0], root ) + 1 ) >> 1;
2072 if ( new_root == root || count <= 0 )
2073 break;
2074 root = new_root;
2075 }
2076 args[0] = new_root;
2077 }
2078 else
2079 args[0] = 0;
2080 args++;
2081 break;
2082
2083 case cff_op_drop:
2084 /* nothing */
2085 FT_TRACE4(( " drop\n" ));
2086
2087 break;
2088
2089 case cff_op_exch:
2090 {
2091 FT_Fixed tmp;
2092
2093
2094 FT_TRACE4(( " exch\n" ));
2095
2096 tmp = args[0];
2097 args[0] = args[1];
2098 args[1] = tmp;
2099 args += 2;
2100 }
2101 break;
2102
2103 case cff_op_index:
2104 {
2105 FT_Int idx = (FT_Int)( args[0] >> 16 );
2106
2107
2108 FT_TRACE4(( " index\n" ));
2109
2110 if ( idx < 0 )
2111 idx = 0;
2112 else if ( idx > num_args - 2 )
2113 idx = num_args - 2;
2114 args[0] = args[-( idx + 1 )];
2115 args++;
2116 }
2117 break;
2118
2119 case cff_op_roll:
2120 {
2121 FT_Int count = (FT_Int)( args[0] >> 16 );
2122 FT_Int idx = (FT_Int)( args[1] >> 16 );
2123
2124
2125 FT_TRACE4(( " roll\n" ));
2126
2127 if ( count <= 0 )
2128 count = 1;
2129
2130 args -= count;
2131 if ( args < stack )
2132 goto Stack_Underflow;
2133
2134 if ( idx >= 0 )
2135 {
2136 while ( idx > 0 )
2137 {
2138 FT_Fixed tmp = args[count - 1];
2139 FT_Int i;
2140
2141
2142 for ( i = count - 2; i >= 0; i-- )
2143 args[i + 1] = args[i];
2144 args[0] = tmp;
2145 idx--;
2146 }
2147 }
2148 else
2149 {
2150 while ( idx < 0 )
2151 {
2152 FT_Fixed tmp = args[0];
2153 FT_Int i;
2154
2155
2156 for ( i = 0; i < count - 1; i++ )
2157 args[i] = args[i + 1];
2158 args[count - 1] = tmp;
2159 idx++;
2160 }
2161 }
2162 args += count;
2163 }
2164 break;
2165
2166 case cff_op_dup:
2167 FT_TRACE4(( " dup\n" ));
2168
2169 args[1] = args[0];
2170 args += 2;
2171 break;
2172
2173 case cff_op_put:
2174 {
2175 FT_Fixed val = args[0];
2176 FT_Int idx = (FT_Int)( args[1] >> 16 );
2177
2178
2179 FT_TRACE4(( " put\n" ));
2180
2181 if ( idx >= 0 && idx < CFF_MAX_TRANS_ELEMENTS )
2182 decoder->buildchar[idx] = val;
2183 }
2184 break;
2185
2186 case cff_op_get:
2187 {
2188 FT_Int idx = (FT_Int)( args[0] >> 16 );
2189 FT_Fixed val = 0;
2190
2191
2192 FT_TRACE4(( " get\n" ));
2193
2194 if ( idx >= 0 && idx < CFF_MAX_TRANS_ELEMENTS )
2195 val = decoder->buildchar[idx];
2196
2197 args[0] = val;
2198 args++;
2199 }
2200 break;
2201
2202 case cff_op_store:
2203 FT_TRACE4(( " store\n"));
2204
2205 goto Unimplemented;
2206
2207 case cff_op_load:
2208 FT_TRACE4(( " load\n" ));
2209
2210 goto Unimplemented;
2211
2212 case cff_op_dotsection:
2213 /* this operator is deprecated and ignored by the parser */
2214 FT_TRACE4(( " dotsection\n" ));
2215 break;
2216
2217 case cff_op_closepath:
2218 /* this is an invalid Type 2 operator; however, there */
2219 /* exist fonts which are incorrectly converted from probably */
2220 /* Type 1 to CFF, and some parsers seem to accept it */
2221
2222 FT_TRACE4(( " closepath (invalid op)\n" ));
2223
2224 args = stack;
2225 break;
2226
2227 case cff_op_hsbw:
2228 /* this is an invalid Type 2 operator; however, there */
2229 /* exist fonts which are incorrectly converted from probably */
2230 /* Type 1 to CFF, and some parsers seem to accept it */
2231
2232 FT_TRACE4(( " hsbw (invalid op)\n" ));
2233
2234 decoder->glyph_width = decoder->nominal_width + ( args[1] >> 16 );
2235
2236 decoder->builder.left_bearing.x = args[0];
2237 decoder->builder.left_bearing.y = 0;
2238
2239 x = decoder->builder.pos_x + args[0];
2240 y = decoder->builder.pos_y;
2241 args = stack;
2242 break;
2243
2244 case cff_op_sbw:
2245 /* this is an invalid Type 2 operator; however, there */
2246 /* exist fonts which are incorrectly converted from probably */
2247 /* Type 1 to CFF, and some parsers seem to accept it */
2248
2249 FT_TRACE4(( " sbw (invalid op)\n" ));
2250
2251 decoder->glyph_width = decoder->nominal_width + ( args[2] >> 16 );
2252
2253 decoder->builder.left_bearing.x = args[0];
2254 decoder->builder.left_bearing.y = args[1];
2255
2256 x = decoder->builder.pos_x + args[0];
2257 y = decoder->builder.pos_y + args[1];
2258 args = stack;
2259 break;
2260
2261 case cff_op_setcurrentpoint:
2262 /* this is an invalid Type 2 operator; however, there */
2263 /* exist fonts which are incorrectly converted from probably */
2264 /* Type 1 to CFF, and some parsers seem to accept it */
2265
2266 FT_TRACE4(( " setcurrentpoint (invalid op)\n" ));
2267
2268 x = decoder->builder.pos_x + args[0];
2269 y = decoder->builder.pos_y + args[1];
2270 args = stack;
2271 break;
2272
2273 case cff_op_callothersubr:
2274 /* this is an invalid Type 2 operator; however, there */
2275 /* exist fonts which are incorrectly converted from probably */
2276 /* Type 1 to CFF, and some parsers seem to accept it */
2277
2278 FT_TRACE4(( " callothersubr (invalid op)\n" ));
2279
2280 /* subsequent `pop' operands should add the arguments, */
2281 /* this is the implementation described for `unknown' other */
2282 /* subroutines in the Type1 spec. */
2283 /* */
2284 /* XXX Fix return arguments (see discussion below). */
2285 args -= 2 + ( args[-2] >> 16 );
2286 if ( args < stack )
2287 goto Stack_Underflow;
2288 break;
2289
2290 case cff_op_pop:
2291 /* this is an invalid Type 2 operator; however, there */
2292 /* exist fonts which are incorrectly converted from probably */
2293 /* Type 1 to CFF, and some parsers seem to accept it */
2294
2295 FT_TRACE4(( " pop (invalid op)\n" ));
2296
2297 /* XXX Increasing `args' is wrong: After a certain number of */
2298 /* `pop's we get a stack overflow. Reason for doing it is */
2299 /* code like this (actually found in a CFF font): */
2300 /* */
2301 /* 17 1 3 callothersubr */
2302 /* pop */
2303 /* callsubr */
2304 /* */
2305 /* Since we handle `callothersubr' as a no-op, and */
2306 /* `callsubr' needs at least one argument, `pop' can't be a */
2307 /* no-op too as it basically should be. */
2308 /* */
2309 /* The right solution would be to provide real support for */
2310 /* `callothersubr' as done in `t1decode.c', however, given */
2311 /* the fact that CFF fonts with `pop' are invalid, it is */
2312 /* questionable whether it is worth the time. */
2313 args++;
2314 break;
2315
2316 case cff_op_and:
2317 {
2318 FT_Fixed cond = args[0] && args[1];
2319
2320
2321 FT_TRACE4(( " and\n" ));
2322
2323 args[0] = cond ? 0x10000L : 0;
2324 args++;
2325 }
2326 break;
2327
2328 case cff_op_or:
2329 {
2330 FT_Fixed cond = args[0] || args[1];
2331
2332
2333 FT_TRACE4(( " or\n" ));
2334
2335 args[0] = cond ? 0x10000L : 0;
2336 args++;
2337 }
2338 break;
2339
2340 case cff_op_eq:
2341 {
2342 FT_Fixed cond = !args[0];
2343
2344
2345 FT_TRACE4(( " eq\n" ));
2346
2347 args[0] = cond ? 0x10000L : 0;
2348 args++;
2349 }
2350 break;
2351
2352 case cff_op_ifelse:
2353 {
2354 FT_Fixed cond = ( args[2] <= args[3] );
2355
2356
2357 FT_TRACE4(( " ifelse\n" ));
2358
2359 if ( !cond )
2360 args[0] = args[1];
2361 args++;
2362 }
2363 break;
2364
2365 case cff_op_callsubr:
2366 {
2367 FT_UInt idx = (FT_UInt)( ( args[0] >> 16 ) +
2368 decoder->locals_bias );
2369
2370
2371 FT_TRACE4(( " callsubr(%d)\n", idx ));
2372
2373 if ( idx >= decoder->num_locals )
2374 {
2375 FT_ERROR(( "cff_decoder_parse_charstrings:"
2376 " invalid local subr index\n" ));
2377 goto Syntax_Error;
2378 }
2379
2380 if ( zone - decoder->zones >= CFF_MAX_SUBRS_CALLS )
2381 {
2382 FT_ERROR(( "cff_decoder_parse_charstrings:"
2383 " too many nested subrs\n" ));
2384 goto Syntax_Error;
2385 }
2386
2387 zone->cursor = ip; /* save current instruction pointer */
2388
2389 zone++;
2390 zone->base = decoder->locals[idx];
2391 zone->limit = decoder->locals[idx + 1];
2392 zone->cursor = zone->base;
2393
2394 if ( !zone->base || zone->limit == zone->base )
2395 {
2396 FT_ERROR(( "cff_decoder_parse_charstrings:"
2397 " invoking empty subrs\n" ));
2398 goto Syntax_Error;
2399 }
2400
2401 decoder->zone = zone;
2402 ip = zone->base;
2403 limit = zone->limit;
2404 }
2405 break;
2406
2407 case cff_op_callgsubr:
2408 {
2409 FT_UInt idx = (FT_UInt)( ( args[0] >> 16 ) +
2410 decoder->globals_bias );
2411
2412
2413 FT_TRACE4(( " callgsubr(%d)\n", idx ));
2414
2415 if ( idx >= decoder->num_globals )
2416 {
2417 FT_ERROR(( "cff_decoder_parse_charstrings:"
2418 " invalid global subr index\n" ));
2419 goto Syntax_Error;
2420 }
2421
2422 if ( zone - decoder->zones >= CFF_MAX_SUBRS_CALLS )
2423 {
2424 FT_ERROR(( "cff_decoder_parse_charstrings:"
2425 " too many nested subrs\n" ));
2426 goto Syntax_Error;
2427 }
2428
2429 zone->cursor = ip; /* save current instruction pointer */
2430
2431 zone++;
2432 zone->base = decoder->globals[idx];
2433 zone->limit = decoder->globals[idx + 1];
2434 zone->cursor = zone->base;
2435
2436 if ( !zone->base || zone->limit == zone->base )
2437 {
2438 FT_ERROR(( "cff_decoder_parse_charstrings:"
2439 " invoking empty subrs\n" ));
2440 goto Syntax_Error;
2441 }
2442
2443 decoder->zone = zone;
2444 ip = zone->base;
2445 limit = zone->limit;
2446 }
2447 break;
2448
2449 case cff_op_return:
2450 FT_TRACE4(( " return\n" ));
2451
2452 if ( decoder->zone <= decoder->zones )
2453 {
2454 FT_ERROR(( "cff_decoder_parse_charstrings:"
2455 " unexpected return\n" ));
2456 goto Syntax_Error;
2457 }
2458
2459 decoder->zone--;
2460 zone = decoder->zone;
2461 ip = zone->cursor;
2462 limit = zone->limit;
2463 break;
2464
2465 default:
2466 Unimplemented:
2467 FT_ERROR(( "Unimplemented opcode: %d", ip[-1] ));
2468
2469 if ( ip[-1] == 12 )
2470 FT_ERROR(( " %d", ip[0] ));
2471 FT_ERROR(( "\n" ));
2472
2473 return CFF_Err_Unimplemented_Feature;
2474 }
2475
2476 decoder->top = args;
2477
2478 if ( decoder->top - stack >= CFF_MAX_OPERANDS )
2479 goto Stack_Overflow;
2480
2481 } /* general operator processing */
2482
2483 } /* while ip < limit */
2484
2485 FT_TRACE4(( "..end..\n\n" ));
2486
2487 Fail:
2488 return error;
2489
2490 Syntax_Error:
2491 FT_TRACE4(( "cff_decoder_parse_charstrings: syntax error\n" ));
2492 return CFF_Err_Invalid_File_Format;
2493
2494 Stack_Underflow:
2495 FT_TRACE4(( "cff_decoder_parse_charstrings: stack underflow\n" ));
2496 return CFF_Err_Too_Few_Arguments;
2497
2498 Stack_Overflow:
2499 FT_TRACE4(( "cff_decoder_parse_charstrings: stack overflow\n" ));
2500 return CFF_Err_Stack_Overflow;
2501 }
2502
2503
2504 /*************************************************************************/
2505 /*************************************************************************/
2506 /*************************************************************************/
2507 /********** *********/
2508 /********** *********/
2509 /********** COMPUTE THE MAXIMUM ADVANCE WIDTH *********/
2510 /********** *********/
2511 /********** The following code is in charge of computing *********/
2512 /********** the maximum advance width of the font. It *********/
2513 /********** quickly processes each glyph charstring to *********/
2514 /********** extract the value from either a `sbw' or `seac' *********/
2515 /********** operator. *********/
2516 /********** *********/
2517 /*************************************************************************/
2518 /*************************************************************************/
2519 /*************************************************************************/
2520
2521
2522 #if 0 /* unused until we support pure CFF fonts */
2523
2524
2525 FT_LOCAL_DEF( FT_Error )
2526 cff_compute_max_advance( TT_Face face,
2527 FT_Int* max_advance )
2528 {
2529 FT_Error error = CFF_Err_Ok;
2530 CFF_Decoder decoder;
2531 FT_Int glyph_index;
2532 CFF_Font cff = (CFF_Font)face->other;
2533
2534
2535 *max_advance = 0;
2536
2537 /* Initialize load decoder */
2538 cff_decoder_init( &decoder, face, 0, 0, 0, 0 );
2539
2540 decoder.builder.metrics_only = 1;
2541 decoder.builder.load_points = 0;
2542
2543 /* For each glyph, parse the glyph charstring and extract */
2544 /* the advance width. */
2545 for ( glyph_index = 0; glyph_index < face->root.num_glyphs;
2546 glyph_index++ )
2547 {
2548 FT_Byte* charstring;
2549 FT_ULong charstring_len;
2550
2551
2552 /* now get load the unscaled outline */
2553 error = cff_get_glyph_data( face, glyph_index,
2554 &charstring, &charstring_len );
2555 if ( !error )
2556 {
2557 error = cff_decoder_prepare( &decoder, size, glyph_index );
2558 if ( !error )
2559 error = cff_decoder_parse_charstrings( &decoder,
2560 charstring,
2561 charstring_len );
2562
2563 cff_free_glyph_data( face, &charstring, &charstring_len );
2564 }
2565
2566 /* ignore the error if one has occurred -- skip to next glyph */
2567 error = CFF_Err_Ok;
2568 }
2569
2570 *max_advance = decoder.builder.advance.x;
2571
2572 return CFF_Err_Ok;
2573 }
2574
2575
2576 #endif /* 0 */
2577
2578
2579 FT_LOCAL_DEF( FT_Error )
2580 cff_slot_load( CFF_GlyphSlot glyph,
2581 CFF_Size size,
2582 FT_UInt glyph_index,
2583 FT_Int32 load_flags )
2584 {
2585 FT_Error error;
2586 CFF_Decoder decoder;
2587 TT_Face face = (TT_Face)glyph->root.face;
2588 FT_Bool hinting, force_scaling;
2589 CFF_Font cff = (CFF_Font)face->extra.data;
2590
2591 FT_Matrix font_matrix;
2592 FT_Vector font_offset;
2593
2594
2595 force_scaling = FALSE;
2596
2597 /* in a CID-keyed font, consider `glyph_index' as a CID and map */
2598 /* it immediately to the real glyph_index -- if it isn't a */
2599 /* subsetted font, glyph_indices and CIDs are identical, though */
2600 if ( cff->top_font.font_dict.cid_registry != 0xFFFFU &&
2601 cff->charset.cids )
2602 {
2603 /* don't handle CID 0 (.notdef) which is directly mapped to GID 0 */
2604 if ( glyph_index != 0 )
2605 {
2606 glyph_index = cff_charset_cid_to_gindex( &cff->charset,
2607 glyph_index );
2608 if ( glyph_index == 0 )
2609 return CFF_Err_Invalid_Argument;
2610 }
2611 }
2612 else if ( glyph_index >= cff->num_glyphs )
2613 return CFF_Err_Invalid_Argument;
2614
2615 if ( load_flags & FT_LOAD_NO_RECURSE )
2616 load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
2617
2618 glyph->x_scale = 0x10000L;
2619 glyph->y_scale = 0x10000L;
2620 if ( size )
2621 {
2622 glyph->x_scale = size->root.metrics.x_scale;
2623 glyph->y_scale = size->root.metrics.y_scale;
2624 }
2625
2626 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
2627
2628 /* try to load embedded bitmap if any */
2629 /* */
2630 /* XXX: The convention should be emphasized in */
2631 /* the documents because it can be confusing. */
2632 if ( size )
2633 {
2634 CFF_Face cff_face = (CFF_Face)size->root.face;
2635 SFNT_Service sfnt = (SFNT_Service)cff_face->sfnt;
2636 FT_Stream stream = cff_face->root.stream;
2637
2638
2639 if ( size->strike_index != 0xFFFFFFFFUL &&
2640 sfnt->load_eblc &&
2641 ( load_flags & FT_LOAD_NO_BITMAP ) == 0 )
2642 {
2643 TT_SBit_MetricsRec metrics;
2644
2645
2646 error = sfnt->load_sbit_image( face,
2647 size->strike_index,
2648 glyph_index,
2649 (FT_Int)load_flags,
2650 stream,
2651 &glyph->root.bitmap,
2652 &metrics );
2653
2654 if ( !error )
2655 {
2656 glyph->root.outline.n_points = 0;
2657 glyph->root.outline.n_contours = 0;
2658
2659 glyph->root.metrics.width = (FT_Pos)metrics.width << 6;
2660 glyph->root.metrics.height = (FT_Pos)metrics.height << 6;
2661
2662 glyph->root.metrics.horiBearingX = (FT_Pos)metrics.horiBearingX << 6;
2663 glyph->root.metrics.horiBearingY = (FT_Pos)metrics.horiBearingY << 6;
2664 glyph->root.metrics.horiAdvance = (FT_Pos)metrics.horiAdvance << 6;
2665
2666 glyph->root.metrics.vertBearingX = (FT_Pos)metrics.vertBearingX << 6;
2667 glyph->root.metrics.vertBearingY = (FT_Pos)metrics.vertBearingY << 6;
2668 glyph->root.metrics.vertAdvance = (FT_Pos)metrics.vertAdvance << 6;
2669
2670 glyph->root.format = FT_GLYPH_FORMAT_BITMAP;
2671
2672 if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )
2673 {
2674 glyph->root.bitmap_left = metrics.vertBearingX;
2675 glyph->root.bitmap_top = metrics.vertBearingY;
2676 }
2677 else
2678 {
2679 glyph->root.bitmap_left = metrics.horiBearingX;
2680 glyph->root.bitmap_top = metrics.horiBearingY;
2681 }
2682 return error;
2683 }
2684 }
2685 }
2686
2687 #endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
2688
2689 /* return immediately if we only want the embedded bitmaps */
2690 if ( load_flags & FT_LOAD_SBITS_ONLY )
2691 return CFF_Err_Invalid_Argument;
2692
2693 /* if we have a CID subfont, use its matrix (which has already */
2694 /* been multiplied with the root matrix) */
2695
2696 /* this scaling is only relevant if the PS hinter isn't active */
2697 if ( cff->num_subfonts )
2698 {
2699 FT_ULong top_upm, sub_upm;
2700 FT_Byte fd_index = cff_fd_select_get( &cff->fd_select,
2701 glyph_index );
2702
2703 if ( fd_index >= cff->num_subfonts )
2704 fd_index = (FT_Byte)( cff->num_subfonts - 1 );
2705
2706 top_upm = cff->top_font.font_dict.units_per_em;
2707 sub_upm = cff->subfonts[fd_index]->font_dict.units_per_em;
2708
2709
2710 font_matrix = cff->subfonts[fd_index]->font_dict.font_matrix;
2711 font_offset = cff->subfonts[fd_index]->font_dict.font_offset;
2712
2713 if ( top_upm != sub_upm )
2714 {
2715 glyph->x_scale = FT_MulDiv( glyph->x_scale, top_upm, sub_upm );
2716 glyph->y_scale = FT_MulDiv( glyph->y_scale, top_upm, sub_upm );
2717
2718 force_scaling = TRUE;
2719 }
2720 }
2721 else
2722 {
2723 font_matrix = cff->top_font.font_dict.font_matrix;
2724 font_offset = cff->top_font.font_dict.font_offset;
2725 }
2726
2727 glyph->root.outline.n_points = 0;
2728 glyph->root.outline.n_contours = 0;
2729
2730 hinting = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE ) == 0 &&
2731 ( load_flags & FT_LOAD_NO_HINTING ) == 0 );
2732
2733 glyph->root.format = FT_GLYPH_FORMAT_OUTLINE; /* by default */
2734
2735 {
2736 FT_Byte* charstring;
2737 FT_ULong charstring_len;
2738
2739
2740 cff_decoder_init( &decoder, face, size, glyph, hinting,
2741 FT_LOAD_TARGET_MODE( load_flags ) );
2742
2743 if ( load_flags & FT_LOAD_ADVANCE_ONLY )
2744 decoder.width_only = TRUE;
2745
2746 decoder.builder.no_recurse =
2747 (FT_Bool)( load_flags & FT_LOAD_NO_RECURSE );
2748
2749 /* now load the unscaled outline */
2750 error = cff_get_glyph_data( face, glyph_index,
2751 &charstring, &charstring_len );
2752 if ( error )
2753 goto Glyph_Build_Finished;
2754
2755 error = cff_decoder_prepare( &decoder, size, glyph_index );
2756 if ( error )
2757 goto Glyph_Build_Finished;
2758
2759 error = cff_decoder_parse_charstrings( &decoder,
2760 charstring,
2761 charstring_len );
2762
2763 cff_free_glyph_data( face, &charstring, charstring_len );
2764
2765 if ( error )
2766 goto Glyph_Build_Finished;
2767
2768 #ifdef FT_CONFIG_OPTION_INCREMENTAL
2769 /* Control data and length may not be available for incremental */
2770 /* fonts. */
2771 if ( face->root.internal->incremental_interface )
2772 {
2773 glyph->root.control_data = 0;
2774 glyph->root.control_len = 0;
2775 }
2776 else
2777 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
2778
2779 /* We set control_data and control_len if charstrings is loaded. */
2780 /* See how charstring loads at cff_index_access_element() in */
2781 /* cffload.c. */
2782 {
2783 CFF_Index csindex = &cff->charstrings_index;
2784
2785
2786 if ( csindex->offsets )
2787 {
2788 glyph->root.control_data = csindex->bytes +
2789 csindex->offsets[glyph_index] - 1;
2790 glyph->root.control_len = charstring_len;
2791 }
2792 }
2793
2794 Glyph_Build_Finished:
2795 /* save new glyph tables, if no error */
2796 if ( !error )
2797 cff_builder_done( &decoder.builder );
2798 /* XXX: anything to do for broken glyph entry? */
2799 }
2800
2801 #ifdef FT_CONFIG_OPTION_INCREMENTAL
2802
2803 /* Incremental fonts can optionally override the metrics. */
2804 if ( !error &&
2805 face->root.internal->incremental_interface &&
2806 face->root.internal->incremental_interface->funcs->get_glyph_metrics )
2807 {
2808 FT_Incremental_MetricsRec metrics;
2809
2810
2811 metrics.bearing_x = decoder.builder.left_bearing.x;
2812 metrics.bearing_y = 0;
2813 metrics.advance = decoder.builder.advance.x;
2814 metrics.advance_v = decoder.builder.advance.y;
2815
2816 error = face->root.internal->incremental_interface->funcs->get_glyph_metrics(
2817 face->root.internal->incremental_interface->object,
2818 glyph_index, FALSE, &metrics );
2819
2820 decoder.builder.left_bearing.x = metrics.bearing_x;
2821 decoder.builder.advance.x = metrics.advance;
2822 decoder.builder.advance.y = metrics.advance_v;
2823 }
2824
2825 #endif /* FT_CONFIG_OPTION_INCREMENTAL */
2826
2827 if ( !error )
2828 {
2829 /* Now, set the metrics -- this is rather simple, as */
2830 /* the left side bearing is the xMin, and the top side */
2831 /* bearing the yMax. */
2832
2833 /* For composite glyphs, return only left side bearing and */
2834 /* advance width. */
2835 if ( load_flags & FT_LOAD_NO_RECURSE )
2836 {
2837 FT_Slot_Internal internal = glyph->root.internal;
2838
2839
2840 glyph->root.metrics.horiBearingX = decoder.builder.left_bearing.x;
2841 glyph->root.metrics.horiAdvance = decoder.glyph_width;
2842 internal->glyph_matrix = font_matrix;
2843 internal->glyph_delta = font_offset;
2844 internal->glyph_transformed = 1;
2845 }
2846 else
2847 {
2848 FT_BBox cbox;
2849 FT_Glyph_Metrics* metrics = &glyph->root.metrics;
2850 FT_Vector advance;
2851 FT_Bool has_vertical_info;
2852
2853
2854 /* copy the _unscaled_ advance width */
2855 metrics->horiAdvance = decoder.glyph_width;
2856 glyph->root.linearHoriAdvance = decoder.glyph_width;
2857 glyph->root.internal->glyph_transformed = 0;
2858
2859 #ifdef FT_CONFIG_OPTION_OLD_INTERNALS
2860 has_vertical_info = FT_BOOL( face->vertical_info &&
2861 face->vertical.number_Of_VMetrics > 0 &&
2862 face->vertical.long_metrics );
2863 #else
2864 has_vertical_info = FT_BOOL( face->vertical_info &&
2865 face->vertical.number_Of_VMetrics > 0 );
2866 #endif
2867
2868 /* get the vertical metrics from the vtmx table if we have one */
2869 if ( has_vertical_info )
2870 {
2871 FT_Short vertBearingY = 0;
2872 FT_UShort vertAdvance = 0;
2873
2874
2875 ( (SFNT_Service)face->sfnt )->get_metrics( face, 1,
2876 glyph_index,
2877 &vertBearingY,
2878 &vertAdvance );
2879 metrics->vertBearingY = vertBearingY;
2880 metrics->vertAdvance = vertAdvance;
2881 }
2882 else
2883 {
2884 /* make up vertical ones */
2885 if ( face->os2.version != 0xFFFFU )
2886 metrics->vertAdvance = (FT_Pos)( face->os2.sTypoAscender -
2887 face->os2.sTypoDescender );
2888 else
2889 metrics->vertAdvance = (FT_Pos)( face->horizontal.Ascender -
2890 face->horizontal.Descender );
2891 }
2892
2893 glyph->root.linearVertAdvance = metrics->vertAdvance;
2894
2895 glyph->root.format = FT_GLYPH_FORMAT_OUTLINE;
2896
2897 glyph->root.outline.flags = 0;
2898 if ( size && size->root.metrics.y_ppem < 24 )
2899 glyph->root.outline.flags |= FT_OUTLINE_HIGH_PRECISION;
2900
2901 glyph->root.outline.flags |= FT_OUTLINE_REVERSE_FILL;
2902
2903 if ( !( font_matrix.xx == 0x10000L &&
2904 font_matrix.yy == 0x10000L &&
2905 font_matrix.xy == 0 &&
2906 font_matrix.yx == 0 ) )
2907 FT_Outline_Transform( &glyph->root.outline, &font_matrix );
2908
2909 if ( !( font_offset.x == 0 &&
2910 font_offset.y == 0 ) )
2911 FT_Outline_Translate( &glyph->root.outline,
2912 font_offset.x, font_offset.y );
2913
2914 advance.x = metrics->horiAdvance;
2915 advance.y = 0;
2916 FT_Vector_Transform( &advance, &font_matrix );
2917 metrics->horiAdvance = advance.x + font_offset.x;
2918
2919 advance.x = 0;
2920 advance.y = metrics->vertAdvance;
2921 FT_Vector_Transform( &advance, &font_matrix );
2922 metrics->vertAdvance = advance.y + font_offset.y;
2923
2924 if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 || force_scaling )
2925 {
2926 /* scale the outline and the metrics */
2927 FT_Int n;
2928 FT_Outline* cur = &glyph->root.outline;
2929 FT_Vector* vec = cur->points;
2930 FT_Fixed x_scale = glyph->x_scale;
2931 FT_Fixed y_scale = glyph->y_scale;
2932
2933
2934 /* First of all, scale the points */
2935 if ( !hinting || !decoder.builder.hints_funcs )
2936 for ( n = cur->n_points; n > 0; n--, vec++ )
2937 {
2938 vec->x = FT_MulFix( vec->x, x_scale );
2939 vec->y = FT_MulFix( vec->y, y_scale );
2940 }
2941
2942 /* Then scale the metrics */
2943 metrics->horiAdvance = FT_MulFix( metrics->horiAdvance, x_scale );
2944 metrics->vertAdvance = FT_MulFix( metrics->vertAdvance, y_scale );
2945 }
2946
2947 /* compute the other metrics */
2948 FT_Outline_Get_CBox( &glyph->root.outline, &cbox );
2949
2950 metrics->width = cbox.xMax - cbox.xMin;
2951 metrics->height = cbox.yMax - cbox.yMin;
2952
2953 metrics->horiBearingX = cbox.xMin;
2954 metrics->horiBearingY = cbox.yMax;
2955
2956 if ( has_vertical_info )
2957 metrics->vertBearingX = metrics->horiBearingX -
2958 metrics->horiAdvance / 2;
2959 else
2960 {
2961 if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )
2962 ft_synthesize_vertical_metrics( metrics,
2963 metrics->vertAdvance );
2964 }
2965 }
2966 }
2967
2968 return error;
2969 }
2970
2971
2972 /* END */
cff_op_store
Definition: cffgload.c:97
PSH_Globals
typedefFT_BEGIN_HEADER struct PSH_GlobalsRec_ * PSH_Globals
Definition: pshints.h:41
cff_op_hstemhm
Definition: cffgload.c:71
FT_Error
int FT_Error
Definition: fttypes.h:296
FT_Incremental_MetricsRec_::bearing_y
FT_Long bearing_y
Definition: ftincrem.h:118
cff_get_standard_encoding
cff_get_standard_encoding(FT_UInt charcode)
Definition: cffload.c:183
CFF_Builder_::base
FT_Outline * base
Definition: cffgload.h:87
CFF_Builder_::metrics_only
FT_Bool metrics_only
Definition: cffgload.h:101
FT_LOAD_VERTICAL_LAYOUT
#define FT_LOAD_VERTICAL_LAYOUT
Definition: freetype.h:2516
FT_DivFix
FT_DivFix(FT_Long a, FT_Long b)
Definition: ftcalc.c:536
CFF_Builder_::loader
FT_GlyphLoader loader
Definition: cffgload.h:86
cff_op_and
Definition: cffgload.c:100
TT_FaceRec_::sfnt
void * sfnt
Definition: tttypes.h:1298
FT_PtrDist
ft_ptrdiff_t FT_PtrDist
Definition: fttypes.h:333
val
GLuint const GLfloat * val
Definition: glew.h:2715
CFF_Decoder_
Definition: cffgload.h:120
cff_op_hintmask
Definition: cffgload.c:74
SFNT_Service
SFNT_Interface * SFNT_Service
Definition: sfnt.h:754
TT_FaceRec_::os2
TT_OS2 os2
Definition: tttypes.h:1282
cff_op_flex1
Definition: cffgload.c:65
cff_builder_close_contour
static void cff_builder_close_contour(CFF_Builder *builder)
Definition: cffgload.c:566
cff_op_sub
Definition: cffgload.c:80
FT_ULong
unsigned long FT_ULong
Definition: fttypes.h:249
FT_LOAD_SBITS_ONLY
#define FT_LOAD_SBITS_ONLY
Definition: freetype.h:2531
FT_Pos
FT_BEGIN_HEADER typedef signed long FT_Pos
Definition: ftimage.h:59
CFF_MAX_TRANS_ELEMENTS
#define CFF_MAX_TRANS_ELEMENTS
Definition: cffgload.h:33
FT_GlyphSlotRec_
Definition: freetype.h:1605
cff_op_index
Definition: cffgload.c:91
cff_op_hlineto
Definition: cffgload.c:51
ft_synthesize_vertical_metrics
ft_synthesize_vertical_metrics(FT_Glyph_Metrics *metrics, FT_Pos advance)
Definition: ftobjs.c:2530
TT_OS2_::version
FT_UShort version
Definition: tttables.h:352
cff_op_max
Definition: cffgload.c:120
FT_SubGlyphRec_
Definition: ftgloadr.h:57
FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES
#define FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES
Definition: freetype.h:3218
cff_op_rrcurveto
Definition: cffgload.c:54
TT_SBit_MetricsRec_::horiBearingY
FT_Char horiBearingY
Definition: tttypes.h:441
FT_MEM_ZERO
#define FT_MEM_ZERO(dest, count)
Definition: ftmemory.h:208
CFF_Builder_
Definition: cffgload.h:81
FT_SUBGLYPH_FLAG_USE_MY_METRICS
#define FT_SUBGLYPH_FLAG_USE_MY_METRICS
Definition: freetype.h:3223
CFF_Decoder_::builder
CFF_Builder builder
Definition: cffgload.h:122
cff_op_not
Definition: cffgload.c:102
CFF_MAX_SUBRS_CALLS
#define CFF_MAX_SUBRS_CALLS
Definition: cffgload.h:32
FT_CURVE_TAG_CUBIC
#define FT_CURVE_TAG_CUBIC
Definition: ftimage.h:518
TT_OS2_::sTypoDescender
FT_Short sTypoDescender
Definition: tttables.h:382
FT_Matrix_::xy
FT_Fixed xy
Definition: fttypes.h:383
cff_builder_init
static void cff_builder_init(CFF_Builder *builder, TT_Face face, CFF_Size size, CFF_GlyphSlot glyph, FT_Bool hinting)
Definition: cffgload.c:247
FT_Int
signed int FT_Int
Definition: fttypes.h:216
cff_op_exch
Definition: cffgload.c:90
FT_Outline_::n_contours
short n_contours
Definition: ftimage.h:385
FT_Data_::pointer
const FT_Byte * pointer
Definition: fttypes.h:404
cff_op_hvcurveto
Definition: cffgload.c:56
cff_op_rcurveline
Definition: cffgload.c:57
T2_Hints_FuncsRec_::hints
T2_Hints hints
Definition: pshints.h:658
cff_op_vhcurveto
Definition: cffgload.c:59
FT_ULONG_MAX
#define FT_ULONG_MAX
Definition: ftstdlib.h:67
FT_Render_Mode
enum FT_Render_Mode_ FT_Render_Mode
TT_SBit_MetricsRec_::horiAdvance
FT_Byte horiAdvance
Definition: tttypes.h:442
FT_Data_::length
FT_Int length
Definition: fttypes.h:405
FT_Matrix_
Definition: fttypes.h:381
stream
GLuint GLuint stream
Definition: glew.h:6573
n
GLclampd n
Definition: glew.h:7287
FT_LOAD_NO_HINTING
#define FT_LOAD_NO_HINTING
Definition: freetype.h:2513
FT_Outline_::contours
short * contours
Definition: ftimage.h:390
CFF_Face
TT_Face CFF_Face
Definition: cffobjs.h:44
x
EGLSurface EGLint x
Definition: eglext.h:293
FT_Outline_::tags
char * tags
Definition: ftimage.h:389
metrics
GLuint GLsizei GLsizei GLfloat * metrics
Definition: glew.h:12394
CFF_FontRecDictRec_::charstring_type
FT_Int charstring_type
Definition: cfftypes.h:118
CFF_Font
struct CFF_FontRec_ * CFF_Font
cff_operator_seac
static FT_Error cff_operator_seac(CFF_Decoder *decoder, FT_Pos asb, FT_Pos adx, FT_Pos ady, FT_Int bchar, FT_Int achar)
Definition: cffgload.c:711
FT_LOAD_NO_RECURSE
#define FT_LOAD_NO_RECURSE
Definition: freetype.h:2521
CFF_FontRec_::subfonts
CFF_SubFont subfonts[CFF_MAX_CID_FONTS]
Definition: cfftypes.h:256
FT_Outline_
Definition: ftimage.h:383
CFF_FontRec_::global_subrs_index
CFF_IndexRec global_subrs_index
Definition: cfftypes.h:234
T2_Hints_FuncsRec_::stems
T2_Hints_StemsFunc stems
Definition: pshints.h:661
cff_builder_start_point
static FT_Error cff_builder_start_point(CFF_Builder *builder, FT_Pos x, FT_Pos y)
Definition: cffgload.c:544
cff_op_vlineto
Definition: cffgload.c:52
cff_op_roll
Definition: cffgload.c:92
FT_LOAD_ADVANCE_ONLY
#define FT_LOAD_ADVANCE_ONLY
Definition: freetype.h:2530
cff_decoder_parse_charstrings
cff_decoder_parse_charstrings(CFF_Decoder *decoder, FT_Byte *charstring_base, FT_ULong charstring_len)
Definition: cffgload.c:883
CFF_GlyphSlotRec_::root
FT_GlyphSlotRec root
Definition: cffobjs.h:73
CFF_Decoder_Zone_::limit
FT_Byte * limit
Definition: cffgload.h:114
cff_op_setcurrentpoint
Definition: cffgload.c:117
if
if(!yyg->yy_init)
Definition: glslang_lex.cpp:1037
FT_Bool
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:104
FT_LOAD_NO_SCALE
#define FT_LOAD_NO_SCALE
Definition: freetype.h:2512
FT_FaceRec_::internal
FT_Face_Internal internal
Definition: freetype.h:964
cff_op_sbw
Definition: cffgload.c:116
CFF_FontRecDictRec_::font_offset
FT_Vector font_offset
Definition: cfftypes.h:122
cff_builder_add_contour
static FT_Error cff_builder_add_contour(CFF_Builder *builder)
Definition: cffgload.c:516
CFF_Decoder_::glyph_width
FT_Pos glyph_width
Definition: cffgload.h:135
CFF_Decoder_Zone_::base
FT_Byte * base
Definition: cffgload.h:113
FT_GlyphSlotRec_::outline
FT_Outline outline
Definition: freetype.h:1624
pointer
GLsizei const GLvoid * pointer
Definition: glew.h:1509
cff_argument_counts
static const FT_Byte cff_argument_counts[]
Definition: cffgload.c:135
FT_GlyphLoader
typedefFT_BEGIN_HEADER struct FT_GlyphLoaderRec_ * FT_GlyphLoader
Definition: ftgloadr.h:43
CFF_FontRec_
Definition: cfftypes.h:219
cff_op_pop
Definition: cffgload.c:114
FT_ERROR
#define FT_ERROR(varformat)
Definition: ftdebug.h:181
CFF_GlyphSlotRec_
Definition: cffobjs.h:71
cff_fd_select_get
cff_fd_select_get(CFF_FDSelect fdselect, FT_UInt glyph_index)
Definition: cffload.c:708
FT_Byte
unsigned char FT_Byte
Definition: fttypes.h:150
cff_op_endchar
Definition: cffgload.c:67
cff_op_eq
Definition: cffgload.c:103
cff_op_add
Definition: cffgload.c:79
CFF_Operator_
CFF_Operator_
Definition: cffgload.c:42
cff_op_hstem
Definition: cffgload.c:69
cff_index_access_element
cff_index_access_element(CFF_Index idx, FT_UInt element, FT_Byte **pbytes, FT_ULong *pbyte_len)
Definition: cffload.c:469
CFF_Internal
struct CFF_InternalRec_ * CFF_Internal
FT_SizeRec_::internal
FT_Size_Internal internal
Definition: freetype.h:1400
FT_TRACE4
#define FT_TRACE4(varformat)
Definition: ftdebug.h:161
CFF_Builder_::no_recurse
FT_Bool no_recurse
Definition: cffgload.h:99
TT_HoriHeader_::Descender
FT_Short Descender
Definition: tttables.h:184
cff_op_dup
Definition: cffgload.c:93
FT_Outline_Get_CBox
FT_Outline_Get_CBox(const FT_Outline *outline, FT_BBox *acbox)
Definition: ftoutln.c:460
FT_GlyphLoader_Add
FT_GlyphLoader_Add(FT_GlyphLoader loader)
Definition: ftgloadr.c:323
CFF_Builder_::left_bearing
FT_Vector left_bearing
Definition: cffgload.h:93
CFF_FontRec_::num_subfonts
FT_UInt num_subfonts
Definition: cfftypes.h:255
CFF_FontRec_::global_subrs
FT_Byte ** global_subrs
Definition: cfftypes.h:247
CFF_Builder_::current
FT_Outline * current
Definition: cffgload.h:88
cff_op_vvcurveto
Definition: cffgload.c:60
cff_op_unknown
Definition: cffgload.c:44
CFF_SubFontRec_::font_dict
CFF_FontRecDictRec font_dict
Definition: cfftypes.h:207
TT_SBit_MetricsRec_::horiBearingX
FT_Char horiBearingX
Definition: tttypes.h:440
cff_decoder_prepare
cff_decoder_prepare(CFF_Decoder *decoder, CFF_Size size, FT_UInt glyph_index)
Definition: cffgload.c:408
cff
CFF_Font cff
Definition: cffdrivr.c:448
FT_Outline_Transform
FT_Outline_Transform(const FT_Outline *outline, const FT_Matrix *matrix)
Definition: ftoutln.c:695
TT_HoriHeader_::Ascender
FT_Short Ascender
Definition: tttables.h:183
cff_op_callgsubr
Definition: cffgload.c:107
first
GLint first
Definition: gl2ext.h:1011
result
GLuint64EXT * result
Definition: glew.h:12708
FT_BBox_::yMax
FT_Pos yMax
Definition: ftimage.h:119
FT_LOCAL_DEF
#define FT_LOCAL_DEF(x)
Definition: ftconfig.h:467
cff_op_neg
Definition: cffgload.c:82
FT_BBox_::xMin
FT_Pos xMin
Definition: ftimage.h:118
cff_decoder_init
cff_decoder_init(CFF_Decoder *decoder, TT_Face face, CFF_Size size, CFF_GlyphSlot slot, FT_Bool hinting, FT_Render_Mode hint_mode)
Definition: cffgload.c:377
TT_Face
struct TT_FaceRec_ * TT_Face
Definition: tttypes.h:951
cff_op_or
Definition: cffgload.c:101
cff_op_rlineto
Definition: cffgload.c:50
v
const GLdouble * v
Definition: glew.h:1377
CFF_COUNT_CHECK_WIDTH
#define CFF_COUNT_CHECK_WIDTH
Definition: cffgload.c:125
cff_op_random
Definition: cffgload.c:83
T2_Hints_FuncsRec_::counter
T2_Hints_CounterFunc counter
Definition: pshints.h:663
TT_SBit_MetricsRec_::height
FT_Byte height
Definition: tttypes.h:437
cffload.h
CFF_FontRec_::fd_select
CFF_FDSelectRec fd_select
Definition: cfftypes.h:258
FT_GlyphLoader_CheckSubGlyphs
FT_GlyphLoader_CheckSubGlyphs(FT_GlyphLoader loader, FT_UInt n_subs)
Definition: ftgloadr.c:276
idx
FT_UInt idx
Definition: cffcmap.c:125
CFF_SizeRec_::root
FT_SizeRec root
Definition: cffobjs.h:57
length
GLsizei GLsizei * length
Definition: gl2ext.h:792
FT_MulDiv
FT_MulDiv(FT_Long a, FT_Long b, FT_Long c)
Definition: ftcalc.c:358
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl2ext.h:848
T2_Hints_FuncsRec_
Definition: pshints.h:656
error
FT_Error error
Definition: cffdrivr.c:407
TT_SBit_MetricsRec_::vertBearingX
FT_Char vertBearingX
Definition: tttypes.h:444
cff_op_vmoveto
Definition: cffgload.c:48
FT_GlyphSlotRec_::num_subglyphs
FT_UInt num_subglyphs
Definition: freetype.h:1626
FT_Vector_::x
FT_Pos x
Definition: ftimage.h:77
CFF_InternalRec_
Definition: cffobjs.h:92
cff_op_abs
Definition: cffgload.c:78
cff_op_rlinecurve
Definition: cffgload.c:58
cfferrs.h
T2_Hints_FuncsRec_::apply
T2_Hints_ApplyFunc apply
Definition: pshints.h:664
TT_VertHeader_::number_Of_VMetrics
FT_UShort number_Of_VMetrics
Definition: tttables.h:325
FT_OUTLINE_HIGH_PRECISION
#define FT_OUTLINE_HIGH_PRECISION
Definition: ftimage.h:482
count
GLint GLsizei count
Definition: gl2ext.h:1011
face
GLenum face
Definition: gl2ext.h:1490
FT_Vector_::y
FT_Pos y
Definition: ftimage.h:78
TT_FaceRec_::vertical_info
FT_Bool vertical_info
Definition: tttypes.h:1276
CFF_FontRec_::top_font
CFF_SubFontRec top_font
Definition: cfftypes.h:254
cff_op_dotsection
Definition: cffgload.c:76
TT_SBit_MetricsRec_::vertBearingY
FT_Char vertBearingY
Definition: tttypes.h:445
check_points
static FT_Error check_points(CFF_Builder *builder, FT_Int count)
Definition: cffgload.c:465
CFF_MAX_OPERANDS
#define CFF_MAX_OPERANDS
Definition: cffgload.h:31
limit
GLint limit
Definition: glew.h:11829
cff_op_drop
Definition: cffgload.c:89
FT_Slot_InternalRec_::loader
FT_GlyphLoader loader
Definition: ftobjs.h:380
cff_op_load
Definition: cffgload.c:98
CFF_Builder_::memory
FT_Memory memory
Definition: cffgload.h:83
FT_Vector_
Definition: ftimage.h:75
TT_FaceRec_::vertical
TT_VertHeader vertical
Definition: tttypes.h:1277
TT_SBit_MetricsRec_::width
FT_Byte width
Definition: tttypes.h:438
CFF_CharsetRec_::cids
FT_UShort * cids
Definition: cfftypes.h:97
FT_Incremental_MetricsRec_::bearing_x
FT_Long bearing_x
Definition: ftincrem.h:117
vec
FT_Vector * vec
Definition: ftbbox.c:579
cff_op_div
Definition: cffgload.c:81
FT_Incremental_MetricsRec_::advance
FT_Long advance
Definition: ftincrem.h:119
FT_GlyphSlotRec_::subglyphs
FT_SubGlyph subglyphs
Definition: freetype.h:1627
cff_op_hflex1
Definition: cffgload.c:64
FT_Slot_InternalRec_::glyph_hints
void * glyph_hints
Definition: ftobjs.h:385
top
GLfloat GLfloat GLfloat top
Definition: glew.h:13816
CFF_Decoder_::width_only
FT_Bool width_only
Definition: cffgload.h:139
CFF_COUNT_CLEAR_STACK
#define CFF_COUNT_CLEAR_STACK
Definition: cffgload.c:127
cff_op_closepath
Definition: cffgload.c:112
FALSE
#define FALSE
Definition: ftobjs.h:57
FT_BBox_::xMax
FT_Pos xMax
Definition: ftimage.h:119
cff_slot_load
cff_slot_load(CFF_GlyphSlot glyph, CFF_Size size, FT_UInt glyph_index, FT_Int32 load_flags)
Definition: cffgload.c:2580
CFF_Builder_::path_begun
FT_Bool path_begun
Definition: cffgload.h:97
cff_op_put
Definition: cffgload.c:95
FT_Outline_::n_points
short n_points
Definition: ftimage.h:386
CFF_Builder_::hints_globals
void * hints_globals
Definition: cffgload.h:104
T2_Hints_FuncsRec_::open
T2_Hints_OpenFunc open
Definition: pshints.h:659
CFF_Builder_::glyph
CFF_GlyphSlot glyph
Definition: cffgload.h:85
FT_Short
signed short FT_Short
Definition: fttypes.h:194
cff_get_glyph_data
static FT_Error cff_get_glyph_data(TT_Face face, FT_UInt glyph_index, FT_Byte **pointer, FT_ULong *length)
Definition: cffgload.c:640
FT_Matrix_::xx
FT_Fixed xx
Definition: fttypes.h:383
FT_BOOL
#define FT_BOOL(x)
Definition: fttypes.h:581
CFF_Builder_::pos_x
FT_Pos pos_x
Definition: cffgload.h:90
cff_op_hmoveto
Definition: cffgload.c:47
cff_op_hsbw
Definition: cffgload.c:111
cff_free_glyph_data
static void cff_free_glyph_data(TT_Face face, FT_Byte **pointer, FT_ULong length)
Definition: cffgload.c:676
TT_FaceRec_::root
FT_FaceRec root
Definition: tttypes.h:1260
TT_FaceRec_::horizontal
TT_HoriHeader horizontal
Definition: tttypes.h:1269
cff_op_hhcurveto
Definition: cffgload.c:55
y
EGLSurface EGLint EGLint y
Definition: eglext.h:293
cff_builder_done
static void cff_builder_done(CFF_Builder *builder)
Definition: cffgload.c:307
FT_MulFix
FT_MulFix(FT_Long a, FT_Long b)
Definition: ftcalc.c:435
FT_Generic_::data
void * data
Definition: fttypes.h:457
cff_builder_add_point1
static FT_Error cff_builder_add_point1(CFF_Builder *builder, FT_Pos x, FT_Pos y)
Definition: cffgload.c:499
FT_TRACE3
#define FT_TRACE3(varformat)
Definition: ftdebug.h:160
TT_FaceRec_::extra
FT_Generic extra
Definition: tttypes.h:1382
cff_op_flex
Definition: cffgload.c:62
TT_SBit_MetricsRec_
Definition: tttypes.h:435
CFF_Decoder_Zone_
Definition: cffgload.h:111
FT_Matrix_::yx
FT_Fixed yx
Definition: fttypes.h:384
ft2build.h
FT_Vector_Transform
FT_Vector_Transform(FT_Vector *vec, const FT_Matrix *matrix)
Definition: ftoutln.c:672
FT_Fixed
signed long FT_Fixed
Definition: fttypes.h:284
cff_op_hflex
Definition: cffgload.c:63
FT_Glyph_Metrics
FT_BEGIN_HEADER struct FT_Glyph_Metrics_ FT_Glyph_Metrics
FT_GlyphSlotRec_::format
FT_Glyph_Format format
Definition: freetype.h:1618
T2_Hints_Funcs
struct T2_Hints_FuncsRec_ * T2_Hints_Funcs
Definition: pshints.h:404
CFF_Decoder_::seac
FT_Bool seac
Definition: cffgload.h:157
cff_op_mul
Definition: cffgload.c:84
cff_compute_bias
static FT_Int cff_compute_bias(FT_Int in_charstring_type, FT_UInt num_subrs)
Definition: cffgload.c:335
cff_builder_add_point
static void cff_builder_add_point(CFF_Builder *builder, FT_Pos x, FT_Pos y, FT_Byte flag)
Definition: cffgload.c:474
CFF_Decoder_Zone_::cursor
FT_Byte * cursor
Definition: cffgload.h:115
TT_OS2_::sTypoAscender
FT_Short sTypoAscender
Definition: tttables.h:381
FT_UInt
unsigned int FT_UInt
Definition: fttypes.h:227
FT_GlyphSlot
struct FT_GlyphSlotRec_ * FT_GlyphSlot
Definition: freetype.h:450
CFF_FontRecDictRec_::units_per_em
FT_ULong units_per_em
Definition: cfftypes.h:121
CFF_FontRecDictRec_::font_matrix
FT_Matrix font_matrix
Definition: cfftypes.h:119
FT_GlyphLoader_Rewind
FT_GlyphLoader_Rewind(FT_GlyphLoader loader)
Definition: ftgloadr.c:87
FT_Data_
Definition: fttypes.h:402
cff_op_callsubr
Definition: cffgload.c:106
cff_lookup_glyph_by_stdcharcode
static FT_Int cff_lookup_glyph_by_stdcharcode(CFF_Font cff, FT_Int charcode)
Definition: cffgload.c:611
FT_GlyphSlotRec_::internal
FT_Slot_Internal internal
Definition: freetype.h:1637
CFF_SubFontRec_
Definition: cfftypes.h:205
FT_Incremental_MetricsRec_::advance_v
FT_Long advance_v
Definition: ftincrem.h:120
cff_charset_cid_to_gindex
cff_charset_cid_to_gindex(CFF_Charset charset, FT_UInt cid)
Definition: cffload.c:816
cff_op_blend
Definition: cffgload.c:87
cffobjs.h
cffgload.h
FT_Slot_InternalRec_
Definition: ftobjs.h:378
CFF_Builder_::face
TT_Face face
Definition: cffgload.h:84
cff_op_vstemhm
Definition: cffgload.c:72
FT_Outline_Translate
FT_Outline_Translate(const FT_Outline *outline, FT_Pos xOffset, FT_Pos yOffset)
Definition: ftoutln.c:510
FT_GlyphLoader_Prepare
FT_GlyphLoader_Prepare(FT_GlyphLoader loader)
Definition: ftgloadr.c:307
FT_CURVE_TAG_ON
#define FT_CURVE_TAG_ON
Definition: ftimage.h:516
cff_op_callothersubr
Definition: cffgload.c:113
CFF_FontRec_::charstrings_index
CFF_IndexRec charstrings_index
Definition: cfftypes.h:239
FT_Matrix_::yy
FT_Fixed yy
Definition: fttypes.h:384
cff_op_ifelse
Definition: cffgload.c:104
cff_op_sqrt
Definition: cffgload.c:85
i
int i
Definition: pngrutil.c:1377
CFF_Builder_::advance
FT_Vector advance
Definition: cffgload.h:94
CFF_FontRec_::num_glyphs
FT_UInt num_glyphs
Definition: cfftypes.h:224
FT_LOAD_NO_BITMAP
#define FT_LOAD_NO_BITMAP
Definition: freetype.h:2515
CFF_CharsetRec_::sids
FT_UShort * sids
Definition: cfftypes.h:96
cff_op_return
Definition: cffgload.c:108
FT_UShort
unsigned short FT_UShort
Definition: fttypes.h:205
FT_GLYPHLOADER_CHECK_POINTS
#define FT_GLYPHLOADER_CHECK_POINTS(_loader, _points, _contours)
Definition: ftgloadr.h:134
cff_op_seac
Definition: cffgload.c:115
FT_StreamRec_
Definition: ftsystem.h:321
FT_BBox_::yMin
FT_Pos yMin
Definition: ftimage.h:118
CFF_Operator
enum CFF_Operator_ CFF_Operator
FT_FaceRec_::stream
FT_Stream stream
Definition: freetype.h:957
FT_BBox_
Definition: ftimage.h:116
TT_FaceRec_
Definition: tttypes.h:1258
CFF_Builder_::load_points
FT_Bool load_points
Definition: cffgload.h:98
CFF_COUNT_EXACT
#define CFF_COUNT_EXACT
Definition: cffgload.c:126
FT_UNUSED
#define FT_UNUSED(arg)
Definition: ftconfig.h:101
cff_op_get
Definition: cffgload.c:96
TRUE
#define TRUE
Definition: ftobjs.h:53
T2_Hints_FuncsRec_::close
T2_Hints_CloseFunc close
Definition: pshints.h:660
FT_Outline_::points
FT_Vector * points
Definition: ftimage.h:388
SFNT_Interface_
Definition: sfnt.h:649
CFF_FontRecDictRec_::cid_registry
FT_UInt cid_registry
Definition: cfftypes.h:135
CFF_FontRec_::charset
CFF_CharsetRec charset
Definition: cfftypes.h:237
cff_op_rmoveto
Definition: cffgload.c:46
cff_op_cntrmask
Definition: cffgload.c:75
FT_GLYPH_FORMAT_OUTLINE
FT_Module_Constructor FT_GLYPH_FORMAT_OUTLINE
Definition: ftrend1.c:283
CFF_Builder_::pos_y
FT_Pos pos_y
Definition: cffgload.h:91
TT_SBit_MetricsRec_::vertAdvance
FT_Byte vertAdvance
Definition: tttypes.h:446
cff_index_forget_element
cff_index_forget_element(CFF_Index idx, FT_Byte **pbytes)
Definition: cffload.c:567
FT_FaceRec_::memory
FT_Memory memory
Definition: freetype.h:956
T2_Hints_FuncsRec_::hintmask
T2_Hints_MaskFunc hintmask
Definition: pshints.h:662
CFF_SizeRec_
Definition: cffobjs.h:55
TT_VertHeader_::long_metrics
void * long_metrics
Definition: tttables.h:331
FT_Incremental_MetricsRec_
Definition: ftincrem.h:115
CFF_Builder_::hints_funcs
void * hints_funcs
Definition: cffgload.h:103
cff_op_vstem
Definition: cffgload.c:70
FT_OUTLINE_REVERSE_FILL
#define FT_OUTLINE_REVERSE_FILL
Definition: ftimage.h:477
CFF_Index
FT_BEGIN_HEADER struct CFF_IndexRec_ * CFF_Index
FT_LOAD_TARGET_MODE
#define FT_LOAD_TARGET_MODE(x)
Definition: freetype.h:2617
size
GLsizei size
Definition: gl2ext.h:1467