celt/celt.c

   1 /* Copyright (c) 2007-2008 CSIRO
   2    Copyright (c) 2007-2010 Xiph.Org Foundation
   3    Copyright (c) 2008 Gregory Maxwell
   4    Written by Jean-Marc Valin and Gregory Maxwell */
   5 /*
   6    Redistribution and use in source and binary forms, with or without
   7    modification, are permitted provided that the following conditions
   8    are met:
   9
  10    - Redistributions of source code must retain the above copyright
  11    notice, this list of conditions and the following disclaimer.
  12
  13    - Redistributions in binary form must reproduce the above copyright
  14    notice, this list of conditions and the following disclaimer in the
  15    documentation and/or other materials provided with the distribution.
  16
  17    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  20    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  21    OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  22    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  23    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  24    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  25    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  26    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  27    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28 */
  29
  30 #ifdef HAVE_CONFIG_H
  31 #include "config.h"
  32 #endif
  33
  34 #define CELT_C
  35
  36 #include "os_support.h"
  37 #include "mdct.h"
  38 #include <math.h>
  39 #include "celt.h"
  40 #include "pitch.h"
  41 #include "bands.h"
  42 #include "modes.h"
  43 #include "entcode.h"
  44 #include "quant_bands.h"
  45 #include "rate.h"
  46 #include "stack_alloc.h"
  47 #include "mathops.h"
  48 #include "float_cast.h"
  49 #include <stdarg.h>
  50 #include "celt_lpc.h"
  51 #include "vq.h"
  52
  53 #ifndef OPUS_VERSION
  54 #define OPUS_VERSION "unknown"
  55 #endif
  56
  57 #ifdef CUSTOM_MODES
  58 #define OPUS_CUSTOM_NOSTATIC
  59 #else
  60 #define OPUS_CUSTOM_NOSTATIC static inline
  61 #endif
  62
  63 static const unsigned char trim_icdf[11] = {126, 124, 119, 109, 87, 41, 19, 9, 4, 2, 0};
  64 /* Probs: NONE: 21.875%, LIGHT: 6.25%, NORMAL: 65.625%, AGGRESSIVE: 6.25% */
  65 static const unsigned char spread_icdf[4] = {25, 23, 2, 0};
  66
  67 static const unsigned char tapset_icdf[3]={2,1,0};
  68
  69 #ifdef CUSTOM_MODES
  70 static const unsigned char toOpusTable[20] = {
  71       0xE0, 0xE8, 0xF0, 0xF8,
  72       0xC0, 0xC8, 0xD0, 0xD8,
  73       0xA0, 0xA8, 0xB0, 0xB8,
  74       0x00, 0x00, 0x00, 0x00,
  75       0x80, 0x88, 0x90, 0x98,
  76 };
  77
  78 static const unsigned char fromOpusTable[16] = {
  79       0x80, 0x88, 0x90, 0x98,
  80       0x40, 0x48, 0x50, 0x58,
  81       0x20, 0x28, 0x30, 0x38,
  82       0x00, 0x08, 0x10, 0x18
  83 };
  84
  85 static inline int toOpus(unsigned char c)
  86 {
  87    int ret=0;
  88    if (c<0xA0)
  89       ret = toOpusTable[c>>3];
  90    if (ret == 0)
  91       return -1;
  92    else
  93       return ret|(c&0x7);
  94 }
  95
  96 static inline int fromOpus(unsigned char c)
  97 {
  98    if (c<0x80)
  99       return -1;
 100    else
 101       return fromOpusTable[(c>>3)-16] | (c&0x7);
 102 }
 103 #endif /* CUSTOM_MODES */
 104
 105 #define COMBFILTER_MAXPERIOD 1024
 106 #define COMBFILTER_MINPERIOD 15
 107
 108 static int resampling_factor(opus_int32 rate)
 109 {
 110    int ret;
 111    switch (rate)
 112    {
 113    case 48000:
 114       ret = 1;
 115       break;
 116    case 24000:
 117       ret = 2;
 118       break;
 119    case 16000:
 120       ret = 3;
 121       break;
 122    case 12000:
 123       ret = 4;
 124       break;
 125    case 8000:
 126       ret = 6;
 127       break;
 128    default:
 129 #ifndef CUSTOM_MODES
 130       celt_assert(0);
 131 #endif
 132       ret = 0;
 133       break;
 134    }
 135    return ret;
 136 }
 137
 138 /** Encoder state
 139  @brief Encoder state
 140  */
 141 struct OpusCustomEncoder {
 142    const OpusCustomMode *mode;     /**< Mode used by the encoder */
 143    int overlap;
 144    int channels;
 145    int stream_channels;
 146
 147    int force_intra;
 148    int clip;
 149    int disable_pf;
 150    int complexity;
 151    int upsample;
 152    int start, end;
 153
 154    opus_int32 bitrate;
 155    int vbr;
 156    int signalling;
 157    int constrained_vbr;      /* If zero, VBR can do whatever it likes with the rate */
 158    int loss_rate;
 159
 160    /* Everything beyond this point gets cleared on a reset */
 161 #define ENCODER_RESET_START rng
 162
 163    opus_uint32 rng;
 164    int spread_decision;
 165    opus_val32 delayedIntra;
 166    int tonal_average;
 167    int lastCodedBands;
 168    int hf_average;
 169    int tapset_decision;
 170
 171    int prefilter_period;
 172    opus_val16 prefilter_gain;
 173    int prefilter_tapset;
 174 #ifdef RESYNTH
 175    int prefilter_period_old;
 176    opus_val16 prefilter_gain_old;
 177    int prefilter_tapset_old;
 178 #endif
 179    int consec_transient;
 180
 181    opus_val32 preemph_memE[2];
 182    opus_val32 preemph_memD[2];
 183
 184    /* VBR-related parameters */
 185    opus_int32 vbr_reservoir;
 186    opus_int32 vbr_drift;
 187    opus_int32 vbr_offset;
 188    opus_int32 vbr_count;
 189
 190 #ifdef RESYNTH
 191    celt_sig syn_mem[2][2*MAX_PERIOD];
 192 #endif
 193
 194    celt_sig in_mem[1]; /* Size = channels*mode->overlap */
 195    /* celt_sig prefilter_mem[],  Size = channels*COMBFILTER_PERIOD */
 196    /* celt_sig overlap_mem[],  Size = channels*mode->overlap */
 197    /* opus_val16 oldEBands[], Size = 2*channels*mode->nbEBands */
 198 };
 199
 200 int celt_encoder_get_size(int channels)
 201 {
 202    CELTMode *mode = opus_custom_mode_create(48000, 960, NULL);
 203    return opus_custom_encoder_get_size(mode, channels);
 204 }
 205
 206 OPUS_CUSTOM_NOSTATIC int opus_custom_encoder_get_size(const CELTMode *mode, int channels)
 207 {
 208    int size = sizeof(struct CELTEncoder)
 209          + (2*channels*mode->overlap-1)*sizeof(celt_sig)
 210          + channels*COMBFILTER_MAXPERIOD*sizeof(celt_sig)
 211          + 3*channels*mode->nbEBands*sizeof(opus_val16);
 212    return size;
 213 }
 214
 215 #ifdef CUSTOM_MODES
 216 CELTEncoder *opus_custom_encoder_create(const CELTMode *mode, int channels, int *error)
 217 {
 218    int ret;
 219    CELTEncoder *st = (CELTEncoder *)opus_alloc(opus_custom_encoder_get_size(mode, channels));
 220    /* init will handle the NULL case */
 221    ret = opus_custom_encoder_init(st, mode, channels);
 222    if (ret != OPUS_OK)
 223    {
 224       opus_custom_encoder_destroy(st);
 225       st = NULL;
 226    }
 227    if (error)
 228       *error = ret;
 229    return st;
 230 }
 231 #endif /* CUSTOM_MODES */
 232
 233 int celt_encoder_init(CELTEncoder *st, opus_int32 sampling_rate, int channels)
 234 {
 235    int ret;
 236    ret = opus_custom_encoder_init(st, opus_custom_mode_create(48000, 960, NULL), channels);
 237    if (ret != OPUS_OK)
 238       return ret;
 239    st->upsample = resampling_factor(sampling_rate);
 240    return OPUS_OK;
 241 }
 242
 243 OPUS_CUSTOM_NOSTATIC int opus_custom_encoder_init(CELTEncoder *st, const CELTMode *mode, int channels)
 244 {
 245    if (channels < 0 || channels > 2)
 246       return OPUS_BAD_ARG;
 247
 248    if (st==NULL || mode==NULL)
 249       return OPUS_ALLOC_FAIL;
 250
 251    OPUS_CLEAR((char*)st, opus_custom_encoder_get_size(mode, channels));
 252
 253    st->mode = mode;
 254    st->overlap = mode->overlap;
 255    st->stream_channels = st->channels = channels;
 256
 257    st->upsample = 1;
 258    st->start = 0;
 259    st->end = st->mode->effEBands;
 260    st->signalling = 1;
 261
 262    st->constrained_vbr = 1;
 263    st->clip = 1;
 264
 265    st->bitrate = OPUS_BITRATE_MAX;
 266    st->vbr = 0;
 267    st->force_intra  = 0;
 268    st->complexity = 5;
 269
 270    opus_custom_encoder_ctl(st, OPUS_RESET_STATE);
 271
 272    return OPUS_OK;
 273 }
 274
 275 #ifdef CUSTOM_MODES
 276 void opus_custom_encoder_destroy(CELTEncoder *st)
 277 {
 278    opus_free(st);
 279 }
 280 #endif /* CUSTOM_MODES */
 281
 282 static inline opus_val16 SIG2WORD16(celt_sig x)
 283 {
 284 #ifdef FIXED_POINT
 285    x = PSHR32(x, SIG_SHIFT);
 286    x = MAX32(x, -32768);
 287    x = MIN32(x, 32767);
 288    return EXTRACT16(x);
 289 #else
 290    return (opus_val16)x;
 291 #endif
 292 }
 293
 294 static int transient_analysis(const opus_val32 * restrict in, int len, int C,
 295                               int overlap)
 296 {
 297    int i;
 298    VARDECL(opus_val16, tmp);
 299    opus_val32 mem0=0,mem1=0;
 300    int is_transient = 0;
 301    int block;
 302    int N;
 303    VARDECL(opus_val16, bins);
 304    SAVE_STACK;
 305    ALLOC(tmp, len, opus_val16);
 306
 307    block = overlap/2;
 308    N=len/block;
 309    ALLOC(bins, N, opus_val16);
 310    if (C==1)
 311    {
 312       for (i=0;i<len;i++)
 313          tmp[i] = SHR32(in[i],SIG_SHIFT);
 314    } else {
 315       for (i=0;i<len;i++)
 316          tmp[i] = SHR32(ADD32(in[i],in[i+len]), SIG_SHIFT+1);
 317    }
 318
 319    /* High-pass filter: (1 - 2*z^-1 + z^-2) / (1 - z^-1 + .5*z^-2) */
 320    for (i=0;i<len;i++)
 321    {
 322       opus_val32 x,y;
 323       x = tmp[i];
 324       y = ADD32(mem0, x);
 325 #ifdef FIXED_POINT
 326       mem0 = mem1 + y - SHL32(x,1);
 327       mem1 = x - SHR32(y,1);
 328 #else
 329       mem0 = mem1 + y - 2*x;
 330       mem1 = x - .5f*y;
 331 #endif
 332       tmp[i] = EXTRACT16(SHR32(y,2));
 333    }
 334    /* First few samples are bad because we don't propagate the memory */
 335    for (i=0;i<12;i++)
 336       tmp[i] = 0;
 337
 338    for (i=0;i<N;i++)
 339    {
 340       int j;
 341       opus_val16 max_abs=0;
 342       for (j=0;j<block;j++)
 343          max_abs = MAX16(max_abs, ABS16(tmp[i*block+j]));
 344       bins[i] = max_abs;
 345    }
 346    for (i=0;i<N;i++)
 347    {
 348       int j;
 349       int conseq=0;
 350       opus_val16 t1, t2, t3;
 351
 352       t1 = MULT16_16_Q15(QCONST16(.15f, 15), bins[i]);
 353       t2 = MULT16_16_Q15(QCONST16(.4f, 15), bins[i]);
 354       t3 = MULT16_16_Q15(QCONST16(.15f, 15), bins[i]);
 355       for (j=0;j<i;j++)
 356       {
 357          if (bins[j] < t1)
 358             conseq++;
 359          if (bins[j] < t2)
 360             conseq++;
 361          else
 362             conseq = 0;
 363       }
 364       if (conseq>=3)
 365          is_transient=1;
 366       conseq = 0;
 367       for (j=i+1;j<N;j++)
 368       {
 369          if (bins[j] < t3)
 370             conseq++;
 371          else
 372             conseq = 0;
 373       }
 374       if (conseq>=7)
 375          is_transient=1;
 376    }
 377    RESTORE_STACK;
 378 #ifdef FUZZING
 379    is_transient = rand()&0x1;
 380 #endif
 381    return is_transient;
 382 }
 383
 384 /** Apply window and compute the MDCT for all sub-frames and
 385     all channels in a frame */
 386 static void compute_mdcts(const CELTMode *mode, int shortBlocks, celt_sig * restrict in, celt_sig * restrict out, int C, int LM)
 387 {
 388    if (C==1 && !shortBlocks)
 389    {
 390       const int overlap = OVERLAP(mode);
 391       clt_mdct_forward(&mode->mdct, in, out, mode->window, overlap, mode->maxLM-LM, 1);
 392    } else {
 393       const int overlap = OVERLAP(mode);
 394       int N = mode->shortMdctSize<<LM;
 395       int B = 1;
 396       int b, c;
 397       if (shortBlocks)
 398       {
 399          N = mode->shortMdctSize;
 400          B = shortBlocks;
 401       }
 402       c=0; do {
 403          for (b=0;b<B;b++)
 404          {
 405             /* Interleaving the sub-frames while doing the MDCTs */
 406             clt_mdct_forward(&mode->mdct, in+c*(B*N+overlap)+b*N, &out[b+c*N*B], mode->window, overlap, shortBlocks ? mode->maxLM : mode->maxLM-LM, B);
 407          }
 408       } while (++c<C);
 409    }
 410 }
 411
 412 /** Compute the IMDCT and apply window for all sub-frames and
 413     all channels in a frame */
 414 static void compute_inv_mdcts(const CELTMode *mode, int shortBlocks, celt_sig *X,
 415       celt_sig * restrict out_mem[],
 416       celt_sig * restrict overlap_mem[], int C, int LM)
 417 {
 418    int c;
 419    const int N = mode->shortMdctSize<<LM;
 420    const int overlap = OVERLAP(mode);
 421    VARDECL(opus_val32, x);
 422    SAVE_STACK;
 423
 424    ALLOC(x, N+overlap, opus_val32);
 425    c=0; do {
 426       int j;
 427       int b;
 428       int N2 = N;
 429       int B = 1;
 430
 431       if (shortBlocks)
 432       {
 433          N2 = mode->shortMdctSize;
 434          B = shortBlocks;
 435       }
 436       /* Prevents problems from the imdct doing the overlap-add */
 437       OPUS_CLEAR(x, overlap);
 438
 439       for (b=0;b<B;b++)
 440       {
 441          /* IMDCT on the interleaved the sub-frames */
 442          clt_mdct_backward(&mode->mdct, &X[b+c*N2*B], x+N2*b, mode->window, overlap, shortBlocks ? mode->maxLM : mode->maxLM-LM, B);
 443       }
 444
 445       for (j=0;j<overlap;j++)
 446          out_mem[c][j] = x[j] + overlap_mem[c][j];
 447       for (;j<N;j++)
 448          out_mem[c][j] = x[j];
 449       for (j=0;j<overlap;j++)
 450          overlap_mem[c][j] = x[N+j];
 451    } while (++c<C);
 452    RESTORE_STACK;
 453 }
 454
 455 static void deemphasis(celt_sig *in[], opus_val16 *pcm, int N, int C, int downsample, const opus_val16 *coef, celt_sig *mem)
 456 {
 457    int c;
 458    int count=0;
 459    c=0; do {
 460       int j;
 461       celt_sig * restrict x;
 462       opus_val16  * restrict y;
 463       celt_sig m = mem[c];
 464       x =in[c];
 465       y = pcm+c;
 466       for (j=0;j<N;j++)
 467       {
 468          celt_sig tmp = *x + m;
 469          m = MULT16_32_Q15(coef[0], tmp)
 470            - MULT16_32_Q15(coef[1], *x);
 471          tmp = SHL32(MULT16_32_Q15(coef[3], tmp), 2);
 472          x++;
 473          /* Technically the store could be moved outside of the if because
 474             the stores we don't want will just be overwritten */
 475          if (count==0)
 476             *y = SCALEOUT(SIG2WORD16(tmp));
 477          if (++count==downsample)
 478          {
 479             y+=C;
 480             count=0;
 481          }
 482       }
 483       mem[c] = m;
 484    } while (++c<C);
 485 }
 486
 487 static void comb_filter(opus_val32 *y, opus_val32 *x, int T0, int T1, int N,
 488       opus_val16 g0, opus_val16 g1, int tapset0, int tapset1,
 489       const opus_val16 *window, int overlap)
 490 {
 491    int i;
 492    /* printf ("%d %d %f %f\n", T0, T1, g0, g1); */
 493    opus_val16 g00, g01, g02, g10, g11, g12;
 494    static const opus_val16 gains[3][3] = {
 495          {QCONST16(0.3066406250f, 15), QCONST16(0.2170410156f, 15), QCONST16(0.1296386719f, 15)},
 496          {QCONST16(0.4638671875f, 15), QCONST16(0.2680664062f, 15), QCONST16(0.f, 15)},
 497          {QCONST16(0.7998046875f, 15), QCONST16(0.1000976562f, 15), QCONST16(0.f, 15)}};
 498    g00 = MULT16_16_Q15(g0, gains[tapset0][0]);
 499    g01 = MULT16_16_Q15(g0, gains[tapset0][1]);
 500    g02 = MULT16_16_Q15(g0, gains[tapset0][2]);
 501    g10 = MULT16_16_Q15(g1, gains[tapset1][0]);
 502    g11 = MULT16_16_Q15(g1, gains[tapset1][1]);
 503    g12 = MULT16_16_Q15(g1, gains[tapset1][2]);
 504    for (i=0;i<overlap;i++)
 505    {
 506       opus_val16 f;
 507       f = MULT16_16_Q15(window[i],window[i]);
 508       y[i] = x[i]
 509                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g00),x[i-T0])
 510                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g01),x[i-T0-1])
 511                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g01),x[i-T0+1])
 512                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g02),x[i-T0-2])
 513                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g02),x[i-T0+2])
 514                + MULT16_32_Q15(MULT16_16_Q15(f,g10),x[i-T1])
 515                + MULT16_32_Q15(MULT16_16_Q15(f,g11),x[i-T1-1])
 516                + MULT16_32_Q15(MULT16_16_Q15(f,g11),x[i-T1+1])
 517                + MULT16_32_Q15(MULT16_16_Q15(f,g12),x[i-T1-2])
 518                + MULT16_32_Q15(MULT16_16_Q15(f,g12),x[i-T1+2]);
 519
 520    }
 521    for (i=overlap;i<N;i++)
 522       y[i] = x[i]
 523                + MULT16_32_Q15(g10,x[i-T1])
 524                + MULT16_32_Q15(g11,x[i-T1-1])
 525                + MULT16_32_Q15(g11,x[i-T1+1])
 526                + MULT16_32_Q15(g12,x[i-T1-2])
 527                + MULT16_32_Q15(g12,x[i-T1+2]);
 528 }
 529
 530 static const signed char tf_select_table[4][8] = {
 531       {0, -1, 0, -1,    0,-1, 0,-1},
 532       {0, -1, 0, -2,    1, 0, 1,-1},
 533       {0, -2, 0, -3,    2, 0, 1,-1},
 534       {0, -2, 0, -3,    3, 0, 1,-1},
 535 };
 536
 537 static opus_val32 l1_metric(const celt_norm *tmp, int N, int LM, int width)
 538 {
 539    int i, j;
 540    static const opus_val16 sqrtM_1[4] = {Q15ONE, QCONST16(.70710678f,15), QCONST16(0.5f,15), QCONST16(0.35355339f,15)};
 541    opus_val32 L1;
 542    opus_val16 bias;
 543    L1=0;
 544    for (i=0;i<1<<LM;i++)
 545    {
 546       opus_val32 L2 = 0;
 547       for (j=0;j<N>>LM;j++)
 548          L2 = MAC16_16(L2, tmp[(j<<LM)+i], tmp[(j<<LM)+i]);
 549       L1 += celt_sqrt(L2);
 550    }
 551    L1 = MULT16_32_Q15(sqrtM_1[LM], L1);
 552    if (width==1)
 553       bias = QCONST16(.12f,15)*LM;
 554    else if (width==2)
 555       bias = QCONST16(.05f,15)*LM;
 556    else
 557       bias = QCONST16(.02f,15)*LM;
 558    L1 = MAC16_32_Q15(L1, bias, L1);
 559    return L1;
 560 }
 561
 562 static int tf_analysis(const CELTMode *m, int len, int C, int isTransient,
 563       int *tf_res, int nbCompressedBytes, celt_norm *X, int N0, int LM,
 564       int *tf_sum)
 565 {
 566    int i;
 567    VARDECL(int, metric);
 568    int cost0;
 569    int cost1;
 570    VARDECL(int, path0);
 571    VARDECL(int, path1);
 572    VARDECL(celt_norm, tmp);
 573    int lambda;
 574    int tf_select=0;
 575    SAVE_STACK;
 576
 577    if (nbCompressedBytes<15*C)
 578    {
 579       *tf_sum = 0;
 580       for (i=0;i<len;i++)
 581          tf_res[i] = isTransient;
 582       return 0;
 583    }
 584    if (nbCompressedBytes<40)
 585       lambda = 12;
 586    else if (nbCompressedBytes<60)
 587       lambda = 6;
 588    else if (nbCompressedBytes<100)
 589       lambda = 4;
 590    else
 591       lambda = 3;
 592
 593    ALLOC(metric, len, int);
 594    ALLOC(tmp, (m->eBands[len]-m->eBands[len-1])<<LM, celt_norm);
 595    ALLOC(path0, len, int);
 596    ALLOC(path1, len, int);
 597
 598    *tf_sum = 0;
 599    for (i=0;i<len;i++)
 600    {
 601       int j, k, N;
 602       opus_val32 L1, best_L1;
 603       int best_level=0;
 604       N = (m->eBands[i+1]-m->eBands[i])<<LM;
 605       for (j=0;j<N;j++)
 606          tmp[j] = X[j+(m->eBands[i]<<LM)];
 607       /* Just add the right channel if we're in stereo */
 608       if (C==2)
 609          for (j=0;j<N;j++)
 610             tmp[j] = ADD16(SHR16(tmp[j], 1),SHR16(X[N0+j+(m->eBands[i]<<LM)], 1));
 611       L1 = l1_metric(tmp, N, isTransient ? LM : 0, N>>LM);
 612       best_L1 = L1;
 613       /*printf ("%f ", L1);*/
 614       for (k=0;k<LM;k++)
 615       {
 616          int B;
 617
 618          if (isTransient)
 619             B = (LM-k-1);
 620          else
 621             B = k+1;
 622
 623          if (isTransient)
 624             haar1(tmp, N>>(LM-k), 1<<(LM-k));
 625          else
 626             haar1(tmp, N>>k, 1<<k);
 627
 628          L1 = l1_metric(tmp, N, B, N>>LM);
 629
 630          if (L1 < best_L1)
 631          {
 632             best_L1 = L1;
 633             best_level = k+1;
 634          }
 635       }
 636       /*printf ("%d ", isTransient ? LM-best_level : best_level);*/
 637       if (isTransient)
 638          metric[i] = best_level;
 639       else
 640          metric[i] = -best_level;
 641       *tf_sum += metric[i];
 642    }
 643    /*printf("\n");*/
 644    /* NOTE: Future optimized implementations could detect extreme transients and set
 645       tf_select = 1 but so far we have not found a reliable way of making this useful */
 646    tf_select = 0;
 647
 648    cost0 = 0;
 649    cost1 = isTransient ? 0 : lambda;
 650    /* Viterbi forward pass */
 651    for (i=1;i<len;i++)
 652    {
 653       int curr0, curr1;
 654       int from0, from1;
 655
 656       from0 = cost0;
 657       from1 = cost1 + lambda;
 658       if (from0 < from1)
 659       {
 660          curr0 = from0;
 661          path0[i]= 0;
 662       } else {
 663          curr0 = from1;
 664          path0[i]= 1;
 665       }
 666
 667       from0 = cost0 + lambda;
 668       from1 = cost1;
 669       if (from0 < from1)
 670       {
 671          curr1 = from0;
 672          path1[i]= 0;
 673       } else {
 674          curr1 = from1;
 675          path1[i]= 1;
 676       }
 677       cost0 = curr0 + abs(metric[i]-tf_select_table[LM][4*isTransient+2*tf_select+0]);
 678       cost1 = curr1 + abs(metric[i]-tf_select_table[LM][4*isTransient+2*tf_select+1]);
 679    }
 680    tf_res[len-1] = cost0 < cost1 ? 0 : 1;
 681    /* Viterbi backward pass to check the decisions */
 682    for (i=len-2;i>=0;i--)
 683    {
 684       if (tf_res[i+1] == 1)
 685          tf_res[i] = path1[i+1];
 686       else
 687          tf_res[i] = path0[i+1];
 688    }
 689    RESTORE_STACK;
 690 #ifdef FUZZING
 691    tf_select = rand()&0x1;
 692    tf_res[0] = rand()&0x1;
 693    for (i=1;i<len;i++)
 694       tf_res[i] = tf_res[i-1] ^ ((rand()&0xF) == 0);
 695 #endif
 696    return tf_select;
 697 }
 698
 699 static void tf_encode(int start, int end, int isTransient, int *tf_res, int LM, int tf_select, ec_enc *enc)
 700 {
 701    int curr, i;
 702    int tf_select_rsv;
 703    int tf_changed;
 704    int logp;
 705    opus_uint32 budget;
 706    opus_uint32 tell;
 707    budget = enc->storage*8;
 708    tell = ec_tell(enc);
 709    logp = isTransient ? 2 : 4;
 710    /* Reserve space to code the tf_select decision. */
 711    tf_select_rsv = LM>0 && tell+logp+1 <= budget;
 712    budget -= tf_select_rsv;
 713    curr = tf_changed = 0;
 714    for (i=start;i<end;i++)
 715    {
 716       if (tell+logp<=budget)
 717       {
 718          ec_enc_bit_logp(enc, tf_res[i] ^ curr, logp);
 719          tell = ec_tell(enc);
 720          curr = tf_res[i];
 721          tf_changed |= curr;
 722       }
 723       else
 724          tf_res[i] = curr;
 725       logp = isTransient ? 4 : 5;
 726    }
 727    /* Only code tf_select if it would actually make a difference. */
 728    if (tf_select_rsv &&
 729          tf_select_table[LM][4*isTransient+0+tf_changed]!=
 730          tf_select_table[LM][4*isTransient+2+tf_changed])
 731       ec_enc_bit_logp(enc, tf_select, 1);
 732    else
 733       tf_select = 0;
 734    for (i=start;i<end;i++)
 735       tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]];
 736    /*printf("%d %d ", isTransient, tf_select); for(i=0;i<end;i++)printf("%d ", tf_res[i]);printf("\n");*/
 737 }
 738
 739 static void tf_decode(int start, int end, int isTransient, int *tf_res, int LM, ec_dec *dec)
 740 {
 741    int i, curr, tf_select;
 742    int tf_select_rsv;
 743    int tf_changed;
 744    int logp;
 745    opus_uint32 budget;
 746    opus_uint32 tell;
 747
 748    budget = dec->storage*8;
 749    tell = ec_tell(dec);
 750    logp = isTransient ? 2 : 4;
 751    tf_select_rsv = LM>0 && tell+logp+1<=budget;
 752    budget -= tf_select_rsv;
 753    tf_changed = curr = 0;
 754    for (i=start;i<end;i++)
 755    {
 756       if (tell+logp<=budget)
 757       {
 758          curr ^= ec_dec_bit_logp(dec, logp);
 759          tell = ec_tell(dec);
 760          tf_changed |= curr;
 761       }
 762       tf_res[i] = curr;
 763       logp = isTransient ? 4 : 5;
 764    }
 765    tf_select = 0;
 766    if (tf_select_rsv &&
 767      tf_select_table[LM][4*isTransient+0+tf_changed] !=
 768      tf_select_table[LM][4*isTransient+2+tf_changed])
 769    {
 770       tf_select = ec_dec_bit_logp(dec, 1);
 771    }
 772    for (i=start;i<end;i++)
 773    {
 774       tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]];
 775    }
 776 }
 777
 778 static void init_caps(const CELTMode *m,int *cap,int LM,int C)
 779 {
 780    int i;
 781    for (i=0;i<m->nbEBands;i++)
 782    {
 783       int N;
 784       N=(m->eBands[i+1]-m->eBands[i])<<LM;
 785       cap[i] = (m->cache.caps[m->nbEBands*(2*LM+C-1)+i]+64)*C*N>>2;
 786    }
 787 }
 788
 789 static int alloc_trim_analysis(const CELTMode *m, const celt_norm *X,
 790       const opus_val16 *bandLogE, int end, int LM, int C, int N0)
 791 {
 792    int i;
 793    opus_val32 diff=0;
 794    int c;
 795    int trim_index = 5;
 796    if (C==2)
 797    {
 798       opus_val16 sum = 0; /* Q10 */
 799       /* Compute inter-channel correlation for low frequencies */
 800       for (i=0;i<8;i++)
 801       {
 802          int j;
 803          opus_val32 partial = 0;
 804          for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++)
 805             partial = MAC16_16(partial, X[j], X[N0+j]);
 806          sum = ADD16(sum, EXTRACT16(SHR32(partial, 18)));
 807       }
 808       sum = MULT16_16_Q15(QCONST16(1.f/8, 15), sum);
 809       /*printf ("%f\n", sum);*/
 810       if (sum > QCONST16(.995f,10))
 811          trim_index-=4;
 812       else if (sum > QCONST16(.92f,10))
 813          trim_index-=3;
 814       else if (sum > QCONST16(.85f,10))
 815          trim_index-=2;
 816       else if (sum > QCONST16(.8f,10))
 817          trim_index-=1;
 818    }
 819
 820    /* Estimate spectral tilt */
 821    c=0; do {
 822       for (i=0;i<end-1;i++)
 823       {
 824          diff += bandLogE[i+c*m->nbEBands]*(opus_int32)(2+2*i-m->nbEBands);
 825       }
 826    } while (++c<C);
 827    /* We divide by two here to avoid making the tilt larger for stereo as a
 828       result of a bug in the loop above */
 829    diff /= 2*C*(end-1);
 830    /*printf("%f\n", diff);*/
 831    if (diff > QCONST16(2.f, DB_SHIFT))
 832       trim_index--;
 833    if (diff > QCONST16(8.f, DB_SHIFT))
 834       trim_index--;
 835    if (diff < -QCONST16(4.f, DB_SHIFT))
 836       trim_index++;
 837    if (diff < -QCONST16(10.f, DB_SHIFT))
 838       trim_index++;
 839
 840    if (trim_index<0)
 841       trim_index = 0;
 842    if (trim_index>10)
 843       trim_index = 10;
 844 #ifdef FUZZING
 845    trim_index = rand()%11;
 846 #endif
 847    return trim_index;
 848 }
 849
 850 static int stereo_analysis(const CELTMode *m, const celt_norm *X,
 851       int LM, int N0)
 852 {
 853    int i;
 854    int thetas;
 855    opus_val32 sumLR = EPSILON, sumMS = EPSILON;
 856
 857    /* Use the L1 norm to model the entropy of the L/R signal vs the M/S signal */
 858    for (i=0;i<13;i++)
 859    {
 860       int j;
 861       for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++)
 862       {
 863          opus_val32 L, R, M, S;
 864          /* We cast to 32-bit first because of the -32768 case */
 865          L = EXTEND32(X[j]);
 866          R = EXTEND32(X[N0+j]);
 867          M = ADD32(L, R);
 868          S = SUB32(L, R);
 869          sumLR = ADD32(sumLR, ADD32(ABS32(L), ABS32(R)));
 870          sumMS = ADD32(sumMS, ADD32(ABS32(M), ABS32(S)));
 871       }
 872    }
 873    sumMS = MULT16_32_Q15(QCONST16(0.707107f, 15), sumMS);
 874    thetas = 13;
 875    /* We don't need thetas for lower bands with LM<=1 */
 876    if (LM<=1)
 877       thetas -= 8;
 878    return MULT16_32_Q15((m->eBands[13]<<(LM+1))+thetas, sumMS)
 879          > MULT16_32_Q15(m->eBands[13]<<(LM+1), sumLR);
 880 }
 881
 882 int celt_encode_with_ec(CELTEncoder * restrict st, const opus_val16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
 883 {
 884    int i, c, N;
 885    opus_int32 bits;
 886    ec_enc _enc;
 887    VARDECL(celt_sig, in);
 888    VARDECL(celt_sig, freq);
 889    VARDECL(celt_norm, X);
 890    VARDECL(celt_ener, bandE);
 891    VARDECL(opus_val16, bandLogE);
 892    VARDECL(int, fine_quant);
 893    VARDECL(opus_val16, error);
 894    VARDECL(int, pulses);
 895    VARDECL(int, cap);
 896    VARDECL(int, offsets);
 897    VARDECL(int, fine_priority);
 898    VARDECL(int, tf_res);
 899    VARDECL(unsigned char, collapse_masks);
 900    celt_sig *prefilter_mem;
 901    opus_val16 *oldBandE, *oldLogE, *oldLogE2;
 902    int shortBlocks=0;
 903    int isTransient=0;
 904    const int CC = st->channels;
 905    const int C = st->stream_channels;
 906    int LM, M;
 907    int tf_select;
 908    int nbFilledBytes, nbAvailableBytes;
 909    int effEnd;
 910    int codedBands;
 911    int tf_sum;
 912    int alloc_trim;
 913    int pitch_index=COMBFILTER_MINPERIOD;
 914    opus_val16 gain1 = 0;
 915    int intensity=0;
 916    int dual_stereo=0;
 917    int effectiveBytes;
 918    opus_val16 pf_threshold;
 919    int dynalloc_logp;
 920    opus_int32 vbr_rate;
 921    opus_int32 total_bits;
 922    opus_int32 total_boost;
 923    opus_int32 balance;
 924    opus_int32 tell;
 925    int prefilter_tapset=0;
 926    int pf_on;
 927    int anti_collapse_rsv;
 928    int anti_collapse_on=0;
 929    int silence=0;
 930    ALLOC_STACK;
 931
 932    if (nbCompressedBytes<2 || pcm==NULL)
 933      return OPUS_BAD_ARG;
 934
 935    frame_size *= st->upsample;
 936    for (LM=0;LM<=st->mode->maxLM;LM++)
 937       if (st->mode->shortMdctSize<<LM==frame_size)
 938          break;
 939    if (LM>st->mode->maxLM)
 940       return OPUS_BAD_ARG;
 941    M=1<<LM;
 942    N = M*st->mode->shortMdctSize;
 943
 944    prefilter_mem = st->in_mem+CC*(st->overlap);
 945    oldBandE = (opus_val16*)(st->in_mem+CC*(2*st->overlap+COMBFILTER_MAXPERIOD));
 946    oldLogE = oldBandE + CC*st->mode->nbEBands;
 947    oldLogE2 = oldLogE + CC*st->mode->nbEBands;
 948
 949    if (enc==NULL)
 950    {
 951       tell=1;
 952       nbFilledBytes=0;
 953    } else {
 954       tell=ec_tell(enc);
 955       nbFilledBytes=(tell+4)>>3;
 956    }
 957
 958 #ifdef CUSTOM_MODES
 959    if (st->signalling && enc==NULL)
 960    {
 961       int tmp = (st->mode->effEBands-st->end)>>1;
 962       st->end = IMAX(1, st->mode->effEBands-tmp);
 963       compressed[0] = tmp<<5;
 964       compressed[0] |= LM<<3;
 965       compressed[0] |= (C==2)<<2;
 966       /* Convert "standard mode" to Opus header */
 967       if (st->mode->Fs==48000 && st->mode->shortMdctSize==120)
 968       {
 969          int c0 = toOpus(compressed[0]);
 970          if (c0<0)
 971             return OPUS_BAD_ARG;
 972          compressed[0] = c0;
 973       }
 974       compressed++;
 975       nbCompressedBytes--;
 976    }
 977 #else
 978    celt_assert(st->signalling==0);
 979 #endif
 980
 981    /* Can't produce more than 1275 output bytes */
 982    nbCompressedBytes = IMIN(nbCompressedBytes,1275);
 983    nbAvailableBytes = nbCompressedBytes - nbFilledBytes;
 984
 985    if (st->vbr && st->bitrate!=OPUS_BITRATE_MAX)
 986    {
 987       opus_int32 den=st->mode->Fs>>BITRES;
 988       vbr_rate=(st->bitrate*frame_size+(den>>1))/den;
 989 #ifdef CUSTOM_MODES
 990       if (st->signalling)
 991          vbr_rate -= 8<<BITRES;
 992 #endif
 993       effectiveBytes = vbr_rate>>(3+BITRES);
 994    } else {
 995       opus_int32 tmp;
 996       vbr_rate = 0;
 997       tmp = st->bitrate*frame_size;
 998       if (tell>1)
 999          tmp += tell;
1000       if (st->bitrate!=OPUS_BITRATE_MAX)
1001          nbCompressedBytes = IMAX(2, IMIN(nbCompressedBytes,
1002                (tmp+4*st->mode->Fs)/(8*st->mode->Fs)-!!st->signalling));
1003       effectiveBytes = nbCompressedBytes;
1004    }
1005
1006    if (enc==NULL)
1007    {
1008       ec_enc_init(&_enc, compressed, nbCompressedBytes);
1009       enc = &_enc;
1010    }
1011
1012    if (vbr_rate>0)
1013    {
1014       /* Computes the max bit-rate allowed in VBR mode to avoid violating the
1015           target rate and buffering.
1016          We must do this up front so that bust-prevention logic triggers
1017           correctly if we don't have enough bits. */
1018       if (st->constrained_vbr)
1019       {
1020          opus_int32 vbr_bound;
1021          opus_int32 max_allowed;
1022          /* We could use any multiple of vbr_rate as bound (depending on the
1023              delay).
1024             This is clamped to ensure we use at least two bytes if the encoder
1025              was entirely empty, but to allow 0 in hybrid mode. */
1026          vbr_bound = vbr_rate;
1027          max_allowed = IMIN(IMAX(tell==1?2:0,
1028                (vbr_rate+vbr_bound-st->vbr_reservoir)>>(BITRES+3)),
1029                nbAvailableBytes);
1030          if(max_allowed < nbAvailableBytes)
1031          {
1032             nbCompressedBytes = nbFilledBytes+max_allowed;
1033             nbAvailableBytes = max_allowed;
1034             ec_enc_shrink(enc, nbCompressedBytes);
1035          }
1036       }
1037    }
1038    total_bits = nbCompressedBytes*8;
1039
1040    effEnd = st->end;
1041    if (effEnd > st->mode->effEBands)
1042       effEnd = st->mode->effEBands;
1043
1044    ALLOC(in, CC*(N+st->overlap), celt_sig);
1045
1046    /* Find pitch period and gain */
1047    {
1048       VARDECL(celt_sig, _pre);
1049       celt_sig *pre[2];
1050       SAVE_STACK;
1051       ALLOC(_pre, CC*(N+COMBFILTER_MAXPERIOD), celt_sig);
1052
1053       pre[0] = _pre;
1054       pre[1] = _pre + (N+COMBFILTER_MAXPERIOD);
1055
1056       silence = 1;
1057       c=0; do {
1058          int count = 0;
1059          const opus_val16 * restrict pcmp = pcm+c;
1060          celt_sig * restrict inp = in+c*(N+st->overlap)+st->overlap;
1061
1062          for (i=0;i<N;i++)
1063          {
1064             celt_sig x, tmp;
1065
1066             x = SCALEIN(*pcmp);
1067 #ifndef FIXED_POINT
1068             if (!(x==x))
1069                x = 0;
1070             if (st->clip)
1071                x = MAX32(-65536.f, MIN32(65536.f,x));
1072 #endif
1073             if (++count==st->upsample)
1074             {
1075                count=0;
1076                pcmp+=CC;
1077             } else {
1078                x = 0;
1079             }
1080             /* Apply pre-emphasis */
1081             tmp = MULT16_16(st->mode->preemph[2], x);
1082             *inp = tmp + st->preemph_memE[c];
1083             st->preemph_memE[c] = MULT16_32_Q15(st->mode->preemph[1], *inp)
1084                                    - MULT16_32_Q15(st->mode->preemph[0], tmp);
1085             silence = silence && *inp == 0;
1086             inp++;
1087          }
1088          OPUS_COPY(pre[c], prefilter_mem+c*COMBFILTER_MAXPERIOD, COMBFILTER_MAXPERIOD);
1089          OPUS_COPY(pre[c]+COMBFILTER_MAXPERIOD, in+c*(N+st->overlap)+st->overlap, N);
1090       } while (++c<CC);
1091
1092 #ifdef FUZZING
1093       if ((rand()&0x3F)==0)
1094          silence = 1;
1095 #endif
1096       if (tell==1)
1097          ec_enc_bit_logp(enc, silence, 15);
1098       else
1099          silence=0;
1100       if (silence)
1101       {
1102          /*In VBR mode there is no need to send more than the minimum. */
1103          if (vbr_rate>0)
1104          {
1105             effectiveBytes=nbCompressedBytes=IMIN(nbCompressedBytes, nbFilledBytes+2);
1106             total_bits=nbCompressedBytes*8;
1107             nbAvailableBytes=2;
1108             ec_enc_shrink(enc, nbCompressedBytes);
1109          }
1110          /* Pretend we've filled all the remaining bits with zeros
1111             (that's what the initialiser did anyway) */
1112          tell = nbCompressedBytes*8;
1113          enc->nbits_total+=tell-ec_tell(enc);
1114       }
1115       if (nbAvailableBytes>12*C && st->start==0 && !silence && !st->disable_pf && st->complexity >= 5)
1116       {
1117          VARDECL(opus_val16, pitch_buf);
1118          ALLOC(pitch_buf, (COMBFILTER_MAXPERIOD+N)>>1, opus_val16);
1119
1120          pitch_downsample(pre, pitch_buf, COMBFILTER_MAXPERIOD+N, CC);
1121          pitch_search(pitch_buf+(COMBFILTER_MAXPERIOD>>1), pitch_buf, N,
1122                COMBFILTER_MAXPERIOD-COMBFILTER_MINPERIOD, &pitch_index);
1123          pitch_index = COMBFILTER_MAXPERIOD-pitch_index;
1124
1125          gain1 = remove_doubling(pitch_buf, COMBFILTER_MAXPERIOD, COMBFILTER_MINPERIOD,
1126                N, &pitch_index, st->prefilter_period, st->prefilter_gain);
1127          if (pitch_index > COMBFILTER_MAXPERIOD-2)
1128             pitch_index = COMBFILTER_MAXPERIOD-2;
1129          gain1 = MULT16_16_Q15(QCONST16(.7f,15),gain1);
1130          if (st->loss_rate>2)
1131             gain1 = HALF32(gain1);
1132          if (st->loss_rate>4)
1133             gain1 = HALF32(gain1);
1134          if (st->loss_rate>8)
1135             gain1 = 0;
1136          prefilter_tapset = st->tapset_decision;
1137       } else {
1138          gain1 = 0;
1139       }
1140
1141       /* Gain threshold for enabling the prefilter/postfilter */
1142       pf_threshold = QCONST16(.2f,15);
1143
1144       /* Adjusting the threshold based on rate and continuity */
1145       if (abs(pitch_index-st->prefilter_period)*10>pitch_index)
1146          pf_threshold += QCONST16(.2f,15);
1147       if (nbAvailableBytes<25)
1148          pf_threshold += QCONST16(.1f,15);
1149       if (nbAvailableBytes<35)
1150          pf_threshold += QCONST16(.1f,15);
1151       if (st->prefilter_gain > QCONST16(.4f,15))
1152          pf_threshold -= QCONST16(.1f,15);
1153       if (st->prefilter_gain > QCONST16(.55f,15))
1154          pf_threshold -= QCONST16(.1f,15);
1155
1156       /* Hard threshold at 0.2 */
1157       pf_threshold = MAX16(pf_threshold, QCONST16(.2f,15));
1158       if (gain1<pf_threshold)
1159       {
1160          if(st->start==0 && tell+16<=total_bits)
1161             ec_enc_bit_logp(enc, 0, 1);
1162          gain1 = 0;
1163          pf_on = 0;
1164       } else {
1165          /*This block is not gated by a total bits check only because
1166            of the nbAvailableBytes check above.*/
1167          int qg;
1168          int octave;
1169
1170          if (ABS16(gain1-st->prefilter_gain)<QCONST16(.1f,15))
1171             gain1=st->prefilter_gain;
1172
1173 #ifdef FIXED_POINT
1174          qg = ((gain1+1536)>>10)/3-1;
1175 #else
1176          qg = (int)floor(.5f+gain1*32/3)-1;
1177 #endif
1178          qg = IMAX(0, IMIN(7, qg));
1179          ec_enc_bit_logp(enc, 1, 1);
1180          pitch_index += 1;
1181          octave = EC_ILOG(pitch_index)-5;
1182          ec_enc_uint(enc, octave, 6);
1183          ec_enc_bits(enc, pitch_index-(16<<octave), 4+octave);
1184          pitch_index -= 1;
1185          ec_enc_bits(enc, qg, 3);
1186          if (ec_tell(enc)+2<=total_bits)
1187             ec_enc_icdf(enc, prefilter_tapset, tapset_icdf, 2);
1188          else
1189            prefilter_tapset = 0;
1190          gain1 = QCONST16(0.09375f,15)*(qg+1);
1191          pf_on = 1;
1192       }
1193       /*printf("%d %f\n", pitch_index, gain1);*/
1194
1195       c=0; do {
1196          int offset = st->mode->shortMdctSize-st->mode->overlap;
1197          st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
1198          OPUS_COPY(in+c*(N+st->overlap), st->in_mem+c*(st->overlap), st->overlap);
1199          if (offset)
1200             comb_filter(in+c*(N+st->overlap)+st->overlap, pre[c]+COMBFILTER_MAXPERIOD,
1201                   st->prefilter_period, st->prefilter_period, offset, -st->prefilter_gain, -st->prefilter_gain,
1202                   st->prefilter_tapset, st->prefilter_tapset, NULL, 0);
1203
1204          comb_filter(in+c*(N+st->overlap)+st->overlap+offset, pre[c]+COMBFILTER_MAXPERIOD+offset,
1205                st->prefilter_period, pitch_index, N-offset, -st->prefilter_gain, -gain1,
1206                st->prefilter_tapset, prefilter_tapset, st->mode->window, st->mode->overlap);
1207          OPUS_COPY(st->in_mem+c*(st->overlap), in+c*(N+st->overlap)+N, st->overlap);
1208
1209          if (N>COMBFILTER_MAXPERIOD)
1210          {
1211             OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, pre[c]+N, COMBFILTER_MAXPERIOD);
1212          } else {
1213             OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, prefilter_mem+c*COMBFILTER_MAXPERIOD+N, COMBFILTER_MAXPERIOD-N);
1214             OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD+COMBFILTER_MAXPERIOD-N, pre[c]+COMBFILTER_MAXPERIOD, N);
1215          }
1216       } while (++c<CC);
1217
1218       RESTORE_STACK;
1219    }
1220
1221    isTransient = 0;
1222    shortBlocks = 0;
1223    if (LM>0 && ec_tell(enc)+3<=total_bits)
1224    {
1225       if (st->complexity > 1)
1226       {
1227          isTransient = transient_analysis(in, N+st->overlap, CC,
1228                   st->overlap);
1229          if (isTransient)
1230             shortBlocks = M;
1231       }
1232       ec_enc_bit_logp(enc, isTransient, 3);
1233    }
1234
1235    ALLOC(freq, CC*N, celt_sig); /**< Interleaved signal MDCTs */
1236    ALLOC(bandE,st->mode->nbEBands*CC, celt_ener);
1237    ALLOC(bandLogE,st->mode->nbEBands*CC, opus_val16);
1238    /* Compute MDCTs */
1239    compute_mdcts(st->mode, shortBlocks, in, freq, CC, LM);
1240
1241    if (CC==2&&C==1)
1242    {
1243       for (i=0;i<N;i++)
1244          freq[i] = ADD32(HALF32(freq[i]), HALF32(freq[N+i]));
1245    }
1246    if (st->upsample != 1)
1247    {
1248       c=0; do
1249       {
1250          int bound = N/st->upsample;
1251          for (i=0;i<bound;i++)
1252             freq[c*N+i] *= st->upsample;
1253          for (;i<N;i++)
1254             freq[c*N+i] = 0;
1255       } while (++c<C);
1256    }
1257    ALLOC(X, C*N, celt_norm);         /**< Interleaved normalised MDCTs */
1258
1259    compute_band_energies(st->mode, freq, bandE, effEnd, C, M);
1260
1261    amp2Log2(st->mode, effEnd, st->end, bandE, bandLogE, C);
1262
1263    /* Band normalisation */
1264    normalise_bands(st->mode, freq, X, bandE, effEnd, C, M);
1265
1266    ALLOC(tf_res, st->mode->nbEBands, int);
1267    tf_select = tf_analysis(st->mode, effEnd, C, isTransient, tf_res, effectiveBytes, X, N, LM, &tf_sum);
1268    for (i=effEnd;i<st->end;i++)
1269       tf_res[i] = tf_res[effEnd-1];
1270
1271    ALLOC(error, C*st->mode->nbEBands, opus_val16);
1272    quant_coarse_energy(st->mode, st->start, st->end, effEnd, bandLogE,
1273          oldBandE, total_bits, error, enc,
1274          C, LM, nbAvailableBytes, st->force_intra,
1275          &st->delayedIntra, st->complexity >= 4, st->loss_rate);
1276
1277    tf_encode(st->start, st->end, isTransient, tf_res, LM, tf_select, enc);
1278
1279    st->spread_decision = SPREAD_NORMAL;
1280    if (ec_tell(enc)+4<=total_bits)
1281    {
1282       if (shortBlocks || st->complexity < 3 || nbAvailableBytes < 10*C)
1283       {
1284          if (st->complexity == 0)
1285             st->spread_decision = SPREAD_NONE;
1286       } else {
1287          st->spread_decision = spreading_decision(st->mode, X,
1288                &st->tonal_average, st->spread_decision, &st->hf_average,
1289                &st->tapset_decision, pf_on&&!shortBlocks, effEnd, C, M);
1290       }
1291       ec_enc_icdf(enc, st->spread_decision, spread_icdf, 5);
1292    }
1293
1294    ALLOC(cap, st->mode->nbEBands, int);
1295    ALLOC(offsets, st->mode->nbEBands, int);
1296
1297    init_caps(st->mode,cap,LM,C);
1298    for (i=0;i<st->mode->nbEBands;i++)
1299       offsets[i] = 0;
1300    /* Dynamic allocation code */
1301    /* Make sure that dynamic allocation can't make us bust the budget */
1302    if (effectiveBytes > 50 && LM>=1)
1303    {
1304       int t1, t2;
1305       if (LM <= 1)
1306       {
1307          t1 = 3;
1308          t2 = 5;
1309       } else {
1310          t1 = 2;
1311          t2 = 4;
1312       }
1313       for (i=st->start+1;i<st->end-1;i++)
1314       {
1315          opus_val32 d2;
1316          d2 = 2*bandLogE[i]-bandLogE[i-1]-bandLogE[i+1];
1317          if (C==2)
1318             d2 = HALF32(d2 + 2*bandLogE[i+st->mode->nbEBands]-
1319                   bandLogE[i-1+st->mode->nbEBands]-bandLogE[i+1+st->mode->nbEBands]);
1320 #ifdef FUZZING
1321          if((rand()&0xF)==0)
1322          {
1323             offsets[i] += 1;
1324             if((rand()&0x3)==0)
1325                offsets[i] += 1+(rand()&0x3);
1326          }
1327 #else
1328          if (d2 > SHL16(t1,DB_SHIFT))
1329             offsets[i] += 1;
1330          if (d2 > SHL16(t2,DB_SHIFT))
1331             offsets[i] += 1;
1332 #endif
1333       }
1334    }
1335    dynalloc_logp = 6;
1336    total_bits<<=BITRES;
1337    total_boost = 0;
1338    tell = ec_tell_frac(enc);
1339    for (i=st->start;i<st->end;i++)
1340    {
1341       int width, quanta;
1342       int dynalloc_loop_logp;
1343       int boost;
1344       int j;
1345       width = C*(st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
1346       /* quanta is 6 bits, but no more than 1 bit/sample
1347          and no less than 1/8 bit/sample */
1348       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
1349       dynalloc_loop_logp = dynalloc_logp;
1350       boost = 0;
1351       for (j = 0; tell+(dynalloc_loop_logp<<BITRES) < total_bits-total_boost
1352             && boost < cap[i]; j++)
1353       {
1354          int flag;
1355          flag = j<offsets[i];
1356          ec_enc_bit_logp(enc, flag, dynalloc_loop_logp);
1357          tell = ec_tell_frac(enc);
1358          if (!flag)
1359             break;
1360          boost += quanta;
1361          total_boost += quanta;
1362          dynalloc_loop_logp = 1;
1363       }
1364       /* Making dynalloc more likely */
1365       if (j)
1366          dynalloc_logp = IMAX(2, dynalloc_logp-1);
1367       offsets[i] = boost;
1368    }
1369    alloc_trim = 5;
1370    if (tell+(6<<BITRES) <= total_bits - total_boost)
1371    {
1372       alloc_trim = alloc_trim_analysis(st->mode, X, bandLogE,
1373             st->end, LM, C, N);
1374       ec_enc_icdf(enc, alloc_trim, trim_icdf, 7);
1375       tell = ec_tell_frac(enc);
1376    }
1377
1378    /* Variable bitrate */
1379    if (vbr_rate>0)
1380    {
1381      opus_val16 alpha;
1382      opus_int32 delta;
1383      /* The target rate in 8th bits per frame */
1384      opus_int32 target;
1385      opus_int32 min_allowed;
1386      int lm_diff = st->mode->maxLM - LM;
1387
1388      /* Don't attempt to use more than 510 kb/s, even for frames smaller than 20 ms.
1389         The CELT allocator will just not be able to use more than that anyway. */
1390      nbCompressedBytes = IMIN(nbCompressedBytes,1275>>(3-LM));
1391      target = vbr_rate + (st->vbr_offset>>lm_diff) - ((40*C+20)<<BITRES);
1392
1393      /* Shortblocks get a large boost in bitrate, but since they
1394         are uncommon long blocks are not greatly affected */
1395      if (shortBlocks || tf_sum < -2*(st->end-st->start))
1396         target = 7*target/4;
1397      else if (tf_sum < -(st->end-st->start))
1398         target = 3*target/2;
1399      else if (M > 1)
1400         target-=(target+14)/28;
1401
1402      /* The current offset is removed from the target and the space used
1403         so far is added*/
1404      target=target+tell;
1405
1406      /* In VBR mode the frame size must not be reduced so much that it would
1407          result in the encoder running out of bits.
1408         The margin of 2 bytes ensures that none of the bust-prevention logic
1409          in the decoder will have triggered so far. */
1410      min_allowed = ((tell+total_boost+(1<<(BITRES+3))-1)>>(BITRES+3)) + 2 - nbFilledBytes;
1411
1412      nbAvailableBytes = (target+(1<<(BITRES+2)))>>(BITRES+3);
1413      nbAvailableBytes = IMAX(min_allowed,nbAvailableBytes);
1414      nbAvailableBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes) - nbFilledBytes;
1415
1416      /* By how much did we "miss" the target on that frame */
1417      delta = target - vbr_rate;
1418
1419      target=nbAvailableBytes<<(BITRES+3);
1420
1421      /*If the frame is silent we don't adjust our drift, otherwise
1422        the encoder will shoot to very high rates after hitting a
1423        span of silence, but we do allow the bitres to refill.
1424        This means that we'll undershoot our target in CVBR/VBR modes
1425        on files with lots of silence. */
1426      if(silence)
1427      {
1428        nbAvailableBytes = 2;
1429        target = 2*8<<BITRES;
1430        delta = 0;
1431      }
1432
1433      if (st->vbr_count < 970)
1434      {
1435         st->vbr_count++;
1436         alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+20),16));
1437      } else
1438         alpha = QCONST16(.001f,15);
1439      /* How many bits have we used in excess of what we're allowed */
1440      if (st->constrained_vbr)
1441         st->vbr_reservoir += target - vbr_rate;
1442      /*printf ("%d\n", st->vbr_reservoir);*/
1443
1444      /* Compute the offset we need to apply in order to reach the target */
1445      st->vbr_drift += (opus_int32)MULT16_32_Q15(alpha,(delta*(1<<lm_diff))-st->vbr_offset-st->vbr_drift);
1446      st->vbr_offset = -st->vbr_drift;
1447      /*printf ("%d\n", st->vbr_drift);*/
1448
1449      if (st->constrained_vbr && st->vbr_reservoir < 0)
1450      {
1451         /* We're under the min value -- increase rate */
1452         int adjust = (-st->vbr_reservoir)/(8<<BITRES);
1453         /* Unless we're just coding silence */
1454         nbAvailableBytes += silence?0:adjust;
1455         st->vbr_reservoir = 0;
1456         /*printf ("+%d\n", adjust);*/
1457      }
1458      nbCompressedBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes);
1459      /* This moves the raw bits to take into account the new compressed size */
1460      ec_enc_shrink(enc, nbCompressedBytes);
1461    }
1462    if (C==2)
1463    {
1464       int effectiveRate;
1465
1466       /* Always use MS for 2.5 ms frames until we can do a better analysis */
1467       if (LM!=0)
1468          dual_stereo = stereo_analysis(st->mode, X, LM, N);
1469
1470       /* Account for coarse energy */
1471       effectiveRate = (8*effectiveBytes - 80)>>LM;
1472
1473       /* effectiveRate in kb/s */
1474       effectiveRate = 2*effectiveRate/5;
1475       if (effectiveRate<35)
1476          intensity = 8;
1477       else if (effectiveRate<50)
1478          intensity = 12;
1479       else if (effectiveRate<68)
1480          intensity = 16;
1481       else if (effectiveRate<84)
1482          intensity = 18;
1483       else if (effectiveRate<102)
1484          intensity = 19;
1485       else if (effectiveRate<130)
1486          intensity = 20;
1487       else
1488          intensity = 100;
1489       intensity = IMIN(st->end,IMAX(st->start, intensity));
1490    }
1491
1492    /* Bit allocation */
1493    ALLOC(fine_quant, st->mode->nbEBands, int);
1494    ALLOC(pulses, st->mode->nbEBands, int);
1495    ALLOC(fine_priority, st->mode->nbEBands, int);
1496
1497    /* bits =           packet size                    - where we are - safety*/
1498    bits = (((opus_int32)nbCompressedBytes*8)<<BITRES) - ec_tell_frac(enc) - 1;
1499    anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0;
1500    bits -= anti_collapse_rsv;
1501    codedBands = compute_allocation(st->mode, st->start, st->end, offsets, cap,
1502          alloc_trim, &intensity, &dual_stereo, bits, &balance, pulses,
1503          fine_quant, fine_priority, C, LM, enc, 1, st->lastCodedBands);
1504    st->lastCodedBands = codedBands;
1505
1506    quant_fine_energy(st->mode, st->start, st->end, oldBandE, error, fine_quant, enc, C);
1507
1508 #ifdef MEASURE_NORM_MSE
1509    float X0[3000];
1510    float bandE0[60];
1511    c=0; do
1512       for (i=0;i<N;i++)
1513          X0[i+c*N] = X[i+c*N];
1514    while (++c<C);
1515    for (i=0;i<C*st->mode->nbEBands;i++)
1516       bandE0[i] = bandE[i];
1517 #endif
1518
1519    /* Residual quantisation */
1520    ALLOC(collapse_masks, C*st->mode->nbEBands, unsigned char);
1521    quant_all_bands(1, st->mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
1522          bandE, pulses, shortBlocks, st->spread_decision, dual_stereo, intensity, tf_res,
1523          nbCompressedBytes*(8<<BITRES)-anti_collapse_rsv, balance, enc, LM, codedBands, &st->rng);
1524
1525    if (anti_collapse_rsv > 0)
1526    {
1527       anti_collapse_on = st->consec_transient<2;
1528 #ifdef FUZZING
1529       anti_collapse_on = rand()&0x1;
1530 #endif
1531       ec_enc_bits(enc, anti_collapse_on, 1);
1532    }
1533    quant_energy_finalise(st->mode, st->start, st->end, oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_tell(enc), enc, C);
1534
1535    if (silence)
1536    {
1537       for (i=0;i<C*st->mode->nbEBands;i++)
1538          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
1539    }
1540
1541 #ifdef RESYNTH
1542    /* Re-synthesis of the coded audio if required */
1543    {
1544       celt_sig *out_mem[2];
1545       celt_sig *overlap_mem[2];
1546
1547       log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
1548       if (silence)
1549       {
1550          for (i=0;i<C*st->mode->nbEBands;i++)
1551             bandE[i] = 0;
1552       }
1553
1554 #ifdef MEASURE_NORM_MSE
1555       measure_norm_mse(st->mode, X, X0, bandE, bandE0, M, N, C);
1556 #endif
1557       if (anti_collapse_on)
1558       {
1559          anti_collapse(st->mode, X, collapse_masks, LM, C, N,
1560                st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
1561       }
1562
1563       /* Synthesis */
1564       denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
1565
1566       OPUS_MOVE(st->syn_mem[0], st->syn_mem[0]+N, MAX_PERIOD);
1567       if (CC==2)
1568          OPUS_MOVE(st->syn_mem[1], st->syn_mem[1]+N, MAX_PERIOD);
1569
1570       c=0; do
1571          for (i=0;i<M*st->mode->eBands[st->start];i++)
1572             freq[c*N+i] = 0;
1573       while (++c<C);
1574       c=0; do
1575          for (i=M*st->mode->eBands[st->end];i<N;i++)
1576             freq[c*N+i] = 0;
1577       while (++c<C);
1578
1579       if (CC==2&&C==1)
1580       {
1581          for (i=0;i<N;i++)
1582             freq[N+i] = freq[i];
1583       }
1584
1585       out_mem[0] = st->syn_mem[0]+MAX_PERIOD;
1586       if (CC==2)
1587          out_mem[1] = st->syn_mem[1]+MAX_PERIOD;
1588
1589       overlap_mem[0] = prefilter_mem+CC*COMBFILTER_MAXPERIOD;
1590       if (CC==2)
1591          overlap_mem[1] = overlap_mem[0] + st->overlap;
1592
1593       compute_inv_mdcts(st->mode, shortBlocks, freq, out_mem, overlap_mem, CC, LM);
1594
1595       c=0; do {
1596          st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
1597          st->prefilter_period_old=IMAX(st->prefilter_period_old, COMBFILTER_MINPERIOD);
1598          comb_filter(out_mem[c], out_mem[c], st->prefilter_period_old, st->prefilter_period, st->mode->shortMdctSize,
1599                st->prefilter_gain_old, st->prefilter_gain, st->prefilter_tapset_old, st->prefilter_tapset,
1600                st->mode->window, st->overlap);
1601          if (LM!=0)
1602             comb_filter(out_mem[c]+st->mode->shortMdctSize, out_mem[c]+st->mode->shortMdctSize, st->prefilter_period, pitch_index, N-st->mode->shortMdctSize,
1603                   st->prefilter_gain, gain1, st->prefilter_tapset, prefilter_tapset,
1604                   st->mode->window, st->mode->overlap);
1605       } while (++c<CC);
1606
1607       deemphasis(out_mem, (opus_val16*)pcm, N, CC, st->upsample, st->mode->preemph, st->preemph_memD);
1608       st->prefilter_period_old = st->prefilter_period;
1609       st->prefilter_gain_old = st->prefilter_gain;
1610       st->prefilter_tapset_old = st->prefilter_tapset;
1611    }
1612 #endif
1613
1614    st->prefilter_period = pitch_index;
1615    st->prefilter_gain = gain1;
1616    st->prefilter_tapset = prefilter_tapset;
1617 #ifdef RESYNTH
1618    if (LM!=0)
1619    {
1620       st->prefilter_period_old = st->prefilter_period;
1621       st->prefilter_gain_old = st->prefilter_gain;
1622       st->prefilter_tapset_old = st->prefilter_tapset;
1623    }
1624 #endif
1625
1626    if (CC==2&&C==1) {
1627       for (i=0;i<st->mode->nbEBands;i++)
1628          oldBandE[st->mode->nbEBands+i]=oldBandE[i];
1629    }
1630
1631    if (!isTransient)
1632    {
1633       for (i=0;i<CC*st->mode->nbEBands;i++)
1634          oldLogE2[i] = oldLogE[i];
1635       for (i=0;i<CC*st->mode->nbEBands;i++)
1636          oldLogE[i] = oldBandE[i];
1637    } else {
1638       for (i=0;i<CC*st->mode->nbEBands;i++)
1639          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
1640    }
1641    /* In case start or end were to change */
1642    c=0; do
1643    {
1644       for (i=0;i<st->start;i++)
1645       {
1646          oldBandE[c*st->mode->nbEBands+i]=0;
1647          oldLogE[c*st->mode->nbEBands+i]=oldLogE2[c*st->mode->nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
1648       }
1649       for (i=st->end;i<st->mode->nbEBands;i++)
1650       {
1651          oldBandE[c*st->mode->nbEBands+i]=0;
1652          oldLogE[c*st->mode->nbEBands+i]=oldLogE2[c*st->mode->nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
1653       }
1654    } while (++c<CC);
1655
1656    if (isTransient)
1657       st->consec_transient++;
1658    else
1659       st->consec_transient=0;
1660    st->rng = enc->rng;
1661
1662    /* If there's any room left (can only happen for very high rates),
1663       it's already filled with zeros */
1664    ec_enc_done(enc);
1665
1666 #ifdef CUSTOM_MODES
1667    if (st->signalling)
1668       nbCompressedBytes++;
1669 #endif
1670
1671    RESTORE_STACK;
1672    if (ec_get_error(enc))
1673       return OPUS_INTERNAL_ERROR;
1674    else
1675       return nbCompressedBytes;
1676 }
1677
1678
1679 #ifdef CUSTOM_MODES
1680
1681 #ifdef FIXED_POINT
1682 int opus_custom_encode(CELTEncoder * restrict st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1683 {
1684    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1685 }
1686
1687 #ifndef DISABLE_FLOAT_API
1688 int opus_custom_encode_float(CELTEncoder * restrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1689 {
1690    int j, ret, C, N;
1691    VARDECL(opus_int16, in);
1692    ALLOC_STACK;
1693
1694    if (pcm==NULL)
1695       return OPUS_BAD_ARG;
1696
1697    C = st->channels;
1698    N = frame_size;
1699    ALLOC(in, C*N, opus_int16);
1700
1701    for (j=0;j<C*N;j++)
1702      in[j] = FLOAT2INT16(pcm[j]);
1703
1704    ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
1705 #ifdef RESYNTH
1706    for (j=0;j<C*N;j++)
1707       ((float*)pcm)[j]=in[j]*(1.f/32768.f);
1708 #endif
1709    RESTORE_STACK;
1710    return ret;
1711 }
1712 #endif /* DISABLE_FLOAT_API */
1713 #else
1714
1715 int opus_custom_encode(CELTEncoder * restrict st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1716 {
1717    int j, ret, C, N;
1718    VARDECL(celt_sig, in);
1719    ALLOC_STACK;
1720
1721    if (pcm==NULL)
1722       return OPUS_BAD_ARG;
1723
1724    C=st->channels;
1725    N=frame_size;
1726    ALLOC(in, C*N, celt_sig);
1727    for (j=0;j<C*N;j++) {
1728      in[j] = SCALEOUT(pcm[j]);
1729    }
1730
1731    ret = celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
1732 #ifdef RESYNTH
1733    for (j=0;j<C*N;j++)
1734       ((opus_int16*)pcm)[j] = FLOAT2INT16(in[j]);
1735 #endif
1736    RESTORE_STACK;
1737    return ret;
1738 }
1739
1740 int opus_custom_encode_float(CELTEncoder * restrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1741 {
1742    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1743 }
1744
1745 #endif
1746
1747 #endif /* CUSTOM_MODES */
1748
1749 int opus_custom_encoder_ctl(CELTEncoder * restrict st, int request, ...)
1750 {
1751    va_list ap;
1752
1753    va_start(ap, request);
1754    switch (request)
1755    {
1756       case OPUS_SET_COMPLEXITY_REQUEST:
1757       {
1758          int value = va_arg(ap, opus_int32);
1759          if (value<0 || value>10)
1760             goto bad_arg;
1761          st->complexity = value;
1762       }
1763       break;
1764       case CELT_SET_START_BAND_REQUEST:
1765       {
1766          opus_int32 value = va_arg(ap, opus_int32);
1767          if (value<0 || value>=st->mode->nbEBands)
1768             goto bad_arg;
1769          st->start = value;
1770       }
1771       break;
1772       case CELT_SET_END_BAND_REQUEST:
1773       {
1774          opus_int32 value = va_arg(ap, opus_int32);
1775          if (value<1 || value>st->mode->nbEBands)
1776             goto bad_arg;
1777          st->end = value;
1778       }
1779       break;
1780       case CELT_SET_PREDICTION_REQUEST:
1781       {
1782          int value = va_arg(ap, opus_int32);
1783          if (value<0 || value>2)
1784             goto bad_arg;
1785          st->disable_pf = value<=1;
1786          st->force_intra = value==0;
1787       }
1788       break;
1789       case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1790       {
1791          int value = va_arg(ap, opus_int32);
1792          if (value<0 || value>100)
1793             goto bad_arg;
1794          st->loss_rate = value;
1795       }
1796       break;
1797       case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1798       {
1799          opus_int32 value = va_arg(ap, opus_int32);
1800          st->constrained_vbr = value;
1801       }
1802       break;
1803       case OPUS_SET_VBR_REQUEST:
1804       {
1805          opus_int32 value = va_arg(ap, opus_int32);
1806          st->vbr = value;
1807       }
1808       break;
1809       case OPUS_SET_BITRATE_REQUEST:
1810       {
1811          opus_int32 value = va_arg(ap, opus_int32);
1812          if (value<=500 && value!=OPUS_BITRATE_MAX)
1813             goto bad_arg;
1814          value = IMIN(value, 260000*st->channels);
1815          st->bitrate = value;
1816       }
1817       break;
1818       case CELT_SET_CHANNELS_REQUEST:
1819       {
1820          opus_int32 value = va_arg(ap, opus_int32);
1821          if (value<1 || value>2)
1822             goto bad_arg;
1823          st->stream_channels = value;
1824       }
1825       break;
1826       case OPUS_RESET_STATE:
1827       {
1828          int i;
1829          opus_val16 *oldBandE, *oldLogE, *oldLogE2;
1830          oldBandE = (opus_val16*)(st->in_mem+st->channels*(2*st->overlap+COMBFILTER_MAXPERIOD));
1831          oldLogE = oldBandE + st->channels*st->mode->nbEBands;
1832          oldLogE2 = oldLogE + st->channels*st->mode->nbEBands;
1833          OPUS_CLEAR((char*)&st->ENCODER_RESET_START,
1834                opus_custom_encoder_get_size(st->mode, st->channels)-
1835                ((char*)&st->ENCODER_RESET_START - (char*)st));
1836          for (i=0;i<st->channels*st->mode->nbEBands;i++)
1837             oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT);
1838          st->vbr_offset = 0;
1839          st->delayedIntra = 1;
1840          st->spread_decision = SPREAD_NORMAL;
1841          st->tonal_average = 256;
1842          st->hf_average = 0;
1843          st->tapset_decision = 0;
1844       }
1845       break;
1846 #ifdef CUSTOM_MODES
1847       case CELT_SET_INPUT_CLIPPING_REQUEST:
1848       {
1849          opus_int32 value = va_arg(ap, opus_int32);
1850          st->clip = value;
1851       }
1852       break;
1853 #endif
1854       case CELT_SET_SIGNALLING_REQUEST:
1855       {
1856          opus_int32 value = va_arg(ap, opus_int32);
1857          st->signalling = value;
1858       }
1859       break;
1860       case CELT_GET_MODE_REQUEST:
1861       {
1862          const CELTMode ** value = va_arg(ap, const CELTMode**);
1863          if (value==0)
1864             goto bad_arg;
1865          *value=st->mode;
1866       }
1867       break;
1868       case OPUS_GET_FINAL_RANGE_REQUEST:
1869       {
1870          opus_uint32 * value = va_arg(ap, opus_uint32 *);
1871          if (value==0)
1872             goto bad_arg;
1873          *value=st->rng;
1874       }
1875       break;
1876       default:
1877          goto bad_request;
1878    }
1879    va_end(ap);
1880    return OPUS_OK;
1881 bad_arg:
1882    va_end(ap);
1883    return OPUS_BAD_ARG;
1884 bad_request:
1885    va_end(ap);
1886    return OPUS_UNIMPLEMENTED;
1887 }
1888
1889 /**********************************************************************/
1890 /*                                                                    */
1891 /*                             DECODER                                */
1892 /*                                                                    */
1893 /**********************************************************************/
1894 #define DECODE_BUFFER_SIZE 2048
1895
1896 /** Decoder state
1897  @brief Decoder state
1898  */
1899 struct OpusCustomDecoder {
1900    const OpusCustomMode *mode;
1901    int overlap;
1902    int channels;
1903    int stream_channels;
1904
1905    int downsample;
1906    int start, end;
1907    int signalling;
1908
1909    /* Everything beyond this point gets cleared on a reset */
1910 #define DECODER_RESET_START rng
1911
1912    opus_uint32 rng;
1913    int error;
1914    int last_pitch_index;
1915    int loss_count;
1916    int postfilter_period;
1917    int postfilter_period_old;
1918    opus_val16 postfilter_gain;
1919    opus_val16 postfilter_gain_old;
1920    int postfilter_tapset;
1921    int postfilter_tapset_old;
1922
1923    celt_sig preemph_memD[2];
1924
1925    celt_sig _decode_mem[1]; /* Size = channels*(DECODE_BUFFER_SIZE+mode->overlap) */
1926    /* opus_val16 lpc[],  Size = channels*LPC_ORDER */
1927    /* opus_val16 oldEBands[], Size = 2*mode->nbEBands */
1928    /* opus_val16 oldLogE[], Size = 2*mode->nbEBands */
1929    /* opus_val16 oldLogE2[], Size = 2*mode->nbEBands */
1930    /* opus_val16 backgroundLogE[], Size = 2*mode->nbEBands */
1931 };
1932
1933 int celt_decoder_get_size(int channels)
1934 {
1935    const CELTMode *mode = opus_custom_mode_create(48000, 960, NULL);
1936    return opus_custom_decoder_get_size(mode, channels);
1937 }
1938
1939 OPUS_CUSTOM_NOSTATIC int opus_custom_decoder_get_size(const CELTMode *mode, int channels)
1940 {
1941    int size = sizeof(struct CELTDecoder)
1942             + (channels*(DECODE_BUFFER_SIZE+mode->overlap)-1)*sizeof(celt_sig)
1943             + channels*LPC_ORDER*sizeof(opus_val16)
1944             + 4*2*mode->nbEBands*sizeof(opus_val16);
1945    return size;
1946 }
1947
1948 #ifdef CUSTOM_MODES
1949 CELTDecoder *opus_custom_decoder_create(const CELTMode *mode, int channels, int *error)
1950 {
1951    int ret;
1952    CELTDecoder *st = (CELTDecoder *)opus_alloc(opus_custom_decoder_get_size(mode, channels));
1953    ret = opus_custom_decoder_init(st, mode, channels);
1954    if (ret != OPUS_OK)
1955    {
1956       opus_custom_decoder_destroy(st);
1957       st = NULL;
1958    }
1959    if (error)
1960       *error = ret;
1961    return st;
1962 }
1963 #endif /* CUSTOM_MODES */
1964
1965 int celt_decoder_init(CELTDecoder *st, opus_int32 sampling_rate, int channels)
1966 {
1967    int ret;
1968    ret = opus_custom_decoder_init(st, opus_custom_mode_create(48000, 960, NULL), channels);
1969    if (ret != OPUS_OK)
1970       return ret;
1971    st->downsample = resampling_factor(sampling_rate);
1972    if (st->downsample==0)
1973       return OPUS_BAD_ARG;
1974    else
1975       return OPUS_OK;
1976 }
1977
1978 OPUS_CUSTOM_NOSTATIC int opus_custom_decoder_init(CELTDecoder *st, const CELTMode *mode, int channels)
1979 {
1980    if (channels < 0 || channels > 2)
1981       return OPUS_BAD_ARG;
1982
1983    if (st==NULL)
1984       return OPUS_ALLOC_FAIL;
1985
1986    OPUS_CLEAR((char*)st, opus_custom_decoder_get_size(mode, channels));
1987
1988    st->mode = mode;
1989    st->overlap = mode->overlap;
1990    st->stream_channels = st->channels = channels;
1991
1992    st->downsample = 1;
1993    st->start = 0;
1994    st->end = st->mode->effEBands;
1995    st->signalling = 1;
1996
1997    st->loss_count = 0;
1998
1999    opus_custom_decoder_ctl(st, OPUS_RESET_STATE);
2000
2001    return OPUS_OK;
2002 }
2003
2004 #ifdef CUSTOM_MODES
2005 void opus_custom_decoder_destroy(CELTDecoder *st)
2006 {
2007    opus_free(st);
2008 }
2009 #endif /* CUSTOM_MODES */
2010
2011 static void celt_decode_lost(CELTDecoder * restrict st, opus_val16 * restrict pcm, int N, int LM)
2012 {
2013    int c;
2014    int pitch_index;
2015    int overlap = st->mode->overlap;
2016    opus_val16 fade = Q15ONE;
2017    int i, len;
2018    const int C = st->channels;
2019    int offset;
2020    celt_sig *out_mem[2];
2021    celt_sig *decode_mem[2];
2022    celt_sig *overlap_mem[2];
2023    opus_val16 *lpc;
2024    opus_val32 *out_syn[2];
2025    opus_val16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE;
2026    SAVE_STACK;
2027
2028    c=0; do {
2029       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
2030       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
2031       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
2032    } while (++c<C);
2033    lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*C);
2034    oldBandE = lpc+C*LPC_ORDER;
2035    oldLogE = oldBandE + 2*st->mode->nbEBands;
2036    oldLogE2 = oldLogE + 2*st->mode->nbEBands;
2037    backgroundLogE = oldLogE2  + 2*st->mode->nbEBands;
2038
2039    out_syn[0] = out_mem[0]+MAX_PERIOD-N;
2040    if (C==2)
2041       out_syn[1] = out_mem[1]+MAX_PERIOD-N;
2042
2043    len = N+st->mode->overlap;
2044
2045    if (st->loss_count >= 5 || st->start!=0)
2046    {
2047       /* Noise-based PLC/CNG */
2048       VARDECL(celt_sig, freq);
2049       VARDECL(celt_norm, X);
2050       VARDECL(celt_ener, bandE);
2051       opus_uint32 seed;
2052       int effEnd;
2053
2054       effEnd = st->end;
2055       if (effEnd > st->mode->effEBands)
2056          effEnd = st->mode->effEBands;
2057
2058       ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
2059       ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
2060       ALLOC(bandE, st->mode->nbEBands*C, celt_ener);
2061
2062       if (st->loss_count >= 5)
2063          log2Amp(st->mode, st->start, st->end, bandE, backgroundLogE, C);
2064       else {
2065          /* Energy decay */
2066          opus_val16 decay = st->loss_count==0 ? QCONST16(1.5f, DB_SHIFT) : QCONST16(.5f, DB_SHIFT);
2067          c=0; do
2068          {
2069             for (i=st->start;i<st->end;i++)
2070                oldBandE[c*st->mode->nbEBands+i] -= decay;
2071          } while (++c<C);
2072          log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
2073       }
2074       seed = st->rng;
2075       for (c=0;c<C;c++)
2076       {
2077          for (i=0;i<(st->mode->eBands[st->start]<<LM);i++)
2078             X[c*N+i] = 0;
2079          for (i=st->start;i<st->mode->effEBands;i++)
2080          {
2081             int j;
2082             int boffs;
2083             int blen;
2084             boffs = N*c+(st->mode->eBands[i]<<LM);
2085             blen = (st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
2086             for (j=0;j<blen;j++)
2087             {
2088                seed = celt_lcg_rand(seed);
2089                X[boffs+j] = (celt_norm)((opus_int32)seed>>20);
2090             }
2091             renormalise_vector(X+boffs, blen, Q15ONE);
2092          }
2093          for (i=(st->mode->eBands[st->end]<<LM);i<N;i++)
2094             X[c*N+i] = 0;
2095       }
2096       st->rng = seed;
2097
2098       denormalise_bands(st->mode, X, freq, bandE, st->mode->effEBands, C, 1<<LM);
2099
2100       c=0; do
2101          for (i=0;i<st->mode->eBands[st->start]<<LM;i++)
2102             freq[c*N+i] = 0;
2103       while (++c<C);
2104       c=0; do {
2105          int bound = st->mode->eBands[effEnd]<<LM;
2106          if (st->downsample!=1)
2107             bound = IMIN(bound, N/st->downsample);
2108          for (i=bound;i<N;i++)
2109             freq[c*N+i] = 0;
2110       } while (++c<C);
2111       compute_inv_mdcts(st->mode, 0, freq, out_syn, overlap_mem, C, LM);
2112    } else {
2113       /* Pitch-based PLC */
2114       if (st->loss_count == 0)
2115       {
2116          opus_val16 pitch_buf[DECODE_BUFFER_SIZE>>1];
2117          /* Corresponds to a min pitch of 67 Hz. It's possible to save CPU in this
2118          search by using only part of the decode buffer */
2119          int poffset = 720;
2120          pitch_downsample(decode_mem, pitch_buf, DECODE_BUFFER_SIZE, C);
2121          /* Max pitch is 100 samples (480 Hz) */
2122          pitch_search(pitch_buf+((poffset)>>1), pitch_buf, DECODE_BUFFER_SIZE-poffset,
2123                poffset-100, &pitch_index);
2124          pitch_index = poffset-pitch_index;
2125          st->last_pitch_index = pitch_index;
2126       } else {
2127          pitch_index = st->last_pitch_index;
2128          fade = QCONST16(.8f,15);
2129       }
2130
2131       c=0; do {
2132          VARDECL(opus_val32, e);
2133          opus_val16 exc[MAX_PERIOD];
2134          opus_val32 ac[LPC_ORDER+1];
2135          opus_val16 decay = 1;
2136          opus_val32 S1=0;
2137          opus_val16 mem[LPC_ORDER]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
2138
2139          ALLOC(e, MAX_PERIOD+2*st->mode->overlap, opus_val32);
2140
2141          offset = MAX_PERIOD-pitch_index;
2142          for (i=0;i<MAX_PERIOD;i++)
2143             exc[i] = ROUND16(out_mem[c][i], SIG_SHIFT);
2144
2145          if (st->loss_count == 0)
2146          {
2147             _celt_autocorr(exc, ac, st->mode->window, st->mode->overlap,
2148                   LPC_ORDER, MAX_PERIOD);
2149
2150             /* Noise floor -40 dB */
2151 #ifdef FIXED_POINT
2152             ac[0] += SHR32(ac[0],13);
2153 #else
2154             ac[0] *= 1.0001f;
2155 #endif
2156             /* Lag windowing */
2157             for (i=1;i<=LPC_ORDER;i++)
2158             {
2159                /*ac[i] *= exp(-.5*(2*M_PI*.002*i)*(2*M_PI*.002*i));*/
2160 #ifdef FIXED_POINT
2161                ac[i] -= MULT16_32_Q15(2*i*i, ac[i]);
2162 #else
2163                ac[i] -= ac[i]*(.008f*i)*(.008f*i);
2164 #endif
2165             }
2166
2167             _celt_lpc(lpc+c*LPC_ORDER, ac, LPC_ORDER);
2168          }
2169          for (i=0;i<LPC_ORDER;i++)
2170             mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT);
2171          celt_fir(exc, lpc+c*LPC_ORDER, exc, MAX_PERIOD, LPC_ORDER, mem);
2172          /*for (i=0;i<MAX_PERIOD;i++)printf("%d ", exc[i]); printf("\n");*/
2173          /* Check if the waveform is decaying (and if so how fast) */
2174          {
2175             opus_val32 E1=1, E2=1;
2176             int period;
2177             if (pitch_index <= MAX_PERIOD/2)
2178                period = pitch_index;
2179             else
2180                period = MAX_PERIOD/2;
2181             for (i=0;i<period;i++)
2182             {
2183                E1 += SHR32(MULT16_16(exc[MAX_PERIOD-period+i],exc[MAX_PERIOD-period+i]),8);
2184                E2 += SHR32(MULT16_16(exc[MAX_PERIOD-2*period+i],exc[MAX_PERIOD-2*period+i]),8);
2185             }
2186             if (E1 > E2)
2187                E1 = E2;
2188             decay = celt_sqrt(frac_div32(SHR32(E1,1),E2));
2189          }
2190
2191          /* Copy excitation, taking decay into account */
2192          for (i=0;i<len+st->mode->overlap;i++)
2193          {
2194             opus_val16 tmp;
2195             if (offset+i >= MAX_PERIOD)
2196             {
2197                offset -= pitch_index;
2198                decay = MULT16_16_Q15(decay, decay);
2199             }
2200             e[i] = SHL32(EXTEND32(MULT16_16_Q15(decay, exc[offset+i])), SIG_SHIFT);
2201             tmp = ROUND16(out_mem[c][offset+i],SIG_SHIFT);
2202             S1 += SHR32(MULT16_16(tmp,tmp),8);
2203          }
2204          for (i=0;i<LPC_ORDER;i++)
2205             mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT);
2206          for (i=0;i<len+st->mode->overlap;i++)
2207             e[i] = MULT16_32_Q15(fade, e[i]);
2208          celt_iir(e, lpc+c*LPC_ORDER, e, len+st->mode->overlap, LPC_ORDER, mem);
2209
2210          {
2211             opus_val32 S2=0;
2212             for (i=0;i<len+overlap;i++)
2213             {
2214                opus_val16 tmp = ROUND16(e[i],SIG_SHIFT);
2215                S2 += SHR32(MULT16_16(tmp,tmp),8);
2216             }
2217             /* This checks for an "explosion" in the synthesis */
2218 #ifdef FIXED_POINT
2219             if (!(S1 > SHR32(S2,2)))
2220 #else
2221                /* Float test is written this way to catch NaNs at the same time */
2222                if (!(S1 > 0.2f*S2))
2223 #endif
2224                {
2225                   for (i=0;i<len+overlap;i++)
2226                      e[i] = 0;
2227                } else if (S1 < S2)
2228                {
2229                   opus_val16 ratio = celt_sqrt(frac_div32(SHR32(S1,1)+1,S2+1));
2230                   for (i=0;i<len+overlap;i++)
2231                      e[i] = MULT16_32_Q15(ratio, e[i]);
2232                }
2233          }
2234
2235          /* Apply post-filter to the MDCT overlap of the previous frame */
2236          comb_filter(out_mem[c]+MAX_PERIOD, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap,
2237                st->postfilter_gain, st->postfilter_gain, st->postfilter_tapset, st->postfilter_tapset,
2238                NULL, 0);
2239
2240          for (i=0;i<MAX_PERIOD+st->mode->overlap-N;i++)
2241             out_mem[c][i] = out_mem[c][N+i];
2242
2243          /* Apply TDAC to the concealed audio so that it blends with the
2244          previous and next frames */
2245          for (i=0;i<overlap/2;i++)
2246          {
2247             opus_val32 tmp;
2248             tmp = MULT16_32_Q15(st->mode->window[i],           e[N+overlap-1-i]) +
2249                   MULT16_32_Q15(st->mode->window[overlap-i-1], e[N+i          ]);
2250             out_mem[c][MAX_PERIOD+i] = MULT16_32_Q15(st->mode->window[overlap-i-1], tmp);
2251             out_mem[c][MAX_PERIOD+overlap-i-1] = MULT16_32_Q15(st->mode->window[i], tmp);
2252          }
2253          for (i=0;i<N;i++)
2254             out_mem[c][MAX_PERIOD-N+i] = e[i];
2255
2256          /* Apply pre-filter to the MDCT overlap for the next frame (post-filter will be applied then) */
2257          comb_filter(e, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap,
2258                -st->postfilter_gain, -st->postfilter_gain, st->postfilter_tapset, st->postfilter_tapset,
2259                NULL, 0);
2260          for (i=0;i<overlap;i++)
2261             out_mem[c][MAX_PERIOD+i] = e[i];
2262       } while (++c<C);
2263    }
2264
2265    deemphasis(out_syn, pcm, N, C, st->downsample, st->mode->preemph, st->preemph_memD);
2266
2267    st->loss_count++;
2268
2269    RESTORE_STACK;
2270 }
2271
2272 int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, int len, opus_val16 * restrict pcm, int frame_size, ec_dec *dec)
2273 {
2274    int c, i, N;
2275    int spread_decision;
2276    opus_int32 bits;
2277    ec_dec _dec;
2278    VARDECL(celt_sig, freq);
2279    VARDECL(celt_norm, X);
2280    VARDECL(celt_ener, bandE);
2281    VARDECL(int, fine_quant);
2282    VARDECL(int, pulses);
2283    VARDECL(int, cap);
2284    VARDECL(int, offsets);
2285    VARDECL(int, fine_priority);
2286    VARDECL(int, tf_res);
2287    VARDECL(unsigned char, collapse_masks);
2288    celt_sig *out_mem[2];
2289    celt_sig *decode_mem[2];
2290    celt_sig *overlap_mem[2];
2291    celt_sig *out_syn[2];
2292    opus_val16 *lpc;
2293    opus_val16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE;
2294
2295    int shortBlocks;
2296    int isTransient;
2297    int intra_ener;
2298    const int CC = st->channels;
2299    int LM, M;
2300    int effEnd;
2301    int codedBands;
2302    int alloc_trim;
2303    int postfilter_pitch;
2304    opus_val16 postfilter_gain;
2305    int intensity=0;
2306    int dual_stereo=0;
2307    opus_int32 total_bits;
2308    opus_int32 balance;
2309    opus_int32 tell;
2310    int dynalloc_logp;
2311    int postfilter_tapset;
2312    int anti_collapse_rsv;
2313    int anti_collapse_on=0;
2314    int silence;
2315    int C = st->stream_channels;
2316    ALLOC_STACK;
2317
2318    frame_size *= st->downsample;
2319
2320    c=0; do {
2321       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
2322       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
2323       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
2324    } while (++c<CC);
2325    lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*CC);
2326    oldBandE = lpc+CC*LPC_ORDER;
2327    oldLogE = oldBandE + 2*st->mode->nbEBands;
2328    oldLogE2 = oldLogE + 2*st->mode->nbEBands;
2329    backgroundLogE = oldLogE2  + 2*st->mode->nbEBands;
2330
2331 #ifdef CUSTOM_MODES
2332    if (st->signalling && data!=NULL)
2333    {
2334       int data0=data[0];
2335       /* Convert "standard mode" to Opus header */
2336       if (st->mode->Fs==48000 && st->mode->shortMdctSize==120)
2337       {
2338          data0 = fromOpus(data0);
2339          if (data0<0)
2340             return OPUS_INVALID_PACKET;
2341       }
2342       st->end = IMAX(1, st->mode->effEBands-2*(data0>>5));
2343       LM = (data0>>3)&0x3;
2344       C = 1 + ((data0>>2)&0x1);
2345       data++;
2346       len--;
2347       if (LM>st->mode->maxLM)
2348          return OPUS_INVALID_PACKET;
2349       if (frame_size < st->mode->shortMdctSize<<LM)
2350          return OPUS_BUFFER_TOO_SMALL;
2351       else
2352          frame_size = st->mode->shortMdctSize<<LM;
2353    } else {
2354 #else
2355    {
2356 #endif
2357       for (LM=0;LM<=st->mode->maxLM;LM++)
2358          if (st->mode->shortMdctSize<<LM==frame_size)
2359             break;
2360       if (LM>st->mode->maxLM)
2361          return OPUS_BAD_ARG;
2362    }
2363    M=1<<LM;
2364
2365    if (len<0 || len>1275 || pcm==NULL)
2366       return OPUS_BAD_ARG;
2367
2368    N = M*st->mode->shortMdctSize;
2369
2370    effEnd = st->end;
2371    if (effEnd > st->mode->effEBands)
2372       effEnd = st->mode->effEBands;
2373
2374    ALLOC(freq, IMAX(CC,C)*N, celt_sig); /**< Interleaved signal MDCTs */
2375    ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
2376    ALLOC(bandE, st->mode->nbEBands*C, celt_ener);
2377    c=0; do
2378       for (i=0;i<M*st->mode->eBands[st->start];i++)
2379          X[c*N+i] = 0;
2380    while (++c<C);
2381    c=0; do
2382       for (i=M*st->mode->eBands[effEnd];i<N;i++)
2383          X[c*N+i] = 0;
2384    while (++c<C);
2385
2386    if (data == NULL || len<=1)
2387    {
2388       celt_decode_lost(st, pcm, N, LM);
2389       RESTORE_STACK;
2390       return frame_size/st->downsample;
2391    }
2392
2393    if (dec == NULL)
2394    {
2395       ec_dec_init(&_dec,(unsigned char*)data,len);
2396       dec = &_dec;
2397    }
2398
2399    if (C==1)
2400    {
2401       for (i=0;i<st->mode->nbEBands;i++)
2402          oldBandE[i]=MAX16(oldBandE[i],oldBandE[st->mode->nbEBands+i]);
2403    }
2404
2405    total_bits = len*8;
2406    tell = ec_tell(dec);
2407
2408    if (tell >= total_bits)
2409       silence = 1;
2410    else if (tell==1)
2411       silence = ec_dec_bit_logp(dec, 15);
2412    else
2413       silence = 0;
2414    if (silence)
2415    {
2416       /* Pretend we've read all the remaining bits */
2417       tell = len*8;
2418       dec->nbits_total+=tell-ec_tell(dec);
2419    }
2420
2421    postfilter_gain = 0;
2422    postfilter_pitch = 0;
2423    postfilter_tapset = 0;
2424    if (st->start==0 && tell+16 <= total_bits)
2425    {
2426       if(ec_dec_bit_logp(dec, 1))
2427       {
2428          int qg, octave;
2429          octave = ec_dec_uint(dec, 6);
2430          postfilter_pitch = (16<<octave)+ec_dec_bits(dec, 4+octave)-1;
2431          qg = ec_dec_bits(dec, 3);
2432          if (ec_tell(dec)+2<=total_bits)
2433             postfilter_tapset = ec_dec_icdf(dec, tapset_icdf, 2);
2434          postfilter_gain = QCONST16(.09375f,15)*(qg+1);
2435       }
2436       tell = ec_tell(dec);
2437    }
2438
2439    if (LM > 0 && tell+3 <= total_bits)
2440    {
2441       isTransient = ec_dec_bit_logp(dec, 3);
2442       tell = ec_tell(dec);
2443    }
2444    else
2445       isTransient = 0;
2446
2447    if (isTransient)
2448       shortBlocks = M;
2449    else
2450       shortBlocks = 0;
2451
2452    /* Decode the global flags (first symbols in the stream) */
2453    intra_ener = tell+3<=total_bits ? ec_dec_bit_logp(dec, 3) : 0;
2454    /* Get band energies */
2455    unquant_coarse_energy(st->mode, st->start, st->end, oldBandE,
2456          intra_ener, dec, C, LM);
2457
2458    ALLOC(tf_res, st->mode->nbEBands, int);
2459    tf_decode(st->start, st->end, isTransient, tf_res, LM, dec);
2460
2461    tell = ec_tell(dec);
2462    spread_decision = SPREAD_NORMAL;
2463    if (tell+4 <= total_bits)
2464       spread_decision = ec_dec_icdf(dec, spread_icdf, 5);
2465
2466    ALLOC(pulses, st->mode->nbEBands, int);
2467    ALLOC(cap, st->mode->nbEBands, int);
2468    ALLOC(offsets, st->mode->nbEBands, int);
2469    ALLOC(fine_priority, st->mode->nbEBands, int);
2470
2471    init_caps(st->mode,cap,LM,C);
2472
2473    dynalloc_logp = 6;
2474    total_bits<<=BITRES;
2475    tell = ec_tell_frac(dec);
2476    for (i=st->start;i<st->end;i++)
2477    {
2478       int width, quanta;
2479       int dynalloc_loop_logp;
2480       int boost;
2481       width = C*(st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
2482       /* quanta is 6 bits, but no more than 1 bit/sample
2483          and no less than 1/8 bit/sample */
2484       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
2485       dynalloc_loop_logp = dynalloc_logp;
2486       boost = 0;
2487       while (tell+(dynalloc_loop_logp<<BITRES) < total_bits && boost < cap[i])
2488       {
2489          int flag;
2490          flag = ec_dec_bit_logp(dec, dynalloc_loop_logp);
2491          tell = ec_tell_frac(dec);
2492          if (!flag)
2493             break;
2494          boost += quanta;
2495          total_bits -= quanta;
2496          dynalloc_loop_logp = 1;
2497       }
2498       offsets[i] = boost;
2499       /* Making dynalloc more likely */
2500       if (boost>0)
2501          dynalloc_logp = IMAX(2, dynalloc_logp-1);
2502    }
2503
2504    ALLOC(fine_quant, st->mode->nbEBands, int);
2505    alloc_trim = tell+(6<<BITRES) <= total_bits ?
2506          ec_dec_icdf(dec, trim_icdf, 7) : 5;
2507
2508    bits = (((opus_int32)len*8)<<BITRES) - ec_tell_frac(dec) - 1;
2509    anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0;
2510    bits -= anti_collapse_rsv;
2511    codedBands = compute_allocation(st->mode, st->start, st->end, offsets, cap,
2512          alloc_trim, &intensity, &dual_stereo, bits, &balance, pulses,
2513          fine_quant, fine_priority, C, LM, dec, 0, 0);
2514
2515    unquant_fine_energy(st->mode, st->start, st->end, oldBandE, fine_quant, dec, C);
2516
2517    /* Decode fixed codebook */
2518    ALLOC(collapse_masks, C*st->mode->nbEBands, unsigned char);
2519    quant_all_bands(0, st->mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
2520          NULL, pulses, shortBlocks, spread_decision, dual_stereo, intensity, tf_res,
2521          len*(8<<BITRES)-anti_collapse_rsv, balance, dec, LM, codedBands, &st->rng);
2522
2523    if (anti_collapse_rsv > 0)
2524    {
2525       anti_collapse_on = ec_dec_bits(dec, 1);
2526    }
2527
2528    unquant_energy_finalise(st->mode, st->start, st->end, oldBandE,
2529          fine_quant, fine_priority, len*8-ec_tell(dec), dec, C);
2530
2531    if (anti_collapse_on)
2532       anti_collapse(st->mode, X, collapse_masks, LM, C, N,
2533             st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
2534
2535    log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
2536
2537    if (silence)
2538    {
2539       for (i=0;i<C*st->mode->nbEBands;i++)
2540       {
2541          bandE[i] = 0;
2542          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
2543       }
2544    }
2545    /* Synthesis */
2546    denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
2547
2548    OPUS_MOVE(decode_mem[0], decode_mem[0]+N, DECODE_BUFFER_SIZE-N);
2549    if (CC==2)
2550       OPUS_MOVE(decode_mem[1], decode_mem[1]+N, DECODE_BUFFER_SIZE-N);
2551
2552    c=0; do
2553       for (i=0;i<M*st->mode->eBands[st->start];i++)
2554          freq[c*N+i] = 0;
2555    while (++c<C);
2556    c=0; do {
2557       int bound = M*st->mode->eBands[effEnd];
2558       if (st->downsample!=1)
2559          bound = IMIN(bound, N/st->downsample);
2560       for (i=bound;i<N;i++)
2561          freq[c*N+i] = 0;
2562    } while (++c<C);
2563
2564    out_syn[0] = out_mem[0]+MAX_PERIOD-N;
2565    if (CC==2)
2566       out_syn[1] = out_mem[1]+MAX_PERIOD-N;
2567
2568    if (CC==2&&C==1)
2569    {
2570       for (i=0;i<N;i++)
2571          freq[N+i] = freq[i];
2572    }
2573    if (CC==1&&C==2)
2574    {
2575       for (i=0;i<N;i++)
2576          freq[i] = HALF32(ADD32(freq[i],freq[N+i]));
2577    }
2578
2579    /* Compute inverse MDCTs */
2580    compute_inv_mdcts(st->mode, shortBlocks, freq, out_syn, overlap_mem, CC, LM);
2581
2582    c=0; do {
2583       st->postfilter_period=IMAX(st->postfilter_period, COMBFILTER_MINPERIOD);
2584       st->postfilter_period_old=IMAX(st->postfilter_period_old, COMBFILTER_MINPERIOD);
2585       comb_filter(out_syn[c], out_syn[c], st->postfilter_period_old, st->postfilter_period, st->mode->shortMdctSize,
2586             st->postfilter_gain_old, st->postfilter_gain, st->postfilter_tapset_old, st->postfilter_tapset,
2587             st->mode->window, st->overlap);
2588       if (LM!=0)
2589          comb_filter(out_syn[c]+st->mode->shortMdctSize, out_syn[c]+st->mode->shortMdctSize, st->postfilter_period, postfilter_pitch, N-st->mode->shortMdctSize,
2590                st->postfilter_gain, postfilter_gain, st->postfilter_tapset, postfilter_tapset,
2591                st->mode->window, st->mode->overlap);
2592
2593    } while (++c<CC);
2594    st->postfilter_period_old = st->postfilter_period;
2595    st->postfilter_gain_old = st->postfilter_gain;
2596    st->postfilter_tapset_old = st->postfilter_tapset;
2597    st->postfilter_period = postfilter_pitch;
2598    st->postfilter_gain = postfilter_gain;
2599    st->postfilter_tapset = postfilter_tapset;
2600    if (LM!=0)
2601    {
2602       st->postfilter_period_old = st->postfilter_period;
2603       st->postfilter_gain_old = st->postfilter_gain;
2604       st->postfilter_tapset_old = st->postfilter_tapset;
2605    }
2606
2607    if (C==1) {
2608       for (i=0;i<st->mode->nbEBands;i++)
2609          oldBandE[st->mode->nbEBands+i]=oldBandE[i];
2610    }
2611
2612    /* In case start or end were to change */
2613    if (!isTransient)
2614    {
2615       for (i=0;i<2*st->mode->nbEBands;i++)
2616          oldLogE2[i] = oldLogE[i];
2617       for (i=0;i<2*st->mode->nbEBands;i++)
2618          oldLogE[i] = oldBandE[i];
2619       for (i=0;i<2*st->mode->nbEBands;i++)
2620          backgroundLogE[i] = MIN16(backgroundLogE[i] + M*QCONST16(0.001f,DB_SHIFT), oldBandE[i]);
2621    } else {
2622       for (i=0;i<2*st->mode->nbEBands;i++)
2623          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
2624    }
2625    c=0; do
2626    {
2627       for (i=0;i<st->start;i++)
2628       {
2629          oldBandE[c*st->mode->nbEBands+i]=0;
2630          oldLogE[c*st->mode->nbEBands+i]=oldLogE2[c*st->mode->nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
2631       }
2632       for (i=st->end;i<st->mode->nbEBands;i++)
2633       {
2634          oldBandE[c*st->mode->nbEBands+i]=0;
2635          oldLogE[c*st->mode->nbEBands+i]=oldLogE2[c*st->mode->nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
2636       }
2637    } while (++c<2);
2638    st->rng = dec->rng;
2639
2640    deemphasis(out_syn, pcm, N, CC, st->downsample, st->mode->preemph, st->preemph_memD);
2641    st->loss_count = 0;
2642    RESTORE_STACK;
2643    if (ec_tell(dec) > 8*len)
2644       return OPUS_INTERNAL_ERROR;
2645    if(ec_get_error(dec))
2646       st->error = 1;
2647    return frame_size/st->downsample;
2648 }
2649
2650
2651 #ifdef CUSTOM_MODES
2652
2653 #ifdef FIXED_POINT
2654 int opus_custom_decode(CELTDecoder * restrict st, const unsigned char *data, int len, opus_int16 * restrict pcm, int frame_size)
2655 {
2656    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
2657 }
2658
2659 #ifndef DISABLE_FLOAT_API
2660 int opus_custom_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size)
2661 {
2662    int j, ret, C, N;
2663    VARDECL(opus_int16, out);
2664    ALLOC_STACK;
2665
2666    if (pcm==NULL)
2667       return OPUS_BAD_ARG;
2668
2669    C = st->channels;
2670    N = frame_size;
2671
2672    ALLOC(out, C*N, opus_int16);
2673    ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL);
2674    if (ret>0)
2675       for (j=0;j<C*ret;j++)
2676          pcm[j]=out[j]*(1.f/32768.f);
2677
2678    RESTORE_STACK;
2679    return ret;
2680 }
2681 #endif /* DISABLE_FLOAT_API */
2682
2683 #else
2684
2685 int opus_custom_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size)
2686 {
2687    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
2688 }
2689
2690 int opus_custom_decode(CELTDecoder * restrict st, const unsigned char *data, int len, opus_int16 * restrict pcm, int frame_size)
2691 {
2692    int j, ret, C, N;
2693    VARDECL(celt_sig, out);
2694    ALLOC_STACK;
2695
2696    if (pcm==NULL)
2697       return OPUS_BAD_ARG;
2698
2699    C = st->channels;
2700    N = frame_size;
2701    ALLOC(out, C*N, celt_sig);
2702
2703    ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL);
2704
2705    if (ret>0)
2706       for (j=0;j<C*ret;j++)
2707          pcm[j] = FLOAT2INT16 (out[j]);
2708
2709    RESTORE_STACK;
2710    return ret;
2711 }
2712
2713 #endif
2714 #endif /* CUSTOM_MODES */
2715
2716 int opus_custom_decoder_ctl(CELTDecoder * restrict st, int request, ...)
2717 {
2718    va_list ap;
2719
2720    va_start(ap, request);
2721    switch (request)
2722    {
2723       case CELT_SET_START_BAND_REQUEST:
2724       {
2725          opus_int32 value = va_arg(ap, opus_int32);
2726          if (value<0 || value>=st->mode->nbEBands)
2727             goto bad_arg;
2728          st->start = value;
2729       }
2730       break;
2731       case CELT_SET_END_BAND_REQUEST:
2732       {
2733          opus_int32 value = va_arg(ap, opus_int32);
2734          if (value<1 || value>st->mode->nbEBands)
2735             goto bad_arg;
2736          st->end = value;
2737       }
2738       break;
2739       case CELT_SET_CHANNELS_REQUEST:
2740       {
2741          opus_int32 value = va_arg(ap, opus_int32);
2742          if (value<1 || value>2)
2743             goto bad_arg;
2744          st->stream_channels = value;
2745       }
2746       break;
2747       case CELT_GET_AND_CLEAR_ERROR_REQUEST:
2748       {
2749          opus_int32 *value = va_arg(ap, opus_int32*);
2750          if (value==NULL)
2751             goto bad_arg;
2752          *value=st->error;
2753          st->error = 0;
2754       }
2755       break;
2756       case OPUS_GET_LOOKAHEAD_REQUEST:
2757       {
2758          opus_int32 *value = va_arg(ap, opus_int32*);
2759          if (value==NULL)
2760             goto bad_arg;
2761          *value = st->overlap/st->downsample;
2762       }
2763       break;
2764       case OPUS_RESET_STATE:
2765       {
2766          int i;
2767          opus_val16 *lpc, *oldBandE, *oldLogE, *oldLogE2;
2768          lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*st->channels);
2769          oldBandE = lpc+st->channels*LPC_ORDER;
2770          oldLogE = oldBandE + 2*st->mode->nbEBands;
2771          oldLogE2 = oldLogE + 2*st->mode->nbEBands;
2772          OPUS_CLEAR((char*)&st->DECODER_RESET_START,
2773                opus_custom_decoder_get_size(st->mode, st->channels)-
2774                ((char*)&st->DECODER_RESET_START - (char*)st));
2775          for (i=0;i<2*st->mode->nbEBands;i++)
2776             oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT);
2777       }
2778       break;
2779       case OPUS_GET_PITCH_REQUEST:
2780       {
2781          opus_int32 *value = va_arg(ap, opus_int32*);
2782          if (value==NULL)
2783             goto bad_arg;
2784          *value = st->postfilter_period;
2785       }
2786       break;
2787 #ifdef OPUS_BUILD
2788       case CELT_GET_MODE_REQUEST:
2789       {
2790          const CELTMode ** value = va_arg(ap, const CELTMode**);
2791          if (value==0)
2792             goto bad_arg;
2793          *value=st->mode;
2794       }
2795       break;
2796       case CELT_SET_SIGNALLING_REQUEST:
2797       {
2798          opus_int32 value = va_arg(ap, opus_int32);
2799          st->signalling = value;
2800       }
2801       break;
2802       case OPUS_GET_FINAL_RANGE_REQUEST:
2803       {
2804          opus_uint32 * value = va_arg(ap, opus_uint32 *);
2805          if (value==0)
2806             goto bad_arg;
2807          *value=st->rng;
2808       }
2809       break;
2810 #endif
2811       default:
2812          goto bad_request;
2813    }
2814    va_end(ap);
2815    return OPUS_OK;
2816 bad_arg:
2817    va_end(ap);
2818    return OPUS_BAD_ARG;
2819 bad_request:
2820       va_end(ap);
2821   return OPUS_UNIMPLEMENTED;
2822 }
2823
2824
2825
2826 const char *opus_strerror(int error)
2827 {
2828    static const char *error_strings[8] = {
2829       "success",
2830       "invalid argument",
2831       "buffer too small",
2832       "internal error",
2833       "corrupted stream",
2834       "request not implemented",
2835       "invalid state",
2836       "memory allocation failed"
2837    };
2838    if (error > 0 || error < -7)
2839       return "unknown error";
2840    else
2841       return error_strings[-error];
2842 }
2843
2844 const char *opus_get_version_string(void)
2845 {
2846     return "libopus " OPUS_VERSION
2847 #ifdef FIXED_POINT
2848           "-fixed"
2849 #endif
2850 #ifdef FUZZING
2851           "-fuzzing"
2852 #endif
2853           ;
2854 }