ReactOS 0.4.15-dev-5664-g3bf4ef6
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 ) ) )
GLint GLint GLint GLint GLint x
Definition: gl.h:1548

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.

979 {
980 FT_Pos ax = in_x + out_x;
981 FT_Pos ay = in_y + out_y;
982
983 FT_Pos d_in, d_out, d_hypot;
984
985
986 /* The idea of this function is to compare the length of the */
987 /* hypotenuse with the `in' and `out' length. The `corner' */
988 /* represented by `in' and `out' is flat if the hypotenuse's */
989 /* length isn't too large. */
990 /* */
991 /* This approach has the advantage that the angle between */
992 /* `in' and `out' is not checked. In case one of the two */
993 /* vectors is `dominant', this is, much larger than the */
994 /* other vector, we thus always have a flat corner. */
995 /* */
996 /* hypotenuse */
997 /* x---------------------------x */
998 /* \ / */
999 /* \ / */
1000 /* in \ / out */
1001 /* \ / */
1002 /* o */
1003 /* Point */
1004
1005 d_in = FT_HYPOT( in_x, in_y );
1006 d_out = FT_HYPOT( out_x, out_y );
1007 d_hypot = FT_HYPOT( ax, ay );
1008
1009 /* now do a simple length comparison: */
1010 /* */
1011 /* d_in + d_out < 17/16 d_hypot */
1012
1013 return ( d_in + d_out - d_hypot ) < ( d_hypot >> 4 );
1014 }
FT_BEGIN_HEADER typedef signed long FT_Pos
Definition: ftimage.h:58
#define FT_HYPOT(x, y)
Definition: ftobjs.h:81
ecx edi movl ebx edx edi decl ecx esi eax jecxz decl eax andl eax esi movl edx movl TEMP incl eax andl eax ecx incl ebx testl eax jnz xchgl ecx incl TEMP esp ecx subl ebx pushl ecx ecx edx ecx shrl ecx mm0 mm4 mm0 mm4 mm1 mm5 mm1 mm5 mm2 mm6 mm2 mm6 mm3 mm7 mm3 mm7 paddd mm0 paddd mm4 paddd mm0 paddd mm4 paddd mm0 paddd mm4 movq mm1 movq mm5 psrlq mm1 psrlq mm5 paddd mm0 paddd mm4 psrad mm0 psrad mm4 packssdw mm0 packssdw mm4 mm1 punpckldq mm0 pand mm1 pand mm0 por mm1 movq edi esi edx edi decl ecx jnz popl ecx andl ecx jecxz mm0 mm0 mm1 mm1 mm2 mm2 mm3 mm3 paddd mm0 paddd mm0 paddd mm0 movq mm1 psrlq mm1 paddd mm0 psrad mm0 packssdw mm0 movd eax movw ax
Definition: synth_sse3d.h:180

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.

915 {
916#ifdef FT_LONG64
917
918 FT_Int64 delta = (FT_Int64)in_x * out_y - (FT_Int64)in_y * out_x;
919
920
921 return ( delta > 0 ) - ( delta < 0 );
922
923#else
924
926
927
928 /* we silently ignore overflow errors, since such large values */
929 /* lead to even more (harmless) rendering errors later on */
930 if ( ADD_LONG( FT_ABS( in_x ), FT_ABS( out_y ) ) <= 131071L &&
931 ADD_LONG( FT_ABS( in_y ), FT_ABS( out_x ) ) <= 131071L )
932 {
933 FT_Long z1 = MUL_LONG( in_x, out_y );
934 FT_Long z2 = MUL_LONG( in_y, out_x );
935
936
937 if ( z1 > z2 )
938 result = +1;
939 else if ( z1 < z2 )
940 result = -1;
941 else
942 result = 0;
943 }
944 else /* products might overflow 32 bits */
945 {
946 FT_Int64 z1, z2;
947
948
949 /* XXX: this function does not allow 64-bit arguments */
950 ft_multo64( (FT_UInt32)in_x, (FT_UInt32)out_y, &z1 );
951 ft_multo64( (FT_UInt32)in_y, (FT_UInt32)out_x, &z2 );
952
953 if ( z1.hi > z2.hi )
954 result = +1;
955 else if ( z1.hi < z2.hi )
956 result = -1;
957 else if ( z1.lo > z2.lo )
958 result = +1;
959 else if ( z1.lo < z2.lo )
960 result = -1;
961 else
962 result = 0;
963 }
964
965 /* XXX: only the sign of return value, +1/0/-1 must be used */
966 return result;
967
968#endif
969 }
static void ft_multo64(FT_UInt32 x, FT_UInt32 y, FT_Int64 *z)
Definition: ftcalc.c:280
struct FT_Int64_ FT_Int64
#define MUL_LONG(a, b)
Definition: ftcalc.h:424
#define ADD_LONG(a, b)
Definition: ftcalc.h:420
#define FT_ABS(a)
Definition: ftobjs.h:74
signed long FT_Long
Definition: fttypes.h:242
signed int FT_Int
Definition: fttypes.h:220
GLuint64EXT * result
Definition: glext.h:11304
FT_UInt32 lo
Definition: ftcalc.c:53
FT_UInt32 hi
Definition: ftcalc.c:54

◆ FT_Hypot()

FT_Hypot ( FT_Fixed  x,
FT_Fixed  y 
)

Definition at line 155 of file ftcalc.c.

157 {
158 FT_Vector v;
159
160
161 v.x = x;
162 v.y = y;
163
164 return FT_Vector_Length( &v );
165 }
FT_Vector_Length(FT_Vector *vec)
Definition: fttrigon.c:426
const GLdouble * v
Definition: gl.h:2040
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548

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.

723 {
724 FT_Fixed xx, xy, yx, yy;
725
726 FT_Long val = 0x10000L * scaling;
727
728
729 if ( !a || !b )
730 return;
731
732 xx = ADD_LONG( FT_MulDiv( a->xx, b->xx, val ),
733 FT_MulDiv( a->xy, b->yx, val ) );
734 xy = ADD_LONG( FT_MulDiv( a->xx, b->xy, val ),
735 FT_MulDiv( a->xy, b->yy, val ) );
736 yx = ADD_LONG( FT_MulDiv( a->yx, b->xx, val ),
737 FT_MulDiv( a->yy, b->yx, val ) );
738 yy = ADD_LONG( FT_MulDiv( a->yx, b->xy, val ),
739 FT_MulDiv( a->yy, b->yy, val ) );
740
741 b->xx = xx;
742 b->xy = xy;
743 b->yx = yx;
744 b->yy = yy;
745 }
FT_MulDiv(FT_Long a_, FT_Long b_, FT_Long c_)
Definition: ftcalc.c:416
signed long FT_Fixed
Definition: fttypes.h:288
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
GLuint GLfloat * val
Definition: glext.h:7180
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
int xx
Definition: npserver.c:29

Referenced by cff_face_init().

◆ FT_MSB()

FT_MSB ( FT_UInt32  z)

Definition at line 114 of file ftcalc.c.

115 {
116 FT_Int shift = 0;
117
118
119 /* determine msb bit index in `shift' */
120 if ( z & 0xFFFF0000UL )
121 {
122 z >>= 16;
123 shift += 16;
124 }
125 if ( z & 0x0000FF00UL )
126 {
127 z >>= 8;
128 shift += 8;
129 }
130 if ( z & 0x000000F0UL )
131 {
132 z >>= 4;
133 shift += 4;
134 }
135 if ( z & 0x0000000CUL )
136 {
137 z >>= 2;
138 shift += 2;
139 }
140 if ( z & 0x00000002UL )
141 {
142 /* z >>= 1; */
143 shift += 1;
144 }
145
146 return shift;
147 }
GLdouble GLdouble z
Definition: glext.h:5874
#define shift
Definition: input.c:1755

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.

467 {
468 FT_Int s = 1;
469 FT_UInt32 a, b, c;
470
471
472 /* XXX: this function does not allow 64-bit arguments */
473
474 a = (FT_UInt32)a_;
475 b = (FT_UInt32)b_;
476 c = (FT_UInt32)c_;
477
478 FT_MOVE_SIGN( a_, a, s );
479 FT_MOVE_SIGN( b_, b, s );
480 FT_MOVE_SIGN( c_, c, s );
481
482 if ( c == 0 )
483 a = 0x7FFFFFFFUL;
484
485 else if ( a + b <= 131071UL )
486 a = a * b / c;
487
488 else
489 {
491
492
493 ft_multo64( a, b, &temp );
494
495 /* last attempt to ditch long division */
496 a = ( temp.hi == 0 ) ? temp.lo / c
497 : ft_div64by32( temp.hi, temp.lo, c );
498 }
499
500 a_ = (FT_Long)a;
501
502 return s < 0 ? NEG_LONG( a_ ) : a_;
503 }
#define FT_MOVE_SIGN(x, x_unsigned, s)
Definition: ftcalc.c:73
static FT_UInt32 ft_div64by32(FT_UInt32 hi, FT_UInt32 lo, FT_UInt32 y)
Definition: ftcalc.c:312
#define NEG_LONG(a)
Definition: ftcalc.h:426
GLdouble s
Definition: gl.h:2039
const GLubyte * c
Definition: glext.h:8905
#define a
Definition: ke_i.h:78
#define c
Definition: ke_i.h:80
#define b
Definition: ke_i.h:79
static calc_node_t temp
Definition: rpn_ieee.c:38

◆ FT_Vector_NormLen()

FT_Vector_NormLen ( FT_Vector vector)

Definition at line 776 of file ftcalc.c.

777 {
778 FT_Int32 x_ = vector->x;
779 FT_Int32 y_ = vector->y;
780 FT_Int32 b, z;
781 FT_UInt32 x, y, u, v, l;
782 FT_Int sx = 1, sy = 1, shift;
783
784
785 x = (FT_UInt32)x_;
786 y = (FT_UInt32)y_;
787
788 FT_MOVE_SIGN( x_, x, sx );
789 FT_MOVE_SIGN( y_, y, sy );
790
791 /* trivial cases */
792 if ( x == 0 )
793 {
794 if ( y > 0 )
795 vector->y = sy * 0x10000;
796 return y;
797 }
798 else if ( y == 0 )
799 {
800 if ( x > 0 )
801 vector->x = sx * 0x10000;
802 return x;
803 }
804
805 /* Estimate length and prenormalize by shifting so that */
806 /* the new approximate length is between 2/3 and 4/3. */
807 /* The magic constant 0xAAAAAAAAUL (2/3 of 2^32) helps */
808 /* achieve this in 16.16 fixed-point representation. */
809 l = x > y ? x + ( y >> 1 )
810 : y + ( x >> 1 );
811
812 shift = 31 - FT_MSB( l );
813 shift -= 15 + ( l >= ( 0xAAAAAAAAUL >> shift ) );
814
815 if ( shift > 0 )
816 {
817 x <<= shift;
818 y <<= shift;
819
820 /* re-estimate length for tiny vectors */
821 l = x > y ? x + ( y >> 1 )
822 : y + ( x >> 1 );
823 }
824 else
825 {
826 x >>= -shift;
827 y >>= -shift;
828 l >>= -shift;
829 }
830
831 /* lower linear approximation for reciprocal length minus one */
832 b = 0x10000 - (FT_Int32)l;
833
834 x_ = (FT_Int32)x;
835 y_ = (FT_Int32)y;
836
837 /* Newton's iterations */
838 do
839 {
840 u = (FT_UInt32)( x_ + ( x_ * b >> 16 ) );
841 v = (FT_UInt32)( y_ + ( y_ * b >> 16 ) );
842
843 /* Normalized squared length in the parentheses approaches 2^32. */
844 /* On two's complement systems, converting to signed gives the */
845 /* difference with 2^32 even if the expression wraps around. */
846 z = -(FT_Int32)( u * u + v * v ) / 0x200;
847 z = z * ( ( 0x10000 + b ) >> 8 ) / 0x10000;
848
849 b += z;
850
851 } while ( z > 0 );
852
853 vector->x = sx < 0 ? -(FT_Pos)u : (FT_Pos)u;
854 vector->y = sy < 0 ? -(FT_Pos)v : (FT_Pos)v;
855
856 /* Conversion to signed helps to recover from likely wrap around */
857 /* in calculating the prenormalized length, because it gives the */
858 /* correct difference with 2^32 on two's complement systems. */
859 l = (FT_UInt32)( 0x10000 + (FT_Int32)( u * x + v * y ) / 0x10000 );
860 if ( shift > 0 )
861 l = ( l + ( 1 << ( shift - 1 ) ) ) >> shift;
862 else
863 l <<= -shift;
864
865 return l;
866 }
r l[0]
Definition: byte_order.h:167
FT_MSB(FT_UInt32 z)
Definition: ftcalc.c:114
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240

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.

754 {
755 FT_Pos xz, yz;
756
757 FT_Long val = 0x10000L * scaling;
758
759
760 if ( !vector || !matrix )
761 return;
762
763 xz = ADD_LONG( FT_MulDiv( vector->x, matrix->xx, val ),
764 FT_MulDiv( vector->y, matrix->xy, val ) );
765 yz = ADD_LONG( FT_MulDiv( vector->x, matrix->yx, val ),
766 FT_MulDiv( vector->y, matrix->yy, val ) );
767
768 vector->x = xz;
769 vector->y = yz;
770 }
GLuint GLenum matrix
Definition: glext.h:9407

Referenced by cff_face_init().