Smart Remote 3 nRF52 v1.2
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_int32 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 
Documentation feedback | Developer Zone | Subscribe | Updated