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