← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to tests/freetype/include/freetype/internal/ftcalc.h

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/freetype/include/freetype/internal/ftcalc.h
 
1
/***************************************************************************/
 
2
/*                                                                         */
 
3
/*  ftcalc.h                                                               */
 
4
/*                                                                         */
 
5
/*    Arithmetic computations (specification).                             */
 
6
/*                                                                         */
 
7
/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2008, 2009 by       */
 
8
/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
 
9
/*                                                                         */
 
10
/*  This file is part of the FreeType project, and may only be used,       */
 
11
/*  modified, and distributed under the terms of the FreeType project      */
 
12
/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
 
13
/*  this file you indicate that you have read the license and              */
 
14
/*  understand and accept it fully.                                        */
 
15
/*                                                                         */
 
16
/***************************************************************************/
 
17
 
 
18
 
 
19
#ifndef __FTCALC_H__
 
20
#define __FTCALC_H__
 
21
 
 
22
 
 
23
#include <ft2build.h>
 
24
#include FT_FREETYPE_H
 
25
 
 
26
 
 
27
FT_BEGIN_HEADER
 
28
 
 
29
 
 
30
  /*************************************************************************/
 
31
  /*                                                                       */
 
32
  /* <Function>                                                            */
 
33
  /*    FT_FixedSqrt                                                       */
 
34
  /*                                                                       */
 
35
  /* <Description>                                                         */
 
36
  /*    Computes the square root of a 16.16 fixed point value.             */
 
37
  /*                                                                       */
 
38
  /* <Input>                                                               */
 
39
  /*    x :: The value to compute the root for.                            */
 
40
  /*                                                                       */
 
41
  /* <Return>                                                              */
 
42
  /*    The result of `sqrt(x)'.                                           */
 
43
  /*                                                                       */
 
44
  /* <Note>                                                                */
 
45
  /*    This function is not very fast.                                    */
 
46
  /*                                                                       */
 
47
  FT_BASE( FT_Int32 )
 
48
  FT_SqrtFixed( FT_Int32  x );
 
49
 
 
50
 
 
51
#ifdef FT_CONFIG_OPTION_OLD_INTERNALS
 
52
 
 
53
  /*************************************************************************/
 
54
  /*                                                                       */
 
55
  /* <Function>                                                            */
 
56
  /*    FT_Sqrt32                                                          */
 
57
  /*                                                                       */
 
58
  /* <Description>                                                         */
 
59
  /*    Computes the square root of an Int32 integer (which will be        */
 
60
  /*    handled as an unsigned long value).                                */
 
61
  /*                                                                       */
 
62
  /* <Input>                                                               */
 
63
  /*    x :: The value to compute the root for.                            */
 
64
  /*                                                                       */
 
65
  /* <Return>                                                              */
 
66
  /*    The result of `sqrt(x)'.                                           */
 
67
  /*                                                                       */
 
68
  FT_EXPORT( FT_Int32 )
 
69
  FT_Sqrt32( FT_Int32  x );
 
70
 
 
71
#endif /* FT_CONFIG_OPTION_OLD_INTERNALS */
 
72
 
 
73
 
 
74
  /*************************************************************************/
 
75
  /*                                                                       */
 
76
  /* FT_MulDiv() and FT_MulFix() are declared in freetype.h.               */
 
77
  /*                                                                       */
 
78
  /*************************************************************************/
 
79
 
 
80
 
 
81
#ifdef TT_USE_BYTECODE_INTERPRETER
 
82
 
 
83
  /*************************************************************************/
 
84
  /*                                                                       */
 
85
  /* <Function>                                                            */
 
86
  /*    FT_MulDiv_No_Round                                                 */
 
87
  /*                                                                       */
 
88
  /* <Description>                                                         */
 
89
  /*    A very simple function used to perform the computation `(a*b)/c'   */
 
90
  /*    (without rounding) with maximal accuracy (it uses a 64-bit         */
 
91
  /*    intermediate integer whenever necessary).                          */
 
92
  /*                                                                       */
 
93
  /*    This function isn't necessarily as fast as some processor specific */
 
94
  /*    operations, but is at least completely portable.                   */
 
95
  /*                                                                       */
 
96
  /* <Input>                                                               */
 
97
  /*    a :: The first multiplier.                                         */
 
98
  /*    b :: The second multiplier.                                        */
 
99
  /*    c :: The divisor.                                                  */
 
100
  /*                                                                       */
 
101
  /* <Return>                                                              */
 
102
  /*    The result of `(a*b)/c'.  This function never traps when trying to */
 
103
  /*    divide by zero; it simply returns `MaxInt' or `MinInt' depending   */
 
104
  /*    on the signs of `a' and `b'.                                       */
 
105
  /*                                                                       */
 
106
  FT_BASE( FT_Long )
 
107
  FT_MulDiv_No_Round( FT_Long  a,
 
108
                      FT_Long  b,
 
109
                      FT_Long  c );
 
110
 
 
111
#endif /* TT_USE_BYTECODE_INTERPRETER */
 
112
 
 
113
 
 
114
  /*
 
115
   *  A variant of FT_Matrix_Multiply which scales its result afterwards.
 
116
   *  The idea is that both `a' and `b' are scaled by factors of 10 so that
 
117
   *  the values are as precise as possible to get a correct result during
 
118
   *  the 64bit multiplication.  Let `sa' and `sb' be the scaling factors of
 
119
   *  `a' and `b', respectively, then the scaling factor of the result is
 
120
   *  `sa*sb'.
 
121
   */
 
122
  FT_BASE( void )
 
123
  FT_Matrix_Multiply_Scaled( const FT_Matrix*  a,
 
124
                             FT_Matrix        *b,
 
125
                             FT_Long           scaling );
 
126
 
 
127
 
 
128
  /*
 
129
   *  A variant of FT_Vector_Transform.  See comments for
 
130
   *  FT_Matrix_Multiply_Scaled.
 
131
   */
 
132
 
 
133
  FT_BASE( void )
 
134
  FT_Vector_Transform_Scaled( FT_Vector*        vector,
 
135
                              const FT_Matrix*  matrix,
 
136
                              FT_Long           scaling );
 
137
 
 
138
 
 
139
  /*
 
140
   *  Return -1, 0, or +1, depending on the orientation of a given corner.
 
141
   *  We use the Cartesian coordinate system, with positive vertical values
 
142
   *  going upwards.  The function returns +1 if the corner turns to the
 
143
   *  left, -1 to the right, and 0 for undecidable cases.
 
144
   */
 
145
  FT_BASE( FT_Int )
 
146
  ft_corner_orientation( FT_Pos  in_x,
 
147
                         FT_Pos  in_y,
 
148
                         FT_Pos  out_x,
 
149
                         FT_Pos  out_y );
 
150
 
 
151
  /*
 
152
   *  Return TRUE if a corner is flat or nearly flat.  This is equivalent to
 
153
   *  saying that the angle difference between the `in' and `out' vectors is
 
154
   *  very small.
 
155
   */
 
156
  FT_BASE( FT_Int )
 
157
  ft_corner_is_flat( FT_Pos  in_x,
 
158
                     FT_Pos  in_y,
 
159
                     FT_Pos  out_x,
 
160
                     FT_Pos  out_y );
 
161
 
 
162
 
 
163
#define INT_TO_F26DOT6( x )    ( (FT_Long)(x) << 6  )
 
164
#define INT_TO_F2DOT14( x )    ( (FT_Long)(x) << 14 )
 
165
#define INT_TO_FIXED( x )      ( (FT_Long)(x) << 16 )
 
166
#define F2DOT14_TO_FIXED( x )  ( (FT_Long)(x) << 2  )
 
167
#define FLOAT_TO_FIXED( x )    ( (FT_Long)( x * 65536.0 ) )
 
168
#define FIXED_TO_INT( x )      ( FT_RoundFix( x ) >> 16 )
 
169
 
 
170
#define ROUND_F26DOT6( x )     ( x >= 0 ? (    ( (x) + 32 ) & -64 )     \
 
171
                                        : ( -( ( 32 - (x) ) & -64 ) ) )
 
172
 
 
173
 
 
174
FT_END_HEADER
 
175
 
 
176
#endif /* __FTCALC_H__ */
 
177
 
 
178
 
 
179
/* END */