ftcalc.c File Reference

#include <freetype/ftglyph.h>
#include <freetype/fttrigon.h>
#include <freetype/internal/ftcalc.h>
#include <freetype/internal/ftdebug.h>
#include <freetype/internal/ftobjs.h>

Include dependency graph for ftcalc.c:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	FT_Int64_

Macros
#define	FT_COMPONENT   calc
#define	FT_MOVE_SIGN(x, x_unsigned, s)

Typedefs
typedef struct FT_Int64_	FT_Int64

Functions
	FT_RoundFix (FT_Fixed a)
	FT_CeilFix (FT_Fixed a)
	FT_FloorFix (FT_Fixed a)
	FT_MSB (FT_UInt32 z)
	FT_Hypot (FT_Fixed x, FT_Fixed y)
static void	ft_multo64 (FT_UInt32 x, FT_UInt32 y, FT_Int64 *z)
static FT_UInt32	ft_div64by32 (FT_UInt32 hi, FT_UInt32 lo, FT_UInt32 y)
static void	FT_Add64 (FT_Int64 *x, FT_Int64 *y, FT_Int64 *z)
	FT_MulDiv (FT_Long a_, FT_Long b_, FT_Long c_)
	FT_MulDiv_No_Round (FT_Long a_, FT_Long b_, FT_Long c_)
	FT_MulFix (FT_Long a_, FT_Long b_)
	FT_DivFix (FT_Long a_, FT_Long b_)
	FT_Matrix_Multiply (const FT_Matrix *a, FT_Matrix *b)
	FT_Matrix_Invert (FT_Matrix *matrix)
	FT_Matrix_Multiply_Scaled (const FT_Matrix *a, FT_Matrix *b, FT_Long scaling)
	FT_Matrix_Check (const FT_Matrix *matrix)
	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)

Macro Definition Documentation

FT_COMPONENT

#define FT_COMPONENT   calc

Definition at line 67 of file ftcalc.c.

FT_MOVE_SIGN

#define FT_MOVE_SIGN	(		x,
			x_unsigned,
			s
	)

Value:

  FT_BEGIN_STMNT                         \
    if ( x < 0 )                         \
    {                                    \
      x_unsigned = 0U - (x_unsigned);    \
      s          = -s;                   \
    }                                    \
  FT_END_STMNT

Definition at line 72 of file ftcalc.c.

Typedef Documentation

FT_Int64

typedef struct FT_Int64_ FT_Int64

Function Documentation

FT_Add64()

static void FT_Add64 ( FT_Int64 *  x, FT_Int64 *  y, FT_Int64 *  z  )

static

Definition at line 350 of file ftcalc.c.

  {
    FT_UInt32  lo, hi;
 
 
    lo = x->lo + y->lo;
    hi = x->hi + y->hi + ( lo < x->lo );
 
    z->lo = lo;
    z->hi = hi;
  }

Referenced by FT_DivFix(), and FT_MulDiv().

FT_CeilFix()

FT_CeilFix

(

FT_Fixed

a

)

Definition at line 96 of file ftcalc.c.

  {
    return ( ADD_LONG( a, 0xFFFFL ) ) & ~0xFFFFL;
  }

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 1046 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 980 of file ftcalc.c.

  {
    /* we silently ignore overflow errors since such large values */
    /* lead to even more (harmless) rendering errors later on     */
 
#ifdef FT_LONG64
 
    FT_Int64  delta = SUB_INT64( MUL_INT64( in_x, out_y ),
                                 MUL_INT64( in_y, out_x ) );
 
 
    return ( delta > 0 ) - ( delta < 0 );
 
#else
 
    FT_Int  result;
 
 
    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_div64by32()

static FT_UInt32 ft_div64by32 ( FT_UInt32  hi, FT_UInt32  lo, FT_UInt32  y  )

static

Definition at line 311 of file ftcalc.c.

  {
    FT_UInt32  r, q;
    FT_Int     i;
 
 
    if ( hi >= y )
      return (FT_UInt32)0x7FFFFFFFL;
 
    /* We shift as many bits as we can into the high register, perform     */
    /* 32-bit division with modulo there, then work through the remaining  */
    /* bits with long division. This optimization is especially noticeable */
    /* for smaller dividends that barely use the high register.            */
 
    i = 31 - FT_MSB( hi );
    r = ( hi << i ) | ( lo >> ( 32 - i ) ); lo <<= i; /* left 64-bit shift */
    q = r / y;
    r -= q * y;   /* remainder */
 
    i = 32 - i;   /* bits remaining in low register */
    do
    {
      q <<= 1;
      r   = ( r << 1 ) | ( lo >> 31 ); lo <<= 1;
 
      if ( r >= y )
      {
        r -= y;
        q |= 1;
      }
    } while ( --i );
 
    return q;
  }

Referenced by FT_DivFix(), FT_MulDiv(), and FT_MulDiv_No_Round().

FT_DivFix()

FT_DivFix	(	FT_Long	a_,
		FT_Long	b_
	)

Definition at line 607 of file ftcalc.c.

  {
    FT_Int     s = 1;
    FT_UInt32  a, b, q;
    FT_Long    q_;
 
 
    /* XXX: this function does not allow 64-bit arguments */
 
    a = (FT_UInt32)a_;
    b = (FT_UInt32)b_;
 
    FT_MOVE_SIGN( a_, a, s );
    FT_MOVE_SIGN( b_, b, s );
 
    if ( b == 0 )
    {
      /* check for division by 0 */
      q = 0x7FFFFFFFUL;
    }
    else if ( a <= 65535UL - ( b >> 17 ) )
    {
      /* compute result directly */
      q = ( ( a << 16 ) + ( b >> 1 ) ) / b;
    }
    else
    {
      /* we need more bits; we have to do it by hand */
      FT_Int64  temp, temp2;
 
 
      temp.hi  = a >> 16;
      temp.lo  = a << 16;
      temp2.hi = 0;
      temp2.lo = b >> 1;
 
      FT_Add64( &temp, &temp2, &temp );
      q = ft_div64by32( temp.hi, temp.lo, b );
    }
 
    q_ = (FT_Long)q;
 
    return s < 0 ? NEG_LONG( q_ ) : q_;
  }

Referenced by af_glyph_hints_align_strong_points(), af_iup_interp(), af_latin_hints_compute_edges(), af_loader_compute_darkening(), af_loader_embolden_glyph_in_slot(), af_loader_load_glyph(), cf2_blues_init(), cf2_checkTransform(), cf2_computeDarkening(), cf2_font_setup(), cf2_getBlueMetrics(), cf2_glyphpath_computeIntersection(), cf2_hintmap_adjustHints(), cf2_interpT2CharString(), cff_blend_build_vector(), cff_face_init(), cff_parse_fixed_dynamic(), cff_parse_real(), cid_parse_font_matrix(), compute_glyph_metrics(), FT_Matrix_Check(), FT_Matrix_Invert(), FT_Request_Metrics(), FT_Select_Metrics(), FT_Stroker_ConicTo(), FT_Stroker_CubicTo(), ft_stroker_inside(), ft_stroker_outside(), FT_Tan(), mm_axis_unmap(), pfr_get_metrics(), PS_Conv_ToFixed(), psh_globals_new(), psh_glyph_find_strong_points(), psh_glyph_interpolate_other_points(), t1_decoder_parse_metrics(), t1_parse_font_matrix(), t42_parse_font_matrix(), and tt_size_reset().

FT_FloorFix()

FT_FloorFix

(

FT_Fixed

a

)

Definition at line 105 of file ftcalc.c.

  {
    return a & ~0xFFFFL;
  }

FT_Hypot()

FT_Hypot	(	FT_Fixed	x,
		FT_Fixed	y
	)

Definition at line 154 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_Check()

FT_Matrix_Check

(

const FT_Matrix *

matrix

)

Definition at line 750 of file ftcalc.c.

  {
    FT_Matrix  m;
    FT_Fixed   val[4];
    FT_Fixed   nonzero_minval, maxval;
    FT_Fixed   temp1, temp2;
    FT_UInt    i;
 
 
    if ( !matrix )
      return 0;
 
    val[0] = FT_ABS( matrix->xx );
    val[1] = FT_ABS( matrix->xy );
    val[2] = FT_ABS( matrix->yx );
    val[3] = FT_ABS( matrix->yy );
 
    /*
     * To avoid overflow, we ensure that each value is not larger than
     *
     *   int(sqrt(2^31 / 4)) = 23170  ;
     *
     * we also check that no value becomes zero if we have to scale.
     */
 
    maxval         = 0;
    nonzero_minval = FT_LONG_MAX;
 
    for ( i = 0; i < 4; i++ )
    {
      if ( val[i] > maxval )
        maxval = val[i];
      if ( val[i] && val[i] < nonzero_minval )
        nonzero_minval = val[i];
    }
 
    /* we only handle 32bit values */
    if ( maxval > 0x7FFFFFFFL )
      return 0;
 
    if ( maxval > 23170 )
    {
      FT_Fixed  scale = FT_DivFix( maxval, 23170 );
 
 
      if ( !FT_DivFix( nonzero_minval, scale ) )
        return 0;    /* value range too large */
 
      m.xx = FT_DivFix( matrix->xx, scale );
      m.xy = FT_DivFix( matrix->xy, scale );
      m.yx = FT_DivFix( matrix->yx, scale );
      m.yy = FT_DivFix( matrix->yy, scale );
    }
    else
      m = *matrix;
 
    temp1 = FT_ABS( m.xx * m.yy - m.xy * m.yx );
    temp2 = m.xx * m.xx + m.xy * m.xy + m.yx * m.yx + m.yy * m.yy;
 
    if ( temp1 == 0         ||
         temp2 / temp1 > 50 )
      return 0;
 
    return 1;
  }

Referenced by cff_parse_font_matrix(), cid_parse_font_matrix(), t1_parse_font_matrix(), and t42_parse_font_matrix().

FT_Matrix_Invert()

FT_Matrix_Invert

(

FT_Matrix *

matrix

)

Definition at line 688 of file ftcalc.c.

  {
    FT_Pos  delta, xx, yy;
 
 
    if ( !matrix )
      return FT_THROW( Invalid_Argument );
 
    /* compute discriminant */
    delta = FT_MulFix( matrix->xx, matrix->yy ) -
            FT_MulFix( matrix->xy, matrix->yx );
 
    if ( !delta )
      return FT_THROW( Invalid_Argument );  /* matrix can't be inverted */
 
    matrix->xy = -FT_DivFix( matrix->xy, delta );
    matrix->yx = -FT_DivFix( matrix->yx, delta );
 
    xx = matrix->xx;
    yy = matrix->yy;
 
    matrix->xx = FT_DivFix( yy, delta );
    matrix->yy = FT_DivFix( xx, delta );
 
    return FT_Err_Ok;
  }

Referenced by af_loader_load_glyph().

FT_Matrix_Multiply()

FT_Matrix_Multiply	(	const FT_Matrix *	a,
		FT_Matrix *	b
	)

Definition at line 660 of file ftcalc.c.

  {
    FT_Fixed  xx, xy, yx, yy;
 
 
    if ( !a || !b )
      return;
 
    xx = ADD_LONG( FT_MulFix( a->xx, b->xx ),
                   FT_MulFix( a->xy, b->yx ) );
    xy = ADD_LONG( FT_MulFix( a->xx, b->xy ),
                   FT_MulFix( a->xy, b->yy ) );
    yx = ADD_LONG( FT_MulFix( a->yx, b->xx ),
                   FT_MulFix( a->yy, b->yx ) );
    yy = ADD_LONG( FT_MulFix( a->yx, b->xy ),
                   FT_MulFix( a->yy, b->yy ) );
 
    b->xx = xx;
    b->xy = xy;
    b->yx = yx;
    b->yy = yy;
  }

Referenced by ftGdiGetGlyphOutline(), and IntExtTextOutW().

FT_Matrix_Multiply_Scaled()

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

Definition at line 719 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 113 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()

FT_MulDiv	(	FT_Long	a_,
		FT_Long	b_,
		FT_Long	c_
	)

Definition at line 415 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 <= 129894UL - ( c >> 17 ) )
      a = ( a * b + ( c >> 1 ) ) / c;
 
    else
    {
      FT_Int64  temp, temp2;
 
 
      ft_multo64( a, b, &temp );
 
      temp2.hi = 0;
      temp2.lo = c >> 1;
 
      FT_Add64( &temp, &temp2, &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_;
  }

Referenced by _bdf_parse_glyphs(), _ft_face_scale_advances(), af_latin_hint_edges(), af_latin_metrics_scale_dim(), af_loader_compute_darkening(), BBox_Conic_Check(), BDF_Face_Init(), cf2_blues_init(), cf2_computeDarkening(), cff_face_init(), cff_size_request(), cff_slot_load(), FNT_Face_Init(), FT_Get_Kerning(), FT_Load_Glyph(), FT_Matrix_Multiply_Scaled(), FT_Outline_EmboldenXY(), FT_Request_Metrics(), FT_Stroker_ConicTo(), FT_Stroker_CubicTo(), ft_stroker_inside(), ft_stroker_outside(), FT_Vector_Transform_Scaled(), IntRequestFontSize(), pcf_load_font(), pfr_get_kerning(), pfr_slot_load(), ps_hints_apply(), psh_glyph_interpolate_normal_points(), psh_glyph_interpolate_strong_points(), T1_Get_Track_Kerning(), T1_Set_MM_Design(), TT_Process_Simple_Glyph(), and tt_size_request().

FT_MulDiv_No_Round()

FT_MulDiv_No_Round	(	FT_Long	a_,
		FT_Long	b_,
		FT_Long	c_
	)

Definition at line 463 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_MulFix()

FT_MulFix	(	FT_Long	a_,
		FT_Long	b_
	)

Definition at line 508 of file ftcalc.c.

  {
#ifdef FT_MULFIX_ASSEMBLER
 
    return FT_MULFIX_ASSEMBLER( a_, b_ );
 
#elif 0
 
    /*
     * This code is nonportable.  See comment below.
     *
     * However, on a platform where right-shift of a signed quantity fills
     * the leftmost bits by copying the sign bit, it might be faster.
     */
 
    FT_Long    sa, sb;
    FT_UInt32  a, b;
 
 
    /*
     * This is a clever way of converting a signed number `a' into its
     * absolute value (stored back into `a') and its sign.  The sign is
     * stored in `sa'; 0 means `a' was positive or zero, and -1 means `a'
     * was negative.  (Similarly for `b' and `sb').
     *
     * Unfortunately, it doesn't work (at least not portably).
     *
     * It makes the assumption that right-shift on a negative signed value
     * fills the leftmost bits by copying the sign bit.  This is wrong.
     * According to K&R 2nd ed, section `A7.8 Shift Operators' on page 206,
     * the result of right-shift of a negative signed value is
     * implementation-defined.  At least one implementation fills the
     * leftmost bits with 0s (i.e., it is exactly the same as an unsigned
     * right shift).  This means that when `a' is negative, `sa' ends up
     * with the value 1 rather than -1.  After that, everything else goes
     * wrong.
     */
    sa = ( a_ >> ( sizeof ( a_ ) * 8 - 1 ) );
    a  = ( a_ ^ sa ) - sa;
    sb = ( b_ >> ( sizeof ( b_ ) * 8 - 1 ) );
    b  = ( b_ ^ sb ) - sb;
 
    a = (FT_UInt32)a_;
    b = (FT_UInt32)b_;
 
    if ( a + ( b >> 8 ) <= 8190UL )
      a = ( a * b + 0x8000U ) >> 16;
    else
    {
      FT_UInt32  al = a & 0xFFFFUL;
 
 
      a = ( a >> 16 ) * b + al * ( b >> 16 ) +
          ( ( al * ( b & 0xFFFFUL ) + 0x8000UL ) >> 16 );
    }
 
    sa ^= sb;
    a   = ( a ^ sa ) - sa;
 
    return (FT_Long)a;
 
#else /* 0 */
 
    FT_Int     s = 1;
    FT_UInt32  a, b;
 
 
    /* XXX: this function does not allow 64-bit arguments */
 
    a = (FT_UInt32)a_;
    b = (FT_UInt32)b_;
 
    FT_MOVE_SIGN( a_, a, s );
    FT_MOVE_SIGN( b_, b, s );
 
    if ( a + ( b >> 8 ) <= 8190UL )
      a = ( a * b + 0x8000UL ) >> 16;
    else
    {
      FT_UInt32  al = a & 0xFFFFUL;
 
 
      a = ( a >> 16 ) * b + al * ( b >> 16 ) +
          ( ( al * ( b & 0xFFFFUL ) + 0x8000UL ) >> 16 );
    }
 
    a_ = (FT_Long)a;
 
    return s < 0 ? NEG_LONG( a_ ) : a_;
 
#endif /* 0 */
 
  }

Referenced by af_glyph_hints_align_strong_points(), af_glyph_hints_reload(), af_iup_interp(), af_latin_hints_compute_blue_edges(), af_latin_hints_compute_edges(), af_latin_metrics_scale_dim(), af_loader_compute_darkening(), af_loader_embolden_glyph_in_slot(), af_loader_load_glyph(), cf2_blues_init(), cf2_computeDarkening(), cf2_doBlend(), cf2_glyphpath_computeIntersection(), cf2_glyphpath_computeOffset(), cf2_glyphpath_hintPoint(), cf2_hint_init(), cf2_hintmap_insertHint(), cf2_hintmap_map(), cf2_interpT2CharString(), cff_blend_build_vector(), cff_slot_load(), cid_slot_load_glyph(), compute_glyph_metrics(), FillTM(), FT_Get_Kerning(), FT_GlyphSlot_Embolden(), FT_Matrix_Invert(), FT_Matrix_Multiply(), FT_Outline_EmboldenXY(), ft_recompute_scaled_metrics(), FT_Request_Metrics(), ft_stroke_border_arcto(), ft_stroker_outside(), FT_Vector_Transform(), load_truetype_glyph(), pfr_glyph_load_rec(), pfr_slot_load(), ps_hints_apply(), psh_blues_scale_zones(), psh_globals_scale_widths(), psh_glyph_interpolate_normal_points(), psh_glyph_interpolate_other_points(), psh_glyph_interpolate_strong_points(), psh_hint_align(), T1_Load_Glyph(), t1_set_mm_blend(), TT_Load_Glyph(), TT_Process_Composite_Component(), TT_Process_Simple_Glyph(), and tt_size_reset().

ft_multo64()

static void ft_multo64 ( FT_UInt32  x, FT_UInt32  y, FT_Int64 *  z  )

static

Definition at line 279 of file ftcalc.c.

  {
    FT_UInt32  lo1, hi1, lo2, hi2, lo, hi, i1, i2;
 
 
    lo1 = x & 0x0000FFFFU;  hi1 = x >> 16;
    lo2 = y & 0x0000FFFFU;  hi2 = y >> 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 );
 
    z->lo = lo;
    z->hi = hi;
  }

Referenced by ft_corner_orientation(), FT_MulDiv(), and FT_MulDiv_No_Round().

FT_RoundFix()

FT_RoundFix

(

FT_Fixed

a

)

Definition at line 87 of file ftcalc.c.

  {
    return ( ADD_LONG( a, 0x8000L - ( a < 0 ) ) ) & ~0xFFFFL;
  }

Referenced by cff_parse_font_bbox(), and ps_parser_load_field().

FT_Vector_NormLen()

FT_Vector_NormLen

(

FT_Vector *

vector

)

Definition at line 845 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 820 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().