License update using the IETF Trust flavour of the BSD on the Silk code
[opus.git] / 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, 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 MACRO_DEBUG_H
29 #define MACRO_DEBUG_H
30
31 /* Redefine macro functions with extensive assertion in DEBUG mode.
32    As functions can't be undefined, this file can't work with SigProcFIX_MacroCount.h */
33
34 #if 0 && defined (_DEBUG) && !defined (silk_MACRO_COUNT)
35
36 #undef silk_ADD16
37 static inline opus_int16 silk_ADD16(opus_int16 a, opus_int16 b){
38     opus_int16 ret;
39
40     ret = a + b;
41     silk_assert( ret == silk_ADD_SAT16( a, b ));
42     return ret;
43 }
44
45 #undef silk_ADD32
46 static inline opus_int32 silk_ADD32(opus_int32 a, opus_int32 b){
47     opus_int32 ret;
48
49     ret = a + b;
50     silk_assert( ret == silk_ADD_SAT32( a, b ));
51     return ret;
52 }
53
54 #undef silk_ADD64
55 static inline opus_int64 silk_ADD64(opus_int64 a, opus_int64 b){
56     opus_int64 ret;
57
58     ret = a + b;
59     silk_assert( ret == silk_ADD_SAT64( a, b ));
60     return ret;
61 }
62
63 #undef silk_SUB16
64 static inline opus_int16 silk_SUB16(opus_int16 a, opus_int16 b){
65     opus_int16 ret;
66
67     ret = a - b;
68     silk_assert( ret == silk_SUB_SAT16( a, b ));
69     return ret;
70 }
71
72 #undef silk_SUB32
73 static inline opus_int32 silk_SUB32(opus_int32 a, opus_int32 b){
74     opus_int32 ret;
75
76     ret = a - b;
77     silk_assert( ret == silk_SUB_SAT32( a, b ));
78     return ret;
79 }
80
81 #undef silk_SUB64
82 static inline opus_int64 silk_SUB64(opus_int64 a, opus_int64 b){
83     opus_int64 ret;
84
85     ret = a - b;
86     silk_assert( ret == silk_SUB_SAT64( a, b ));
87     return ret;
88 }
89
90 #undef silk_ADD_SAT16
91 static inline opus_int16 silk_ADD_SAT16( opus_int16 a16, opus_int16 b16 ) {
92     opus_int16 res;
93     res = (opus_int16)silk_SAT16( silk_ADD32( (opus_int32)(a16), (b16) ) );
94     silk_assert( res == silk_SAT16( (opus_int32)a16 + (opus_int32)b16 ) );
95     return res;
96 }
97
98 #undef silk_ADD_SAT32
99 static inline opus_int32 silk_ADD_SAT32(opus_int32 a32, opus_int32 b32){
100     opus_int32 res;
101     res =    ((((a32) + (b32)) & 0x80000000) == 0 ?                                   \
102             ((((a32) & (b32)) & 0x80000000) != 0 ? silk_int32_MIN : (a32)+(b32)) :    \
103             ((((a32) | (b32)) & 0x80000000) == 0 ? silk_int32_MAX : (a32)+(b32)) );
104     silk_assert( res == silk_SAT32( (opus_int64)a32 + (opus_int64)b32 ) );
105     return res;
106 }
107
108 #undef silk_ADD_SAT64
109 static inline opus_int64 silk_ADD_SAT64( opus_int64 a64, opus_int64 b64 ) {
110     opus_int64 res;
111     res =    ((((a64) + (b64)) & 0x8000000000000000LL) == 0 ?                                   \
112             ((((a64) & (b64)) & 0x8000000000000000LL) != 0 ? silk_int64_MIN : (a64)+(b64)) :    \
113             ((((a64) | (b64)) & 0x8000000000000000LL) == 0 ? silk_int64_MAX : (a64)+(b64)) );
114     if( res != a64 + b64 ) {
115         /* Check that we saturated to the correct extreme value */
116         silk_assert( ( res == silk_int64_MAX && ( ( a64 >> 1 ) + ( b64 >> 1 ) > ( silk_int64_MAX >> 3 ) ) ) ||
117                     ( res == silk_int64_MIN && ( ( a64 >> 1 ) + ( b64 >> 1 ) < ( silk_int64_MIN >> 3 ) ) ) );
118     } else {
119         /* Saturation not necessary */
120         silk_assert( res == a64 + b64 );
121     }
122     return res;
123 }
124
125 #undef silk_SUB_SAT16
126 static inline opus_int16 silk_SUB_SAT16( opus_int16 a16, opus_int16 b16 ) {
127     opus_int16 res;
128     res = (opus_int16)silk_SAT16( silk_SUB32( (opus_int32)(a16), (b16) ) );
129     silk_assert( res == silk_SAT16( (opus_int32)a16 - (opus_int32)b16 ) );
130     return res;
131 }
132
133 #undef silk_SUB_SAT32
134 static inline opus_int32 silk_SUB_SAT32( opus_int32 a32, opus_int32 b32 ) {
135     opus_int32 res;
136     res =     ((((a32)-(b32)) & 0x80000000) == 0 ?                                           \
137             (( (a32) & ((b32)^0x80000000) & 0x80000000) ? silk_int32_MIN : (a32)-(b32)) :    \
138             ((((a32)^0x80000000) & (b32)  & 0x80000000) ? silk_int32_MAX : (a32)-(b32)) );
139     silk_assert( res == silk_SAT32( (opus_int64)a32 - (opus_int64)b32 ) );
140     return res;
141 }
142
143 #undef silk_SUB_SAT64
144 static inline opus_int64 silk_SUB_SAT64( opus_int64 a64, opus_int64 b64 ) {
145     opus_int64 res;
146     res =    ((((a64)-(b64)) & 0x8000000000000000LL) == 0 ?                                                      \
147             (( (a64) & ((b64)^0x8000000000000000LL) & 0x8000000000000000LL) ? silk_int64_MIN : (a64)-(b64)) :    \
148             ((((a64)^0x8000000000000000LL) & (b64)  & 0x8000000000000000LL) ? silk_int64_MAX : (a64)-(b64)) );
149
150     if( res != a64 - b64 ) {
151         /* Check that we saturated to the correct extreme value */
152         silk_assert( ( res == silk_int64_MAX && ( ( a64 >> 1 ) + ( b64 >> 1 ) > ( silk_int64_MAX >> 3 ) ) ) ||
153                     ( res == silk_int64_MIN && ( ( a64 >> 1 ) + ( b64 >> 1 ) < ( silk_int64_MIN >> 3 ) ) ) );
154     } else {
155         /* Saturation not necessary */
156         silk_assert( res == a64 - b64 );
157     }
158     return res;
159 }
160
161 #undef silk_MUL
162 static inline opus_int32 silk_MUL(opus_int32 a32, opus_int32 b32){
163     opus_int32 ret;
164     opus_int64 ret64;
165     ret = a32 * b32;
166     ret64 = (opus_int64)a32 * (opus_int64)b32;
167     silk_assert((opus_int64)ret == ret64 );        /* Check output overflow */
168     return ret;
169 }
170
171 #undef silk_MUL_uint
172 static inline opus_uint32 silk_MUL_uint(opus_uint32 a32, opus_uint32 b32){
173     opus_uint32 ret;
174     ret = a32 * b32;
175     silk_assert((opus_uint64)ret == (opus_uint64)a32 * (opus_uint64)b32);        /* Check output overflow */
176     return ret;
177 }
178
179 #undef silk_MLA
180 static inline opus_int32 silk_MLA(opus_int32 a32, opus_int32 b32, opus_int32 c32){
181     opus_int32 ret;
182     ret = a32 + b32 * c32;
183     silk_assert((opus_int64)ret == (opus_int64)a32 + (opus_int64)b32 * (opus_int64)c32);    /* Check output overflow */
184     return ret;
185 }
186
187 #undef silk_MLA_uint
188 static inline opus_int32 silk_MLA_uint(opus_uint32 a32, opus_uint32 b32, opus_uint32 c32){
189     opus_uint32 ret;
190     ret = a32 + b32 * c32;
191     silk_assert((opus_int64)ret == (opus_int64)a32 + (opus_int64)b32 * (opus_int64)c32);    /* Check output overflow */
192     return ret;
193 }
194
195 #undef silk_SMULWB
196 static inline opus_int32 silk_SMULWB(opus_int32 a32, opus_int32 b32){
197     opus_int32 ret;
198     ret = (a32 >> 16) * (opus_int32)((opus_int16)b32) + (((a32 & 0x0000FFFF) * (opus_int32)((opus_int16)b32)) >> 16);
199     silk_assert((opus_int64)ret == ((opus_int64)a32 * (opus_int16)b32) >> 16);
200     return ret;
201 }
202
203 #undef silk_SMLAWB
204 static inline opus_int32 silk_SMLAWB(opus_int32 a32, opus_int32 b32, opus_int32 c32){
205     opus_int32 ret;
206     ret = silk_ADD32( a32, silk_SMULWB( b32, c32 ) );
207     silk_assert(silk_ADD32( a32, silk_SMULWB( b32, c32 ) ) == silk_ADD_SAT32( a32, silk_SMULWB( b32, c32 ) ));
208     return ret;
209 }
210
211 #undef silk_SMULWT
212 static inline opus_int32 silk_SMULWT(opus_int32 a32, opus_int32 b32){
213     opus_int32 ret;
214     ret = (a32 >> 16) * (b32 >> 16) + (((a32 & 0x0000FFFF) * (b32 >> 16)) >> 16);
215     silk_assert((opus_int64)ret == ((opus_int64)a32 * (b32 >> 16)) >> 16);
216     return ret;
217 }
218
219 #undef silk_SMLAWT
220 static inline opus_int32 silk_SMLAWT(opus_int32 a32, opus_int32 b32, opus_int32 c32){
221     opus_int32 ret;
222     ret = a32 + ((b32 >> 16) * (c32 >> 16)) + (((b32 & 0x0000FFFF) * ((c32 >> 16)) >> 16));
223     silk_assert((opus_int64)ret == (opus_int64)a32 + (((opus_int64)b32 * (c32 >> 16)) >> 16));
224     return ret;
225 }
226
227 #undef silk_SMULL
228 static inline opus_int64 silk_SMULL(opus_int64 a64, opus_int64 b64){
229     opus_int64 ret64;
230     ret64 = a64 * b64;
231     if( b64 != 0 ) {
232         silk_assert( a64 == (ret64 / b64) );
233     } else if( a64 != 0 ) {
234         silk_assert( b64 == (ret64 / a64) );
235     }
236     return ret64;
237 }
238
239 /* no checking needed for silk_SMULBB */
240 #undef silk_SMLABB
241 static inline opus_int32 silk_SMLABB(opus_int32 a32, opus_int32 b32, opus_int32 c32){
242     opus_int32 ret;
243     ret = a32 + (opus_int32)((opus_int16)b32) * (opus_int32)((opus_int16)c32);
244     silk_assert((opus_int64)ret == (opus_int64)a32 + (opus_int64)b32 * (opus_int16)c32);
245     return ret;
246 }
247
248 /* no checking needed for silk_SMULBT */
249 #undef silk_SMLABT
250 static inline opus_int32 silk_SMLABT(opus_int32 a32, opus_int32 b32, opus_int32 c32){
251     opus_int32 ret;
252     ret = a32 + ((opus_int32)((opus_int16)b32)) * (c32 >> 16);
253     silk_assert((opus_int64)ret == (opus_int64)a32 + (opus_int64)b32 * (c32 >> 16));
254     return ret;
255 }
256
257 /* no checking needed for silk_SMULTT */
258 #undef silk_SMLATT
259 static inline opus_int32 silk_SMLATT(opus_int32 a32, opus_int32 b32, opus_int32 c32){
260     opus_int32 ret;
261     ret = a32 + (b32 >> 16) * (c32 >> 16);
262     silk_assert((opus_int64)ret == (opus_int64)a32 + (b32 >> 16) * (c32 >> 16));
263     return ret;
264 }
265
266 #undef silk_SMULWW
267 static inline opus_int32 silk_SMULWW(opus_int32 a32, opus_int32 b32){
268     opus_int32 ret, tmp1, tmp2;
269     opus_int64 ret64;
270
271     ret  = silk_SMULWB( a32, b32 );
272     tmp1 = silk_RSHIFT_ROUND( b32, 16 );
273     tmp2 = silk_MUL( a32, tmp1 );
274
275     silk_assert( (opus_int64)tmp2 == (opus_int64) a32 * (opus_int64) tmp1 );
276
277     tmp1 = ret;
278     ret  = silk_ADD32( tmp1, tmp2 );
279     silk_assert( silk_ADD32( tmp1, tmp2 ) == silk_ADD_SAT32( tmp1, tmp2 ) );
280
281     ret64 = silk_RSHIFT64( silk_SMULL( a32, b32 ), 16 );
282     silk_assert( (opus_int64)ret == ret64 );
283
284     return ret;
285 }
286
287 #undef silk_SMLAWW
288 static inline opus_int32 silk_SMLAWW(opus_int32 a32, opus_int32 b32, opus_int32 c32){
289     opus_int32 ret, tmp;
290
291     tmp = silk_SMULWW( b32, c32 );
292     ret = silk_ADD32( a32, tmp );
293     silk_assert( ret == silk_ADD_SAT32( a32, tmp ) );
294     return ret;
295 }
296
297 /* Multiply-accumulate macros that allow overflow in the addition (ie, no asserts in debug mode) */
298 #undef  silk_MLA_ovflw
299 #define silk_MLA_ovflw(a32, b32, c32)    ((a32) + ((b32) * (c32)))
300 #undef  silk_SMLABB_ovflw
301 #define silk_SMLABB_ovflw(a32, b32, c32)    ((a32) + ((opus_int32)((opus_int16)(b32))) * (opus_int32)((opus_int16)(c32)))
302
303 /* no checking needed for silk_SMULL
304    no checking needed for silk_SMLAL
305    no checking needed for silk_SMLALBB
306    no checking needed for SigProcFIX_CLZ16
307    no checking needed for SigProcFIX_CLZ32*/
308
309 #undef silk_DIV32
310 static inline opus_int32 silk_DIV32(opus_int32 a32, opus_int32 b32){
311     silk_assert( b32 != 0 );
312     return a32 / b32;
313 }
314
315 #undef silk_DIV32_16
316 static inline opus_int32 silk_DIV32_16(opus_int32 a32, opus_int32 b32){
317     silk_assert( b32 != 0 );
318     silk_assert( b32 <= silk_int16_MAX );
319     silk_assert( b32 >= silk_int16_MIN );
320     return a32 / b32;
321 }
322
323 /* no checking needed for silk_SAT8
324    no checking needed for silk_SAT16
325    no checking needed for silk_SAT32
326    no checking needed for silk_POS_SAT32
327    no checking needed for silk_ADD_POS_SAT8
328    no checking needed for silk_ADD_POS_SAT16
329    no checking needed for silk_ADD_POS_SAT32
330    no checking needed for silk_ADD_POS_SAT64 */
331
332 #undef silk_LSHIFT8
333 static inline opus_int8 silk_LSHIFT8(opus_int8 a, opus_int32 shift){
334     opus_int8 ret;
335     ret = a << shift;
336     silk_assert(shift >= 0);
337     silk_assert(shift < 8);
338     silk_assert((opus_int64)ret == ((opus_int64)a) << shift);
339     return ret;
340 }
341
342 #undef silk_LSHIFT16
343 static inline opus_int16 silk_LSHIFT16(opus_int16 a, opus_int32 shift){
344     opus_int16 ret;
345     ret = a << shift;
346     silk_assert(shift >= 0);
347     silk_assert(shift < 16);
348     silk_assert((opus_int64)ret == ((opus_int64)a) << shift);
349     return ret;
350 }
351
352 #undef silk_LSHIFT32
353 static inline opus_int32 silk_LSHIFT32(opus_int32 a, opus_int32 shift){
354     opus_int32 ret;
355     ret = a << shift;
356     silk_assert(shift >= 0);
357     silk_assert(shift < 32);
358     silk_assert((opus_int64)ret == ((opus_int64)a) << shift);
359     return ret;
360 }
361
362 #undef silk_LSHIFT64
363 static inline opus_int64 silk_LSHIFT64(opus_int64 a, opus_int shift){
364     silk_assert(shift >= 0);
365     silk_assert(shift < 64);
366     return a << shift;
367 }
368
369 #undef silk_LSHIFT_ovflw
370 static inline opus_int32 silk_LSHIFT_ovflw(opus_int32 a, opus_int32 shift){
371     silk_assert(shift >= 0);            /* no check for overflow */
372     return a << shift;
373 }
374
375 #undef silk_LSHIFT_uint
376 static inline opus_uint32 silk_LSHIFT_uint(opus_uint32 a, opus_int32 shift){
377     opus_uint32 ret;
378     ret = a << shift;
379     silk_assert(shift >= 0);
380     silk_assert((opus_int64)ret == ((opus_int64)a) << shift);
381     return ret;
382 }
383
384 #undef silk_RSHIFT8
385 static inline opus_int8 silk_RSHIFT8(opus_int8 a, opus_int32 shift){
386     silk_assert(shift >=  0);
387     silk_assert(shift < 8);
388     return a >> shift;
389 }
390
391 #undef silk_RSHIFT16
392 static inline opus_int16 silk_RSHIFT16(opus_int16 a, opus_int32 shift){
393     silk_assert(shift >=  0);
394     silk_assert(shift < 16);
395     return a >> shift;
396 }
397
398 #undef silk_RSHIFT32
399 static inline opus_int32 silk_RSHIFT32(opus_int32 a, opus_int32 shift){
400     silk_assert(shift >=  0);
401     silk_assert(shift < 32);
402     return a >> shift;
403 }
404
405 #undef silk_RSHIFT64
406 static inline opus_int64 silk_RSHIFT64(opus_int64 a, opus_int64 shift){
407     silk_assert(shift >=  0);
408     silk_assert(shift <= 63);
409     return a >> shift;
410 }
411
412 #undef silk_RSHIFT_uint
413 static inline opus_uint32 silk_RSHIFT_uint(opus_uint32 a, opus_int32 shift){
414     silk_assert(shift >=  0);
415     silk_assert(shift <= 32);
416     return a >> shift;
417 }
418
419 #undef silk_ADD_LSHIFT
420 static inline opus_int32 silk_ADD_LSHIFT(opus_int32 a, opus_int32 b, opus_int32 shift){
421     opus_int32 ret;
422     silk_assert(shift >= 0);
423     silk_assert(shift <= 31);
424     ret = a + (b << shift);
425     silk_assert((opus_int64)ret == (opus_int64)a + (((opus_int64)b) << shift));
426     return ret;                /* shift >= 0 */
427 }
428
429 #undef silk_ADD_LSHIFT32
430 static inline opus_int32 silk_ADD_LSHIFT32(opus_int32 a, opus_int32 b, opus_int32 shift){
431     opus_int32 ret;
432     silk_assert(shift >= 0);
433     silk_assert(shift <= 31);
434     ret = a + (b << shift);
435     silk_assert((opus_int64)ret == (opus_int64)a + (((opus_int64)b) << shift));
436     return ret;                /* shift >= 0 */
437 }
438
439 #undef silk_ADD_LSHIFT_uint
440 static inline opus_uint32 silk_ADD_LSHIFT_uint(opus_uint32 a, opus_uint32 b, opus_int32 shift){
441     opus_uint32 ret;
442     silk_assert(shift >= 0);
443     silk_assert(shift <= 32);
444     ret = a + (b << shift);
445     silk_assert((opus_int64)ret == (opus_int64)a + (((opus_int64)b) << shift));
446     return ret;                /* shift >= 0 */
447 }
448
449 #undef silk_ADD_RSHIFT
450 static inline opus_int32 silk_ADD_RSHIFT(opus_int32 a, opus_int32 b, opus_int32 shift){
451     opus_int32 ret;
452     silk_assert(shift >= 0);
453     silk_assert(shift <= 31);
454     ret = a + (b >> shift);
455     silk_assert((opus_int64)ret == (opus_int64)a + (((opus_int64)b) >> shift));
456     return ret;                /* shift  > 0 */
457 }
458
459 #undef silk_ADD_RSHIFT32
460 static inline opus_int32 silk_ADD_RSHIFT32(opus_int32 a, opus_int32 b, opus_int32 shift){
461     opus_int32 ret;
462     silk_assert(shift >= 0);
463     silk_assert(shift <= 31);
464     ret = a + (b >> shift);
465     silk_assert((opus_int64)ret == (opus_int64)a + (((opus_int64)b) >> shift));
466     return ret;                /* shift  > 0 */
467 }
468
469 #undef silk_ADD_RSHIFT_uint
470 static inline opus_uint32 silk_ADD_RSHIFT_uint(opus_uint32 a, opus_uint32 b, opus_int32 shift){
471     opus_uint32 ret;
472     silk_assert(shift >= 0);
473     silk_assert(shift <= 32);
474     ret = a + (b >> shift);
475     silk_assert((opus_int64)ret == (opus_int64)a + (((opus_int64)b) >> shift));
476     return ret;                /* shift  > 0 */
477 }
478
479 #undef silk_SUB_LSHIFT32
480 static inline opus_int32 silk_SUB_LSHIFT32(opus_int32 a, opus_int32 b, opus_int32 shift){
481     opus_int32 ret;
482     silk_assert(shift >= 0);
483     silk_assert(shift <= 31);
484     ret = a - (b << shift);
485     silk_assert((opus_int64)ret == (opus_int64)a - (((opus_int64)b) << shift));
486     return ret;                /* shift >= 0 */
487 }
488
489 #undef silk_SUB_RSHIFT32
490 static inline opus_int32 silk_SUB_RSHIFT32(opus_int32 a, opus_int32 b, opus_int32 shift){
491     opus_int32 ret;
492     silk_assert(shift >= 0);
493     silk_assert(shift <= 31);
494     ret = a - (b >> shift);
495     silk_assert((opus_int64)ret == (opus_int64)a - (((opus_int64)b) >> shift));
496     return ret;                /* shift  > 0 */
497 }
498
499 #undef silk_RSHIFT_ROUND
500 static inline opus_int32 silk_RSHIFT_ROUND(opus_int32 a, opus_int32 shift){
501     opus_int32 ret;
502     silk_assert(shift > 0);        /* the marco definition can't handle a shift of zero */
503     silk_assert(shift < 32);
504     ret = shift == 1 ? (a >> 1) + (a & 1) : ((a >> (shift - 1)) + 1) >> 1;
505     silk_assert((opus_int64)ret == ((opus_int64)a + ((opus_int64)1 << (shift - 1))) >> shift);
506     return ret;
507 }
508
509 #undef silk_RSHIFT_ROUND64
510 static inline opus_int64 silk_RSHIFT_ROUND64(opus_int64 a, opus_int32 shift){
511     opus_int64 ret;
512     silk_assert(shift > 0);        /* the marco definition can't handle a shift of zero */
513     silk_assert(shift < 64);
514     ret = shift == 1 ? (a >> 1) + (a & 1) : ((a >> (shift - 1)) + 1) >> 1;
515     return ret;
516 }
517
518 /* silk_abs is used on floats also, so doesn't work... */
519 /*#undef silk_abs
520 static inline opus_int32 silk_abs(opus_int32 a){
521     silk_assert(a != 0x80000000);
522     return (((a) >  0)  ? (a) : -(a));            // Be careful, silk_abs returns wrong when input equals to silk_intXX_MIN
523 }*/
524
525 #undef silk_abs_int64
526 static inline opus_int64 silk_abs_int64(opus_int64 a){
527     silk_assert(a != 0x8000000000000000);
528     return (((a) >  0)  ? (a) : -(a));            /* Be careful, silk_abs returns wrong when input equals to silk_intXX_MIN */
529 }
530
531 #undef silk_abs_int32
532 static inline opus_int32 silk_abs_int32(opus_int32 a){
533     silk_assert(a != 0x80000000);
534     return abs(a);
535 }
536
537 #undef silk_CHECK_FIT8
538 static inline opus_int8 silk_CHECK_FIT8( opus_int64 a ){
539     opus_int8 ret;
540     ret = (opus_int8)a;
541     silk_assert( (opus_int64)ret == a );
542     return( ret );
543 }
544
545 #undef silk_CHECK_FIT16
546 static inline opus_int16 silk_CHECK_FIT16( opus_int64 a ){
547     opus_int16 ret;
548     ret = (opus_int16)a;
549     silk_assert( (opus_int64)ret == a );
550     return( ret );
551 }
552
553 #undef silk_CHECK_FIT32
554 static inline opus_int32 silk_CHECK_FIT32( opus_int64 a ){
555     opus_int32 ret;
556     ret = (opus_int32)a;
557     silk_assert( (opus_int64)ret == a );
558     return( ret );
559 }
560
561 /* no checking for silk_NSHIFT_MUL_32_32
562    no checking for silk_NSHIFT_MUL_16_16
563    no checking needed for silk_min
564    no checking needed for silk_max
565    no checking needed for silk_sign
566 */
567
568 #endif
569 #endif /* MACRO_DEBUG_H */