Fixes two encoder bugs causing glitches in stereo->mono switches
[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, (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 _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 #undef silk_MLA
179 static inline opus_int32 silk_MLA(opus_int32 a32, opus_int32 b32, opus_int32 c32){
180     opus_int32 ret;
181     ret = a32 + b32 * c32;
182     silk_assert((opus_int64)ret == (opus_int64)a32 + (opus_int64)b32 * (opus_int64)c32);    /* Check output overflow */
183     return ret;
184 }
185
186 #undef silk_MLA_uint
187 static inline opus_int32 silk_MLA_uint(opus_uint32 a32, opus_uint32 b32, opus_uint32 c32){
188     opus_uint32 ret;
189     ret = a32 + b32 * c32;
190     silk_assert((opus_int64)ret == (opus_int64)a32 + (opus_int64)b32 * (opus_int64)c32);    /* Check output overflow */
191     return ret;
192 }
193
194 #undef    silk_SMULWB
195 static inline opus_int32 silk_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     silk_assert((opus_int64)ret == ((opus_int64)a32 * (opus_int16)b32) >> 16);
199     return ret;
200 }
201 #undef    silk_SMLAWB
202 static inline opus_int32 silk_SMLAWB(opus_int32 a32, opus_int32 b32, opus_int32 c32){
203     opus_int32 ret;
204     ret = silk_ADD32( a32, silk_SMULWB( b32, c32 ) );
205     silk_assert(silk_ADD32( a32, silk_SMULWB( b32, c32 ) ) == silk_ADD_SAT32( a32, silk_SMULWB( b32, c32 ) ));
206     return ret;
207 }
208
209 #undef silk_SMULWT
210 static inline opus_int32 silk_SMULWT(opus_int32 a32, opus_int32 b32){
211     opus_int32 ret;
212     ret = (a32 >> 16) * (b32 >> 16) + (((a32 & 0x0000FFFF) * (b32 >> 16)) >> 16);
213     silk_assert((opus_int64)ret == ((opus_int64)a32 * (b32 >> 16)) >> 16);
214     return ret;
215 }
216 #undef silk_SMLAWT
217 static inline opus_int32 silk_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     silk_assert((opus_int64)ret == (opus_int64)a32 + (((opus_int64)b32 * (c32 >> 16)) >> 16));
221     return ret;
222 }
223
224 #undef silk_SMULL
225 static inline opus_int64 silk_SMULL(opus_int64 a64, opus_int64 b64){
226     opus_int64 ret64;
227     ret64 = a64 * b64;
228     if( b64 != 0 ) {
229         silk_assert( a64 == (ret64 / b64) );
230     } else if( a64 != 0 ) {
231         silk_assert( b64 == (ret64 / a64) );
232     }
233     return ret64;
234 }
235
236 /* no checking needed for silk_SMULBB */
237 #undef    silk_SMLABB
238 static inline opus_int32 silk_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     silk_assert((opus_int64)ret == (opus_int64)a32 + (opus_int64)b32 * (opus_int16)c32);
242     return ret;
243 }
244
245 /* no checking needed for silk_SMULBT */
246 #undef    silk_SMLABT
247 static inline opus_int32 silk_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     silk_assert((opus_int64)ret == (opus_int64)a32 + (opus_int64)b32 * (c32 >> 16));
251     return ret;
252 }
253
254 /* no checking needed for silk_SMULTT */
255 #undef    silk_SMLATT
256 static inline opus_int32 silk_SMLATT(opus_int32 a32, opus_int32 b32, opus_int32 c32){
257     opus_int32 ret;
258     ret = a32 + (b32 >> 16) * (c32 >> 16);
259     silk_assert((opus_int64)ret == (opus_int64)a32 + (b32 >> 16) * (c32 >> 16));
260     return ret;
261 }
262
263 #undef    silk_SMULWW
264 static inline opus_int32 silk_SMULWW(opus_int32 a32, opus_int32 b32){
265     opus_int32 ret, tmp1, tmp2;
266     opus_int64 ret64;
267
268     ret  = silk_SMULWB( a32, b32 );
269     tmp1 = silk_RSHIFT_ROUND( b32, 16 );
270     tmp2 = silk_MUL( a32, tmp1 );
271
272     silk_assert( (opus_int64)tmp2 == (opus_int64) a32 * (opus_int64) tmp1 );
273
274     tmp1 = ret;
275     ret  = silk_ADD32( tmp1, tmp2 );
276     silk_assert( silk_ADD32( tmp1, tmp2 ) == silk_ADD_SAT32( tmp1, tmp2 ) );
277
278     ret64 = silk_RSHIFT64( silk_SMULL( a32, b32 ), 16 );
279     silk_assert( (opus_int64)ret == ret64 );
280
281     return ret;
282 }
283
284 #undef    silk_SMLAWW
285 static inline opus_int32 silk_SMLAWW(opus_int32 a32, opus_int32 b32, opus_int32 c32){
286     opus_int32 ret, tmp;
287
288     tmp = silk_SMULWW( b32, c32 );
289     ret = silk_ADD32( a32, tmp );
290     silk_assert( ret == silk_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    silk_MLA_ovflw
296 #define silk_MLA_ovflw(a32, b32, c32)    ((a32) + ((b32) * (c32)))
297 #undef    silk_SMLABB_ovflw
298 #define silk_SMLABB_ovflw(a32, b32, c32)    ((a32) + ((opus_int32)((opus_int16)(b32))) * (opus_int32)((opus_int16)(c32)))
299
300 /* no checking needed for silk_SMULL
301    no checking needed for silk_SMLAL
302    no checking needed for silk_SMLALBB
303    no checking needed for SigProcFIX_CLZ16
304    no checking needed for SigProcFIX_CLZ32*/
305
306 #undef silk_DIV32
307 static inline opus_int32 silk_DIV32(opus_int32 a32, opus_int32 b32){
308     silk_assert( b32 != 0 );
309     return a32 / b32;
310 }
311
312 #undef silk_DIV32_16
313 static inline opus_int32 silk_DIV32_16(opus_int32 a32, opus_int32 b32){
314     silk_assert( b32 != 0 );
315     silk_assert( b32 <= silk_int16_MAX );
316     silk_assert( b32 >= silk_int16_MIN );
317     return a32 / b32;
318 }
319
320 /* no checking needed for silk_SAT8
321    no checking needed for silk_SAT16
322    no checking needed for silk_SAT32
323    no checking needed for silk_POS_SAT32
324    no checking needed for silk_ADD_POS_SAT8
325    no checking needed for silk_ADD_POS_SAT16
326    no checking needed for silk_ADD_POS_SAT32
327    no checking needed for silk_ADD_POS_SAT64 */
328 #undef    silk_LSHIFT8
329 static inline opus_int8 silk_LSHIFT8(opus_int8 a, opus_int32 shift){
330     opus_int8 ret;
331     ret = a << shift;
332     silk_assert(shift >= 0);
333     silk_assert(shift < 8);
334     silk_assert((opus_int64)ret == ((opus_int64)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     ret = a << shift;
341     silk_assert(shift >= 0);
342     silk_assert(shift < 16);
343     silk_assert((opus_int64)ret == ((opus_int64)a) << shift);
344     return ret;
345 }
346 #undef    silk_LSHIFT32
347 static inline opus_int32 silk_LSHIFT32(opus_int32 a, opus_int32 shift){
348     opus_int32 ret;
349     ret = a << shift;
350     silk_assert(shift >= 0);
351     silk_assert(shift < 32);
352     silk_assert((opus_int64)ret == ((opus_int64)a) << shift);
353     return ret;
354 }
355 #undef    silk_LSHIFT64
356 static inline opus_int64 silk_LSHIFT64(opus_int64 a, opus_int shift){
357     silk_assert(shift >= 0);
358     silk_assert(shift < 64);
359     return a << shift;
360 }
361
362 #undef    silk_LSHIFT_ovflw
363 static inline opus_int32 silk_LSHIFT_ovflw(opus_int32 a, opus_int32 shift){
364     silk_assert(shift >= 0);            /* no check for overflow */
365     return a << shift;
366 }
367
368 #undef    silk_LSHIFT_uint
369 static inline opus_uint32 silk_LSHIFT_uint(opus_uint32 a, opus_int32 shift){
370     opus_uint32 ret;
371     ret = a << shift;
372     silk_assert(shift >= 0);
373     silk_assert((opus_int64)ret == ((opus_int64)a) << shift);
374     return ret;
375 }
376
377 #undef    silk_RSHIFT8
378 static inline opus_int8 silk_RSHIFT8(opus_int8 a, opus_int32 shift){
379     silk_assert(shift >=  0);
380     silk_assert(shift < 8);
381     return a >> shift;
382 }
383 #undef    silk_RSHIFT16
384 static inline opus_int16 silk_RSHIFT16(opus_int16 a, opus_int32 shift){
385     silk_assert(shift >=  0);
386     silk_assert(shift < 16);
387     return a >> shift;
388 }
389 #undef    silk_RSHIFT32
390 static inline opus_int32 silk_RSHIFT32(opus_int32 a, opus_int32 shift){
391     silk_assert(shift >=  0);
392     silk_assert(shift < 32);
393     return a >> shift;
394 }
395 #undef    silk_RSHIFT64
396 static inline opus_int64 silk_RSHIFT64(opus_int64 a, opus_int64 shift){
397     silk_assert(shift >=  0);
398     silk_assert(shift <= 63);
399     return a >> shift;
400 }
401
402 #undef    silk_RSHIFT_uint
403 static inline opus_uint32 silk_RSHIFT_uint(opus_uint32 a, opus_int32 shift){
404     silk_assert(shift >=  0);
405     silk_assert(shift <= 32);
406     return a >> shift;
407 }
408
409 #undef    silk_ADD_LSHIFT
410 static inline opus_int32 silk_ADD_LSHIFT(opus_int32 a, opus_int32 b, opus_int32 shift){
411     opus_int32 ret;
412     silk_assert(shift >= 0);
413     silk_assert(shift <= 31);
414     ret = a + (b << shift);
415     silk_assert((opus_int64)ret == (opus_int64)a + (((opus_int64)b) << shift));
416     return ret;                /* shift >= 0 */
417 }
418 #undef    silk_ADD_LSHIFT32
419 static inline opus_int32 silk_ADD_LSHIFT32(opus_int32 a, opus_int32 b, opus_int32 shift){
420     opus_int32 ret;
421     silk_assert(shift >= 0);
422     silk_assert(shift <= 31);
423     ret = a + (b << shift);
424     silk_assert((opus_int64)ret == (opus_int64)a + (((opus_int64)b) << shift));
425     return ret;                /* shift >= 0 */
426 }
427 #undef    silk_ADD_LSHIFT_uint
428 static inline opus_uint32 silk_ADD_LSHIFT_uint(opus_uint32 a, opus_uint32 b, opus_int32 shift){
429     opus_uint32 ret;
430     silk_assert(shift >= 0);
431     silk_assert(shift <= 32);
432     ret = a + (b << shift);
433     silk_assert((opus_int64)ret == (opus_int64)a + (((opus_int64)b) << shift));
434     return ret;                /* shift >= 0 */
435 }
436 #undef    silk_ADD_RSHIFT
437 static inline opus_int32 silk_ADD_RSHIFT(opus_int32 a, opus_int32 b, opus_int32 shift){
438     opus_int32 ret;
439     silk_assert(shift >= 0);
440     silk_assert(shift <= 31);
441     ret = a + (b >> shift);
442     silk_assert((opus_int64)ret == (opus_int64)a + (((opus_int64)b) >> shift));
443     return ret;                /* shift  > 0 */
444 }
445 #undef    silk_ADD_RSHIFT32
446 static inline opus_int32 silk_ADD_RSHIFT32(opus_int32 a, opus_int32 b, opus_int32 shift){
447     opus_int32 ret;
448     silk_assert(shift >= 0);
449     silk_assert(shift <= 31);
450     ret = a + (b >> shift);
451     silk_assert((opus_int64)ret == (opus_int64)a + (((opus_int64)b) >> shift));
452     return ret;                /* shift  > 0 */
453 }
454 #undef    silk_ADD_RSHIFT_uint
455 static inline opus_uint32 silk_ADD_RSHIFT_uint(opus_uint32 a, opus_uint32 b, opus_int32 shift){
456     opus_uint32 ret;
457     silk_assert(shift >= 0);
458     silk_assert(shift <= 32);
459     ret = a + (b >> shift);
460     silk_assert((opus_int64)ret == (opus_int64)a + (((opus_int64)b) >> shift));
461     return ret;                /* shift  > 0 */
462 }
463 #undef    silk_SUB_LSHIFT32
464 static inline opus_int32 silk_SUB_LSHIFT32(opus_int32 a, opus_int32 b, opus_int32 shift){
465     opus_int32 ret;
466     silk_assert(shift >= 0);
467     silk_assert(shift <= 31);
468     ret = a - (b << shift);
469     silk_assert((opus_int64)ret == (opus_int64)a - (((opus_int64)b) << shift));
470     return ret;                /* shift >= 0 */
471 }
472 #undef    silk_SUB_RSHIFT32
473 static inline opus_int32 silk_SUB_RSHIFT32(opus_int32 a, opus_int32 b, opus_int32 shift){
474     opus_int32 ret;
475     silk_assert(shift >= 0);
476     silk_assert(shift <= 31);
477     ret = a - (b >> shift);
478     silk_assert((opus_int64)ret == (opus_int64)a - (((opus_int64)b) >> shift));
479     return ret;                /* shift  > 0 */
480 }
481
482 #undef    silk_RSHIFT_ROUND
483 static inline opus_int32 silk_RSHIFT_ROUND(opus_int32 a, opus_int32 shift){
484     opus_int32 ret;
485     silk_assert(shift > 0);        /* the marco definition can't handle a shift of zero */
486     silk_assert(shift < 32);
487     ret = shift == 1 ? (a >> 1) + (a & 1) : ((a >> (shift - 1)) + 1) >> 1;
488     silk_assert((opus_int64)ret == ((opus_int64)a + ((opus_int64)1 << (shift - 1))) >> shift);
489     return ret;
490 }
491
492 #undef    silk_RSHIFT_ROUND64
493 static inline opus_int64 silk_RSHIFT_ROUND64(opus_int64 a, opus_int32 shift){
494     opus_int64 ret;
495     silk_assert(shift > 0);        /* the marco definition can't handle a shift of zero */
496     silk_assert(shift < 64);
497     ret = shift == 1 ? (a >> 1) + (a & 1) : ((a >> (shift - 1)) + 1) >> 1;
498     return ret;
499 }
500
501 /* silk_abs is used on floats also, so doesn't work... */
502 /*#undef    silk_abs
503 static inline opus_int32 silk_abs(opus_int32 a){
504     silk_assert(a != 0x80000000);
505     return (((a) >  0)  ? (a) : -(a));            // Be careful, silk_abs returns wrong when input equals to silk_intXX_MIN
506 }*/
507
508 #undef    silk_abs_int64
509 static inline opus_int64 silk_abs_int64(opus_int64 a){
510     silk_assert(a != 0x8000000000000000);
511     return (((a) >  0)  ? (a) : -(a));            /* Be careful, silk_abs returns wrong when input equals to silk_intXX_MIN */
512 }
513
514 #undef    silk_abs_int32
515 static inline opus_int32 silk_abs_int32(opus_int32 a){
516     silk_assert(a != 0x80000000);
517     return abs(a);
518 }
519
520 #undef    silk_CHECK_FIT8
521 static inline opus_int8 silk_CHECK_FIT8( opus_int64 a ){
522     opus_int8 ret;
523     ret = (opus_int8)a;
524     silk_assert( (opus_int64)ret == a );
525     return( ret );
526 }
527
528 #undef    silk_CHECK_FIT16
529 static inline opus_int16 silk_CHECK_FIT16( opus_int64 a ){
530     opus_int16 ret;
531     ret = (opus_int16)a;
532     silk_assert( (opus_int64)ret == a );
533     return( ret );
534 }
535
536 #undef    silk_CHECK_FIT32
537 static inline opus_int32 silk_CHECK_FIT32( opus_int64 a ){
538     opus_int32 ret;
539     ret = (opus_int32)a;
540     silk_assert( (opus_int64)ret == a );
541     return( ret );
542 }
543
544 /* no checking for silk_NSHIFT_MUL_32_32
545    no checking for silk_NSHIFT_MUL_16_16
546    no checking needed for silk_min
547    no checking needed for silk_max
548    no checking needed for silk_sign
549 */
550
551 #endif
552 #endif /* _MACRO_DEBUG_H_ */