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 inline opus_int64 silk_SaveCount(){ 38 return(ops_count); 39 } 40 41 static 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 inline silk_PrintCount(){ 50 printf("ops_count = %d \n ", (opus_int32)ops_count); 51 } 52 53 #undef silk_MUL 54 static 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 719
