Update bundled freetype to 2.6.1

third_party/freetype/src/base/ftbbox.c

 /***************************************************************************/
 /*                                                                         */
 /*  ftbbox.c                                                               */
 /*                                                                         */
 /*    FreeType bbox computation (body).                                    */
 /*                                                                         */
-/*  Copyright 1996-2002, 2004, 2006, 2010, 2013, 2014 by                   */
+/*  Copyright 1996-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.                                        */
 /*                                                                         */
 /***************************************************************************/
 
@@ skipping 17 matching lines @@
 
 
   typedef struct  TBBox_Rec_
   {
     FT_Vector  last;
     FT_BBox    bbox;
 
   } TBBox_Rec;
 
 
-#define FT_UPDATE_BBOX(p, bbox)       \
-  FT_BEGIN_STMNT                      \
-    if ( p->x < bbox.xMin )           \
-      bbox.xMin = p->x;               \
-    if ( p->x > bbox.xMax )           \
-      bbox.xMax = p->x;               \
-    if ( p->y < bbox.yMin )           \
-      bbox.yMin = p->y;               \
-    if ( p->y > bbox.yMax )           \
-      bbox.yMax = p->y;               \
+#define FT_UPDATE_BBOX( p, bbox ) \
+  FT_BEGIN_STMNT                  \
+    if ( p->x < bbox.xMin )       \
+      bbox.xMin = p->x;           \
+    if ( p->x > bbox.xMax )       \
+      bbox.xMax = p->x;           \
+    if ( p->y < bbox.yMin )       \
+      bbox.yMin = p->y;           \
+    if ( p->y > bbox.yMax )       \
+      bbox.yMax = p->y;           \
   FT_END_STMNT
 
-#define CHECK_X( p, bbox )  \
+#define CHECK_X( p, bbox )                         \
           ( p->x < bbox.xMin || p->x > bbox.xMax )
 
-#define CHECK_Y( p, bbox )  \
+#define CHECK_Y( p, bbox )                         \
           ( p->y < bbox.yMin || p->y > bbox.yMax )
 
 
   /*************************************************************************/
   /*                                                                       */
   /* <Function>                                                            */
   /*    BBox_Move_To                                                       */
   /*                                                                       */
   /* <Description>                                                         */
   /*    This function is used as a `move_to' emitter during                */
@@ skipping 177 matching lines @@
   /*                                                                       */
   static FT_Pos
   cubic_peak( FT_Pos  q1,
               FT_Pos  q2,
               FT_Pos  q3,
               FT_Pos  q4 )
   {
     FT_Pos  peak = 0;
     FT_Int  shift;
 
+
     /* This function finds a peak of a cubic segment if it is above 0    */
     /* using iterative bisection of the segment, or returns 0.           */
     /* The fixed-point arithmetic of bisection is inherently stable      */
     /* but may loose accuracy in the two lowest bits.  To compensate,    */
     /* we upscale the segment if there is room.  Large values may need   */
     /* to be downscaled to avoid overflows during bisection.             */
     /* It is called with either q2 or q3 positive, which is necessary    */
     /* for the peak to exist and avoids undefined FT_MSB.                */
 
-    shift = 27 -
-      FT_MSB( FT_ABS( q1 ) | FT_ABS( q2 ) | FT_ABS( q3 ) | FT_ABS( q4 ) );
+    shift = 27 - FT_MSB( (FT_UInt32)( FT_ABS( q1 ) |
+                                      FT_ABS( q2 ) |
+                                      FT_ABS( q3 ) |
+                                      FT_ABS( q4 ) ) );
 
     if ( shift > 0 )
     {
       /* upscaling too much just wastes time */
       if ( shift > 2 )
         shift = 2;
 
       q1 <<=  shift;
       q2 <<=  shift;
       q3 <<=  shift;
@@ skipping 133 matching lines @@
                         control2->y,
                         to->y,
                         &user->bbox.yMin,
                         &user->bbox.yMax );
 
     user->last = *to;
 
     return 0;
   }
 
-FT_DEFINE_OUTLINE_FUNCS(bbox_interface,
+
+  FT_DEFINE_OUTLINE_FUNCS(bbox_interface,
     (FT_Outline_MoveTo_Func) BBox_Move_To,
     (FT_Outline_LineTo_Func) BBox_Line_To,
     (FT_Outline_ConicTo_Func)BBox_Conic_To,
     (FT_Outline_CubicTo_Func)BBox_Cubic_To,
     0, 0
   )
 
+
   /* documentation is in ftbbox.h */
 
   FT_EXPORT_DEF( FT_Error )
   FT_Outline_Get_BBox( FT_Outline*  outline,
                        FT_BBox     *abbox )
   {
-    FT_BBox     cbox = { 0x7FFFFFFF, 0x7FFFFFFF, -0x7FFFFFFF, -0x7FFFFFFF };
-    FT_BBox     bbox = { 0x7FFFFFFF, 0x7FFFFFFF, -0x7FFFFFFF, -0x7FFFFFFF };
+    FT_BBox     cbox = {  0x7FFFFFFFL,  0x7FFFFFFFL,
+                         -0x7FFFFFFFL, -0x7FFFFFFFL };
+    FT_BBox     bbox = {  0x7FFFFFFFL,  0x7FFFFFFFL,
+                         -0x7FFFFFFFL, -0x7FFFFFFFL };
     FT_Vector*  vec;
     FT_UShort   n;
 
 
     if ( !abbox )
       return FT_THROW( Invalid_Argument );
 
     if ( !outline )
       return FT_THROW( Invalid_Outline );
 
@@ skipping 45 matching lines @@
       *abbox = user.bbox;
     }
     else
       *abbox = bbox;
 
     return FT_Err_Ok;
   }
 
 
 /* END */