XFA: merge patch from CL 817753002
[pdfium.git] / core / src / fxge / fx_freetype / fxft2.5.01 / 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-2004, 2006, 2010, 2012 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 "../../include/ft2build.h"
21 #include "../../include/freetype/freetype.h"
22 #include "../../include/freetype/internal/ftobjs.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                 // XYQ 2006-3-11: FT PS hinter doesn't process wide zone well (all points shrinked to one horizontal line)
315                 // therefore, we have to do some nasty thing here, because some fonts do give wide bottom zones.
316                 // Our principle is to preserve the bottom line
317                 // TEST DOC: bug#395 csl.pdf  letters "y", "j", etc.
318                 if (zone->org_top - zone->org_bottom > 10) {
319                         zone->org_top = zone->org_bottom;
320                         zone->org_delta = 0;
321                 }
322       }
323     }
324
325     /* expand top and bottom tables with blue fuzz */
326     {
327       FT_Int         dim, top, bot, delta;
328       PSH_Blue_Zone  zone;
329
330
331       zone  = top_table->zones;
332       count = count_top;
333
334       for ( dim = 1; dim >= 0; dim-- )
335       {
336         if ( count > 0 )
337         {
338           /* expand the bottom of the lowest zone normally */
339           zone->org_bottom -= fuzz;
340
341           /* expand the top and bottom of intermediate zones;    */
342           /* checking that the interval is smaller than the fuzz */
343           top = zone->org_top;
344
345           for ( count--; count > 0; count-- )
346           {
347             bot   = zone[1].org_bottom;
348             delta = bot - top;
349
350             if ( delta < 2 * fuzz )
351               zone[0].org_top = zone[1].org_bottom = top + delta / 2;
352             else
353             {
354               zone[0].org_top    = top + fuzz;
355               zone[1].org_bottom = bot - fuzz;
356             }
357
358             zone++;
359             top = zone->org_top;
360           }
361
362           /* expand the top of the highest zone normally */
363           zone->org_top = top + fuzz;
364         }
365         zone  = bot_table->zones;
366         count = count_bot;
367       }
368     }
369   }
370
371
372   /* reset the blues table when the device transform changes */
373   static void
374   psh_blues_scale_zones( PSH_Blues  blues,
375                          FT_Fixed   scale,
376                          FT_Pos     delta )
377   {
378     FT_UInt         count;
379     FT_UInt         num;
380     PSH_Blue_Table  table = 0;
381
382     /*                                                        */
383     /* Determine whether we need to suppress overshoots or    */
384     /* not.  We simply need to compare the vertical scale     */
385     /* parameter to the raw bluescale value.  Here is why:    */
386     /*                                                        */
387     /*   We need to suppress overshoots for all pointsizes.   */
388     /*   At 300dpi that satisfies:                            */
389     /*                                                        */
390     /*      pointsize < 240*bluescale + 0.49                  */
391     /*                                                        */
392     /*   This corresponds to:                                 */
393     /*                                                        */
394     /*      pixelsize < 1000*bluescale + 49/24                */
395     /*                                                        */
396     /*      scale*EM_Size < 1000*bluescale + 49/24            */
397     /*                                                        */
398     /*   However, for normal Type 1 fonts, EM_Size is 1000!   */
399     /*   We thus only check:                                  */
400     /*                                                        */
401     /*      scale < bluescale + 49/24000                      */
402     /*                                                        */
403     /*   which we shorten to                                  */
404     /*                                                        */
405     /*      "scale < bluescale"                               */
406     /*                                                        */
407     /* Note that `blue_scale' is stored 1000 times its real   */
408     /* value, and that `scale' converts from font units to    */
409     /* fractional pixels.                                     */
410     /*                                                        */
411
412     /* 1000 / 64 = 125 / 8 */
413     if ( scale >= 0x20C49BAL )
414       blues->no_overshoots = FT_BOOL( scale < blues->blue_scale * 8 / 125 );
415     else
416       blues->no_overshoots = FT_BOOL( scale * 125 < blues->blue_scale * 8 );
417
418     /*                                                        */
419     /*  The blue threshold is the font units distance under   */
420     /*  which overshoots are suppressed due to the BlueShift  */
421     /*  even if the scale is greater than BlueScale.          */
422     /*                                                        */
423     /*  It is the smallest distance such that                 */
424     /*                                                        */
425     /*    dist <= BlueShift && dist*scale <= 0.5 pixels       */
426     /*                                                        */
427     {
428       FT_Int  threshold = blues->blue_shift;
429
430
431       while ( threshold > 0 && FT_MulFix( threshold, scale ) > 32 )
432         threshold--;
433
434       blues->blue_threshold = threshold;
435     }
436
437     for ( num = 0; num < 4; num++ )
438     {
439       PSH_Blue_Zone  zone;
440
441
442       switch ( num )
443       {
444       case 0:
445         table = &blues->normal_top;
446         break;
447       case 1:
448         table = &blues->normal_bottom;
449         break;
450       case 2:
451         table = &blues->family_top;
452         break;
453       default:
454         table = &blues->family_bottom;
455         break;
456       }
457
458       zone  = table->zones;
459       count = table->count;
460       for ( ; count > 0; count--, zone++ )
461       {
462         zone->cur_top    = FT_MulFix( zone->org_top,    scale ) + delta;
463         zone->cur_bottom = FT_MulFix( zone->org_bottom, scale ) + delta;
464         zone->cur_ref    = FT_MulFix( zone->org_ref,    scale ) + delta;
465         zone->cur_delta  = FT_MulFix( zone->org_delta,  scale );
466
467         /* round scaled reference position */
468         zone->cur_ref = FT_PIX_ROUND( zone->cur_ref );
469
470 #if 0
471         if ( zone->cur_ref > zone->cur_top )
472           zone->cur_ref -= 64;
473         else if ( zone->cur_ref < zone->cur_bottom )
474           zone->cur_ref += 64;
475 #endif
476       }
477     }
478
479     /* process the families now */
480
481     for ( num = 0; num < 2; num++ )
482     {
483       PSH_Blue_Zone   zone1, zone2;
484       FT_UInt         count1, count2;
485       PSH_Blue_Table  normal, family;
486
487
488       switch ( num )
489       {
490       case 0:
491         normal = &blues->normal_top;
492         family = &blues->family_top;
493         break;
494
495       default:
496         normal = &blues->normal_bottom;
497         family = &blues->family_bottom;
498       }
499
500       zone1  = normal->zones;
501       count1 = normal->count;
502
503       for ( ; count1 > 0; count1--, zone1++ )
504       {
505         /* try to find a family zone whose reference position is less */
506         /* than 1 pixel far from the current zone                     */
507         zone2  = family->zones;
508         count2 = family->count;
509
510         for ( ; count2 > 0; count2--, zone2++ )
511         {
512           FT_Pos  Delta;
513
514
515           Delta = zone1->org_ref - zone2->org_ref;
516           if ( Delta < 0 )
517             Delta = -Delta;
518
519           if ( FT_MulFix( Delta, scale ) < 64 )
520           {
521             zone1->cur_top    = zone2->cur_top;
522             zone1->cur_bottom = zone2->cur_bottom;
523             zone1->cur_ref    = zone2->cur_ref;
524             zone1->cur_delta  = zone2->cur_delta;
525             break;
526           }
527         }
528       }
529     }
530   }
531
532
533   /* calculate the maximum height of given blue zones */
534   static FT_Short
535   psh_calc_max_height( FT_UInt          num,
536                        const FT_Short*  values,
537                        FT_Short         cur_max )
538   {
539     FT_UInt  count;
540
541
542     for ( count = 0; count < num; count += 2 )
543     {
544       FT_Short  cur_height = values[count + 1] - values[count];
545
546
547       if ( cur_height > cur_max )
548         cur_max = cur_height;
549     }
550
551     return cur_max;
552   }
553
554
555   FT_LOCAL_DEF( void )
556   psh_blues_snap_stem( PSH_Blues      blues,
557                        FT_Int         stem_top,
558                        FT_Int         stem_bot,
559                        PSH_Alignment  alignment )
560   {
561     PSH_Blue_Table  table;
562     FT_UInt         count;
563     FT_Pos          delta;
564     PSH_Blue_Zone   zone;
565     FT_Int          no_shoots;
566
567
568     alignment->align = PSH_BLUE_ALIGN_NONE;
569
570     no_shoots = blues->no_overshoots;
571
572     /* look up stem top in top zones table */
573     table = &blues->normal_top;
574     count = table->count;
575     zone  = table->zones;
576
577     for ( ; count > 0; count--, zone++ )
578     {
579       delta = stem_top - zone->org_bottom;
580       if ( delta < -blues->blue_fuzz )
581         break;
582
583       if ( stem_top <= zone->org_top + blues->blue_fuzz )
584       {
585         if ( no_shoots || delta <= blues->blue_threshold )
586         {
587           alignment->align    |= PSH_BLUE_ALIGN_TOP;
588           alignment->align_top = zone->cur_ref;
589         }
590         break;
591       }
592     }
593
594     /* look up stem bottom in bottom zones table */
595     table = &blues->normal_bottom;
596     count = table->count;
597     zone  = table->zones + count-1;
598
599     for ( ; count > 0; count--, zone-- )
600     {
601       delta = zone->org_top - stem_bot;
602       if ( delta < -blues->blue_fuzz )
603         break;
604
605       if ( stem_bot >= zone->org_bottom - blues->blue_fuzz )
606       {
607         if ( no_shoots || delta < blues->blue_threshold )
608         {
609           alignment->align    |= PSH_BLUE_ALIGN_BOT;
610           alignment->align_bot = zone->cur_ref;
611         }
612         break;
613       }
614     }
615   }
616
617
618   /*************************************************************************/
619   /*************************************************************************/
620   /*****                                                               *****/
621   /*****                        GLOBAL HINTS                           *****/
622   /*****                                                               *****/
623   /*************************************************************************/
624   /*************************************************************************/
625
626   static void
627   psh_globals_destroy( PSH_Globals  globals )
628   {
629     if ( globals )
630     {
631       FT_Memory  memory;
632
633
634       memory = globals->memory;
635       globals->dimension[0].stdw.count = 0;
636       globals->dimension[1].stdw.count = 0;
637
638       globals->blues.normal_top.count    = 0;
639       globals->blues.normal_bottom.count = 0;
640       globals->blues.family_top.count    = 0;
641       globals->blues.family_bottom.count = 0;
642
643       FT_FREE( globals );
644
645 #ifdef DEBUG_HINTER
646       ps_debug_globals = 0;
647 #endif
648     }
649   }
650
651
652   static FT_Error
653   psh_globals_new( FT_Memory     memory,
654                    T1_Private*   priv,
655                    PSH_Globals  *aglobals )
656   {
657     PSH_Globals  globals = NULL;
658     FT_Error     error;
659
660
661     if ( !FT_NEW( globals ) )
662     {
663       FT_UInt    count;
664       FT_Short*  read;
665
666
667       globals->memory = memory;
668
669       /* copy standard widths */
670       {
671         PSH_Dimension  dim   = &globals->dimension[1];
672         PSH_Width      write = dim->stdw.widths;
673
674
675         write->org = priv->standard_width[0];
676         write++;
677
678         read = priv->snap_widths;
679         for ( count = priv->num_snap_widths; count > 0; count-- )
680         {
681           write->org = *read;
682           write++;
683           read++;
684         }
685
686         dim->stdw.count = priv->num_snap_widths + 1;
687       }
688
689       /* copy standard heights */
690       {
691         PSH_Dimension  dim = &globals->dimension[0];
692         PSH_Width      write = dim->stdw.widths;
693
694
695         write->org = priv->standard_height[0];
696         write++;
697         read = priv->snap_heights;
698         for ( count = priv->num_snap_heights; count > 0; count-- )
699         {
700           write->org = *read;
701           write++;
702           read++;
703         }
704
705         dim->stdw.count = priv->num_snap_heights + 1;
706       }
707
708       /* copy blue zones */
709       psh_blues_set_zones( &globals->blues, priv->num_blue_values,
710                            priv->blue_values, priv->num_other_blues,
711                            priv->other_blues, priv->blue_fuzz, 0 );
712
713       psh_blues_set_zones( &globals->blues, priv->num_family_blues,
714                            priv->family_blues, priv->num_family_other_blues,
715                            priv->family_other_blues, priv->blue_fuzz, 1 );
716
717       /* limit the BlueScale value to `1 / max_of_blue_zone_heights' */
718       {
719         FT_Fixed  max_scale;
720         FT_Short  max_height = 1;
721
722
723         max_height = psh_calc_max_height( priv->num_blue_values,
724                                           priv->blue_values,
725                                           max_height );
726         max_height = psh_calc_max_height( priv->num_other_blues,
727                                           priv->other_blues,
728                                           max_height );
729         max_height = psh_calc_max_height( priv->num_family_blues,
730                                           priv->family_blues,
731                                           max_height );
732         max_height = psh_calc_max_height( priv->num_family_other_blues,
733                                           priv->family_other_blues,
734                                           max_height );
735
736         /* BlueScale is scaled 1000 times */
737         max_scale = FT_DivFix( 1000, max_height );
738         globals->blues.blue_scale = priv->blue_scale < max_scale
739                                       ? priv->blue_scale
740                                       : max_scale;
741       }
742
743       globals->blues.blue_shift = priv->blue_shift;
744       globals->blues.blue_fuzz  = priv->blue_fuzz;
745
746       globals->dimension[0].scale_mult  = 0;
747       globals->dimension[0].scale_delta = 0;
748       globals->dimension[1].scale_mult  = 0;
749       globals->dimension[1].scale_delta = 0;
750
751 #ifdef DEBUG_HINTER
752       ps_debug_globals = globals;
753 #endif
754     }
755
756     *aglobals = globals;
757     return error;
758   }
759
760
761   FT_LOCAL_DEF( FT_Error )
762   psh_globals_set_scale( PSH_Globals  globals,
763                          FT_Fixed     x_scale,
764                          FT_Fixed     y_scale,
765                          FT_Fixed     x_delta,
766                          FT_Fixed     y_delta )
767   {
768     PSH_Dimension  dim = &globals->dimension[0];
769
770
771     dim = &globals->dimension[0];
772     if ( x_scale != dim->scale_mult  ||
773          x_delta != dim->scale_delta )
774     {
775       dim->scale_mult  = x_scale;
776       dim->scale_delta = x_delta;
777
778       psh_globals_scale_widths( globals, 0 );
779     }
780
781     dim = &globals->dimension[1];
782     if ( y_scale != dim->scale_mult  ||
783          y_delta != dim->scale_delta )
784     {
785       dim->scale_mult  = y_scale;
786       dim->scale_delta = y_delta;
787
788       psh_globals_scale_widths( globals, 1 );
789       psh_blues_scale_zones( &globals->blues, y_scale, y_delta );
790     }
791
792     return 0;
793   }
794
795
796   FT_LOCAL_DEF( void )
797   psh_globals_funcs_init( PSH_Globals_FuncsRec*  funcs )
798   {
799     funcs->create    = psh_globals_new;
800     funcs->set_scale = psh_globals_set_scale;
801     funcs->destroy   = psh_globals_destroy;
802   }
803
804
805 /* END */