Eliminate some unreachable cases from the cwrs code and fixup the
[opus.git] / silk / 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, (subject to the limitations in the disclaimer below)
5 are permitted provided that the following conditions 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 Skype Limited, nor the names of specific
12 contributors, may be used to endorse or promote products derived from
13 this software without specific prior written permission.
14 NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED
15 BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
16 CONTRIBUTORS ''AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
17 BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
18 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19 COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
22 USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
23 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25 OF THIS SOFTWARE, EVEN IF ADVISED OF THE 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    SKP_MACRO_COUNT
33 #define varDefine opus_int64 ops_count = 0;
34
35 extern opus_int64 ops_count;
36
37 SKP_INLINE opus_int64 SKP_SaveCount(){
38     return(ops_count);
39 }
40
41 SKP_INLINE opus_int64 SKP_SaveResetCount(){
42     opus_int64 ret;
43
44     ret = ops_count;
45     ops_count = 0;
46     return(ret);
47 }
48
49 SKP_INLINE SKP_PrintCount(){
50     printf("ops_count = %d \n ", (opus_int32)ops_count);
51 }
52
53 #undef SKP_MUL
54 SKP_INLINE opus_int32 SKP_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 SKP_MUL_uint
62 SKP_INLINE opus_uint32 SKP_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 SKP_MLA
69 SKP_INLINE opus_int32 SKP_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 SKP_MLA_uint
77 SKP_INLINE opus_int32 SKP_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 SKP_SMULWB
85 SKP_INLINE opus_int32 SKP_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    SKP_SMLAWB
92 SKP_INLINE opus_int32 SKP_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 SKP_SMULWT
100 SKP_INLINE opus_int32 SKP_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 SKP_SMLAWT
107 SKP_INLINE opus_int32 SKP_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 SKP_SMULBB
115 SKP_INLINE opus_int32 SKP_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 SKP_SMLABB
122 SKP_INLINE opus_int32 SKP_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 SKP_SMULBT
130 SKP_INLINE opus_int32 SKP_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 SKP_SMLABT
138 SKP_INLINE opus_int32 SKP_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 SKP_SMULTT
146 SKP_INLINE opus_int32 SKP_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    SKP_SMLATT
154 SKP_INLINE opus_int32 SKP_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    SKP_MLA_ovflw
164 #define SKP_MLA_ovflw SKP_MLA
165
166 #undef SKP_SMLABB_ovflw
167 #define SKP_SMLABB_ovflw SKP_SMLABB
168
169 #undef SKP_SMLABT_ovflw
170 #define SKP_SMLABT_ovflw SKP_SMLABT
171
172 #undef SKP_SMLATT_ovflw
173 #define SKP_SMLATT_ovflw SKP_SMLATT
174
175 #undef SKP_SMLAWB_ovflw
176 #define SKP_SMLAWB_ovflw SKP_SMLAWB
177
178 #undef SKP_SMLAWT_ovflw
179 #define SKP_SMLAWT_ovflw SKP_SMLAWT
180
181 #undef SKP_SMULL
182 SKP_INLINE opus_int64 SKP_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    SKP_SMLAL
190 SKP_INLINE opus_int64 SKP_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    SKP_SMLALBB
197 SKP_INLINE opus_int64 SKP_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 SKP_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 SKP_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 SKP_DIV32
255 SKP_INLINE opus_int32 SKP_DIV32(opus_int32 a32, opus_int32 b32){
256     ops_count += 64;
257     return a32 / b32;
258 }
259
260 #undef SKP_DIV32_16
261 SKP_INLINE opus_int32 SKP_DIV32_16(opus_int32 a32, opus_int32 b32){
262     ops_count += 32;
263     return a32 / b32;
264 }
265
266 #undef SKP_SAT8
267 SKP_INLINE opus_int8 SKP_SAT8(opus_int64 a){
268     opus_int8 tmp;
269     ops_count += 1;
270     tmp = (opus_int8)((a) > SKP_int8_MAX ? SKP_int8_MAX  : \
271                     ((a) < SKP_int8_MIN ? SKP_int8_MIN  : (a)));
272     return(tmp);
273 }
274
275 #undef SKP_SAT16
276 SKP_INLINE opus_int16 SKP_SAT16(opus_int64 a){
277     opus_int16 tmp;
278     ops_count += 1;
279     tmp = (opus_int16)((a) > SKP_int16_MAX ? SKP_int16_MAX  : \
280                      ((a) < SKP_int16_MIN ? SKP_int16_MIN  : (a)));
281     return(tmp);
282 }
283 #undef SKP_SAT32
284 SKP_INLINE opus_int32 SKP_SAT32(opus_int64 a){
285     opus_int32 tmp;
286     ops_count += 1;
287     tmp = (opus_int32)((a) > SKP_int32_MAX ? SKP_int32_MAX  : \
288                      ((a) < SKP_int32_MIN ? SKP_int32_MIN  : (a)));
289     return(tmp);
290 }
291 #undef SKP_POS_SAT32
292 SKP_INLINE opus_int32 SKP_POS_SAT32(opus_int64 a){
293     opus_int32 tmp;
294     ops_count += 1;
295     tmp = (opus_int32)((a) > SKP_int32_MAX ? SKP_int32_MAX : (a));
296     return(tmp);
297 }
298
299 #undef SKP_ADD_POS_SAT8
300 SKP_INLINE opus_int8 SKP_ADD_POS_SAT8(opus_int64 a, opus_int64 b){
301     opus_int8 tmp;
302     ops_count += 1;
303     tmp = (opus_int8)((((a)+(b)) & 0x80) ? SKP_int8_MAX  : ((a)+(b)));
304     return(tmp);
305 }
306 #undef SKP_ADD_POS_SAT16
307 SKP_INLINE opus_int16 SKP_ADD_POS_SAT16(opus_int64 a, opus_int64 b){
308     opus_int16 tmp;
309     ops_count += 1;
310     tmp = (opus_int16)((((a)+(b)) & 0x8000) ? SKP_int16_MAX : ((a)+(b)));
311     return(tmp);
312 }
313
314 #undef SKP_ADD_POS_SAT32
315 SKP_INLINE opus_int32 SKP_ADD_POS_SAT32(opus_int64 a, opus_int64 b){
316     opus_int32 tmp;
317     ops_count += 1;
318     tmp = (opus_int32)((((a)+(b)) & 0x80000000) ? SKP_int32_MAX : ((a)+(b)));
319     return(tmp);
320 }
321
322 #undef SKP_ADD_POS_SAT64
323 SKP_INLINE opus_int64 SKP_ADD_POS_SAT64(opus_int64 a, opus_int64 b){
324     opus_int64 tmp;
325     ops_count += 1;
326     tmp = ((((a)+(b)) & 0x8000000000000000LL) ? SKP_int64_MAX : ((a)+(b)));
327     return(tmp);
328 }
329
330 #undef    SKP_LSHIFT8
331 SKP_INLINE opus_int8 SKP_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    SKP_LSHIFT16
338 SKP_INLINE opus_int16 SKP_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    SKP_LSHIFT32
345 SKP_INLINE opus_int32 SKP_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    SKP_LSHIFT64
352 SKP_INLINE opus_int64 SKP_LSHIFT64(opus_int64 a, opus_int shift){
353     ops_count += 1;
354     return a << shift;
355 }
356
357 #undef    SKP_LSHIFT_ovflw
358 SKP_INLINE opus_int32 SKP_LSHIFT_ovflw(opus_int32 a, opus_int32 shift){
359     ops_count += 1;
360     return a << shift;
361 }
362
363 #undef    SKP_LSHIFT_uint
364 SKP_INLINE opus_uint32 SKP_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    SKP_RSHIFT8
372 SKP_INLINE opus_int8 SKP_RSHIFT8(opus_int8 a, opus_int32 shift){
373     ops_count += 1;
374     return a >> shift;
375 }
376 #undef    SKP_RSHIFT16
377 SKP_INLINE opus_int16 SKP_RSHIFT16(opus_int16 a, opus_int32 shift){
378     ops_count += 1;
379     return a >> shift;
380 }
381 #undef    SKP_RSHIFT32
382 SKP_INLINE opus_int32 SKP_RSHIFT32(opus_int32 a, opus_int32 shift){
383     ops_count += 1;
384     return a >> shift;
385 }
386 #undef    SKP_RSHIFT64
387 SKP_INLINE opus_int64 SKP_RSHIFT64(opus_int64 a, opus_int64 shift){
388     ops_count += 1;
389     return a >> shift;
390 }
391
392 #undef    SKP_RSHIFT_uint
393 SKP_INLINE opus_uint32 SKP_RSHIFT_uint(opus_uint32 a, opus_int32 shift){
394     ops_count += 1;
395     return a >> shift;
396 }
397
398 #undef    SKP_ADD_LSHIFT
399 SKP_INLINE opus_int32 SKP_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    SKP_ADD_LSHIFT32
406 SKP_INLINE opus_int32 SKP_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    SKP_ADD_LSHIFT_uint
413 SKP_INLINE opus_uint32 SKP_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    SKP_ADD_RSHIFT
420 SKP_INLINE opus_int32 SKP_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    SKP_ADD_RSHIFT32
427 SKP_INLINE opus_int32 SKP_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    SKP_ADD_RSHIFT_uint
434 SKP_INLINE opus_uint32 SKP_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    SKP_SUB_LSHIFT32
441 SKP_INLINE opus_int32 SKP_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    SKP_SUB_RSHIFT32
448 SKP_INLINE opus_int32 SKP_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    SKP_RSHIFT_ROUND
456 SKP_INLINE opus_int32 SKP_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    SKP_RSHIFT_ROUND64
464 SKP_INLINE opus_int64 SKP_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    SKP_abs_int64
472 SKP_INLINE opus_int64 SKP_abs_int64(opus_int64 a){
473     ops_count += 1;
474     return (((a) >  0)  ? (a) : -(a));            // Be careful, SKP_abs returns wrong when input equals to SKP_intXX_MIN
475 }
476
477 #undef    SKP_abs_int32
478 SKP_INLINE opus_int32 SKP_abs_int32(opus_int32 a){
479     ops_count += 1;
480     return abs(a);
481 }
482
483
484 #undef SKP_min
485 static SKP_min(a, b){
486     ops_count += 1;
487     return (((a) < (b)) ? (a) :  (b));
488 }
489 #undef SKP_max
490 static SKP_max(a, b){
491     ops_count += 1;
492     return (((a) > (b)) ? (a) :  (b));
493 }
494 #undef SKP_sign
495 static SKP_sign(a){
496     ops_count += 1;
497     return ((a) > 0 ? 1 : ( (a) < 0 ? -1 : 0 ));
498 }
499
500 #undef    SKP_ADD16
501 SKP_INLINE opus_int16 SKP_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    SKP_ADD32
509 SKP_INLINE opus_int32 SKP_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    SKP_ADD64
517 SKP_INLINE opus_int64 SKP_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    SKP_SUB16
525 SKP_INLINE opus_int16 SKP_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    SKP_SUB32
533 SKP_INLINE opus_int32 SKP_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    SKP_SUB64
541 SKP_INLINE opus_int64 SKP_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 SKP_ADD_SAT16
549 SKP_INLINE opus_int16 SKP_ADD_SAT16( opus_int16 a16, opus_int16 b16 ) {
550     opus_int16 res;
551     // Nb will be counted in AKP_add32 and SKP_SAT16
552     res = (opus_int16)SKP_SAT16( SKP_ADD32( (opus_int32)(a16), (b16) ) );
553     return res;
554 }
555
556 #undef SKP_ADD_SAT32
557 SKP_INLINE opus_int32 SKP_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 ? SKP_int32_MIN : (a32)+(b32)) :    \
562             ((((a32) | (b32)) & 0x80000000) == 0 ? SKP_int32_MAX : (a32)+(b32)) );
563     return res;
564 }
565
566 #undef SKP_ADD_SAT64
567 SKP_INLINE opus_int64 SKP_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 ? SKP_int64_MIN : (a64)+(b64)) :    \
572             ((((a64) | (b64)) & 0x8000000000000000LL) == 0 ? SKP_int64_MAX : (a64)+(b64)) );
573     return res;
574 }
575
576 #undef SKP_SUB_SAT16
577 SKP_INLINE opus_int16 SKP_SUB_SAT16( opus_int16 a16, opus_int16 b16 ) {
578     opus_int16 res;
579     SKP_assert(0);
580     // Nb will be counted in sub-macros
581     res = (opus_int16)SKP_SAT16( SKP_SUB32( (opus_int32)(a16), (b16) ) );
582     return res;
583 }
584
585 #undef SKP_SUB_SAT32
586 SKP_INLINE opus_int32 SKP_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) ? SKP_int32_MIN : (a32)-(b32)) :    \
591             ((((a32)^0x80000000) & (b32)  & 0x80000000) ? SKP_int32_MAX : (a32)-(b32)) );
592     return res;
593 }
594
595 #undef SKP_SUB_SAT64
596 SKP_INLINE opus_int64 SKP_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) ? SKP_int64_MIN : (a64)-(b64)) :    \
601             ((((a64)^0x8000000000000000LL) & (b64)  & 0x8000000000000000LL) ? SKP_int64_MAX : (a64)-(b64)) );
602
603     return res;
604 }
605
606 #undef    SKP_SMULWW
607 SKP_INLINE opus_int32 SKP_SMULWW(opus_int32 a32, opus_int32 b32){
608     opus_int32 ret;
609     // Nb will be counted in sub-macros
610     ret = SKP_MLA(SKP_SMULWB((a32), (b32)), (a32), SKP_RSHIFT_ROUND((b32), 16));
611     return ret;
612 }
613
614 #undef    SKP_SMLAWW
615 SKP_INLINE opus_int32 SKP_SMLAWW(opus_int32 a32, opus_int32 b32, opus_int32 c32){
616     opus_int32 ret;
617     // Nb will be counted in sub-macros
618     ret = SKP_MLA(SKP_SMLAWB((a32), (b32), (c32)), (b32), SKP_RSHIFT_ROUND((c32), 16));
619     return ret;
620 }
621
622 #undef    SKP_min_int
623 SKP_INLINE opus_int SKP_min_int(opus_int a, opus_int b)
624 {
625     ops_count += 1;
626     return (((a) < (b)) ? (a) : (b));
627 }
628
629 #undef    SKP_min_16
630 SKP_INLINE opus_int16 SKP_min_16(opus_int16 a, opus_int16 b)
631 {
632     ops_count += 1;
633     return (((a) < (b)) ? (a) : (b));
634 }
635 #undef    SKP_min_32
636 SKP_INLINE opus_int32 SKP_min_32(opus_int32 a, opus_int32 b)
637 {
638     ops_count += 1;
639     return (((a) < (b)) ? (a) : (b));
640 }
641 #undef    SKP_min_64
642 SKP_INLINE opus_int64 SKP_min_64(opus_int64 a, opus_int64 b)
643 {
644     ops_count += 1;
645     return (((a) < (b)) ? (a) : (b));
646 }
647
648 /* SKP_min() versions with typecast in the function call */
649 #undef    SKP_max_int
650 SKP_INLINE opus_int SKP_max_int(opus_int a, opus_int b)
651 {
652     ops_count += 1;
653     return (((a) > (b)) ? (a) : (b));
654 }
655 #undef    SKP_max_16
656 SKP_INLINE opus_int16 SKP_max_16(opus_int16 a, opus_int16 b)
657 {
658     ops_count += 1;
659     return (((a) > (b)) ? (a) : (b));
660 }
661 #undef    SKP_max_32
662 SKP_INLINE opus_int32 SKP_max_32(opus_int32 a, opus_int32 b)
663 {
664     ops_count += 1;
665     return (((a) > (b)) ? (a) : (b));
666 }
667
668 #undef    SKP_max_64
669 SKP_INLINE opus_int64 SKP_max_64(opus_int64 a, opus_int64 b)
670 {
671     ops_count += 1;
672     return (((a) > (b)) ? (a) : (b));
673 }
674
675
676 #undef SKP_LIMIT_int
677 SKP_INLINE opus_int SKP_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 SKP_LIMIT_16
689 SKP_INLINE opus_int16 SKP_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 SKP_LIMIT_32
702 SKP_INLINE opus_int SKP_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 exVarDefine
714 #define varDefine
715 #define SKP_SaveCount()
716
717 #endif
718 #endif
719