Fix dump_modes for the api change and move it into a subdirectory
[opus.git] / silk / silk_MacroDebug.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_DEBUG_H_
29 #define _SIGPROCFIX_API_DEBUG_H_
30
31 /* Redefine macro functions with extensive assertion in Win32_DEBUG mode.
32    As function can't be undefined, this file can't work with SigProcFIX_MacroCount.h */
33
34 #if 0 && defined (_WIN32) && defined (_DEBUG) && !defined (SKP_MACRO_COUNT)
35
36 #undef    SKP_ADD16
37 static inline opus_int16 SKP_ADD16(opus_int16 a, opus_int16 b){
38     opus_int16 ret;
39
40     ret = a + b;
41     SKP_assert( ret == SKP_ADD_SAT16( a, b ));
42     return ret;
43 }
44
45 #undef    SKP_ADD32
46 static inline opus_int32 SKP_ADD32(opus_int32 a, opus_int32 b){
47     opus_int32 ret;
48
49     ret = a + b;
50     SKP_assert( ret == SKP_ADD_SAT32( a, b ));
51     return ret;
52 }
53
54 #undef    SKP_ADD64
55 static inline opus_int64 SKP_ADD64(opus_int64 a, opus_int64 b){
56     opus_int64 ret;
57
58     ret = a + b;
59     SKP_assert( ret == SKP_ADD_SAT64( a, b ));
60     return ret;
61 }
62
63 #undef    SKP_SUB16
64 static inline opus_int16 SKP_SUB16(opus_int16 a, opus_int16 b){
65     opus_int16 ret;
66
67     ret = a - b;
68     SKP_assert( ret == SKP_SUB_SAT16( a, b ));
69     return ret;
70 }
71
72 #undef    SKP_SUB32
73 static inline opus_int32 SKP_SUB32(opus_int32 a, opus_int32 b){
74     opus_int32 ret;
75
76     ret = a - b;
77     SKP_assert( ret == SKP_SUB_SAT32( a, b ));
78     return ret;
79 }
80
81 #undef    SKP_SUB64
82 static inline opus_int64 SKP_SUB64(opus_int64 a, opus_int64 b){
83     opus_int64 ret;
84
85     ret = a - b;
86     SKP_assert( ret == SKP_SUB_SAT64( a, b ));
87     return ret;
88 }
89
90 #undef SKP_ADD_SAT16
91 static inline opus_int16 SKP_ADD_SAT16( opus_int16 a16, opus_int16 b16 ) {
92     opus_int16 res;
93     res = (opus_int16)SKP_SAT16( SKP_ADD32( (opus_int32)(a16), (b16) ) );
94     SKP_assert( res == SKP_SAT16( ( opus_int32 )a16 + ( opus_int32 )b16 ) );
95     return res;
96 }
97
98 #undef SKP_ADD_SAT32
99 static inline opus_int32 SKP_ADD_SAT32(opus_int32 a32, opus_int32 b32){
100     opus_int32 res;
101     res =    ((((a32) + (b32)) & 0x80000000) == 0 ?                                    \
102             ((((a32) & (b32)) & 0x80000000) != 0 ? SKP_int32_MIN : (a32)+(b32)) :    \
103             ((((a32) | (b32)) & 0x80000000) == 0 ? SKP_int32_MAX : (a32)+(b32)) );
104     SKP_assert( res == SKP_SAT32( ( opus_int64 )a32 + ( opus_int64 )b32 ) );
105     return res;
106 }
107
108 #undef SKP_ADD_SAT64
109 static inline opus_int64 SKP_ADD_SAT64( opus_int64 a64, opus_int64 b64 ) {
110     opus_int64 res;
111     res =    ((((a64) + (b64)) & 0x8000000000000000LL) == 0 ?                                \
112             ((((a64) & (b64)) & 0x8000000000000000LL) != 0 ? SKP_int64_MIN : (a64)+(b64)) :    \
113             ((((a64) | (b64)) & 0x8000000000000000LL) == 0 ? SKP_int64_MAX : (a64)+(b64)) );
114     if( res != a64 + b64 ) {
115         /* Check that we saturated to the correct extreme value */
116         SKP_assert( ( res == SKP_int64_MAX && ( ( a64 >> 1 ) + ( b64 >> 1 ) > ( SKP_int64_MAX >> 3 ) ) ) ||
117                     ( res == SKP_int64_MIN && ( ( a64 >> 1 ) + ( b64 >> 1 ) < ( SKP_int64_MIN >> 3 ) ) ) );
118     } else {
119         /* Saturation not necessary */
120         SKP_assert( res == a64 + b64 );
121     }
122     return res;
123 }
124
125 #undef SKP_SUB_SAT16
126 static inline opus_int16 SKP_SUB_SAT16( opus_int16 a16, opus_int16 b16 ) {
127     opus_int16 res;
128     res = (opus_int16)SKP_SAT16( SKP_SUB32( (opus_int32)(a16), (b16) ) );
129     SKP_assert( res == SKP_SAT16( ( opus_int32 )a16 - ( opus_int32 )b16 ) );
130     return res;
131 }
132
133 #undef SKP_SUB_SAT32
134 static inline opus_int32 SKP_SUB_SAT32( opus_int32 a32, opus_int32 b32 ) {
135     opus_int32 res;
136     res =     ((((a32)-(b32)) & 0x80000000) == 0 ?                                            \
137             (( (a32) & ((b32)^0x80000000) & 0x80000000) ? SKP_int32_MIN : (a32)-(b32)) :    \
138             ((((a32)^0x80000000) & (b32)  & 0x80000000) ? SKP_int32_MAX : (a32)-(b32)) );
139     SKP_assert( res == SKP_SAT32( ( opus_int64 )a32 - ( opus_int64 )b32 ) );
140     return res;
141 }
142
143 #undef SKP_SUB_SAT64
144 static inline opus_int64 SKP_SUB_SAT64( opus_int64 a64, opus_int64 b64 ) {
145     opus_int64 res;
146     res =    ((((a64)-(b64)) & 0x8000000000000000LL) == 0 ?                                                        \
147             (( (a64) & ((b64)^0x8000000000000000LL) & 0x8000000000000000LL) ? SKP_int64_MIN : (a64)-(b64)) :    \
148             ((((a64)^0x8000000000000000LL) & (b64)  & 0x8000000000000000LL) ? SKP_int64_MAX : (a64)-(b64)) );
149
150     if( res != a64 - b64 ) {
151         /* Check that we saturated to the correct extreme value */
152         SKP_assert( ( res == SKP_int64_MAX && ( ( a64 >> 1 ) + ( b64 >> 1 ) > ( SKP_int64_MAX >> 3 ) ) ) ||
153                     ( res == SKP_int64_MIN && ( ( a64 >> 1 ) + ( b64 >> 1 ) < ( SKP_int64_MIN >> 3 ) ) ) );
154     } else {
155         /* Saturation not necessary */
156         SKP_assert( res == a64 - b64 );
157     }
158     return res;
159 }
160
161 #undef SKP_MUL
162 static inline opus_int32 SKP_MUL(opus_int32 a32, opus_int32 b32){
163     opus_int32 ret;
164     opus_int64 ret64; /* Will easily show how many bits that are needed */
165     ret = a32 * b32;
166     ret64 = (opus_int64)a32 * (opus_int64)b32;
167     SKP_assert((opus_int64)ret == ret64 );        /* Check output overflow */
168     return ret;
169 }
170
171 #undef SKP_MUL_uint
172 static inline opus_uint32 SKP_MUL_uint(opus_uint32 a32, opus_uint32 b32){
173     opus_uint32 ret;
174     ret = a32 * b32;
175     SKP_assert((opus_uint64)ret == (opus_uint64)a32 * (opus_uint64)b32);        /* Check output overflow */
176     return ret;
177 }
178 #undef SKP_MLA
179 static inline opus_int32 SKP_MLA(opus_int32 a32, opus_int32 b32, opus_int32 c32){
180     opus_int32 ret;
181     ret = a32 + b32 * c32;
182     SKP_assert((opus_int64)ret == (opus_int64)a32 + (opus_int64)b32 * (opus_int64)c32);    /* Check output overflow */
183     return ret;
184 }
185
186 #undef SKP_MLA_uint
187 static inline opus_int32 SKP_MLA_uint(opus_uint32 a32, opus_uint32 b32, opus_uint32 c32){
188     opus_uint32 ret;
189     ret = a32 + b32 * c32;
190     SKP_assert((opus_int64)ret == (opus_int64)a32 + (opus_int64)b32 * (opus_int64)c32);    /* Check output overflow */
191     return ret;
192 }
193
194 #undef    SKP_SMULWB
195 static inline opus_int32 SKP_SMULWB(opus_int32 a32, opus_int32 b32){
196     opus_int32 ret;
197     ret = (a32 >> 16) * (opus_int32)((opus_int16)b32) + (((a32 & 0x0000FFFF) * (opus_int32)((opus_int16)b32)) >> 16);
198     SKP_assert((opus_int64)ret == ((opus_int64)a32 * (opus_int16)b32) >> 16);
199     return ret;
200 }
201 #undef    SKP_SMLAWB
202 static inline opus_int32 SKP_SMLAWB(opus_int32 a32, opus_int32 b32, opus_int32 c32){
203     opus_int32 ret;
204     ret = SKP_ADD32( a32, SKP_SMULWB( b32, c32 ) );
205     SKP_assert(SKP_ADD32( a32, SKP_SMULWB( b32, c32 ) ) == SKP_ADD_SAT32( a32, SKP_SMULWB( b32, c32 ) ));
206     return ret;
207 }
208
209 #undef SKP_SMULWT
210 static inline opus_int32 SKP_SMULWT(opus_int32 a32, opus_int32 b32){
211     opus_int32 ret;
212     ret = (a32 >> 16) * (b32 >> 16) + (((a32 & 0x0000FFFF) * (b32 >> 16)) >> 16);
213     SKP_assert((opus_int64)ret == ((opus_int64)a32 * (b32 >> 16)) >> 16);
214     return ret;
215 }
216 #undef SKP_SMLAWT
217 static inline opus_int32 SKP_SMLAWT(opus_int32 a32, opus_int32 b32, opus_int32 c32){
218     opus_int32 ret;
219     ret = a32 + ((b32 >> 16) * (c32 >> 16)) + (((b32 & 0x0000FFFF) * ((c32 >> 16)) >> 16));
220     SKP_assert((opus_int64)ret == (opus_int64)a32 + (((opus_int64)b32 * (c32 >> 16)) >> 16));
221     return ret;
222 }
223
224 #undef SKP_SMULL
225 static inline opus_int64 SKP_SMULL(opus_int64 a64, opus_int64 b64){
226     opus_int64 ret64;
227     ret64 = a64 * b64;
228     if( b64 != 0 ) {
229         SKP_assert( a64 == (ret64 / b64) );
230     } else if( a64 != 0 ) {
231         SKP_assert( b64 == (ret64 / a64) );
232     }
233     return ret64;
234 }
235
236 /* no checking needed for SKP_SMULBB */
237 #undef    SKP_SMLABB
238 static inline opus_int32 SKP_SMLABB(opus_int32 a32, opus_int32 b32, opus_int32 c32){
239     opus_int32 ret;
240     ret = a32 + (opus_int32)((opus_int16)b32) * (opus_int32)((opus_int16)c32);
241     SKP_assert((opus_int64)ret == (opus_int64)a32 + (opus_int64)b32 * (opus_int16)c32);
242     return ret;
243 }
244
245 /* no checking needed for SKP_SMULBT */
246 #undef    SKP_SMLABT
247 static inline opus_int32 SKP_SMLABT(opus_int32 a32, opus_int32 b32, opus_int32 c32){
248     opus_int32 ret;
249     ret = a32 + ((opus_int32)((opus_int16)b32)) * (c32 >> 16);
250     SKP_assert((opus_int64)ret == (opus_int64)a32 + (opus_int64)b32 * (c32 >> 16));
251     return ret;
252 }
253
254 /* no checking needed for SKP_SMULTT */
255 #undef    SKP_SMLATT
256 static inline opus_int32 SKP_SMLATT(opus_int32 a32, opus_int32 b32, opus_int32 c32){
257     opus_int32 ret;
258     ret = a32 + (b32 >> 16) * (c32 >> 16);
259     SKP_assert((opus_int64)ret == (opus_int64)a32 + (b32 >> 16) * (c32 >> 16));
260     return ret;
261 }
262
263 #undef    SKP_SMULWW
264 static inline opus_int32 SKP_SMULWW(opus_int32 a32, opus_int32 b32){
265     opus_int32 ret, tmp1, tmp2;
266     opus_int64 ret64;
267
268     ret  = SKP_SMULWB( a32, b32 );
269     tmp1 = SKP_RSHIFT_ROUND( b32, 16 );
270     tmp2 = SKP_MUL( a32, tmp1 );
271
272     SKP_assert( (opus_int64)tmp2 == (opus_int64) a32 * (opus_int64) tmp1 );
273
274     tmp1 = ret;
275     ret  = SKP_ADD32( tmp1, tmp2 );
276     SKP_assert( SKP_ADD32( tmp1, tmp2 ) == SKP_ADD_SAT32( tmp1, tmp2 ) );
277
278     ret64 = SKP_RSHIFT64( SKP_SMULL( a32, b32 ), 16 );
279     SKP_assert( (opus_int64)ret == ret64 );
280
281     return ret;
282 }
283
284 #undef    SKP_SMLAWW
285 static inline opus_int32 SKP_SMLAWW(opus_int32 a32, opus_int32 b32, opus_int32 c32){
286     opus_int32 ret, tmp;
287
288     tmp = SKP_SMULWW( b32, c32 );
289     ret = SKP_ADD32( a32, tmp );
290     SKP_assert( ret == SKP_ADD_SAT32( a32, tmp ) );
291     return ret;
292 }
293
294 /* multiply-accumulate macros that allow overflow in the addition (ie, no asserts in debug mode) */
295 #undef    SKP_MLA_ovflw
296 #define SKP_MLA_ovflw(a32, b32, c32)    ((a32) + ((b32) * (c32)))
297 #undef    SKP_SMLABB_ovflw
298 #define SKP_SMLABB_ovflw(a32, b32, c32)    ((a32) + ((opus_int32)((opus_int16)(b32))) * (opus_int32)((opus_int16)(c32)))
299 #undef    SKP_SMLABT_ovflw
300 #define SKP_SMLABT_ovflw(a32, b32, c32)    ((a32) + ((opus_int32)((opus_int16)(b32))) * ((c32) >> 16))
301 #undef    SKP_SMLATT_ovflw
302 #define SKP_SMLATT_ovflw(a32, b32, c32)    ((a32) + ((b32) >> 16) * ((c32) >> 16))
303 #undef    SKP_SMLAWB_ovflw
304 #define SKP_SMLAWB_ovflw(a32, b32, c32)    ((a32) + ((((b32) >> 16) * (opus_int32)((opus_int16)(c32))) + ((((b32) & 0x0000FFFF) * (opus_int32)((opus_int16)(c32))) >> 16)))
305 #undef    SKP_SMLAWT_ovflw
306 #define SKP_SMLAWT_ovflw(a32, b32, c32)    ((a32) + (((b32) >> 16) * ((c32) >> 16)) + ((((b32) & 0x0000FFFF) * ((c32) >> 16)) >> 16))
307
308 /* no checking needed for SKP_SMULL
309    no checking needed for SKP_SMLAL
310    no checking needed for SKP_SMLALBB
311    no checking needed for SigProcFIX_CLZ16
312    no checking needed for SigProcFIX_CLZ32*/
313
314 #undef SKP_DIV32
315 static inline opus_int32 SKP_DIV32(opus_int32 a32, opus_int32 b32){
316     SKP_assert( b32 != 0 );
317     return a32 / b32;
318 }
319
320 #undef SKP_DIV32_16
321 static inline opus_int32 SKP_DIV32_16(opus_int32 a32, opus_int32 b32){
322     SKP_assert( b32 != 0 );
323     SKP_assert( b32 <= SKP_int16_MAX );
324     SKP_assert( b32 >= SKP_int16_MIN );
325     return a32 / b32;
326 }
327
328 /* no checking needed for SKP_SAT8
329    no checking needed for SKP_SAT16
330    no checking needed for SKP_SAT32
331    no checking needed for SKP_POS_SAT32
332    no checking needed for SKP_ADD_POS_SAT8
333    no checking needed for SKP_ADD_POS_SAT16
334    no checking needed for SKP_ADD_POS_SAT32
335    no checking needed for SKP_ADD_POS_SAT64 */
336 #undef    SKP_LSHIFT8
337 static inline opus_int8 SKP_LSHIFT8(opus_int8 a, opus_int32 shift){
338     opus_int8 ret;
339     ret = a << shift;
340     SKP_assert(shift >= 0);
341     SKP_assert(shift < 8);
342     SKP_assert((opus_int64)ret == ((opus_int64)a) << shift);
343     return ret;
344 }
345 #undef    SKP_LSHIFT16
346 static inline opus_int16 SKP_LSHIFT16(opus_int16 a, opus_int32 shift){
347     opus_int16 ret;
348     ret = a << shift;
349     SKP_assert(shift >= 0);
350     SKP_assert(shift < 16);
351     SKP_assert((opus_int64)ret == ((opus_int64)a) << shift);
352     return ret;
353 }
354 #undef    SKP_LSHIFT32
355 static inline opus_int32 SKP_LSHIFT32(opus_int32 a, opus_int32 shift){
356     opus_int32 ret;
357     ret = a << shift;
358     SKP_assert(shift >= 0);
359     SKP_assert(shift < 32);
360     SKP_assert((opus_int64)ret == ((opus_int64)a) << shift);
361     return ret;
362 }
363 #undef    SKP_LSHIFT64
364 static inline opus_int64 SKP_LSHIFT64(opus_int64 a, opus_int shift){
365     SKP_assert(shift >= 0);
366     SKP_assert(shift < 64);
367     return a << shift;
368 }
369
370 #undef    SKP_LSHIFT_ovflw
371 static inline opus_int32 SKP_LSHIFT_ovflw(opus_int32 a, opus_int32 shift){
372     SKP_assert(shift >= 0);            /* no check for overflow */
373     return a << shift;
374 }
375
376 #undef    SKP_LSHIFT_uint
377 static inline opus_uint32 SKP_LSHIFT_uint(opus_uint32 a, opus_int32 shift){
378     opus_uint32 ret;
379     ret = a << shift;
380     SKP_assert(shift >= 0);
381     SKP_assert((opus_int64)ret == ((opus_int64)a) << shift);
382     return ret;
383 }
384
385 #undef    SKP_RSHIFT8
386 static inline opus_int8 SKP_RSHIFT8(opus_int8 a, opus_int32 shift){
387     SKP_assert(shift >=  0);
388     SKP_assert(shift < 8);
389     return a >> shift;
390 }
391 #undef    SKP_RSHIFT16
392 static inline opus_int16 SKP_RSHIFT16(opus_int16 a, opus_int32 shift){
393     SKP_assert(shift >=  0);
394     SKP_assert(shift < 16);
395     return a >> shift;
396 }
397 #undef    SKP_RSHIFT32
398 static inline opus_int32 SKP_RSHIFT32(opus_int32 a, opus_int32 shift){
399     SKP_assert(shift >=  0);
400     SKP_assert(shift < 32);
401     return a >> shift;
402 }
403 #undef    SKP_RSHIFT64
404 static inline opus_int64 SKP_RSHIFT64(opus_int64 a, opus_int64 shift){
405     SKP_assert(shift >=  0);
406     SKP_assert(shift <= 63);
407     return a >> shift;
408 }
409
410 #undef    SKP_RSHIFT_uint
411 static inline opus_uint32 SKP_RSHIFT_uint(opus_uint32 a, opus_int32 shift){
412     SKP_assert(shift >=  0);
413     SKP_assert(shift <= 32);
414     return a >> shift;
415 }
416
417 #undef    SKP_ADD_LSHIFT
418 static inline opus_int32 SKP_ADD_LSHIFT(opus_int32 a, opus_int32 b, opus_int32 shift){
419     opus_int32 ret;
420     SKP_assert(shift >= 0);
421     SKP_assert(shift <= 31);
422     ret = a + (b << shift);
423     SKP_assert((opus_int64)ret == (opus_int64)a + (((opus_int64)b) << shift));
424     return ret;                /* shift >= 0 */
425 }
426 #undef    SKP_ADD_LSHIFT32
427 static inline opus_int32 SKP_ADD_LSHIFT32(opus_int32 a, opus_int32 b, opus_int32 shift){
428     opus_int32 ret;
429     SKP_assert(shift >= 0);
430     SKP_assert(shift <= 31);
431     ret = a + (b << shift);
432     SKP_assert((opus_int64)ret == (opus_int64)a + (((opus_int64)b) << shift));
433     return ret;                /* shift >= 0 */
434 }
435 #undef    SKP_ADD_LSHIFT_uint
436 static inline opus_uint32 SKP_ADD_LSHIFT_uint(opus_uint32 a, opus_uint32 b, opus_int32 shift){
437     opus_uint32 ret;
438     SKP_assert(shift >= 0);
439     SKP_assert(shift <= 32);
440     ret = a + (b << shift);
441     SKP_assert((opus_int64)ret == (opus_int64)a + (((opus_int64)b) << shift));
442     return ret;                /* shift >= 0 */
443 }
444 #undef    SKP_ADD_RSHIFT
445 static inline opus_int32 SKP_ADD_RSHIFT(opus_int32 a, opus_int32 b, opus_int32 shift){
446     opus_int32 ret;
447     SKP_assert(shift >= 0);
448     SKP_assert(shift <= 31);
449     ret = a + (b >> shift);
450     SKP_assert((opus_int64)ret == (opus_int64)a + (((opus_int64)b) >> shift));
451     return ret;                /* shift  > 0 */
452 }
453 #undef    SKP_ADD_RSHIFT32
454 static inline opus_int32 SKP_ADD_RSHIFT32(opus_int32 a, opus_int32 b, opus_int32 shift){
455     opus_int32 ret;
456     SKP_assert(shift >= 0);
457     SKP_assert(shift <= 31);
458     ret = a + (b >> shift);
459     SKP_assert((opus_int64)ret == (opus_int64)a + (((opus_int64)b) >> shift));
460     return ret;                /* shift  > 0 */
461 }
462 #undef    SKP_ADD_RSHIFT_uint
463 static inline opus_uint32 SKP_ADD_RSHIFT_uint(opus_uint32 a, opus_uint32 b, opus_int32 shift){
464     opus_uint32 ret;
465     SKP_assert(shift >= 0);
466     SKP_assert(shift <= 32);
467     ret = a + (b >> shift);
468     SKP_assert((opus_int64)ret == (opus_int64)a + (((opus_int64)b) >> shift));
469     return ret;                /* shift  > 0 */
470 }
471 #undef    SKP_SUB_LSHIFT32
472 static inline opus_int32 SKP_SUB_LSHIFT32(opus_int32 a, opus_int32 b, opus_int32 shift){
473     opus_int32 ret;
474     SKP_assert(shift >= 0);
475     SKP_assert(shift <= 31);
476     ret = a - (b << shift);
477     SKP_assert((opus_int64)ret == (opus_int64)a - (((opus_int64)b) << shift));
478     return ret;                /* shift >= 0 */
479 }
480 #undef    SKP_SUB_RSHIFT32
481 static inline opus_int32 SKP_SUB_RSHIFT32(opus_int32 a, opus_int32 b, opus_int32 shift){
482     opus_int32 ret;
483     SKP_assert(shift >= 0);
484     SKP_assert(shift <= 31);
485     ret = a - (b >> shift);
486     SKP_assert((opus_int64)ret == (opus_int64)a - (((opus_int64)b) >> shift));
487     return ret;                /* shift  > 0 */
488 }
489
490 #undef    SKP_RSHIFT_ROUND
491 static inline opus_int32 SKP_RSHIFT_ROUND(opus_int32 a, opus_int32 shift){
492     opus_int32 ret;
493     SKP_assert(shift > 0);        /* the marco definition can't handle a shift of zero */
494     SKP_assert(shift < 32);
495     ret = shift == 1 ? (a >> 1) + (a & 1) : ((a >> (shift - 1)) + 1) >> 1;
496     SKP_assert((opus_int64)ret == ((opus_int64)a + ((opus_int64)1 << (shift - 1))) >> shift);
497     return ret;
498 }
499
500 #undef    SKP_RSHIFT_ROUND64
501 static inline opus_int64 SKP_RSHIFT_ROUND64(opus_int64 a, opus_int32 shift){
502     opus_int64 ret;
503     SKP_assert(shift > 0);        /* the marco definition can't handle a shift of zero */
504     SKP_assert(shift < 64);
505     ret = shift == 1 ? (a >> 1) + (a & 1) : ((a >> (shift - 1)) + 1) >> 1;
506     return ret;
507 }
508
509 /* SKP_abs is used on floats also, so doesn't work... */
510 /*#undef    SKP_abs
511 static inline opus_int32 SKP_abs(opus_int32 a){
512     SKP_assert(a != 0x80000000);
513     return (((a) >  0)  ? (a) : -(a));            // Be careful, SKP_abs returns wrong when input equals to SKP_intXX_MIN
514 }*/
515
516 #undef    SKP_abs_int64
517 static inline opus_int64 SKP_abs_int64(opus_int64 a){
518     SKP_assert(a != 0x8000000000000000);
519     return (((a) >  0)  ? (a) : -(a));            /* Be careful, SKP_abs returns wrong when input equals to SKP_intXX_MIN */
520 }
521
522 #undef    SKP_abs_int32
523 static inline opus_int32 SKP_abs_int32(opus_int32 a){
524     SKP_assert(a != 0x80000000);
525     return abs(a);
526 }
527
528 #undef    SKP_CHECK_FIT8
529 static inline opus_int8 SKP_CHECK_FIT8( opus_int64 a ){
530     opus_int8 ret;
531     ret = (opus_int8)a;
532     SKP_assert( (opus_int64)ret == a );
533     return( ret );
534 }
535
536 #undef    SKP_CHECK_FIT16
537 static inline opus_int16 SKP_CHECK_FIT16( opus_int64 a ){
538     opus_int16 ret;
539     ret = (opus_int16)a;
540     SKP_assert( (opus_int64)ret == a );
541     return( ret );
542 }
543
544 #undef    SKP_CHECK_FIT32
545 static inline opus_int32 SKP_CHECK_FIT32( opus_int64 a ){
546     opus_int32 ret;
547     ret = (opus_int32)a;
548     SKP_assert( (opus_int64)ret == a );
549     return( ret );
550 }
551
552 /* no checking for SKP_NSHIFT_MUL_32_32
553    no checking for SKP_NSHIFT_MUL_16_16
554    no checking needed for SKP_min
555    no checking needed for SKP_max
556    no checking needed for SKP_sign
557 */
558
559 #endif
560 #endif