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