Update freetype to 2.5.4.

third_party/freetype/src/smooth/ftgrays.c

 /***************************************************************************/
 /*                                                                         */
 /*  ftgrays.c                                                              */
 /*                                                                         */
 /*    A new `perfect' anti-aliasing renderer (body).                       */
 /*                                                                         */
-/*  Copyright 2000-2003, 2005-2013 by                                      */
+/*  Copyright 2000-2003, 2005-2014 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.                                        */
 /*                                                                         */
 /***************************************************************************/
 
   /*************************************************************************/
   /*                                                                       */
   /* This file can be compiled without the rest of the FreeType engine, by */
   /* defining the _STANDALONE_ macro when compiling it.  You also need to  */
   /* put the files `ftgrays.h' and `ftimage.h' into the current            */
   /* compilation directory.  Typically, you could do something like        */
   /*                                                                       */
   /* - copy `src/smooth/ftgrays.c' (this file) to your current directory   */
   /*                                                                       */
-  /* - copy `include/freetype/ftimage.h' and `src/smooth/ftgrays.h' to the */
-  /*   same directory                                                      */
+  /* - copy `include/ftimage.h' and `src/smooth/ftgrays.h' to the same     */
+  /*   directory                                                           */
   /*                                                                       */
   /* - compile `ftgrays' with the _STANDALONE_ macro defined, as in        */
   /*                                                                       */
   /*     cc -c -D_STANDALONE_ ftgrays.c                                    */
   /*                                                                       */
   /* The renderer can be initialized with a call to                        */
   /* `ft_gray_raster.raster_new'; an anti-aliased bitmap can be generated  */
   /* with a call to `ft_gray_raster.raster_render'.                        */
   /*                                                                       */
   /* See the comments and documentation in the file `ftimage.h' for more   */
@@ skipping 52 matching lines @@
 #define FT_COMPONENT  trace_smooth
 
 
 #ifdef _STANDALONE_
 
 
   /* Auxiliary macros for token concatenation. */
 #define FT_ERR_XCAT( x, y )  x ## y
 #define FT_ERR_CAT( x, y )   FT_ERR_XCAT( x, y )
 
+#define FT_BEGIN_STMNT  do {
+#define FT_END_STMNT    } while ( 0 )
+
 
   /* define this to dump debugging information */
 /* #define FT_DEBUG_LEVEL_TRACE */
 
 
 #ifdef FT_DEBUG_LEVEL_TRACE
 #include <stdio.h>
 #include <stdarg.h>
 #endif
 
@@ skipping 116 matching lines @@
             raster_reset_,                                        \
             raster_set_mode_,                                     \
             raster_render_,                                       \
             raster_done_                                          \
          };
 
 
 #else /* !_STANDALONE_ */
 
 
-#include "../../include/ft2build.h"
+#include <ft2build.h>
 #include "ftgrays.h"
-#include "../../include/freetype/internal/ftobjs.h"
-#include "../../include/freetype/internal/ftdebug.h"
-#include "../../include/freetype/ftoutln.h"
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_DEBUG_H
+#include FT_OUTLINE_H
 
 #include "ftsmerrs.h"
 
 #include "ftspic.h"
 
 #define Smooth_Err_Invalid_Mode     Smooth_Err_Cannot_Render_Glyph
 #define Smooth_Err_Memory_Overflow  Smooth_Err_Out_Of_Memory
 #define ErrRaster_Memory_Overflow   Smooth_Err_Out_Of_Memory
 
 
@@ skipping 51 matching lines @@
 
 #if PIXEL_BITS >= 6
 #define UPSCALE( x )    ( (x) << ( PIXEL_BITS - 6 ) )
 #define DOWNSCALE( x )  ( (x) >> ( PIXEL_BITS - 6 ) )
 #else
 #define UPSCALE( x )    ( (x) >> ( 6 - PIXEL_BITS ) )
 #define DOWNSCALE( x )  ( (x) << ( 6 - PIXEL_BITS ) )
 #endif
 
 
+  /* Compute `dividend / divisor' and return both its quotient and     */
+  /* remainder, cast to a specific type.  This macro also ensures that */
+  /* the remainder is always positive.                                 */
+#define FT_DIV_MOD( type, dividend, divisor, quotient, remainder ) \
+  FT_BEGIN_STMNT                                                   \
+    (quotient)  = (type)( (dividend) / (divisor) );                \
+    (remainder) = (type)( (dividend) % (divisor) );                \
+    if ( (remainder) < 0 )                                         \
+    {                                                              \
+      (quotient)--;                                                \
+      (remainder) += (type)(divisor);                              \
+    }                                                              \
+  FT_END_STMNT
+
+#ifdef  __arm__
+  /* Work around a bug specific to GCC which make the compiler fail to */
+  /* optimize a division and modulo operation on the same parameters   */
+  /* into a single call to `__aeabi_idivmod'.  See                     */
+  /*                                                                   */
+  /*  http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43721                */
+#undef FT_DIV_MOD
+#define FT_DIV_MOD( type, dividend, divisor, quotient, remainder ) \
+  FT_BEGIN_STMNT                                                   \
+    (quotient)  = (type)( (dividend) / (divisor) );                \
+    (remainder) = (type)( (dividend) - (quotient) * (divisor) );   \
+    if ( (remainder) < 0 )                                         \
+    {                                                              \
+      (quotient)--;                                                \
+      (remainder) += (type)(divisor);                              \
+    }                                                              \
+  FT_END_STMNT
+#endif /* __arm__ */
+
+
   /*************************************************************************/
   /*                                                                       */
   /*   TYPE DEFINITIONS                                                    */
   /*                                                                       */
 
   /* don't change the following types to FT_Int or FT_Pos, since we might */
   /* need to define them to "float" or "double" when experimenting with   */
   /* new algorithms                                                       */
 
   typedef long  TCoord;   /* integer scanline/pixel coordinate */
@@ skipping 218 matching lines @@
     *pcell      = cell;
 
   Exit:
     return cell;
   }
 
 
   static void
   gray_record_cell( RAS_ARG )
   {
-    if ( !ras.invalid && ( ras.area | ras.cover ) )
+    if ( ras.area | ras.cover )
     {
       PCell  cell = gray_find_cell( RAS_VAR );
 
 
       cell->area  += ras.area;
       cell->cover += ras.cover;
     }
   }
 
 
@@ skipping 28 matching lines @@
 
     /* are we moving to a different cell ? */
     if ( ex != ras.ex || ey != ras.ey )
     {
       /* record the current one if it is valid */
       if ( !ras.invalid )
         gray_record_cell( RAS_VAR );
 
       ras.area  = 0;
       ras.cover = 0;
+      ras.ex    = ex;
+      ras.ey    = ey;
     }
 
-    ras.ex      = ex;
-    ras.ey      = ey;
     ras.invalid = ( (unsigned)ey >= (unsigned)ras.count_ey ||
                               ex >= ras.count_ex           );
   }
 
 
   /*************************************************************************/
   /*                                                                       */
   /* Start a new contour at a given cell.                                  */
   /*                                                                       */
   static void
@@ skipping 65 matching lines @@
     incr  = 1;
 
     if ( dx < 0 )
     {
       p     = fx1 * ( y2 - y1 );
       first = 0;
       incr  = -1;
       dx    = -dx;
     }
 
-    delta = (TCoord)( p / dx );
-    mod   = (TCoord)( p % dx );
-    if ( mod < 0 )
-    {
-      delta--;
-      mod += (TCoord)dx;
-    }
+    FT_DIV_MOD( TCoord, p, dx, delta, mod );
 
     ras.area  += (TArea)(( fx1 + first ) * delta);
     ras.cover += delta;
 
     ex1 += incr;
     gray_set_cell( RAS_VAR_ ex1, ey );
     y1  += delta;
 
     if ( ex1 != ex2 )
     {
       TCoord  lift, rem;
 
 
-      p    = ONE_PIXEL * ( y2 - y1 + delta );
-      lift = (TCoord)( p / dx );
-      rem  = (TCoord)( p % dx );
-      if ( rem < 0 )
-      {
-        lift--;
-        rem += (TCoord)dx;
-      }
+      p = ONE_PIXEL * ( y2 - y1 + delta );
+      FT_DIV_MOD( TCoord, p, dx, lift, rem );
 
       mod -= (int)dx;
 
       while ( ex1 != ex2 )
       {
         delta = lift;
         mod  += rem;
         if ( mod >= 0 )
         {
           mod -= (TCoord)dx;
@@ skipping 29 matching lines @@
 
 
     ey1 = TRUNC( ras.last_ey );
     ey2 = TRUNC( to_y );     /* if (ey2 >= ras.max_ey) ey2 = ras.max_ey-1; */
     fy1 = (TCoord)( ras.y - ras.last_ey );
     fy2 = (TCoord)( to_y - SUBPIXELS( ey2 ) );
 
     dx = to_x - ras.x;
     dy = to_y - ras.y;
 
-    /* XXX: we should do something about the trivial case where dx == 0, */
-    /*      as it happens very often!                                    */
-
     /* perform vertical clipping */
     {
       TCoord  min, max;
 
 
       min = ey1;
       max = ey2;
       if ( ey1 > ey2 )
       {
         min = ey2;
@@ skipping 58 matching lines @@
     incr  = 1;
 
     if ( dy < 0 )
     {
       p     = fy1 * dx;
       first = 0;
       incr  = -1;
       dy    = -dy;
     }
 
-    delta = (int)( p / dy );
-    mod   = (int)( p % dy );
-    if ( mod < 0 )
-    {
-      delta--;
-      mod += (TCoord)dy;
-    }
+    FT_DIV_MOD( int, p, dy, delta, mod );
 
     x = ras.x + delta;
     gray_render_scanline( RAS_VAR_ ey1, ras.x, fy1, x, (TCoord)first );
 
     ey1 += incr;
     gray_set_cell( RAS_VAR_ TRUNC( x ), ey1 );
 
     if ( ey1 != ey2 )
     {
       p     = ONE_PIXEL * dx;
-      lift  = (int)( p / dy );
-      rem   = (int)( p % dy );
-      if ( rem < 0 )
-      {
-        lift--;
-        rem += (int)dy;
-      }
+      FT_DIV_MOD( int, p, dy, lift, rem );
       mod -= (int)dy;
 
       while ( ey1 != ey2 )
       {
         delta = lift;
         mod  += rem;
         if ( mod >= 0 )
         {
           mod -= (int)dy;
           delta++;
@@ skipping 193 matching lines @@
       /* F. Hain, at                                                      */
       /* http://www.cis.southalabama.edu/~hain/general/Publications/Bezier/Camera-ready%20CISST02%202.pdf */
 
       {
         TPos  dx, dy, dx_, dy_;
         TPos  dx1, dy1, dx2, dy2;
         TPos  L, s, s_limit;
 
 
         /* dx and dy are x and y components of the P0-P3 chord vector. */
-        dx = arc[3].x - arc[0].x;
-        dy = arc[3].y - arc[0].y;
+        dx = dx_ = arc[3].x - arc[0].x;
+        dy = dy_ = arc[3].y - arc[0].y;
 
-        /* L is an (under)estimate of the Euclidean distance P0-P3.       */
-        /*                                                                */
-        /* If dx >= dy, then r = sqrt(dx^2 + dy^2) can be overestimated   */
-        /* with least maximum error by                                    */
-        /*                                                                */
-        /*   r_upperbound = dx + (sqrt(2) - 1) * dy  ,                    */
-        /*                                                                */
-        /* where sqrt(2) - 1 can be (over)estimated by 107/256, giving an */
-        /* error of no more than 8.4%.                                    */
-        /*                                                                */
-        /* Similarly, some elementary calculus shows that r can be        */
-        /* underestimated with least maximum error by                     */
-        /*                                                                */
-        /*   r_lowerbound = sqrt(2 + sqrt(2)) / 2 * dx                    */
-        /*                  + sqrt(2 - sqrt(2)) / 2 * dy  .               */
-        /*                                                                */
-        /* 236/256 and 97/256 are (under)estimates of the two algebraic   */
-        /* numbers, giving an error of no more than 8.1%.                 */
-
-        dx_ = FT_ABS( dx );
-        dy_ = FT_ABS( dy );
-
-        /* This is the same as                     */
-        /*                                         */
-        /*   L = ( 236 * FT_MAX( dx_, dy_ )        */
-        /*       + 97 * FT_MIN( dx_, dy_ ) ) >> 8; */
-        L = ( dx_ > dy_ ? 236 * dx_ +  97 * dy_
-                        :  97 * dx_ + 236 * dy_ ) >> 8;
+        L = FT_HYPOT( dx_, dy_ );
 
         /* Avoid possible arithmetic overflow below by splitting. */
         if ( L > 32767 )
           goto Split;
 
         /* Max deviation may be as much as (s/L) * 3/4 (if Hain's v = 1). */
         s_limit = L * (TPos)( ONE_PIXEL / 6 );
 
         /* s is L * the perpendicular distance from P1 to the line P0-P3. */
         dx1 = arc[1].x - arc[0].x;
@@ skipping 39 matching lines @@
 
 
   static int
   gray_move_to( const FT_Vector*  to,
                 gray_PWorker      worker )
   {
     TPos  x, y;
 
 
     /* record current cell, if any */
-    gray_record_cell( RAS_VAR );
+    if ( !ras.invalid )
+      gray_record_cell( RAS_VAR );
 
     /* start to a new position */
     x = UPSCALE( to->x );
     y = UPSCALE( to->y );
 
     gray_start_cell( RAS_VAR_ TRUNC( x ), TRUNC( y ) );
 
     worker->x = x;
     worker->y = y;
     return 0;
@@ skipping 164 matching lines @@
             FT_TRACE7(( "[%d..%d]:%02x ",
                         span->x, span->x + span->len - 1, span->coverage ));
           FT_TRACE7(( "\n" ));
         }
 
 #endif /* FT_DEBUG_LEVEL_TRACE */
 
         ras.num_gray_spans = 0;
         ras.span_y         = (int)y;
 
-        count = 0;
         span  = ras.gray_spans;
       }
       else
         span++;
-          // Fix the Vulnerability Report FoxIT Reader - MSVR-10-0077.
-          // Limited to the value range of 'x', we have to crop it for avoid the overflow.
-          if (x < 32768) {
+
       /* add a gray span to the current list */
       span->x        = (short)x;
       span->len      = (unsigned short)acount;
       span->coverage = (unsigned char)coverage;
 
       ras.num_gray_spans++;
-          }
     }
   }
 
 
 #ifdef FT_DEBUG_LEVEL_TRACE
 
   /* to be called while in the debugger --                                */
   /* this function causes a compiler warning since it is unused otherwise */
   static void
   gray_dump_cells( RAS_ARG )
@@ skipping 144 matching lines @@
     int         error;
 
     int   n;         /* index of contour in outline     */
     int   first;     /* index of first point in contour */
     char  tag;       /* current point's state           */
 
     int   shift;
     TPos  delta;
 
 
-    if ( !outline || !func_interface )
+    if ( !outline )
+      return FT_THROW( Invalid_Outline );
+
+    if ( !func_interface )
       return FT_THROW( Invalid_Argument );
 
     shift = func_interface->shift;
     delta = func_interface->delta;
     first = 0;
 
     for ( n = 0; n < outline->n_contours; n++ )
     {
       int  last;  /* index of last point in contour */
 
@@ skipping 224 matching lines @@
   static int
   gray_convert_glyph_inner( RAS_ARG )
   {
 
     volatile int  error = 0;
 
 #ifdef FT_CONFIG_OPTION_PIC
       FT_Outline_Funcs func_interface;
       Init_Class_func_interface(&func_interface);
 #endif
-#ifndef _FX_MANAGED_CODE_    
+
     if ( ft_setjmp( ras.jump_buffer ) == 0 )
     {
-#endif
       error = FT_Outline_Decompose( &ras.outline, &func_interface, &ras );
-      gray_record_cell( RAS_VAR );
-#ifndef _FX_MANAGED_CODE_ 
-        }
+      if ( !ras.invalid )
+        gray_record_cell( RAS_VAR );
+    }
     else
       error = FT_THROW( Memory_Overflow );
-#endif
+
     return error;
   }
 
 
   static int
   gray_convert_glyph( RAS_ARG )
   {
     gray_TBand            bands[40];
     gray_TBand* volatile  band;
     int volatile          n, num_bands;
@@ skipping 307 matching lines @@
       else
       {
         rast->buffer      = NULL;
         rast->buffer_size = 0;
         rast->worker      = NULL;
       }
     }
   }
 
 
+  static int
+  gray_raster_set_mode( FT_Raster      raster,
+                        unsigned long  mode,
+                        void*          args )
+  {
+    FT_UNUSED( raster );
+    FT_UNUSED( mode );
+    FT_UNUSED( args );
+
+
+    return 0; /* nothing to do */
+  }
+
+
   FT_DEFINE_RASTER_FUNCS(ft_grays_raster,
     FT_GLYPH_FORMAT_OUTLINE,
 
     (FT_Raster_New_Func)     gray_raster_new,
     (FT_Raster_Reset_Func)   gray_raster_reset,
-    (FT_Raster_Set_Mode_Func)0,
+    (FT_Raster_Set_Mode_Func)gray_raster_set_mode,
     (FT_Raster_Render_Func)  gray_raster_render,
     (FT_Raster_Done_Func)    gray_raster_done
   )
 
 
 /* END */
 
 
 /* Local Variables: */
 /* coding: utf-8    */
 /* End:             */