Clean up: alignment of comments
[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 OPUS_INLINE opus_int64 silk_SaveCount(){
38     return(ops_count);
39 }
40
41 static OPUS_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 OPUS_INLINE silk_PrintCount(){
50     printf("ops_count = %d \n ", (opus_int32)ops_count);
51 }
52
53 #undef silk_MUL
54 static OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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 OPUS_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_LSHIFT8
323 static OPUS_INLINE opus_int8 silk_LSHIFT8(opus_int8 a, opus_int32 shift){
324     opus_int8 ret;
325     ops_count += 1;
326     ret = a << shift;
327     return ret;
328 }
329 #undef    silk_LSHIFT16
330 static OPUS_INLINE opus_int16 silk_LSHIFT16(opus_int16 a, opus_int32 shift){
331     opus_int16 ret;
332     ops_count += 1;
333     ret = a << shift;
334     return ret;
335 }
336 #undef    silk_LSHIFT32
337 static OPUS_INLINE opus_int32 silk_LSHIFT32(opus_int32 a, opus_int32 shift){
338     opus_int32 ret;
339     ops_count += 1;
340     ret = a << shift;
341     return ret;
342 }
343 #undef    silk_LSHIFT64
344 static OPUS_INLINE opus_int64 silk_LSHIFT64(opus_int64 a, opus_int shift){
345     ops_count += 1;
346     return a << shift;
347 }
348
349 #undef    silk_LSHIFT_ovflw
350 static OPUS_INLINE opus_int32 silk_LSHIFT_ovflw(opus_int32 a, opus_int32 shift){
351     ops_count += 1;
352     return a << shift;
353 }
354
355 #undef    silk_LSHIFT_uint
356 static OPUS_INLINE opus_uint32 silk_LSHIFT_uint(opus_uint32 a, opus_int32 shift){
357     opus_uint32 ret;
358     ops_count += 1;
359     ret = a << shift;
360     return ret;
361 }
362
363 #undef    silk_RSHIFT8
364 static OPUS_INLINE opus_int8 silk_RSHIFT8(opus_int8 a, opus_int32 shift){
365     ops_count += 1;
366     return a >> shift;
367 }
368 #undef    silk_RSHIFT16
369 static OPUS_INLINE opus_int16 silk_RSHIFT16(opus_int16 a, opus_int32 shift){
370     ops_count += 1;
371     return a >> shift;
372 }
373 #undef    silk_RSHIFT32
374 static OPUS_INLINE opus_int32 silk_RSHIFT32(opus_int32 a, opus_int32 shift){
375     ops_count += 1;
376     return a >> shift;
377 }
378 #undef    silk_RSHIFT64
379 static OPUS_INLINE opus_int64 silk_RSHIFT64(opus_int64 a, opus_int64 shift){
380     ops_count += 1;
381     return a >> shift;
382 }
383
384 #undef    silk_RSHIFT_uint
385 static OPUS_INLINE opus_uint32 silk_RSHIFT_uint(opus_uint32 a, opus_int32 shift){
386     ops_count += 1;
387     return a >> shift;
388 }
389
390 #undef    silk_ADD_LSHIFT
391 static OPUS_INLINE opus_int32 silk_ADD_LSHIFT(opus_int32 a, opus_int32 b, opus_int32 shift){
392     opus_int32 ret;
393     ops_count += 1;
394     ret = a + (b << shift);
395     return ret;                /* shift >= 0*/
396 }
397 #undef    silk_ADD_LSHIFT32
398 static OPUS_INLINE opus_int32 silk_ADD_LSHIFT32(opus_int32 a, opus_int32 b, opus_int32 shift){
399     opus_int32 ret;
400     ops_count += 1;
401     ret = a + (b << shift);
402     return ret;                /* shift >= 0*/
403 }
404 #undef    silk_ADD_LSHIFT_uint
405 static OPUS_INLINE opus_uint32 silk_ADD_LSHIFT_uint(opus_uint32 a, opus_uint32 b, opus_int32 shift){
406     opus_uint32 ret;
407     ops_count += 1;
408     ret = a + (b << shift);
409     return ret;                /* shift >= 0*/
410 }
411 #undef    silk_ADD_RSHIFT
412 static OPUS_INLINE opus_int32 silk_ADD_RSHIFT(opus_int32 a, opus_int32 b, opus_int32 shift){
413     opus_int32 ret;
414     ops_count += 1;
415     ret = a + (b >> shift);
416     return ret;                /* shift  > 0*/
417 }
418 #undef    silk_ADD_RSHIFT32
419 static OPUS_INLINE opus_int32 silk_ADD_RSHIFT32(opus_int32 a, opus_int32 b, opus_int32 shift){
420     opus_int32 ret;
421     ops_count += 1;
422     ret = a + (b >> shift);
423     return ret;                /* shift  > 0*/
424 }
425 #undef    silk_ADD_RSHIFT_uint
426 static OPUS_INLINE opus_uint32 silk_ADD_RSHIFT_uint(opus_uint32 a, opus_uint32 b, opus_int32 shift){
427     opus_uint32 ret;
428     ops_count += 1;
429     ret = a + (b >> shift);
430     return ret;                /* shift  > 0*/
431 }
432 #undef    silk_SUB_LSHIFT32
433 static OPUS_INLINE opus_int32 silk_SUB_LSHIFT32(opus_int32 a, opus_int32 b, opus_int32 shift){
434     opus_int32 ret;
435     ops_count += 1;
436     ret = a - (b << shift);
437     return ret;                /* shift >= 0*/
438 }
439 #undef    silk_SUB_RSHIFT32
440 static OPUS_INLINE opus_int32 silk_SUB_RSHIFT32(opus_int32 a, opus_int32 b, opus_int32 shift){
441     opus_int32 ret;
442     ops_count += 1;
443     ret = a - (b >> shift);
444     return ret;                /* shift  > 0*/
445 }
446
447 #undef    silk_RSHIFT_ROUND
448 static OPUS_INLINE opus_int32 silk_RSHIFT_ROUND(opus_int32 a, opus_int32 shift){
449     opus_int32 ret;
450     ops_count += 3;
451     ret = shift == 1 ? (a >> 1) + (a & 1) : ((a >> (shift - 1)) + 1) >> 1;
452     return ret;
453 }
454
455 #undef    silk_RSHIFT_ROUND64
456 static OPUS_INLINE opus_int64 silk_RSHIFT_ROUND64(opus_int64 a, opus_int32 shift){
457     opus_int64 ret;
458     ops_count += 6;
459     ret = shift == 1 ? (a >> 1) + (a & 1) : ((a >> (shift - 1)) + 1) >> 1;
460     return ret;
461 }
462
463 #undef    silk_abs_int64
464 static OPUS_INLINE opus_int64 silk_abs_int64(opus_int64 a){
465     ops_count += 1;
466     return (((a) >  0)  ? (a) : -(a));            /* Be careful, silk_abs returns wrong when input equals to silk_intXX_MIN*/
467 }
468
469 #undef    silk_abs_int32
470 static OPUS_INLINE opus_int32 silk_abs_int32(opus_int32 a){
471     ops_count += 1;
472     return silk_abs(a);
473 }
474
475
476 #undef silk_min
477 static silk_min(a, b){
478     ops_count += 1;
479     return (((a) < (b)) ? (a) :  (b));
480 }
481 #undef silk_max
482 static silk_max(a, b){
483     ops_count += 1;
484     return (((a) > (b)) ? (a) :  (b));
485 }
486 #undef silk_sign
487 static silk_sign(a){
488     ops_count += 1;
489     return ((a) > 0 ? 1 : ( (a) < 0 ? -1 : 0 ));
490 }
491
492 #undef    silk_ADD16
493 static OPUS_INLINE opus_int16 silk_ADD16(opus_int16 a, opus_int16 b){
494     opus_int16 ret;
495     ops_count += 1;
496     ret = a + b;
497     return ret;
498 }
499
500 #undef    silk_ADD32
501 static OPUS_INLINE opus_int32 silk_ADD32(opus_int32 a, opus_int32 b){
502     opus_int32 ret;
503     ops_count += 1;
504     ret = a + b;
505     return ret;
506 }
507
508 #undef    silk_ADD64
509 static OPUS_INLINE opus_int64 silk_ADD64(opus_int64 a, opus_int64 b){
510     opus_int64 ret;
511     ops_count += 2;
512     ret = a + b;
513     return ret;
514 }
515
516 #undef    silk_SUB16
517 static OPUS_INLINE opus_int16 silk_SUB16(opus_int16 a, opus_int16 b){
518     opus_int16 ret;
519     ops_count += 1;
520     ret = a - b;
521     return ret;
522 }
523
524 #undef    silk_SUB32
525 static OPUS_INLINE opus_int32 silk_SUB32(opus_int32 a, opus_int32 b){
526     opus_int32 ret;
527     ops_count += 1;
528     ret = a - b;
529     return ret;
530 }
531
532 #undef    silk_SUB64
533 static OPUS_INLINE opus_int64 silk_SUB64(opus_int64 a, opus_int64 b){
534     opus_int64 ret;
535     ops_count += 2;
536     ret = a - b;
537     return ret;
538 }
539
540 #undef silk_ADD_SAT16
541 static OPUS_INLINE opus_int16 silk_ADD_SAT16( opus_int16 a16, opus_int16 b16 ) {
542     opus_int16 res;
543     /* Nb will be counted in AKP_add32 and silk_SAT16*/
544     res = (opus_int16)silk_SAT16( silk_ADD32( (opus_int32)(a16), (b16) ) );
545     return res;
546 }
547
548 #undef silk_ADD_SAT32
549 static OPUS_INLINE opus_int32 silk_ADD_SAT32(opus_int32 a32, opus_int32 b32){
550     opus_int32 res;
551     ops_count += 1;
552     res =    ((((a32) + (b32)) & 0x80000000) == 0 ?                                    \
553             ((((a32) & (b32)) & 0x80000000) != 0 ? silk_int32_MIN : (a32)+(b32)) :    \
554             ((((a32) | (b32)) & 0x80000000) == 0 ? silk_int32_MAX : (a32)+(b32)) );
555     return res;
556 }
557
558 #undef silk_ADD_SAT64
559 static OPUS_INLINE opus_int64 silk_ADD_SAT64( opus_int64 a64, opus_int64 b64 ) {
560     opus_int64 res;
561     ops_count += 1;
562     res =    ((((a64) + (b64)) & 0x8000000000000000LL) == 0 ?                                \
563             ((((a64) & (b64)) & 0x8000000000000000LL) != 0 ? silk_int64_MIN : (a64)+(b64)) :    \
564             ((((a64) | (b64)) & 0x8000000000000000LL) == 0 ? silk_int64_MAX : (a64)+(b64)) );
565     return res;
566 }
567
568 #undef silk_SUB_SAT16
569 static OPUS_INLINE opus_int16 silk_SUB_SAT16( opus_int16 a16, opus_int16 b16 ) {
570     opus_int16 res;
571     silk_assert(0);
572     /* Nb will be counted in sub-macros*/
573     res = (opus_int16)silk_SAT16( silk_SUB32( (opus_int32)(a16), (b16) ) );
574     return res;
575 }
576
577 #undef silk_SUB_SAT32
578 static OPUS_INLINE opus_int32 silk_SUB_SAT32( opus_int32 a32, opus_int32 b32 ) {
579     opus_int32 res;
580     ops_count += 1;
581     res =     ((((a32)-(b32)) & 0x80000000) == 0 ?                                            \
582             (( (a32) & ((b32)^0x80000000) & 0x80000000) ? silk_int32_MIN : (a32)-(b32)) :    \
583             ((((a32)^0x80000000) & (b32)  & 0x80000000) ? silk_int32_MAX : (a32)-(b32)) );
584     return res;
585 }
586
587 #undef silk_SUB_SAT64
588 static OPUS_INLINE opus_int64 silk_SUB_SAT64( opus_int64 a64, opus_int64 b64 ) {
589     opus_int64 res;
590     ops_count += 1;
591     res =    ((((a64)-(b64)) & 0x8000000000000000LL) == 0 ?                                                        \
592             (( (a64) & ((b64)^0x8000000000000000LL) & 0x8000000000000000LL) ? silk_int64_MIN : (a64)-(b64)) :    \
593             ((((a64)^0x8000000000000000LL) & (b64)  & 0x8000000000000000LL) ? silk_int64_MAX : (a64)-(b64)) );
594
595     return res;
596 }
597
598 #undef    silk_SMULWW
599 static OPUS_INLINE opus_int32 silk_SMULWW(opus_int32 a32, opus_int32 b32){
600     opus_int32 ret;
601     /* Nb will be counted in sub-macros*/
602     ret = silk_MLA(silk_SMULWB((a32), (b32)), (a32), silk_RSHIFT_ROUND((b32), 16));
603     return ret;
604 }
605
606 #undef    silk_SMLAWW
607 static OPUS_INLINE opus_int32 silk_SMLAWW(opus_int32 a32, opus_int32 b32, opus_int32 c32){
608     opus_int32 ret;
609     /* Nb will be counted in sub-macros*/
610     ret = silk_MLA(silk_SMLAWB((a32), (b32), (c32)), (b32), silk_RSHIFT_ROUND((c32), 16));
611     return ret;
612 }
613
614 #undef    silk_min_int
615 static OPUS_INLINE opus_int silk_min_int(opus_int a, opus_int b)
616 {
617     ops_count += 1;
618     return (((a) < (b)) ? (a) : (b));
619 }
620
621 #undef    silk_min_16
622 static OPUS_INLINE opus_int16 silk_min_16(opus_int16 a, opus_int16 b)
623 {
624     ops_count += 1;
625     return (((a) < (b)) ? (a) : (b));
626 }
627 #undef    silk_min_32
628 static OPUS_INLINE opus_int32 silk_min_32(opus_int32 a, opus_int32 b)
629 {
630     ops_count += 1;
631     return (((a) < (b)) ? (a) : (b));
632 }
633 #undef    silk_min_64
634 static OPUS_INLINE opus_int64 silk_min_64(opus_int64 a, opus_int64 b)
635 {
636     ops_count += 1;
637     return (((a) < (b)) ? (a) : (b));
638 }
639
640 /* silk_min() versions with typecast in the function call */
641 #undef    silk_max_int
642 static OPUS_INLINE opus_int silk_max_int(opus_int a, opus_int b)
643 {
644     ops_count += 1;
645     return (((a) > (b)) ? (a) : (b));
646 }
647 #undef    silk_max_16
648 static OPUS_INLINE opus_int16 silk_max_16(opus_int16 a, opus_int16 b)
649 {
650     ops_count += 1;
651     return (((a) > (b)) ? (a) : (b));
652 }
653 #undef    silk_max_32
654 static OPUS_INLINE opus_int32 silk_max_32(opus_int32 a, opus_int32 b)
655 {
656     ops_count += 1;
657     return (((a) > (b)) ? (a) : (b));
658 }
659
660 #undef    silk_max_64
661 static OPUS_INLINE opus_int64 silk_max_64(opus_int64 a, opus_int64 b)
662 {
663     ops_count += 1;
664     return (((a) > (b)) ? (a) : (b));
665 }
666
667
668 #undef silk_LIMIT_int
669 static OPUS_INLINE opus_int silk_LIMIT_int(opus_int a, opus_int limit1, opus_int limit2)
670 {
671     opus_int ret;
672     ops_count += 6;
673
674     ret = ((limit1) > (limit2) ? ((a) > (limit1) ? (limit1) : ((a) < (limit2) ? (limit2) : (a))) \
675         : ((a) > (limit2) ? (limit2) : ((a) < (limit1) ? (limit1) : (a))));
676
677     return(ret);
678 }
679
680 #undef silk_LIMIT_16
681 static OPUS_INLINE opus_int16 silk_LIMIT_16(opus_int16 a, opus_int16 limit1, opus_int16 limit2)
682 {
683     opus_int16 ret;
684     ops_count += 6;
685
686     ret = ((limit1) > (limit2) ? ((a) > (limit1) ? (limit1) : ((a) < (limit2) ? (limit2) : (a))) \
687         : ((a) > (limit2) ? (limit2) : ((a) < (limit1) ? (limit1) : (a))));
688
689 return(ret);
690 }
691
692
693 #undef silk_LIMIT_32
694 static OPUS_INLINE opus_int silk_LIMIT_32(opus_int32 a, opus_int32 limit1, opus_int32 limit2)
695 {
696     opus_int32 ret;
697     ops_count += 6;
698
699     ret = ((limit1) > (limit2) ? ((a) > (limit1) ? (limit1) : ((a) < (limit2) ? (limit2) : (a))) \
700         : ((a) > (limit2) ? (limit2) : ((a) < (limit1) ? (limit1) : (a))));
701     return(ret);
702 }
703
704 #else
705 #define varDefine
706 #define silk_SaveCount()
707
708 #endif
709 #endif
710