Home | History | Annotate | Download | only in silk
      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 
    719