Remove trailing whitespace from the license headers.
[opus.git] / silk / MacroCount.h
1 /***********************************************************************
2 Copyright (c) 2006-2011, Skype Limited. All rights reserved.
3 Redistribution and use in source and binary forms, with or without
4 modification, are permitted provided that the following conditions
5 are met:
6 - Redistributions of source code must retain the above copyright notice,
7 this list of conditions and the following disclaimer.
8 - Redistributions in binary form must reproduce the above copyright
9 notice, this list of conditions and the following disclaimer in the
10 documentation and/or other materials provided with the distribution.
11 - Neither the name of Internet Society, IETF or IETF Trust, nor the
12 names of specific contributors, may be used to endorse or promote
13 products derived from this software without specific prior written
14 permission.
15 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
16 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
19 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
25 POSSIBILITY OF SUCH DAMAGE.
26 ***********************************************************************/
27
28 #ifndef SIGPROCFIX_API_MACROCOUNT_H
29 #define SIGPROCFIX_API_MACROCOUNT_H
30 #include <stdio.h>
31
32 #ifdef    silk_MACRO_COUNT
33 #define varDefine opus_int64 ops_count = 0;
34
35 extern opus_int64 ops_count;
36
37 static inline opus_int64 silk_SaveCount(){
38     return(ops_count);
39 }
40
41 static inline opus_int64 silk_SaveResetCount(){
42     opus_int64 ret;
43
44     ret = ops_count;
45     ops_count = 0;
46     return(ret);
47 }
48
49 static inline silk_PrintCount(){
50     printf("ops_count = %d \n ", (opus_int32)ops_count);
51 }
52
53 #undef silk_MUL
54 static inline opus_int32 silk_MUL(opus_int32 a32, opus_int32 b32){
55     opus_int32 ret;
56     ops_count += 4;
57     ret = a32 * b32;
58     return ret;
59 }
60
61 #undef silk_MUL_uint
62 static inline opus_uint32 silk_MUL_uint(opus_uint32 a32, opus_uint32 b32){
63     opus_uint32 ret;
64     ops_count += 4;
65     ret = a32 * b32;
66     return ret;
67 }
68 #undef silk_MLA
69 static inline opus_int32 silk_MLA(opus_int32 a32, opus_int32 b32, opus_int32 c32){
70     opus_int32 ret;
71     ops_count += 4;
72     ret = a32 + b32 * c32;
73     return ret;
74 }
75
76 #undef silk_MLA_uint
77 static inline opus_int32 silk_MLA_uint(opus_uint32 a32, opus_uint32 b32, opus_uint32 c32){
78     opus_uint32 ret;
79     ops_count += 4;
80     ret = a32 + b32 * c32;
81     return ret;
82 }
83
84 #undef silk_SMULWB
85 static inline opus_int32 silk_SMULWB(opus_int32 a32, opus_int32 b32){
86     opus_int32 ret;
87     ops_count += 5;
88     ret = (a32 >> 16) * (opus_int32)((opus_int16)b32) + (((a32 & 0x0000FFFF) * (opus_int32)((opus_int16)b32)) >> 16);
89     return ret;
90 }
91 #undef    silk_SMLAWB
92 static inline opus_int32 silk_SMLAWB(opus_int32 a32, opus_int32 b32, opus_int32 c32){
93     opus_int32 ret;
94     ops_count += 5;
95     ret = ((a32) + ((((b32) >> 16) * (opus_int32)((opus_int16)(c32))) + ((((b32) & 0x0000FFFF) * (opus_int32)((opus_int16)(c32))) >> 16)));
96     return ret;
97 }
98
99 #undef silk_SMULWT
100 static inline opus_int32 silk_SMULWT(opus_int32 a32, opus_int32 b32){
101     opus_int32 ret;
102     ops_count += 4;
103     ret = (a32 >> 16) * (b32 >> 16) + (((a32 & 0x0000FFFF) * (b32 >> 16)) >> 16);
104     return ret;
105 }
106 #undef silk_SMLAWT
107 static inline opus_int32 silk_SMLAWT(opus_int32 a32, opus_int32 b32, opus_int32 c32){
108     opus_int32 ret;
109     ops_count += 4;
110     ret = a32 + ((b32 >> 16) * (c32 >> 16)) + (((b32 & 0x0000FFFF) * ((c32 >> 16)) >> 16));
111     return ret;
112 }
113
114 #undef silk_SMULBB
115 static inline opus_int32 silk_SMULBB(opus_int32 a32, opus_int32 b32){
116     opus_int32 ret;
117     ops_count += 1;
118     ret = (opus_int32)((opus_int16)a32) * (opus_int32)((opus_int16)b32);
119     return ret;
120 }
121 #undef silk_SMLABB
122 static inline opus_int32 silk_SMLABB(opus_int32 a32, opus_int32 b32, opus_int32 c32){
123     opus_int32 ret;
124     ops_count += 1;
125     ret = a32 + (opus_int32)((opus_int16)b32) * (opus_int32)((opus_int16)c32);
126     return ret;
127 }
128
129 #undef silk_SMULBT
130 static inline opus_int32 silk_SMULBT(opus_int32 a32, opus_int32 b32 ){
131     opus_int32 ret;
132     ops_count += 4;
133     ret = ((opus_int32)((opus_int16)a32)) * (b32 >> 16);
134     return ret;
135 }
136
137 #undef silk_SMLABT
138 static inline opus_int32 silk_SMLABT(opus_int32 a32, opus_int32 b32, opus_int32 c32){
139     opus_int32 ret;
140     ops_count += 1;
141     ret = a32 + ((opus_int32)((opus_int16)b32)) * (c32 >> 16);
142     return ret;
143 }
144
145 #undef silk_SMULTT
146 static inline opus_int32 silk_SMULTT(opus_int32 a32, opus_int32 b32){
147     opus_int32 ret;
148     ops_count += 1;
149     ret = (a32 >> 16) * (b32 >> 16);
150     return ret;
151 }
152
153 #undef    silk_SMLATT
154 static inline opus_int32 silk_SMLATT(opus_int32 a32, opus_int32 b32, opus_int32 c32){
155     opus_int32 ret;
156     ops_count += 1;
157     ret = a32 + (b32 >> 16) * (c32 >> 16);
158     return ret;
159 }
160
161
162 /* multiply-accumulate macros that allow overflow in the addition (ie, no asserts in debug mode)*/
163 #undef    silk_MLA_ovflw
164 #define silk_MLA_ovflw silk_MLA
165
166 #undef silk_SMLABB_ovflw
167 #define silk_SMLABB_ovflw silk_SMLABB
168
169 #undef silk_SMLABT_ovflw
170 #define silk_SMLABT_ovflw silk_SMLABT
171
172 #undef silk_SMLATT_ovflw
173 #define silk_SMLATT_ovflw silk_SMLATT
174
175 #undef silk_SMLAWB_ovflw
176 #define silk_SMLAWB_ovflw silk_SMLAWB
177
178 #undef silk_SMLAWT_ovflw
179 #define silk_SMLAWT_ovflw silk_SMLAWT
180
181 #undef silk_SMULL
182 static inline opus_int64 silk_SMULL(opus_int32 a32, opus_int32 b32){
183     opus_int64 ret;
184     ops_count += 8;
185     ret = ((opus_int64)(a32) * /*(opus_int64)*/(b32));
186     return ret;
187 }
188
189 #undef    silk_SMLAL
190 static inline opus_int64 silk_SMLAL(opus_int64 a64, opus_int32 b32, opus_int32 c32){
191     opus_int64 ret;
192     ops_count += 8;
193     ret = a64 + ((opus_int64)(b32) * /*(opus_int64)*/(c32));
194     return ret;
195 }
196 #undef    silk_SMLALBB
197 static inline opus_int64 silk_SMLALBB(opus_int64 a64, opus_int16 b16, opus_int16 c16){
198     opus_int64 ret;
199     ops_count += 4;
200     ret = a64 + ((opus_int64)(b16) * /*(opus_int64)*/(c16));
201     return ret;
202 }
203
204 #undef    SigProcFIX_CLZ16
205 static inline opus_int32 SigProcFIX_CLZ16(opus_int16 in16)
206 {
207     opus_int32 out32 = 0;
208     ops_count += 10;
209     if( in16 == 0 ) {
210         return 16;
211     }
212     /* test nibbles */
213     if( in16 & 0xFF00 ) {
214         if( in16 & 0xF000 ) {
215             in16 >>= 12;
216         } else {
217             out32 += 4;
218             in16 >>= 8;
219         }
220     } else {
221         if( in16 & 0xFFF0 ) {
222             out32 += 8;
223             in16 >>= 4;
224         } else {
225             out32 += 12;
226         }
227     }
228     /* test bits and return */
229     if( in16 & 0xC ) {
230         if( in16 & 0x8 )
231             return out32 + 0;
232         else
233             return out32 + 1;
234     } else {
235         if( in16 & 0xE )
236             return out32 + 2;
237         else
238             return out32 + 3;
239     }
240 }
241
242 #undef SigProcFIX_CLZ32
243 static inline opus_int32 SigProcFIX_CLZ32(opus_int32 in32)
244 {
245     /* test highest 16 bits and convert to opus_int16 */
246     ops_count += 2;
247     if( in32 & 0xFFFF0000 ) {
248         return SigProcFIX_CLZ16((opus_int16)(in32 >> 16));
249     } else {
250         return SigProcFIX_CLZ16((opus_int16)in32) + 16;
251     }
252 }
253
254 #undef silk_DIV32
255 static inline opus_int32 silk_DIV32(opus_int32 a32, opus_int32 b32){
256     ops_count += 64;
257     return a32 / b32;
258 }
259
260 #undef silk_DIV32_16
261 static inline opus_int32 silk_DIV32_16(opus_int32 a32, opus_int32 b32){
262     ops_count += 32;
263     return a32 / b32;
264 }
265
266 #undef silk_SAT8
267 static inline opus_int8 silk_SAT8(opus_int64 a){
268     opus_int8 tmp;
269     ops_count += 1;
270     tmp = (opus_int8)((a) > silk_int8_MAX ? silk_int8_MAX  : \
271                     ((a) < silk_int8_MIN ? silk_int8_MIN  : (a)));
272     return(tmp);
273 }
274
275 #undef silk_SAT16
276 static inline opus_int16 silk_SAT16(opus_int64 a){
277     opus_int16 tmp;
278     ops_count += 1;
279     tmp = (opus_int16)((a) > silk_int16_MAX ? silk_int16_MAX  : \
280                      ((a) < silk_int16_MIN ? silk_int16_MIN  : (a)));
281     return(tmp);
282 }
283 #undef silk_SAT32
284 static inline opus_int32 silk_SAT32(opus_int64 a){
285     opus_int32 tmp;
286     ops_count += 1;
287     tmp = (opus_int32)((a) > silk_int32_MAX ? silk_int32_MAX  : \
288                      ((a) < silk_int32_MIN ? silk_int32_MIN  : (a)));
289     return(tmp);
290 }
291 #undef silk_POS_SAT32
292 static inline opus_int32 silk_POS_SAT32(opus_int64 a){
293     opus_int32 tmp;
294     ops_count += 1;
295     tmp = (opus_int32)((a) > silk_int32_MAX ? silk_int32_MAX : (a));
296     return(tmp);
297 }
298
299 #undef silk_ADD_POS_SAT8
300 static inline opus_int8 silk_ADD_POS_SAT8(opus_int64 a, opus_int64 b){
301     opus_int8 tmp;
302     ops_count += 1;
303     tmp = (opus_int8)((((a)+(b)) & 0x80) ? silk_int8_MAX  : ((a)+(b)));
304     return(tmp);
305 }
306 #undef silk_ADD_POS_SAT16
307 static inline opus_int16 silk_ADD_POS_SAT16(opus_int64 a, opus_int64 b){
308     opus_int16 tmp;
309     ops_count += 1;
310     tmp = (opus_int16)((((a)+(b)) & 0x8000) ? silk_int16_MAX : ((a)+(b)));
311     return(tmp);
312 }
313
314 #undef silk_ADD_POS_SAT32
315 static inline opus_int32 silk_ADD_POS_SAT32(opus_int64 a, opus_int64 b){
316     opus_int32 tmp;
317     ops_count += 1;
318     tmp = (opus_int32)((((a)+(b)) & 0x80000000) ? silk_int32_MAX : ((a)+(b)));
319     return(tmp);
320 }
321
322 #undef silk_ADD_POS_SAT64
323 static inline opus_int64 silk_ADD_POS_SAT64(opus_int64 a, opus_int64 b){
324     opus_int64 tmp;
325     ops_count += 1;
326     tmp = ((((a)+(b)) & 0x8000000000000000LL) ? silk_int64_MAX : ((a)+(b)));
327     return(tmp);
328 }
329
330 #undef    silk_LSHIFT8
331 static inline opus_int8 silk_LSHIFT8(opus_int8 a, opus_int32 shift){
332     opus_int8 ret;
333     ops_count += 1;
334     ret = a << shift;
335     return ret;
336 }
337 #undef    silk_LSHIFT16
338 static inline opus_int16 silk_LSHIFT16(opus_int16 a, opus_int32 shift){
339     opus_int16 ret;
340     ops_count += 1;
341     ret = a << shift;
342     return ret;
343 }
344 #undef    silk_LSHIFT32
345 static inline opus_int32 silk_LSHIFT32(opus_int32 a, opus_int32 shift){
346     opus_int32 ret;
347     ops_count += 1;
348     ret = a << shift;
349     return ret;
350 }
351 #undef    silk_LSHIFT64
352 static inline opus_int64 silk_LSHIFT64(opus_int64 a, opus_int shift){
353     ops_count += 1;
354     return a << shift;
355 }
356
357 #undef    silk_LSHIFT_ovflw
358 static inline opus_int32 silk_LSHIFT_ovflw(opus_int32 a, opus_int32 shift){
359     ops_count += 1;
360     return a << shift;
361 }
362
363 #undef    silk_LSHIFT_uint
364 static inline opus_uint32 silk_LSHIFT_uint(opus_uint32 a, opus_int32 shift){
365     opus_uint32 ret;
366     ops_count += 1;
367     ret = a << shift;
368     return ret;
369 }
370
371 #undef    silk_RSHIFT8
372 static inline opus_int8 silk_RSHIFT8(opus_int8 a, opus_int32 shift){
373     ops_count += 1;
374     return a >> shift;
375 }
376 #undef    silk_RSHIFT16
377 static inline opus_int16 silk_RSHIFT16(opus_int16 a, opus_int32 shift){
378     ops_count += 1;
379     return a >> shift;
380 }
381 #undef    silk_RSHIFT32
382 static inline opus_int32 silk_RSHIFT32(opus_int32 a, opus_int32 shift){
383     ops_count += 1;
384     return a >> shift;
385 }
386 #undef    silk_RSHIFT64
387 static inline opus_int64 silk_RSHIFT64(opus_int64 a, opus_int64 shift){
388     ops_count += 1;
389     return a >> shift;
390 }
391
392 #undef    silk_RSHIFT_uint
393 static inline opus_uint32 silk_RSHIFT_uint(opus_uint32 a, opus_int32 shift){
394     ops_count += 1;
395     return a >> shift;
396 }
397
398 #undef    silk_ADD_LSHIFT
399 static inline opus_int32 silk_ADD_LSHIFT(opus_int32 a, opus_int32 b, opus_int32 shift){
400     opus_int32 ret;
401     ops_count += 1;
402     ret = a + (b << shift);
403     return ret;                /* shift >= 0*/
404 }
405 #undef    silk_ADD_LSHIFT32
406 static inline opus_int32 silk_ADD_LSHIFT32(opus_int32 a, opus_int32 b, opus_int32 shift){
407     opus_int32 ret;
408     ops_count += 1;
409     ret = a + (b << shift);
410     return ret;                /* shift >= 0*/
411 }
412 #undef    silk_ADD_LSHIFT_uint
413 static inline opus_uint32 silk_ADD_LSHIFT_uint(opus_uint32 a, opus_uint32 b, opus_int32 shift){
414     opus_uint32 ret;
415     ops_count += 1;
416     ret = a + (b << shift);
417     return ret;                /* shift >= 0*/
418 }
419 #undef    silk_ADD_RSHIFT
420 static inline opus_int32 silk_ADD_RSHIFT(opus_int32 a, opus_int32 b, opus_int32 shift){
421     opus_int32 ret;
422     ops_count += 1;
423     ret = a + (b >> shift);
424     return ret;                /* shift  > 0*/
425 }
426 #undef    silk_ADD_RSHIFT32
427 static inline opus_int32 silk_ADD_RSHIFT32(opus_int32 a, opus_int32 b, opus_int32 shift){
428     opus_int32 ret;
429     ops_count += 1;
430     ret = a + (b >> shift);
431     return ret;                /* shift  > 0*/
432 }
433 #undef    silk_ADD_RSHIFT_uint
434 static inline opus_uint32 silk_ADD_RSHIFT_uint(opus_uint32 a, opus_uint32 b, opus_int32 shift){
435     opus_uint32 ret;
436     ops_count += 1;
437     ret = a + (b >> shift);
438     return ret;                /* shift  > 0*/
439 }
440 #undef    silk_SUB_LSHIFT32
441 static inline opus_int32 silk_SUB_LSHIFT32(opus_int32 a, opus_int32 b, opus_int32 shift){
442     opus_int32 ret;
443     ops_count += 1;
444     ret = a - (b << shift);
445     return ret;                /* shift >= 0*/
446 }
447 #undef    silk_SUB_RSHIFT32
448 static inline opus_int32 silk_SUB_RSHIFT32(opus_int32 a, opus_int32 b, opus_int32 shift){
449     opus_int32 ret;
450     ops_count += 1;
451     ret = a - (b >> shift);
452     return ret;                /* shift  > 0*/
453 }
454
455 #undef    silk_RSHIFT_ROUND
456 static inline opus_int32 silk_RSHIFT_ROUND(opus_int32 a, opus_int32 shift){
457     opus_int32 ret;
458     ops_count += 3;
459     ret = shift == 1 ? (a >> 1) + (a & 1) : ((a >> (shift - 1)) + 1) >> 1;
460     return ret;
461 }
462
463 #undef    silk_RSHIFT_ROUND64
464 static inline opus_int64 silk_RSHIFT_ROUND64(opus_int64 a, opus_int32 shift){
465     opus_int64 ret;
466     ops_count += 6;
467     ret = shift == 1 ? (a >> 1) + (a & 1) : ((a >> (shift - 1)) + 1) >> 1;
468     return ret;
469 }
470
471 #undef    silk_abs_int64
472 static inline opus_int64 silk_abs_int64(opus_int64 a){
473     ops_count += 1;
474     return (((a) >  0)  ? (a) : -(a));            /* Be careful, silk_abs returns wrong when input equals to silk_intXX_MIN*/
475 }
476
477 #undef    silk_abs_int32
478 static inline opus_int32 silk_abs_int32(opus_int32 a){
479     ops_count += 1;
480     return silk_abs(a);
481 }
482
483
484 #undef silk_min
485 static silk_min(a, b){
486     ops_count += 1;
487     return (((a) < (b)) ? (a) :  (b));
488 }
489 #undef silk_max
490 static silk_max(a, b){
491     ops_count += 1;
492     return (((a) > (b)) ? (a) :  (b));
493 }
494 #undef silk_sign
495 static silk_sign(a){
496     ops_count += 1;
497     return ((a) > 0 ? 1 : ( (a) < 0 ? -1 : 0 ));
498 }
499
500 #undef    silk_ADD16
501 static inline opus_int16 silk_ADD16(opus_int16 a, opus_int16 b){
502     opus_int16 ret;
503     ops_count += 1;
504     ret = a + b;
505     return ret;
506 }
507
508 #undef    silk_ADD32
509 static inline opus_int32 silk_ADD32(opus_int32 a, opus_int32 b){
510     opus_int32 ret;
511     ops_count += 1;
512     ret = a + b;
513     return ret;
514 }
515
516 #undef    silk_ADD64
517 static inline opus_int64 silk_ADD64(opus_int64 a, opus_int64 b){
518     opus_int64 ret;
519     ops_count += 2;
520     ret = a + b;
521     return ret;
522 }
523
524 #undef    silk_SUB16
525 static inline opus_int16 silk_SUB16(opus_int16 a, opus_int16 b){
526     opus_int16 ret;
527     ops_count += 1;
528     ret = a - b;
529     return ret;
530 }
531
532 #undef    silk_SUB32
533 static inline opus_int32 silk_SUB32(opus_int32 a, opus_int32 b){
534     opus_int32 ret;
535     ops_count += 1;
536     ret = a - b;
537     return ret;
538 }
539
540 #undef    silk_SUB64
541 static inline opus_int64 silk_SUB64(opus_int64 a, opus_int64 b){
542     opus_int64 ret;
543     ops_count += 2;
544     ret = a - b;
545     return ret;
546 }
547
548 #undef silk_ADD_SAT16
549 static inline opus_int16 silk_ADD_SAT16( opus_int16 a16, opus_int16 b16 ) {
550     opus_int16 res;
551     /* Nb will be counted in AKP_add32 and silk_SAT16*/
552     res = (opus_int16)silk_SAT16( silk_ADD32( (opus_int32)(a16), (b16) ) );
553     return res;
554 }
555
556 #undef silk_ADD_SAT32
557 static inline opus_int32 silk_ADD_SAT32(opus_int32 a32, opus_int32 b32){
558     opus_int32 res;
559     ops_count += 1;
560     res =    ((((a32) + (b32)) & 0x80000000) == 0 ?                                    \
561             ((((a32) & (b32)) & 0x80000000) != 0 ? silk_int32_MIN : (a32)+(b32)) :    \
562             ((((a32) | (b32)) & 0x80000000) == 0 ? silk_int32_MAX : (a32)+(b32)) );
563     return res;
564 }
565
566 #undef silk_ADD_SAT64
567 static inline opus_int64 silk_ADD_SAT64( opus_int64 a64, opus_int64 b64 ) {
568     opus_int64 res;
569     ops_count += 1;
570     res =    ((((a64) + (b64)) & 0x8000000000000000LL) == 0 ?                                \
571             ((((a64) & (b64)) & 0x8000000000000000LL) != 0 ? silk_int64_MIN : (a64)+(b64)) :    \
572             ((((a64) | (b64)) & 0x8000000000000000LL) == 0 ? silk_int64_MAX : (a64)+(b64)) );
573     return res;
574 }
575
576 #undef silk_SUB_SAT16
577 static inline opus_int16 silk_SUB_SAT16( opus_int16 a16, opus_int16 b16 ) {
578     opus_int16 res;
579     silk_assert(0);
580     /* Nb will be counted in sub-macros*/
581     res = (opus_int16)silk_SAT16( silk_SUB32( (opus_int32)(a16), (b16) ) );
582     return res;
583 }
584
585 #undef silk_SUB_SAT32
586 static inline opus_int32 silk_SUB_SAT32( opus_int32 a32, opus_int32 b32 ) {
587     opus_int32 res;
588     ops_count += 1;
589     res =     ((((a32)-(b32)) & 0x80000000) == 0 ?                                            \
590             (( (a32) & ((b32)^0x80000000) & 0x80000000) ? silk_int32_MIN : (a32)-(b32)) :    \
591             ((((a32)^0x80000000) & (b32)  & 0x80000000) ? silk_int32_MAX : (a32)-(b32)) );
592     return res;
593 }
594
595 #undef silk_SUB_SAT64
596 static inline opus_int64 silk_SUB_SAT64( opus_int64 a64, opus_int64 b64 ) {
597     opus_int64 res;
598     ops_count += 1;
599     res =    ((((a64)-(b64)) & 0x8000000000000000LL) == 0 ?                                                        \
600             (( (a64) & ((b64)^0x8000000000000000LL) & 0x8000000000000000LL) ? silk_int64_MIN : (a64)-(b64)) :    \
601             ((((a64)^0x8000000000000000LL) & (b64)  & 0x8000000000000000LL) ? silk_int64_MAX : (a64)-(b64)) );
602
603     return res;
604 }
605
606 #undef    silk_SMULWW
607 static inline opus_int32 silk_SMULWW(opus_int32 a32, opus_int32 b32){
608     opus_int32 ret;
609     /* Nb will be counted in sub-macros*/
610     ret = silk_MLA(silk_SMULWB((a32), (b32)), (a32), silk_RSHIFT_ROUND((b32), 16));
611     return ret;
612 }
613
614 #undef    silk_SMLAWW
615 static inline opus_int32 silk_SMLAWW(opus_int32 a32, opus_int32 b32, opus_int32 c32){
616     opus_int32 ret;
617     /* Nb will be counted in sub-macros*/
618     ret = silk_MLA(silk_SMLAWB((a32), (b32), (c32)), (b32), silk_RSHIFT_ROUND((c32), 16));
619     return ret;
620 }
621
622 #undef    silk_min_int
623 static inline opus_int silk_min_int(opus_int a, opus_int b)
624 {
625     ops_count += 1;
626     return (((a) < (b)) ? (a) : (b));
627 }
628
629 #undef    silk_min_16
630 static inline opus_int16 silk_min_16(opus_int16 a, opus_int16 b)
631 {
632     ops_count += 1;
633     return (((a) < (b)) ? (a) : (b));
634 }
635 #undef    silk_min_32
636 static inline opus_int32 silk_min_32(opus_int32 a, opus_int32 b)
637 {
638     ops_count += 1;
639     return (((a) < (b)) ? (a) : (b));
640 }
641 #undef    silk_min_64
642 static inline opus_int64 silk_min_64(opus_int64 a, opus_int64 b)
643 {
644     ops_count += 1;
645     return (((a) < (b)) ? (a) : (b));
646 }
647
648 /* silk_min() versions with typecast in the function call */
649 #undef    silk_max_int
650 static inline opus_int silk_max_int(opus_int a, opus_int b)
651 {
652     ops_count += 1;
653     return (((a) > (b)) ? (a) : (b));
654 }
655 #undef    silk_max_16
656 static inline opus_int16 silk_max_16(opus_int16 a, opus_int16 b)
657 {
658     ops_count += 1;
659     return (((a) > (b)) ? (a) : (b));
660 }
661 #undef    silk_max_32
662 static inline opus_int32 silk_max_32(opus_int32 a, opus_int32 b)
663 {
664     ops_count += 1;
665     return (((a) > (b)) ? (a) : (b));
666 }
667
668 #undef    silk_max_64
669 static inline opus_int64 silk_max_64(opus_int64 a, opus_int64 b)
670 {
671     ops_count += 1;
672     return (((a) > (b)) ? (a) : (b));
673 }
674
675
676 #undef silk_LIMIT_int
677 static inline opus_int silk_LIMIT_int(opus_int a, opus_int limit1, opus_int limit2)
678 {
679     opus_int ret;
680     ops_count += 6;
681
682     ret = ((limit1) > (limit2) ? ((a) > (limit1) ? (limit1) : ((a) < (limit2) ? (limit2) : (a))) \
683         : ((a) > (limit2) ? (limit2) : ((a) < (limit1) ? (limit1) : (a))));
684
685     return(ret);
686 }
687
688 #undef silk_LIMIT_16
689 static inline opus_int16 silk_LIMIT_16(opus_int16 a, opus_int16 limit1, opus_int16 limit2)
690 {
691     opus_int16 ret;
692     ops_count += 6;
693
694     ret = ((limit1) > (limit2) ? ((a) > (limit1) ? (limit1) : ((a) < (limit2) ? (limit2) : (a))) \
695         : ((a) > (limit2) ? (limit2) : ((a) < (limit1) ? (limit1) : (a))));
696
697 return(ret);
698 }
699
700
701 #undef silk_LIMIT_32
702 static inline opus_int silk_LIMIT_32(opus_int32 a, opus_int32 limit1, opus_int32 limit2)
703 {
704     opus_int32 ret;
705     ops_count += 6;
706
707     ret = ((limit1) > (limit2) ? ((a) > (limit1) ? (limit1) : ((a) < (limit2) ? (limit2) : (a))) \
708         : ((a) > (limit2) ? (limit2) : ((a) < (limit1) ? (limit1) : (a))));
709     return(ret);
710 }
711
712 #else
713 #define varDefine
714 #define silk_SaveCount()
715
716 #endif
717 #endif
718