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