ftcalc.h File Reference

#include <ft2build.h>

Include dependency graph for ftcalc.h:

Go to the source code of this file.

Macros
#define	INT_TO_F26DOT6(x)   ( (FT_Long)(x) * 64 ) /* << 6 */
#define	INT_TO_F2DOT14(x)   ( (FT_Long)(x) * 16384 ) /* << 14 */
#define	INT_TO_FIXED(x)   ( (FT_Long)(x) * 65536 ) /* << 16 */
#define	F2DOT14_TO_FIXED(x)   ( (FT_Long)(x) * 4 ) /* << 2 */
#define	FIXED_TO_INT(x)   ( FT_RoundFix( x ) >> 16 )
#define	ROUND_F26DOT6(x)
#define	ADD_LONG(a, b)    (FT_Long)( (FT_ULong)(a) + (FT_ULong)(b) )
#define	SUB_LONG(a, b)    (FT_Long)( (FT_ULong)(a) - (FT_ULong)(b) )
#define	MUL_LONG(a, b)    (FT_Long)( (FT_ULong)(a) * (FT_ULong)(b) )
#define	NEG_LONG(a)    (FT_Long)( (FT_ULong)0 - (FT_ULong)(a) )
#define	ADD_INT32(a, b)    (FT_Int32)( (FT_UInt32)(a) + (FT_UInt32)(b) )
#define	SUB_INT32(a, b)    (FT_Int32)( (FT_UInt32)(a) - (FT_UInt32)(b) )
#define	MUL_INT32(a, b)    (FT_Int32)( (FT_UInt32)(a) * (FT_UInt32)(b) )
#define	NEG_INT32(a)    (FT_Int32)( (FT_UInt32)0 - (FT_UInt32)(a) )

Functions
FT_BEGIN_HEADER	FT_MulDiv_No_Round (FT_Long a, FT_Long b, FT_Long c)
	FT_Matrix_Multiply_Scaled (const FT_Matrix *a, FT_Matrix *b, FT_Long scaling)
	FT_Vector_Transform_Scaled (FT_Vector *vector, const FT_Matrix *matrix, FT_Long scaling)
	FT_Vector_NormLen (FT_Vector *vector)
	ft_corner_orientation (FT_Pos in_x, FT_Pos in_y, FT_Pos out_x, FT_Pos out_y)
	ft_corner_is_flat (FT_Pos in_x, FT_Pos in_y, FT_Pos out_x, FT_Pos out_y)
	FT_MSB (FT_UInt32 z)
	FT_Hypot (FT_Fixed x, FT_Fixed y)

Macro Definition Documentation

ADD_INT32

#define ADD_INT32	(		a,
			b
	)		(FT_Int32)( (FT_UInt32)(a) + (FT_UInt32)(b) )

Definition at line 429 of file ftcalc.h.

ADD_LONG

#define ADD_LONG	(		a,
			b
	)		(FT_Long)( (FT_ULong)(a) + (FT_ULong)(b) )

Definition at line 420 of file ftcalc.h.

F2DOT14_TO_FIXED

#define F2DOT14_TO_FIXED

(

x

)

( (FT_Long)(x) * 4 ) /* << 2 */

Definition at line 405 of file ftcalc.h.

FIXED_TO_INT

#define FIXED_TO_INT

(

x

)

( FT_RoundFix( x ) >> 16 )

Definition at line 406 of file ftcalc.h.

INT_TO_F26DOT6

#define INT_TO_F26DOT6

(

x

)

( (FT_Long)(x) * 64 ) /* << 6 */

Definition at line 402 of file ftcalc.h.

INT_TO_F2DOT14

#define INT_TO_F2DOT14

(

x

)

( (FT_Long)(x) * 16384 ) /* << 14 */

Definition at line 403 of file ftcalc.h.

INT_TO_FIXED

#define INT_TO_FIXED

(

x

)

( (FT_Long)(x) * 65536 ) /* << 16 */

Definition at line 404 of file ftcalc.h.

MUL_INT32

#define MUL_INT32	(		a,
			b
	)		(FT_Int32)( (FT_UInt32)(a) * (FT_UInt32)(b) )

Definition at line 433 of file ftcalc.h.

MUL_LONG

#define MUL_LONG	(		a,
			b
	)		(FT_Long)( (FT_ULong)(a) * (FT_ULong)(b) )

Definition at line 424 of file ftcalc.h.

NEG_INT32

#define NEG_INT32

(

a

)

(FT_Int32)( (FT_UInt32)0 - (FT_UInt32)(a) )

Definition at line 435 of file ftcalc.h.

NEG_LONG

#define NEG_LONG

(

a

)

(FT_Long)( (FT_ULong)0 - (FT_ULong)(a) )

Definition at line 426 of file ftcalc.h.

ROUND_F26DOT6

#define ROUND_F26DOT6

(

x

)

Value:

                                        ( x >= 0 ? (    ( (x) + 32 ) & -64 )     \
                                        : ( -( ( 32 - (x) ) & -64 ) ) )

Definition at line 408 of file ftcalc.h.

SUB_INT32

#define SUB_INT32	(		a,
			b
	)		(FT_Int32)( (FT_UInt32)(a) - (FT_UInt32)(b) )

Definition at line 431 of file ftcalc.h.

SUB_LONG

#define SUB_LONG	(		a,
			b
	)		(FT_Long)( (FT_ULong)(a) - (FT_ULong)(b) )

Definition at line 422 of file ftcalc.h.

Function Documentation

ft_corner_is_flat()

ft_corner_is_flat	(	FT_Pos	in_x,
		FT_Pos	in_y,
		FT_Pos	out_x,
		FT_Pos	out_y
	)

Definition at line 975 of file ftcalc.c.

  {
    FT_Pos  ax = in_x + out_x;
    FT_Pos  ay = in_y + out_y;
 
    FT_Pos  d_in, d_out, d_hypot;
 
 
    /* The idea of this function is to compare the length of the */
    /* hypotenuse with the `in' and `out' length.  The `corner'  */
    /* represented by `in' and `out' is flat if the hypotenuse's */
    /* length isn't too large.                                   */
    /*                                                           */
    /* This approach has the advantage that the angle between    */
    /* `in' and `out' is not checked.  In case one of the two    */
    /* vectors is `dominant', this is, much larger than the      */
    /* other vector, we thus always have a flat corner.          */
    /*                                                           */
    /*                hypotenuse                                 */
    /*       x---------------------------x                       */
    /*        \                      /                           */
    /*         \                /                                */
    /*      in  \          /  out                                */
    /*           \    /                                          */
    /*            o                                              */
    /*              Point                                        */
 
    d_in    = FT_HYPOT(  in_x,  in_y );
    d_out   = FT_HYPOT( out_x, out_y );
    d_hypot = FT_HYPOT(    ax,    ay );
 
    /* now do a simple length comparison: */
    /*                                    */
    /*   d_in + d_out < 17/16 d_hypot     */
 
    return ( d_in + d_out - d_hypot ) < ( d_hypot >> 4 );
  }

Referenced by af_glyph_hints_reload().

ft_corner_orientation()

ft_corner_orientation	(	FT_Pos	in_x,
		FT_Pos	in_y,
		FT_Pos	out_x,
		FT_Pos	out_y
	)

Definition at line 911 of file ftcalc.c.

  {
#ifdef FT_LONG64
 
    FT_Int64  delta = (FT_Int64)in_x * out_y - (FT_Int64)in_y * out_x;
 
 
    return ( delta > 0 ) - ( delta < 0 );
 
#else
 
    FT_Int  result;
 
 
    /* we silently ignore overflow errors, since such large values */
    /* lead to even more (harmless) rendering errors later on      */
    if ( ADD_LONG( FT_ABS( in_x ), FT_ABS( out_y ) ) <= 131071L &&
         ADD_LONG( FT_ABS( in_y ), FT_ABS( out_x ) ) <= 131071L )
    {
      FT_Long  z1 = MUL_LONG( in_x, out_y );
      FT_Long  z2 = MUL_LONG( in_y, out_x );
 
 
      if ( z1 > z2 )
        result = +1;
      else if ( z1 < z2 )
        result = -1;
      else
        result = 0;
    }
    else /* products might overflow 32 bits */
    {
      FT_Int64  z1, z2;
 
 
      /* XXX: this function does not allow 64-bit arguments */
      ft_multo64( (FT_UInt32)in_x, (FT_UInt32)out_y, &z1 );
      ft_multo64( (FT_UInt32)in_y, (FT_UInt32)out_x, &z2 );
 
      if ( z1.hi > z2.hi )
        result = +1;
      else if ( z1.hi < z2.hi )
        result = -1;
      else if ( z1.lo > z2.lo )
        result = +1;
      else if ( z1.lo < z2.lo )
        result = -1;
      else
        result = 0;
    }
 
    /* XXX: only the sign of return value, +1/0/-1 must be used */
    return result;
 
#endif
  }

FT_Hypot()

FT_Hypot	(	FT_Fixed	x,
		FT_Fixed	y
	)

Definition at line 155 of file ftcalc.c.

  {
    FT_Vector  v;
 
 
    v.x = x;
    v.y = y;
 
    return FT_Vector_Length( &v );
  }

Referenced by TT_Process_Composite_Component().

FT_Matrix_Multiply_Scaled()

FT_Matrix_Multiply_Scaled	(	const FT_Matrix *	a,
		FT_Matrix *	b,
		FT_Long	scaling
	)

Definition at line 720 of file ftcalc.c.

  {
    FT_Fixed  xx, xy, yx, yy;
 
    FT_Long   val = 0x10000L * scaling;
 
 
    if ( !a || !b )
      return;
 
    xx = ADD_LONG( FT_MulDiv( a->xx, b->xx, val ),
                   FT_MulDiv( a->xy, b->yx, val ) );
    xy = ADD_LONG( FT_MulDiv( a->xx, b->xy, val ),
                   FT_MulDiv( a->xy, b->yy, val ) );
    yx = ADD_LONG( FT_MulDiv( a->yx, b->xx, val ),
                   FT_MulDiv( a->yy, b->yx, val ) );
    yy = ADD_LONG( FT_MulDiv( a->yx, b->xy, val ),
                   FT_MulDiv( a->yy, b->yy, val ) );
 
    b->xx = xx;
    b->xy = xy;
    b->yx = yx;
    b->yy = yy;
  }

Referenced by cff_face_init().

FT_MSB()

FT_MSB

(

FT_UInt32

z

)

Definition at line 114 of file ftcalc.c.

  {
    FT_Int  shift = 0;
 
 
    /* determine msb bit index in `shift' */
    if ( z & 0xFFFF0000UL )
    {
      z     >>= 16;
      shift  += 16;
    }
    if ( z & 0x0000FF00UL )
    {
      z     >>= 8;
      shift  += 8;
    }
    if ( z & 0x000000F0UL )
    {
      z     >>= 4;
      shift  += 4;
    }
    if ( z & 0x0000000CUL )
    {
      z     >>= 2;
      shift  += 2;
    }
    if ( z & 0x00000002UL )
    {
   /* z     >>= 1; */
      shift  += 1;
    }
 
    return shift;
  }

Referenced by af_loader_compute_darkening(), cf2_computeDarkening(), cubic_peak(), ft_div64by32(), FT_Outline_Get_Orientation(), ft_trig_prenorm(), FT_Vector_NormLen(), and pfr_face_get_kerning().

FT_MulDiv_No_Round()

FT_BEGIN_HEADER FT_MulDiv_No_Round	(	FT_Long	a,
		FT_Long	b,
		FT_Long	c
	)

Definition at line 464 of file ftcalc.c.

  {
    FT_Int     s = 1;
    FT_UInt32  a, b, c;
 
 
    /* XXX: this function does not allow 64-bit arguments */
 
    a = (FT_UInt32)a_;
    b = (FT_UInt32)b_;
    c = (FT_UInt32)c_;
 
    FT_MOVE_SIGN( a_, a, s );
    FT_MOVE_SIGN( b_, b, s );
    FT_MOVE_SIGN( c_, c, s );
 
    if ( c == 0 )
      a = 0x7FFFFFFFUL;
 
    else if ( a + b <= 131071UL )
      a = a * b / c;
 
    else
    {
      FT_Int64  temp;
 
 
      ft_multo64( a, b, &temp );
 
      /* last attempt to ditch long division */
      a = ( temp.hi == 0 ) ? temp.lo / c
                           : ft_div64by32( temp.hi, temp.lo, c );
    }
 
    a_ = (FT_Long)a;
 
    return s < 0 ? NEG_LONG( a_ ) : a_;
  }

FT_Vector_NormLen()

FT_Vector_NormLen

(

FT_Vector *

vector

)

Definition at line 776 of file ftcalc.c.

  {
    FT_Int32   x_ = vector->x;
    FT_Int32   y_ = vector->y;
    FT_Int32   b, z;
    FT_UInt32  x, y, u, v, l;
    FT_Int     sx = 1, sy = 1, shift;
 
 
    x = (FT_UInt32)x_;
    y = (FT_UInt32)y_;
 
    FT_MOVE_SIGN( x_, x, sx );
    FT_MOVE_SIGN( y_, y, sy );
 
    /* trivial cases */
    if ( x == 0 )
    {
      if ( y > 0 )
        vector->y = sy * 0x10000;
      return y;
    }
    else if ( y == 0 )
    {
      if ( x > 0 )
        vector->x = sx * 0x10000;
      return x;
    }
 
    /* Estimate length and prenormalize by shifting so that */
    /* the new approximate length is between 2/3 and 4/3.   */
    /* The magic constant 0xAAAAAAAAUL (2/3 of 2^32) helps  */
    /* achieve this in 16.16 fixed-point representation.    */
    l = x > y ? x + ( y >> 1 )
              : y + ( x >> 1 );
 
    shift  = 31 - FT_MSB( l );
    shift -= 15 + ( l >= ( 0xAAAAAAAAUL >> shift ) );
 
    if ( shift > 0 )
    {
      x <<= shift;
      y <<= shift;
 
      /* re-estimate length for tiny vectors */
      l = x > y ? x + ( y >> 1 )
                : y + ( x >> 1 );
    }
    else
    {
      x >>= -shift;
      y >>= -shift;
      l >>= -shift;
    }
 
    /* lower linear approximation for reciprocal length minus one */
    b = 0x10000 - (FT_Int32)l;
 
    x_ = (FT_Int32)x;
    y_ = (FT_Int32)y;
 
    /* Newton's iterations */
    do
    {
      u = (FT_UInt32)( x_ + ( x_ * b >> 16 ) );
      v = (FT_UInt32)( y_ + ( y_ * b >> 16 ) );
 
      /* Normalized squared length in the parentheses approaches 2^32. */
      /* On two's complement systems, converting to signed gives the   */
      /* difference with 2^32 even if the expression wraps around.     */
      z = -(FT_Int32)( u * u + v * v ) / 0x200;
      z = z * ( ( 0x10000 + b ) >> 8 ) / 0x10000;
 
      b += z;
 
    } while ( z > 0 );
 
    vector->x = sx < 0 ? -(FT_Pos)u : (FT_Pos)u;
    vector->y = sy < 0 ? -(FT_Pos)v : (FT_Pos)v;
 
    /* Conversion to signed helps to recover from likely wrap around */
    /* in calculating the prenormalized length, because it gives the */
    /* correct difference with 2^32 on two's complement systems.     */
    l = (FT_UInt32)( 0x10000 + (FT_Int32)( u * x + v * y ) / 0x10000 );
    if ( shift > 0 )
      l = ( l + ( 1 << ( shift - 1 ) ) ) >> shift;
    else
      l <<= -shift;
 
    return l;
  }

Referenced by FT_Outline_EmboldenXY().

FT_Vector_Transform_Scaled()

FT_Vector_Transform_Scaled	(	FT_Vector *	vector,
		const FT_Matrix *	matrix,
		FT_Long	scaling
	)

Definition at line 751 of file ftcalc.c.

  {
    FT_Pos   xz, yz;
 
    FT_Long  val = 0x10000L * scaling;
 
 
    if ( !vector || !matrix )
      return;
 
    xz = ADD_LONG( FT_MulDiv( vector->x, matrix->xx, val ),
                   FT_MulDiv( vector->y, matrix->xy, val ) );
    yz = ADD_LONG( FT_MulDiv( vector->x, matrix->yx, val ),
                   FT_MulDiv( vector->y, matrix->yy, val ) );
 
    vector->x = xz;
    vector->y = yz;
  }

Referenced by cff_face_init().