celt/fixed_debug.h

   1 /* Copyright (C) 2003-2008 Jean-Marc Valin
   2    Copyright (C) 2007-2012 Xiph.Org Foundation */
   3 /**
   4    @file fixed_debug.h
   5    @brief Fixed-point operations with debugging
   6 */
   7 /*
   8    Redistribution and use in source and binary forms, with or without
   9    modification, are permitted provided that the following conditions
  10    are met:
  11
  12    - Redistributions of source code must retain the above copyright
  13    notice, this list of conditions and the following disclaimer.
  14
  15    - Redistributions in binary form must reproduce the above copyright
  16    notice, this list of conditions and the following disclaimer in the
  17    documentation and/or other materials provided with the distribution.
  18
  19    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  23    OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  24    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  25    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  26    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  27    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  28    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  29    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30 */
  31
  32 #ifndef FIXED_DEBUG_H
  33 #define FIXED_DEBUG_H
  34
  35 #include <stdio.h>
  36
  37 #ifdef CELT_C
  38 #include "opus_defines.h"
  39 OPUS_EXPORT opus_int64 celt_mips=0;
  40 #else
  41 extern opus_int64 celt_mips;
  42 #endif
  43
  44 #define MULT16_16SU(a,b) ((opus_val32)(opus_val16)(a)*(opus_val32)(opus_uint16)(b))
  45 #define MULT32_32_Q31(a,b) ADD32(ADD32(SHL32(MULT16_16(SHR32((a),16),SHR((b),16)),1), SHR32(MULT16_16SU(SHR32((a),16),((b)&0x0000ffff)),15)), SHR32(MULT16_16SU(SHR32((b),16),((a)&0x0000ffff)),15))
  46
  47 /** 16x32 multiplication, followed by a 16-bit shift right. Results fits in 32 bits */
  48 #define MULT16_32_Q16(a,b) ADD32(MULT16_16((a),SHR32((b),16)), SHR32(MULT16_16SU((a),((b)&0x0000ffff)),16))
  49
  50 #define MULT16_32_P16(a,b) MULT16_32_PX(a,b,16)
  51
  52 #define QCONST16(x,bits) ((opus_val16)(.5+(x)*(((opus_val32)1)<<(bits))))
  53 #define QCONST32(x,bits) ((opus_val32)(.5+(x)*(((opus_val32)1)<<(bits))))
  54
  55 #define VERIFY_SHORT(x) ((x)<=32767&&(x)>=-32768)
  56 #define VERIFY_INT(x) ((x)<=2147483647LL&&(x)>=-2147483648LL)
  57 #define VERIFY_UINT(x) ((x)<=(2147483647LLU<<1))
  58
  59 #define SHR(a,b) SHR32(a,b)
  60 #define PSHR(a,b) PSHR32(a,b)
  61
  62 static inline short NEG16(int x)
  63 {
  64    int res;
  65    if (!VERIFY_SHORT(x))
  66    {
  67       fprintf (stderr, "NEG16: input is not short: %d\n", (int)x);
  68 #ifdef FIXED_DEBUG_ASSERT
  69       celt_assert(0);
  70 #endif
  71    }
  72    res = -x;
  73    if (!VERIFY_SHORT(res))
  74    {
  75       fprintf (stderr, "NEG16: output is not short: %d\n", (int)res);
  76 #ifdef FIXED_DEBUG_ASSERT
  77       celt_assert(0);
  78 #endif
  79    }
  80    celt_mips++;
  81    return res;
  82 }
  83 static inline int NEG32(opus_int64 x)
  84 {
  85    opus_int64 res;
  86    if (!VERIFY_INT(x))
  87    {
  88       fprintf (stderr, "NEG16: input is not int: %d\n", (int)x);
  89 #ifdef FIXED_DEBUG_ASSERT
  90       celt_assert(0);
  91 #endif
  92    }
  93    res = -x;
  94    if (!VERIFY_INT(res))
  95    {
  96       fprintf (stderr, "NEG16: output is not int: %d\n", (int)res);
  97 #ifdef FIXED_DEBUG_ASSERT
  98       celt_assert(0);
  99 #endif
 100    }
 101    celt_mips+=2;
 102    return res;
 103 }
 104
 105 #define EXTRACT16(x) EXTRACT16_(x, __FILE__, __LINE__)
 106 static inline short EXTRACT16_(int x, char *file, int line)
 107 {
 108    int res;
 109    if (!VERIFY_SHORT(x))
 110    {
 111       fprintf (stderr, "EXTRACT16: input is not short: %d in %s: line %d\n", x, file, line);
 112 #ifdef FIXED_DEBUG_ASSERT
 113       celt_assert(0);
 114 #endif
 115    }
 116    res = x;
 117    celt_mips++;
 118    return res;
 119 }
 120
 121 #define EXTEND32(x) EXTEND32_(x, __FILE__, __LINE__)
 122 static inline int EXTEND32_(int x, char *file, int line)
 123 {
 124    int res;
 125    if (!VERIFY_SHORT(x))
 126    {
 127       fprintf (stderr, "EXTEND32: input is not short: %d in %s: line %d\n", x, file, line);
 128 #ifdef FIXED_DEBUG_ASSERT
 129       celt_assert(0);
 130 #endif
 131    }
 132    res = x;
 133    celt_mips++;
 134    return res;
 135 }
 136
 137 #define SHR16(a, shift) SHR16_(a, shift, __FILE__, __LINE__)
 138 static inline short SHR16_(int a, int shift, char *file, int line)
 139 {
 140    int res;
 141    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(shift))
 142    {
 143       fprintf (stderr, "SHR16: inputs are not short: %d >> %d in %s: line %d\n", a, shift, file, line);
 144 #ifdef FIXED_DEBUG_ASSERT
 145       celt_assert(0);
 146 #endif
 147    }
 148    res = a>>shift;
 149    if (!VERIFY_SHORT(res))
 150    {
 151       fprintf (stderr, "SHR16: output is not short: %d in %s: line %d\n", res, file, line);
 152 #ifdef FIXED_DEBUG_ASSERT
 153       celt_assert(0);
 154 #endif
 155    }
 156    celt_mips++;
 157    return res;
 158 }
 159 #define SHL16(a, shift) SHL16_(a, shift, __FILE__, __LINE__)
 160 static inline short SHL16_(int a, int shift, char *file, int line)
 161 {
 162    int res;
 163    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(shift))
 164    {
 165       fprintf (stderr, "SHL16: inputs are not short: %d %d in %s: line %d\n", a, shift, file, line);
 166 #ifdef FIXED_DEBUG_ASSERT
 167       celt_assert(0);
 168 #endif
 169    }
 170    res = a<<shift;
 171    if (!VERIFY_SHORT(res))
 172    {
 173       fprintf (stderr, "SHL16: output is not short: %d in %s: line %d\n", res, file, line);
 174 #ifdef FIXED_DEBUG_ASSERT
 175       celt_assert(0);
 176 #endif
 177    }
 178    celt_mips++;
 179    return res;
 180 }
 181
 182 static inline int SHR32(opus_int64 a, int shift)
 183 {
 184    opus_int64  res;
 185    if (!VERIFY_INT(a) || !VERIFY_SHORT(shift))
 186    {
 187       fprintf (stderr, "SHR32: inputs are not int: %d %d\n", (int)a, shift);
 188 #ifdef FIXED_DEBUG_ASSERT
 189       celt_assert(0);
 190 #endif
 191    }
 192    res = a>>shift;
 193    if (!VERIFY_INT(res))
 194    {
 195       fprintf (stderr, "SHR32: output is not int: %d\n", (int)res);
 196 #ifdef FIXED_DEBUG_ASSERT
 197       celt_assert(0);
 198 #endif
 199    }
 200    celt_mips+=2;
 201    return res;
 202 }
 203 #define SHL32(a, shift) SHL32_(a, shift, __FILE__, __LINE__)
 204 static inline int SHL32_(opus_int64 a, int shift, char *file, int line)
 205 {
 206    opus_int64  res;
 207    if (!VERIFY_INT(a) || !VERIFY_SHORT(shift))
 208    {
 209       fprintf (stderr, "SHL32: inputs are not int: %lld %d in %s: line %d\n", a, shift, file, line);
 210 #ifdef FIXED_DEBUG_ASSERT
 211       celt_assert(0);
 212 #endif
 213    }
 214    res = a<<shift;
 215    if (!VERIFY_INT(res))
 216    {
 217       fprintf (stderr, "SHL32: output is not int: %lld<<%d = %lld in %s: line %d\n", a, shift, res, file, line);
 218 #ifdef FIXED_DEBUG_ASSERT
 219       celt_assert(0);
 220 #endif
 221    }
 222    celt_mips+=2;
 223    return res;
 224 }
 225
 226 #define PSHR32(a,shift) (celt_mips--,SHR32(ADD32((a),(((opus_val32)(1)<<((shift))>>1))),shift))
 227 #define VSHR32(a, shift) (((shift)>0) ? SHR32(a, shift) : SHL32(a, -(shift)))
 228
 229 #define ROUND16(x,a) (celt_mips--,EXTRACT16(PSHR32((x),(a))))
 230 #define HALF16(x)  (SHR16(x,1))
 231 #define HALF32(x)  (SHR32(x,1))
 232
 233 //#define SHR(a,shift) ((a) >> (shift))
 234 //#define SHL(a,shift) ((a) << (shift))
 235
 236 #define ADD16(a, b) ADD16_(a, b, __FILE__, __LINE__)
 237 static inline short ADD16_(int a, int b, char *file, int line)
 238 {
 239    int res;
 240    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
 241    {
 242       fprintf (stderr, "ADD16: inputs are not short: %d %d in %s: line %d\n", a, b, file, line);
 243 #ifdef FIXED_DEBUG_ASSERT
 244       celt_assert(0);
 245 #endif
 246    }
 247    res = a+b;
 248    if (!VERIFY_SHORT(res))
 249    {
 250       fprintf (stderr, "ADD16: output is not short: %d+%d=%d in %s: line %d\n", a,b,res, file, line);
 251 #ifdef FIXED_DEBUG_ASSERT
 252       celt_assert(0);
 253 #endif
 254    }
 255    celt_mips++;
 256    return res;
 257 }
 258
 259 #define SUB16(a, b) SUB16_(a, b, __FILE__, __LINE__)
 260 static inline short SUB16_(int a, int b, char *file, int line)
 261 {
 262    int res;
 263    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
 264    {
 265       fprintf (stderr, "SUB16: inputs are not short: %d %d in %s: line %d\n", a, b, file, line);
 266 #ifdef FIXED_DEBUG_ASSERT
 267       celt_assert(0);
 268 #endif
 269    }
 270    res = a-b;
 271    if (!VERIFY_SHORT(res))
 272    {
 273       fprintf (stderr, "SUB16: output is not short: %d in %s: line %d\n", res, file, line);
 274 #ifdef FIXED_DEBUG_ASSERT
 275       celt_assert(0);
 276 #endif
 277    }
 278    celt_mips++;
 279    return res;
 280 }
 281
 282 #define ADD32(a, b) ADD32_(a, b, __FILE__, __LINE__)
 283 static inline int ADD32_(opus_int64 a, opus_int64 b, char *file, int line)
 284 {
 285    opus_int64 res;
 286    if (!VERIFY_INT(a) || !VERIFY_INT(b))
 287    {
 288       fprintf (stderr, "ADD32: inputs are not int: %d %d in %s: line %d\n", (int)a, (int)b, file, line);
 289 #ifdef FIXED_DEBUG_ASSERT
 290       celt_assert(0);
 291 #endif
 292    }
 293    res = a+b;
 294    if (!VERIFY_INT(res))
 295    {
 296       fprintf (stderr, "ADD32: output is not int: %d in %s: line %d\n", (int)res, file, line);
 297 #ifdef FIXED_DEBUG_ASSERT
 298       celt_assert(0);
 299 #endif
 300    }
 301    celt_mips+=2;
 302    return res;
 303 }
 304
 305 #define SUB32(a, b) SUB32_(a, b, __FILE__, __LINE__)
 306 static inline int SUB32_(opus_int64 a, opus_int64 b, char *file, int line)
 307 {
 308    opus_int64 res;
 309    if (!VERIFY_INT(a) || !VERIFY_INT(b))
 310    {
 311       fprintf (stderr, "SUB32: inputs are not int: %d %d in %s: line %d\n", (int)a, (int)b, file, line);
 312 #ifdef FIXED_DEBUG_ASSERT
 313       celt_assert(0);
 314 #endif
 315    }
 316    res = a-b;
 317    if (!VERIFY_INT(res))
 318    {
 319       fprintf (stderr, "SUB32: output is not int: %d in %s: line %d\n", (int)res, file, line);
 320 #ifdef FIXED_DEBUG_ASSERT
 321       celt_assert(0);
 322 #endif
 323    }
 324    celt_mips+=2;
 325    return res;
 326 }
 327
 328 #undef UADD32
 329 #define UADD32(a, b) UADD32_(a, b, __FILE__, __LINE__)
 330 static inline unsigned int UADD32_(opus_uint64 a, opus_uint64 b, char *file, int line)
 331 {
 332    opus_uint64 res;
 333    if (!VERIFY_UINT(a) || !VERIFY_UINT(b))
 334    {
 335       fprintf (stderr, "UADD32: inputs are not uint32: %llu %llu in %s: line %d\n", a, b, file, line);
 336 #ifdef FIXED_DEBUG_ASSERT
 337       celt_assert(0);
 338 #endif
 339    }
 340    res = a+b;
 341    if (!VERIFY_UINT(res))
 342    {
 343       fprintf (stderr, "UADD32: output is not uint32: %llu in %s: line %d\n", res, file, line);
 344 #ifdef FIXED_DEBUG_ASSERT
 345       celt_assert(0);
 346 #endif
 347    }
 348    celt_mips+=2;
 349    return res;
 350 }
 351
 352 #undef USUB32
 353 #define USUB32(a, b) USUB32_(a, b, __FILE__, __LINE__)
 354 static inline unsigned int USUB32_(opus_uint64 a, opus_uint64 b, char *file, int line)
 355 {
 356    opus_uint64 res;
 357    if (!VERIFY_UINT(a) || !VERIFY_UINT(b))
 358    {
 359       fprintf (stderr, "USUB32: inputs are not uint32: %llu %llu in %s: line %d\n", a, b, file, line);
 360 #ifdef FIXED_DEBUG_ASSERT
 361       celt_assert(0);
 362 #endif
 363    }
 364    if (a<b)
 365    {
 366       fprintf (stderr, "USUB32: inputs underflow: %llu < %llu in %s: line %d\n", a, b, file, line);
 367 #ifdef FIXED_DEBUG_ASSERT
 368       celt_assert(0);
 369 #endif
 370    }
 371    res = a-b;
 372    if (!VERIFY_UINT(res))
 373    {
 374       fprintf (stderr, "USUB32: output is not uint32: %llu - %llu = %llu in %s: line %d\n", a, b, res, file, line);
 375 #ifdef FIXED_DEBUG_ASSERT
 376       celt_assert(0);
 377 #endif
 378    }
 379    celt_mips+=2;
 380    return res;
 381 }
 382
 383 /* result fits in 16 bits */
 384 static inline short MULT16_16_16(int a, int b)
 385 {
 386    int res;
 387    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
 388    {
 389       fprintf (stderr, "MULT16_16_16: inputs are not short: %d %d\n", a, b);
 390 #ifdef FIXED_DEBUG_ASSERT
 391       celt_assert(0);
 392 #endif
 393    }
 394    res = a*b;
 395    if (!VERIFY_SHORT(res))
 396    {
 397       fprintf (stderr, "MULT16_16_16: output is not short: %d\n", res);
 398 #ifdef FIXED_DEBUG_ASSERT
 399       celt_assert(0);
 400 #endif
 401    }
 402    celt_mips++;
 403    return res;
 404 }
 405
 406 #define MULT16_16(a, b) MULT16_16_(a, b, __FILE__, __LINE__)
 407 static inline int MULT16_16_(int a, int b, char *file, int line)
 408 {
 409    opus_int64 res;
 410    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
 411    {
 412       fprintf (stderr, "MULT16_16: inputs are not short: %d %d in %s: line %d\n", a, b, file, line);
 413 #ifdef FIXED_DEBUG_ASSERT
 414       celt_assert(0);
 415 #endif
 416    }
 417    res = ((opus_int64)a)*b;
 418    if (!VERIFY_INT(res))
 419    {
 420       fprintf (stderr, "MULT16_16: output is not int: %d in %s: line %d\n", (int)res, file, line);
 421 #ifdef FIXED_DEBUG_ASSERT
 422       celt_assert(0);
 423 #endif
 424    }
 425    celt_mips++;
 426    return res;
 427 }
 428
 429 #define MAC16_16(c,a,b)     (celt_mips-=2,ADD32((c),MULT16_16((a),(b))))
 430
 431 #define MULT16_32_QX(a, b, Q) MULT16_32_QX_(a, b, Q, __FILE__, __LINE__)
 432 static inline int MULT16_32_QX_(int a, opus_int64 b, int Q, char *file, int line)
 433 {
 434    opus_int64 res;
 435    if (!VERIFY_SHORT(a) || !VERIFY_INT(b))
 436    {
 437       fprintf (stderr, "MULT16_32_Q%d: inputs are not short+int: %d %d in %s: line %d\n", Q, (int)a, (int)b, file, line);
 438 #ifdef FIXED_DEBUG_ASSERT
 439       celt_assert(0);
 440 #endif
 441    }
 442    if (ABS32(b)>=((opus_val32)(1)<<(15+Q)))
 443    {
 444       fprintf (stderr, "MULT16_32_Q%d: second operand too large: %d %d in %s: line %d\n", Q, (int)a, (int)b, file, line);
 445 #ifdef FIXED_DEBUG_ASSERT
 446       celt_assert(0);
 447 #endif
 448    }
 449    res = (((opus_int64)a)*(opus_int64)b) >> Q;
 450    if (!VERIFY_INT(res))
 451    {
 452       fprintf (stderr, "MULT16_32_Q%d: output is not int: %d*%d=%d in %s: line %d\n", Q, (int)a, (int)b,(int)res, file, line);
 453 #ifdef FIXED_DEBUG_ASSERT
 454       celt_assert(0);
 455 #endif
 456    }
 457    if (Q==15)
 458       celt_mips+=3;
 459    else
 460       celt_mips+=4;
 461    return res;
 462 }
 463
 464 #define MULT16_32_PX(a, b, Q) MULT16_32_PX_(a, b, Q, __FILE__, __LINE__)
 465 static inline int MULT16_32_PX_(int a, opus_int64 b, int Q, char *file, int line)
 466 {
 467    opus_int64 res;
 468    if (!VERIFY_SHORT(a) || !VERIFY_INT(b))
 469    {
 470       fprintf (stderr, "MULT16_32_P%d: inputs are not short+int: %d %d in %s: line %d\n\n", Q, (int)a, (int)b, file, line);
 471 #ifdef FIXED_DEBUG_ASSERT
 472       celt_assert(0);
 473 #endif
 474    }
 475    if (ABS32(b)>=((opus_int64)(1)<<(15+Q)))
 476    {
 477       fprintf (stderr, "MULT16_32_Q%d: second operand too large: %d %d in %s: line %d\n\n", Q, (int)a, (int)b,file, line);
 478 #ifdef FIXED_DEBUG_ASSERT
 479       celt_assert(0);
 480 #endif
 481    }
 482    res = ((((opus_int64)a)*(opus_int64)b) + (((opus_val32)(1)<<Q)>>1))>> Q;
 483    if (!VERIFY_INT(res))
 484    {
 485       fprintf (stderr, "MULT16_32_P%d: output is not int: %d*%d=%d in %s: line %d\n\n", Q, (int)a, (int)b,(int)res, file, line);
 486 #ifdef FIXED_DEBUG_ASSERT
 487       celt_assert(0);
 488 #endif
 489    }
 490    if (Q==15)
 491       celt_mips+=4;
 492    else
 493       celt_mips+=5;
 494    return res;
 495 }
 496
 497 #define MULT16_32_Q15(a,b) MULT16_32_QX(a,b,15)
 498 #define MAC16_32_Q15(c,a,b) (celt_mips-=2,ADD32((c),MULT16_32_Q15((a),(b))))
 499
 500 static inline int SATURATE(int a, int b)
 501 {
 502    if (a>b)
 503       a=b;
 504    if (a<-b)
 505       a = -b;
 506    celt_mips+=3;
 507    return a;
 508 }
 509
 510 static inline int MULT16_16_Q11_32(int a, int b)
 511 {
 512    opus_int64 res;
 513    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
 514    {
 515       fprintf (stderr, "MULT16_16_Q11: inputs are not short: %d %d\n", a, b);
 516 #ifdef FIXED_DEBUG_ASSERT
 517       celt_assert(0);
 518 #endif
 519    }
 520    res = ((opus_int64)a)*b;
 521    res >>= 11;
 522    if (!VERIFY_INT(res))
 523    {
 524       fprintf (stderr, "MULT16_16_Q11: output is not short: %d*%d=%d\n", (int)a, (int)b, (int)res);
 525 #ifdef FIXED_DEBUG_ASSERT
 526       celt_assert(0);
 527 #endif
 528    }
 529    celt_mips+=3;
 530    return res;
 531 }
 532 static inline short MULT16_16_Q13(int a, int b)
 533 {
 534    opus_int64 res;
 535    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
 536    {
 537       fprintf (stderr, "MULT16_16_Q13: inputs are not short: %d %d\n", a, b);
 538 #ifdef FIXED_DEBUG_ASSERT
 539       celt_assert(0);
 540 #endif
 541    }
 542    res = ((opus_int64)a)*b;
 543    res >>= 13;
 544    if (!VERIFY_SHORT(res))
 545    {
 546       fprintf (stderr, "MULT16_16_Q13: output is not short: %d*%d=%d\n", a, b, (int)res);
 547 #ifdef FIXED_DEBUG_ASSERT
 548       celt_assert(0);
 549 #endif
 550    }
 551    celt_mips+=3;
 552    return res;
 553 }
 554 static inline short MULT16_16_Q14(int a, int b)
 555 {
 556    opus_int64 res;
 557    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
 558    {
 559       fprintf (stderr, "MULT16_16_Q14: inputs are not short: %d %d\n", a, b);
 560 #ifdef FIXED_DEBUG_ASSERT
 561       celt_assert(0);
 562 #endif
 563    }
 564    res = ((opus_int64)a)*b;
 565    res >>= 14;
 566    if (!VERIFY_SHORT(res))
 567    {
 568       fprintf (stderr, "MULT16_16_Q14: output is not short: %d\n", (int)res);
 569 #ifdef FIXED_DEBUG_ASSERT
 570       celt_assert(0);
 571 #endif
 572    }
 573    celt_mips+=3;
 574    return res;
 575 }
 576
 577 #define MULT16_16_Q15(a, b) MULT16_16_Q15_(a, b, __FILE__, __LINE__)
 578 static inline short MULT16_16_Q15_(int a, int b, char *file, int line)
 579 {
 580    opus_int64 res;
 581    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
 582    {
 583       fprintf (stderr, "MULT16_16_Q15: inputs are not short: %d %d in %s: line %d\n", a, b, file, line);
 584 #ifdef FIXED_DEBUG_ASSERT
 585       celt_assert(0);
 586 #endif
 587    }
 588    res = ((opus_int64)a)*b;
 589    res >>= 15;
 590    if (!VERIFY_SHORT(res))
 591    {
 592       fprintf (stderr, "MULT16_16_Q15: output is not short: %d in %s: line %d\n", (int)res, file, line);
 593 #ifdef FIXED_DEBUG_ASSERT
 594       celt_assert(0);
 595 #endif
 596    }
 597    celt_mips+=1;
 598    return res;
 599 }
 600
 601 static inline short MULT16_16_P13(int a, int b)
 602 {
 603    opus_int64 res;
 604    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
 605    {
 606       fprintf (stderr, "MULT16_16_P13: inputs are not short: %d %d\n", a, b);
 607 #ifdef FIXED_DEBUG_ASSERT
 608       celt_assert(0);
 609 #endif
 610    }
 611    res = ((opus_int64)a)*b;
 612    res += 4096;
 613    if (!VERIFY_INT(res))
 614    {
 615       fprintf (stderr, "MULT16_16_P13: overflow: %d*%d=%d\n", a, b, (int)res);
 616 #ifdef FIXED_DEBUG_ASSERT
 617       celt_assert(0);
 618 #endif
 619    }
 620    res >>= 13;
 621    if (!VERIFY_SHORT(res))
 622    {
 623       fprintf (stderr, "MULT16_16_P13: output is not short: %d*%d=%d\n", a, b, (int)res);
 624 #ifdef FIXED_DEBUG_ASSERT
 625       celt_assert(0);
 626 #endif
 627    }
 628    celt_mips+=4;
 629    return res;
 630 }
 631 static inline short MULT16_16_P14(int a, int b)
 632 {
 633    opus_int64 res;
 634    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
 635    {
 636       fprintf (stderr, "MULT16_16_P14: inputs are not short: %d %d\n", a, b);
 637 #ifdef FIXED_DEBUG_ASSERT
 638       celt_assert(0);
 639 #endif
 640    }
 641    res = ((opus_int64)a)*b;
 642    res += 8192;
 643    if (!VERIFY_INT(res))
 644    {
 645       fprintf (stderr, "MULT16_16_P14: overflow: %d*%d=%d\n", a, b, (int)res);
 646 #ifdef FIXED_DEBUG_ASSERT
 647       celt_assert(0);
 648 #endif
 649    }
 650    res >>= 14;
 651    if (!VERIFY_SHORT(res))
 652    {
 653       fprintf (stderr, "MULT16_16_P14: output is not short: %d*%d=%d\n", a, b, (int)res);
 654 #ifdef FIXED_DEBUG_ASSERT
 655       celt_assert(0);
 656 #endif
 657    }
 658    celt_mips+=4;
 659    return res;
 660 }
 661 static inline short MULT16_16_P15(int a, int b)
 662 {
 663    opus_int64 res;
 664    if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
 665    {
 666       fprintf (stderr, "MULT16_16_P15: inputs are not short: %d %d\n", a, b);
 667 #ifdef FIXED_DEBUG_ASSERT
 668       celt_assert(0);
 669 #endif
 670    }
 671    res = ((opus_int64)a)*b;
 672    res += 16384;
 673    if (!VERIFY_INT(res))
 674    {
 675       fprintf (stderr, "MULT16_16_P15: overflow: %d*%d=%d\n", a, b, (int)res);
 676 #ifdef FIXED_DEBUG_ASSERT
 677       celt_assert(0);
 678 #endif
 679    }
 680    res >>= 15;
 681    if (!VERIFY_SHORT(res))
 682    {
 683       fprintf (stderr, "MULT16_16_P15: output is not short: %d*%d=%d\n", a, b, (int)res);
 684 #ifdef FIXED_DEBUG_ASSERT
 685       celt_assert(0);
 686 #endif
 687    }
 688    celt_mips+=2;
 689    return res;
 690 }
 691
 692 #define DIV32_16(a, b) DIV32_16_(a, b, __FILE__, __LINE__)
 693
 694 static inline int DIV32_16_(opus_int64 a, opus_int64 b, char *file, int line)
 695 {
 696    opus_int64 res;
 697    if (b==0)
 698    {
 699       fprintf(stderr, "DIV32_16: divide by zero: %d/%d in %s: line %d\n", (int)a, (int)b, file, line);
 700 #ifdef FIXED_DEBUG_ASSERT
 701       celt_assert(0);
 702 #endif
 703       return 0;
 704    }
 705    if (!VERIFY_INT(a) || !VERIFY_SHORT(b))
 706    {
 707       fprintf (stderr, "DIV32_16: inputs are not int/short: %d %d in %s: line %d\n", (int)a, (int)b, file, line);
 708 #ifdef FIXED_DEBUG_ASSERT
 709       celt_assert(0);
 710 #endif
 711    }
 712    res = a/b;
 713    if (!VERIFY_SHORT(res))
 714    {
 715       fprintf (stderr, "DIV32_16: output is not short: %d / %d = %d in %s: line %d\n", (int)a,(int)b,(int)res, file, line);
 716       if (res>32767)
 717          res = 32767;
 718       if (res<-32768)
 719          res = -32768;
 720 #ifdef FIXED_DEBUG_ASSERT
 721       celt_assert(0);
 722 #endif
 723    }
 724    celt_mips+=35;
 725    return res;
 726 }
 727
 728 #define DIV32(a, b) DIV32_(a, b, __FILE__, __LINE__)
 729 static inline int DIV32_(opus_int64 a, opus_int64 b, char *file, int line)
 730 {
 731    opus_int64 res;
 732    if (b==0)
 733    {
 734       fprintf(stderr, "DIV32: divide by zero: %d/%d in %s: line %d\n", (int)a, (int)b, file, line);
 735 #ifdef FIXED_DEBUG_ASSERT
 736       celt_assert(0);
 737 #endif
 738       return 0;
 739    }
 740
 741    if (!VERIFY_INT(a) || !VERIFY_INT(b))
 742    {
 743       fprintf (stderr, "DIV32: inputs are not int/short: %d %d in %s: line %d\n", (int)a, (int)b, file, line);
 744 #ifdef FIXED_DEBUG_ASSERT
 745       celt_assert(0);
 746 #endif
 747    }
 748    res = a/b;
 749    if (!VERIFY_INT(res))
 750    {
 751       fprintf (stderr, "DIV32: output is not int: %d in %s: line %d\n", (int)res, file, line);
 752 #ifdef FIXED_DEBUG_ASSERT
 753       celt_assert(0);
 754 #endif
 755    }
 756    celt_mips+=70;
 757    return res;
 758 }
 759
 760 #undef PRINT_MIPS
 761 #define PRINT_MIPS(file) do {fprintf (file, "total complexity = %llu MIPS\n", celt_mips);} while (0);
 762
 763 #endif