The Tor Browser / file comparison

comparison: media/libopus/silk/MacroCount.h

media/libopus/silk/MacroCount.h

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:47e7582ff172
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_ADD_POS_SAT64
323 static OPUS_INLINE opus_int64 silk_ADD_POS_SAT64(opus_int64 a, opus_int64 b){
324 opus_int64 tmp;
325 ops_count += 1;
326 tmp = ((((a)+(b)) & 0x8000000000000000LL) ? silk_int64_MAX : ((a)+(b)));
327 return(tmp);
328 }
329
330 #undef silk_LSHIFT8
331 static OPUS_INLINE opus_int8 silk_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 silk_LSHIFT16
338 static OPUS_INLINE opus_int16 silk_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 silk_LSHIFT32
345 static OPUS_INLINE opus_int32 silk_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 silk_LSHIFT64
352 static OPUS_INLINE opus_int64 silk_LSHIFT64(opus_int64 a, opus_int shift){
353 ops_count += 1;
354 return a << shift;
355 }
356
357 #undef silk_LSHIFT_ovflw
358 static OPUS_INLINE opus_int32 silk_LSHIFT_ovflw(opus_int32 a, opus_int32 shift){
359 ops_count += 1;
360 return a << shift;
361 }
362
363 #undef silk_LSHIFT_uint
364 static OPUS_INLINE opus_uint32 silk_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 silk_RSHIFT8
372 static OPUS_INLINE opus_int8 silk_RSHIFT8(opus_int8 a, opus_int32 shift){
373 ops_count += 1;
374 return a >> shift;
375 }
376 #undef silk_RSHIFT16
377 static OPUS_INLINE opus_int16 silk_RSHIFT16(opus_int16 a, opus_int32 shift){
378 ops_count += 1;
379 return a >> shift;
380 }
381 #undef silk_RSHIFT32
382 static OPUS_INLINE opus_int32 silk_RSHIFT32(opus_int32 a, opus_int32 shift){
383 ops_count += 1;
384 return a >> shift;
385 }
386 #undef silk_RSHIFT64
387 static OPUS_INLINE opus_int64 silk_RSHIFT64(opus_int64 a, opus_int64 shift){
388 ops_count += 1;
389 return a >> shift;
390 }
391
392 #undef silk_RSHIFT_uint
393 static OPUS_INLINE opus_uint32 silk_RSHIFT_uint(opus_uint32 a, opus_int32 shift){
394 ops_count += 1;
395 return a >> shift;
396 }
397
398 #undef silk_ADD_LSHIFT
399 static OPUS_INLINE opus_int32 silk_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 silk_ADD_LSHIFT32
406 static OPUS_INLINE opus_int32 silk_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 silk_ADD_LSHIFT_uint
413 static OPUS_INLINE opus_uint32 silk_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 silk_ADD_RSHIFT
420 static OPUS_INLINE opus_int32 silk_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 silk_ADD_RSHIFT32
427 static OPUS_INLINE opus_int32 silk_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 silk_ADD_RSHIFT_uint
434 static OPUS_INLINE opus_uint32 silk_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 silk_SUB_LSHIFT32
441 static OPUS_INLINE opus_int32 silk_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 silk_SUB_RSHIFT32
448 static OPUS_INLINE opus_int32 silk_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 silk_RSHIFT_ROUND
456 static OPUS_INLINE opus_int32 silk_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 silk_RSHIFT_ROUND64
464 static OPUS_INLINE opus_int64 silk_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 silk_abs_int64
472 static OPUS_INLINE opus_int64 silk_abs_int64(opus_int64 a){
473 ops_count += 1;
474 return (((a) > 0) ? (a) : -(a)); /* Be careful, silk_abs returns wrong when input equals to silk_intXX_MIN*/
475 }
476
477 #undef silk_abs_int32
478 static OPUS_INLINE opus_int32 silk_abs_int32(opus_int32 a){
479 ops_count += 1;
480 return silk_abs(a);
481 }
482
483
484 #undef silk_min
485 static silk_min(a, b){
486 ops_count += 1;
487 return (((a) < (b)) ? (a) : (b));
488 }
489 #undef silk_max
490 static silk_max(a, b){
491 ops_count += 1;
492 return (((a) > (b)) ? (a) : (b));
493 }
494 #undef silk_sign
495 static silk_sign(a){
496 ops_count += 1;
497 return ((a) > 0 ? 1 : ( (a) < 0 ? -1 : 0 ));
498 }
499
500 #undef silk_ADD16
501 static OPUS_INLINE opus_int16 silk_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 silk_ADD32
509 static OPUS_INLINE opus_int32 silk_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 silk_ADD64
517 static OPUS_INLINE opus_int64 silk_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 silk_SUB16
525 static OPUS_INLINE opus_int16 silk_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 silk_SUB32
533 static OPUS_INLINE opus_int32 silk_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 silk_SUB64
541 static OPUS_INLINE opus_int64 silk_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 silk_ADD_SAT16
549 static OPUS_INLINE opus_int16 silk_ADD_SAT16( opus_int16 a16, opus_int16 b16 ) {
550 opus_int16 res;
551 /* Nb will be counted in AKP_add32 and silk_SAT16*/
552 res = (opus_int16)silk_SAT16( silk_ADD32( (opus_int32)(a16), (b16) ) );
553 return res;
554 }
555
556 #undef silk_ADD_SAT32
557 static OPUS_INLINE opus_int32 silk_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 ? silk_int32_MIN : (a32)+(b32)) : \
562 ((((a32) | (b32)) & 0x80000000) == 0 ? silk_int32_MAX : (a32)+(b32)) );
563 return res;
564 }
565
566 #undef silk_ADD_SAT64
567 static OPUS_INLINE opus_int64 silk_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 ? silk_int64_MIN : (a64)+(b64)) : \
572 ((((a64) | (b64)) & 0x8000000000000000LL) == 0 ? silk_int64_MAX : (a64)+(b64)) );
573 return res;
574 }
575
576 #undef silk_SUB_SAT16
577 static OPUS_INLINE opus_int16 silk_SUB_SAT16( opus_int16 a16, opus_int16 b16 ) {
578 opus_int16 res;
579 silk_assert(0);
580 /* Nb will be counted in sub-macros*/
581 res = (opus_int16)silk_SAT16( silk_SUB32( (opus_int32)(a16), (b16) ) );
582 return res;
583 }
584
585 #undef silk_SUB_SAT32
586 static OPUS_INLINE opus_int32 silk_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) ? silk_int32_MIN : (a32)-(b32)) : \
591 ((((a32)^0x80000000) & (b32) & 0x80000000) ? silk_int32_MAX : (a32)-(b32)) );
592 return res;
593 }
594
595 #undef silk_SUB_SAT64
596 static OPUS_INLINE opus_int64 silk_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) ? silk_int64_MIN : (a64)-(b64)) : \
601 ((((a64)^0x8000000000000000LL) & (b64) & 0x8000000000000000LL) ? silk_int64_MAX : (a64)-(b64)) );
602
603 return res;
604 }
605
606 #undef silk_SMULWW
607 static OPUS_INLINE opus_int32 silk_SMULWW(opus_int32 a32, opus_int32 b32){
608 opus_int32 ret;
609 /* Nb will be counted in sub-macros*/
610 ret = silk_MLA(silk_SMULWB((a32), (b32)), (a32), silk_RSHIFT_ROUND((b32), 16));
611 return ret;
612 }
613
614 #undef silk_SMLAWW
615 static OPUS_INLINE opus_int32 silk_SMLAWW(opus_int32 a32, opus_int32 b32, opus_int32 c32){
616 opus_int32 ret;
617 /* Nb will be counted in sub-macros*/
618 ret = silk_MLA(silk_SMLAWB((a32), (b32), (c32)), (b32), silk_RSHIFT_ROUND((c32), 16));
619 return ret;
620 }
621
622 #undef silk_min_int
623 static OPUS_INLINE opus_int silk_min_int(opus_int a, opus_int b)
624 {
625 ops_count += 1;
626 return (((a) < (b)) ? (a) : (b));
627 }
628
629 #undef silk_min_16
630 static OPUS_INLINE opus_int16 silk_min_16(opus_int16 a, opus_int16 b)
631 {
632 ops_count += 1;
633 return (((a) < (b)) ? (a) : (b));
634 }
635 #undef silk_min_32
636 static OPUS_INLINE opus_int32 silk_min_32(opus_int32 a, opus_int32 b)
637 {
638 ops_count += 1;
639 return (((a) < (b)) ? (a) : (b));
640 }
641 #undef silk_min_64
642 static OPUS_INLINE opus_int64 silk_min_64(opus_int64 a, opus_int64 b)
643 {
644 ops_count += 1;
645 return (((a) < (b)) ? (a) : (b));
646 }
647
648 /* silk_min() versions with typecast in the function call */
649 #undef silk_max_int
650 static OPUS_INLINE opus_int silk_max_int(opus_int a, opus_int b)
651 {
652 ops_count += 1;
653 return (((a) > (b)) ? (a) : (b));
654 }
655 #undef silk_max_16
656 static OPUS_INLINE opus_int16 silk_max_16(opus_int16 a, opus_int16 b)
657 {
658 ops_count += 1;
659 return (((a) > (b)) ? (a) : (b));
660 }
661 #undef silk_max_32
662 static OPUS_INLINE opus_int32 silk_max_32(opus_int32 a, opus_int32 b)
663 {
664 ops_count += 1;
665 return (((a) > (b)) ? (a) : (b));
666 }
667
668 #undef silk_max_64
669 static OPUS_INLINE opus_int64 silk_max_64(opus_int64 a, opus_int64 b)
670 {
671 ops_count += 1;
672 return (((a) > (b)) ? (a) : (b));
673 }
674
675
676 #undef silk_LIMIT_int
677 static OPUS_INLINE opus_int silk_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 silk_LIMIT_16
689 static OPUS_INLINE opus_int16 silk_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 silk_LIMIT_32
702 static OPUS_INLINE opus_int silk_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 varDefine
714 #define silk_SaveCount()
715
716 #endif
717 #endif
718

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial