ref: 17ae985d3838bb4f83644ecad27a87a1a8730a4c
parent: 433bc53fb67a19a67df563a22993210bafc45964
author: Werner Lemberg <[email protected]>
date: Sun Jan 2 04:41:30 EST 2000
ftbbox.h: FT_Get_Outline_BBox() must be called FT_Raster_GetBBox().
ftcalc.c: Added a missing closing paranthesis in 64bit version of
FT_MulFix().
Some formatting; updating copyright.
--- a/include/ftbbox.h
+++ b/include/ftbbox.h
@@ -4,7 +4,7 @@
/* */
/* FreeType bbox computation (specification). */
/* */
-/* Copyright 1996-1999 by */
+/* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used */
@@ -40,7 +40,7 @@
/*************************************************************************/
/* */
/* <Function> */
- /* FT_Get_Outline_BBox */
+ /* FT_Raster_GetBBox */
/* */
/* <Description> */
/* Computes the exact bounding box of an outline. This is slower */
@@ -59,8 +59,8 @@
/* Error code. 0 means success. */
/* */
EXPORT_DEF
- FT_Error FT_Get_Outline_BBox( FT_Outline* outline,
- FT_BBox* bbox );
+ FT_Error FT_Raster_GetBBox( FT_Outline* outline,
+ FT_BBox* abbox );
#ifdef __cplusplus
--- a/src/base/ftbase.c
+++ b/src/base/ftbase.c
@@ -1,3 +1,21 @@
+/***************************************************************************/
+/* */
+/* ftbase.c */
+/* */
+/* Single object library component. */
+/* */
+/* Copyright 1996-2000 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 <ftcalc.c>
#include <ftobjs.c>
#include <ftstream.c>
@@ -4,3 +22,6 @@
#include <ftlist.c>
#include <ftextend.c>
+
+
+/* END */
--- a/src/base/ftbbox.c
+++ b/src/base/ftbbox.c
@@ -4,7 +4,7 @@
/* */
/* FreeType bbox computation (body). */
/* */
-/* Copyright 1996-1999 by */
+/* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used */
@@ -343,7 +343,7 @@
/* Computes the exact bounding box of an outline. This is slower */
/* than computing the control box. However, it uses an advanced */
/* algorithm which returns _very_ quickly when the two boxes */
- /* coincide. Otherwise, the outline Bezier arcs are walked over to */
+ /* coincide. Otherwise, the outline Bezier arcs are walked over to */
/* extract their extrema. */
/* */
/* <Input> */
@@ -419,10 +419,10 @@
static FT_Outline_Funcs interface =
{- (FT_Outline_MoveTo_Func) BBox_Move_To,
- (FT_Outline_LineTo_Func) BBox_Move_To,
- (FT_Outline_ConicTo_Func) BBox_Conic_To,
- (FT_Outline_CubicTo_Func) BBox_Cubic_To
+ (FT_Outline_MoveTo_Func) BBox_Move_To,
+ (FT_Outline_LineTo_Func) BBox_Move_To,
+ (FT_Outline_ConicTo_Func)BBox_Conic_To,
+ (FT_Outline_CubicTo_Func)BBox_Cubic_To
};
FT_Error error;
--- a/src/base/ftcalc.c
+++ b/src/base/ftcalc.c
@@ -4,7 +4,7 @@
/* */
/* Arithmetic computations (body). */
/* */
-/* Copyright 1996-1999 by */
+/* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used */
@@ -24,7 +24,7 @@
/*************************************************************************/
/* */
- /* Implementing basic computation routines. */
+ /* Implementing basic computation routines. */
/* */
/* FT_MulDiv() and FT_MulFix() are declared in freetype.h. */
/* */
@@ -39,22 +39,25 @@
FT_Int32 FT_Sqrt32( FT_Int32 x )
{FT_ULong val, root, newroot, mask;
+
root = 0;
mask = 0x40000000;
val = (FT_ULong)x;
+
do
{- newroot = root+mask;
+ newroot = root + mask;
if (newroot <= val)
{val -= newroot;
root = newroot+mask;
}
+
root >>= 1;
mask >>= 2;
}
- while (mask != 0);
+ while ( mask != 0 );
return root;
}
@@ -93,12 +96,13 @@
{FT_Int s;
+
s = 1;
if ( a < 0 ) { a = -a; s = -s; } if ( b < 0 ) { b = -b; s = -s; } if ( c < 0 ) { c = -c; s = -s; }- return s*( ((FT_Int64)a * b + (c >> 1) )/c);
+ return s * ( ( (FT_Int64)a * b + ( c >> 1 ) ) / c );
}
@@ -109,7 +113,7 @@
/* */
/* <Description> */
/* A very simple function used to perform the computation */
- /* `(A*B)/0x10000' with maximum accuracy. Most of the time, this is */
+ /* `(A*B)/0x10000' with maximum accuracy. Most of the time this is */
/* used to multiply a given value by a 16.16 fixed float factor. */
/* */
/* <Input> */
@@ -125,7 +129,7 @@
/* value of `a' is less than 2048, and `b' is a 16.16 scaling factor. */
/* As this happens mainly when scaling from notional units to */
/* fractional pixels in FreeType, it resulted in noticeable speed */
- /* improvements between versions 2.0 and 1.x. */
+ /* improvements between versions 2.x and 1.x. */
/* */
/* As a conclusion, always try to place a 16.16 factor as the */
/* _second_ argument of this function; this can make a great */
@@ -137,13 +141,15 @@
{FT_Int s;
+
s = 1;
if ( a < 0 ) { a = -a; s = -s; } if ( b < 0 ) { b = -b; s = -s; }- return s*(FT_Long)((FT_Int64)a * b + 0x8000) >> 16);
+ return s * (FT_Long)( ( (FT_Int64)a * b + 0x8000 ) >> 16 );
}
+
/*************************************************************************/
/* */
/* <Function> */
@@ -152,7 +158,7 @@
/* <Description> */
/* A very simple function used to perform the computation */
/* `(A*0x10000)/B' with maximum accuracy. Most of the time, this is */
- /* used to divide a given value by a 16.16 fixed float factor. */
+ /* used to divide a given value by a 16.16 fixed float factor. */
/* */
/* <Input> */
/* a :: The first multiplier. */
@@ -163,9 +169,9 @@
/* The result of `(a*0x10000)/b'. */
/* */
/* <Note> */
- /* The optimisation for FT_DivFix() is simple : if (a << 16) fits */
- /* in 32 bits, then the division is computed directly. Otherwise, */
- /* we use a specialised version of the old FT_MulDiv64 */
+ /* The optimization for FT_DivFix() is simple: If (a << 16) fits in */
+ /* 32 bits, then the division is computed directly. Otherwise, we */
+ /* use a specialized version of the old FT_MulDiv64(). */
/* */
EXPORT_FUNC
FT_Int32 FT_DivFix( FT_Long a,
@@ -174,6 +180,7 @@
FT_Int32 s;
FT_Word32 q;
+
s = a; a = ABS(a);
s ^= b; b = ABS(b);
@@ -220,7 +227,7 @@
/* Graham Asher. The trick is to optimize computation if everything */
/* fits within 32 bits (a rather common case). */
/* */
- /* We compute `a*b+c/2', then divide it by `c'. (positive values) */
+ /* We compute `a*b+c/2', then divide it by `c' (positive values). */
/* */
/* 46340 is FLOOR(SQRT(2^31-1)). */
/* */
@@ -230,7 +237,7 @@
/* */
/* if ( c < 0x157F0*2 ) then ( a*b+c/2 <= 0x7FFFFFFF ) */
/* */
- /* and 2*0x157F0 = 176096 */
+ /* and 2*0x157F0 = 176096. */
/* */
EXPORT_FUNC
FT_Long FT_MulDiv( FT_Long a,
@@ -255,6 +262,7 @@
{FT_Int64 temp, temp2;
+
FT_MulTo64( a, b, &temp );
temp2.hi = (FT_Int32)(c >> 31);
temp2.lo = (FT_Word32)(c / 2);
@@ -285,10 +293,10 @@
/* The result of `(a*b)/0x10000'. */
/* */
/* <Note> */
- /* The optimisation for FT_MulFix() is different. We could simply be */
+ /* The optimization for FT_MulFix() is different. We could simply be */
/* happy by applying the same principles as with FT_MulDiv(), because */
/* */
- /* c = 0x10000 < 176096 */
+ /* c = 0x10000 < 176096 */
/* */
/* However, in most cases, we have a `b' with a value around 0x10000 */
/* which is greater than 46340. */
@@ -295,7 +303,7 @@
/* */
/* According to some testing, most cases have `a' < 2048, so a good */
/* idea is to use bounds like 2048 and 1048576 (=floor((2^31-1)/2048) */
- /* for `a' and `b' respectively. */
+ /* for `a' and `b', respectively. */
/* */
EXPORT_FUNC
FT_Long FT_MulFix( FT_Long a,
@@ -303,6 +311,7 @@
{FT_Long s;
+
if ( a == 0 || b == 0x10000L )
return a;
@@ -317,6 +326,7 @@
{FT_Long al = a & 0xFFFF;
+
a = (a >> 16)*b + al*(b >> 16) + ( al*(b & 0xFFFF) >> 16 );
}
@@ -343,9 +353,9 @@
/* The result of `(a*0x10000)/b'. */
/* */
/* <Note> */
- /* The optimisation for FT_DivFix() is simple : if (a << 16) fits */
- /* in 32 bits, then the division is computed directly. Otherwise, */
- /* we use a specialised version of the old FT_MulDiv64 */
+ /* The optimization for FT_DivFix() is simple: If (a << 16) fits in */
+ /* 32 bits, then the division is computed directly. Otherwise, we */
+ /* use a specialized version of the old FT_MulDiv64(). */
/* */
EXPORT_FUNC
FT_Long FT_DivFix( FT_Long a,
@@ -354,6 +364,7 @@
FT_Int32 s;
FT_Word32 q;
+
s = a; a = ABS(a);
s ^= b; b = ABS(b);
@@ -371,18 +382,19 @@
/* we need more bits, we'll have to do it by hand */
FT_Word32 c;
- q = (a/b) << 16;
- c = a%b;
- /* we must compute C*0x10000/B, we simply shift C and B so */
+ q = ( a / b ) << 16;
+ c = a % b;
+
+ /* we must compute C*0x10000/B; we simply shift C and B so */
/* C becomes smaller than 16 bits */
- while (c >> 16)
+ while ( c >> 16 )
{c >>= 1;
b <<= 1;
}
- q += (c << 16)/b;
+ q += ( c << 16 ) / b;
}
return ( s < 0 ? -(FT_Int32)q : (FT_Int32)q );
@@ -417,6 +429,7 @@
{FT_Word32 lo1, hi1, lo2, hi2, lo, hi, i1, i2;
+
lo1 = x & 0x0000FFFF; hi1 = x >> 16;
lo2 = y & 0x0000FFFF; hi2 = y >> 16;
@@ -431,7 +444,7 @@
if ( i1 < i2 )
hi += 1L << 16;
- hi += (i1 >> 16);
+ hi += i1 >> 16;
i1 = i1 << 16;
/* Check carry overflow of i1 + lo */
--- a/src/base/ftcalc.h
+++ b/src/base/ftcalc.h
@@ -4,7 +4,7 @@
/* */
/* Arithmetic computations (specification). */
/* */
-/* Copyright 1996-1999 by */
+/* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used */
@@ -29,6 +29,7 @@
#ifdef LONG64
+
typedef INT64 FT_Int64;
#define ADD_64( x, y, z ) z = (x) + (y)
@@ -53,8 +54,10 @@
BASE_DEF void FT_MulTo64 ( FT_Int32 x, FT_Int32 y, FT_Int64* z );
BASE_DEF FT_Int32 FT_Div64by32( FT_Int64* x, FT_Int32 y );
+
#endif /* LONG64 */
+
#define SQRT_32( x ) FT_Sqrt32( x )
BASE_DEF FT_Int32 FT_Sqrt32( FT_Int32 l );
@@ -73,7 +76,7 @@
#define FLOAT_TO_FIXED( x ) ( (FT_Long)(x * 65536.0) )
#define ROUND_F26DOT6( x ) ( x >= 0 ? ( ((x) + 32) & -64) \
- : ( -((32 - (x)) & -64) ) )
+ : ( -((32 - (x)) & -64) ) )
#ifdef __cplusplus
}