]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/freetype/autohint/ahhint.c
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
added wxLog::ClearTraceMasks()
[wxWidgets.git] / src / freetype / autohint / ahhint.c
... / ...
CommitLineData
1/***************************************************************************/
2/* */
3/* ahhint.c */
4/* */
5/* Glyph hinter (body). */
6/* */
7/* Copyright 2000 Catharon Productions Inc. */
8/* Author: David Turner */
9/* */
10/* This file is part of the Catharon Typography Project and shall only */
11/* be used, modified, and distributed under the terms of the Catharon */
12/* Open Source License that should come with this file under the name */
13/* `CatharonLicense.txt'. By continuing to use, modify, or distribute */
14/* this file you indicate that you have read the license and */
15/* understand and accept it fully. */
16/* */
17/* Note that this license is compatible with the FreeType license. */
18/* */
19/***************************************************************************/
20
21
22#ifdef FT_FLAT_COMPILE
23
24#include "ahhint.h"
25#include "ahglyph.h"
26#include "ahangles.h"
27
28#else
29
30#include <autohint/ahhint.h>
31#include <autohint/ahglyph.h>
32#include <autohint/ahangles.h>
33
34#endif
35
36#include <freetype/ftoutln.h>
37
38
39#define FACE_GLOBALS( face ) ((AH_Face_Globals*)(face)->autohint.data)
40
41#define AH_USE_IUP
42
43
44 /*************************************************************************/
45 /*************************************************************************/
46 /**** ****/
47 /**** Hinting routines ****/
48 /**** ****/
49 /*************************************************************************/
50 /*************************************************************************/
51
52
53 static int disable_horz_edges = 0;
54 static int disable_vert_edges = 0;
55
56
57 /* snap a given width in scaled coordinates to one of the */
58 /* current standard widths */
59 static
60 FT_Pos ah_snap_width( FT_Pos* widths,
61 FT_Int count,
62 FT_Pos width )
63 {
64 int n;
65 FT_Pos best = 64 + 32 + 2;
66 FT_Pos reference = width;
67
68
69 for ( n = 0; n < count; n++ )
70 {
71 FT_Pos w;
72 FT_Pos dist;
73
74
75 w = widths[n];
76 dist = width - w;
77 if ( dist < 0 )
78 dist = -dist;
79 if ( dist < best )
80 {
81 best = dist;
82 reference = w;
83 }
84 }
85
86 if ( width >= reference )
87 {
88 width -= 0x21;
89 if ( width < reference )
90 width = reference;
91 }
92 else
93 {
94 width += 0x21;
95 if ( width > reference )
96 width = reference;
97 }
98
99 return width;
100 }
101
102
103 /* align one stem edge relative to the previous stem edge */
104 static
105 void ah_align_linked_edge( AH_Hinter* hinter,
106 AH_Edge* base_edge,
107 AH_Edge* stem_edge,
108 int vertical )
109 {
110 FT_Pos dist = stem_edge->opos - base_edge->opos;
111 AH_Globals* globals = &hinter->globals->scaled;
112 FT_Pos sign = 1;
113
114
115 if ( dist < 0 )
116 {
117 dist = -dist;
118 sign = -1;
119 }
120
121 if ( vertical )
122 {
123 dist = ah_snap_width( globals->heights, globals->num_heights, dist );
124
125 /* in the case of vertical hinting, always round */
126 /* the stem heights to integer pixels */
127 if ( dist >= 64 )
128 dist = ( dist + 16 ) & -64;
129 else
130 dist = 64;
131 }
132 else
133 {
134 dist = ah_snap_width( globals->widths, globals->num_widths, dist );
135
136 if ( hinter->flags & ah_hinter_monochrome )
137 {
138 /* monochrome horizontal hinting: snap widths to integer pixels */
139 /* with a different threshold */
140 if ( dist < 64 )
141 dist = 64;
142 else
143 dist = ( dist + 32 ) & -64;
144 }
145 else
146 {
147 /* for horizontal anti-aliased hinting, we adopt a more subtle */
148 /* approach: we strengthen small stems, round stems whose size */
149 /* is between 1 and 2 pixels to an integer, otherwise nothing */
150 if ( dist < 48 )
151 dist = ( dist + 64 ) >> 1;
152
153 else if ( dist < 128 )
154 dist = ( dist + 42 ) & -64;
155 }
156 }
157
158 stem_edge->pos = base_edge->pos + sign * dist;
159 }
160
161
162 static
163 void ah_align_serif_edge( AH_Hinter* hinter,
164 AH_Edge* base,
165 AH_Edge* serif )
166 {
167 FT_Pos dist;
168 FT_Pos sign = 1;
169
170 UNUSED( hinter );
171
172
173 dist = serif->opos - base->opos;
174 if ( dist < 0 )
175 {
176 dist = -dist;
177 sign = -1;
178 }
179
180 /* do not strengthen serifs */
181 if ( base->flags & ah_edge_done )
182 {
183 if ( dist > 64 )
184 dist = ( dist + 16 ) & -64;
185
186 else if ( dist <= 32 )
187 dist = ( dist + 33 ) >> 1;
188 }
189
190 serif->pos = base->pos + sign * dist;
191 }
192
193
194 /*************************************************************************/
195 /*************************************************************************/
196 /*************************************************************************/
197 /**** ****/
198 /**** E D G E H I N T I N G ****/
199 /**** ****/
200 /*************************************************************************/
201 /*************************************************************************/
202 /*************************************************************************/
203
204
205 /* Another alternative edge hinting algorithm */
206 static
207 void ah_hint_edges_3( AH_Hinter* hinter )
208 {
209 AH_Edge* edges;
210 AH_Edge* edge_limit;
211 AH_Outline* outline = hinter->glyph;
212 FT_Int dimension;
213
214
215 edges = outline->horz_edges;
216 edge_limit = edges + outline->num_hedges;
217
218 for ( dimension = 1; dimension >= 0; dimension-- )
219 {
220 AH_Edge* edge;
221 AH_Edge* before = 0;
222 AH_Edge* after = 0;
223 AH_Edge* anchor = 0;
224 int has_serifs = 0;
225
226
227 if ( disable_vert_edges && !dimension )
228 goto Next_Dimension;
229
230 if ( disable_horz_edges && dimension )
231 goto Next_Dimension;
232
233 /* we begin by aligning all stems relative to the blue zone */
234 /* if needed -- that's only for horizontal edges */
235 if ( dimension )
236 {
237 for ( edge = edges; edge < edge_limit; edge++ )
238 {
239 FT_Pos* blue;
240 AH_Edge *edge1, *edge2;
241
242
243 if ( edge->flags & ah_edge_done )
244 continue;
245
246 blue = edge->blue_edge;
247 edge1 = 0;
248 edge2 = edge->link;
249
250 if ( blue )
251 {
252 edge1 = edge;
253 }
254 else if (edge2 && edge2->blue_edge)
255 {
256 blue = edge2->blue_edge;
257 edge1 = edge2;
258 edge2 = edge;
259 }
260
261 if ( !edge1 )
262 continue;
263
264 edge1->pos = blue[0];
265 edge1->flags |= ah_edge_done;
266
267 if ( edge2 && !edge2->blue_edge )
268 {
269 ah_align_linked_edge( hinter, edge1, edge2, dimension );
270 edge2->flags |= ah_edge_done;
271 }
272
273 if ( !anchor )
274 anchor = edge;
275 }
276 }
277
278 /* now, we will align all stem edges, trying to maintain the */
279 /* relative order of stems in the glyph.. */
280 before = 0;
281 after = 0;
282 for ( edge = edges; edge < edge_limit; edge++ )
283 {
284 AH_Edge *edge2;
285
286
287 if ( edge->flags & ah_edge_done )
288 continue;
289
290 /* skip all non-stem edges */
291 edge2 = edge->link;
292 if ( !edge2 )
293 {
294 has_serifs++;
295 continue;
296 }
297
298 /* now, align the stem */
299
300 /* this should not happen, but it's better to be safe.. */
301 if ( edge2->blue_edge || edge2 < edge )
302 {
303
304#if 0
305 printf( "strange blue alignement, edge %d to %d\n",
306 edge - edges, edge2 - edges );
307#endif
308
309 ah_align_linked_edge( hinter, edge2, edge, dimension );
310 edge->flags |= ah_edge_done;
311 continue;
312 }
313
314 {
315 FT_Bool min = 0;
316 FT_Pos delta;
317
318 if ( !anchor )
319 {
320 edge->pos = ( edge->opos + 32 ) & -64;
321 anchor = edge;
322 }
323 else
324 edge->pos = anchor->pos +
325 ( ( edge->opos - anchor->opos + 32 ) & -64 );
326
327 edge->flags |= ah_edge_done;
328
329 if ( edge > edges && edge->pos < edge[-1].pos )
330 {
331 edge->pos = edge[-1].pos;
332 min = 1;
333 }
334
335 ah_align_linked_edge( hinter, edge, edge2, dimension );
336 delta = 0;
337 if ( edge2 + 1 < edge_limit &&
338 edge2[1].flags & ah_edge_done )
339 delta = edge2[1].pos - edge2->pos;
340
341 if ( delta < 0 )
342 {
343 edge2->pos += delta;
344 if ( !min )
345 edge->pos += delta;
346 }
347 edge2->flags |= ah_edge_done;
348 }
349 }
350
351 if ( !has_serifs )
352 goto Next_Dimension;
353
354 /* now, hint the remaining edges (serifs and single) in order */
355 /* to complete our processing */
356 for ( edge = edges; edge < edge_limit; edge++ )
357 {
358 if ( edge->flags & ah_edge_done )
359 continue;
360
361 if ( edge->serif )
362 {
363 ah_align_serif_edge( hinter, edge->serif, edge );
364 }
365 else if ( !anchor )
366 {
367 edge->pos = ( edge->opos + 32 ) & -64;
368 anchor = edge;
369 }
370 else
371 edge->pos = anchor->pos +
372 ( ( edge->opos-anchor->opos + 32 ) & -64 );
373
374 edge->flags |= ah_edge_done;
375
376 if ( edge > edges && edge->pos < edge[-1].pos )
377 edge->pos = edge[-1].pos;
378
379 if ( edge + 1 < edge_limit &&
380 edge[1].flags & ah_edge_done &&
381 edge->pos > edge[1].pos )
382 edge->pos = edge[1].pos;
383 }
384
385 Next_Dimension:
386 edges = outline->vert_edges;
387 edge_limit = edges + outline->num_vedges;
388 }
389 }
390
391
392 LOCAL_FUNC
393 void ah_hinter_hint_edges( AH_Hinter* hinter,
394 int no_horz_edges,
395 int no_vert_edges )
396 {
397 disable_horz_edges = no_horz_edges;
398 disable_vert_edges = no_vert_edges;
399
400 /* AH_Interpolate_Blue_Edges( hinter ); -- doesn't seem to help */
401 /* reduce the problem of the disappearing eye in the `e' of Times... */
402 /* also, creates some artifacts near the blue zones? */
403 {
404 ah_hint_edges_3( hinter );
405
406#if 0
407 /* outline optimizer removed temporarily */
408 if ( hinter->flags & ah_hinter_optimize )
409 {
410 AH_Optimizer opt;
411
412
413 if ( !AH_Optimizer_Init( &opt, hinter->glyph, hinter->memory ) )
414 {
415 AH_Optimizer_Compute( &opt );
416 AH_Optimizer_Done( &opt );
417 }
418 }
419#endif
420
421 }
422 }
423
424
425 /*************************************************************************/
426 /*************************************************************************/
427 /*************************************************************************/
428 /**** ****/
429 /**** P O I N T H I N T I N G ****/
430 /**** ****/
431 /*************************************************************************/
432 /*************************************************************************/
433 /*************************************************************************/
434
435 static
436 void ah_hinter_align_edge_points( AH_Hinter* hinter )
437 {
438 AH_Outline* outline = hinter->glyph;
439 AH_Edge* edges;
440 AH_Edge* edge_limit;
441 FT_Int dimension;
442
443
444 edges = outline->horz_edges;
445 edge_limit = edges + outline->num_hedges;
446
447 for ( dimension = 1; dimension >= 0; dimension-- )
448 {
449 AH_Edge* edge;
450 AH_Edge* before;
451 AH_Edge* after;
452
453
454 before = 0;
455 after = 0;
456
457 edge = edges;
458 for ( ; edge < edge_limit; edge++ )
459 {
460 /* move the points of each segment */
461 /* in each edge to the edge's position */
462 AH_Segment* seg = edge->first;
463
464
465 do
466 {
467 AH_Point* point = seg->first;
468
469
470 for (;;)
471 {
472 if ( dimension )
473 {
474 point->y = edge->pos;
475 point->flags |= ah_flah_touch_y;
476 }
477 else
478 {
479 point->x = edge->pos;
480 point->flags |= ah_flah_touch_x;
481 }
482
483 if ( point == seg->last )
484 break;
485
486 point = point->next;
487 }
488
489 seg = seg->edge_next;
490
491 } while ( seg != edge->first );
492 }
493
494 edges = outline->vert_edges;
495 edge_limit = edges + outline->num_vedges;
496 }
497 }
498
499
500 /* hint the strong points -- this is equivalent to the TrueType `IP' */
501 static
502 void ah_hinter_align_strong_points( AH_Hinter* hinter )
503 {
504 AH_Outline* outline = hinter->glyph;
505 FT_Int dimension;
506 AH_Edge* edges;
507 AH_Edge* edge_limit;
508 AH_Point* points;
509 AH_Point* point_limit;
510 AH_Flags touch_flag;
511
512
513 points = outline->points;
514 point_limit = points + outline->num_points;
515
516 edges = outline->horz_edges;
517 edge_limit = edges + outline->num_hedges;
518 touch_flag = ah_flah_touch_y;
519
520 for ( dimension = 1; dimension >= 0; dimension-- )
521 {
522 AH_Point* point;
523 AH_Edge* edge;
524 AH_Edge* before;
525 AH_Edge* after;
526
527
528 before = 0;
529 after = 0;
530
531 if ( edges < edge_limit )
532 for ( point = points; point < point_limit; point++ )
533 {
534 FT_Pos u, ou, fu; /* point position */
535 FT_Pos delta;
536
537
538 if ( point->flags & touch_flag )
539 continue;
540
541#ifndef AH_OPTION_NO_WEAK_INTERPOLATION
542 /* if this point is candidate to weak interpolation, we will */
543 /* interpolate it after all strong points have been processed */
544 if ( point->flags & ah_flah_weak_interpolation )
545 continue;
546#endif
547
548 if ( dimension )
549 {
550 u = point->fy;
551 ou = point->oy;
552 }
553 else
554 {
555 u = point->fx;
556 ou = point->ox;
557 }
558
559 fu = u;
560
561 /* is the point before the first edge? */
562 edge = edges;
563 delta = edge->fpos - u;
564 if ( delta >= 0 )
565 {
566 u = edge->pos - ( edge->opos - ou );
567 goto Store_Point;
568 }
569
570 /* is the point after the last edge ? */
571 edge = edge_limit - 1;
572 delta = u - edge->fpos;
573 if ( delta >= 0 )
574 {
575 u = edge->pos + ( ou - edge->opos );
576 goto Store_Point;
577 }
578
579 /* otherwise, interpolate the point in between */
580 {
581 AH_Edge* before = 0;
582 AH_Edge* after = 0;
583
584
585 for ( edge = edges; edge < edge_limit; edge++ )
586 {
587 if ( u == edge->fpos )
588 {
589 u = edge->pos;
590 goto Store_Point;
591 }
592 if ( u < edge->fpos )
593 break;
594 before = edge;
595 }
596
597 for ( edge = edge_limit - 1; edge >= edges; edge-- )
598 {
599 if ( u == edge->fpos )
600 {
601 u = edge->pos;
602 goto Store_Point;
603 }
604 if ( u > edge->fpos )
605 break;
606 after = edge;
607 }
608
609 /* assert( before && after && before != after ) */
610 u = before->pos + FT_MulDiv( fu - before->fpos,
611 after->pos - before->pos,
612 after->fpos - before->fpos );
613 }
614
615 Store_Point:
616
617 /* save the point position */
618 if ( dimension )
619 point->y = u;
620 else
621 point->x = u;
622
623 point->flags |= touch_flag;
624 }
625
626 edges = outline->vert_edges;
627 edge_limit = edges + outline->num_vedges;
628 touch_flag = ah_flah_touch_x;
629 }
630 }
631
632
633#ifndef AH_OPTION_NO_WEAK_INTERPOLATION
634
635 static
636 void ah_iup_shift( AH_Point* p1,
637 AH_Point* p2,
638 AH_Point* ref )
639 {
640 AH_Point* p;
641 FT_Pos delta = ref->u - ref->v;
642
643
644 for ( p = p1; p < ref; p++ )
645 p->u = p->v + delta;
646
647 for ( p = ref + 1; p <= p2; p++ )
648 p->u = p->v + delta;
649 }
650
651
652 static
653 void ah_iup_interp( AH_Point* p1,
654 AH_Point* p2,
655 AH_Point* ref1,
656 AH_Point* ref2 )
657 {
658 AH_Point* p;
659 FT_Pos u;
660 FT_Pos v1 = ref1->v;
661 FT_Pos v2 = ref2->v;
662 FT_Pos d1 = ref1->u - v1;
663 FT_Pos d2 = ref2->u - v2;
664
665
666 if ( p1 > p2 )
667 return;
668
669 if ( v1 == v2 )
670 {
671 for ( p = p1; p <= p2; p++ )
672 {
673 FT_Pos u = p->v;
674
675
676 if ( u <= v1 )
677 u += d1;
678 else
679 u += d2;
680
681 p->u = u;
682 }
683 return;
684 }
685
686 if ( v1 < v2 )
687 {
688 for ( p = p1; p <= p2; p++ )
689 {
690 u = p->v;
691
692 if ( u <= v1 )
693 u += d1;
694 else if ( u >= v2 )
695 u += d2;
696 else
697 u = ref1->u + FT_MulDiv( u - v1, ref2->u - ref1->u, v2 - v1 );
698
699 p->u = u;
700 }
701 }
702 else
703 {
704 for ( p = p1; p <= p2; p++ )
705 {
706 u = p->v;
707
708 if ( u <= v2 )
709 u += d2;
710 else if ( u >= v1 )
711 u += d1;
712 else
713 u = ref1->u + FT_MulDiv( u - v1, ref2->u - ref1->u, v2 - v1 );
714
715 p->u = u;
716 }
717 }
718 }
719
720
721 /* interpolate weak points -- this is equivalent to the TrueType `IUP' */
722 static
723 void ah_hinter_align_weak_points( AH_Hinter* hinter )
724 {
725 AH_Outline* outline = hinter->glyph;
726 FT_Int dimension;
727 AH_Edge* edges;
728 AH_Edge* edge_limit;
729 AH_Point* points;
730 AH_Point* point_limit;
731 AH_Point** contour_limit;
732 AH_Flags touch_flag;
733
734
735 points = outline->points;
736 point_limit = points + outline->num_points;
737
738 /* PASS 1: Move segment points to edge positions */
739
740 edges = outline->horz_edges;
741 edge_limit = edges + outline->num_hedges;
742 touch_flag = ah_flah_touch_y;
743
744 contour_limit = outline->contours + outline->num_contours;
745
746 ah_setup_uv( outline, ah_uv_oy );
747
748 for ( dimension = 1; dimension >= 0; dimension-- )
749 {
750 AH_Point* point;
751 AH_Point* end_point;
752 AH_Point* first_point;
753 AH_Point** contour;
754
755
756 point = points;
757 contour = outline->contours;
758
759 for ( ; contour < contour_limit; contour++ )
760 {
761 point = *contour;
762 end_point = point->prev;
763 first_point = point;
764
765 while ( point <= end_point && !( point->flags & touch_flag ) )
766 point++;
767
768 if ( point <= end_point )
769 {
770 AH_Point* first_touched = point;
771 AH_Point* cur_touched = point;
772
773
774 point++;
775 while ( point <= end_point )
776 {
777 if ( point->flags & touch_flag )
778 {
779 /* we found two successive touched points; we interpolate */
780 /* all contour points between them */
781 ah_iup_interp( cur_touched + 1, point - 1,
782 cur_touched, point );
783 cur_touched = point;
784 }
785 point++;
786 }
787
788 if ( cur_touched == first_touched )
789 {
790 /* this is a special case: only one point was touched in the */
791 /* contour; we thus simply shift the whole contour */
792 ah_iup_shift( first_point, end_point, cur_touched );
793 }
794 else
795 {
796 /* now interpolate after the last touched point to the end */
797 /* of the contour */
798 ah_iup_interp( cur_touched + 1, end_point,
799 cur_touched, first_touched );
800
801 /* if the first contour point isn't touched, interpolate */
802 /* from the contour start to the first touched point */
803 if ( first_touched > points )
804 ah_iup_interp( first_point, first_touched - 1,
805 cur_touched, first_touched );
806 }
807 }
808 }
809
810 /* now save the interpolated values back to x/y */
811 if ( dimension )
812 {
813 for ( point = points; point < point_limit; point++ )
814 point->y = point->u;
815
816 touch_flag = ah_flah_touch_x;
817 ah_setup_uv( outline, ah_uv_ox );
818 }
819 else
820 {
821 for ( point = points; point < point_limit; point++ )
822 point->x = point->u;
823
824 break; /* exit loop */
825 }
826 }
827 }
828
829#endif /* !AH_OPTION_NO_WEAK_INTERPOLATION */
830
831
832 LOCAL_FUNC
833 void ah_hinter_align_points( AH_Hinter* hinter )
834 {
835 ah_hinter_align_edge_points( hinter );
836
837#ifndef AH_OPTION_NO_STRONG_INTERPOLATION
838 ah_hinter_align_strong_points( hinter );
839#endif
840
841#ifndef AH_OPTION_NO_WEAK_INTERPOLATION
842 ah_hinter_align_weak_points( hinter );
843#endif
844 }
845
846
847 /*************************************************************************/
848 /*************************************************************************/
849 /*************************************************************************/
850 /**** ****/
851 /**** H I N T E R O B J E C T M E T H O D S ****/
852 /**** ****/
853 /*************************************************************************/
854 /*************************************************************************/
855 /*************************************************************************/
856
857
858 /* scale and fit the global metrics */
859 static
860 void ah_hinter_scale_globals( AH_Hinter* hinter,
861 FT_Fixed x_scale,
862 FT_Fixed y_scale )
863 {
864 FT_Int n;
865 AH_Face_Globals* globals = hinter->globals;
866 AH_Globals* design = &globals->design;
867 AH_Globals* scaled = &globals->scaled;
868
869
870 /* copy content */
871 *scaled = *design;
872
873 /* scale the standard widths & heights */
874 for ( n = 0; n < design->num_widths; n++ )
875 scaled->widths[n] = FT_MulFix( design->widths[n], x_scale );
876
877 for ( n = 0; n < design->num_heights; n++ )
878 scaled->heights[n] = FT_MulFix( design->heights[n], y_scale );
879
880 /* scale the blue zones */
881 for ( n = 0; n < ah_blue_max; n++ )
882 {
883 FT_Pos delta, delta2;
884
885
886 delta = design->blue_shoots[n] - design->blue_refs[n];
887 delta2 = delta;
888 if ( delta < 0 )
889 delta2 = -delta2;
890 delta2 = FT_MulFix( delta2, y_scale );
891
892 if ( delta2 < 32 )
893 delta2 = 0;
894 else if ( delta2 < 64 )
895 delta2 = 32 + ( ( ( delta2 - 32 ) + 16 ) & -32 );
896 else
897 delta2 = ( delta2 + 32 ) & -64;
898
899 if ( delta < 0 )
900 delta2 = -delta2;
901
902 scaled->blue_refs[n] =
903 ( FT_MulFix( design->blue_refs[n], y_scale ) + 32 ) & -64;
904 scaled->blue_shoots[n] = scaled->blue_refs[n] + delta2;
905 }
906
907 globals->x_scale = x_scale;
908 globals->y_scale = y_scale;
909 }
910
911
912 static
913 void ah_hinter_align( AH_Hinter* hinter )
914 {
915 ah_hinter_align_edge_points( hinter );
916 ah_hinter_align_points( hinter );
917 }
918
919
920 /* finalize a hinter object */
921 void ah_hinter_done( AH_Hinter* hinter )
922 {
923 if ( hinter )
924 {
925 FT_Memory memory = hinter->memory;
926
927
928 ah_loader_done( hinter->loader );
929 ah_outline_done( hinter->glyph );
930
931 /* note: the `globals' pointer is _not_ owned by the hinter */
932 /* but by the current face object, we don't need to */
933 /* release it */
934 hinter->globals = 0;
935 hinter->face = 0;
936
937 FREE( hinter );
938 }
939 }
940
941
942 /* create a new empty hinter object */
943 FT_Error ah_hinter_new( FT_Library library,
944 AH_Hinter** ahinter )
945 {
946 AH_Hinter* hinter = 0;
947 FT_Memory memory = library->memory;
948 FT_Error error;
949
950
951 *ahinter = 0;
952
953 /* allocate object */
954 if ( ALLOC( hinter, sizeof ( *hinter ) ) )
955 goto Exit;
956
957 hinter->memory = memory;
958 hinter->flags = 0;
959
960 /* allocate outline and loader */
961 error = ah_outline_new( memory, &hinter->glyph ) ||
962 ah_loader_new ( memory, &hinter->loader ) ||
963 ah_loader_create_extra( hinter->loader );
964 if ( error )
965 goto Exit;
966
967 *ahinter = hinter;
968
969 Exit:
970 if ( error )
971 ah_hinter_done( hinter );
972
973 return error;
974 }
975
976
977 /* create a face's autohint globals */
978 FT_Error ah_hinter_new_face_globals( AH_Hinter* hinter,
979 FT_Face face,
980 AH_Globals* globals )
981 {
982 FT_Error error;
983 FT_Memory memory = hinter->memory;
984 AH_Face_Globals* face_globals;
985
986
987 if ( ALLOC( face_globals, sizeof ( *face_globals ) ) )
988 goto Exit;
989
990 hinter->face = face;
991 hinter->globals = face_globals;
992
993 if ( globals )
994 face_globals->design = *globals;
995 else
996 ah_hinter_compute_globals( hinter );
997
998 face->autohint.data = face_globals;
999 face->autohint.finalizer = (FT_Generic_Finalizer)
1000 ah_hinter_done_face_globals;
1001 face_globals->face = face;
1002
1003 Exit:
1004 return error;
1005 }
1006
1007
1008 /* discard a face's autohint globals */
1009 void ah_hinter_done_face_globals( AH_Face_Globals* globals )
1010 {
1011 FT_Face face = globals->face;
1012 FT_Memory memory = face->memory;
1013
1014
1015 FREE( globals );
1016 }
1017
1018
1019 static
1020 FT_Error ah_hinter_load( AH_Hinter* hinter,
1021 FT_UInt glyph_index,
1022 FT_UInt load_flags,
1023 FT_UInt depth )
1024 {
1025 FT_Face face = hinter->face;
1026 FT_GlyphSlot slot = face->glyph;
1027 FT_Fixed x_scale = face->size->metrics.x_scale;
1028 FT_Fixed y_scale = face->size->metrics.y_scale;
1029 FT_Glyph_Metrics metrics; /* temporary metrics */
1030 FT_Error error;
1031 AH_Outline* outline = hinter->glyph;
1032 AH_Loader* gloader = hinter->loader;
1033 FT_Bool no_horz_hints =
1034 ( load_flags & AH_HINT_NO_HORZ_EDGES ) != 0;
1035 FT_Bool no_vert_hints =
1036 ( load_flags & AH_HINT_NO_VERT_EDGES ) != 0;
1037
1038
1039 /* load the glyph */
1040 error = FT_Load_Glyph( face, glyph_index, load_flags );
1041 if ( error )
1042 goto Exit;
1043
1044 /* save current glyph metrics */
1045 metrics = slot->metrics;
1046
1047 switch ( slot->format )
1048 {
1049 case ft_glyph_format_outline:
1050 /* first of all, copy the outline points in the loader's current */
1051 /* extra points, which is used to keep original glyph coordinates */
1052 error = ah_loader_check_points( gloader, slot->outline.n_points + 2,
1053 slot->outline.n_contours );
1054 if ( error )
1055 goto Exit;
1056
1057 MEM_Copy( gloader->current.extra_points, slot->outline.points,
1058 slot->outline.n_points * sizeof ( FT_Vector ) );
1059
1060 MEM_Copy( gloader->current.outline.contours, slot->outline.contours,
1061 slot->outline.n_contours * sizeof ( short ) );
1062
1063 MEM_Copy( gloader->current.outline.tags, slot->outline.tags,
1064 slot->outline.n_points * sizeof ( char ) );
1065
1066 gloader->current.outline.n_points = slot->outline.n_points;
1067 gloader->current.outline.n_contours = slot->outline.n_contours;
1068
1069 /* compute original phantom points */
1070 hinter->pp1.x = 0;
1071 hinter->pp1.y = 0;
1072 hinter->pp2.x = FT_MulFix( slot->metrics.horiAdvance, x_scale );
1073 hinter->pp2.y = 0;
1074
1075 /* be sure to check for spacing glyphs */
1076 if ( slot->outline.n_points == 0 )
1077 goto Hint_Metrics;
1078
1079 /* now, load the slot image into the auto-outline, and run the */
1080 /* automatic hinting process */
1081 error = ah_outline_load( outline, face ); /* XXX: change to slot */
1082 if ( error )
1083 goto Exit;
1084
1085 /* perform feature detection */
1086 ah_outline_detect_features( outline );
1087
1088 if ( !no_horz_hints )
1089 {
1090 ah_outline_compute_blue_edges( outline, hinter->globals );
1091 ah_outline_scale_blue_edges( outline, hinter->globals );
1092 }
1093
1094 /* perform alignment control */
1095 ah_hinter_hint_edges( hinter, no_horz_hints, no_vert_hints );
1096 ah_hinter_align( hinter );
1097
1098 /* now save the current outline into the loader's current table */
1099 ah_outline_save( outline, gloader );
1100
1101 /* we now need to hint the metrics according to the change in */
1102 /* width/positioning that occured during the hinting process */
1103 {
1104 FT_Pos old_width, new_width;
1105 FT_Pos old_advance, new_advance;
1106 FT_Pos old_lsb, new_lsb;
1107 AH_Edge* edge1 = outline->vert_edges; /* leftmost edge */
1108 AH_Edge* edge2 = edge1 +
1109 outline->num_vedges - 1; /* rightmost edge */
1110
1111
1112 old_width = edge2->opos - edge1->opos;
1113 new_width = edge2->pos - edge1->pos;
1114
1115 old_advance = hinter->pp2.x;
1116 old_lsb = edge1->opos;
1117 new_lsb = edge1->pos;
1118
1119 new_advance = old_advance +
1120 ( new_width + new_lsb - old_width - old_lsb );
1121
1122 hinter->pp1.x = ( ( new_lsb - old_lsb ) + 32 ) & -64;
1123 hinter->pp2.x = ( ( edge2->pos +
1124 ( old_advance - edge2->opos ) ) + 32 ) & -64;
1125 }
1126
1127 /* good, we simply add the glyph to our loader's base */
1128 ah_loader_add( gloader );
1129 break;
1130
1131 case ft_glyph_format_composite:
1132 {
1133 FT_UInt nn, num_subglyphs = slot->num_subglyphs;
1134 FT_UInt num_base_subgs, start_point, start_contour;
1135 FT_SubGlyph* subglyph;
1136
1137
1138 start_point = gloader->base.outline.n_points;
1139 start_contour = gloader->base.outline.n_contours;
1140
1141 /* first of all, copy the subglyph descriptors in the glyph loader */
1142 error = ah_loader_check_subglyphs( gloader, num_subglyphs );
1143 if ( error )
1144 goto Exit;
1145
1146 MEM_Copy( gloader->current.subglyphs, slot->subglyphs,
1147 num_subglyphs * sizeof ( FT_SubGlyph ) );
1148
1149 gloader->current.num_subglyphs = num_subglyphs;
1150 num_base_subgs = gloader->base.num_subglyphs;
1151
1152 /* now, read each subglyph independently */
1153 for ( nn = 0; nn < num_subglyphs; nn++ )
1154 {
1155 FT_Vector pp1, pp2;
1156 FT_Pos x, y;
1157 FT_UInt num_points, num_new_points, num_base_points;
1158
1159
1160 /* gloader.current.subglyphs can change during glyph loading due */
1161 /* to re-allocation -- we must recompute the current subglyph on */
1162 /* each iteration */
1163 subglyph = gloader->base.subglyphs + num_base_subgs + nn;
1164
1165 pp1 = hinter->pp1;
1166 pp2 = hinter->pp2;
1167
1168 num_base_points = gloader->base.outline.n_points;
1169
1170 error = ah_hinter_load( hinter, subglyph->index,
1171 load_flags, depth + 1 );
1172 if ( error )
1173 goto Exit;
1174
1175 /* recompute subglyph pointer */
1176 subglyph = gloader->base.subglyphs + num_base_subgs + nn;
1177
1178 if ( subglyph->flags & FT_SUBGLYPH_FLAG_USE_MY_METRICS )
1179 {
1180 pp1 = hinter->pp1;
1181 pp2 = hinter->pp2;
1182 }
1183 else
1184 {
1185 hinter->pp1 = pp1;
1186 hinter->pp2 = pp2;
1187 }
1188
1189 num_points = gloader->base.outline.n_points;
1190 num_new_points = num_points - num_base_points;
1191
1192 /* now perform the transform required for this subglyph */
1193
1194 if ( subglyph->flags & ( FT_SUBGLYPH_FLAG_SCALE |
1195 FT_SUBGLYPH_FLAG_XY_SCALE |
1196 FT_SUBGLYPH_FLAG_2X2 ) )
1197 {
1198 FT_Vector* cur = gloader->base.outline.points +
1199 num_base_points;
1200 FT_Vector* org = gloader->base.extra_points +
1201 num_base_points;
1202 FT_Vector* limit = cur + num_new_points;
1203
1204
1205 for ( ; cur < limit; cur++, org++ )
1206 {
1207 FT_Vector_Transform( cur, &subglyph->transform );
1208 FT_Vector_Transform( org, &subglyph->transform );
1209 }
1210 }
1211
1212 /* apply offset */
1213
1214 if ( !( subglyph->flags & FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES ) )
1215 {
1216 FT_Int k = subglyph->arg1;
1217 FT_UInt l = subglyph->arg2;
1218 FT_Vector* p1;
1219 FT_Vector* p2;
1220
1221
1222 if ( start_point + k >= num_base_points ||
1223 l >= (FT_UInt)num_new_points )
1224 {
1225 error = FT_Err_Invalid_Composite;
1226 goto Exit;
1227 }
1228
1229 l += num_base_points;
1230
1231 /* for now, only use the current point coordinates */
1232 /* we may consider another approach in the near future */
1233 p1 = gloader->base.outline.points + start_point + k;
1234 p2 = gloader->base.outline.points + start_point + l;
1235
1236 x = p1->x - p2->x;
1237 y = p1->y - p2->y;
1238 }
1239 else
1240 {
1241 x = FT_MulFix( subglyph->arg1, x_scale );
1242 y = FT_MulFix( subglyph->arg2, y_scale );
1243
1244 x = ( x + 32 ) & -64;
1245 y = ( y + 32 ) & -64;
1246 }
1247
1248 {
1249 FT_Outline dummy = gloader->base.outline;
1250
1251
1252 dummy.points += num_base_points;
1253 dummy.n_points = num_new_points;
1254
1255 FT_Outline_Translate( &dummy, x, y );
1256 }
1257 }
1258 }
1259 break;
1260
1261 default:
1262 /* we don't support other formats (yet?) */
1263 error = FT_Err_Unimplemented_Feature;
1264 }
1265
1266 Hint_Metrics:
1267 if ( depth == 0 )
1268 {
1269 FT_BBox bbox;
1270
1271
1272 /* we must translate our final outline by -pp1.x, and compute */
1273 /* the new metrics */
1274 if ( hinter->pp1.x )
1275 FT_Outline_Translate( &gloader->base.outline, -hinter->pp1.x, 0 );
1276
1277 FT_Outline_Get_CBox( &gloader->base.outline, &bbox );
1278 bbox.xMin &= -64;
1279 bbox.yMin &= -64;
1280 bbox.xMax = ( bbox.xMax + 63 ) & -64;
1281 bbox.yMax = ( bbox.yMax + 63 ) & -64;
1282
1283 slot->metrics.width = bbox.xMax - bbox.xMin;
1284 slot->metrics.height = bbox.yMax - bbox.yMin;
1285 slot->metrics.horiBearingX = bbox.xMin;
1286 slot->metrics.horiBearingY = bbox.yMax;
1287 slot->metrics.horiAdvance = hinter->pp2.x - hinter->pp1.x;
1288 /* XXX: TO DO - slot->linearHoriAdvance */
1289
1290 /* now copy outline into glyph slot */
1291 ah_loader_rewind( slot->loader );
1292 error = ah_loader_copy_points( slot->loader, gloader );
1293 if ( error )
1294 goto Exit;
1295
1296 slot->outline = slot->loader->base.outline;
1297 slot->format = ft_glyph_format_outline;
1298 }
1299
1300 Exit:
1301 return error;
1302 }
1303
1304
1305 /* load and hint a given glyph */
1306 FT_Error ah_hinter_load_glyph( AH_Hinter* hinter,
1307 FT_GlyphSlot slot,
1308 FT_Size size,
1309 FT_UInt glyph_index,
1310 FT_Int load_flags )
1311 {
1312 FT_Face face = slot->face;
1313 FT_Error error;
1314 FT_Fixed x_scale = size->metrics.x_scale;
1315 FT_Fixed y_scale = size->metrics.y_scale;
1316 AH_Face_Globals* face_globals = FACE_GLOBALS( face );
1317
1318
1319 /* first of all, we need to check that we're using the correct face and */
1320 /* global hints to load the glyph */
1321 if ( hinter->face != face || hinter->globals != face_globals )
1322 {
1323 hinter->face = face;
1324 if ( !face_globals )
1325 {
1326 error = ah_hinter_new_face_globals( hinter, face, 0 );
1327 if ( error )
1328 goto Exit;
1329 }
1330 hinter->globals = FACE_GLOBALS( face );
1331 face_globals = FACE_GLOBALS( face );
1332 }
1333
1334 /* now, we must check the current character pixel size to see if we */
1335 /* need to rescale the global metrics */
1336 if ( face_globals->x_scale != x_scale ||
1337 face_globals->y_scale != y_scale )
1338 ah_hinter_scale_globals( hinter, x_scale, y_scale );
1339
1340 load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_RECURSE;
1341
1342 ah_loader_rewind( hinter->loader );
1343
1344 error = ah_hinter_load( hinter, glyph_index, load_flags, 0 );
1345
1346 Exit:
1347 return error;
1348 }
1349
1350
1351 /* retrieve a face's autohint globals for client applications */
1352 void ah_hinter_get_global_hints( AH_Hinter* hinter,
1353 FT_Face face,
1354 void** global_hints,
1355 long* global_len )
1356 {
1357 AH_Globals* globals = 0;
1358 FT_Memory memory = hinter->memory;
1359 FT_Error error;
1360
1361
1362 /* allocate new master globals */
1363 if ( ALLOC( globals, sizeof ( *globals ) ) )
1364 goto Fail;
1365
1366 /* compute face globals if needed */
1367 if ( !FACE_GLOBALS( face ) )
1368 {
1369 error = ah_hinter_new_face_globals( hinter, face, 0 );
1370 if ( error )
1371 goto Fail;
1372 }
1373
1374 *globals = FACE_GLOBALS( face )->design;
1375 *global_hints = globals;
1376 *global_len = sizeof( *globals );
1377
1378 return;
1379
1380 Fail:
1381 FREE( globals );
1382
1383 *global_hints = 0;
1384 *global_len = 0;
1385 }
1386
1387
1388 void ah_hinter_done_global_hints( AH_Hinter* hinter,
1389 void* global_hints )
1390 {
1391 FT_Memory memory = hinter->memory;
1392
1393
1394 FREE( global_hints );
1395 }
1396
1397
1398/* END */
wxWidgets (Impactor)