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