Update bundled freetype to 2.6.1

third_party/freetype/src/pshinter/pshalgo.c

 /***************************************************************************/
 /*                                                                         */
 /*  pshalgo.c                                                              */
 /*                                                                         */
 /*    PostScript hinting algorithm (body).                                 */
 /*                                                                         */
-/*  Copyright 2001-2010, 2012-2014 by                                      */
+/*  Copyright 2001-2015 by                                                 */
 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 /*                                                                         */
 /*  This file is part of the FreeType project, and may only be used        */
 /*  modified and distributed under the terms of the FreeType project       */
 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
 /*  this file you indicate that you have read the license and              */
 /*  understand and accept it fully.                                        */
 /*                                                                         */
 /***************************************************************************/
 
 
 #include <ft2build.h>
 #include FT_INTERNAL_OBJECTS_H
 #include FT_INTERNAL_DEBUG_H
 #include FT_INTERNAL_CALC_H
 #include "pshalgo.h"
 
 #include "pshnterr.h"
 
 
 #undef  FT_COMPONENT
 #define FT_COMPONENT  trace_pshalgo2
 
 
 #ifdef DEBUG_HINTER
-  PSH_Hint_Table  ps_debug_hint_table = 0;
-  PSH_HintFunc    ps_debug_hint_func  = 0;
-  PSH_Glyph       ps_debug_glyph      = 0;
+  PSH_Hint_Table  ps_debug_hint_table = NULL;
+  PSH_HintFunc    ps_debug_hint_func  = NULL;
+  PSH_Glyph       ps_debug_glyph      = NULL;
 #endif
 
 
 #define  COMPUTE_INFLEXS  /* compute inflection points to optimize `S' */
                           /* and similar glyphs                        */
-#define  STRONGER         /* slightly increase the contrast of smooth  */
-                          /* hinting                                   */
 
 
   /*************************************************************************/
   /*************************************************************************/
   /*****                                                               *****/
   /*****                  BASIC HINTS RECORDINGS                       *****/
   /*****                                                               *****/
   /*************************************************************************/
   /*************************************************************************/
 
   /* return true if two stem hints overlap */
   static FT_Int
   psh_hint_overlap( PSH_Hint  hint1,
                     PSH_Hint  hint2 )
   {
     return hint1->org_pos + hint1->org_len >= hint2->org_pos &&
            hint2->org_pos + hint2->org_len >= hint1->org_pos;
   }
 
 
   /* destroy hints table */
   static void
   psh_hint_table_done( PSH_Hint_Table  table,
                        FT_Memory       memory )
   {
     FT_FREE( table->zones );
     table->num_zones = 0;
-    table->zone      = 0;
+    table->zone      = NULL;
 
     FT_FREE( table->sort );
     FT_FREE( table->hints );
     table->num_hints   = 0;
     table->max_hints   = 0;
-    table->sort_global = 0;
+    table->sort_global = NULL;
   }
 
 
   /* deactivate all hints in a table */
   static void
   psh_hint_table_deactivate( PSH_Hint_Table  table )
   {
     FT_UInt   count = table->max_hints;
     PSH_Hint  hint  = table->hints;
 
@@ skipping 27 matching lines @@
     psh_hint_activate( hint );
 
     /* now scan the current active hint set to check */
     /* whether `hint' overlaps with another hint     */
     {
       PSH_Hint*  sorted = table->sort_global;
       FT_UInt    count  = table->num_hints;
       PSH_Hint   hint2;
 
 
-      hint->parent = 0;
+      hint->parent = NULL;
       for ( ; count > 0; count--, sorted++ )
       {
         hint2 = sorted[0];
 
         if ( psh_hint_overlap( hint, hint2 ) )
         {
           hint->parent = hint2;
           break;
         }
       }
@@ skipping 52 matching lines @@
     /* allocate our tables */
     if ( FT_NEW_ARRAY( table->sort,  2 * count     ) ||
          FT_NEW_ARRAY( table->hints,     count     ) ||
          FT_NEW_ARRAY( table->zones, 2 * count + 1 ) )
       goto Exit;
 
     table->max_hints   = count;
     table->sort_global = table->sort + count;
     table->num_hints   = 0;
     table->num_zones   = 0;
-    table->zone        = 0;
+    table->zone        = NULL;
 
     /* initialize the `table->hints' array */
     {
       PSH_Hint  write = table->hints;
       PS_Hint   read  = hints->hints;
 
 
       for ( ; count > 0; count--, write++, read++ )
       {
         write->org_pos = read->pos;
@@ skipping 675 matching lines @@
 
 
   /*************************************************************************/
   /*************************************************************************/
   /*****                                                               *****/
   /*****                POINTS INTERPOLATION ROUTINES                  *****/
   /*****                                                               *****/
   /*************************************************************************/
   /*************************************************************************/
 
-#define PSH_ZONE_MIN  -3200000L
-#define PSH_ZONE_MAX  +3200000L
-
 #define xxDEBUG_ZONES
 
 
 #ifdef DEBUG_ZONES
 
 #include FT_CONFIG_STANDARD_LIBRARY_H
 
   static void
   psh_print_zone( PSH_Zone  zone )
   {
     printf( "zone [scale,delta,min,max] = [%.3f,%.3f,%d,%d]\n",
              zone->scale / 65536.0,
              zone->delta / 64.0,
              zone->min,
              zone->max );
   }
 
-#else
-
-#define psh_print_zone( x )  do { } while ( 0 )
-
 #endif /* DEBUG_ZONES */
 
 
   /*************************************************************************/
   /*************************************************************************/
   /*****                                                               *****/
   /*****                    HINTER GLYPH MANAGEMENT                    *****/
   /*****                                                               *****/
   /*************************************************************************/
   /*************************************************************************/
 
-#if 1
-
 #define  psh_corner_is_flat      ft_corner_is_flat
 #define  psh_corner_orientation  ft_corner_orientation
 
-#else
-
-  FT_LOCAL_DEF( FT_Int )
-  psh_corner_is_flat( FT_Pos  x_in,
-                      FT_Pos  y_in,
-                      FT_Pos  x_out,
-                      FT_Pos  y_out )
-  {
-    FT_Pos  ax = x_in;
-    FT_Pos  ay = y_in;
-
-    FT_Pos  d_in, d_out, d_corner;
-
-
-    if ( ax < 0 )
-      ax = -ax;
-    if ( ay < 0 )
-      ay = -ay;
-    d_in = ax + ay;
-
-    ax = x_out;
-    if ( ax < 0 )
-      ax = -ax;
-    ay = y_out;
-    if ( ay < 0 )
-      ay = -ay;
-    d_out = ax + ay;
-
-    ax = x_out + x_in;
-    if ( ax < 0 )
-      ax = -ax;
-    ay = y_out + y_in;
-    if ( ay < 0 )
-      ay = -ay;
-    d_corner = ax + ay;
-
-    return ( d_in + d_out - d_corner ) < ( d_corner >> 4 );
-  }
-
-  static FT_Int
-  psh_corner_orientation( FT_Pos  in_x,
-                          FT_Pos  in_y,
-                          FT_Pos  out_x,
-                          FT_Pos  out_y )
-  {
-    FT_Int  result;
-
-
-    /* deal with the trivial cases quickly */
-    if ( in_y == 0 )
-    {
-      if ( in_x >= 0 )
-        result = out_y;
-      else
-        result = -out_y;
-    }
-    else if ( in_x == 0 )
-    {
-      if ( in_y >= 0 )
-        result = -out_x;
-      else
-        result = out_x;
-    }
-    else if ( out_y == 0 )
-    {
-      if ( out_x >= 0 )
-        result = in_y;
-      else
-        result = -in_y;
-    }
-    else if ( out_x == 0 )
-    {
-      if ( out_y >= 0 )
-        result = -in_x;
-      else
-        result =  in_x;
-    }
-    else /* general case */
-    {
-      long long  delta = (long long)in_x * out_y - (long long)in_y * out_x;
-
-      if ( delta == 0 )
-        result = 0;
-      else
-        result = 1 - 2 * ( delta < 0 );
-    }
-
-    return result;
-  }
-
-#endif /* !1 */
-
 
 #ifdef COMPUTE_INFLEXS
 
   /* compute all inflex points in a given glyph */
   static void
   psh_glyph_compute_inflections( PSH_Glyph  glyph )
   {
     FT_UInt  n;
 
 
@@ skipping 107 matching lines @@
 
     psh_hint_table_done( &glyph->hint_tables[1], memory );
     psh_hint_table_done( &glyph->hint_tables[0], memory );
 
     FT_FREE( glyph->points );
     FT_FREE( glyph->contours );
 
     glyph->num_points   = 0;
     glyph->num_contours = 0;
 
-    glyph->memory = 0;
+    glyph->memory = NULL;
   }
 
 
   static int
   psh_compute_dir( FT_Pos  dx,
                    FT_Pos  dy )
   {
     FT_Pos  ax, ay;
     int     result = PSH_DIR_NONE;
 
@@ skipping 104 matching lines @@
     /* clear all fields */
     FT_MEM_ZERO( glyph, sizeof ( *glyph ) );
 
     memory = glyph->memory = globals->memory;
 
     /* allocate and setup points + contours arrays */
     if ( FT_NEW_ARRAY( glyph->points,   outline->n_points   ) ||
          FT_NEW_ARRAY( glyph->contours, outline->n_contours ) )
       goto Exit;
 
-    glyph->num_points   = outline->n_points;
-    glyph->num_contours = outline->n_contours;
+    glyph->num_points   = (FT_UInt)outline->n_points;
+    glyph->num_contours = (FT_UInt)outline->n_contours;
 
     {
       FT_UInt      first = 0, next, n;
       PSH_Point    points  = glyph->points;
       PSH_Contour  contour = glyph->contours;
 
 
       for ( n = 0; n < glyph->num_contours; n++ )
       {
-        FT_Int     count;
+        FT_UInt    count;
         PSH_Point  point;
 
 
-        next  = outline->contours[n] + 1;
+        next  = (FT_UInt)outline->contours[n] + 1;
         count = next - first;
 
         contour->start = points + first;
-        contour->count = (FT_UInt)count;
+        contour->count = count;
 
         if ( count > 0 )
         {
           point = points + first;
 
           point->prev    = points + next - 1;
           point->contour = contour;
 
           for ( ; count > 1; count-- )
           {
@@ skipping 382 matching lines @@
     /* process secondary hints to `selected' points */
     if ( num_masks > 1 && glyph->num_points > 0 )
     {
       /* the `endchar' op can reduce the number of points */
       first = mask->end_point > glyph->num_points
                 ? glyph->num_points
                 : mask->end_point;
       mask++;
       for ( ; num_masks > 1; num_masks--, mask++ )
       {
-        FT_UInt  next;
-        FT_Int   count;
+        FT_UInt  next = FT_MIN( mask->end_point, glyph->num_points );
 
 
-        next  = mask->end_point > glyph->num_points
-                  ? glyph->num_points
-                  : mask->end_point;
-        count = next - first;
-        if ( count > 0 )
+        if ( next > first )
         {
+          FT_UInt    count = next - first;
           PSH_Point  point = glyph->points + first;
 
 
           psh_hint_table_activate_mask( table, mask );
 
           psh_hint_table_find_strong_points( table, point, count,
                                              threshold, major_dir );
         }
         first = next;
       }
@@ skipping 322 matching lines @@
     for ( ; num_contours > 0; num_contours--, contour++ )
     {
       PSH_Point  start = contour->start;
       PSH_Point  first, next, point;
       FT_UInt    fit_count;
 
 
       /* count the number of strong points in this contour */
       next      = start + contour->count;
       fit_count = 0;
-      first     = 0;
+      first     = NULL;
 
       for ( point = start; point < next; point++ )
         if ( psh_point_is_fitted( point ) )
         {
           if ( !first )
             first = point;
 
           fit_count++;
         }
 
@@ skipping 231 matching lines @@
 
 #ifndef DEBUG_HINTER
     psh_glyph_done( glyph );
 #endif
 
     return error;
   }
 
 
 /* END */