Smart Remote 3 nRF52 v1.2
fixed_debug.h
1 /* Copyright (C) 2003-2008 Jean-Marc Valin
2  Copyright (C) 2007-2012 Xiph.Org Foundation */
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 
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 
63 #define ADD32_ovflw(a,b) (celt_mips+=2,(opus_val32)((opus_uint32)(a)+(opus_uint32)(b)))
64 
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 */
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
Documentation feedback | Developer Zone | Subscribe | Updated