blob: fa91d1e1cbf2760def88c3bfdaa56039640bf9f4
1 | /* |
2 | * Copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> |
3 | * |
4 | * This file is part of FFmpeg. |
5 | * |
6 | * FFmpeg is free software; you can redistribute it and/or |
7 | * modify it under the terms of the GNU Lesser General Public |
8 | * License as published by the Free Software Foundation; either |
9 | * version 2.1 of the License, or (at your option) any later version. |
10 | * |
11 | * FFmpeg is distributed in the hope that it will be useful, |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
14 | * Lesser General Public License for more details. |
15 | * |
16 | * You should have received a copy of the GNU Lesser General Public |
17 | * License along with FFmpeg; if not, write to the Free Software |
18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
19 | */ |
20 | |
21 | #ifndef AVUTIL_SOFTFLOAT_H |
22 | #define AVUTIL_SOFTFLOAT_H |
23 | |
24 | #include <stdint.h> |
25 | #include "common.h" |
26 | |
27 | #include "avassert.h" |
28 | #include "softfloat_tables.h" |
29 | |
30 | #define MIN_EXP -149 |
31 | #define MAX_EXP 126 |
32 | #define ONE_BITS 29 |
33 | |
34 | typedef struct SoftFloat{ |
35 | int32_t mant; |
36 | int32_t exp; |
37 | }SoftFloat; |
38 | |
39 | static const SoftFloat FLOAT_0 = { 0, MIN_EXP}; ///< 0.0 |
40 | static const SoftFloat FLOAT_05 = { 0x20000000, 0}; ///< 0.5 |
41 | static const SoftFloat FLOAT_1 = { 0x20000000, 1}; ///< 1.0 |
42 | static const SoftFloat FLOAT_EPSILON = { 0x29F16B12, -16}; ///< A small value |
43 | static const SoftFloat FLOAT_1584893192 = { 0x32B771ED, 1}; ///< 1.584893192 (10^.2) |
44 | static const SoftFloat FLOAT_100000 = { 0x30D40000, 17}; ///< 100000 |
45 | static const SoftFloat FLOAT_0999999 = { 0x3FFFFBCE, 0}; ///< 0.999999 |
46 | |
47 | |
48 | /** |
49 | * Convert a SoftFloat to a double precision float. |
50 | */ |
51 | static inline av_const double av_sf2double(SoftFloat v) { |
52 | v.exp -= ONE_BITS +1; |
53 | if(v.exp > 0) return (double)v.mant * (double)(1 << v.exp); |
54 | else return (double)v.mant / (double)(1 << (-v.exp)); |
55 | } |
56 | |
57 | static av_const SoftFloat av_normalize_sf(SoftFloat a){ |
58 | if(a.mant){ |
59 | #if 1 |
60 | while((a.mant + 0x1FFFFFFFU)<0x3FFFFFFFU){ |
61 | a.mant += a.mant; |
62 | a.exp -= 1; |
63 | } |
64 | #else |
65 | int s=ONE_BITS - av_log2(FFABS(a.mant)); |
66 | a.exp -= s; |
67 | a.mant <<= s; |
68 | #endif |
69 | if(a.exp < MIN_EXP){ |
70 | a.exp = MIN_EXP; |
71 | a.mant= 0; |
72 | } |
73 | }else{ |
74 | a.exp= MIN_EXP; |
75 | } |
76 | return a; |
77 | } |
78 | |
79 | static inline av_const SoftFloat av_normalize1_sf(SoftFloat a){ |
80 | #if 1 |
81 | if((int32_t)(a.mant + 0x40000000U) <= 0){ |
82 | a.exp++; |
83 | a.mant>>=1; |
84 | } |
85 | av_assert2(a.mant < 0x40000000 && a.mant > -0x40000000); |
86 | av_assert2(a.exp <= MAX_EXP); |
87 | return a; |
88 | #elif 1 |
89 | int t= a.mant + 0x40000000 < 0; |
90 | return (SoftFloat){ a.mant>>t, a.exp+t}; |
91 | #else |
92 | int t= (a.mant + 0x3FFFFFFFU)>>31; |
93 | return (SoftFloat){a.mant>>t, a.exp+t}; |
94 | #endif |
95 | } |
96 | |
97 | /** |
98 | * @return Will not be more denormalized than a*b. So if either input is |
99 | * normalized, then the output will not be worse then the other input. |
100 | * If both are normalized, then the output will be normalized. |
101 | */ |
102 | static inline av_const SoftFloat av_mul_sf(SoftFloat a, SoftFloat b){ |
103 | a.exp += b.exp; |
104 | av_assert2((int32_t)((a.mant * (int64_t)b.mant) >> ONE_BITS) == (a.mant * (int64_t)b.mant) >> ONE_BITS); |
105 | a.mant = (a.mant * (int64_t)b.mant) >> ONE_BITS; |
106 | a = av_normalize1_sf((SoftFloat){a.mant, a.exp - 1}); |
107 | if (!a.mant || a.exp < MIN_EXP) |
108 | return FLOAT_0; |
109 | return a; |
110 | } |
111 | |
112 | /** |
113 | * b has to be normalized and not zero. |
114 | * @return Will not be more denormalized than a. |
115 | */ |
116 | static inline av_const SoftFloat av_div_sf(SoftFloat a, SoftFloat b){ |
117 | a.exp -= b.exp; |
118 | a.mant = ((int64_t)a.mant<<(ONE_BITS+1)) / b.mant; |
119 | a = av_normalize1_sf(a); |
120 | if (!a.mant || a.exp < MIN_EXP) |
121 | return FLOAT_0; |
122 | return a; |
123 | } |
124 | |
125 | /** |
126 | * Compares two SoftFloats. |
127 | * @returns < 0 if the first is less |
128 | * > 0 if the first is greater |
129 | * 0 if they are equal |
130 | */ |
131 | static inline av_const int av_cmp_sf(SoftFloat a, SoftFloat b){ |
132 | int t= a.exp - b.exp; |
133 | if (t <-31) return - b.mant ; |
134 | else if (t < 0) return (a.mant >> (-t)) - b.mant ; |
135 | else if (t < 32) return a.mant - (b.mant >> t); |
136 | else return a.mant ; |
137 | } |
138 | |
139 | /** |
140 | * Compares two SoftFloats. |
141 | * @returns 1 if a is greater than b, 0 otherwise |
142 | */ |
143 | static inline av_const int av_gt_sf(SoftFloat a, SoftFloat b) |
144 | { |
145 | int t= a.exp - b.exp; |
146 | if (t <-31) return 0 > b.mant ; |
147 | else if (t < 0) return (a.mant >> (-t)) > b.mant ; |
148 | else if (t < 32) return a.mant > (b.mant >> t); |
149 | else return a.mant > 0 ; |
150 | } |
151 | |
152 | /** |
153 | * @returns the sum of 2 SoftFloats. |
154 | */ |
155 | static inline av_const SoftFloat av_add_sf(SoftFloat a, SoftFloat b){ |
156 | int t= a.exp - b.exp; |
157 | if (t <-31) return b; |
158 | else if (t < 0) return av_normalize_sf(av_normalize1_sf((SoftFloat){ b.mant + (a.mant >> (-t)), b.exp})); |
159 | else if (t < 32) return av_normalize_sf(av_normalize1_sf((SoftFloat){ a.mant + (b.mant >> t ), a.exp})); |
160 | else return a; |
161 | } |
162 | |
163 | /** |
164 | * @returns the difference of 2 SoftFloats. |
165 | */ |
166 | static inline av_const SoftFloat av_sub_sf(SoftFloat a, SoftFloat b){ |
167 | return av_add_sf(a, (SoftFloat){ -b.mant, b.exp}); |
168 | } |
169 | |
170 | //FIXME log, exp, pow |
171 | |
172 | /** |
173 | * Converts a mantisse and exponent to a SoftFloat |
174 | * @returns a SoftFloat with value v * 2^frac_bits |
175 | */ |
176 | static inline av_const SoftFloat av_int2sf(int v, int frac_bits){ |
177 | int exp_offset = 0; |
178 | if(v <= INT_MIN + 1){ |
179 | exp_offset = 1; |
180 | v>>=1; |
181 | } |
182 | return av_normalize_sf(av_normalize1_sf((SoftFloat){v, ONE_BITS + 1 - frac_bits + exp_offset})); |
183 | } |
184 | |
185 | /** |
186 | * Converts a SoftFloat to an integer. |
187 | * Rounding is to -inf. |
188 | */ |
189 | static inline av_const int av_sf2int(SoftFloat v, int frac_bits){ |
190 | v.exp += frac_bits - (ONE_BITS + 1); |
191 | if(v.exp >= 0) return v.mant << v.exp ; |
192 | else return v.mant >>(-v.exp); |
193 | } |
194 | |
195 | /** |
196 | * Rounding-to-nearest used. |
197 | */ |
198 | static av_always_inline SoftFloat av_sqrt_sf(SoftFloat val) |
199 | { |
200 | int tabIndex, rem; |
201 | |
202 | if (val.mant == 0) |
203 | val.exp = MIN_EXP; |
204 | else if (val.mant < 0) |
205 | abort(); |
206 | else |
207 | { |
208 | tabIndex = (val.mant - 0x20000000) >> 20; |
209 | |
210 | rem = val.mant & 0xFFFFF; |
211 | val.mant = (int)(((int64_t)av_sqrttbl_sf[tabIndex] * (0x100000 - rem) + |
212 | (int64_t)av_sqrttbl_sf[tabIndex + 1] * rem + |
213 | 0x80000) >> 20); |
214 | val.mant = (int)(((int64_t)av_sqr_exp_multbl_sf[val.exp & 1] * val.mant + |
215 | 0x10000000) >> 29); |
216 | |
217 | if (val.mant < 0x40000000) |
218 | val.exp -= 2; |
219 | else |
220 | val.mant >>= 1; |
221 | |
222 | val.exp = (val.exp >> 1) + 1; |
223 | } |
224 | |
225 | return val; |
226 | } |
227 | |
228 | /** |
229 | * Rounding-to-nearest used. |
230 | */ |
231 | static av_unused void av_sincos_sf(int a, int *s, int *c) |
232 | { |
233 | int idx, sign; |
234 | int sv, cv; |
235 | int st, ct; |
236 | |
237 | idx = a >> 26; |
238 | sign = (idx << 27) >> 31; |
239 | cv = av_costbl_1_sf[idx & 0xf]; |
240 | cv = (cv ^ sign) - sign; |
241 | |
242 | idx -= 8; |
243 | sign = (idx << 27) >> 31; |
244 | sv = av_costbl_1_sf[idx & 0xf]; |
245 | sv = (sv ^ sign) - sign; |
246 | |
247 | idx = a >> 21; |
248 | ct = av_costbl_2_sf[idx & 0x1f]; |
249 | st = av_sintbl_2_sf[idx & 0x1f]; |
250 | |
251 | idx = (int)(((int64_t)cv * ct - (int64_t)sv * st + 0x20000000) >> 30); |
252 | |
253 | sv = (int)(((int64_t)cv * st + (int64_t)sv * ct + 0x20000000) >> 30); |
254 | |
255 | cv = idx; |
256 | |
257 | idx = a >> 16; |
258 | ct = av_costbl_3_sf[idx & 0x1f]; |
259 | st = av_sintbl_3_sf[idx & 0x1f]; |
260 | |
261 | idx = (int)(((int64_t)cv * ct - (int64_t)sv * st + 0x20000000) >> 30); |
262 | |
263 | sv = (int)(((int64_t)cv * st + (int64_t)sv * ct + 0x20000000) >> 30); |
264 | cv = idx; |
265 | |
266 | idx = a >> 11; |
267 | |
268 | ct = (int)(((int64_t)av_costbl_4_sf[idx & 0x1f] * (0x800 - (a & 0x7ff)) + |
269 | (int64_t)av_costbl_4_sf[(idx & 0x1f)+1]*(a & 0x7ff) + |
270 | 0x400) >> 11); |
271 | st = (int)(((int64_t)av_sintbl_4_sf[idx & 0x1f] * (0x800 - (a & 0x7ff)) + |
272 | (int64_t)av_sintbl_4_sf[(idx & 0x1f) + 1] * (a & 0x7ff) + |
273 | 0x400) >> 11); |
274 | |
275 | *c = (int)(((int64_t)cv * ct + (int64_t)sv * st + 0x20000000) >> 30); |
276 | |
277 | *s = (int)(((int64_t)cv * st + (int64_t)sv * ct + 0x20000000) >> 30); |
278 | } |
279 | |
280 | #endif /* AVUTIL_SOFTFLOAT_H */ |
281 |