]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/freetype/type1z/z1gload.c
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Fixed the drawing of the HRules so they don't try to iterate over all
[wxWidgets.git] / src / freetype / type1z / z1gload.c
... / ...
CommitLineData
1/***************************************************************************/
2/* */
3/* z1gload.c */
4/* */
5/* Experimental Type 1 Glyph Loader (body). */
6/* */
7/* Copyright 1996-2000 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#ifdef FT_FLAT_COMPILE
20
21#include "z1gload.h"
22
23#else
24
25#include <type1z/z1gload.h>
26
27#endif
28
29
30#include <freetype/internal/ftdebug.h>
31#include <freetype/internal/ftstream.h>
32#include <freetype/ftoutln.h>
33
34#include <string.h> /* for strcmp() */
35
36
37 /*************************************************************************/
38 /* */
39 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
40 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
41 /* messages during execution. */
42 /* */
43#undef FT_COMPONENT
44#define FT_COMPONENT trace_z1gload
45
46
47 typedef enum Z1_Operator_
48 {
49 op_none = 0,
50 op_endchar,
51 op_hsbw,
52 op_seac,
53 op_sbw,
54 op_closepath,
55 op_hlineto,
56 op_hmoveto,
57 op_hvcurveto,
58 op_rlineto,
59 op_rmoveto,
60 op_rrcurveto,
61 op_vhcurveto,
62 op_vlineto,
63 op_vmoveto,
64 op_dotsection,
65 op_hstem,
66 op_hstem3,
67 op_vstem,
68 op_vstem3,
69 op_div,
70 op_callothersubr,
71 op_callsubr,
72 op_pop,
73 op_return,
74 op_setcurrentpoint,
75
76 op_max /* never remove this one */
77
78 } Z1_Operator;
79
80 static
81 const FT_Int t1_args_count[op_max] =
82 {
83 0, /* none */
84 0, /* endchar */
85 2, /* hsbw */
86 5, /* seac */
87 4, /* sbw */
88 0, /* closepath */
89 1, /* hlineto */
90 1, /* hmoveto */
91 4, /* hvcurveto */
92 2, /* rlineto */
93 2, /* rmoveto */
94 6, /* rrcurveto */
95 4, /* vhcurveto */
96 1, /* vlineto */
97 1, /* vmoveto */
98 0, /* dotsection */
99 2, /* hstem */
100 6, /* hstem3 */
101 2, /* vstem */
102 6, /* vstem3 */
103 2, /* div */
104 -1, /* callothersubr */
105 1, /* callsubr */
106 0, /* pop */
107 0, /* return */
108 2 /* setcurrentpoint */
109 };
110
111
112 /*************************************************************************/
113 /*************************************************************************/
114 /*************************************************************************/
115 /********** *********/
116 /********** *********/
117 /********** GENERIC CHARSTRING PARSING *********/
118 /********** *********/
119 /********** *********/
120 /*************************************************************************/
121 /*************************************************************************/
122 /*************************************************************************/
123
124
125 /*************************************************************************/
126 /* */
127 /* <Function> */
128 /* Z1_Init_Builder */
129 /* */
130 /* <Description> */
131 /* Initializes a given glyph builder. */
132 /* */
133 /* <InOut> */
134 /* builder :: A pointer to the glyph builder to initialize. */
135 /* */
136 /* <Input> */
137 /* face :: The current face object. */
138 /* */
139 /* size :: The current size object. */
140 /* */
141 /* glyph :: The current glyph object. */
142 /* */
143 LOCAL_FUNC
144 void Z1_Init_Builder( Z1_Builder* builder,
145 T1_Face face,
146 Z1_Size size,
147 Z1_GlyphSlot glyph )
148 {
149 builder->path_begun = 0;
150 builder->load_points = 1;
151
152 builder->face = face;
153 builder->glyph = glyph;
154 builder->memory = face->root.memory;
155
156 if ( glyph )
157 {
158 FT_GlyphLoader* loader = glyph->root.loader;
159
160
161 builder->loader = loader;
162 builder->current = &loader->current.outline;
163 builder->base = &loader->base.outline;
164
165 FT_GlyphLoader_Rewind( loader );
166 }
167
168 if ( size )
169 {
170 builder->scale_x = size->root.metrics.x_scale;
171 builder->scale_y = size->root.metrics.y_scale;
172 }
173
174 builder->pos_x = 0;
175 builder->pos_y = 0;
176
177 builder->left_bearing.x = 0;
178 builder->left_bearing.y = 0;
179 builder->advance.x = 0;
180 builder->advance.y = 0;
181 }
182
183
184 /*************************************************************************/
185 /* */
186 /* <Function> */
187 /* Z1_Done_Builder */
188 /* */
189 /* <Description> */
190 /* Finalizes a given glyph builder. Its contents can still be used */
191 /* after the call, but the function saves important information */
192 /* within the corresponding glyph slot. */
193 /* */
194 /* <Input> */
195 /* builder :: A pointer to the glyph builder to finalize. */
196 /* */
197 LOCAL_FUNC
198 void Z1_Done_Builder( Z1_Builder* builder )
199 {
200 Z1_GlyphSlot glyph = builder->glyph;
201
202
203 if ( glyph )
204 glyph->root.outline = *builder->base;
205 }
206
207
208 /*************************************************************************/
209 /* */
210 /* <Function> */
211 /* Z1_Init_Decoder */
212 /* */
213 /* <Description> */
214 /* Initializes a given glyph decoder. */
215 /* */
216 /* <InOut> */
217 /* decoder :: A pointer to the glyph builder to initialize. */
218 /* */
219 LOCAL_FUNC
220 void Z1_Init_Decoder( Z1_Decoder* decoder )
221 {
222 decoder->top = 0;
223 decoder->zone = 0;
224 decoder->flex_state = 0;
225 decoder->num_flex_vectors = 0;
226 decoder->blend = 0;
227
228 /* Clear loader */
229 MEM_Set( &decoder->builder, 0, sizeof ( decoder->builder ) );
230 }
231
232
233 /* check that there is enough space for `count' more points */
234 static
235 FT_Error check_points( Z1_Builder* builder,
236 FT_Int count )
237 {
238 return FT_GlyphLoader_Check_Points( builder->loader, count, 0 );
239 }
240
241
242 /* add a new point; do not check space */
243 static
244 void add_point( Z1_Builder* builder,
245 FT_Pos x,
246 FT_Pos y,
247 FT_Byte flag )
248 {
249 FT_Outline* outline = builder->current;
250
251
252 if ( builder->load_points )
253 {
254 FT_Vector* point = outline->points + outline->n_points;
255 FT_Byte* control = (FT_Byte*)outline->tags + outline->n_points;
256
257
258 point->x = x;
259 point->y = y;
260 *control = flag ? FT_Curve_Tag_On : FT_Curve_Tag_Cubic;
261
262 builder->last = *point;
263 }
264
265 outline->n_points++;
266 }
267
268
269 /* check space for a new on-curve point, then add it */
270 static
271 FT_Error add_point1( Z1_Builder* builder,
272 FT_Pos x,
273 FT_Pos y )
274 {
275 FT_Error error;
276
277
278 error = check_points( builder, 1 );
279 if ( !error )
280 add_point( builder, x, y, 1 );
281
282 return error;
283 }
284
285
286 /* check space for a new contour, then add it */
287 static
288 FT_Error add_contour( Z1_Builder* builder )
289 {
290 FT_Outline* outline = builder->current;
291 FT_Error error;
292
293
294 if ( !builder->load_points )
295 {
296 outline->n_contours++;
297 return FT_Err_Ok;
298 }
299
300 /* reallocate contours array if necessary */
301 error = FT_GlyphLoader_Check_Points( builder->loader, 0, 1 );
302 if ( !error )
303 {
304 if ( outline->n_contours > 0 )
305 outline->contours[outline->n_contours - 1] = outline->n_points - 1;
306
307 outline->n_contours++;
308 }
309
310 return error;
311 }
312
313
314 /* if a path was begun, add its first on-curve point */
315 static
316 FT_Error start_point( Z1_Builder* builder,
317 FT_Pos x,
318 FT_Pos y )
319 {
320 /* test whether we are building a new contour */
321 if ( !builder->path_begun )
322 {
323 FT_Error error;
324
325
326 builder->path_begun = 1;
327 error = add_contour( builder );
328 if ( error )
329 return error;
330 }
331 return add_point1( builder, x, y );
332 }
333
334
335 /* close the current contour */
336 static
337 void close_contour( Z1_Builder* builder )
338 {
339 FT_Outline* outline = builder->current;
340
341
342 /* XXX: we must not include the last point in the path if it */
343 /* is located on the first point */
344 if ( outline->n_points > 1 )
345 {
346 FT_Int first = 0;
347 FT_Vector* p1 = outline->points + first;
348 FT_Vector* p2 = outline->points + outline->n_points-1;
349
350
351 if ( outline->n_contours > 1 )
352 {
353 first = outline->contours[outline->n_contours - 2] + 1;
354 p1 = outline->points + first;
355 }
356
357 if ( p1->x == p2->x && p1->y == p2->y )
358 outline->n_points--;
359 }
360
361 if ( outline->n_contours > 0 )
362 outline->contours[outline->n_contours - 1] = outline->n_points - 1;
363 }
364
365
366 /*************************************************************************/
367 /* */
368 /* <Function> */
369 /* lookup_glyph_by_stdcharcode */
370 /* */
371 /* <Description> */
372 /* Looks up a given glyph by its StandardEncoding charcode. Used */
373 /* to implement the SEAC Type 1 operator. */
374 /* */
375 /* <Input> */
376 /* face :: The current face object. */
377 /* */
378 /* charcode :: The character code to look for. */
379 /* */
380 /* <Return> */
381 /* A glyph index in the font face. Returns -1 if the corresponding */
382 /* glyph wasn't found. */
383 /* */
384 static
385 FT_Int lookup_glyph_by_stdcharcode( T1_Face face,
386 FT_Int charcode )
387 {
388 FT_Int n;
389 const FT_String* glyph_name;
390 PSNames_Interface* psnames = (PSNames_Interface*)face->psnames;
391
392
393 /* check range of standard char code */
394 if ( charcode < 0 || charcode > 255 )
395 return -1;
396
397 glyph_name = psnames->adobe_std_strings(
398 psnames->adobe_std_encoding[charcode]);
399
400 for ( n = 0; n < face->type1.num_glyphs; n++ )
401 {
402 FT_String* name = (FT_String*)face->type1.glyph_names[n];
403
404
405 if ( name && strcmp( name,glyph_name ) == 0 )
406 return n;
407 }
408
409 return -1;
410 }
411
412
413 /*************************************************************************/
414 /* */
415 /* <Function> */
416 /* t1operator_seac */
417 /* */
418 /* <Description> */
419 /* Implements the `seac' Type 1 operator for a Type 1 decoder. */
420 /* */
421 /* <Input> */
422 /* decoder :: The current CID decoder. */
423 /* */
424 /* asb :: The accent's side bearing. */
425 /* */
426 /* adx :: The horizontal offset of the accent. */
427 /* */
428 /* ady :: The vertical offset of the accent. */
429 /* */
430 /* bchar :: The base character's StandardEncoding charcode. */
431 /* */
432 /* achar :: The accent character's StandardEncoding charcode. */
433 /* */
434 /* <Return> */
435 /* FreeType error code. 0 means success. */
436 /* */
437 static
438 FT_Error t1operator_seac( Z1_Decoder* decoder,
439 FT_Pos asb,
440 FT_Pos adx,
441 FT_Pos ady,
442 FT_Int bchar,
443 FT_Int achar )
444 {
445 FT_Error error;
446 FT_Int bchar_index, achar_index, n_base_points;
447 FT_Outline* base = decoder->builder.base;
448 FT_Vector left_bearing, advance;
449 T1_Face face = decoder->builder.face;
450 T1_Font* type1 = &face->type1;
451
452
453 bchar_index = lookup_glyph_by_stdcharcode( face, bchar );
454 achar_index = lookup_glyph_by_stdcharcode( face, achar );
455
456 if ( bchar_index < 0 || achar_index < 0 )
457 {
458 FT_ERROR(( "t1operator_seac:" ));
459 FT_ERROR(( " invalid seac character code arguments\n" ));
460 return T1_Err_Syntax_Error;
461 }
462
463 /* if we are trying to load a composite glyph, do not load the */
464 /* accent character and return the array of subglyphs. */
465 if ( decoder->builder.no_recurse )
466 {
467 FT_GlyphSlot glyph = (FT_GlyphSlot)decoder->builder.glyph;
468 FT_GlyphLoader* loader = glyph->loader;
469 FT_SubGlyph* subg;
470
471
472 /* reallocate subglyph array if necessary */
473 error = FT_GlyphLoader_Check_Subglyphs( loader, 2 );
474 if ( error )
475 goto Exit;
476
477 subg = loader->current.subglyphs;
478
479 /* subglyph 0 = base character */
480 subg->index = bchar_index;
481 subg->flags = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES |
482 FT_SUBGLYPH_FLAG_USE_MY_METRICS;
483 subg->arg1 = 0;
484 subg->arg2 = 0;
485 subg++;
486
487 /* subglyph 1 = accent character */
488 subg->index = achar_index;
489 subg->flags = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES;
490 subg->arg1 = adx - asb;
491 subg->arg2 = ady;
492
493 /* set up remaining glyph fields */
494 glyph->num_subglyphs = 2;
495 glyph->subglyphs = loader->base.subglyphs;
496 glyph->format = ft_glyph_format_composite;
497
498 loader->current.num_subglyphs = 2;
499 }
500
501 /* First load `bchar' in builder */
502 /* now load the unscaled outline */
503
504 FT_GlyphLoader_Prepare( decoder->builder.loader ); /* prepare loader */
505
506 error = Z1_Parse_CharStrings( decoder,
507 type1->charstrings [bchar_index],
508 type1->charstrings_len[bchar_index],
509 type1->num_subrs,
510 type1->subrs,
511 type1->subrs_len );
512 if ( error )
513 goto Exit;
514
515 n_base_points = base->n_points;
516
517 /* save the left bearing and width of the base character */
518 /* as they will be erased by the next load. */
519
520 left_bearing = decoder->builder.left_bearing;
521 advance = decoder->builder.advance;
522
523 decoder->builder.left_bearing.x = 0;
524 decoder->builder.left_bearing.y = 0;
525
526 /* Now load `achar' on top of */
527 /* the base outline */
528 error = Z1_Parse_CharStrings( decoder,
529 type1->charstrings [achar_index],
530 type1->charstrings_len[achar_index],
531 type1->num_subrs,
532 type1->subrs,
533 type1->subrs_len );
534 if ( error )
535 return error;
536
537 /* restore the left side bearing and */
538 /* advance width of the base character */
539
540 decoder->builder.left_bearing = left_bearing;
541 decoder->builder.advance = advance;
542
543 /* Finally, move the accent */
544 if ( decoder->builder.load_points )
545 {
546 FT_Outline dummy;
547
548
549 dummy.n_points = base->n_points - n_base_points;
550 dummy.points = base->points + n_base_points;
551 FT_Outline_Translate( &dummy, adx - asb, ady );
552 }
553
554 Exit:
555 return error;
556 }
557
558
559#define USE_ARGS( n ) do \
560 { \
561 top -= n; \
562 if ( top < decoder->stack ) \
563 goto Stack_Underflow; \
564 } while ( 0 )
565
566
567 /*************************************************************************/
568 /* */
569 /* <Function> */
570 /* Z1_Parse_CharStrings */
571 /* */
572 /* <Description> */
573 /* Parses a given Type 1 charstrings program. */
574 /* */
575 /* <Input> */
576 /* decoder :: The current Type 1 decoder. */
577 /* */
578 /* charstring_base :: The base address of the charstring stream. */
579 /* */
580 /* charstring_len :: The length in bytes of the charstring stream. */
581 /* */
582 /* num_subrs :: The number of sub-routines. */
583 /* */
584 /* subrs_base :: An array of sub-routines addresses. */
585 /* */
586 /* subrs_len :: An array of sub-routines lengths. */
587 /* */
588 /* <Return> */
589 /* Free error code. 0 means success. */
590 /* */
591 LOCAL_FUNC
592 FT_Error Z1_Parse_CharStrings( Z1_Decoder* decoder,
593 FT_Byte* charstring_base,
594 FT_Int charstring_len,
595 FT_Int num_subrs,
596 FT_Byte** subrs_base,
597 FT_Int* subrs_len )
598 {
599 FT_Error error;
600 Z1_Decoder_Zone* zone;
601 FT_Byte* ip;
602 FT_Byte* limit;
603 Z1_Builder* builder = &decoder->builder;
604 FT_Outline* outline;
605 FT_Pos x, y;
606
607
608 /* First of all, initialize the decoder */
609 decoder->top = decoder->stack;
610 decoder->zone = decoder->zones;
611 zone = decoder->zones;
612
613 builder->path_begun = 0;
614
615 zone->base = charstring_base;
616 limit = zone->limit = charstring_base + charstring_len;
617 ip = zone->cursor = zone->base;
618
619 error = T1_Err_Ok;
620 outline = builder->current;
621
622 x = builder->pos_x;
623 y = builder->pos_y;
624
625 /* now, execute loop */
626 while ( ip < limit )
627 {
628 FT_Int* top = decoder->top;
629 Z1_Operator op = op_none;
630 FT_Long value = 0;
631
632
633 /*********************************************************************/
634 /* */
635 /* Decode operator or operand */
636 /* */
637 /* */
638
639 /* first of all, decompress operator or value */
640 switch ( *ip++ )
641 {
642 case 1:
643 op = op_hstem;
644 break;
645
646 case 3:
647 op = op_vstem;
648 break;
649 case 4:
650 op = op_vmoveto;
651 break;
652 case 5:
653 op = op_rlineto;
654 break;
655 case 6:
656 op = op_hlineto;
657 break;
658 case 7:
659 op = op_vlineto;
660 break;
661 case 8:
662 op = op_rrcurveto;
663 break;
664 case 9:
665 op = op_closepath;
666 break;
667 case 10:
668 op = op_callsubr;
669 break;
670 case 11:
671 op = op_return;
672 break;
673
674 case 13:
675 op = op_hsbw;
676 break;
677 case 14:
678 op = op_endchar;
679 break;
680
681 case 21:
682 op = op_rmoveto;
683 break;
684 case 22:
685 op = op_hmoveto;
686 break;
687
688 case 30:
689 op = op_vhcurveto;
690 break;
691 case 31:
692 op = op_hvcurveto;
693 break;
694
695 case 12:
696 if ( ip > limit )
697 {
698 FT_ERROR(( "Z1_Parse_CharStrings: invalid escape (12+EOF)\n" ));
699 goto Syntax_Error;
700 }
701
702 switch ( *ip++ )
703 {
704 case 0:
705 op = op_dotsection;
706 break;
707 case 1:
708 op = op_vstem3;
709 break;
710 case 2:
711 op = op_hstem3;
712 break;
713 case 6:
714 op = op_seac;
715 break;
716 case 7:
717 op = op_sbw;
718 break;
719 case 12:
720 op = op_div;
721 break;
722 case 16:
723 op = op_callothersubr;
724 break;
725 case 17:
726 op = op_pop;
727 break;
728 case 33:
729 op = op_setcurrentpoint;
730 break;
731
732 default:
733 FT_ERROR(( "Z1_Parse_CharStrings: invalid escape (12+%d)\n",
734 ip[-1] ));
735 goto Syntax_Error;
736 }
737 break;
738
739 case 255: /* four bytes integer */
740 if ( ip + 4 > limit )
741 {
742 FT_ERROR(( "Z1_Parse_CharStrings: unexpected EOF in integer\n" ));
743 goto Syntax_Error;
744 }
745
746 value = ( (FT_Long)ip[0] << 24 ) |
747 ( (FT_Long)ip[1] << 16 ) |
748 ( (FT_Long)ip[2] << 8 ) |
749 ip[3];
750 ip += 4;
751 break;
752
753 default:
754 if ( ip[-1] >= 32 )
755 {
756 if ( ip[-1] < 247 )
757 value = (FT_Long)ip[-1] - 139;
758 else
759 {
760 if ( ++ip > limit )
761 {
762 FT_ERROR(( "Z1_Parse_CharStrings:" ));
763 FT_ERROR(( " unexpected EOF in integer\n" ));
764 goto Syntax_Error;
765 }
766
767 if ( ip[-2] < 251 )
768 value = ( (FT_Long)( ip[-2] - 247 ) << 8 ) + ip[-1] + 108;
769 else
770 value = -( ( ( (FT_Long)ip[-2] - 251 ) << 8 ) + ip[-1] + 108 );
771 }
772 }
773 else
774 {
775 FT_ERROR(( "Z1_Parse_CharStrings: invalid byte (%d)\n",
776 ip[-1] ));
777 goto Syntax_Error;
778 }
779 }
780
781 /*********************************************************************/
782 /* */
783 /* Push value on stack, or process operator */
784 /* */
785 /* */
786 if ( op == op_none )
787 {
788 if ( top - decoder->stack >= T1_MAX_CHARSTRINGS_OPERANDS )
789 {
790 FT_ERROR(( "Z1_Parse_CharStrings: stack overflow!\n" ));
791 goto Syntax_Error;
792 }
793
794 FT_TRACE4(( " %ld", value ));
795
796 *top++ = value;
797 decoder->top = top;
798 }
799 else if ( op == op_callothersubr ) /* callothersubr */
800 {
801 FT_TRACE4(( " callothersubr" ));
802
803 if ( top - decoder->stack < 2 )
804 goto Stack_Underflow;
805
806 top -= 2;
807 switch ( top[1] )
808 {
809 case 1: /* start flex feature */
810 if ( top[0] != 0 )
811 goto Unexpected_OtherSubr;
812
813 decoder->flex_state = 1;
814 decoder->num_flex_vectors = 0;
815 if ( start_point( builder, x, y ) ||
816 check_points( builder, 6 ) )
817 goto Memory_Error;
818 break;
819
820 case 2: /* add flex vectors */
821 {
822 FT_Int index;
823
824 if ( top[0] != 0 )
825 goto Unexpected_OtherSubr;
826
827 /* note that we should not add a point for index 0; */
828 /* this will move our current position to the flex */
829 /* point without adding any point to the outline */
830 index = decoder->num_flex_vectors++;
831 if ( index > 0 && index < 7 )
832 add_point( builder,
833 x,
834 y,
835 (FT_Byte)( index == 3 || index == 6 ) );
836 }
837 break;
838
839 case 0: /* end flex feature */
840 if ( top[0] != 3 )
841 goto Unexpected_OtherSubr;
842
843 if ( decoder->flex_state == 0 ||
844 decoder->num_flex_vectors != 7 )
845 {
846 FT_ERROR(( "Z1_Parse_CharStrings: unexpected flex end\n" ));
847 goto Syntax_Error;
848 }
849
850 /* now consume the remaining `pop pop setcurpoint' */
851 if ( ip + 6 > limit ||
852 ip[0] != 12 || ip[1] != 17 || /* pop */
853 ip[2] != 12 || ip[3] != 17 || /* pop */
854 ip[4] != 12 || ip[5] != 33 ) /* setcurpoint */
855 {
856 FT_ERROR(( "Z1_Parse_CharStrings: invalid flex charstring\n" ));
857 goto Syntax_Error;
858 }
859
860 ip += 6;
861 decoder->flex_state = 0;
862 break;
863
864 case 3: /* change hints */
865 if ( top[0] != 1 )
866 goto Unexpected_OtherSubr;
867
868 /* eat the following `pop' */
869 if ( ip + 2 > limit )
870 {
871 FT_ERROR(( "Z1_Parse_CharStrings: invalid escape (12+%d)\n",
872 ip[-1] ));
873 goto Syntax_Error;
874 }
875
876 if ( ip[0] != 12 || ip[1] != 17 )
877 {
878 FT_ERROR(( "Z1_Parse_CharStrings:" ));
879 FT_ERROR(( " `pop' expected, found (%d %d)\n",
880 ip[0], ip[1] ));
881 goto Syntax_Error;
882 }
883 ip += 2;
884 break;
885
886 case 12:
887 case 13:
888 /* counter control hints, clear stack */
889 top = decoder->stack;
890 break;
891
892 case 14:
893 case 15:
894 case 16:
895 case 17:
896 case 18: /* multiple masters */
897 {
898 T1_Blend* blend = decoder->blend;
899 FT_UInt num_points, nn, mm;
900 FT_Int* delta;
901 FT_Int* values;
902
903
904 if ( !blend )
905 {
906 FT_ERROR(( "Z1_Parse_CharStrings:" ));
907 FT_ERROR(( " unexpected multiple masters operator!\n" ));
908 goto Syntax_Error;
909 }
910
911 num_points = top[1] - 13 + ( top[1] == 18 );
912 if ( top[0] != (FT_Int)( num_points * blend->num_designs ) )
913 {
914 FT_ERROR(( "Z1_Parse_CharStrings:" ));
915 FT_ERROR(( " incorrect number of mm arguments\n" ));
916 goto Syntax_Error;
917 }
918
919 top -= blend->num_designs*num_points;
920 if ( top < decoder->stack )
921 goto Stack_Underflow;
922
923 /* we want to compute: */
924 /* */
925 /* a0*w0 + a1*w1 + ... + ak*wk */
926 /* */
927 /* but we only have the a0, a1-a0, a2-a0, .. ak-a0 */
928 /* however, given that w0 + w1 + ... + wk == 1, we can */
929 /* rewrite it easily as: */
930 /* */
931 /* a0 + (a1-a0)*w1 + (a2-a0)*w2 + .. + (ak-a0)*wk */
932 /* */
933 /* where k == num_designs-1 */
934 /* */
935 /* I guess that's why it's written in this `compact' */
936 /* form. */
937 /* */
938 delta = top + num_points;
939 values = top;
940 for ( nn = 0; nn < num_points; nn++ )
941 {
942 FT_Int x = values[0];
943
944
945 for ( mm = 1; mm < blend->num_designs; mm++ )
946 x += FT_MulFix( *delta++, blend->weight_vector[mm] );
947
948 *values++ = x;
949 }
950 /* note that `top' will be incremented later by calls to `pop' */
951 break;
952 }
953
954 default:
955 Unexpected_OtherSubr:
956 FT_ERROR(( "Z1_Parse_CharStrings: invalid othersubr [%d %d]!\n",
957 top[0], top[1] ));
958 goto Syntax_Error;
959 }
960 decoder->top = top;
961 }
962 else /* general operator */
963 {
964 FT_Int num_args = t1_args_count[op];
965
966
967 if ( top - decoder->stack < num_args )
968 goto Stack_Underflow;
969
970 top -= num_args;
971
972 switch ( op )
973 {
974 case op_endchar:
975 FT_TRACE4(( " endchar" ));
976
977 close_contour( builder );
978
979 /* add current outline to the glyph slot */
980 FT_GlyphLoader_Add( builder->loader );
981
982 /* return now! */
983 FT_TRACE4(( "\n\n" ));
984 return T1_Err_Ok;
985
986 case op_hsbw:
987 FT_TRACE4(( " hsbw" ));
988
989 builder->left_bearing.x += top[0];
990 builder->advance.x = top[1];
991 builder->advance.y = 0;
992
993 builder->last.x = x = top[0];
994 builder->last.y = y = 0;
995
996 /* the `metrics_only' indicates that we only want to compute */
997 /* the glyph's metrics (lsb + advance width), not load the */
998 /* rest of it; so exit immediately */
999 if ( builder->metrics_only )
1000 return T1_Err_Ok;
1001
1002 break;
1003
1004 case op_seac:
1005 /* return immediately after the processing */
1006 return t1operator_seac( decoder, top[0], top[1],
1007 top[2], top[3], top[4] );
1008
1009 case op_sbw:
1010 FT_TRACE4(( " sbw" ));
1011
1012 builder->left_bearing.x += top[0];
1013 builder->left_bearing.y += top[1];
1014 builder->advance.x = top[2];
1015 builder->advance.y = top[3];
1016
1017 builder->last.x = x = top[0];
1018 builder->last.y = y = top[1];
1019
1020 /* the `metrics_only' indicates that we only want to compute */
1021 /* the glyph's metrics (lsb + advance width), not load the */
1022 /* rest of it; so exit immediately */
1023 if ( builder->metrics_only )
1024 return T1_Err_Ok;
1025
1026 break;
1027
1028 case op_closepath:
1029 FT_TRACE4(( " closepath" ));
1030
1031 close_contour( builder );
1032 builder->path_begun = 0;
1033 break;
1034
1035 case op_hlineto:
1036 FT_TRACE4(( " hlineto" ));
1037
1038 if ( start_point( builder, x, y ) )
1039 goto Memory_Error;
1040
1041 x += top[0];
1042 goto Add_Line;
1043
1044 case op_hmoveto:
1045 FT_TRACE4(( " hmoveto" ));
1046
1047 x += top[0];
1048 break;
1049
1050 case op_hvcurveto:
1051 FT_TRACE4(( " hvcurveto" ));
1052
1053 if ( start_point( builder, x, y ) ||
1054 check_points( builder, 3 ) )
1055 goto Memory_Error;
1056
1057 x += top[0];
1058 add_point( builder, x, y, 0 );
1059 x += top[1];
1060 y += top[2];
1061 add_point( builder, x, y, 0 );
1062 y += top[3];
1063 add_point( builder, x, y, 1 );
1064 break;
1065
1066 case op_rlineto:
1067 FT_TRACE4(( " rlineto" ));
1068
1069 if ( start_point( builder, x, y ) )
1070 goto Memory_Error;
1071
1072 x += top[0];
1073 y += top[1];
1074
1075 Add_Line:
1076 if ( add_point1( builder, x, y ) )
1077 goto Memory_Error;
1078 break;
1079
1080 case op_rmoveto:
1081 FT_TRACE4(( " rmoveto" ));
1082
1083 x += top[0];
1084 y += top[1];
1085 break;
1086
1087 case op_rrcurveto:
1088 FT_TRACE4(( " rcurveto" ));
1089
1090 if ( start_point( builder, x, y ) ||
1091 check_points( builder, 3 ) )
1092 goto Memory_Error;
1093
1094 x += top[0];
1095 y += top[1];
1096 add_point( builder, x, y, 0 );
1097
1098 x += top[2];
1099 y += top[3];
1100 add_point( builder, x, y, 0 );
1101
1102 x += top[4];
1103 y += top[5];
1104 add_point( builder, x, y, 1 );
1105 break;
1106
1107 case op_vhcurveto:
1108 FT_TRACE4(( " vhcurveto" ));
1109
1110 if ( start_point( builder, x, y ) ||
1111 check_points( builder, 3 ) )
1112 goto Memory_Error;
1113
1114 y += top[0];
1115 add_point( builder, x, y, 0 );
1116 x += top[1];
1117 y += top[2];
1118 add_point( builder, x, y, 0 );
1119 x += top[3];
1120 add_point( builder, x, y, 1 );
1121 break;
1122
1123 case op_vlineto:
1124 FT_TRACE4(( " vlineto" ));
1125
1126 if ( start_point( builder, x, y ) )
1127 goto Memory_Error;
1128
1129 y += top[0];
1130 goto Add_Line;
1131
1132 case op_vmoveto:
1133 FT_TRACE4(( " vmoveto" ));
1134
1135 y += top[0];
1136 break;
1137
1138 case op_div:
1139 FT_TRACE4(( " div" ));
1140
1141 if ( top[1] )
1142 {
1143 *top = top[0] / top[1];
1144 ++top;
1145 }
1146 else
1147 {
1148 FT_ERROR(( "Z1_Parse_CharStrings: division by 0\n" ));
1149 goto Syntax_Error;
1150 }
1151 break;
1152
1153 case op_callsubr:
1154 {
1155 FT_Int index;
1156
1157
1158 FT_TRACE4(( " callsubr" ));
1159
1160 index = top[0];
1161 if ( index < 0 || index >= num_subrs )
1162 {
1163 FT_ERROR(( "Z1_Parse_CharStrings: invalid subrs index\n" ));
1164 goto Syntax_Error;
1165 }
1166
1167 if ( zone - decoder->zones >= T1_MAX_SUBRS_CALLS )
1168 {
1169 FT_ERROR(( "Z1_Parse_CharStrings: too many nested subrs\n" ));
1170 goto Syntax_Error;
1171 }
1172
1173 zone->cursor = ip; /* save current instruction pointer */
1174
1175 zone++;
1176 zone->base = subrs_base[index];
1177 zone->limit = zone->base + subrs_len[index];
1178 zone->cursor = zone->base;
1179
1180 if ( !zone->base )
1181 {
1182 FT_ERROR(( "Z1_Parse_CharStrings: invoking empty subrs!\n" ));
1183 goto Syntax_Error;
1184 }
1185
1186 decoder->zone = zone;
1187 ip = zone->base;
1188 limit = zone->limit;
1189 break;
1190 }
1191
1192 case op_pop:
1193 FT_TRACE4(( " pop" ));
1194
1195 /* theorically, the arguments are already on the stack */
1196 top++;
1197 break;
1198
1199 case op_return:
1200 FT_TRACE4(( " return" ));
1201
1202 if ( zone <= decoder->zones )
1203 {
1204 FT_ERROR(( "Z1_Parse_CharStrings: unexpected return\n" ));
1205 goto Syntax_Error;
1206 }
1207
1208 zone--;
1209 ip = zone->cursor;
1210 limit = zone->limit;
1211 decoder->zone = zone;
1212 break;
1213
1214 case op_dotsection:
1215 FT_TRACE4(( " dotsection" ));
1216
1217 break;
1218
1219 case op_hstem:
1220 FT_TRACE4(( " hstem" ));
1221
1222 break;
1223
1224 case op_hstem3:
1225 FT_TRACE4(( " hstem3" ));
1226
1227 break;
1228
1229 case op_vstem:
1230 FT_TRACE4(( " vstem" ));
1231
1232 break;
1233
1234 case op_vstem3:
1235 FT_TRACE4(( " vstem3" ));
1236
1237 break;
1238
1239 case op_setcurrentpoint:
1240 FT_TRACE4(( " setcurrentpoint" ));
1241
1242 FT_ERROR(( "Z1_Parse_CharStrings:" ));
1243 FT_ERROR(( " unexpected `setcurrentpoint'\n" ));
1244 goto Syntax_Error;
1245
1246 default:
1247 FT_ERROR(( "Z1_Parse_CharStrings: unhandled opcode %d\n", op ));
1248 goto Syntax_Error;
1249 }
1250
1251 decoder->top = top;
1252
1253 } /* general operator processing */
1254
1255 } /* while ip < limit */
1256
1257 FT_TRACE4(( "..end..\n\n" ));
1258 return error;
1259
1260 Syntax_Error:
1261 return T1_Err_Syntax_Error;
1262
1263 Stack_Underflow:
1264 return T1_Err_Stack_Underflow;
1265
1266 Memory_Error:
1267 return builder->error;
1268 }
1269
1270
1271 /*************************************************************************/
1272 /*************************************************************************/
1273 /*************************************************************************/
1274 /********** *********/
1275 /********** COMPUTE THE MAXIMUM ADVANCE WIDTH *********/
1276 /********** *********/
1277 /********** The following code is in charge of computing *********/
1278 /********** the maximum advance width of the font. It *********/
1279 /********** quickly processes each glyph charstring to *********/
1280 /********** extract the value from either a `sbw' or `seac' *********/
1281 /********** operator. *********/
1282 /********** *********/
1283 /*************************************************************************/
1284 /*************************************************************************/
1285 /*************************************************************************/
1286
1287
1288 LOCAL_FUNC
1289 FT_Error Z1_Compute_Max_Advance( T1_Face face,
1290 FT_Int* max_advance )
1291 {
1292 FT_Error error;
1293 Z1_Decoder decoder;
1294 FT_Int glyph_index;
1295 T1_Font* type1 = &face->type1;
1296
1297
1298 *max_advance = 0;
1299
1300 /* Initialize load decoder */
1301 Z1_Init_Decoder( &decoder );
1302 Z1_Init_Builder( &decoder.builder, face, 0, 0 );
1303
1304 decoder.blend = face->blend;
1305 decoder.builder.metrics_only = 1;
1306 decoder.builder.load_points = 0;
1307
1308 /* for each glyph, parse the glyph charstring and extract */
1309 /* the advance width */
1310 for ( glyph_index = 0; glyph_index < type1->num_glyphs; glyph_index++ )
1311 {
1312 /* now get load the unscaled outline */
1313 error = Z1_Parse_CharStrings( &decoder,
1314 type1->charstrings [glyph_index],
1315 type1->charstrings_len[glyph_index],
1316 type1->num_subrs,
1317 type1->subrs,
1318 type1->subrs_len );
1319 /* ignore the error if one occured - skip to next glyph */
1320 }
1321
1322 *max_advance = decoder.builder.advance.x;
1323 return T1_Err_Ok;
1324 }
1325
1326
1327 /*************************************************************************/
1328 /*************************************************************************/
1329 /*************************************************************************/
1330 /********** *********/
1331 /********** UNHINTED GLYPH LOADER *********/
1332 /********** *********/
1333 /********** The following code is in charge of loading a *********/
1334 /********** single outline. It completely ignores hinting *********/
1335 /********** and is used when FT_LOAD_NO_HINTING is set. *********/
1336 /********** *********/
1337 /********** The Type 1 hinter is located in `t1hint.c' *********/
1338 /********** *********/
1339 /*************************************************************************/
1340 /*************************************************************************/
1341 /*************************************************************************/
1342
1343
1344 LOCAL_FUNC
1345 FT_Error Z1_Load_Glyph( Z1_GlyphSlot glyph,
1346 Z1_Size size,
1347 FT_Int glyph_index,
1348 FT_Int load_flags )
1349 {
1350 FT_Error error;
1351 Z1_Decoder decoder;
1352 T1_Face face = (T1_Face)glyph->root.face;
1353 FT_Bool hinting;
1354 T1_Font* type1 = &face->type1;
1355
1356
1357 if ( load_flags & FT_LOAD_NO_RECURSE )
1358 load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
1359
1360 glyph->x_scale = size->root.metrics.x_scale;
1361 glyph->y_scale = size->root.metrics.y_scale;
1362
1363 glyph->root.outline.n_points = 0;
1364 glyph->root.outline.n_contours = 0;
1365
1366 hinting = ( load_flags & FT_LOAD_NO_SCALE ) == 0 &&
1367 ( load_flags & FT_LOAD_NO_HINTING ) == 0;
1368
1369 glyph->root.format = ft_glyph_format_outline;
1370
1371 Z1_Init_Decoder( &decoder );
1372 Z1_Init_Builder( &decoder.builder, face, size, glyph );
1373
1374 decoder.blend = ((T1_Face)glyph->root.face)->blend;
1375 decoder.builder.no_recurse = ( load_flags & FT_LOAD_NO_RECURSE ) != 0;
1376
1377 /* now load the unscaled outline */
1378 error = Z1_Parse_CharStrings( &decoder,
1379 type1->charstrings [glyph_index],
1380 type1->charstrings_len[glyph_index],
1381 type1->num_subrs,
1382 type1->subrs,
1383 type1->subrs_len );
1384
1385 /* save new glyph tables */
1386 Z1_Done_Builder( &decoder.builder );
1387
1388 /* now, set the metrics -- this is rather simple, as */
1389 /* the left side bearing is the xMin, and the top side */
1390 /* bearing the yMax */
1391 if ( !error )
1392 {
1393 glyph->root.outline.flags &= ft_outline_owner;
1394 glyph->root.outline.flags |= ft_outline_reverse_fill;
1395
1396 /* for composite glyphs, return only left side bearing and */
1397 /* advance width */
1398 if ( load_flags & FT_LOAD_NO_RECURSE )
1399 {
1400 glyph->root.metrics.horiBearingX = decoder.builder.left_bearing.x;
1401 glyph->root.metrics.horiAdvance = decoder.builder.advance.x;
1402 }
1403 else
1404 {
1405 FT_BBox cbox;
1406 FT_Glyph_Metrics* metrics = &glyph->root.metrics;
1407
1408
1409 /* copy the _unscaled_ advance width */
1410 metrics->horiAdvance = decoder.builder.advance.x;
1411
1412 /* make up vertical metrics */
1413 metrics->vertBearingX = 0;
1414 metrics->vertBearingY = 0;
1415 metrics->vertAdvance = 0;
1416
1417 glyph->root.format = ft_glyph_format_outline;
1418
1419 if ( size && size->root.metrics.y_ppem < 24 )
1420 glyph->root.outline.flags |= ft_outline_high_precision;
1421
1422#if 0
1423 glyph->root.outline.second_pass = TRUE;
1424 glyph->root.outline.high_precision = size->root.metrics.y_ppem < 24;
1425 glyph->root.outline.dropout_mode = 2;
1426#endif /* 0 */
1427
1428 if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 )
1429 {
1430 /* scale the outline and the metrics */
1431 FT_Int n;
1432 FT_Outline* cur = decoder.builder.base;
1433 FT_Vector* vec = cur->points;
1434 FT_Fixed x_scale = glyph->x_scale;
1435 FT_Fixed y_scale = glyph->y_scale;
1436
1437
1438 /* First of all, scale the points */
1439 for ( n = cur->n_points; n > 0; n--, vec++ )
1440 {
1441 vec->x = FT_MulFix( vec->x, x_scale );
1442 vec->y = FT_MulFix( vec->y, y_scale );
1443 }
1444
1445 FT_Outline_Get_CBox( &glyph->root.outline, &cbox );
1446
1447 /* Then scale the metrics */
1448 metrics->horiAdvance = FT_MulFix( metrics->horiAdvance, x_scale );
1449 metrics->vertAdvance = FT_MulFix( metrics->vertAdvance, y_scale );
1450
1451 metrics->vertBearingX = FT_MulFix( metrics->vertBearingX, x_scale );
1452 metrics->vertBearingY = FT_MulFix( metrics->vertBearingY, y_scale );
1453 }
1454
1455 /* apply the font matrix */
1456 FT_Outline_Transform( &glyph->root.outline,
1457 &face->type1.font_matrix );
1458
1459 /* compute the other metrics */
1460 FT_Outline_Get_CBox( &glyph->root.outline, &cbox );
1461
1462 /* grid fit the bounding box if necessary */
1463 if ( hinting )
1464 {
1465 cbox.xMin &= -64;
1466 cbox.yMin &= -64;
1467 cbox.xMax = ( cbox.xMax+63 ) & -64;
1468 cbox.yMax = ( cbox.yMax+63 ) & -64;
1469 }
1470
1471 metrics->width = cbox.xMax - cbox.xMin;
1472 metrics->height = cbox.yMax - cbox.yMin;
1473
1474 metrics->horiBearingX = cbox.xMin;
1475 metrics->horiBearingY = cbox.yMax;
1476 }
1477 }
1478 return error;
1479 }
1480
1481
1482/* END */
wxWidgets (Impactor)