Rename '_FOO' to avoid potentional collisions with reserved identifiers.
[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 FOUNDATION OR
21    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
25    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
26    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 #ifdef HAVE_CONFIG_H
31 #include "config.h"
32 #endif
33
34 #define CELT_C
35
36 #include "os_support.h"
37 #include "mdct.h"
38 #include <math.h>
39 #include "celt.h"
40 #include "pitch.h"
41 #include "bands.h"
42 #include "modes.h"
43 #include "entcode.h"
44 #include "quant_bands.h"
45 #include "rate.h"
46 #include "stack_alloc.h"
47 #include "mathops.h"
48 #include "float_cast.h"
49 #include <stdarg.h>
50 #include "celt_lpc.h"
51 #include "vq.h"
52
53 #ifndef OPUS_VERSION
54 #define OPUS_VERSION "unknown"
55 #endif
56
57 #ifdef CUSTOM_MODES
58 #define OPUS_CUSTOM_NOSTATIC
59 #else
60 #define OPUS_CUSTOM_NOSTATIC static inline
61 #endif
62
63 static const unsigned char trim_icdf[11] = {126, 124, 119, 109, 87, 41, 19, 9, 4, 2, 0};
64 /* Probs: NONE: 21.875%, LIGHT: 6.25%, NORMAL: 65.625%, AGGRESSIVE: 6.25% */
65 static const unsigned char spread_icdf[4] = {25, 23, 2, 0};
66
67 static const unsigned char tapset_icdf[3]={2,1,0};
68
69 #ifdef CUSTOM_MODES
70 static const unsigned char toOpusTable[20] = {
71       0xE0, 0xE8, 0xF0, 0xF8,
72       0xC0, 0xC8, 0xD0, 0xD8,
73       0xA0, 0xA8, 0xB0, 0xB8,
74       0x00, 0x00, 0x00, 0x00,
75       0x80, 0x88, 0x90, 0x98,
76 };
77
78 static const unsigned char fromOpusTable[16] = {
79       0x80, 0x88, 0x90, 0x98,
80       0x40, 0x48, 0x50, 0x58,
81       0x20, 0x28, 0x30, 0x38,
82       0x00, 0x08, 0x10, 0x18
83 };
84
85 static inline int toOpus(unsigned char c)
86 {
87    int ret=0;
88    if (c<0xA0)
89       ret = toOpusTable[c>>3];
90    if (ret == 0)
91       return -1;
92    else
93       return ret|(c&0x7);
94 }
95
96 static inline int fromOpus(unsigned char c)
97 {
98    if (c<0x80)
99       return -1;
100    else
101       return fromOpusTable[(c>>3)-16] | (c&0x7);
102 }
103 #endif /* CUSTOM_MODES */
104
105 #define COMBFILTER_MAXPERIOD 1024
106 #define COMBFILTER_MINPERIOD 15
107
108 static int resampling_factor(opus_int32 rate)
109 {
110    int ret;
111    switch (rate)
112    {
113    case 48000:
114       ret = 1;
115       break;
116    case 24000:
117       ret = 2;
118       break;
119    case 16000:
120       ret = 3;
121       break;
122    case 12000:
123       ret = 4;
124       break;
125    case 8000:
126       ret = 6;
127       break;
128    default:
129 #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(SHR(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==downsample)
476          {
477             *y = SCALEOUT(SIG2WORD16(tmp));
478             y+=C;
479             count=0;
480          }
481       }
482       mem[c] = m;
483    } while (++c<C);
484 }
485
486 static void comb_filter(opus_val32 *y, opus_val32 *x, int T0, int T1, int N,
487       opus_val16 g0, opus_val16 g1, int tapset0, int tapset1,
488       const opus_val16 *window, int overlap)
489 {
490    int i;
491    /* printf ("%d %d %f %f\n", T0, T1, g0, g1); */
492    opus_val16 g00, g01, g02, g10, g11, g12;
493    static const opus_val16 gains[3][3] = {
494          {QCONST16(0.3066406250f, 15), QCONST16(0.2170410156f, 15), QCONST16(0.1296386719f, 15)},
495          {QCONST16(0.4638671875f, 15), QCONST16(0.2680664062f, 15), QCONST16(0.f, 15)},
496          {QCONST16(0.7998046875f, 15), QCONST16(0.1000976562f, 15), QCONST16(0.f, 15)}};
497    g00 = MULT16_16_Q15(g0, gains[tapset0][0]);
498    g01 = MULT16_16_Q15(g0, gains[tapset0][1]);
499    g02 = MULT16_16_Q15(g0, gains[tapset0][2]);
500    g10 = MULT16_16_Q15(g1, gains[tapset1][0]);
501    g11 = MULT16_16_Q15(g1, gains[tapset1][1]);
502    g12 = MULT16_16_Q15(g1, gains[tapset1][2]);
503    for (i=0;i<overlap;i++)
504    {
505       opus_val16 f;
506       f = MULT16_16_Q15(window[i],window[i]);
507       y[i] = x[i]
508                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g00),x[i-T0])
509                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g01),x[i-T0-1])
510                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g01),x[i-T0+1])
511                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g02),x[i-T0-2])
512                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g02),x[i-T0+2])
513                + MULT16_32_Q15(MULT16_16_Q15(f,g10),x[i-T1])
514                + MULT16_32_Q15(MULT16_16_Q15(f,g11),x[i-T1-1])
515                + MULT16_32_Q15(MULT16_16_Q15(f,g11),x[i-T1+1])
516                + MULT16_32_Q15(MULT16_16_Q15(f,g12),x[i-T1-2])
517                + MULT16_32_Q15(MULT16_16_Q15(f,g12),x[i-T1+2]);
518
519    }
520    for (i=overlap;i<N;i++)
521       y[i] = x[i]
522                + MULT16_32_Q15(g10,x[i-T1])
523                + MULT16_32_Q15(g11,x[i-T1-1])
524                + MULT16_32_Q15(g11,x[i-T1+1])
525                + MULT16_32_Q15(g12,x[i-T1-2])
526                + MULT16_32_Q15(g12,x[i-T1+2]);
527 }
528
529 static const signed char tf_select_table[4][8] = {
530       {0, -1, 0, -1,    0,-1, 0,-1},
531       {0, -1, 0, -2,    1, 0, 1,-1},
532       {0, -2, 0, -3,    2, 0, 1,-1},
533       {0, -2, 0, -3,    3, 0, 1,-1},
534 };
535
536 static opus_val32 l1_metric(const celt_norm *tmp, int N, int LM, int width)
537 {
538    int i, j;
539    static const opus_val16 sqrtM_1[4] = {Q15ONE, QCONST16(.70710678f,15), QCONST16(0.5f,15), QCONST16(0.35355339f,15)};
540    opus_val32 L1;
541    opus_val16 bias;
542    L1=0;
543    for (i=0;i<1<<LM;i++)
544    {
545       opus_val32 L2 = 0;
546       for (j=0;j<N>>LM;j++)
547          L2 = MAC16_16(L2, tmp[(j<<LM)+i], tmp[(j<<LM)+i]);
548       L1 += celt_sqrt(L2);
549    }
550    L1 = MULT16_32_Q15(sqrtM_1[LM], L1);
551    if (width==1)
552       bias = QCONST16(.12f,15)*LM;
553    else if (width==2)
554       bias = QCONST16(.05f,15)*LM;
555    else
556       bias = QCONST16(.02f,15)*LM;
557    L1 = MAC16_32_Q15(L1, bias, L1);
558    return L1;
559 }
560
561 static int tf_analysis(const CELTMode *m, int len, int C, int isTransient,
562       int *tf_res, int nbCompressedBytes, celt_norm *X, int N0, int LM,
563       int *tf_sum)
564 {
565    int i;
566    VARDECL(int, metric);
567    int cost0;
568    int cost1;
569    VARDECL(int, path0);
570    VARDECL(int, path1);
571    VARDECL(celt_norm, tmp);
572    int lambda;
573    int tf_select=0;
574    SAVE_STACK;
575
576    if (nbCompressedBytes<15*C)
577    {
578       *tf_sum = 0;
579       for (i=0;i<len;i++)
580          tf_res[i] = isTransient;
581       return 0;
582    }
583    if (nbCompressedBytes<40)
584       lambda = 12;
585    else if (nbCompressedBytes<60)
586       lambda = 6;
587    else if (nbCompressedBytes<100)
588       lambda = 4;
589    else
590       lambda = 3;
591
592    ALLOC(metric, len, int);
593    ALLOC(tmp, (m->eBands[len]-m->eBands[len-1])<<LM, celt_norm);
594    ALLOC(path0, len, int);
595    ALLOC(path1, len, int);
596
597    *tf_sum = 0;
598    for (i=0;i<len;i++)
599    {
600       int j, k, N;
601       opus_val32 L1, best_L1;
602       int best_level=0;
603       N = (m->eBands[i+1]-m->eBands[i])<<LM;
604       for (j=0;j<N;j++)
605          tmp[j] = X[j+(m->eBands[i]<<LM)];
606       /* Just add the right channel if we're in stereo */
607       if (C==2)
608          for (j=0;j<N;j++)
609             tmp[j] = ADD16(tmp[j],X[N0+j+(m->eBands[i]<<LM)]);
610       L1 = l1_metric(tmp, N, isTransient ? LM : 0, N>>LM);
611       best_L1 = L1;
612       /*printf ("%f ", L1);*/
613       for (k=0;k<LM;k++)
614       {
615          int B;
616
617          if (isTransient)
618             B = (LM-k-1);
619          else
620             B = k+1;
621
622          if (isTransient)
623             haar1(tmp, N>>(LM-k), 1<<(LM-k));
624          else
625             haar1(tmp, N>>k, 1<<k);
626
627          L1 = l1_metric(tmp, N, B, N>>LM);
628
629          if (L1 < best_L1)
630          {
631             best_L1 = L1;
632             best_level = k+1;
633          }
634       }
635       /*printf ("%d ", isTransient ? LM-best_level : best_level);*/
636       if (isTransient)
637          metric[i] = best_level;
638       else
639          metric[i] = -best_level;
640       *tf_sum += metric[i];
641    }
642    /*printf("\n");*/
643    /* NOTE: Future optimized implementations could detect extreme transients and set
644       tf_select = 1 but so far we have not found a reliable way of making this useful */
645    tf_select = 0;
646
647    cost0 = 0;
648    cost1 = isTransient ? 0 : lambda;
649    /* Viterbi forward pass */
650    for (i=1;i<len;i++)
651    {
652       int curr0, curr1;
653       int from0, from1;
654
655       from0 = cost0;
656       from1 = cost1 + lambda;
657       if (from0 < from1)
658       {
659          curr0 = from0;
660          path0[i]= 0;
661       } else {
662          curr0 = from1;
663          path0[i]= 1;
664       }
665
666       from0 = cost0 + lambda;
667       from1 = cost1;
668       if (from0 < from1)
669       {
670          curr1 = from0;
671          path1[i]= 0;
672       } else {
673          curr1 = from1;
674          path1[i]= 1;
675       }
676       cost0 = curr0 + abs(metric[i]-tf_select_table[LM][4*isTransient+2*tf_select+0]);
677       cost1 = curr1 + abs(metric[i]-tf_select_table[LM][4*isTransient+2*tf_select+1]);
678    }
679    tf_res[len-1] = cost0 < cost1 ? 0 : 1;
680    /* Viterbi backward pass to check the decisions */
681    for (i=len-2;i>=0;i--)
682    {
683       if (tf_res[i+1] == 1)
684          tf_res[i] = path1[i+1];
685       else
686          tf_res[i] = path0[i+1];
687    }
688    RESTORE_STACK;
689 #ifdef FUZZING
690    tf_select = rand()&0x1;
691    tf_res[0] = rand()&0x1;
692    for (i=1;i<len;i++)
693       tf_res[i] = tf_res[i-1] ^ ((rand()&0xF) == 0);
694 #endif
695    return tf_select;
696 }
697
698 static void tf_encode(int start, int end, int isTransient, int *tf_res, int LM, int tf_select, ec_enc *enc)
699 {
700    int curr, i;
701    int tf_select_rsv;
702    int tf_changed;
703    int logp;
704    opus_uint32 budget;
705    opus_uint32 tell;
706    budget = enc->storage*8;
707    tell = ec_tell(enc);
708    logp = isTransient ? 2 : 4;
709    /* Reserve space to code the tf_select decision. */
710    tf_select_rsv = LM>0 && tell+logp+1 <= budget;
711    budget -= tf_select_rsv;
712    curr = tf_changed = 0;
713    for (i=start;i<end;i++)
714    {
715       if (tell+logp<=budget)
716       {
717          ec_enc_bit_logp(enc, tf_res[i] ^ curr, logp);
718          tell = ec_tell(enc);
719          curr = tf_res[i];
720          tf_changed |= curr;
721       }
722       else
723          tf_res[i] = curr;
724       logp = isTransient ? 4 : 5;
725    }
726    /* Only code tf_select if it would actually make a difference. */
727    if (tf_select_rsv &&
728          tf_select_table[LM][4*isTransient+0+tf_changed]!=
729          tf_select_table[LM][4*isTransient+2+tf_changed])
730       ec_enc_bit_logp(enc, tf_select, 1);
731    else
732       tf_select = 0;
733    for (i=start;i<end;i++)
734       tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]];
735    /*printf("%d %d ", isTransient, tf_select); for(i=0;i<end;i++)printf("%d ", tf_res[i]);printf("\n");*/
736 }
737
738 static void tf_decode(int start, int end, int isTransient, int *tf_res, int LM, ec_dec *dec)
739 {
740    int i, curr, tf_select;
741    int tf_select_rsv;
742    int tf_changed;
743    int logp;
744    opus_uint32 budget;
745    opus_uint32 tell;
746
747    budget = dec->storage*8;
748    tell = ec_tell(dec);
749    logp = isTransient ? 2 : 4;
750    tf_select_rsv = LM>0 && tell+logp+1<=budget;
751    budget -= tf_select_rsv;
752    tf_changed = curr = 0;
753    for (i=start;i<end;i++)
754    {
755       if (tell+logp<=budget)
756       {
757          curr ^= ec_dec_bit_logp(dec, logp);
758          tell = ec_tell(dec);
759          tf_changed |= curr;
760       }
761       tf_res[i] = curr;
762       logp = isTransient ? 4 : 5;
763    }
764    tf_select = 0;
765    if (tf_select_rsv &&
766      tf_select_table[LM][4*isTransient+0+tf_changed] !=
767      tf_select_table[LM][4*isTransient+2+tf_changed])
768    {
769       tf_select = ec_dec_bit_logp(dec, 1);
770    }
771    for (i=start;i<end;i++)
772    {
773       tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]];
774    }
775 }
776
777 static void init_caps(const CELTMode *m,int *cap,int LM,int C)
778 {
779    int i;
780    for (i=0;i<m->nbEBands;i++)
781    {
782       int N;
783       N=(m->eBands[i+1]-m->eBands[i])<<LM;
784       cap[i] = (m->cache.caps[m->nbEBands*(2*LM+C-1)+i]+64)*C*N>>2;
785    }
786 }
787
788 static int alloc_trim_analysis(const CELTMode *m, const celt_norm *X,
789       const opus_val16 *bandLogE, int end, int LM, int C, int N0)
790 {
791    int i;
792    opus_val32 diff=0;
793    int c;
794    int trim_index = 5;
795    if (C==2)
796    {
797       opus_val16 sum = 0; /* Q10 */
798       /* Compute inter-channel correlation for low frequencies */
799       for (i=0;i<8;i++)
800       {
801          int j;
802          opus_val32 partial = 0;
803          for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++)
804             partial = MAC16_16(partial, X[j], X[N0+j]);
805          sum = ADD16(sum, EXTRACT16(SHR32(partial, 18)));
806       }
807       sum = MULT16_16_Q15(QCONST16(1.f/8, 15), sum);
808       /*printf ("%f\n", sum);*/
809       if (sum > QCONST16(.995f,10))
810          trim_index-=4;
811       else if (sum > QCONST16(.92f,10))
812          trim_index-=3;
813       else if (sum > QCONST16(.85f,10))
814          trim_index-=2;
815       else if (sum > QCONST16(.8f,10))
816          trim_index-=1;
817    }
818
819    /* Estimate spectral tilt */
820    c=0; do {
821       for (i=0;i<end-1;i++)
822       {
823          diff += bandLogE[i+c*m->nbEBands]*(opus_int32)(2+2*i-m->nbEBands);
824       }
825    } while (++c<C);
826    /* We divide by two here to avoid making the tilt larger for stereo as a
827       result of a bug in the loop above */
828    diff /= 2*C*(end-1);
829    /*printf("%f\n", diff);*/
830    if (diff > QCONST16(2.f, DB_SHIFT))
831       trim_index--;
832    if (diff > QCONST16(8.f, DB_SHIFT))
833       trim_index--;
834    if (diff < -QCONST16(4.f, DB_SHIFT))
835       trim_index++;
836    if (diff < -QCONST16(10.f, DB_SHIFT))
837       trim_index++;
838
839    if (trim_index<0)
840       trim_index = 0;
841    if (trim_index>10)
842       trim_index = 10;
843 #ifdef FUZZING
844    trim_index = rand()%11;
845 #endif
846    return trim_index;
847 }
848
849 static int stereo_analysis(const CELTMode *m, const celt_norm *X,
850       int LM, int N0)
851 {
852    int i;
853    int thetas;
854    opus_val32 sumLR = EPSILON, sumMS = EPSILON;
855
856    /* Use the L1 norm to model the entropy of the L/R signal vs the M/S signal */
857    for (i=0;i<13;i++)
858    {
859       int j;
860       for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++)
861       {
862          opus_val16 L, R, M, S;
863          L = X[j];
864          R = X[N0+j];
865          M = L+R;
866          S = L-R;
867          sumLR += EXTEND32(ABS16(L)) + EXTEND32(ABS16(R));
868          sumMS += EXTEND32(ABS16(M)) + EXTEND32(ABS16(S));
869       }
870    }
871    sumMS = MULT16_32_Q15(QCONST16(0.707107f, 15), sumMS);
872    thetas = 13;
873    /* We don't need thetas for lower bands with LM<=1 */
874    if (LM<=1)
875       thetas -= 8;
876    return MULT16_32_Q15((m->eBands[13]<<(LM+1))+thetas, sumMS)
877          > MULT16_32_Q15(m->eBands[13]<<(LM+1), sumLR);
878 }
879
880 int celt_encode_with_ec(CELTEncoder * restrict st, const opus_val16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
881 {
882    int i, c, N;
883    opus_int32 bits;
884    ec_enc _enc;
885    VARDECL(celt_sig, in);
886    VARDECL(celt_sig, freq);
887    VARDECL(celt_norm, X);
888    VARDECL(celt_ener, bandE);
889    VARDECL(opus_val16, bandLogE);
890    VARDECL(int, fine_quant);
891    VARDECL(opus_val16, error);
892    VARDECL(int, pulses);
893    VARDECL(int, cap);
894    VARDECL(int, offsets);
895    VARDECL(int, fine_priority);
896    VARDECL(int, tf_res);
897    VARDECL(unsigned char, collapse_masks);
898    celt_sig *prefilter_mem;
899    opus_val16 *oldBandE, *oldLogE, *oldLogE2;
900    int shortBlocks=0;
901    int isTransient=0;
902    const int CC = st->channels;
903    const int C = st->stream_channels;
904    int LM, M;
905    int tf_select;
906    int nbFilledBytes, nbAvailableBytes;
907    int effEnd;
908    int codedBands;
909    int tf_sum;
910    int alloc_trim;
911    int pitch_index=COMBFILTER_MINPERIOD;
912    opus_val16 gain1 = 0;
913    int intensity=0;
914    int dual_stereo=0;
915    int effectiveBytes;
916    opus_val16 pf_threshold;
917    int dynalloc_logp;
918    opus_int32 vbr_rate;
919    opus_int32 total_bits;
920    opus_int32 total_boost;
921    opus_int32 balance;
922    opus_int32 tell;
923    int prefilter_tapset=0;
924    int pf_on;
925    int anti_collapse_rsv;
926    int anti_collapse_on=0;
927    int silence=0;
928    ALLOC_STACK;
929
930    if (nbCompressedBytes<2 || pcm==NULL)
931      return OPUS_BAD_ARG;
932
933    frame_size *= st->upsample;
934    for (LM=0;LM<=st->mode->maxLM;LM++)
935       if (st->mode->shortMdctSize<<LM==frame_size)
936          break;
937    if (LM>st->mode->maxLM)
938       return OPUS_BAD_ARG;
939    M=1<<LM;
940    N = M*st->mode->shortMdctSize;
941
942    prefilter_mem = st->in_mem+CC*(st->overlap);
943    oldBandE = (opus_val16*)(st->in_mem+CC*(2*st->overlap+COMBFILTER_MAXPERIOD));
944    oldLogE = oldBandE + CC*st->mode->nbEBands;
945    oldLogE2 = oldLogE + CC*st->mode->nbEBands;
946
947    if (enc==NULL)
948    {
949       tell=1;
950       nbFilledBytes=0;
951    } else {
952       tell=ec_tell(enc);
953       nbFilledBytes=(tell+4)>>3;
954    }
955
956 #ifdef CUSTOM_MODES
957    if (st->signalling && enc==NULL)
958    {
959       int tmp = (st->mode->effEBands-st->end)>>1;
960       st->end = IMAX(1, st->mode->effEBands-tmp);
961       compressed[0] = tmp<<5;
962       compressed[0] |= LM<<3;
963       compressed[0] |= (C==2)<<2;
964       /* Convert "standard mode" to Opus header */
965       if (st->mode->Fs==48000 && st->mode->shortMdctSize==120)
966       {
967          int c0 = toOpus(compressed[0]);
968          if (c0<0)
969             return OPUS_BAD_ARG;
970          compressed[0] = c0;
971       }
972       compressed++;
973       nbCompressedBytes--;
974    }
975 #else
976    celt_assert(st->signalling==0);
977 #endif
978
979    /* Can't produce more than 1275 output bytes */
980    nbCompressedBytes = IMIN(nbCompressedBytes,1275);
981    nbAvailableBytes = nbCompressedBytes - nbFilledBytes;
982
983    if (st->vbr && st->bitrate!=OPUS_BITRATE_MAX)
984    {
985       opus_int32 den=st->mode->Fs>>BITRES;
986       vbr_rate=(st->bitrate*frame_size+(den>>1))/den;
987 #ifdef CUSTOM_MODES
988       if (st->signalling)
989          vbr_rate -= 8<<BITRES;
990 #endif
991       effectiveBytes = vbr_rate>>(3+BITRES);
992    } else {
993       opus_int32 tmp;
994       vbr_rate = 0;
995       tmp = st->bitrate*frame_size;
996       if (tell>1)
997          tmp += tell;
998       if (st->bitrate!=OPUS_BITRATE_MAX)
999          nbCompressedBytes = IMAX(2, IMIN(nbCompressedBytes,
1000                (tmp+4*st->mode->Fs)/(8*st->mode->Fs)-!!st->signalling));
1001       effectiveBytes = nbCompressedBytes;
1002    }
1003
1004    if (enc==NULL)
1005    {
1006       ec_enc_init(&_enc, compressed, nbCompressedBytes);
1007       enc = &_enc;
1008    }
1009
1010    if (vbr_rate>0)
1011    {
1012       /* Computes the max bit-rate allowed in VBR mode to avoid violating the
1013           target rate and buffering.
1014          We must do this up front so that bust-prevention logic triggers
1015           correctly if we don't have enough bits. */
1016       if (st->constrained_vbr)
1017       {
1018          opus_int32 vbr_bound;
1019          opus_int32 max_allowed;
1020          /* We could use any multiple of vbr_rate as bound (depending on the
1021              delay).
1022             This is clamped to ensure we use at least two bytes if the encoder
1023              was entirely empty, but to allow 0 in hybrid mode. */
1024          vbr_bound = vbr_rate;
1025          max_allowed = IMIN(IMAX(tell==1?2:0,
1026                (vbr_rate+vbr_bound-st->vbr_reservoir)>>(BITRES+3)),
1027                nbAvailableBytes);
1028          if(max_allowed < nbAvailableBytes)
1029          {
1030             nbCompressedBytes = nbFilledBytes+max_allowed;
1031             nbAvailableBytes = max_allowed;
1032             ec_enc_shrink(enc, nbCompressedBytes);
1033          }
1034       }
1035    }
1036    total_bits = nbCompressedBytes*8;
1037
1038    effEnd = st->end;
1039    if (effEnd > st->mode->effEBands)
1040       effEnd = st->mode->effEBands;
1041
1042    ALLOC(in, CC*(N+st->overlap), celt_sig);
1043
1044    /* Find pitch period and gain */
1045    {
1046       VARDECL(celt_sig, _pre);
1047       celt_sig *pre[2];
1048       SAVE_STACK;
1049       ALLOC(_pre, CC*(N+COMBFILTER_MAXPERIOD), celt_sig);
1050
1051       pre[0] = _pre;
1052       pre[1] = _pre + (N+COMBFILTER_MAXPERIOD);
1053
1054       silence = 1;
1055       c=0; do {
1056          int count = 0;
1057          const opus_val16 * restrict pcmp = pcm+c;
1058          celt_sig * restrict inp = in+c*(N+st->overlap)+st->overlap;
1059
1060          for (i=0;i<N;i++)
1061          {
1062             celt_sig x, tmp;
1063
1064             x = SCALEIN(*pcmp);
1065 #ifndef FIXED_POINT
1066             if (!(x==x))
1067                x = 0;
1068             if (st->clip)
1069                x = MAX32(-65536.f, MIN32(65536.f,x));
1070 #endif
1071             if (++count==st->upsample)
1072             {
1073                count=0;
1074                pcmp+=CC;
1075             } else {
1076                x = 0;
1077             }
1078             /* Apply pre-emphasis */
1079             tmp = MULT16_16(st->mode->preemph[2], x);
1080             *inp = tmp + st->preemph_memE[c];
1081             st->preemph_memE[c] = MULT16_32_Q15(st->mode->preemph[1], *inp)
1082                                    - MULT16_32_Q15(st->mode->preemph[0], tmp);
1083             silence = silence && *inp == 0;
1084             inp++;
1085          }
1086          OPUS_COPY(pre[c], prefilter_mem+c*COMBFILTER_MAXPERIOD, COMBFILTER_MAXPERIOD);
1087          OPUS_COPY(pre[c]+COMBFILTER_MAXPERIOD, in+c*(N+st->overlap)+st->overlap, N);
1088       } while (++c<CC);
1089
1090 #ifdef FUZZING
1091       if ((rand()&0x3F)==0)
1092          silence = 1;
1093 #endif
1094       if (tell==1)
1095          ec_enc_bit_logp(enc, silence, 15);
1096       else
1097          silence=0;
1098       if (silence)
1099       {
1100          /*In VBR mode there is no need to send more than the minimum. */
1101          if (vbr_rate>0)
1102          {
1103             effectiveBytes=nbCompressedBytes=IMIN(nbCompressedBytes, nbFilledBytes+2);
1104             total_bits=nbCompressedBytes*8;
1105             nbAvailableBytes=2;
1106             ec_enc_shrink(enc, nbCompressedBytes);
1107          }
1108          /* Pretend we've filled all the remaining bits with zeros
1109             (that's what the initialiser did anyway) */
1110          tell = nbCompressedBytes*8;
1111          enc->nbits_total+=tell-ec_tell(enc);
1112       }
1113       if (nbAvailableBytes>12*C && st->start==0 && !silence && !st->disable_pf && st->complexity >= 5)
1114       {
1115          VARDECL(opus_val16, pitch_buf);
1116          ALLOC(pitch_buf, (COMBFILTER_MAXPERIOD+N)>>1, opus_val16);
1117
1118          pitch_downsample(pre, pitch_buf, COMBFILTER_MAXPERIOD+N, CC);
1119          pitch_search(pitch_buf+(COMBFILTER_MAXPERIOD>>1), pitch_buf, N,
1120                COMBFILTER_MAXPERIOD-COMBFILTER_MINPERIOD, &pitch_index);
1121          pitch_index = COMBFILTER_MAXPERIOD-pitch_index;
1122
1123          gain1 = remove_doubling(pitch_buf, COMBFILTER_MAXPERIOD, COMBFILTER_MINPERIOD,
1124                N, &pitch_index, st->prefilter_period, st->prefilter_gain);
1125          if (pitch_index > COMBFILTER_MAXPERIOD-2)
1126             pitch_index = COMBFILTER_MAXPERIOD-2;
1127          gain1 = MULT16_16_Q15(QCONST16(.7f,15),gain1);
1128          if (st->loss_rate>2)
1129             gain1 = HALF32(gain1);
1130          if (st->loss_rate>4)
1131             gain1 = HALF32(gain1);
1132          if (st->loss_rate>8)
1133             gain1 = 0;
1134          prefilter_tapset = st->tapset_decision;
1135       } else {
1136          gain1 = 0;
1137       }
1138
1139       /* Gain threshold for enabling the prefilter/postfilter */
1140       pf_threshold = QCONST16(.2f,15);
1141
1142       /* Adjusting the threshold based on rate and continuity */
1143       if (abs(pitch_index-st->prefilter_period)*10>pitch_index)
1144          pf_threshold += QCONST16(.2f,15);
1145       if (nbAvailableBytes<25)
1146          pf_threshold += QCONST16(.1f,15);
1147       if (nbAvailableBytes<35)
1148          pf_threshold += QCONST16(.1f,15);
1149       if (st->prefilter_gain > QCONST16(.4f,15))
1150          pf_threshold -= QCONST16(.1f,15);
1151       if (st->prefilter_gain > QCONST16(.55f,15))
1152          pf_threshold -= QCONST16(.1f,15);
1153
1154       /* Hard threshold at 0.2 */
1155       pf_threshold = MAX16(pf_threshold, QCONST16(.2f,15));
1156       if (gain1<pf_threshold)
1157       {
1158          if(st->start==0 && tell+16<=total_bits)
1159             ec_enc_bit_logp(enc, 0, 1);
1160          gain1 = 0;
1161          pf_on = 0;
1162       } else {
1163          /*This block is not gated by a total bits check only because
1164            of the nbAvailableBytes check above.*/
1165          int qg;
1166          int octave;
1167
1168          if (ABS16(gain1-st->prefilter_gain)<QCONST16(.1f,15))
1169             gain1=st->prefilter_gain;
1170
1171 #ifdef FIXED_POINT
1172          qg = ((gain1+1536)>>10)/3-1;
1173 #else
1174          qg = (int)floor(.5f+gain1*32/3)-1;
1175 #endif
1176          qg = IMAX(0, IMIN(7, qg));
1177          ec_enc_bit_logp(enc, 1, 1);
1178          pitch_index += 1;
1179          octave = EC_ILOG(pitch_index)-5;
1180          ec_enc_uint(enc, octave, 6);
1181          ec_enc_bits(enc, pitch_index-(16<<octave), 4+octave);
1182          pitch_index -= 1;
1183          ec_enc_bits(enc, qg, 3);
1184          if (ec_tell(enc)+2<=total_bits)
1185             ec_enc_icdf(enc, prefilter_tapset, tapset_icdf, 2);
1186          else
1187            prefilter_tapset = 0;
1188          gain1 = QCONST16(0.09375f,15)*(qg+1);
1189          pf_on = 1;
1190       }
1191       /*printf("%d %f\n", pitch_index, gain1);*/
1192
1193       c=0; do {
1194          int offset = st->mode->shortMdctSize-st->mode->overlap;
1195          st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
1196          OPUS_COPY(in+c*(N+st->overlap), st->in_mem+c*(st->overlap), st->overlap);
1197          if (offset)
1198             comb_filter(in+c*(N+st->overlap)+st->overlap, pre[c]+COMBFILTER_MAXPERIOD,
1199                   st->prefilter_period, st->prefilter_period, offset, -st->prefilter_gain, -st->prefilter_gain,
1200                   st->prefilter_tapset, st->prefilter_tapset, NULL, 0);
1201
1202          comb_filter(in+c*(N+st->overlap)+st->overlap+offset, pre[c]+COMBFILTER_MAXPERIOD+offset,
1203                st->prefilter_period, pitch_index, N-offset, -st->prefilter_gain, -gain1,
1204                st->prefilter_tapset, prefilter_tapset, st->mode->window, st->mode->overlap);
1205          OPUS_COPY(st->in_mem+c*(st->overlap), in+c*(N+st->overlap)+N, st->overlap);
1206
1207          if (N>COMBFILTER_MAXPERIOD)
1208          {
1209             OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, pre[c]+N, COMBFILTER_MAXPERIOD);
1210          } else {
1211             OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, prefilter_mem+c*COMBFILTER_MAXPERIOD+N, COMBFILTER_MAXPERIOD-N);
1212             OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD+COMBFILTER_MAXPERIOD-N, pre[c]+COMBFILTER_MAXPERIOD, N);
1213          }
1214       } while (++c<CC);
1215
1216       RESTORE_STACK;
1217    }
1218
1219    isTransient = 0;
1220    shortBlocks = 0;
1221    if (LM>0 && ec_tell(enc)+3<=total_bits)
1222    {
1223       if (st->complexity > 1)
1224       {
1225          isTransient = transient_analysis(in, N+st->overlap, CC,
1226                   st->overlap);
1227          if (isTransient)
1228             shortBlocks = M;
1229       }
1230       ec_enc_bit_logp(enc, isTransient, 3);
1231    }
1232
1233    ALLOC(freq, CC*N, celt_sig); /**< Interleaved signal MDCTs */
1234    ALLOC(bandE,st->mode->nbEBands*CC, celt_ener);
1235    ALLOC(bandLogE,st->mode->nbEBands*CC, opus_val16);
1236    /* Compute MDCTs */
1237    compute_mdcts(st->mode, shortBlocks, in, freq, CC, LM);
1238
1239    if (CC==2&&C==1)
1240    {
1241       for (i=0;i<N;i++)
1242          freq[i] = ADD32(HALF32(freq[i]), HALF32(freq[N+i]));
1243    }
1244    if (st->upsample != 1)
1245    {
1246       c=0; do
1247       {
1248          int bound = N/st->upsample;
1249          for (i=0;i<bound;i++)
1250             freq[c*N+i] *= st->upsample;
1251          for (;i<N;i++)
1252             freq[c*N+i] = 0;
1253       } while (++c<C);
1254    }
1255    ALLOC(X, C*N, celt_norm);         /**< Interleaved normalised MDCTs */
1256
1257    compute_band_energies(st->mode, freq, bandE, effEnd, C, M);
1258
1259    amp2Log2(st->mode, effEnd, st->end, bandE, bandLogE, C);
1260
1261    /* Band normalisation */
1262    normalise_bands(st->mode, freq, X, bandE, effEnd, C, M);
1263
1264    ALLOC(tf_res, st->mode->nbEBands, int);
1265    tf_select = tf_analysis(st->mode, effEnd, C, isTransient, tf_res, effectiveBytes, X, N, LM, &tf_sum);
1266    for (i=effEnd;i<st->end;i++)
1267       tf_res[i] = tf_res[effEnd-1];
1268
1269    ALLOC(error, C*st->mode->nbEBands, opus_val16);
1270    quant_coarse_energy(st->mode, st->start, st->end, effEnd, bandLogE,
1271          oldBandE, total_bits, error, enc,
1272          C, LM, nbAvailableBytes, st->force_intra,
1273          &st->delayedIntra, st->complexity >= 4, st->loss_rate);
1274
1275    tf_encode(st->start, st->end, isTransient, tf_res, LM, tf_select, enc);
1276
1277    st->spread_decision = SPREAD_NORMAL;
1278    if (ec_tell(enc)+4<=total_bits)
1279    {
1280       if (shortBlocks || st->complexity < 3 || nbAvailableBytes < 10*C)
1281       {
1282          if (st->complexity == 0)
1283             st->spread_decision = SPREAD_NONE;
1284       } else {
1285          st->spread_decision = spreading_decision(st->mode, X,
1286                &st->tonal_average, st->spread_decision, &st->hf_average,
1287                &st->tapset_decision, pf_on&&!shortBlocks, effEnd, C, M);
1288       }
1289       ec_enc_icdf(enc, st->spread_decision, spread_icdf, 5);
1290    }
1291
1292    ALLOC(cap, st->mode->nbEBands, int);
1293    ALLOC(offsets, st->mode->nbEBands, int);
1294
1295    init_caps(st->mode,cap,LM,C);
1296    for (i=0;i<st->mode->nbEBands;i++)
1297       offsets[i] = 0;
1298    /* Dynamic allocation code */
1299    /* Make sure that dynamic allocation can't make us bust the budget */
1300    if (effectiveBytes > 50 && LM>=1)
1301    {
1302       int t1, t2;
1303       if (LM <= 1)
1304       {
1305          t1 = 3;
1306          t2 = 5;
1307       } else {
1308          t1 = 2;
1309          t2 = 4;
1310       }
1311       for (i=st->start+1;i<st->end-1;i++)
1312       {
1313          opus_val32 d2;
1314          d2 = 2*bandLogE[i]-bandLogE[i-1]-bandLogE[i+1];
1315          if (C==2)
1316             d2 = HALF32(d2 + 2*bandLogE[i+st->mode->nbEBands]-
1317                   bandLogE[i-1+st->mode->nbEBands]-bandLogE[i+1+st->mode->nbEBands]);
1318 #ifdef FUZZING
1319          if((rand()&0xF)==0)
1320          {
1321             offsets[i] += 1;
1322             if((rand()&0x3)==0)
1323                offsets[i] += 1+(rand()&0x3);
1324          }
1325 #else
1326          if (d2 > SHL16(t1,DB_SHIFT))
1327             offsets[i] += 1;
1328          if (d2 > SHL16(t2,DB_SHIFT))
1329             offsets[i] += 1;
1330 #endif
1331       }
1332    }
1333    dynalloc_logp = 6;
1334    total_bits<<=BITRES;
1335    total_boost = 0;
1336    tell = ec_tell_frac(enc);
1337    for (i=st->start;i<st->end;i++)
1338    {
1339       int width, quanta;
1340       int dynalloc_loop_logp;
1341       int boost;
1342       int j;
1343       width = C*(st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
1344       /* quanta is 6 bits, but no more than 1 bit/sample
1345          and no less than 1/8 bit/sample */
1346       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
1347       dynalloc_loop_logp = dynalloc_logp;
1348       boost = 0;
1349       for (j = 0; tell+(dynalloc_loop_logp<<BITRES) < total_bits-total_boost
1350             && boost < cap[i]; j++)
1351       {
1352          int flag;
1353          flag = j<offsets[i];
1354          ec_enc_bit_logp(enc, flag, dynalloc_loop_logp);
1355          tell = ec_tell_frac(enc);
1356          if (!flag)
1357             break;
1358          boost += quanta;
1359          total_boost += quanta;
1360          dynalloc_loop_logp = 1;
1361       }
1362       /* Making dynalloc more likely */
1363       if (j)
1364          dynalloc_logp = IMAX(2, dynalloc_logp-1);
1365       offsets[i] = boost;
1366    }
1367    alloc_trim = 5;
1368    if (tell+(6<<BITRES) <= total_bits - total_boost)
1369    {
1370       alloc_trim = alloc_trim_analysis(st->mode, X, bandLogE,
1371             st->end, LM, C, N);
1372       ec_enc_icdf(enc, alloc_trim, trim_icdf, 7);
1373       tell = ec_tell_frac(enc);
1374    }
1375
1376    /* Variable bitrate */
1377    if (vbr_rate>0)
1378    {
1379      opus_val16 alpha;
1380      opus_int32 delta;
1381      /* The target rate in 8th bits per frame */
1382      opus_int32 target;
1383      opus_int32 min_allowed;
1384      int lm_diff = st->mode->maxLM - LM;
1385
1386      target = vbr_rate + (st->vbr_offset>>lm_diff) - ((40*C+20)<<BITRES);
1387
1388      /* Shortblocks get a large boost in bitrate, but since they
1389         are uncommon long blocks are not greatly affected */
1390      if (shortBlocks || tf_sum < -2*(st->end-st->start))
1391         target = 7*target/4;
1392      else if (tf_sum < -(st->end-st->start))
1393         target = 3*target/2;
1394      else if (M > 1)
1395         target-=(target+14)/28;
1396
1397      /* The current offset is removed from the target and the space used
1398         so far is added*/
1399      target=target+tell;
1400
1401      /* In VBR mode the frame size must not be reduced so much that it would
1402          result in the encoder running out of bits.
1403         The margin of 2 bytes ensures that none of the bust-prevention logic
1404          in the decoder will have triggered so far. */
1405      min_allowed = ((tell+total_boost+(1<<(BITRES+3))-1)>>(BITRES+3)) + 2 - nbFilledBytes;
1406
1407      nbAvailableBytes = (target+(1<<(BITRES+2)))>>(BITRES+3);
1408      nbAvailableBytes = IMAX(min_allowed,nbAvailableBytes);
1409      nbAvailableBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes) - nbFilledBytes;
1410
1411      /* By how much did we "miss" the target on that frame */
1412      delta = target - vbr_rate;
1413
1414      target=nbAvailableBytes<<(BITRES+3);
1415
1416      /*If the frame is silent we don't adjust our drift, otherwise
1417        the encoder will shoot to very high rates after hitting a
1418        span of silence, but we do allow the bitres to refill.
1419        This means that we'll undershoot our target in CVBR/VBR modes
1420        on files with lots of silence. */
1421      if(silence)
1422      {
1423        nbAvailableBytes = 2;
1424        target = 2*8<<BITRES;
1425        delta = 0;
1426      }
1427
1428      if (st->vbr_count < 970)
1429      {
1430         st->vbr_count++;
1431         alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+20),16));
1432      } else
1433         alpha = QCONST16(.001f,15);
1434      /* How many bits have we used in excess of what we're allowed */
1435      if (st->constrained_vbr)
1436         st->vbr_reservoir += target - vbr_rate;
1437      /*printf ("%d\n", st->vbr_reservoir);*/
1438
1439      /* Compute the offset we need to apply in order to reach the target */
1440      st->vbr_drift += (opus_int32)MULT16_32_Q15(alpha,(delta*(1<<lm_diff))-st->vbr_offset-st->vbr_drift);
1441      st->vbr_offset = -st->vbr_drift;
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, CC, 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(SHR(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<CC)
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, CC, 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          int *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          int *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          int *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 FUZZING
2843           "-fuzzing"
2844 #endif
2845           ;
2846 }