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