AuroraMiddleware/freetype
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

modified the TrueType interpreter to let it

Browse Source 
use the new trigonometric functions provided in "fttrigon.h". This
        gets rid of some old 64-bit computation routines, as well as many
        warnings when compiling the library with the "long long" 64-bit
        integer type.
This commit is contained in:
David Turner 2001-06-14 12:34:00 +00:00
parent 1b3a0014e2
commit ac6cc419df
5 changed files with 72 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
ChangeLog
View File

@ -1,3 +1,13 @@
2001-06-14 David Turner <david@freetype.org>
* src/base/ftcalc.c, include/internal/ftcalc.h, src/truetype/ttinterp.c,
include/config/ftoption.h: modified the TrueType interpreter to let it
use the new trigonometric functions provided in "fttrigon.h". This
gets rid of some old 64-bit computation routines, as well as many
warnings when compiling the library with the "long long" 64-bit
integer type.
2001-06-11 Mike Owens <MOwens@amtdatasouth.com>
* src/base/ftcalc.c (FT_MulDiv, FT_DivFix, FT_Sqrt64): Remove

2
include/freetype/config/ftoption.h
View File

@ -237,7 +237,7 @@ FT_BEGIN_HEADER
/* Used for debugging, this configuration macro should disappear */
/* soon. */
/* */
#define FT_CONFIG_OPTION_OLD_CALCS
#undef FT_CONFIG_OPTION_OLD_CALCS
/*************************************************************************/

37
include/freetype/internal/ftcalc.h
View File

@ -27,18 +27,19 @@
FT_BEGIN_HEADER
#ifdef FT_LONG64
typedef FT_INT64 FT_Int64;
#define ADD_64( x, y, z ) z = (x) + (y)
#define MUL_64( x, y, z ) z = (FT_Int64)(x) * (y)
#define DIV_64( x, y ) ( (x) / (y) )
/* OLD 64-bits internal API */
#ifdef FT_CONFIG_OPTION_OLD_CALCS
#define SQRT_64( z ) FT_Sqrt64( z )
# ifdef FT_LONG64
typedef FT_INT64 FT_Int64;
# define ADD_64( x, y, z ) z = (x) + (y)
# define MUL_64( x, y, z ) z = (FT_Int64)(x) * (y)
# define DIV_64( x, y ) ( (x) / (y) )
# define SQRT_64( z ) FT_Sqrt64( z )
/*************************************************************************/
/* */
@ -58,10 +59,8 @@ FT_BEGIN_HEADER
/* */
FT_EXPORT( FT_Int32 ) FT_Sqrt64( FT_Int64 l );
#endif /* FT_CONFIG_OPTION_OLD_CALCS */
#else /* FT_LONG64 */
# else /* !FT_LONG64 */
typedef struct FT_Int64_
@ -72,9 +71,9 @@ FT_BEGIN_HEADER
} FT_Int64;
#define ADD_64( x, y, z ) FT_Add64( &x, &y, &z )
#define MUL_64( x, y, z ) FT_MulTo64( x, y, &z )
#define DIV_64( x, y ) FT_Div64by32( &x, y )
# define ADD_64( x, y, z ) FT_Add64( &x, &y, &z )
# define MUL_64( x, y, z ) FT_MulTo64( x, y, &z )
# define DIV_64( x, y ) FT_Div64by32( &x, y )
/*************************************************************************/
@ -146,9 +145,7 @@ FT_BEGIN_HEADER
FT_Int32 y );
#ifdef FT_CONFIG_OPTION_OLD_CALCS
#define SQRT_64( z ) FT_Sqrt64( &z )
# define SQRT_64( z ) FT_Sqrt64( &z )
/*************************************************************************/
/* */
@ -168,11 +165,11 @@ FT_BEGIN_HEADER
/* */
FT_EXPORT( FT_Int32 ) FT_Sqrt64( FT_Int64* x );
# endif /* !FT_LONG64 */
#endif /* FT_CONFIG_OPTION_OLD_CALCS */
#endif /* FT_LONG64 */
FT_EXPORT( FT_Int32 ) FT_SqrtFixed( FT_Int32 x );

21
src/base/ftcalc.c
View File

@ -38,6 +38,27 @@
#include FT_INTERNAL_OBJECTS_H
/* we need to define a 64-bits data type here */
#ifndef FT_CONFIG_OPTION_OLD_CALCS
# ifdef FT_LONG64
typedef FT_INT64 FT_Int64;
# else
typedef struct FT_Int64_
{
FT_UInt32 lo;
FT_UInt32 hi;
} FT_Int64;
# endif
#endif
/*************************************************************************/
/* */
/* The macro FT_COMPONENT is used in trace mode. It is an implicit */

153
src/truetype/ttinterp.c
View File

@ -19,6 +19,7 @@
#include <ft2build.h>
#include FT_INTERNAL_DEBUG_H
#include FT_INTERNAL_CALC_H
#include FT_TRIGONOMETRY_H
#include FT_SYSTEM_H
#include "ttinterp.h"
@ -31,10 +32,8 @@
#define TT_MULFIX FT_MulFix
#define TT_MULDIV FT_MulDiv
#define TT_INT64 FT_Int64
/*************************************************************************/
/* */
/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
@ -825,6 +824,7 @@
}
/* return length of given vector */
#ifdef FT_CONFIG_OPTION_OLD_CALCS
static FT_F26Dot6 Norm( FT_F26Dot6 X,
@ -841,6 +841,18 @@
return (FT_F26Dot6)SQRT_64( T1 );
}
#else /* !FT_CONFIG_OPTION_OLD_CALCS */
static FT_F26Dot6 Norm( FT_F26Dot6 X,
FT_F26Dot6 Y )
{
FT_Vector v;
v.x = X;
v.y = Y;
return FT_Vector_Length( &v );
}
#endif /* FT_CONFIG_OPTION_OLD_CALCS */
@ -1214,21 +1226,9 @@
{
FT_Long x, y;
#ifdef FT_CONFIG_OPTION_OLD_CALCS
x = TT_MULDIV( CUR.GS.projVector.x, CUR.tt_metrics.x_ratio, 0x4000 );
y = TT_MULDIV( CUR.GS.projVector.y, CUR.tt_metrics.y_ratio, 0x4000 );
CUR.tt_metrics.ratio = Norm( x, y );
#else
x = TT_MULDIV( CUR.GS.projVector.x, CUR.tt_metrics.x_ratio, 0x8000 );
y = TT_MULDIV( CUR.GS.projVector.y, CUR.tt_metrics.y_ratio, 0x8000 );
CUR.tt_metrics.ratio = FT_Sqrt32( x * x + y * y ) << 1;
#endif /* FT_CONFIG_OPTION_OLD_CALCS */
}
return CUR.tt_metrics.ratio;
@ -2287,123 +2287,16 @@
FT_F26Dot6 Vy,
FT_UnitVector* R )
{
FT_F26Dot6 u, v, d;
FT_Int shift;
FT_ULong H, L, L2, hi, lo, med;
u = ABS( Vx );
v = ABS( Vy );
if ( u < v )
{
d = u;
u = v;
v = d;
}
R->x = 0;
R->y = 0;
/* check that we are not trying to normalise zero! */
if ( u == 0 )
return SUCCESS;
/* compute (u*u + v*v) on 64 bits with two 32-bit registers [H:L] */
hi = (FT_ULong)u >> 16;
lo = (FT_ULong)u & 0xFFFF;
med = hi * lo;
H = hi * hi + ( med >> 15 );
med <<= 17;
L = lo * lo + med;
if ( L < med )
H++;
hi = (FT_ULong)v >> 16;
lo = (FT_ULong)v & 0xFFFF;
med = hi * lo;
H += hi * hi + ( med >> 15 );
med <<= 17;
L2 = lo * lo + med;
if ( L2 < med )
H++;
L += L2;
if ( L < L2 )
H++;
/* if the value is smaller than 32-bits */
if ( H == 0 )
{
shift = 0;
while ( ( L & 0xC0000000L ) == 0 )
{
L <<= 2;
shift++;
}
d = FT_Sqrt32( L );
R->x = (FT_F2Dot14)TT_MULDIV( Vx << shift, 0x4000, d );
R->y = (FT_F2Dot14)TT_MULDIV( Vy << shift, 0x4000, d );
}
/* if the value is greater than 64-bits */
else
{
shift = 0;
while ( H )
{
L = ( L >> 2 ) | ( H << 30 );
H >>= 2;
shift++;
}
d = FT_Sqrt32( L );
R->x = (FT_F2Dot14)TT_MULDIV( Vx >> shift, 0x4000, d );
R->y = (FT_F2Dot14)TT_MULDIV( Vy >> shift, 0x4000, d );
}
{
FT_ULong x, y, w;
FT_Int sx, sy;
sx = R->x >= 0 ? 1 : -1;
sy = R->y >= 0 ? 1 : -1;
x = (FT_ULong)sx * R->x;
y = (FT_ULong)sy * R->y;
w = x * x + y * y;
/* we now want to adjust (x,y) in order to have sqrt(w) == 0x4000 */
/* which means 0x1000000 <= w < 0x1004000 */
while ( w <= 0x10000000L )
{
/* increment the smallest coordinate */
if ( x < y )
x++;
else
y++;
w = x * x + y * y;
}
while ( w >= 0x10040000L )
{
/* decrement the smallest coordinate */
if ( x < y )
x--;
else
y--;
w = x * x + y * y;
}
R->x = sx * x;
R->y = sy * y;
}
FT_Vector v;
FT_Angle angle;
angle = FT_Atan2( Vx, Vy );
FT_Vector_Unit( &v, angle );
R->x = v.x >> 2;
R->y = v.y >> 2;
return SUCCESS;
}