minhngoc25a
/
freetype2
mirror of git://git.savannah.gnu.org/freetype/freetype2.git
2
1
Fork 2
Code Issues 4 Releases Wiki Activity

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.
This commit is contained in:
Werner Lemberg 2000-01-02 09:41:30 +00:00
parent 433bc53fb6
commit 17ae985d38
5 changed files with 75 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/ftbbox.h
View File

@ -4,7 +4,7 @@
/* */ /* */
/* FreeType bbox computation (specification). */ /* FreeType bbox computation (specification). */
/* */ /* */
/* Copyright 1996-1999 by */ /* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */ /* */
/* This file is part of the FreeType project, and may only be used */ /* This file is part of the FreeType project, and may only be used */
@ -40,7 +40,7 @@
/*************************************************************************/ /*************************************************************************/
/* */ /* */
/* <Function> */ /* <Function> */
/* FT_Get_Outline_BBox */ /* FT_Raster_GetBBox */
/* */ /* */
/* <Description> */ /* <Description> */
/* Computes the exact bounding box of an outline. This is slower */ /* Computes the exact bounding box of an outline. This is slower */
@ -59,8 +59,8 @@
/* Error code. 0 means success. */ /* Error code. 0 means success. */
/* */ /* */
EXPORT_DEF EXPORT_DEF
FT_Error FT_Get_Outline_BBox( FT_Outline* outline, FT_Error FT_Raster_GetBBox( FT_Outline* outline,
FT_BBox* bbox ); FT_BBox* abbox );
#ifdef __cplusplus #ifdef __cplusplus

21
src/base/ftbase.c
View File

@ -1,6 +1,27 @@
/***************************************************************************/
/* */
/* 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 <ftcalc.c>
#include <ftobjs.c> #include <ftobjs.c>
#include <ftstream.c> #include <ftstream.c>
#include <ftlist.c> #include <ftlist.c>
#include <ftextend.c> #include <ftextend.c>
/* END */

12
src/base/ftbbox.c
View File

@ -4,7 +4,7 @@
/* */ /* */
/* FreeType bbox computation (body). */ /* FreeType bbox computation (body). */
/* */ /* */
/* Copyright 1996-1999 by */ /* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */ /* */
/* This file is part of the FreeType project, and may only be used */ /* 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 */ /* Computes the exact bounding box of an outline. This is slower */
/* than computing the control box. However, it uses an advanced */ /* than computing the control box. However, it uses an advanced */
/* algorithm which returns _very_ quickly when the two boxes */ /* 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. */ /* extract their extrema. */
/* */ /* */
/* <Input> */ /* <Input> */
@ -419,10 +419,10 @@
static FT_Outline_Funcs interface = static FT_Outline_Funcs interface =
{ {
(FT_Outline_MoveTo_Func) BBox_Move_To, (FT_Outline_MoveTo_Func) BBox_Move_To,
(FT_Outline_LineTo_Func) BBox_Move_To, (FT_Outline_LineTo_Func) BBox_Move_To,
(FT_Outline_ConicTo_Func) BBox_Conic_To, (FT_Outline_ConicTo_Func)BBox_Conic_To,
(FT_Outline_CubicTo_Func) BBox_Cubic_To (FT_Outline_CubicTo_Func)BBox_Cubic_To
}; };
FT_Error error; FT_Error error;

65
src/base/ftcalc.c
View File

@ -4,7 +4,7 @@
/* */ /* */
/* Arithmetic computations (body). */ /* Arithmetic computations (body). */
/* */ /* */
/* Copyright 1996-1999 by */ /* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */ /* */
/* This file is part of the FreeType project, and may only be used */ /* 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. */ /* FT_MulDiv() and FT_MulFix() are declared in freetype.h. */
/* */ /* */
@ -39,22 +39,25 @@
FT_Int32 FT_Sqrt32( FT_Int32 x ) FT_Int32 FT_Sqrt32( FT_Int32 x )
{ {
FT_ULong val, root, newroot, mask; FT_ULong val, root, newroot, mask;
root = 0; root = 0;
mask = 0x40000000; mask = 0x40000000;
val = (FT_ULong)x; val = (FT_ULong)x;
do do
{ {
newroot = root+mask; newroot = root + mask;
if (newroot <= val) if (newroot <= val)
{ {
val -= newroot; val -= newroot;
root = newroot+mask; root = newroot+mask;
} }
root >>= 1; root >>= 1;
mask >>= 2; mask >>= 2;
} }
while (mask != 0); while ( mask != 0 );
return root; return root;
} }
@ -93,12 +96,13 @@
{ {
FT_Int s; FT_Int s;
s = 1; s = 1;
if ( a < 0 ) { a = -a; s = -s; } if ( a < 0 ) { a = -a; s = -s; }
if ( b < 0 ) { b = -b; s = -s; } if ( b < 0 ) { b = -b; s = -s; }
if ( c < 0 ) { c = -c; 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> */ /* <Description> */
/* A very simple function used to perform the computation */ /* 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. */ /* used to multiply a given value by a 16.16 fixed float factor. */
/* */ /* */
/* <Input> */ /* <Input> */
@ -125,7 +129,7 @@
/* value of `a' is less than 2048, and `b' is a 16.16 scaling factor. */ /* 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 */ /* As this happens mainly when scaling from notional units to */
/* fractional pixels in FreeType, it resulted in noticeable speed */ /* 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 */ /* As a conclusion, always try to place a 16.16 factor as the */
/* _second_ argument of this function; this can make a great */ /* _second_ argument of this function; this can make a great */
@ -137,13 +141,15 @@
{ {
FT_Int s; FT_Int s;
s = 1; s = 1;
if ( a < 0 ) { a = -a; s = -s; } if ( a < 0 ) { a = -a; s = -s; }
if ( b < 0 ) { b = -b; 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> */ /* <Function> */
@ -152,7 +158,7 @@
/* <Description> */ /* <Description> */
/* A very simple function used to perform the computation */ /* A very simple function used to perform the computation */
/* `(A*0x10000)/B' with maximum accuracy. Most of the time, this is */ /* `(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> */ /* <Input> */
/* a :: The first multiplier. */ /* a :: The first multiplier. */
@ -163,9 +169,9 @@
/* The result of `(a*0x10000)/b'. */ /* The result of `(a*0x10000)/b'. */
/* */ /* */
/* <Note> */ /* <Note> */
/* The optimisation for FT_DivFix() is simple : if (a << 16) fits */ /* The optimization for FT_DivFix() is simple: If (a << 16) fits in */
/* in 32 bits, then the division is computed directly. Otherwise, */ /* 32 bits, then the division is computed directly. Otherwise, we */
/* we use a specialised version of the old FT_MulDiv64 */ /* use a specialized version of the old FT_MulDiv64(). */
/* */ /* */
EXPORT_FUNC EXPORT_FUNC
FT_Int32 FT_DivFix( FT_Long a, FT_Int32 FT_DivFix( FT_Long a,
@ -174,6 +180,7 @@
FT_Int32 s; FT_Int32 s;
FT_Word32 q; FT_Word32 q;
s = a; a = ABS(a); s = a; a = ABS(a);
s ^= b; b = ABS(b); s ^= b; b = ABS(b);
@ -220,7 +227,7 @@
/* Graham Asher. The trick is to optimize computation if everything */ /* Graham Asher. The trick is to optimize computation if everything */
/* fits within 32 bits (a rather common case). */ /* 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)). */ /* 46340 is FLOOR(SQRT(2^31-1)). */
/* */ /* */
@ -230,7 +237,7 @@
/* */ /* */
/* if ( c < 0x157F0*2 ) then ( a*b+c/2 <= 0x7FFFFFFF ) */ /* if ( c < 0x157F0*2 ) then ( a*b+c/2 <= 0x7FFFFFFF ) */
/* */ /* */
/* and 2*0x157F0 = 176096 */ /* and 2*0x157F0 = 176096. */
/* */ /* */
EXPORT_FUNC EXPORT_FUNC
FT_Long FT_MulDiv( FT_Long a, FT_Long FT_MulDiv( FT_Long a,
@ -255,6 +262,7 @@
{ {
FT_Int64 temp, temp2; FT_Int64 temp, temp2;
FT_MulTo64( a, b, &temp ); FT_MulTo64( a, b, &temp );
temp2.hi = (FT_Int32)(c >> 31); temp2.hi = (FT_Int32)(c >> 31);
temp2.lo = (FT_Word32)(c / 2); temp2.lo = (FT_Word32)(c / 2);
@ -285,17 +293,17 @@
/* The result of `(a*b)/0x10000'. */ /* The result of `(a*b)/0x10000'. */
/* */ /* */
/* <Note> */ /* <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 */ /* 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 */ /* However, in most cases, we have a `b' with a value around 0x10000 */
/* which is greater than 46340. */ /* which is greater than 46340. */
/* */ /* */
/* According to some testing, most cases have `a' < 2048, so a good */ /* 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) */ /* 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 EXPORT_FUNC
FT_Long FT_MulFix( FT_Long a, FT_Long FT_MulFix( FT_Long a,
@ -303,6 +311,7 @@
{ {
FT_Long s; FT_Long s;
if ( a == 0 || b == 0x10000L ) if ( a == 0 || b == 0x10000L )
return a; return a;
@ -317,6 +326,7 @@
{ {
FT_Long al = a & 0xFFFF; FT_Long al = a & 0xFFFF;
a = (a >> 16)*b + al*(b >> 16) + ( al*(b & 0xFFFF) >> 16 ); a = (a >> 16)*b + al*(b >> 16) + ( al*(b & 0xFFFF) >> 16 );
} }
@ -343,9 +353,9 @@
/* The result of `(a*0x10000)/b'. */ /* The result of `(a*0x10000)/b'. */
/* */ /* */
/* <Note> */ /* <Note> */
/* The optimisation for FT_DivFix() is simple : if (a << 16) fits */ /* The optimization for FT_DivFix() is simple: If (a << 16) fits in */
/* in 32 bits, then the division is computed directly. Otherwise, */ /* 32 bits, then the division is computed directly. Otherwise, we */
/* we use a specialised version of the old FT_MulDiv64 */ /* use a specialized version of the old FT_MulDiv64(). */
/* */ /* */
EXPORT_FUNC EXPORT_FUNC
FT_Long FT_DivFix( FT_Long a, FT_Long FT_DivFix( FT_Long a,
@ -354,6 +364,7 @@
FT_Int32 s; FT_Int32 s;
FT_Word32 q; FT_Word32 q;
s = a; a = ABS(a); s = a; a = ABS(a);
s ^= b; b = ABS(b); s ^= b; b = ABS(b);
@ -371,18 +382,19 @@
/* we need more bits, we'll have to do it by hand */ /* we need more bits, we'll have to do it by hand */
FT_Word32 c; 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 */ /* C becomes smaller than 16 bits */
while (c >> 16) while ( c >> 16 )
{ {
c >>= 1; c >>= 1;
b <<= 1; b <<= 1;
} }
q += (c << 16)/b; q += ( c << 16 ) / b;
} }
return ( s < 0 ? -(FT_Int32)q : (FT_Int32)q ); return ( s < 0 ? -(FT_Int32)q : (FT_Int32)q );
@ -417,6 +429,7 @@
{ {
FT_Word32 lo1, hi1, lo2, hi2, lo, hi, i1, i2; FT_Word32 lo1, hi1, lo2, hi2, lo, hi, i1, i2;
lo1 = x & 0x0000FFFF; hi1 = x >> 16; lo1 = x & 0x0000FFFF; hi1 = x >> 16;
lo2 = y & 0x0000FFFF; hi2 = y >> 16; lo2 = y & 0x0000FFFF; hi2 = y >> 16;
@ -431,7 +444,7 @@
if ( i1 < i2 ) if ( i1 < i2 )
hi += 1L << 16; hi += 1L << 16;
hi += (i1 >> 16); hi += i1 >> 16;
i1 = i1 << 16; i1 = i1 << 16;
/* Check carry overflow of i1 + lo */ /* Check carry overflow of i1 + lo */

7
src/base/ftcalc.h
View File

@ -4,7 +4,7 @@
/* */ /* */
/* Arithmetic computations (specification). */ /* Arithmetic computations (specification). */
/* */ /* */
/* Copyright 1996-1999 by */ /* Copyright 1996-2000 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */ /* */
/* This file is part of the FreeType project, and may only be used */ /* This file is part of the FreeType project, and may only be used */
@ -29,6 +29,7 @@
#ifdef LONG64 #ifdef LONG64
typedef INT64 FT_Int64; typedef INT64 FT_Int64;
#define ADD_64( x, y, z ) z = (x) + (y) #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 void FT_MulTo64 ( FT_Int32 x, FT_Int32 y, FT_Int64* z );
BASE_DEF FT_Int32 FT_Div64by32( FT_Int64* x, FT_Int32 y ); BASE_DEF FT_Int32 FT_Div64by32( FT_Int64* x, FT_Int32 y );
#endif /* LONG64 */ #endif /* LONG64 */
#define SQRT_32( x ) FT_Sqrt32( x ) #define SQRT_32( x ) FT_Sqrt32( x )
BASE_DEF FT_Int32 FT_Sqrt32( FT_Int32 l ); BASE_DEF FT_Int32 FT_Sqrt32( FT_Int32 l );
@ -73,7 +76,7 @@
#define FLOAT_TO_FIXED( x ) ( (FT_Long)(x * 65536.0) ) #define FLOAT_TO_FIXED( x ) ( (FT_Long)(x * 65536.0) )
#define ROUND_F26DOT6( x ) ( x >= 0 ? ( ((x) + 32) & -64) \ #define ROUND_F26DOT6( x ) ( x >= 0 ? ( ((x) + 32) & -64) \
: ( -((32 - (x)) & -64) ) ) : ( -((32 - (x)) & -64) ) )
#ifdef __cplusplus #ifdef __cplusplus
} }