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