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