Update bundled freetype to 2.6.1

third_party/freetype/src/base/ftstroke.c

 /***************************************************************************/
 /*                                                                         */
 /*  ftstroke.c                                                             */
 /*                                                                         */
 /*    FreeType path stroker (body).                                        */
 /*                                                                         */
-/*  Copyright 2002-2006, 2008-2011, 2013, 2014 by                          */
+/*  Copyright 2002-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_STROKER_H
 #include FT_TRIGONOMETRY_H
 #include FT_OUTLINE_H
 #include FT_INTERNAL_MEMORY_H
 #include FT_INTERNAL_DEBUG_H
 #include FT_INTERNAL_OBJECTS_H
 
+#include "basepic.h"
+
+
+  /* declare an extern to access `ft_outline_glyph_class' globally     */
+  /* allocated  in `ftglyph.c', and use the FT_OUTLINE_GLYPH_CLASS_GET */
+  /* macro to access it when FT_CONFIG_OPTION_PIC is defined           */
+#ifndef FT_CONFIG_OPTION_PIC
+  FT_CALLBACK_TABLE const FT_Glyph_Class  ft_outline_glyph_class;
+#endif
+
 
   /* documentation is in ftstroke.h */
 
   FT_EXPORT_DEF( FT_StrokerBorder )
   FT_Outline_GetInsideBorder( FT_Outline*  outline )
   {
     FT_Orientation  o = FT_Outline_Get_Orientation( outline );
 
 
     return o == FT_ORIENTATION_TRUETYPE ? FT_STROKER_BORDER_RIGHT
@@ skipping 303 matching lines @@
 
   Exit:
     return error;
   }
 
 
   static void
   ft_stroke_border_close( FT_StrokeBorder  border,
                           FT_Bool          reverse )
   {
-    FT_UInt  start = border->start;
+    FT_UInt  start = (FT_UInt)border->start;
     FT_UInt  count = border->num_points;
 
 
     FT_ASSERT( border->start >= 0 );
 
     /* don't record empty paths! */
     if ( count <= start + 1U )
       border->num_points = start;
     else
     {
@@ skipping 231 matching lines @@
 
 
   static FT_Error
   ft_stroke_border_moveto( FT_StrokeBorder  border,
                            FT_Vector*       to )
   {
     /* close current open path if any ? */
     if ( border->start >= 0 )
       ft_stroke_border_close( border, FALSE );
 
-    border->start = border->num_points;
+    border->start = (FT_Int)border->num_points;
     border->movable = FALSE;
 
     return ft_stroke_border_lineto( border, to, FALSE );
   }
 
 
   static void
   ft_stroke_border_init( FT_StrokeBorder  border,
                          FT_Memory        memory )
   {
@@ skipping 122 matching lines @@
       for ( ; count > 0; count--, tags++, idx++ )
       {
         if ( *tags & FT_STROKE_TAG_END )
         {
           *write++ = idx;
           outline->n_contours++;
         }
       }
     }
 
-    outline->n_points = (short)( outline->n_points + border->num_points );
+    outline->n_points += (short)border->num_points;
 
     FT_ASSERT( FT_Outline_Check( outline ) == 0 );
   }
 
 
   /*************************************************************************/
   /*************************************************************************/
   /*****                                                               *****/
   /*****                           STROKER                             *****/
   /*****                                                               *****/
@@ skipping 71 matching lines @@
   {
     if ( !stroker )
       return;
 
     stroker->radius      = radius;
     stroker->line_cap    = line_cap;
     stroker->line_join   = line_join;
     stroker->miter_limit = miter_limit;
 
     /* ensure miter limit has sensible value */
-    if ( stroker->miter_limit < 0x10000 )
-      stroker->miter_limit = 0x10000;
+    if ( stroker->miter_limit < 0x10000L )
+      stroker->miter_limit = 0x10000L;
 
     /* save line join style:                                           */
     /* line join style can be temporarily changed when stroking curves */
     stroker->line_join_saved = line_join;
 
     FT_Stroker_Rewind( stroker );
   }
 
 
   /* documentation is in ftstroke.h */
@@ skipping 143 matching lines @@
     FT_Error         error = FT_Err_Ok;
     FT_Bool          intersect;          /* use intersection of lines? */
 
 
     rotate = FT_SIDE_TO_ROTATE( side );
 
     theta = FT_Angle_Diff( stroker->angle_in, stroker->angle_out ) / 2;
 
     /* Only intersect borders if between two lineto's and both */
     /* lines are long enough (line_length is zero for curves). */
-    if ( !border->movable || line_length == 0 )
+    /* Also avoid U-turns of nearly 180 degree.                */
+    if ( !border->movable || line_length == 0  ||
+         theta > 0x59C000 || theta < -0x59C000 )
       intersect = FALSE;
     else
     {
       /* compute minimum required length of lines */
       FT_Fixed  min_length = ft_pos_abs( FT_MulFix( stroker->radius,
                                                     FT_Tan( theta ) ) );
 
 
       intersect = FT_BOOL( min_length                         &&
                            stroker->line_length >= min_length &&
@@ skipping 200 matching lines @@
     FT_Int    inside_side;
 
 
     turn = FT_Angle_Diff( stroker->angle_in, stroker->angle_out );
 
     /* no specific corner processing is required if the turn is 0 */
     if ( turn == 0 )
       goto Exit;
 
     /* when we turn to the right, the inside side is 0 */
-    inside_side = 0;
-
     /* otherwise, the inside side is 1 */
-    if ( turn < 0 )
-      inside_side = 1;
+    inside_side = ( turn < 0 );
 
     /* process the inside side */
     error = ft_stroker_inside( stroker, inside_side, line_length );
     if ( error )
       goto Exit;
 
     /* process the outside side */
-    error = ft_stroker_outside( stroker, 1 - inside_side, line_length );
+    error = ft_stroker_outside( stroker, !inside_side, line_length );
 
   Exit:
     return error;
   }
 
 
   /* add two points to the left and right borders corresponding to the */
   /* start of the subpath                                              */
   static FT_Error
   ft_stroker_subpath_start( FT_Stroker  stroker,
@@ skipping 569 matching lines @@
                                FT_Bool     open )
   {
     FT_StrokeBorder  right = stroker->borders + 0;
     FT_StrokeBorder  left  = stroker->borders + 1;
     FT_Int           new_points;
     FT_Error         error = FT_Err_Ok;
 
 
     FT_ASSERT( left->start >= 0 );
 
-    new_points = left->num_points - left->start;
+    new_points = (FT_Int)left->num_points - left->start;
     if ( new_points > 0 )
     {
       error = ft_stroke_border_grow( right, (FT_UInt)new_points );
       if ( error )
         goto Exit;
 
       {
         FT_Vector*  dst_point = right->points + right->num_points;
         FT_Byte*    dst_tag   = right->tags   + right->num_points;
         FT_Vector*  src_point = left->points  + left->num_points - 1;
@@ skipping 19 matching lines @@
               dst_tag[0] ^= FT_STROKE_TAG_BEGIN_END;
           }
 
           src_point--;
           src_tag--;
           dst_point++;
           dst_tag++;
         }
       }
 
-      left->num_points   = left->start;
-      right->num_points += new_points;
+      left->num_points   = (FT_UInt)left->start;
+      right->num_points += (FT_UInt)new_points;
 
       right->movable = FALSE;
       left->movable  = FALSE;
     }
 
   Exit:
     return error;
   }
 
 
@@ skipping 57 matching lines @@
 
       /* process the corner */
       stroker->angle_out = stroker->subpath_angle;
       turn               = FT_Angle_Diff( stroker->angle_in,
                                           stroker->angle_out );
 
       /* no specific corner processing is required if the turn is 0 */
       if ( turn != 0 )
       {
         /* when we turn to the right, the inside side is 0 */
-        inside_side = 0;
-
         /* otherwise, the inside side is 1 */
-        if ( turn < 0 )
-          inside_side = 1;
+        inside_side = ( turn < 0 );
 
         error = ft_stroker_inside( stroker,
                                    inside_side,
                                    stroker->subpath_line_length );
         if ( error )
           goto Exit;
 
         /* process the outside side */
         error = ft_stroker_outside( stroker,
-                                    1 - inside_side,
+                                    !inside_side,
                                     stroker->subpath_line_length );
         if ( error )
           goto Exit;
       }
 
       /* then end our two subpaths */
       ft_stroke_border_close( stroker->borders + 0, FALSE );
       ft_stroke_border_close( stroker->borders + 1, TRUE );
     }
 
@@ skipping 142 matching lines @@
 
     FT_Stroker_Rewind( stroker );
 
     first = 0;
 
     for ( n = 0; n < outline->n_contours; n++ )
     {
       FT_UInt  last;  /* index of last point in contour */
 
 
-      last  = outline->contours[n];
+      last  = (FT_UInt)outline->contours[n];
       limit = outline->points + last;
 
       /* skip empty points; we don't stroke these */
       if ( last <= first )
       {
         first = last + 1;
         continue;
       }
 
       v_start = outline->points[first];
@@ skipping 150 matching lines @@
     return FT_Err_Ok;
 
   Exit:
     return error;
 
   Invalid_Outline:
     return FT_THROW( Invalid_Outline );
   }
 
 
-  /* declare an extern to access `ft_outline_glyph_class' globally     */
-  /* allocated  in `ftglyph.c', and use the FT_OUTLINE_GLYPH_CLASS_GET */
-  /* macro to access it when FT_CONFIG_OPTION_PIC is defined           */
-#ifndef FT_CONFIG_OPTION_PIC
-  extern const FT_Glyph_Class  ft_outline_glyph_class;
-#endif
-#include "basepic.h"
-
-
   /* documentation is in ftstroke.h */
 
   FT_EXPORT_DEF( FT_Error )
   FT_Glyph_Stroke( FT_Glyph    *pglyph,
                    FT_Stroker   stroker,
                    FT_Bool      destroy )
   {
     FT_Error  error = FT_ERR( Invalid_Argument );
     FT_Glyph  glyph = NULL;
 
@@ skipping 29 matching lines @@
 
       error = FT_Stroker_ParseOutline( stroker, outline, FALSE );
       if ( error )
         goto Fail;
 
       FT_Stroker_GetCounts( stroker, &num_points, &num_contours );
 
       FT_Outline_Done( glyph->library, outline );
 
       error = FT_Outline_New( glyph->library,
-                              num_points, num_contours, outline );
+                              num_points,
+                              (FT_Int)num_contours,
+                              outline );
       if ( error )
         goto Fail;
 
       outline->n_points   = 0;
       outline->n_contours = 0;
 
       FT_Stroker_Export( stroker, outline );
     }
 
     if ( destroy )
@@ skipping 69 matching lines @@
       if ( error )
         goto Fail;
 
       FT_Stroker_GetBorderCounts( stroker, border,
                                   &num_points, &num_contours );
 
       FT_Outline_Done( glyph->library, outline );
 
       error = FT_Outline_New( glyph->library,
                               num_points,
-                              num_contours,
+                              (FT_Int)num_contours,
                               outline );
       if ( error )
         goto Fail;
 
       outline->n_points   = 0;
       outline->n_contours = 0;
 
       FT_Stroker_ExportBorder( stroker, border, outline );
     }
 
     if ( destroy )
       FT_Done_Glyph( *pglyph );
 
     *pglyph = glyph;
     goto Exit;
 
   Fail:
     FT_Done_Glyph( glyph );
     glyph = NULL;
 
     if ( !destroy )
       *pglyph = NULL;
 
   Exit:
     return error;
   }
 
 
 /* END */