Update freetype to 2.5.4.

third_party/freetype/src/raster/ftraster.c

 /***************************************************************************/
 /*                                                                         */
 /*  ftraster.c                                                             */
 /*                                                                         */
 /*    The FreeType glyph rasterizer (body).                                */
 /*                                                                         */
-/*  Copyright 1996-2003, 2005, 2007-2013 by                                */
+/*  Copyright 1996-2003, 2005, 2007-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 `ftimage.h' and `ftmisc.h' into the $(incdir)           */
   /* directory.  Typically, you should do something like                   */
   /*                                                                       */
   /* - copy `src/raster/ftraster.c' (this file) to your current directory  */
   /*                                                                       */
-  /* - copy `include/freetype/ftimage.h' and `src/raster/ftmisc.h'         */
-  /*   to your current directory                                           */
+  /* - copy `include/ftimage.h' and `src/raster/ftmisc.h' to your current  */
+  /*   directory                                                           */
   /*                                                                       */
   /* - compile `ftraster' with the _STANDALONE_ macro defined, as in       */
   /*                                                                       */
   /*     cc -c -D_STANDALONE_ ftraster.c                                   */
   /*                                                                       */
   /* The renderer can be initialized with a call to                        */
   /* `ft_standard_raster.raster_new'; a bitmap can be generated            */
   /* with a call to `ft_standard_raster.raster_render'.                    */
   /*                                                                       */
   /* See the comments and documentation in the file `ftimage.h' for more   */
@@ skipping 12 matching lines @@
 
 #define FT_CONFIG_STANDARD_LIBRARY_H  <stdlib.h>
 
 #include <string.h>           /* for memset */
 
 #include "ftmisc.h"
 #include "ftimage.h"
 
 #else /* !_STANDALONE_ */
 
-#include "../../include/ft2build.h"
+#include <ft2build.h>
 #include "ftraster.h"
-#include "../../include/freetype/internal/ftcalc.h"   /* for FT_MulDiv and FT_MulDiv_No_Round */
+#include FT_INTERNAL_CALC_H   /* for FT_MulDiv and FT_MulDiv_No_Round */
 
 #include "rastpic.h"
 
 #endif /* !_STANDALONE_ */
 
 
   /*************************************************************************/
   /*                                                                       */
   /* A simple technical note on how the raster works                       */
   /* -----------------------------------------------                       */
@@ skipping 149 matching lines @@
             raster_new_,                                            \
             raster_reset_,                                          \
             raster_set_mode_,                                       \
             raster_render_,                                         \
             raster_done_                                            \
          };
 
 #else /* !_STANDALONE_ */
 
 
-#include "../../include/freetype/internal/ftobjs.h"
-#include "../../include/freetype/internal/ftdebug.h"       /* for FT_TRACE, FT_ERROR, and FT_THROW */
+#include FT_INTERNAL_OBJECTS_H
+#include FT_INTERNAL_DEBUG_H       /* for FT_TRACE, FT_ERROR, and FT_THROW */
 
 #include "rasterrs.h"
 
 #define Raster_Err_None         FT_Err_Ok
 #define Raster_Err_Not_Ini      Raster_Err_Raster_Uninitialized
 #define Raster_Err_Overflow     Raster_Err_Raster_Overflow
 #define Raster_Err_Neg_Height   Raster_Err_Raster_Negative_Height
 #define Raster_Err_Invalid      Raster_Err_Invalid_Outline
 #define Raster_Err_Unsupported  Raster_Err_Cannot_Render_Glyph
 
@@ skipping 1622 matching lines @@
         limit--;
       }
       else
       {
         /* if both first and last points are conic,         */
         /* start at their middle and record its position    */
         /* for closure                                      */
         v_start.x = ( v_start.x + v_last.x ) / 2;
         v_start.y = ( v_start.y + v_last.y ) / 2;
 
-        v_last = v_start;
+     /* v_last = v_start; */
       }
       point--;
       tags--;
     }
 
     ras.lastX = v_start.x;
     ras.lastY = v_start.y;
 
     while ( point < limit )
     {
@@ skipping 389 matching lines @@
   static void
   Vertical_Sweep_Span( RAS_ARGS Short       y,
                                 FT_F26Dot6  x1,
                                 FT_F26Dot6  x2,
                                 PProfile    left,
                                 PProfile    right )
   {
     Long   e1, e2;
     Byte*  target;
 
+    Int  dropOutControl = left->flags & 7;
+
     FT_UNUSED( y );
     FT_UNUSED( left );
     FT_UNUSED( right );
 
 
     /* Drop-out control */
 
     e1 = TRUNC( CEILING( x1 ) );
 
-    if ( x2 - x1 - ras.precision <= ras.precision_jitter )
+    if ( dropOutControl != 2                             &&
+         x2 - x1 - ras.precision <= ras.precision_jitter )
       e2 = e1;
     else
       e2 = TRUNC( FLOOR( x2 ) );
 
     if ( e2 >= 0 && e1 < ras.bWidth )
     {
       int   c1, c2;
       Byte  f1, f2;
 
 
@@ skipping 236 matching lines @@
       {
         Byte   f1;
         PByte  bits;
 
 
         bits = ras.bTarget + ( y >> 3 );
         f1   = (Byte)( 0x80 >> ( y & 7 ) );
 
         e1 = TRUNC( e1 );
 
-        if ( e1 >= 0 && e1 < ras.target.rows )
+        if ( e1 >= 0 && (ULong)e1 < ras.target.rows )
         {
           PByte  p;
 
 
           p = bits - e1 * ras.target.pitch;
           if ( ras.target.pitch > 0 )
             p += ( ras.target.rows - 1 ) * ras.target.pitch;
 
           p[0] |= f1;
         }
@@ skipping 73 matching lines @@
 
         default: /* modes 2, 3, 6, 7 */
           return;  /* no drop-out control */
         }
 
         /* undocumented but confirmed: If the drop-out would result in a  */
         /* pixel outside of the bounding box, use the pixel inside of the */
         /* bounding box instead                                           */
         if ( pxl < 0 )
           pxl = e1;
-        else if ( TRUNC( pxl ) >= ras.target.rows )
+        else if ( (ULong)( TRUNC( pxl ) ) >= ras.target.rows )
           pxl = e2;
 
         /* check that the other pixel isn't set */
         e1 = pxl == e1 ? e2 : e1;
 
         e1 = TRUNC( e1 );
 
         bits = ras.bTarget + ( y >> 3 );
         f1   = (Byte)( 0x80 >> ( y & 7 ) );
 
         bits -= e1 * ras.target.pitch;
         if ( ras.target.pitch > 0 )
           bits += ( ras.target.rows - 1 ) * ras.target.pitch;
 
-        if ( e1 >= 0              &&
-             e1 < ras.target.rows &&
-             *bits & f1           )
+        if ( e1 >= 0                     &&
+             (ULong)e1 < ras.target.rows &&
+             *bits & f1                  )
           return;
       }
       else
         return;
     }
 
     bits = ras.bTarget + ( y >> 3 );
     f1   = (Byte)( 0x80 >> ( y & 7 ) );
 
     e1 = TRUNC( pxl );
 
-    if ( e1 >= 0 && e1 < ras.target.rows )
+    if ( e1 >= 0 && (ULong)e1 < ras.target.rows )
     {
       bits -= e1 * ras.target.pitch;
       if ( ras.target.pitch > 0 )
         bits += ( ras.target.rows - 1 ) * ras.target.pitch;
 
       bits[0] |= f1;
     }
   }
 
 
@@ skipping 845 matching lines @@
       else
       {
         raster->buffer      = NULL;
         raster->buffer_size = 0;
         raster->worker      = NULL;
       }
     }
   }
 
 
-  static void
+  static int
   ft_black_set_mode( black_PRaster  raster,
                      unsigned long  mode,
                      const char*    palette )
   {
 #ifdef FT_RASTER_OPTION_ANTI_ALIASING
 
     if ( mode == FT_MAKE_TAG( 'p', 'a', 'l', '5' ) )
     {
       /* set 5-levels gray palette */
       raster->grays[0] = palette[0];
       raster->grays[1] = palette[1];
       raster->grays[2] = palette[2];
       raster->grays[3] = palette[3];
       raster->grays[4] = palette[4];
     }
 
 #else
 
     FT_UNUSED( raster );
     FT_UNUSED( mode );
     FT_UNUSED( palette );
 
 #endif
+
+    return 0;
   }
 
 
   static int
   ft_black_render( black_PRaster            raster,
                    const FT_Raster_Params*  params )
   {
     const FT_Outline*  outline    = (const FT_Outline*)params->source;
     const FT_Bitmap*   target_map = params->target;
     black_PWorker      worker;
@@ skipping 55 matching lines @@
     FT_GLYPH_FORMAT_OUTLINE,
     (FT_Raster_New_Func)     ft_black_new,
     (FT_Raster_Reset_Func)   ft_black_reset,
     (FT_Raster_Set_Mode_Func)ft_black_set_mode,
     (FT_Raster_Render_Func)  ft_black_render,
     (FT_Raster_Done_Func)    ft_black_done
   )
 
 
 /* END */