Update bundled freetype to 2.6.1

third_party/freetype/src/base/fttrigon.c

 /***************************************************************************/
 /*                                                                         */
 /*  fttrigon.c                                                             */
 /*                                                                         */
 /*    FreeType trigonometric functions (body).                             */
 /*                                                                         */
-/*  Copyright 2001-2005, 2012-2014 by                                      */
+/*  Copyright 2001-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 48 matching lines @@
     if ( val < 0 )
     {
        val = -val;
        s = -1;
     }
 
     /* 0x40000000 comes from regression analysis between true */
     /* and CORDIC hypotenuse, so it minimizes the error       */
     val = (FT_Fixed)( ( (FT_Int64)val * FT_TRIG_SCALE + 0x40000000UL ) >> 32 );
 
-    return ( s >= 0 ) ? val : -val;
+    return s < 0 ? -val : val;
   }
 
 #else /* !FT_LONG64 */
 
   /* multiply a given value by the CORDIC shrink factor */
   static FT_Fixed
   ft_trig_downscale( FT_Fixed  val )
   {
     FT_Int     s = 1;
     FT_UInt32  lo1, hi1, lo2, hi2, lo, hi, i1, i2;
 
 
     if ( val < 0 )
     {
        val = -val;
        s = -1;
     }
 
-    lo1 = val & 0x0000FFFFU;
-    hi1 = val >> 16;
+    lo1 = (FT_UInt32)val & 0x0000FFFFU;
+    hi1 = (FT_UInt32)val >> 16;
     lo2 = FT_TRIG_SCALE & 0x0000FFFFU;
     hi2 = FT_TRIG_SCALE >> 16;
 
     lo = lo1 * lo2;
     i1 = lo1 * hi2;
     i2 = lo2 * hi1;
     hi = hi1 * hi2;
 
     /* Check carry overflow of i1 + i2 */
     i1 += i2;
     hi += (FT_UInt32)( i1 < i2 ) << 16;
 
     hi += i1 >> 16;
     i1  = i1 << 16;
 
     /* Check carry overflow of i1 + lo */
     lo += i1;
     hi += ( lo < i1 );
 
     /* 0x40000000 comes from regression analysis between true */
     /* and CORDIC hypotenuse, so it minimizes the error       */
 
     /* Check carry overflow of lo + 0x40000000 */
-    lo += 0x40000000U;
-    hi += ( lo < 0x40000000U );
+    lo += 0x40000000UL;
+    hi += ( lo < 0x40000000UL );
 
-    val  = (FT_Fixed)hi;
+    val = (FT_Fixed)hi;
 
-    return ( s >= 0 ) ? val : -val;
+    return s < 0 ? -val : val;
   }
 
 #endif /* !FT_LONG64 */
 
 
   /* undefined and never called for zero vector */
   static FT_Int
   ft_trig_prenorm( FT_Vector*  vec )
   {
     FT_Pos  x, y;
     FT_Int  shift;
 
 
     x = vec->x;
     y = vec->y;
 
-    shift = FT_MSB( FT_ABS( x ) | FT_ABS( y ) );
+    shift = FT_MSB( (FT_UInt32)( FT_ABS( x ) | FT_ABS( y ) ) );
 
     if ( shift <= FT_TRIG_SAFE_MSB )
     {
       shift  = FT_TRIG_SAFE_MSB - shift;
       vec->x = (FT_Pos)( (FT_ULong)x << shift );
       vec->y = (FT_Pos)( (FT_ULong)y << shift );
     }
     else
     {
       shift -= FT_TRIG_SAFE_MSB;
@@ skipping 139 matching lines @@
 
 
   /* documentation is in fttrigon.h */
 
   FT_EXPORT_DEF( FT_Fixed )
   FT_Cos( FT_Angle  angle )
   {
     FT_Vector  v;
 
 
-    v.x = FT_TRIG_SCALE >> 8;
-    v.y = 0;
-    ft_trig_pseudo_rotate( &v, angle );
+    FT_Vector_Unit( &v, angle );
 
-    return ( v.x + 0x80L ) >> 8;
+    return v.x;
   }
 
 
   /* documentation is in fttrigon.h */
 
   FT_EXPORT_DEF( FT_Fixed )
   FT_Sin( FT_Angle  angle )
   {
-    return FT_Cos( FT_ANGLE_PI2 - angle );
+    FT_Vector  v;
+
+
+    FT_Vector_Unit( &v, angle );
+
+    return v.y;
   }
 
 
   /* documentation is in fttrigon.h */
 
   FT_EXPORT_DEF( FT_Fixed )
   FT_Tan( FT_Angle  angle )
   {
     FT_Vector  v;
 
 
-    v.x = FT_TRIG_SCALE >> 8;
-    v.y = 0;
-    ft_trig_pseudo_rotate( &v, angle );
+    FT_Vector_Unit( &v, angle );
 
     return FT_DivFix( v.y, v.x );
   }
 
 
   /* documentation is in fttrigon.h */
 
   FT_EXPORT_DEF( FT_Angle )
   FT_Atan2( FT_Fixed  dx,
             FT_Fixed  dy )
@@ skipping 41 matching lines @@
   /* documentation is in fttrigon.h */
 
   FT_EXPORT_DEF( void )
   FT_Vector_Rotate( FT_Vector*  vec,
                     FT_Angle    angle )
   {
     FT_Int     shift;
     FT_Vector  v;
 
 
-    if ( !vec )
+    if ( !vec || !angle )
       return;
 
-    v.x   = vec->x;
-    v.y   = vec->y;
+    v = *vec;
 
-    if ( angle && ( v.x != 0 || v.y != 0 ) )
+    if ( v.x == 0 && v.y == 0 )
+      return;
+
+    shift = ft_trig_prenorm( &v );
+    ft_trig_pseudo_rotate( &v, angle );
+    v.x = ft_trig_downscale( v.x );
+    v.y = ft_trig_downscale( v.y );
+
+    if ( shift > 0 )
     {
-      shift = ft_trig_prenorm( &v );
-      ft_trig_pseudo_rotate( &v, angle );
-      v.x = ft_trig_downscale( v.x );
-      v.y = ft_trig_downscale( v.y );
-
-      if ( shift > 0 )
-      {
-        FT_Int32  half = (FT_Int32)1L << ( shift - 1 );
+      FT_Int32  half = (FT_Int32)1L << ( shift - 1 );
 
 
-        vec->x = ( v.x + half + FT_SIGN_LONG( v.x ) ) >> shift;
-        vec->y = ( v.y + half + FT_SIGN_LONG( v.y ) ) >> shift;
-      }
-      else
-      {
-        shift  = -shift;
-        vec->x = (FT_Pos)( (FT_ULong)v.x << shift );
-        vec->y = (FT_Pos)( (FT_ULong)v.y << shift );
-      }
+      vec->x = ( v.x + half + FT_SIGN_LONG( v.x ) ) >> shift;
+      vec->y = ( v.y + half + FT_SIGN_LONG( v.y ) ) >> shift;
+    }
+    else
+    {
+      shift  = -shift;
+      vec->x = (FT_Pos)( (FT_ULong)v.x << shift );
+      vec->y = (FT_Pos)( (FT_ULong)v.y << shift );
     }
   }
 
 
   /* documentation is in fttrigon.h */
 
   FT_EXPORT_DEF( FT_Fixed )
   FT_Vector_Length( FT_Vector*  vec )
   {
     FT_Int     shift;
@@ skipping 15 matching lines @@
       return FT_ABS( v.x );
     }
 
     /* general case */
     shift = ft_trig_prenorm( &v );
     ft_trig_pseudo_polarize( &v );
 
     v.x = ft_trig_downscale( v.x );
 
     if ( shift > 0 )
-      return ( v.x + ( 1 << ( shift - 1 ) ) ) >> shift;
+      return ( v.x + ( 1L << ( shift - 1 ) ) ) >> shift;
 
     return (FT_Fixed)( (FT_UInt32)v.x << -shift );
   }
 
 
   /* documentation is in fttrigon.h */
 
   FT_EXPORT_DEF( void )
   FT_Vector_Polarize( FT_Vector*  vec,
                       FT_Fixed   *length,
                       FT_Angle   *angle )
   {
     FT_Int     shift;
     FT_Vector  v;
 
 
     if ( !vec || !length || !angle )
       return;
 
     v = *vec;
 
     if ( v.x == 0 && v.y == 0 )
       return;
 
     shift = ft_trig_prenorm( &v );
     ft_trig_pseudo_polarize( &v );
 
     v.x = ft_trig_downscale( v.x );
 
-    *length = ( shift >= 0 ) ?                      ( v.x >>  shift )
-                             : (FT_Fixed)( (FT_UInt32)v.x << -shift );
+    *length = shift >= 0 ?                      ( v.x >>  shift )
+                         : (FT_Fixed)( (FT_UInt32)v.x << -shift );
     *angle  = v.y;
   }
 
 
   /* documentation is in fttrigon.h */
 
   FT_EXPORT_DEF( void )
   FT_Vector_From_Polar( FT_Vector*  vec,
                         FT_Fixed    length,
                         FT_Angle    angle )
@@ skipping 10 matching lines @@
 
   /* documentation is in fttrigon.h */
 
   FT_EXPORT_DEF( FT_Angle )
   FT_Angle_Diff( FT_Angle  angle1,
                  FT_Angle  angle2 )
   {
     FT_Angle  delta = angle2 - angle1;
 
 
-    delta %= FT_ANGLE_2PI;
-    if ( delta < 0 )
+    while ( delta <= -FT_ANGLE_PI )
       delta += FT_ANGLE_2PI;
 
-    if ( delta > FT_ANGLE_PI )
+    while ( delta > FT_ANGLE_PI )
       delta -= FT_ANGLE_2PI;
 
     return delta;
   }
 
 
 /* END */