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