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