Update freetype to latest version of ASOP.

src/smooth/ftgrays.c

 /***************************************************************************/
 /*                                                                         */
 /*  ftgrays.c                                                              */
 /*                                                                         */
 /*    A new `perfect' anti-aliasing renderer (body).                       */
 /*                                                                         */
-/*  Copyright 2000-2003, 2005-2012 by                                      */
+/*  Copyright 2000-2003, 2005-2013 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.                                        */
 /*                                                                         */
 /***************************************************************************/
 
@@ skipping 69 matching lines @@
   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
   /* messages during execution.                                            */
   /*                                                                       */
 #undef  FT_COMPONENT
 #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 this to dump debugging information */
 /* #define FT_DEBUG_LEVEL_TRACE */
 
 
 #ifdef FT_DEBUG_LEVEL_TRACE
 #include <stdio.h>
 #include <stdarg.h>
 #endif
 
 #include <stddef.h>
@@ skipping 40 matching lines @@
               ... )
   {
     va_list  ap;
 
 
     va_start( ap, fmt );
     vfprintf( stderr, fmt, ap );
     va_end( ap );
   }
 
+
+  /* empty function useful for setting a breakpoint to catch errors */
+  int
+  FT_Throw( int          error,
+            int          line,
+            const char*  file )
+  {
+    FT_UNUSED( error );
+    FT_UNUSED( line );
+    FT_UNUSED( file );
+
+    return 0;
+  }
+
+
   /* we don't handle tracing levels in stand-alone mode; */
 #ifndef FT_TRACE5
 #define FT_TRACE5( varformat )  FT_Message varformat
 #endif
 #ifndef FT_TRACE7
 #define FT_TRACE7( varformat )  FT_Message varformat
 #endif
 #ifndef FT_ERROR
 #define FT_ERROR( varformat )   FT_Message varformat
 #endif
 
+#define FT_THROW( e )                               \
+          ( FT_Throw( FT_ERR_CAT( ErrRaster, e ),   \
+                      __LINE__,                     \
+                      __FILE__ )                  | \
+            FT_ERR_CAT( ErrRaster, e )            )
+
 #else /* !FT_DEBUG_LEVEL_TRACE */
 
 #define FT_TRACE5( x )  do { } while ( 0 )     /* nothing */
 #define FT_TRACE7( x )  do { } while ( 0 )     /* nothing */
 #define FT_ERROR( x )   do { } while ( 0 )     /* nothing */
+#define FT_THROW( e )   FT_ERR_CAT( ErrRaster_, e )
+
 
 #endif /* !FT_DEBUG_LEVEL_TRACE */
 
 
 #define FT_DEFINE_OUTLINE_FUNCS( class_,               \
                                  move_to_, line_to_,   \
                                  conic_to_, cubic_to_, \
                                  shift_, delta_ )      \
           static const FT_Outline_Funcs class_ =       \
           {                                            \
@@ skipping 12 matching lines @@
           const FT_Raster_Funcs class_ =                          \
           {                                                       \
             glyph_format_,                                        \
             raster_new_,                                          \
             raster_reset_,                                        \
             raster_set_mode_,                                     \
             raster_render_,                                       \
             raster_done_                                          \
          };
 
+
 #else /* !_STANDALONE_ */
 
 
 #include <ft2build.h>
 #include "ftgrays.h"
 #include FT_INTERNAL_OBJECTS_H
 #include FT_INTERNAL_DEBUG_H
 #include FT_OUTLINE_H
 
 #include "ftsmerrs.h"
 
 #include "ftspic.h"
 
-#define ErrRaster_Invalid_Mode      Smooth_Err_Cannot_Render_Glyph
-#define ErrRaster_Invalid_Outline   Smooth_Err_Invalid_Outline
+#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
-#define ErrRaster_Invalid_Argument  Smooth_Err_Invalid_Argument
+
 
 #endif /* !_STANDALONE_ */
 
+
 #ifndef FT_MEM_SET
 #define FT_MEM_SET( d, s, c )  ft_memset( d, s, c )
 #endif
 
 #ifndef FT_MEM_ZERO
 #define FT_MEM_ZERO( dest, count )  FT_MEM_SET( dest, 0, count )
 #endif
 
   /* as usual, for the speed hungry :-) */
 
@@ skipping 70 matching lines @@
   /* approximately determine the size of integers using an ANSI-C header */
 #if FT_UINT_MAX == 0xFFFFU
   typedef long  TArea;
 #else
   typedef int   TArea;
 #endif
 
 #endif /* PIXEL_BITS >= 8 */
 
 
-  /* maximal number of gray spans in a call to the span callback */
+  /* maximum number of gray spans in a call to the span callback */
 #define FT_MAX_GRAY_SPANS  32
 
 
   typedef struct TCell_*  PCell;
 
   typedef struct  TCell_
   {
     TPos    x;     /* same with gray_TWorker.ex    */
     TCoord  cover; /* same with gray_TWorker.cover */
     TArea   area;
@@ skipping 267 matching lines @@
   /*                                                                       */
   /* Render a scanline as one or more cells.                               */
   /*                                                                       */
   static void
   gray_render_scanline( RAS_ARG_ TCoord  ey,
                                  TPos    x1,
                                  TCoord  y1,
                                  TPos    x2,
                                  TCoord  y2 )
   {
-    TCoord  ex1, ex2, fx1, fx2, delta, mod, lift, rem;
+    TCoord  ex1, ex2, fx1, fx2, delta, mod;
     long    p, first, dx;
     int     incr;
 
 
     dx = x2 - x1;
 
     ex1 = TRUNC( x1 );
     ex2 = TRUNC( x2 );
     fx1 = (TCoord)( x1 - SUBPIXELS( ex1 ) );
     fx2 = (TCoord)( x2 - SUBPIXELS( ex2 ) );
@@ skipping 40 matching lines @@
 
     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;
       }
 
       mod -= (int)dx;
@@ skipping 410 matching lines @@
           goto Split;
 
         /* s is L * the perpendicular distance from P2 to the line P0-P3. */
         dx2 = arc[2].x - arc[0].x;
         dy2 = arc[2].y - arc[0].y;
         s = FT_ABS( dy * dx2 - dx * dy2 );
 
         if ( s > s_limit )
           goto Split;
 
-        /* If P1 or P2 is outside P0-P3, split the curve. */
-        if ( dy * dy1 + dx * dx1 < 0                                     ||
-             dy * dy2 + dx * dx2 < 0                                     ||
-             dy * (arc[3].y - arc[1].y) + dx * (arc[3].x - arc[1].x) < 0 ||
-             dy * (arc[3].y - arc[2].y) + dx * (arc[3].x - arc[2].x) < 0 )
+        /* Split super curvy segments where the off points are so far
+           from the chord that the angles P0-P1-P3 or P0-P2-P3 become
+           acute as detected by appropriate dot products. */
+        if ( dx1 * ( dx1 - dx ) + dy1 * ( dy1 - dy ) > 0 ||
+             dx2 * ( dx2 - dx ) + dy2 * ( dy2 - dy ) > 0 )
           goto Split;
 
         /* No reason to split. */
         goto Draw;
       }
 
     Split:
       gray_split_cubic( arc );
       arc += 3;
       continue;
@@ skipping 111 matching lines @@
     }
   }
 
 
   static void
   gray_hline( RAS_ARG_ TCoord  x,
                        TCoord  y,
                        TPos    area,
                        TCoord  acount )
   {
-    FT_Span*  span;
-    int       count;
-    int       coverage;
+    int  coverage;
 
 
     /* compute the coverage line's coverage, depending on the    */
     /* outline fill rule                                         */
     /*                                                           */
     /* the coverage percentage is area/(PIXEL_BITS*PIXEL_BITS*2) */
     /*                                                           */
     coverage = (int)( area >> ( PIXEL_BITS * 2 + 1 - 8 ) );
                                                     /* use range 0..256 */
     if ( coverage < 0 )
@@ skipping 21 matching lines @@
     /* FT_Span.x is a 16-bit short, so limit our coordinates appropriately */
     if ( x >= 32767 )
       x = 32767;
 
     /* FT_Span.y is an integer, so limit our coordinates appropriately */
     if ( y >= FT_INT_MAX )
       y = FT_INT_MAX;
 
     if ( coverage )
     {
+      FT_Span*  span;
+      int       count;
+
+
       /* see whether we can add this span to the current list */
       count = ras.num_gray_spans;
       span  = ras.gray_spans + count - 1;
       if ( count > 0                          &&
            ras.span_y == y                    &&
            (int)span->x + span->len == (int)x &&
            span->coverage == coverage         )
       {
         span->len = (unsigned short)( span->len + acount );
         return;
@@ skipping 109 matching lines @@
 
       if ( cover != 0 )
         gray_hline( RAS_VAR_ x, yindex, cover * ( ONE_PIXEL * 2 ),
                     ras.count_ex - x );
     }
 
     if ( ras.render_span && ras.num_gray_spans > 0 )
       ras.render_span( ras.span_y, ras.num_gray_spans,
                        ras.gray_spans, ras.render_span_data );
 
+#ifdef FT_DEBUG_LEVEL_TRACE
+
+    if ( ras.num_gray_spans > 0 )
+    {
+      FT_Span*  span;
+      int       n;
+
+
+      FT_TRACE7(( "y = %3d ", ras.span_y ));
+      span = ras.gray_spans;
+      for ( n = 0; n < ras.num_gray_spans; n++, span++ )
+        FT_TRACE7(( "[%d..%d]:%02x ",
+                    span->x, span->x + span->len - 1, span->coverage ));
+      FT_TRACE7(( "\n" ));
+    }
+
     FT_TRACE7(( "gray_sweep: end\n" ));
+
+#endif /* FT_DEBUG_LEVEL_TRACE */
+
   }
 
 
 #ifdef _STANDALONE_
 
   /*************************************************************************/
   /*                                                                       */
   /*  The following function should only compile in stand-alone mode,      */
   /*  i.e., when building this component without the rest of FreeType.     */
   /*                                                                       */
@@ skipping 46 matching lines @@
 
     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 )
-      return ErrRaster_Invalid_Argument;
+      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 192 matching lines @@
     }
 
     FT_TRACE5(( "FT_Outline_Decompose: Done\n", n ));
     return 0;
 
   Exit:
     FT_TRACE5(( "FT_Outline_Decompose: Error %d\n", error ));
     return error;
 
   Invalid_Outline:
-    return ErrRaster_Invalid_Outline;
+    return FT_THROW( Invalid_Outline );
   }
 
 #endif /* _STANDALONE_ */
 
 
   typedef struct  gray_TBand_
   {
     TPos  min, max;
 
   } gray_TBand;
@@ skipping 17 matching lines @@
       FT_Outline_Funcs func_interface;
       Init_Class_func_interface(&func_interface);
 #endif
 
     if ( ft_setjmp( ras.jump_buffer ) == 0 )
     {
       error = FT_Outline_Decompose( &ras.outline, &func_interface, &ras );
       gray_record_cell( RAS_VAR );
     }
     else
-      error = ErrRaster_Memory_Overflow;
+      error = FT_THROW( Memory_Overflow );
 
     return error;
   }
 
 
   static int
   gray_convert_glyph( RAS_ARG )
   {
     gray_TBand            bands[40];
     gray_TBand* volatile  band;
@@ skipping 132 matching lines @@
   static int
   gray_raster_render( gray_PRaster             raster,
                       const FT_Raster_Params*  params )
   {
     const FT_Outline*  outline    = (const FT_Outline*)params->source;
     const FT_Bitmap*   target_map = params->target;
     gray_PWorker       worker;
 
 
     if ( !raster || !raster->buffer || !raster->buffer_size )
-      return ErrRaster_Invalid_Argument;
+      return FT_THROW( Invalid_Argument );
 
     if ( !outline )
-      return ErrRaster_Invalid_Outline;
+      return FT_THROW( Invalid_Outline );
 
     /* return immediately if the outline is empty */
     if ( outline->n_points == 0 || outline->n_contours <= 0 )
       return 0;
 
     if ( !outline->contours || !outline->points )
-      return ErrRaster_Invalid_Outline;
+      return FT_THROW( Invalid_Outline );
 
     if ( outline->n_points !=
            outline->contours[outline->n_contours - 1] + 1 )
-      return ErrRaster_Invalid_Outline;
+      return FT_THROW( Invalid_Outline );
 
     worker = raster->worker;
 
     /* if direct mode is not set, we must have a target bitmap */
     if ( !( params->flags & FT_RASTER_FLAG_DIRECT ) )
     {
       if ( !target_map )
-        return ErrRaster_Invalid_Argument;
+        return FT_THROW( Invalid_Argument );
 
       /* nothing to do */
       if ( !target_map->width || !target_map->rows )
         return 0;
 
       if ( !target_map->buffer )
-        return ErrRaster_Invalid_Argument;
+        return FT_THROW( Invalid_Argument );
     }
 
     /* this version does not support monochrome rendering */
     if ( !( params->flags & FT_RASTER_FLAG_AA ) )
-      return ErrRaster_Invalid_Mode;
+      return FT_THROW( Invalid_Mode );
 
     /* compute clipping box */
     if ( !( params->flags & FT_RASTER_FLAG_DIRECT ) )
     {
       /* compute clip box from target pixmap */
       ras.clip_box.xMin = 0;
       ras.clip_box.yMin = 0;
       ras.clip_box.xMax = target_map->width;
       ras.clip_box.yMax = target_map->rows;
     }
@@ skipping 138 matching lines @@
     (FT_Raster_Done_Func)    gray_raster_done
   )
 
 
 /* END */
 
 
 /* Local Variables: */
 /* coding: utf-8    */
 /* End:             */