fixed_debug.h: delete some dead code
[opus.git] / celt / fixed_debug.h
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 #define NEG32_ovflw(a) (celt_mips+=2,(opus_val32)(-(opus_uint32)(a)))
67
68 static OPUS_INLINE short NEG16(int x)
69 {
70    int res;
71    if (!VERIFY_SHORT(x))
72    {
73       fprintf (stderr, "NEG16: input is not short: %d\n", (int)x);
74 #ifdef FIXED_DEBUG_ASSERT
75       celt_assert(0);
76 #endif
77    }
78    res = -x;
79    if (!VERIFY_SHORT(res))
80    {
81       fprintf (stderr, "NEG16: output is not short: %d\n", (int)res);
82 #ifdef FIXED_DEBUG_ASSERT
83       celt_assert(0);
84 #endif
85    }
86    celt_mips++;
87    return res;
88 }
89 static OPUS_INLINE int NEG32(opus_int64 x)
90 {
91    opus_int64 res;
92    if (!VERIFY_INT(x))
93    {
94       fprintf (stderr, "NEG16: input is not int: %d\n", (int)x);
95 #ifdef FIXED_DEBUG_ASSERT
96       celt_assert(0);
97 #endif
98    }
99    res = -x;
100    if (!VERIFY_INT(res))
101    {
102       fprintf (stderr, "NEG16: output is not int: %d\n", (int)res);
103 #ifdef FIXED_DEBUG_ASSERT
104       celt_assert(0);
105 #endif
106    }
107    celt_mips+=2;
108    return res;
109 }
110
111 #define EXTRACT16(x) EXTRACT16_(x, __FILE__, __LINE__)
112 static OPUS_INLINE short EXTRACT16_(int x, char *file, int line)
113 {
114    int res;
115    if (!VERIFY_SHORT(x))
116    {
117       fprintf (stderr, "EXTRACT16: input is not short: %d in %s: line %d\n", x, file, line);
118 #ifdef FIXED_DEBUG_ASSERT
119       celt_assert(0);
120 #endif
121    }
122    res = x;
123    celt_mips++;
124    return res;
125 }
126
127 #define EXTEND32(x) EXTEND32_(x, __FILE__, __LINE__)
128 static OPUS_INLINE int EXTEND32_(int x, char *file, int line)
129 {
130    int res;
131    if (!VERIFY_SHORT(x))
132    {
133       fprintf (stderr, "EXTEND32: input is not short: %d in %s: line %d\n", x, file, line);
134 #ifdef FIXED_DEBUG_ASSERT
135       celt_assert(0);
136 #endif
137    }
138    res = x;
139    celt_mips++;
140    return res;
141 }
142
143 #define SHR16(a, shift) SHR16_(a, shift, __FILE__, __LINE__)
144 static OPUS_INLINE short SHR16_(int a, int shift, char *file, int line)
145 {
146    int res;
147    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(shift))
148    {
149       fprintf (stderr, "SHR16: inputs are not short: %d >> %d in %s: line %d\n", a, shift, file, line);
150 #ifdef FIXED_DEBUG_ASSERT
151       celt_assert(0);
152 #endif
153    }
154    res = a>>shift;
155    if (!VERIFY_SHORT(res))
156    {
157       fprintf (stderr, "SHR16: output is not short: %d in %s: line %d\n", res, file, line);
158 #ifdef FIXED_DEBUG_ASSERT
159       celt_assert(0);
160 #endif
161    }
162    celt_mips++;
163    return res;
164 }
165 #define SHL16(a, shift) SHL16_(a, shift, __FILE__, __LINE__)
166 static OPUS_INLINE short SHL16_(int a, int shift, char *file, int line)
167 {
168    int res;
169    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(shift))
170    {
171       fprintf (stderr, "SHL16: inputs are not short: %d %d in %s: line %d\n", a, shift, file, line);
172 #ifdef FIXED_DEBUG_ASSERT
173       celt_assert(0);
174 #endif
175    }
176    res = a<<shift;
177    if (!VERIFY_SHORT(res))
178    {
179       fprintf (stderr, "SHL16: output is not short: %d in %s: line %d\n", res, file, line);
180 #ifdef FIXED_DEBUG_ASSERT
181       celt_assert(0);
182 #endif
183    }
184    celt_mips++;
185    return res;
186 }
187
188 static OPUS_INLINE int SHR32(opus_int64 a, int shift)
189 {
190    opus_int64  res;
191    if (!VERIFY_INT(a) || !VERIFY_SHORT(shift))
192    {
193       fprintf (stderr, "SHR32: inputs are not int: %d %d\n", (int)a, shift);
194 #ifdef FIXED_DEBUG_ASSERT
195       celt_assert(0);
196 #endif
197    }
198    res = a>>shift;
199    if (!VERIFY_INT(res))
200    {
201       fprintf (stderr, "SHR32: output is not int: %d\n", (int)res);
202 #ifdef FIXED_DEBUG_ASSERT
203       celt_assert(0);
204 #endif
205    }
206    celt_mips+=2;
207    return res;
208 }
209 #define SHL32(a, shift) SHL32_(a, shift, __FILE__, __LINE__)
210 static OPUS_INLINE int SHL32_(opus_int64 a, int shift, char *file, int line)
211 {
212    opus_int64  res;
213    if (!VERIFY_INT(a) || !VERIFY_SHORT(shift))
214    {
215       fprintf (stderr, "SHL32: inputs are not int: %lld %d in %s: line %d\n", a, shift, file, line);
216 #ifdef FIXED_DEBUG_ASSERT
217       celt_assert(0);
218 #endif
219    }
220    res = a<<shift;
221    if (!VERIFY_INT(res))
222    {
223       fprintf (stderr, "SHL32: output is not int: %lld<<%d = %lld in %s: line %d\n", a, shift, res, file, line);
224 #ifdef FIXED_DEBUG_ASSERT
225       celt_assert(0);
226 #endif
227    }
228    celt_mips+=2;
229    return res;
230 }
231
232 #define PSHR32(a,shift) (celt_mips--,SHR32(ADD32((a),(((opus_val32)(1)<<((shift))>>1))),shift))
233 #define VSHR32(a, shift) (((shift)>0) ? SHR32(a, shift) : SHL32(a, -(shift)))
234
235 #define ROUND16(x,a) (celt_mips--,EXTRACT16(PSHR32((x),(a))))
236 #define SROUND16(x,a) (celt_mips--,EXTRACT16(SATURATE(PSHR32(x,a), 32767)));
237
238 #define HALF16(x)  (SHR16(x,1))
239 #define HALF32(x)  (SHR32(x,1))
240
241 #define ADD16(a, b) ADD16_(a, b, __FILE__, __LINE__)
242 static OPUS_INLINE short ADD16_(int a, int b, char *file, int line)
243 {
244    int res;
245    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
246    {
247       fprintf (stderr, "ADD16: inputs are not short: %d %d in %s: line %d\n", a, b, file, line);
248 #ifdef FIXED_DEBUG_ASSERT
249       celt_assert(0);
250 #endif
251    }
252    res = a+b;
253    if (!VERIFY_SHORT(res))
254    {
255       fprintf (stderr, "ADD16: output is not short: %d+%d=%d in %s: line %d\n", a,b,res, file, line);
256 #ifdef FIXED_DEBUG_ASSERT
257       celt_assert(0);
258 #endif
259    }
260    celt_mips++;
261    return res;
262 }
263
264 #define SUB16(a, b) SUB16_(a, b, __FILE__, __LINE__)
265 static OPUS_INLINE short SUB16_(int a, int b, char *file, int line)
266 {
267    int res;
268    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
269    {
270       fprintf (stderr, "SUB16: inputs are not short: %d %d in %s: line %d\n", a, b, file, line);
271 #ifdef FIXED_DEBUG_ASSERT
272       celt_assert(0);
273 #endif
274    }
275    res = a-b;
276    if (!VERIFY_SHORT(res))
277    {
278       fprintf (stderr, "SUB16: output is not short: %d in %s: line %d\n", res, file, line);
279 #ifdef FIXED_DEBUG_ASSERT
280       celt_assert(0);
281 #endif
282    }
283    celt_mips++;
284    return res;
285 }
286
287 #define ADD32(a, b) ADD32_(a, b, __FILE__, __LINE__)
288 static OPUS_INLINE int ADD32_(opus_int64 a, opus_int64 b, char *file, int line)
289 {
290    opus_int64 res;
291    if (!VERIFY_INT(a) || !VERIFY_INT(b))
292    {
293       fprintf (stderr, "ADD32: inputs are not int: %d %d in %s: line %d\n", (int)a, (int)b, file, line);
294 #ifdef FIXED_DEBUG_ASSERT
295       celt_assert(0);
296 #endif
297    }
298    res = a+b;
299    if (!VERIFY_INT(res))
300    {
301       fprintf (stderr, "ADD32: output is not int: %d in %s: line %d\n", (int)res, file, line);
302 #ifdef FIXED_DEBUG_ASSERT
303       celt_assert(0);
304 #endif
305    }
306    celt_mips+=2;
307    return res;
308 }
309
310 #define SUB32(a, b) SUB32_(a, b, __FILE__, __LINE__)
311 static OPUS_INLINE int SUB32_(opus_int64 a, opus_int64 b, char *file, int line)
312 {
313    opus_int64 res;
314    if (!VERIFY_INT(a) || !VERIFY_INT(b))
315    {
316       fprintf (stderr, "SUB32: inputs are not int: %d %d in %s: line %d\n", (int)a, (int)b, file, line);
317 #ifdef FIXED_DEBUG_ASSERT
318       celt_assert(0);
319 #endif
320    }
321    res = a-b;
322    if (!VERIFY_INT(res))
323    {
324       fprintf (stderr, "SUB32: output is not int: %d in %s: line %d\n", (int)res, file, line);
325 #ifdef FIXED_DEBUG_ASSERT
326       celt_assert(0);
327 #endif
328    }
329    celt_mips+=2;
330    return res;
331 }
332
333 #undef UADD32
334 #define UADD32(a, b) UADD32_(a, b, __FILE__, __LINE__)
335 static OPUS_INLINE unsigned int UADD32_(opus_uint64 a, opus_uint64 b, char *file, int line)
336 {
337    opus_uint64 res;
338    if (!VERIFY_UINT(a) || !VERIFY_UINT(b))
339    {
340       fprintf (stderr, "UADD32: inputs are not uint32: %llu %llu in %s: line %d\n", a, b, file, line);
341 #ifdef FIXED_DEBUG_ASSERT
342       celt_assert(0);
343 #endif
344    }
345    res = a+b;
346    if (!VERIFY_UINT(res))
347    {
348       fprintf (stderr, "UADD32: output is not uint32: %llu in %s: line %d\n", res, file, line);
349 #ifdef FIXED_DEBUG_ASSERT
350       celt_assert(0);
351 #endif
352    }
353    celt_mips+=2;
354    return res;
355 }
356
357 #undef USUB32
358 #define USUB32(a, b) USUB32_(a, b, __FILE__, __LINE__)
359 static OPUS_INLINE unsigned int USUB32_(opus_uint64 a, opus_uint64 b, char *file, int line)
360 {
361    opus_uint64 res;
362    if (!VERIFY_UINT(a) || !VERIFY_UINT(b))
363    {
364       fprintf (stderr, "USUB32: inputs are not uint32: %llu %llu in %s: line %d\n", a, b, file, line);
365 #ifdef FIXED_DEBUG_ASSERT
366       celt_assert(0);
367 #endif
368    }
369    if (a<b)
370    {
371       fprintf (stderr, "USUB32: inputs underflow: %llu < %llu in %s: line %d\n", a, b, file, line);
372 #ifdef FIXED_DEBUG_ASSERT
373       celt_assert(0);
374 #endif
375    }
376    res = a-b;
377    if (!VERIFY_UINT(res))
378    {
379       fprintf (stderr, "USUB32: output is not uint32: %llu - %llu = %llu in %s: line %d\n", a, b, res, file, line);
380 #ifdef FIXED_DEBUG_ASSERT
381       celt_assert(0);
382 #endif
383    }
384    celt_mips+=2;
385    return res;
386 }
387
388 /* result fits in 16 bits */
389 static OPUS_INLINE short MULT16_16_16(int a, int b)
390 {
391    int res;
392    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
393    {
394       fprintf (stderr, "MULT16_16_16: inputs are not short: %d %d\n", a, b);
395 #ifdef FIXED_DEBUG_ASSERT
396       celt_assert(0);
397 #endif
398    }
399    res = a*b;
400    if (!VERIFY_SHORT(res))
401    {
402       fprintf (stderr, "MULT16_16_16: output is not short: %d\n", res);
403 #ifdef FIXED_DEBUG_ASSERT
404       celt_assert(0);
405 #endif
406    }
407    celt_mips++;
408    return res;
409 }
410
411 #define MULT16_16(a, b) MULT16_16_(a, b, __FILE__, __LINE__)
412 static OPUS_INLINE int MULT16_16_(int a, int b, char *file, int line)
413 {
414    opus_int64 res;
415    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
416    {
417       fprintf (stderr, "MULT16_16: inputs are not short: %d %d in %s: line %d\n", a, b, file, line);
418 #ifdef FIXED_DEBUG_ASSERT
419       celt_assert(0);
420 #endif
421    }
422    res = ((opus_int64)a)*b;
423    if (!VERIFY_INT(res))
424    {
425       fprintf (stderr, "MULT16_16: output is not int: %d in %s: line %d\n", (int)res, file, line);
426 #ifdef FIXED_DEBUG_ASSERT
427       celt_assert(0);
428 #endif
429    }
430    celt_mips++;
431    return res;
432 }
433
434 #define MAC16_16(c,a,b)     (celt_mips-=2,ADD32((c),MULT16_16((a),(b))))
435
436 #define MULT16_32_QX(a, b, Q) MULT16_32_QX_(a, b, Q, __FILE__, __LINE__)
437 static OPUS_INLINE int MULT16_32_QX_(int a, opus_int64 b, int Q, char *file, int line)
438 {
439    opus_int64 res;
440    if (!VERIFY_SHORT(a) || !VERIFY_INT(b))
441    {
442       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);
443 #ifdef FIXED_DEBUG_ASSERT
444       celt_assert(0);
445 #endif
446    }
447    if (ABS32(b)>=((opus_val32)(1)<<(15+Q)))
448    {
449       fprintf (stderr, "MULT16_32_Q%d: second operand too large: %d %d in %s: line %d\n", Q, (int)a, (int)b, file, line);
450 #ifdef FIXED_DEBUG_ASSERT
451       celt_assert(0);
452 #endif
453    }
454    res = (((opus_int64)a)*(opus_int64)b) >> Q;
455    if (!VERIFY_INT(res))
456    {
457       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);
458 #ifdef FIXED_DEBUG_ASSERT
459       celt_assert(0);
460 #endif
461    }
462    if (Q==15)
463       celt_mips+=3;
464    else
465       celt_mips+=4;
466    return res;
467 }
468
469 #define MULT16_32_PX(a, b, Q) MULT16_32_PX_(a, b, Q, __FILE__, __LINE__)
470 static OPUS_INLINE int MULT16_32_PX_(int a, opus_int64 b, int Q, char *file, int line)
471 {
472    opus_int64 res;
473    if (!VERIFY_SHORT(a) || !VERIFY_INT(b))
474    {
475       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);
476 #ifdef FIXED_DEBUG_ASSERT
477       celt_assert(0);
478 #endif
479    }
480    if (ABS32(b)>=((opus_int64)(1)<<(15+Q)))
481    {
482       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);
483 #ifdef FIXED_DEBUG_ASSERT
484       celt_assert(0);
485 #endif
486    }
487    res = ((((opus_int64)a)*(opus_int64)b) + (((opus_val32)(1)<<Q)>>1))>> Q;
488    if (!VERIFY_INT(res))
489    {
490       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);
491 #ifdef FIXED_DEBUG_ASSERT
492       celt_assert(0);
493 #endif
494    }
495    if (Q==15)
496       celt_mips+=4;
497    else
498       celt_mips+=5;
499    return res;
500 }
501
502 #define MULT16_32_Q15(a,b) MULT16_32_QX(a,b,15)
503 #define MAC16_32_Q15(c,a,b) (celt_mips-=2,ADD32((c),MULT16_32_Q15((a),(b))))
504 #define MAC16_32_Q16(c,a,b) (celt_mips-=2,ADD32((c),MULT16_32_Q16((a),(b))))
505
506 static OPUS_INLINE int SATURATE(int a, int b)
507 {
508    if (a>b)
509       a=b;
510    if (a<-b)
511       a = -b;
512    celt_mips+=3;
513    return a;
514 }
515
516 static OPUS_INLINE opus_int16 SATURATE16(opus_int32 a)
517 {
518    celt_mips+=3;
519    if (a>32767)
520       return 32767;
521    else if (a<-32768)
522       return -32768;
523    else return a;
524 }
525
526 static OPUS_INLINE int MULT16_16_Q11_32(int a, int b)
527 {
528    opus_int64 res;
529    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
530    {
531       fprintf (stderr, "MULT16_16_Q11: inputs are not short: %d %d\n", a, b);
532 #ifdef FIXED_DEBUG_ASSERT
533       celt_assert(0);
534 #endif
535    }
536    res = ((opus_int64)a)*b;
537    res >>= 11;
538    if (!VERIFY_INT(res))
539    {
540       fprintf (stderr, "MULT16_16_Q11: output is not short: %d*%d=%d\n", (int)a, (int)b, (int)res);
541 #ifdef FIXED_DEBUG_ASSERT
542       celt_assert(0);
543 #endif
544    }
545    celt_mips+=3;
546    return res;
547 }
548 static OPUS_INLINE short MULT16_16_Q13(int a, int b)
549 {
550    opus_int64 res;
551    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
552    {
553       fprintf (stderr, "MULT16_16_Q13: inputs are not short: %d %d\n", a, b);
554 #ifdef FIXED_DEBUG_ASSERT
555       celt_assert(0);
556 #endif
557    }
558    res = ((opus_int64)a)*b;
559    res >>= 13;
560    if (!VERIFY_SHORT(res))
561    {
562       fprintf (stderr, "MULT16_16_Q13: output is not short: %d*%d=%d\n", a, b, (int)res);
563 #ifdef FIXED_DEBUG_ASSERT
564       celt_assert(0);
565 #endif
566    }
567    celt_mips+=3;
568    return res;
569 }
570 static OPUS_INLINE short MULT16_16_Q14(int a, int b)
571 {
572    opus_int64 res;
573    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
574    {
575       fprintf (stderr, "MULT16_16_Q14: inputs are not short: %d %d\n", a, b);
576 #ifdef FIXED_DEBUG_ASSERT
577       celt_assert(0);
578 #endif
579    }
580    res = ((opus_int64)a)*b;
581    res >>= 14;
582    if (!VERIFY_SHORT(res))
583    {
584       fprintf (stderr, "MULT16_16_Q14: output is not short: %d\n", (int)res);
585 #ifdef FIXED_DEBUG_ASSERT
586       celt_assert(0);
587 #endif
588    }
589    celt_mips+=3;
590    return res;
591 }
592
593 #define MULT16_16_Q15(a, b) MULT16_16_Q15_(a, b, __FILE__, __LINE__)
594 static OPUS_INLINE short MULT16_16_Q15_(int a, int b, char *file, int line)
595 {
596    opus_int64 res;
597    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
598    {
599       fprintf (stderr, "MULT16_16_Q15: inputs are not short: %d %d in %s: line %d\n", a, b, file, line);
600 #ifdef FIXED_DEBUG_ASSERT
601       celt_assert(0);
602 #endif
603    }
604    res = ((opus_int64)a)*b;
605    res >>= 15;
606    if (!VERIFY_SHORT(res))
607    {
608       fprintf (stderr, "MULT16_16_Q15: output is not short: %d in %s: line %d\n", (int)res, file, line);
609 #ifdef FIXED_DEBUG_ASSERT
610       celt_assert(0);
611 #endif
612    }
613    celt_mips+=1;
614    return res;
615 }
616
617 static OPUS_INLINE short MULT16_16_P13(int a, int b)
618 {
619    opus_int64 res;
620    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
621    {
622       fprintf (stderr, "MULT16_16_P13: inputs are not short: %d %d\n", a, b);
623 #ifdef FIXED_DEBUG_ASSERT
624       celt_assert(0);
625 #endif
626    }
627    res = ((opus_int64)a)*b;
628    res += 4096;
629    if (!VERIFY_INT(res))
630    {
631       fprintf (stderr, "MULT16_16_P13: overflow: %d*%d=%d\n", a, b, (int)res);
632 #ifdef FIXED_DEBUG_ASSERT
633       celt_assert(0);
634 #endif
635    }
636    res >>= 13;
637    if (!VERIFY_SHORT(res))
638    {
639       fprintf (stderr, "MULT16_16_P13: output is not short: %d*%d=%d\n", a, b, (int)res);
640 #ifdef FIXED_DEBUG_ASSERT
641       celt_assert(0);
642 #endif
643    }
644    celt_mips+=4;
645    return res;
646 }
647 static OPUS_INLINE short MULT16_16_P14(int a, int b)
648 {
649    opus_int64 res;
650    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
651    {
652       fprintf (stderr, "MULT16_16_P14: inputs are not short: %d %d\n", a, b);
653 #ifdef FIXED_DEBUG_ASSERT
654       celt_assert(0);
655 #endif
656    }
657    res = ((opus_int64)a)*b;
658    res += 8192;
659    if (!VERIFY_INT(res))
660    {
661       fprintf (stderr, "MULT16_16_P14: overflow: %d*%d=%d\n", a, b, (int)res);
662 #ifdef FIXED_DEBUG_ASSERT
663       celt_assert(0);
664 #endif
665    }
666    res >>= 14;
667    if (!VERIFY_SHORT(res))
668    {
669       fprintf (stderr, "MULT16_16_P14: output is not short: %d*%d=%d\n", a, b, (int)res);
670 #ifdef FIXED_DEBUG_ASSERT
671       celt_assert(0);
672 #endif
673    }
674    celt_mips+=4;
675    return res;
676 }
677 static OPUS_INLINE short MULT16_16_P15(int a, int b)
678 {
679    opus_int64 res;
680    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
681    {
682       fprintf (stderr, "MULT16_16_P15: inputs are not short: %d %d\n", a, b);
683 #ifdef FIXED_DEBUG_ASSERT
684       celt_assert(0);
685 #endif
686    }
687    res = ((opus_int64)a)*b;
688    res += 16384;
689    if (!VERIFY_INT(res))
690    {
691       fprintf (stderr, "MULT16_16_P15: overflow: %d*%d=%d\n", a, b, (int)res);
692 #ifdef FIXED_DEBUG_ASSERT
693       celt_assert(0);
694 #endif
695    }
696    res >>= 15;
697    if (!VERIFY_SHORT(res))
698    {
699       fprintf (stderr, "MULT16_16_P15: output is not short: %d*%d=%d\n", a, b, (int)res);
700 #ifdef FIXED_DEBUG_ASSERT
701       celt_assert(0);
702 #endif
703    }
704    celt_mips+=2;
705    return res;
706 }
707
708 #define DIV32_16(a, b) DIV32_16_(a, b, __FILE__, __LINE__)
709
710 static OPUS_INLINE int DIV32_16_(opus_int64 a, opus_int64 b, char *file, int line)
711 {
712    opus_int64 res;
713    if (b==0)
714    {
715       fprintf(stderr, "DIV32_16: divide by zero: %d/%d in %s: line %d\n", (int)a, (int)b, file, line);
716 #ifdef FIXED_DEBUG_ASSERT
717       celt_assert(0);
718 #endif
719       return 0;
720    }
721    if (!VERIFY_INT(a) || !VERIFY_SHORT(b))
722    {
723       fprintf (stderr, "DIV32_16: inputs are not int/short: %d %d in %s: line %d\n", (int)a, (int)b, file, line);
724 #ifdef FIXED_DEBUG_ASSERT
725       celt_assert(0);
726 #endif
727    }
728    res = a/b;
729    if (!VERIFY_SHORT(res))
730    {
731       fprintf (stderr, "DIV32_16: output is not short: %d / %d = %d in %s: line %d\n", (int)a,(int)b,(int)res, file, line);
732       if (res>32767)
733          res = 32767;
734       if (res<-32768)
735          res = -32768;
736 #ifdef FIXED_DEBUG_ASSERT
737       celt_assert(0);
738 #endif
739    }
740    celt_mips+=35;
741    return res;
742 }
743
744 #define DIV32(a, b) DIV32_(a, b, __FILE__, __LINE__)
745 static OPUS_INLINE int DIV32_(opus_int64 a, opus_int64 b, char *file, int line)
746 {
747    opus_int64 res;
748    if (b==0)
749    {
750       fprintf(stderr, "DIV32: divide by zero: %d/%d in %s: line %d\n", (int)a, (int)b, file, line);
751 #ifdef FIXED_DEBUG_ASSERT
752       celt_assert(0);
753 #endif
754       return 0;
755    }
756
757    if (!VERIFY_INT(a) || !VERIFY_INT(b))
758    {
759       fprintf (stderr, "DIV32: inputs are not int/short: %d %d in %s: line %d\n", (int)a, (int)b, file, line);
760 #ifdef FIXED_DEBUG_ASSERT
761       celt_assert(0);
762 #endif
763    }
764    res = a/b;
765    if (!VERIFY_INT(res))
766    {
767       fprintf (stderr, "DIV32: output is not int: %d in %s: line %d\n", (int)res, file, line);
768 #ifdef FIXED_DEBUG_ASSERT
769       celt_assert(0);
770 #endif
771    }
772    celt_mips+=70;
773    return res;
774 }
775
776 static OPUS_INLINE opus_val16 SIG2WORD16_generic(celt_sig x)
777 {
778    x = PSHR32(x, SIG_SHIFT);
779    x = MAX32(x, -32768);
780    x = MIN32(x, 32767);
781    return EXTRACT16(x);
782 }
783 #define SIG2WORD16(x) (SIG2WORD16_generic(x))
784
785
786 #undef PRINT_MIPS
787 #define PRINT_MIPS(file) do {fprintf (file, "total complexity = %llu MIPS\n", celt_mips);} while (0);
788
789 #endif