diff options
Diffstat (limited to 'lib/rbcodec/codecs/libopus/celt/fixed_debug.h')
-rw-r--r-- | lib/rbcodec/codecs/libopus/celt/fixed_debug.h | 791 |
1 files changed, 791 insertions, 0 deletions
diff --git a/lib/rbcodec/codecs/libopus/celt/fixed_debug.h b/lib/rbcodec/codecs/libopus/celt/fixed_debug.h new file mode 100644 index 0000000000..f435295234 --- /dev/null +++ b/lib/rbcodec/codecs/libopus/celt/fixed_debug.h | |||
@@ -0,0 +1,791 @@ | |||
1 | /* Copyright (C) 2003-2008 Jean-Marc Valin | ||
2 | Copyright (C) 2007-2012 Xiph.Org Foundation */ | ||
3 | /** | ||
4 | @file fixed_debug.h | ||
5 | @brief Fixed-point operations with debugging | ||
6 | */ | ||
7 | /* | ||
8 | Redistribution and use in source and binary forms, with or without | ||
9 | modification, are permitted provided that the following conditions | ||
10 | are met: | ||
11 | |||
12 | - Redistributions of source code must retain the above copyright | ||
13 | notice, this list of conditions and the following disclaimer. | ||
14 | |||
15 | - Redistributions in binary form must reproduce the above copyright | ||
16 | notice, this list of conditions and the following disclaimer in the | ||
17 | documentation and/or other materials provided with the distribution. | ||
18 | |||
19 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
20 | ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
21 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
22 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER | ||
23 | OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
24 | EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
25 | PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | ||
26 | PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | ||
27 | LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | ||
28 | NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
29 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
30 | */ | ||
31 | |||
32 | #ifndef FIXED_DEBUG_H | ||
33 | #define FIXED_DEBUG_H | ||
34 | |||
35 | #include <stdio.h> | ||
36 | #include "opus_defines.h" | ||
37 | |||
38 | #ifdef CELT_C | ||
39 | OPUS_EXPORT opus_int64 celt_mips=0; | ||
40 | #else | ||
41 | extern opus_int64 celt_mips; | ||
42 | #endif | ||
43 | |||
44 | #define MULT16_16SU(a,b) ((opus_val32)(opus_val16)(a)*(opus_val32)(opus_uint16)(b)) | ||
45 | #define MULT32_32_Q31(a,b) ADD32(ADD32(SHL32(MULT16_16(SHR32((a),16),SHR((b),16)),1), SHR32(MULT16_16SU(SHR32((a),16),((b)&0x0000ffff)),15)), SHR32(MULT16_16SU(SHR32((b),16),((a)&0x0000ffff)),15)) | ||
46 | |||
47 | /** 16x32 multiplication, followed by a 16-bit shift right. Results fits in 32 bits */ | ||
48 | #define MULT16_32_Q16(a,b) ADD32(MULT16_16((a),SHR32((b),16)), SHR32(MULT16_16SU((a),((b)&0x0000ffff)),16)) | ||
49 | |||
50 | #define MULT16_32_P16(a,b) MULT16_32_PX(a,b,16) | ||
51 | |||
52 | #define QCONST16(x,bits) ((opus_val16)(.5+(x)*(((opus_val32)1)<<(bits)))) | ||
53 | #define QCONST32(x,bits) ((opus_val32)(.5+(x)*(((opus_val32)1)<<(bits)))) | ||
54 | |||
55 | #define VERIFY_SHORT(x) ((x)<=32767&&(x)>=-32768) | ||
56 | #define VERIFY_INT(x) ((x)<=2147483647LL&&(x)>=-2147483648LL) | ||
57 | #define VERIFY_UINT(x) ((x)<=(2147483647LLU<<1)) | ||
58 | |||
59 | #define SHR(a,b) SHR32(a,b) | ||
60 | #define PSHR(a,b) PSHR32(a,b) | ||
61 | |||
62 | /** Add two 32-bit values, ignore any overflows */ | ||
63 | #define ADD32_ovflw(a,b) (celt_mips+=2,(opus_val32)((opus_uint32)(a)+(opus_uint32)(b))) | ||
64 | /** Subtract two 32-bit values, ignore any overflows */ | ||
65 | #define SUB32_ovflw(a,b) (celt_mips+=2,(opus_val32)((opus_uint32)(a)-(opus_uint32)(b))) | ||
66 | /* Avoid MSVC warning C4146: unary minus operator applied to unsigned type */ | ||
67 | /** Negate 32-bit value, ignore any overflows */ | ||
68 | #define NEG32_ovflw(a) (celt_mips+=2,(opus_val32)(0-(opus_uint32)(a))) | ||
69 | |||
70 | static OPUS_INLINE short NEG16(int x) | ||
71 | { | ||
72 | int res; | ||
73 | if (!VERIFY_SHORT(x)) | ||
74 | { | ||
75 | fprintf (stderr, "NEG16: input is not short: %d\n", (int)x); | ||
76 | #ifdef FIXED_DEBUG_ASSERT | ||
77 | celt_assert(0); | ||
78 | #endif | ||
79 | } | ||
80 | res = -x; | ||
81 | if (!VERIFY_SHORT(res)) | ||
82 | { | ||
83 | fprintf (stderr, "NEG16: output is not short: %d\n", (int)res); | ||
84 | #ifdef FIXED_DEBUG_ASSERT | ||
85 | celt_assert(0); | ||
86 | #endif | ||
87 | } | ||
88 | celt_mips++; | ||
89 | return res; | ||
90 | } | ||
91 | static OPUS_INLINE int NEG32(opus_int64 x) | ||
92 | { | ||
93 | opus_int64 res; | ||
94 | if (!VERIFY_INT(x)) | ||
95 | { | ||
96 | fprintf (stderr, "NEG16: input is not int: %d\n", (int)x); | ||
97 | #ifdef FIXED_DEBUG_ASSERT | ||
98 | celt_assert(0); | ||
99 | #endif | ||
100 | } | ||
101 | res = -x; | ||
102 | if (!VERIFY_INT(res)) | ||
103 | { | ||
104 | fprintf (stderr, "NEG16: output is not int: %d\n", (int)res); | ||
105 | #ifdef FIXED_DEBUG_ASSERT | ||
106 | celt_assert(0); | ||
107 | #endif | ||
108 | } | ||
109 | celt_mips+=2; | ||
110 | return res; | ||
111 | } | ||
112 | |||
113 | #define EXTRACT16(x) EXTRACT16_(x, __FILE__, __LINE__) | ||
114 | static OPUS_INLINE short EXTRACT16_(int x, char *file, int line) | ||
115 | { | ||
116 | int res; | ||
117 | if (!VERIFY_SHORT(x)) | ||
118 | { | ||
119 | fprintf (stderr, "EXTRACT16: input is not short: %d in %s: line %d\n", x, file, line); | ||
120 | #ifdef FIXED_DEBUG_ASSERT | ||
121 | celt_assert(0); | ||
122 | #endif | ||
123 | } | ||
124 | res = x; | ||
125 | celt_mips++; | ||
126 | return res; | ||
127 | } | ||
128 | |||
129 | #define EXTEND32(x) EXTEND32_(x, __FILE__, __LINE__) | ||
130 | static OPUS_INLINE int EXTEND32_(int x, char *file, int line) | ||
131 | { | ||
132 | int res; | ||
133 | if (!VERIFY_SHORT(x)) | ||
134 | { | ||
135 | fprintf (stderr, "EXTEND32: input is not short: %d in %s: line %d\n", x, file, line); | ||
136 | #ifdef FIXED_DEBUG_ASSERT | ||
137 | celt_assert(0); | ||
138 | #endif | ||
139 | } | ||
140 | res = x; | ||
141 | celt_mips++; | ||
142 | return res; | ||
143 | } | ||
144 | |||
145 | #define SHR16(a, shift) SHR16_(a, shift, __FILE__, __LINE__) | ||
146 | static OPUS_INLINE short SHR16_(int a, int shift, char *file, int line) | ||
147 | { | ||
148 | int res; | ||
149 | if (!VERIFY_SHORT(a) || !VERIFY_SHORT(shift)) | ||
150 | { | ||
151 | fprintf (stderr, "SHR16: inputs are not short: %d >> %d in %s: line %d\n", a, shift, file, line); | ||
152 | #ifdef FIXED_DEBUG_ASSERT | ||
153 | celt_assert(0); | ||
154 | #endif | ||
155 | } | ||
156 | res = a>>shift; | ||
157 | if (!VERIFY_SHORT(res)) | ||
158 | { | ||
159 | fprintf (stderr, "SHR16: output is not short: %d in %s: line %d\n", res, file, line); | ||
160 | #ifdef FIXED_DEBUG_ASSERT | ||
161 | celt_assert(0); | ||
162 | #endif | ||
163 | } | ||
164 | celt_mips++; | ||
165 | return res; | ||
166 | } | ||
167 | #define SHL16(a, shift) SHL16_(a, shift, __FILE__, __LINE__) | ||
168 | static OPUS_INLINE short SHL16_(int a, int shift, char *file, int line) | ||
169 | { | ||
170 | int res; | ||
171 | if (!VERIFY_SHORT(a) || !VERIFY_SHORT(shift)) | ||
172 | { | ||
173 | fprintf (stderr, "SHL16: inputs are not short: %d %d in %s: line %d\n", a, shift, file, line); | ||
174 | #ifdef FIXED_DEBUG_ASSERT | ||
175 | celt_assert(0); | ||
176 | #endif | ||
177 | } | ||
178 | res = a<<shift; | ||
179 | if (!VERIFY_SHORT(res)) | ||
180 | { | ||
181 | fprintf (stderr, "SHL16: output is not short: %d in %s: line %d\n", res, file, line); | ||
182 | #ifdef FIXED_DEBUG_ASSERT | ||
183 | celt_assert(0); | ||
184 | #endif | ||
185 | } | ||
186 | celt_mips++; | ||
187 | return res; | ||
188 | } | ||
189 | |||
190 | static OPUS_INLINE int SHR32(opus_int64 a, int shift) | ||
191 | { | ||
192 | opus_int64 res; | ||
193 | if (!VERIFY_INT(a) || !VERIFY_SHORT(shift)) | ||
194 | { | ||
195 | fprintf (stderr, "SHR32: inputs are not int: %d %d\n", (int)a, shift); | ||
196 | #ifdef FIXED_DEBUG_ASSERT | ||
197 | celt_assert(0); | ||
198 | #endif | ||
199 | } | ||
200 | res = a>>shift; | ||
201 | if (!VERIFY_INT(res)) | ||
202 | { | ||
203 | fprintf (stderr, "SHR32: output is not int: %d\n", (int)res); | ||
204 | #ifdef FIXED_DEBUG_ASSERT | ||
205 | celt_assert(0); | ||
206 | #endif | ||
207 | } | ||
208 | celt_mips+=2; | ||
209 | return res; | ||
210 | } | ||
211 | #define SHL32(a, shift) SHL32_(a, shift, __FILE__, __LINE__) | ||
212 | static OPUS_INLINE int SHL32_(opus_int64 a, int shift, char *file, int line) | ||
213 | { | ||
214 | opus_int64 res; | ||
215 | if (!VERIFY_INT(a) || !VERIFY_SHORT(shift)) | ||
216 | { | ||
217 | fprintf (stderr, "SHL32: inputs are not int: %lld %d in %s: line %d\n", a, shift, file, line); | ||
218 | #ifdef FIXED_DEBUG_ASSERT | ||
219 | celt_assert(0); | ||
220 | #endif | ||
221 | } | ||
222 | res = a<<shift; | ||
223 | if (!VERIFY_INT(res)) | ||
224 | { | ||
225 | fprintf (stderr, "SHL32: output is not int: %lld<<%d = %lld in %s: line %d\n", a, shift, res, file, line); | ||
226 | #ifdef FIXED_DEBUG_ASSERT | ||
227 | celt_assert(0); | ||
228 | #endif | ||
229 | } | ||
230 | celt_mips+=2; | ||
231 | return res; | ||
232 | } | ||
233 | |||
234 | #define PSHR32(a,shift) (celt_mips--,SHR32(ADD32((a),(((opus_val32)(1)<<((shift))>>1))),shift)) | ||
235 | #define VSHR32(a, shift) (((shift)>0) ? SHR32(a, shift) : SHL32(a, -(shift))) | ||
236 | |||
237 | #define ROUND16(x,a) (celt_mips--,EXTRACT16(PSHR32((x),(a)))) | ||
238 | #define SROUND16(x,a) (celt_mips--,EXTRACT16(SATURATE(PSHR32(x,a), 32767))); | ||
239 | |||
240 | #define HALF16(x) (SHR16(x,1)) | ||
241 | #define HALF32(x) (SHR32(x,1)) | ||
242 | |||
243 | #define ADD16(a, b) ADD16_(a, b, __FILE__, __LINE__) | ||
244 | static OPUS_INLINE short ADD16_(int a, int b, char *file, int line) | ||
245 | { | ||
246 | int res; | ||
247 | if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b)) | ||
248 | { | ||
249 | fprintf (stderr, "ADD16: inputs are not short: %d %d in %s: line %d\n", a, b, file, line); | ||
250 | #ifdef FIXED_DEBUG_ASSERT | ||
251 | celt_assert(0); | ||
252 | #endif | ||
253 | } | ||
254 | res = a+b; | ||
255 | if (!VERIFY_SHORT(res)) | ||
256 | { | ||
257 | fprintf (stderr, "ADD16: output is not short: %d+%d=%d in %s: line %d\n", a,b,res, file, line); | ||
258 | #ifdef FIXED_DEBUG_ASSERT | ||
259 | celt_assert(0); | ||
260 | #endif | ||
261 | } | ||
262 | celt_mips++; | ||
263 | return res; | ||
264 | } | ||
265 | |||
266 | #define SUB16(a, b) SUB16_(a, b, __FILE__, __LINE__) | ||
267 | static OPUS_INLINE short SUB16_(int a, int b, char *file, int line) | ||
268 | { | ||
269 | int res; | ||
270 | if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b)) | ||
271 | { | ||
272 | fprintf (stderr, "SUB16: inputs are not short: %d %d in %s: line %d\n", a, b, file, line); | ||
273 | #ifdef FIXED_DEBUG_ASSERT | ||
274 | celt_assert(0); | ||
275 | #endif | ||
276 | } | ||
277 | res = a-b; | ||
278 | if (!VERIFY_SHORT(res)) | ||
279 | { | ||
280 | fprintf (stderr, "SUB16: output is not short: %d in %s: line %d\n", res, file, line); | ||
281 | #ifdef FIXED_DEBUG_ASSERT | ||
282 | celt_assert(0); | ||
283 | #endif | ||
284 | } | ||
285 | celt_mips++; | ||
286 | return res; | ||
287 | } | ||
288 | |||
289 | #define ADD32(a, b) ADD32_(a, b, __FILE__, __LINE__) | ||
290 | static OPUS_INLINE int ADD32_(opus_int64 a, opus_int64 b, char *file, int line) | ||
291 | { | ||
292 | opus_int64 res; | ||
293 | if (!VERIFY_INT(a) || !VERIFY_INT(b)) | ||
294 | { | ||
295 | fprintf (stderr, "ADD32: inputs are not int: %d %d in %s: line %d\n", (int)a, (int)b, file, line); | ||
296 | #ifdef FIXED_DEBUG_ASSERT | ||
297 | celt_assert(0); | ||
298 | #endif | ||
299 | } | ||
300 | res = a+b; | ||
301 | if (!VERIFY_INT(res)) | ||
302 | { | ||
303 | fprintf (stderr, "ADD32: output is not int: %d in %s: line %d\n", (int)res, file, line); | ||
304 | #ifdef FIXED_DEBUG_ASSERT | ||
305 | celt_assert(0); | ||
306 | #endif | ||
307 | } | ||
308 | celt_mips+=2; | ||
309 | return res; | ||
310 | } | ||
311 | |||
312 | #define SUB32(a, b) SUB32_(a, b, __FILE__, __LINE__) | ||
313 | static OPUS_INLINE int SUB32_(opus_int64 a, opus_int64 b, char *file, int line) | ||
314 | { | ||
315 | opus_int64 res; | ||
316 | if (!VERIFY_INT(a) || !VERIFY_INT(b)) | ||
317 | { | ||
318 | fprintf (stderr, "SUB32: inputs are not int: %d %d in %s: line %d\n", (int)a, (int)b, file, line); | ||
319 | #ifdef FIXED_DEBUG_ASSERT | ||
320 | celt_assert(0); | ||
321 | #endif | ||
322 | } | ||
323 | res = a-b; | ||
324 | if (!VERIFY_INT(res)) | ||
325 | { | ||
326 | fprintf (stderr, "SUB32: output is not int: %d in %s: line %d\n", (int)res, file, line); | ||
327 | #ifdef FIXED_DEBUG_ASSERT | ||
328 | celt_assert(0); | ||
329 | #endif | ||
330 | } | ||
331 | celt_mips+=2; | ||
332 | return res; | ||
333 | } | ||
334 | |||
335 | #undef UADD32 | ||
336 | #define UADD32(a, b) UADD32_(a, b, __FILE__, __LINE__) | ||
337 | static OPUS_INLINE unsigned int UADD32_(opus_uint64 a, opus_uint64 b, char *file, int line) | ||
338 | { | ||
339 | opus_uint64 res; | ||
340 | if (!VERIFY_UINT(a) || !VERIFY_UINT(b)) | ||
341 | { | ||
342 | fprintf (stderr, "UADD32: inputs are not uint32: %llu %llu in %s: line %d\n", a, b, file, line); | ||
343 | #ifdef FIXED_DEBUG_ASSERT | ||
344 | celt_assert(0); | ||
345 | #endif | ||
346 | } | ||
347 | res = a+b; | ||
348 | if (!VERIFY_UINT(res)) | ||
349 | { | ||
350 | fprintf (stderr, "UADD32: output is not uint32: %llu in %s: line %d\n", res, file, line); | ||
351 | #ifdef FIXED_DEBUG_ASSERT | ||
352 | celt_assert(0); | ||
353 | #endif | ||
354 | } | ||
355 | celt_mips+=2; | ||
356 | return res; | ||
357 | } | ||
358 | |||
359 | #undef USUB32 | ||
360 | #define USUB32(a, b) USUB32_(a, b, __FILE__, __LINE__) | ||
361 | static OPUS_INLINE unsigned int USUB32_(opus_uint64 a, opus_uint64 b, char *file, int line) | ||
362 | { | ||
363 | opus_uint64 res; | ||
364 | if (!VERIFY_UINT(a) || !VERIFY_UINT(b)) | ||
365 | { | ||
366 | fprintf (stderr, "USUB32: inputs are not uint32: %llu %llu in %s: line %d\n", a, b, file, line); | ||
367 | #ifdef FIXED_DEBUG_ASSERT | ||
368 | celt_assert(0); | ||
369 | #endif | ||
370 | } | ||
371 | if (a<b) | ||
372 | { | ||
373 | fprintf (stderr, "USUB32: inputs underflow: %llu < %llu in %s: line %d\n", a, b, file, line); | ||
374 | #ifdef FIXED_DEBUG_ASSERT | ||
375 | celt_assert(0); | ||
376 | #endif | ||
377 | } | ||
378 | res = a-b; | ||
379 | if (!VERIFY_UINT(res)) | ||
380 | { | ||
381 | fprintf (stderr, "USUB32: output is not uint32: %llu - %llu = %llu in %s: line %d\n", a, b, res, file, line); | ||
382 | #ifdef FIXED_DEBUG_ASSERT | ||
383 | celt_assert(0); | ||
384 | #endif | ||
385 | } | ||
386 | celt_mips+=2; | ||
387 | return res; | ||
388 | } | ||
389 | |||
390 | /* result fits in 16 bits */ | ||
391 | static OPUS_INLINE short MULT16_16_16(int a, int b) | ||
392 | { | ||
393 | int res; | ||
394 | if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b)) | ||
395 | { | ||
396 | fprintf (stderr, "MULT16_16_16: inputs are not short: %d %d\n", a, b); | ||
397 | #ifdef FIXED_DEBUG_ASSERT | ||
398 | celt_assert(0); | ||
399 | #endif | ||
400 | } | ||
401 | res = a*b; | ||
402 | if (!VERIFY_SHORT(res)) | ||
403 | { | ||
404 | fprintf (stderr, "MULT16_16_16: output is not short: %d\n", res); | ||
405 | #ifdef FIXED_DEBUG_ASSERT | ||
406 | celt_assert(0); | ||
407 | #endif | ||
408 | } | ||
409 | celt_mips++; | ||
410 | return res; | ||
411 | } | ||
412 | |||
413 | #define MULT16_16(a, b) MULT16_16_(a, b, __FILE__, __LINE__) | ||
414 | static OPUS_INLINE int MULT16_16_(int a, int b, char *file, int line) | ||
415 | { | ||
416 | opus_int64 res; | ||
417 | if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b)) | ||
418 | { | ||
419 | fprintf (stderr, "MULT16_16: inputs are not short: %d %d in %s: line %d\n", a, b, file, line); | ||
420 | #ifdef FIXED_DEBUG_ASSERT | ||
421 | celt_assert(0); | ||
422 | #endif | ||
423 | } | ||
424 | res = ((opus_int64)a)*b; | ||
425 | if (!VERIFY_INT(res)) | ||
426 | { | ||
427 | fprintf (stderr, "MULT16_16: output is not int: %d in %s: line %d\n", (int)res, file, line); | ||
428 | #ifdef FIXED_DEBUG_ASSERT | ||
429 | celt_assert(0); | ||
430 | #endif | ||
431 | } | ||
432 | celt_mips++; | ||
433 | return res; | ||
434 | } | ||
435 | |||
436 | #define MAC16_16(c,a,b) (celt_mips-=2,ADD32((c),MULT16_16((a),(b)))) | ||
437 | |||
438 | #define MULT16_32_QX(a, b, Q) MULT16_32_QX_(a, b, Q, __FILE__, __LINE__) | ||
439 | static OPUS_INLINE int MULT16_32_QX_(int a, opus_int64 b, int Q, char *file, int line) | ||
440 | { | ||
441 | opus_int64 res; | ||
442 | if (!VERIFY_SHORT(a) || !VERIFY_INT(b)) | ||
443 | { | ||
444 | fprintf (stderr, "MULT16_32_Q%d: inputs are not short+int: %d %d in %s: line %d\n", Q, (int)a, (int)b, file, line); | ||
445 | #ifdef FIXED_DEBUG_ASSERT | ||
446 | celt_assert(0); | ||
447 | #endif | ||
448 | } | ||
449 | if (ABS32(b)>=((opus_val32)(1)<<(15+Q))) | ||
450 | { | ||
451 | fprintf (stderr, "MULT16_32_Q%d: second operand too large: %d %d in %s: line %d\n", Q, (int)a, (int)b, file, line); | ||
452 | #ifdef FIXED_DEBUG_ASSERT | ||
453 | celt_assert(0); | ||
454 | #endif | ||
455 | } | ||
456 | res = (((opus_int64)a)*(opus_int64)b) >> Q; | ||
457 | if (!VERIFY_INT(res)) | ||
458 | { | ||
459 | fprintf (stderr, "MULT16_32_Q%d: output is not int: %d*%d=%d in %s: line %d\n", Q, (int)a, (int)b,(int)res, file, line); | ||
460 | #ifdef FIXED_DEBUG_ASSERT | ||
461 | celt_assert(0); | ||
462 | #endif | ||
463 | } | ||
464 | if (Q==15) | ||
465 | celt_mips+=3; | ||
466 | else | ||
467 | celt_mips+=4; | ||
468 | return res; | ||
469 | } | ||
470 | |||
471 | #define MULT16_32_PX(a, b, Q) MULT16_32_PX_(a, b, Q, __FILE__, __LINE__) | ||
472 | static OPUS_INLINE int MULT16_32_PX_(int a, opus_int64 b, int Q, char *file, int line) | ||
473 | { | ||
474 | opus_int64 res; | ||
475 | if (!VERIFY_SHORT(a) || !VERIFY_INT(b)) | ||
476 | { | ||
477 | fprintf (stderr, "MULT16_32_P%d: inputs are not short+int: %d %d in %s: line %d\n\n", Q, (int)a, (int)b, file, line); | ||
478 | #ifdef FIXED_DEBUG_ASSERT | ||
479 | celt_assert(0); | ||
480 | #endif | ||
481 | } | ||
482 | if (ABS32(b)>=((opus_int64)(1)<<(15+Q))) | ||
483 | { | ||
484 | fprintf (stderr, "MULT16_32_Q%d: second operand too large: %d %d in %s: line %d\n\n", Q, (int)a, (int)b,file, line); | ||
485 | #ifdef FIXED_DEBUG_ASSERT | ||
486 | celt_assert(0); | ||
487 | #endif | ||
488 | } | ||
489 | res = ((((opus_int64)a)*(opus_int64)b) + (((opus_val32)(1)<<Q)>>1))>> Q; | ||
490 | if (!VERIFY_INT(res)) | ||
491 | { | ||
492 | fprintf (stderr, "MULT16_32_P%d: output is not int: %d*%d=%d in %s: line %d\n\n", Q, (int)a, (int)b,(int)res, file, line); | ||
493 | #ifdef FIXED_DEBUG_ASSERT | ||
494 | celt_assert(0); | ||
495 | #endif | ||
496 | } | ||
497 | if (Q==15) | ||
498 | celt_mips+=4; | ||
499 | else | ||
500 | celt_mips+=5; | ||
501 | return res; | ||
502 | } | ||
503 | |||
504 | #define MULT16_32_Q15(a,b) MULT16_32_QX(a,b,15) | ||
505 | #define MAC16_32_Q15(c,a,b) (celt_mips-=2,ADD32((c),MULT16_32_Q15((a),(b)))) | ||
506 | #define MAC16_32_Q16(c,a,b) (celt_mips-=2,ADD32((c),MULT16_32_Q16((a),(b)))) | ||
507 | |||
508 | static OPUS_INLINE int SATURATE(int a, int b) | ||
509 | { | ||
510 | if (a>b) | ||
511 | a=b; | ||
512 | if (a<-b) | ||
513 | a = -b; | ||
514 | celt_mips+=3; | ||
515 | return a; | ||
516 | } | ||
517 | |||
518 | static OPUS_INLINE opus_int16 SATURATE16(opus_int32 a) | ||
519 | { | ||
520 | celt_mips+=3; | ||
521 | if (a>32767) | ||
522 | return 32767; | ||
523 | else if (a<-32768) | ||
524 | return -32768; | ||
525 | else return a; | ||
526 | } | ||
527 | |||
528 | static OPUS_INLINE int MULT16_16_Q11_32(int a, int b) | ||
529 | { | ||
530 | opus_int64 res; | ||
531 | if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b)) | ||
532 | { | ||
533 | fprintf (stderr, "MULT16_16_Q11: inputs are not short: %d %d\n", a, b); | ||
534 | #ifdef FIXED_DEBUG_ASSERT | ||
535 | celt_assert(0); | ||
536 | #endif | ||
537 | } | ||
538 | res = ((opus_int64)a)*b; | ||
539 | res >>= 11; | ||
540 | if (!VERIFY_INT(res)) | ||
541 | { | ||
542 | fprintf (stderr, "MULT16_16_Q11: output is not short: %d*%d=%d\n", (int)a, (int)b, (int)res); | ||
543 | #ifdef FIXED_DEBUG_ASSERT | ||
544 | celt_assert(0); | ||
545 | #endif | ||
546 | } | ||
547 | celt_mips+=3; | ||
548 | return res; | ||
549 | } | ||
550 | static OPUS_INLINE short MULT16_16_Q13(int a, int b) | ||
551 | { | ||
552 | opus_int64 res; | ||
553 | if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b)) | ||
554 | { | ||
555 | fprintf (stderr, "MULT16_16_Q13: inputs are not short: %d %d\n", a, b); | ||
556 | #ifdef FIXED_DEBUG_ASSERT | ||
557 | celt_assert(0); | ||
558 | #endif | ||
559 | } | ||
560 | res = ((opus_int64)a)*b; | ||
561 | res >>= 13; | ||
562 | if (!VERIFY_SHORT(res)) | ||
563 | { | ||
564 | fprintf (stderr, "MULT16_16_Q13: output is not short: %d*%d=%d\n", a, b, (int)res); | ||
565 | #ifdef FIXED_DEBUG_ASSERT | ||
566 | celt_assert(0); | ||
567 | #endif | ||
568 | } | ||
569 | celt_mips+=3; | ||
570 | return res; | ||
571 | } | ||
572 | static OPUS_INLINE short MULT16_16_Q14(int a, int b) | ||
573 | { | ||
574 | opus_int64 res; | ||
575 | if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b)) | ||
576 | { | ||
577 | fprintf (stderr, "MULT16_16_Q14: inputs are not short: %d %d\n", a, b); | ||
578 | #ifdef FIXED_DEBUG_ASSERT | ||
579 | celt_assert(0); | ||
580 | #endif | ||
581 | } | ||
582 | res = ((opus_int64)a)*b; | ||
583 | res >>= 14; | ||
584 | if (!VERIFY_SHORT(res)) | ||
585 | { | ||
586 | fprintf (stderr, "MULT16_16_Q14: output is not short: %d\n", (int)res); | ||
587 | #ifdef FIXED_DEBUG_ASSERT | ||
588 | celt_assert(0); | ||
589 | #endif | ||
590 | } | ||
591 | celt_mips+=3; | ||
592 | return res; | ||
593 | } | ||
594 | |||
595 | #define MULT16_16_Q15(a, b) MULT16_16_Q15_(a, b, __FILE__, __LINE__) | ||
596 | static OPUS_INLINE short MULT16_16_Q15_(int a, int b, char *file, int line) | ||
597 | { | ||
598 | opus_int64 res; | ||
599 | if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b)) | ||
600 | { | ||
601 | fprintf (stderr, "MULT16_16_Q15: inputs are not short: %d %d in %s: line %d\n", a, b, file, line); | ||
602 | #ifdef FIXED_DEBUG_ASSERT | ||
603 | celt_assert(0); | ||
604 | #endif | ||
605 | } | ||
606 | res = ((opus_int64)a)*b; | ||
607 | res >>= 15; | ||
608 | if (!VERIFY_SHORT(res)) | ||
609 | { | ||
610 | fprintf (stderr, "MULT16_16_Q15: output is not short: %d in %s: line %d\n", (int)res, file, line); | ||
611 | #ifdef FIXED_DEBUG_ASSERT | ||
612 | celt_assert(0); | ||
613 | #endif | ||
614 | } | ||
615 | celt_mips+=1; | ||
616 | return res; | ||
617 | } | ||
618 | |||
619 | static OPUS_INLINE short MULT16_16_P13(int a, int b) | ||
620 | { | ||
621 | opus_int64 res; | ||
622 | if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b)) | ||
623 | { | ||
624 | fprintf (stderr, "MULT16_16_P13: inputs are not short: %d %d\n", a, b); | ||
625 | #ifdef FIXED_DEBUG_ASSERT | ||
626 | celt_assert(0); | ||
627 | #endif | ||
628 | } | ||
629 | res = ((opus_int64)a)*b; | ||
630 | res += 4096; | ||
631 | if (!VERIFY_INT(res)) | ||
632 | { | ||
633 | fprintf (stderr, "MULT16_16_P13: overflow: %d*%d=%d\n", a, b, (int)res); | ||
634 | #ifdef FIXED_DEBUG_ASSERT | ||
635 | celt_assert(0); | ||
636 | #endif | ||
637 | } | ||
638 | res >>= 13; | ||
639 | if (!VERIFY_SHORT(res)) | ||
640 | { | ||
641 | fprintf (stderr, "MULT16_16_P13: output is not short: %d*%d=%d\n", a, b, (int)res); | ||
642 | #ifdef FIXED_DEBUG_ASSERT | ||
643 | celt_assert(0); | ||
644 | #endif | ||
645 | } | ||
646 | celt_mips+=4; | ||
647 | return res; | ||
648 | } | ||
649 | static OPUS_INLINE short MULT16_16_P14(int a, int b) | ||
650 | { | ||
651 | opus_int64 res; | ||
652 | if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b)) | ||
653 | { | ||
654 | fprintf (stderr, "MULT16_16_P14: inputs are not short: %d %d\n", a, b); | ||
655 | #ifdef FIXED_DEBUG_ASSERT | ||
656 | celt_assert(0); | ||
657 | #endif | ||
658 | } | ||
659 | res = ((opus_int64)a)*b; | ||
660 | res += 8192; | ||
661 | if (!VERIFY_INT(res)) | ||
662 | { | ||
663 | fprintf (stderr, "MULT16_16_P14: overflow: %d*%d=%d\n", a, b, (int)res); | ||
664 | #ifdef FIXED_DEBUG_ASSERT | ||
665 | celt_assert(0); | ||
666 | #endif | ||
667 | } | ||
668 | res >>= 14; | ||
669 | if (!VERIFY_SHORT(res)) | ||
670 | { | ||
671 | fprintf (stderr, "MULT16_16_P14: output is not short: %d*%d=%d\n", a, b, (int)res); | ||
672 | #ifdef FIXED_DEBUG_ASSERT | ||
673 | celt_assert(0); | ||
674 | #endif | ||
675 | } | ||
676 | celt_mips+=4; | ||
677 | return res; | ||
678 | } | ||
679 | static OPUS_INLINE short MULT16_16_P15(int a, int b) | ||
680 | { | ||
681 | opus_int64 res; | ||
682 | if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b)) | ||
683 | { | ||
684 | fprintf (stderr, "MULT16_16_P15: inputs are not short: %d %d\n", a, b); | ||
685 | #ifdef FIXED_DEBUG_ASSERT | ||
686 | celt_assert(0); | ||
687 | #endif | ||
688 | } | ||
689 | res = ((opus_int64)a)*b; | ||
690 | res += 16384; | ||
691 | if (!VERIFY_INT(res)) | ||
692 | { | ||
693 | fprintf (stderr, "MULT16_16_P15: overflow: %d*%d=%d\n", a, b, (int)res); | ||
694 | #ifdef FIXED_DEBUG_ASSERT | ||
695 | celt_assert(0); | ||
696 | #endif | ||
697 | } | ||
698 | res >>= 15; | ||
699 | if (!VERIFY_SHORT(res)) | ||
700 | { | ||
701 | fprintf (stderr, "MULT16_16_P15: output is not short: %d*%d=%d\n", a, b, (int)res); | ||
702 | #ifdef FIXED_DEBUG_ASSERT | ||
703 | celt_assert(0); | ||
704 | #endif | ||
705 | } | ||
706 | celt_mips+=2; | ||
707 | return res; | ||
708 | } | ||
709 | |||
710 | #define DIV32_16(a, b) DIV32_16_(a, b, __FILE__, __LINE__) | ||
711 | |||
712 | static OPUS_INLINE int DIV32_16_(opus_int64 a, opus_int64 b, char *file, int line) | ||
713 | { | ||
714 | opus_int64 res; | ||
715 | if (b==0) | ||
716 | { | ||
717 | fprintf(stderr, "DIV32_16: divide by zero: %d/%d in %s: line %d\n", (int)a, (int)b, file, line); | ||
718 | #ifdef FIXED_DEBUG_ASSERT | ||
719 | celt_assert(0); | ||
720 | #endif | ||
721 | return 0; | ||
722 | } | ||
723 | if (!VERIFY_INT(a) || !VERIFY_SHORT(b)) | ||
724 | { | ||
725 | fprintf (stderr, "DIV32_16: inputs are not int/short: %d %d in %s: line %d\n", (int)a, (int)b, file, line); | ||
726 | #ifdef FIXED_DEBUG_ASSERT | ||
727 | celt_assert(0); | ||
728 | #endif | ||
729 | } | ||
730 | res = a/b; | ||
731 | if (!VERIFY_SHORT(res)) | ||
732 | { | ||
733 | fprintf (stderr, "DIV32_16: output is not short: %d / %d = %d in %s: line %d\n", (int)a,(int)b,(int)res, file, line); | ||
734 | if (res>32767) | ||
735 | res = 32767; | ||
736 | if (res<-32768) | ||
737 | res = -32768; | ||
738 | #ifdef FIXED_DEBUG_ASSERT | ||
739 | celt_assert(0); | ||
740 | #endif | ||
741 | } | ||
742 | celt_mips+=35; | ||
743 | return res; | ||
744 | } | ||
745 | |||
746 | #define DIV32(a, b) DIV32_(a, b, __FILE__, __LINE__) | ||
747 | static OPUS_INLINE int DIV32_(opus_int64 a, opus_int64 b, char *file, int line) | ||
748 | { | ||
749 | opus_int64 res; | ||
750 | if (b==0) | ||
751 | { | ||
752 | fprintf(stderr, "DIV32: divide by zero: %d/%d in %s: line %d\n", (int)a, (int)b, file, line); | ||
753 | #ifdef FIXED_DEBUG_ASSERT | ||
754 | celt_assert(0); | ||
755 | #endif | ||
756 | return 0; | ||
757 | } | ||
758 | |||
759 | if (!VERIFY_INT(a) || !VERIFY_INT(b)) | ||
760 | { | ||
761 | fprintf (stderr, "DIV32: inputs are not int/short: %d %d in %s: line %d\n", (int)a, (int)b, file, line); | ||
762 | #ifdef FIXED_DEBUG_ASSERT | ||
763 | celt_assert(0); | ||
764 | #endif | ||
765 | } | ||
766 | res = a/b; | ||
767 | if (!VERIFY_INT(res)) | ||
768 | { | ||
769 | fprintf (stderr, "DIV32: output is not int: %d in %s: line %d\n", (int)res, file, line); | ||
770 | #ifdef FIXED_DEBUG_ASSERT | ||
771 | celt_assert(0); | ||
772 | #endif | ||
773 | } | ||
774 | celt_mips+=70; | ||
775 | return res; | ||
776 | } | ||
777 | |||
778 | static OPUS_INLINE opus_val16 SIG2WORD16_generic(celt_sig x) | ||
779 | { | ||
780 | x = PSHR32(x, SIG_SHIFT); | ||
781 | x = MAX32(x, -32768); | ||
782 | x = MIN32(x, 32767); | ||
783 | return EXTRACT16(x); | ||
784 | } | ||
785 | #define SIG2WORD16(x) (SIG2WORD16_generic(x)) | ||
786 | |||
787 | |||
788 | #undef PRINT_MIPS | ||
789 | #define PRINT_MIPS(file) do {fprintf (file, "total complexity = %llu MIPS\n", celt_mips);} while (0); | ||
790 | |||
791 | #endif | ||