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