projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[CMAKE]
[reactos.git] / lib / 3rdparty / freetype / src / pshinter / pshglob.c
1 /***************************************************************************/
2 /* */
3 /* pshglob.c */
4 /* */
5 /* PostScript hinter global hinting management (body). */
6 /* Inspired by the new auto-hinter module. */
7 /* */
8 /* Copyright 2001, 2002, 2003, 2004, 2006, 2010 by */
9 /* David Turner, Robert Wilhelm, and Werner Lemberg. */
10 /* */
11 /* This file is part of the FreeType project, and may only be used */
12 /* modified and distributed under the terms of the FreeType project */
13 /* license, LICENSE.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 /***************************************************************************/
18
19
20 #include <ft2build.h>
21 #include FT_FREETYPE_H
22 #include FT_INTERNAL_OBJECTS_H
23 #include "pshglob.h"
24
25 #ifdef DEBUG_HINTER
26 PSH_Globals ps_debug_globals = 0;
27 #endif
28
29
30 /*************************************************************************/
31 /*************************************************************************/
32 /***** *****/
33 /***** STANDARD WIDTHS *****/
34 /***** *****/
35 /*************************************************************************/
36 /*************************************************************************/
37
38
39 /* scale the widths/heights table */
40 static void
41 psh_globals_scale_widths( PSH_Globals globals,
42 FT_UInt direction )
43 {
44 PSH_Dimension dim = &globals->dimension[direction];
45 PSH_Widths stdw = &dim->stdw;
46 FT_UInt count = stdw->count;
47 PSH_Width width = stdw->widths;
48 PSH_Width stand = width; /* standard width/height */
49 FT_Fixed scale = dim->scale_mult;
50
51
52 if ( count > 0 )
53 {
54 width->cur = FT_MulFix( width->org, scale );
55 width->fit = FT_PIX_ROUND( width->cur );
56
57 width++;
58 count--;
59
60 for ( ; count > 0; count--, width++ )
61 {
62 FT_Pos w, dist;
63
64
65 w = FT_MulFix( width->org, scale );
66 dist = w - stand->cur;
67
68 if ( dist < 0 )
69 dist = -dist;
70
71 if ( dist < 128 )
72 w = stand->cur;
73
74 width->cur = w;
75 width->fit = FT_PIX_ROUND( w );
76 }
77 }
78 }
79
80
81 #if 0
82
83 /* org_width is is font units, result in device pixels, 26.6 format */
84 FT_LOCAL_DEF( FT_Pos )
85 psh_dimension_snap_width( PSH_Dimension dimension,
86 FT_Int org_width )
87 {
88 FT_UInt n;
89 FT_Pos width = FT_MulFix( org_width, dimension->scale_mult );
90 FT_Pos best = 64 + 32 + 2;
91 FT_Pos reference = width;
92
93
94 for ( n = 0; n < dimension->stdw.count; n++ )
95 {
96 FT_Pos w;
97 FT_Pos dist;
98
99
100 w = dimension->stdw.widths[n].cur;
101 dist = width - w;
102 if ( dist < 0 )
103 dist = -dist;
104 if ( dist < best )
105 {
106 best = dist;
107 reference = w;
108 }
109 }
110
111 if ( width >= reference )
112 {
113 width -= 0x21;
114 if ( width < reference )
115 width = reference;
116 }
117 else
118 {
119 width += 0x21;
120 if ( width > reference )
121 width = reference;
122 }
123
124 return width;
125 }
126
127 #endif /* 0 */
128
129
130 /*************************************************************************/
131 /*************************************************************************/
132 /***** *****/
133 /***** BLUE ZONES *****/
134 /***** *****/
135 /*************************************************************************/
136 /*************************************************************************/
137
138 static void
139 psh_blues_set_zones_0( PSH_Blues target,
140 FT_Bool is_others,
141 FT_UInt read_count,
142 FT_Short* read,
143 PSH_Blue_Table top_table,
144 PSH_Blue_Table bot_table )
145 {
146 FT_UInt count_top = top_table->count;
147 FT_UInt count_bot = bot_table->count;
148 FT_Bool first = 1;
149
150 FT_UNUSED( target );
151
152
153 for ( ; read_count > 1; read_count -= 2 )
154 {
155 FT_Int reference, delta;
156 FT_UInt count;
157 PSH_Blue_Zone zones, zone;
158 FT_Bool top;
159
160
161 /* read blue zone entry, and select target top/bottom zone */
162 top = 0;
163 if ( first || is_others )
164 {
165 reference = read[1];
166 delta = read[0] - reference;
167
168 zones = bot_table->zones;
169 count = count_bot;
170 first = 0;
171 }
172 else
173 {
174 reference = read[0];
175 delta = read[1] - reference;
176
177 zones = top_table->zones;
178 count = count_top;
179 top = 1;
180 }
181
182 /* insert into sorted table */
183 zone = zones;
184 for ( ; count > 0; count--, zone++ )
185 {
186 if ( reference < zone->org_ref )
187 break;
188
189 if ( reference == zone->org_ref )
190 {
191 FT_Int delta0 = zone->org_delta;
192
193
194 /* we have two zones on the same reference position -- */
195 /* only keep the largest one */
196 if ( delta < 0 )
197 {
198 if ( delta < delta0 )
199 zone->org_delta = delta;
200 }
201 else
202 {
203 if ( delta > delta0 )
204 zone->org_delta = delta;
205 }
206 goto Skip;
207 }
208 }
209
210 for ( ; count > 0; count-- )
211 zone[count] = zone[count-1];
212
213 zone->org_ref = reference;
214 zone->org_delta = delta;
215
216 if ( top )
217 count_top++;
218 else
219 count_bot++;
220
221 Skip:
222 read += 2;
223 }
224
225 top_table->count = count_top;
226 bot_table->count = count_bot;
227 }
228
229
230 /* Re-read blue zones from the original fonts and store them into out */
231 /* private structure. This function re-orders, sanitizes and */
232 /* fuzz-expands the zones as well. */
233 static void
234 psh_blues_set_zones( PSH_Blues target,
235 FT_UInt count,
236 FT_Short* blues,
237 FT_UInt count_others,
238 FT_Short* other_blues,
239 FT_Int fuzz,
240 FT_Int family )
241 {
242 PSH_Blue_Table top_table, bot_table;
243 FT_Int count_top, count_bot;
244
245
246 if ( family )
247 {
248 top_table = &target->family_top;
249 bot_table = &target->family_bottom;
250 }
251 else
252 {
253 top_table = &target->normal_top;
254 bot_table = &target->normal_bottom;
255 }
256
257 /* read the input blue zones, and build two sorted tables */
258 /* (one for the top zones, the other for the bottom zones) */
259 top_table->count = 0;
260 bot_table->count = 0;
261
262 /* first, the blues */
263 psh_blues_set_zones_0( target, 0,
264 count, blues, top_table, bot_table );
265 psh_blues_set_zones_0( target, 1,
266 count_others, other_blues, top_table, bot_table );
267
268 count_top = top_table->count;
269 count_bot = bot_table->count;
270
271 /* sanitize top table */
272 if ( count_top > 0 )
273 {
274 PSH_Blue_Zone zone = top_table->zones;
275
276
277 for ( count = count_top; count > 0; count--, zone++ )
278 {
279 FT_Int delta;
280
281
282 if ( count > 1 )
283 {
284 delta = zone[1].org_ref - zone[0].org_ref;
285 if ( zone->org_delta > delta )
286 zone->org_delta = delta;
287 }
288
289 zone->org_bottom = zone->org_ref;
290 zone->org_top = zone->org_delta + zone->org_ref;
291 }
292 }
293
294 /* sanitize bottom table */
295 if ( count_bot > 0 )
296 {
297 PSH_Blue_Zone zone = bot_table->zones;
298
299
300 for ( count = count_bot; count > 0; count--, zone++ )
301 {
302 FT_Int delta;
303
304
305 if ( count > 1 )
306 {
307 delta = zone[0].org_ref - zone[1].org_ref;
308 if ( zone->org_delta < delta )
309 zone->org_delta = delta;
310 }
311
312 zone->org_top = zone->org_ref;
313 zone->org_bottom = zone->org_delta + zone->org_ref;
314 }
315 }
316
317 /* expand top and bottom tables with blue fuzz */
318 {
319 FT_Int dim, top, bot, delta;
320 PSH_Blue_Zone zone;
321
322
323 zone = top_table->zones;
324 count = count_top;
325
326 for ( dim = 1; dim >= 0; dim-- )
327 {
328 if ( count > 0 )
329 {
330 /* expand the bottom of the lowest zone normally */
331 zone->org_bottom -= fuzz;
332
333 /* expand the top and bottom of intermediate zones; */
334 /* checking that the interval is smaller than the fuzz */
335 top = zone->org_top;
336
337 for ( count--; count > 0; count-- )
338 {
339 bot = zone[1].org_bottom;
340 delta = bot - top;
341
342 if ( delta < 2 * fuzz )
343 zone[0].org_top = zone[1].org_bottom = top + delta / 2;
344 else
345 {
346 zone[0].org_top = top + fuzz;
347 zone[1].org_bottom = bot - fuzz;
348 }
349
350 zone++;
351 top = zone->org_top;
352 }
353
354 /* expand the top of the highest zone normally */
355 zone->org_top = top + fuzz;
356 }
357 zone = bot_table->zones;
358 count = count_bot;
359 }
360 }
361 }
362
363
364 /* reset the blues table when the device transform changes */
365 static void
366 psh_blues_scale_zones( PSH_Blues blues,
367 FT_Fixed scale,
368 FT_Pos delta )
369 {
370 FT_UInt count;
371 FT_UInt num;
372 PSH_Blue_Table table = 0;
373
374 /* */
375 /* Determine whether we need to suppress overshoots or */
376 /* not. We simply need to compare the vertical scale */
377 /* parameter to the raw bluescale value. Here is why: */
378 /* */
379 /* We need to suppress overshoots for all pointsizes. */
380 /* At 300dpi that satisfies: */
381 /* */
382 /* pointsize < 240*bluescale + 0.49 */
383 /* */
384 /* This corresponds to: */
385 /* */
386 /* pixelsize < 1000*bluescale + 49/24 */
387 /* */
388 /* scale*EM_Size < 1000*bluescale + 49/24 */
389 /* */
390 /* However, for normal Type 1 fonts, EM_Size is 1000! */
391 /* We thus only check: */
392 /* */
393 /* scale < bluescale + 49/24000 */
394 /* */
395 /* which we shorten to */
396 /* */
397 /* "scale < bluescale" */
398 /* */
399 /* Note that `blue_scale' is stored 1000 times its real */
400 /* value, and that `scale' converts from font units to */
401 /* fractional pixels. */
402 /* */
403
404 /* 1000 / 64 = 125 / 8 */
405 if ( scale >= 0x20C49BAL )
406 blues->no_overshoots = FT_BOOL( scale < blues->blue_scale * 8 / 125 );
407 else
408 blues->no_overshoots = FT_BOOL( scale * 125 < blues->blue_scale * 8 );
409
410 /* */
411 /* The blue threshold is the font units distance under */
412 /* which overshoots are suppressed due to the BlueShift */
413 /* even if the scale is greater than BlueScale. */
414 /* */
415 /* It is the smallest distance such that */
416 /* */
417 /* dist <= BlueShift && dist*scale <= 0.5 pixels */
418 /* */
419 {
420 FT_Int threshold = blues->blue_shift;
421
422
423 while ( threshold > 0 && FT_MulFix( threshold, scale ) > 32 )
424 threshold--;
425
426 blues->blue_threshold = threshold;
427 }
428
429 for ( num = 0; num < 4; num++ )
430 {
431 PSH_Blue_Zone zone;
432
433
434 switch ( num )
435 {
436 case 0:
437 table = &blues->normal_top;
438 break;
439 case 1:
440 table = &blues->normal_bottom;
441 break;
442 case 2:
443 table = &blues->family_top;
444 break;
445 default:
446 table = &blues->family_bottom;
447 break;
448 }
449
450 zone = table->zones;
451 count = table->count;
452 for ( ; count > 0; count--, zone++ )
453 {
454 zone->cur_top = FT_MulFix( zone->org_top, scale ) + delta;
455 zone->cur_bottom = FT_MulFix( zone->org_bottom, scale ) + delta;
456 zone->cur_ref = FT_MulFix( zone->org_ref, scale ) + delta;
457 zone->cur_delta = FT_MulFix( zone->org_delta, scale );
458
459 /* round scaled reference position */
460 zone->cur_ref = FT_PIX_ROUND( zone->cur_ref );
461
462 #if 0
463 if ( zone->cur_ref > zone->cur_top )
464 zone->cur_ref -= 64;
465 else if ( zone->cur_ref < zone->cur_bottom )
466 zone->cur_ref += 64;
467 #endif
468 }
469 }
470
471 /* process the families now */
472
473 for ( num = 0; num < 2; num++ )
474 {
475 PSH_Blue_Zone zone1, zone2;
476 FT_UInt count1, count2;
477 PSH_Blue_Table normal, family;
478
479
480 switch ( num )
481 {
482 case 0:
483 normal = &blues->normal_top;
484 family = &blues->family_top;
485 break;
486
487 default:
488 normal = &blues->normal_bottom;
489 family = &blues->family_bottom;
490 }
491
492 zone1 = normal->zones;
493 count1 = normal->count;
494
495 for ( ; count1 > 0; count1--, zone1++ )
496 {
497 /* try to find a family zone whose reference position is less */
498 /* than 1 pixel far from the current zone */
499 zone2 = family->zones;
500 count2 = family->count;
501
502 for ( ; count2 > 0; count2--, zone2++ )
503 {
504 FT_Pos Delta;
505
506
507 Delta = zone1->org_ref - zone2->org_ref;
508 if ( Delta < 0 )
509 Delta = -Delta;
510
511 if ( FT_MulFix( Delta, scale ) < 64 )
512 {
513 zone1->cur_top = zone2->cur_top;
514 zone1->cur_bottom = zone2->cur_bottom;
515 zone1->cur_ref = zone2->cur_ref;
516 zone1->cur_delta = zone2->cur_delta;
517 break;
518 }
519 }
520 }
521 }
522 }
523
524
525 FT_LOCAL_DEF( void )
526 psh_blues_snap_stem( PSH_Blues blues,
527 FT_Int stem_top,
528 FT_Int stem_bot,
529 PSH_Alignment alignment )
530 {
531 PSH_Blue_Table table;
532 FT_UInt count;
533 FT_Pos delta;
534 PSH_Blue_Zone zone;
535 FT_Int no_shoots;
536
537
538 alignment->align = PSH_BLUE_ALIGN_NONE;
539
540 no_shoots = blues->no_overshoots;
541
542 /* look up stem top in top zones table */
543 table = &blues->normal_top;
544 count = table->count;
545 zone = table->zones;
546
547 for ( ; count > 0; count--, zone++ )
548 {
549 delta = stem_top - zone->org_bottom;
550 if ( delta < -blues->blue_fuzz )
551 break;
552
553 if ( stem_top <= zone->org_top + blues->blue_fuzz )
554 {
555 if ( no_shoots || delta <= blues->blue_threshold )
556 {
557 alignment->align |= PSH_BLUE_ALIGN_TOP;
558 alignment->align_top = zone->cur_ref;
559 }
560 break;
561 }
562 }
563
564 /* look up stem bottom in bottom zones table */
565 table = &blues->normal_bottom;
566 count = table->count;
567 zone = table->zones + count-1;
568
569 for ( ; count > 0; count--, zone-- )
570 {
571 delta = zone->org_top - stem_bot;
572 if ( delta < -blues->blue_fuzz )
573 break;
574
575 if ( stem_bot >= zone->org_bottom - blues->blue_fuzz )
576 {
577 if ( no_shoots || delta < blues->blue_threshold )
578 {
579 alignment->align |= PSH_BLUE_ALIGN_BOT;
580 alignment->align_bot = zone->cur_ref;
581 }
582 break;
583 }
584 }
585 }
586
587
588 /*************************************************************************/
589 /*************************************************************************/
590 /***** *****/
591 /***** GLOBAL HINTS *****/
592 /***** *****/
593 /*************************************************************************/
594 /*************************************************************************/
595
596 static void
597 psh_globals_destroy( PSH_Globals globals )
598 {
599 if ( globals )
600 {
601 FT_Memory memory;
602
603
604 memory = globals->memory;
605 globals->dimension[0].stdw.count = 0;
606 globals->dimension[1].stdw.count = 0;
607
608 globals->blues.normal_top.count = 0;
609 globals->blues.normal_bottom.count = 0;
610 globals->blues.family_top.count = 0;
611 globals->blues.family_bottom.count = 0;
612
613 FT_FREE( globals );
614
615 #ifdef DEBUG_HINTER
616 ps_debug_globals = 0;
617 #endif
618 }
619 }
620
621
622 static FT_Error
623 psh_globals_new( FT_Memory memory,
624 T1_Private* priv,
625 PSH_Globals *aglobals )
626 {
627 PSH_Globals globals = NULL;
628 FT_Error error;
629
630
631 if ( !FT_NEW( globals ) )
632 {
633 FT_UInt count;
634 FT_Short* read;
635
636
637 globals->memory = memory;
638
639 /* copy standard widths */
640 {
641 PSH_Dimension dim = &globals->dimension[1];
642 PSH_Width write = dim->stdw.widths;
643
644
645 write->org = priv->standard_width[0];
646 write++;
647
648 read = priv->snap_widths;
649 for ( count = priv->num_snap_widths; count > 0; count-- )
650 {
651 write->org = *read;
652 write++;
653 read++;
654 }
655
656 dim->stdw.count = priv->num_snap_widths + 1;
657 }
658
659 /* copy standard heights */
660 {
661 PSH_Dimension dim = &globals->dimension[0];
662 PSH_Width write = dim->stdw.widths;
663
664
665 write->org = priv->standard_height[0];
666 write++;
667 read = priv->snap_heights;
668 for ( count = priv->num_snap_heights; count > 0; count-- )
669 {
670 write->org = *read;
671 write++;
672 read++;
673 }
674
675 dim->stdw.count = priv->num_snap_heights + 1;
676 }
677
678 /* copy blue zones */
679 psh_blues_set_zones( &globals->blues, priv->num_blue_values,
680 priv->blue_values, priv->num_other_blues,
681 priv->other_blues, priv->blue_fuzz, 0 );
682
683 psh_blues_set_zones( &globals->blues, priv->num_family_blues,
684 priv->family_blues, priv->num_family_other_blues,
685 priv->family_other_blues, priv->blue_fuzz, 1 );
686
687 globals->blues.blue_scale = priv->blue_scale;
688 globals->blues.blue_shift = priv->blue_shift;
689 globals->blues.blue_fuzz = priv->blue_fuzz;
690
691 globals->dimension[0].scale_mult = 0;
692 globals->dimension[0].scale_delta = 0;
693 globals->dimension[1].scale_mult = 0;
694 globals->dimension[1].scale_delta = 0;
695
696 #ifdef DEBUG_HINTER
697 ps_debug_globals = globals;
698 #endif
699 }
700
701 *aglobals = globals;
702 return error;
703 }
704
705
706 FT_LOCAL_DEF( FT_Error )
707 psh_globals_set_scale( PSH_Globals globals,
708 FT_Fixed x_scale,
709 FT_Fixed y_scale,
710 FT_Fixed x_delta,
711 FT_Fixed y_delta )
712 {
713 PSH_Dimension dim = &globals->dimension[0];
714
715
716 dim = &globals->dimension[0];
717 if ( x_scale != dim->scale_mult ||
718 x_delta != dim->scale_delta )
719 {
720 dim->scale_mult = x_scale;
721 dim->scale_delta = x_delta;
722
723 psh_globals_scale_widths( globals, 0 );
724 }
725
726 dim = &globals->dimension[1];
727 if ( y_scale != dim->scale_mult ||
728 y_delta != dim->scale_delta )
729 {
730 dim->scale_mult = y_scale;
731 dim->scale_delta = y_delta;
732
733 psh_globals_scale_widths( globals, 1 );
734 psh_blues_scale_zones( &globals->blues, y_scale, y_delta );
735 }
736
737 return 0;
738 }
739
740
741 FT_LOCAL_DEF( void )
742 psh_globals_funcs_init( PSH_Globals_FuncsRec* funcs )
743 {
744 funcs->create = psh_globals_new;
745 funcs->set_scale = psh_globals_set_scale;
746 funcs->destroy = psh_globals_destroy;
747 }
748
749
750 /* END */
A free Windows-compatible Operating System