Smoother intensity stereo decision thresholds
[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)
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 #ifndef FIXED_POINT
1517    if (0 && st->analysis.valid)
1518    {
1519       if (st->analysis.boost_amount[0]>.2)
1520          offsets[st->analysis.boost_band[0]]+=2;
1521       if (st->analysis.boost_amount[0]>.4)
1522          offsets[st->analysis.boost_band[0]]+=2;
1523       if (st->analysis.boost_amount[1]>.2)
1524          offsets[st->analysis.boost_band[1]]+=2;
1525       if (st->analysis.boost_amount[1]>.4)
1526          offsets[st->analysis.boost_band[1]]+=2;
1527    }
1528 #endif
1529    dynalloc_logp = 6;
1530    total_bits<<=BITRES;
1531    total_boost = 0;
1532    tell = ec_tell_frac(enc);
1533    for (i=st->start;i<st->end;i++)
1534    {
1535       int width, quanta;
1536       int dynalloc_loop_logp;
1537       int boost;
1538       int j;
1539       width = C*(st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
1540       /* quanta is 6 bits, but no more than 1 bit/sample
1541          and no less than 1/8 bit/sample */
1542       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
1543       dynalloc_loop_logp = dynalloc_logp;
1544       boost = 0;
1545       for (j = 0; tell+(dynalloc_loop_logp<<BITRES) < total_bits-total_boost
1546             && boost < cap[i]; j++)
1547       {
1548          int flag;
1549          flag = j<offsets[i];
1550          ec_enc_bit_logp(enc, flag, dynalloc_loop_logp);
1551          tell = ec_tell_frac(enc);
1552          if (!flag)
1553             break;
1554          boost += quanta;
1555          total_boost += quanta;
1556          dynalloc_loop_logp = 1;
1557       }
1558       /* Making dynalloc more likely */
1559       if (j)
1560          dynalloc_logp = IMAX(2, dynalloc_logp-1);
1561       offsets[i] = boost;
1562    }
1563
1564    if (C==2)
1565    {
1566       int effectiveRate;
1567
1568       /* Always use MS for 2.5 ms frames until we can do a better analysis */
1569       if (LM!=0)
1570          dual_stereo = stereo_analysis(st->mode, X, LM, N);
1571
1572       static const opus_val16 intensity_thresholds[21]=
1573       /* 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19  20  off*/
1574         { 16,21,23,25,27,29,31,33,35,38,42,46,50,54,58,63,68,75,84,102,130};
1575       static const opus_val16 intensity_histeresis[21]=
1576         {  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 4, 5, 6,  8, 12};
1577
1578       /* Account for coarse energy */
1579       effectiveRate = (8*effectiveBytes - 80)>>LM;
1580
1581       /* effectiveRate in kb/s */
1582       effectiveRate = 2*effectiveRate/5;
1583
1584       st->intensity = hysteresis_decision(effectiveRate, intensity_thresholds, intensity_histeresis, 21, st->intensity);
1585       st->intensity = IMIN(st->end,IMAX(st->start, st->intensity));
1586    }
1587
1588    alloc_trim = 5;
1589    if (tell+(6<<BITRES) <= total_bits - total_boost)
1590    {
1591       alloc_trim = alloc_trim_analysis(st->mode, X, bandLogE,
1592             st->end, LM, C, N, &st->analysis, &st->stereo_saving, tf_estimate, st->intensity);
1593       ec_enc_icdf(enc, alloc_trim, trim_icdf, 7);
1594       tell = ec_tell_frac(enc);
1595    }
1596
1597    /* Variable bitrate */
1598    if (vbr_rate>0)
1599    {
1600      opus_val16 alpha;
1601      opus_int32 delta;
1602      /* The target rate in 8th bits per frame */
1603      opus_int32 target, new_target;
1604      opus_int32 min_allowed;
1605      int coded_bins;
1606      int coded_bands;
1607      int lm_diff = st->mode->maxLM - LM;
1608      coded_bands = st->lastCodedBands ? st->lastCodedBands : st->mode->nbEBands;
1609      coded_bins = st->mode->eBands[coded_bands]<<LM;
1610      if (C==2)
1611         coded_bins += st->mode->eBands[IMIN(st->intensity, coded_bands)]<<LM;
1612
1613      /* Don't attempt to use more than 510 kb/s, even for frames smaller than 20 ms.
1614         The CELT allocator will just not be able to use more than that anyway. */
1615      nbCompressedBytes = IMIN(nbCompressedBytes,1275>>(3-LM));
1616      target = vbr_rate - ((40*C+20)<<BITRES);
1617      if (st->constrained_vbr)
1618         target += (st->vbr_offset>>lm_diff);
1619
1620      /*printf("%f %f %f %f %d %d ", st->analysis.activity, st->analysis.tonality, tf_estimate, st->stereo_saving, tot_boost, coded_bands);*/
1621 #ifndef FIXED_POINT
1622      if (st->analysis.valid && st->analysis.activity<.4)
1623         target -= (coded_bins<<BITRES)*1*(.4-st->analysis.activity);
1624 #endif
1625      if (C==2)
1626      {
1627         int coded_stereo_bands;
1628         int coded_stereo_dof;
1629         coded_stereo_bands = IMIN(st->intensity, coded_bands);
1630         coded_stereo_dof = (st->mode->eBands[coded_stereo_bands]<<LM)-coded_stereo_bands;
1631         /*printf("%d %d %d ", coded_stereo_dof, coded_bins, tot_boost);*/
1632         target -= MIN32(target/3, SHR16(MULT16_16(st->stereo_saving,(coded_stereo_dof<<BITRES)),8));
1633         target += MULT16_16_Q15(QCONST16(0.035,15),coded_stereo_dof<<BITRES);
1634      }
1635      /* Compensates for the average tonality boost */
1636      target -= MULT16_16_Q15(QCONST16(0.13f,15),coded_bins<<BITRES);
1637      /* Limits starving of other bands when using dynalloc */
1638      target += tot_boost;
1639      /* Compensates for the average transient boost */
1640      target = MULT16_32_Q15(QCONST16(0.96f,15),target);
1641
1642      new_target = SHL32(MULT16_32_Q15(tf_estimate, target),1);
1643
1644 #ifndef FIXED_POINT
1645      if (st->analysis.valid) {
1646         int tonal_target;
1647         float tonal;
1648         tonal = MAX16(0,st->analysis.tonality-.2);
1649         tonal_target = new_target + (coded_bins<<BITRES)*2.0f*tonal;
1650         if (pitch_change)
1651            tonal_target +=  (coded_bins<<BITRES)*.8;
1652         /*printf("%f %f ", st->analysis.tonality, tonal);*/
1653         new_target = IMAX(tonal_target,new_target);
1654      }
1655 #endif
1656
1657      {
1658         opus_int32 floor_depth;
1659         int bins;
1660         bins = st->mode->eBands[st->mode->nbEBands-2]<<LM;
1661         /*floor_depth = SHR32(MULT16_16((C*bins<<BITRES),celt_log2(SHL32(MAX16(1,sample_max),13))), DB_SHIFT);*/
1662         floor_depth = SHR32(MULT16_16((C*bins<<BITRES),maxDepth), DB_SHIFT);
1663         floor_depth = IMAX(floor_depth, new_target>>2);
1664         new_target = IMIN(new_target, floor_depth);
1665         /*printf("%f %d\n", maxDepth, floor_depth);*/
1666      }
1667      /* The current offset is removed from the target and the space used
1668         so far is added*/
1669      target=new_target+tell;
1670      /* In VBR mode the frame size must not be reduced so much that it would
1671          result in the encoder running out of bits.
1672         The margin of 2 bytes ensures that none of the bust-prevention logic
1673          in the decoder will have triggered so far. */
1674      min_allowed = ((tell+total_boost+(1<<(BITRES+3))-1)>>(BITRES+3)) + 2 - nbFilledBytes;
1675
1676      nbAvailableBytes = (target+(1<<(BITRES+2)))>>(BITRES+3);
1677      nbAvailableBytes = IMAX(min_allowed,nbAvailableBytes);
1678      nbAvailableBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes) - nbFilledBytes;
1679
1680      /* By how much did we "miss" the target on that frame */
1681      delta = target - vbr_rate;
1682
1683      target=nbAvailableBytes<<(BITRES+3);
1684
1685      /*If the frame is silent we don't adjust our drift, otherwise
1686        the encoder will shoot to very high rates after hitting a
1687        span of silence, but we do allow the bitres to refill.
1688        This means that we'll undershoot our target in CVBR/VBR modes
1689        on files with lots of silence. */
1690      if(silence)
1691      {
1692        nbAvailableBytes = 2;
1693        target = 2*8<<BITRES;
1694        delta = 0;
1695      }
1696
1697      if (st->vbr_count < 970)
1698      {
1699         st->vbr_count++;
1700         alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+20),16));
1701      } else
1702         alpha = QCONST16(.001f,15);
1703      /* How many bits have we used in excess of what we're allowed */
1704      if (st->constrained_vbr)
1705         st->vbr_reservoir += target - vbr_rate;
1706      /*printf ("%d\n", st->vbr_reservoir);*/
1707
1708      /* Compute the offset we need to apply in order to reach the target */
1709      if (st->constrained_vbr)
1710      {
1711         st->vbr_drift += (opus_int32)MULT16_32_Q15(alpha,(delta*(1<<lm_diff))-st->vbr_offset-st->vbr_drift);
1712         st->vbr_offset = -st->vbr_drift;
1713      }
1714      /*printf ("%d\n", st->vbr_drift);*/
1715
1716      if (st->constrained_vbr && st->vbr_reservoir < 0)
1717      {
1718         /* We're under the min value -- increase rate */
1719         int adjust = (-st->vbr_reservoir)/(8<<BITRES);
1720         /* Unless we're just coding silence */
1721         nbAvailableBytes += silence?0:adjust;
1722         st->vbr_reservoir = 0;
1723         /*printf ("+%d\n", adjust);*/
1724      }
1725      nbCompressedBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes);
1726      /*printf("%d\n", nbCompressedBytes*50*8);*/
1727      /* This moves the raw bits to take into account the new compressed size */
1728      ec_enc_shrink(enc, nbCompressedBytes);
1729    }
1730
1731    /* Bit allocation */
1732    ALLOC(fine_quant, st->mode->nbEBands, int);
1733    ALLOC(pulses, st->mode->nbEBands, int);
1734    ALLOC(fine_priority, st->mode->nbEBands, int);
1735
1736    /* bits =           packet size                    - where we are - safety*/
1737    bits = (((opus_int32)nbCompressedBytes*8)<<BITRES) - ec_tell_frac(enc) - 1;
1738    anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0;
1739    bits -= anti_collapse_rsv;
1740    codedBands = compute_allocation(st->mode, st->start, st->end, offsets, cap,
1741          alloc_trim, &st->intensity, &dual_stereo, bits, &balance, pulses,
1742          fine_quant, fine_priority, C, LM, enc, 1, st->lastCodedBands);
1743    st->lastCodedBands = codedBands;
1744
1745    quant_fine_energy(st->mode, st->start, st->end, oldBandE, error, fine_quant, enc, C);
1746
1747 #ifdef MEASURE_NORM_MSE
1748    float X0[3000];
1749    float bandE0[60];
1750    c=0; do
1751       for (i=0;i<N;i++)
1752          X0[i+c*N] = X[i+c*N];
1753    while (++c<C);
1754    for (i=0;i<C*st->mode->nbEBands;i++)
1755       bandE0[i] = bandE[i];
1756 #endif
1757
1758    /* Residual quantisation */
1759    ALLOC(collapse_masks, C*st->mode->nbEBands, unsigned char);
1760    quant_all_bands(1, st->mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
1761          bandE, pulses, shortBlocks, st->spread_decision, dual_stereo, st->intensity, tf_res,
1762          nbCompressedBytes*(8<<BITRES)-anti_collapse_rsv, balance, enc, LM, codedBands, &st->rng);
1763
1764    if (anti_collapse_rsv > 0)
1765    {
1766       anti_collapse_on = st->consec_transient<2;
1767 #ifdef FUZZING
1768       anti_collapse_on = rand()&0x1;
1769 #endif
1770       ec_enc_bits(enc, anti_collapse_on, 1);
1771    }
1772    quant_energy_finalise(st->mode, st->start, st->end, oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_tell(enc), enc, C);
1773
1774    if (silence)
1775    {
1776       for (i=0;i<C*st->mode->nbEBands;i++)
1777          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
1778    }
1779
1780 #ifdef RESYNTH
1781    /* Re-synthesis of the coded audio if required */
1782    {
1783       celt_sig *out_mem[2];
1784       celt_sig *overlap_mem[2];
1785
1786       log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
1787       if (silence)
1788       {
1789          for (i=0;i<C*st->mode->nbEBands;i++)
1790             bandE[i] = 0;
1791       }
1792
1793 #ifdef MEASURE_NORM_MSE
1794       measure_norm_mse(st->mode, X, X0, bandE, bandE0, M, N, C);
1795 #endif
1796       if (anti_collapse_on)
1797       {
1798          anti_collapse(st->mode, X, collapse_masks, LM, C, N,
1799                st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
1800       }
1801
1802       /* Synthesis */
1803       denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
1804
1805       OPUS_MOVE(st->syn_mem[0], st->syn_mem[0]+N, MAX_PERIOD);
1806       if (CC==2)
1807          OPUS_MOVE(st->syn_mem[1], st->syn_mem[1]+N, MAX_PERIOD);
1808
1809       c=0; do
1810          for (i=0;i<M*st->mode->eBands[st->start];i++)
1811             freq[c*N+i] = 0;
1812       while (++c<C);
1813       c=0; do
1814          for (i=M*st->mode->eBands[st->end];i<N;i++)
1815             freq[c*N+i] = 0;
1816       while (++c<C);
1817
1818       if (CC==2&&C==1)
1819       {
1820          for (i=0;i<N;i++)
1821             freq[N+i] = freq[i];
1822       }
1823
1824       out_mem[0] = st->syn_mem[0]+MAX_PERIOD;
1825       if (CC==2)
1826          out_mem[1] = st->syn_mem[1]+MAX_PERIOD;
1827
1828       overlap_mem[0] = prefilter_mem+CC*COMBFILTER_MAXPERIOD;
1829       if (CC==2)
1830          overlap_mem[1] = overlap_mem[0] + st->overlap;
1831
1832       compute_inv_mdcts(st->mode, shortBlocks, freq, out_mem, overlap_mem, CC, LM);
1833
1834       c=0; do {
1835          st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
1836          st->prefilter_period_old=IMAX(st->prefilter_period_old, COMBFILTER_MINPERIOD);
1837          comb_filter(out_mem[c], out_mem[c], st->prefilter_period_old, st->prefilter_period, st->mode->shortMdctSize,
1838                st->prefilter_gain_old, st->prefilter_gain, st->prefilter_tapset_old, st->prefilter_tapset,
1839                st->mode->window, st->overlap);
1840          if (LM!=0)
1841             comb_filter(out_mem[c]+st->mode->shortMdctSize, out_mem[c]+st->mode->shortMdctSize, st->prefilter_period, pitch_index, N-st->mode->shortMdctSize,
1842                   st->prefilter_gain, gain1, st->prefilter_tapset, prefilter_tapset,
1843                   st->mode->window, st->mode->overlap);
1844       } while (++c<CC);
1845
1846       deemphasis(out_mem, (opus_val16*)pcm, N, CC, st->upsample, st->mode->preemph, st->preemph_memD);
1847       st->prefilter_period_old = st->prefilter_period;
1848       st->prefilter_gain_old = st->prefilter_gain;
1849       st->prefilter_tapset_old = st->prefilter_tapset;
1850    }
1851 #endif
1852
1853    st->prefilter_period = pitch_index;
1854    st->prefilter_gain = gain1;
1855    st->prefilter_tapset = prefilter_tapset;
1856 #ifdef RESYNTH
1857    if (LM!=0)
1858    {
1859       st->prefilter_period_old = st->prefilter_period;
1860       st->prefilter_gain_old = st->prefilter_gain;
1861       st->prefilter_tapset_old = st->prefilter_tapset;
1862    }
1863 #endif
1864
1865    if (CC==2&&C==1) {
1866       for (i=0;i<st->mode->nbEBands;i++)
1867          oldBandE[st->mode->nbEBands+i]=oldBandE[i];
1868    }
1869
1870    if (!isTransient)
1871    {
1872       for (i=0;i<CC*st->mode->nbEBands;i++)
1873          oldLogE2[i] = oldLogE[i];
1874       for (i=0;i<CC*st->mode->nbEBands;i++)
1875          oldLogE[i] = oldBandE[i];
1876    } else {
1877       for (i=0;i<CC*st->mode->nbEBands;i++)
1878          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
1879    }
1880    /* In case start or end were to change */
1881    c=0; do
1882    {
1883       for (i=0;i<st->start;i++)
1884       {
1885          oldBandE[c*st->mode->nbEBands+i]=0;
1886          oldLogE[c*st->mode->nbEBands+i]=oldLogE2[c*st->mode->nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
1887       }
1888       for (i=st->end;i<st->mode->nbEBands;i++)
1889       {
1890          oldBandE[c*st->mode->nbEBands+i]=0;
1891          oldLogE[c*st->mode->nbEBands+i]=oldLogE2[c*st->mode->nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
1892       }
1893    } while (++c<CC);
1894
1895    if (isTransient)
1896       st->consec_transient++;
1897    else
1898       st->consec_transient=0;
1899    st->rng = enc->rng;
1900
1901    /* If there's any room left (can only happen for very high rates),
1902       it's already filled with zeros */
1903    ec_enc_done(enc);
1904
1905 #ifdef CUSTOM_MODES
1906    if (st->signalling)
1907       nbCompressedBytes++;
1908 #endif
1909
1910    RESTORE_STACK;
1911    if (ec_get_error(enc))
1912       return OPUS_INTERNAL_ERROR;
1913    else
1914       return nbCompressedBytes;
1915 }
1916
1917
1918 #ifdef CUSTOM_MODES
1919
1920 #ifdef FIXED_POINT
1921 int opus_custom_encode(CELTEncoder * restrict st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1922 {
1923    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1924 }
1925
1926 #ifndef DISABLE_FLOAT_API
1927 int opus_custom_encode_float(CELTEncoder * restrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1928 {
1929    int j, ret, C, N;
1930    VARDECL(opus_int16, in);
1931    ALLOC_STACK;
1932
1933    if (pcm==NULL)
1934       return OPUS_BAD_ARG;
1935
1936    C = st->channels;
1937    N = frame_size;
1938    ALLOC(in, C*N, opus_int16);
1939
1940    for (j=0;j<C*N;j++)
1941      in[j] = FLOAT2INT16(pcm[j]);
1942
1943    ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
1944 #ifdef RESYNTH
1945    for (j=0;j<C*N;j++)
1946       ((float*)pcm)[j]=in[j]*(1.f/32768.f);
1947 #endif
1948    RESTORE_STACK;
1949    return ret;
1950 }
1951 #endif /* DISABLE_FLOAT_API */
1952 #else
1953
1954 int opus_custom_encode(CELTEncoder * restrict st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1955 {
1956    int j, ret, C, N;
1957    VARDECL(celt_sig, in);
1958    ALLOC_STACK;
1959
1960    if (pcm==NULL)
1961       return OPUS_BAD_ARG;
1962
1963    C=st->channels;
1964    N=frame_size;
1965    ALLOC(in, C*N, celt_sig);
1966    for (j=0;j<C*N;j++) {
1967      in[j] = SCALEOUT(pcm[j]);
1968    }
1969
1970    ret = celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
1971 #ifdef RESYNTH
1972    for (j=0;j<C*N;j++)
1973       ((opus_int16*)pcm)[j] = FLOAT2INT16(in[j]);
1974 #endif
1975    RESTORE_STACK;
1976    return ret;
1977 }
1978
1979 int opus_custom_encode_float(CELTEncoder * restrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1980 {
1981    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1982 }
1983
1984 #endif
1985
1986 #endif /* CUSTOM_MODES */
1987
1988 int opus_custom_encoder_ctl(CELTEncoder * restrict st, int request, ...)
1989 {
1990    va_list ap;
1991
1992    va_start(ap, request);
1993    switch (request)
1994    {
1995       case OPUS_SET_COMPLEXITY_REQUEST:
1996       {
1997          int value = va_arg(ap, opus_int32);
1998          if (value<0 || value>10)
1999             goto bad_arg;
2000          st->complexity = value;
2001       }
2002       break;
2003       case CELT_SET_START_BAND_REQUEST:
2004       {
2005          opus_int32 value = va_arg(ap, opus_int32);
2006          if (value<0 || value>=st->mode->nbEBands)
2007             goto bad_arg;
2008          st->start = value;
2009       }
2010       break;
2011       case CELT_SET_END_BAND_REQUEST:
2012       {
2013          opus_int32 value = va_arg(ap, opus_int32);
2014          if (value<1 || value>st->mode->nbEBands)
2015             goto bad_arg;
2016          st->end = value;
2017       }
2018       break;
2019       case CELT_SET_PREDICTION_REQUEST:
2020       {
2021          int value = va_arg(ap, opus_int32);
2022          if (value<0 || value>2)
2023             goto bad_arg;
2024          st->disable_pf = value<=1;
2025          st->force_intra = value==0;
2026       }
2027       break;
2028       case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2029       {
2030          int value = va_arg(ap, opus_int32);
2031          if (value<0 || value>100)
2032             goto bad_arg;
2033          st->loss_rate = value;
2034       }
2035       break;
2036       case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2037       {
2038          opus_int32 value = va_arg(ap, opus_int32);
2039          st->constrained_vbr = value;
2040       }
2041       break;
2042       case OPUS_SET_VBR_REQUEST:
2043       {
2044          opus_int32 value = va_arg(ap, opus_int32);
2045          st->vbr = value;
2046       }
2047       break;
2048       case OPUS_SET_BITRATE_REQUEST:
2049       {
2050          opus_int32 value = va_arg(ap, opus_int32);
2051          if (value<=500 && value!=OPUS_BITRATE_MAX)
2052             goto bad_arg;
2053          value = IMIN(value, 260000*st->channels);
2054          st->bitrate = value;
2055       }
2056       break;
2057       case CELT_SET_CHANNELS_REQUEST:
2058       {
2059          opus_int32 value = va_arg(ap, opus_int32);
2060          if (value<1 || value>2)
2061             goto bad_arg;
2062          st->stream_channels = value;
2063       }
2064       break;
2065       case OPUS_SET_LSB_DEPTH_REQUEST:
2066       {
2067           opus_int32 value = va_arg(ap, opus_int32);
2068           if (value<8 || value>24)
2069              goto bad_arg;
2070           st->lsb_depth=value;
2071       }
2072       break;
2073       case OPUS_GET_LSB_DEPTH_REQUEST:
2074       {
2075           opus_int32 *value = va_arg(ap, opus_int32*);
2076           *value=st->lsb_depth;
2077       }
2078       break;
2079       case OPUS_RESET_STATE:
2080       {
2081          int i;
2082          opus_val16 *oldBandE, *oldLogE, *oldLogE2;
2083          oldBandE = (opus_val16*)(st->in_mem+st->channels*(2*st->overlap+COMBFILTER_MAXPERIOD));
2084          oldLogE = oldBandE + st->channels*st->mode->nbEBands;
2085          oldLogE2 = oldLogE + st->channels*st->mode->nbEBands;
2086          OPUS_CLEAR((char*)&st->ENCODER_RESET_START,
2087                opus_custom_encoder_get_size(st->mode, st->channels)-
2088                ((char*)&st->ENCODER_RESET_START - (char*)st));
2089          for (i=0;i<st->channels*st->mode->nbEBands;i++)
2090             oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT);
2091          st->vbr_offset = 0;
2092          st->delayedIntra = 1;
2093          st->spread_decision = SPREAD_NORMAL;
2094          st->tonal_average = 256;
2095          st->hf_average = 0;
2096          st->tapset_decision = 0;
2097       }
2098       break;
2099 #ifdef CUSTOM_MODES
2100       case CELT_SET_INPUT_CLIPPING_REQUEST:
2101       {
2102          opus_int32 value = va_arg(ap, opus_int32);
2103          st->clip = value;
2104       }
2105       break;
2106 #endif
2107       case CELT_SET_SIGNALLING_REQUEST:
2108       {
2109          opus_int32 value = va_arg(ap, opus_int32);
2110          st->signalling = value;
2111       }
2112       break;
2113       case CELT_SET_ANALYSIS_REQUEST:
2114       {
2115          AnalysisInfo *info = va_arg(ap, AnalysisInfo *);
2116          if (info)
2117             OPUS_COPY(&st->analysis, info, 1);
2118       }
2119       break;
2120       case CELT_GET_MODE_REQUEST:
2121       {
2122          const CELTMode ** value = va_arg(ap, const CELTMode**);
2123          if (value==0)
2124             goto bad_arg;
2125          *value=st->mode;
2126       }
2127       break;
2128       case OPUS_GET_FINAL_RANGE_REQUEST:
2129       {
2130          opus_uint32 * value = va_arg(ap, opus_uint32 *);
2131          if (value==0)
2132             goto bad_arg;
2133          *value=st->rng;
2134       }
2135       break;
2136       default:
2137          goto bad_request;
2138    }
2139    va_end(ap);
2140    return OPUS_OK;
2141 bad_arg:
2142    va_end(ap);
2143    return OPUS_BAD_ARG;
2144 bad_request:
2145    va_end(ap);
2146    return OPUS_UNIMPLEMENTED;
2147 }
2148
2149 /**********************************************************************/
2150 /*                                                                    */
2151 /*                             DECODER                                */
2152 /*                                                                    */
2153 /**********************************************************************/
2154 #define DECODE_BUFFER_SIZE 2048
2155
2156 /** Decoder state
2157  @brief Decoder state
2158  */
2159 struct OpusCustomDecoder {
2160    const OpusCustomMode *mode;
2161    int overlap;
2162    int channels;
2163    int stream_channels;
2164
2165    int downsample;
2166    int start, end;
2167    int signalling;
2168
2169    /* Everything beyond this point gets cleared on a reset */
2170 #define DECODER_RESET_START rng
2171
2172    opus_uint32 rng;
2173    int error;
2174    int last_pitch_index;
2175    int loss_count;
2176    int postfilter_period;
2177    int postfilter_period_old;
2178    opus_val16 postfilter_gain;
2179    opus_val16 postfilter_gain_old;
2180    int postfilter_tapset;
2181    int postfilter_tapset_old;
2182
2183    celt_sig preemph_memD[2];
2184
2185    celt_sig _decode_mem[1]; /* Size = channels*(DECODE_BUFFER_SIZE+mode->overlap) */
2186    /* opus_val16 lpc[],  Size = channels*LPC_ORDER */
2187    /* opus_val16 oldEBands[], Size = 2*mode->nbEBands */
2188    /* opus_val16 oldLogE[], Size = 2*mode->nbEBands */
2189    /* opus_val16 oldLogE2[], Size = 2*mode->nbEBands */
2190    /* opus_val16 backgroundLogE[], Size = 2*mode->nbEBands */
2191 };
2192
2193 int celt_decoder_get_size(int channels)
2194 {
2195    const CELTMode *mode = opus_custom_mode_create(48000, 960, NULL);
2196    return opus_custom_decoder_get_size(mode, channels);
2197 }
2198
2199 OPUS_CUSTOM_NOSTATIC int opus_custom_decoder_get_size(const CELTMode *mode, int channels)
2200 {
2201    int size = sizeof(struct CELTDecoder)
2202             + (channels*(DECODE_BUFFER_SIZE+mode->overlap)-1)*sizeof(celt_sig)
2203             + channels*LPC_ORDER*sizeof(opus_val16)
2204             + 4*2*mode->nbEBands*sizeof(opus_val16);
2205    return size;
2206 }
2207
2208 #ifdef CUSTOM_MODES
2209 CELTDecoder *opus_custom_decoder_create(const CELTMode *mode, int channels, int *error)
2210 {
2211    int ret;
2212    CELTDecoder *st = (CELTDecoder *)opus_alloc(opus_custom_decoder_get_size(mode, channels));
2213    ret = opus_custom_decoder_init(st, mode, channels);
2214    if (ret != OPUS_OK)
2215    {
2216       opus_custom_decoder_destroy(st);
2217       st = NULL;
2218    }
2219    if (error)
2220       *error = ret;
2221    return st;
2222 }
2223 #endif /* CUSTOM_MODES */
2224
2225 int celt_decoder_init(CELTDecoder *st, opus_int32 sampling_rate, int channels)
2226 {
2227    int ret;
2228    ret = opus_custom_decoder_init(st, opus_custom_mode_create(48000, 960, NULL), channels);
2229    if (ret != OPUS_OK)
2230       return ret;
2231    st->downsample = resampling_factor(sampling_rate);
2232    if (st->downsample==0)
2233       return OPUS_BAD_ARG;
2234    else
2235       return OPUS_OK;
2236 }
2237
2238 OPUS_CUSTOM_NOSTATIC int opus_custom_decoder_init(CELTDecoder *st, const CELTMode *mode, int channels)
2239 {
2240    if (channels < 0 || channels > 2)
2241       return OPUS_BAD_ARG;
2242
2243    if (st==NULL)
2244       return OPUS_ALLOC_FAIL;
2245
2246    OPUS_CLEAR((char*)st, opus_custom_decoder_get_size(mode, channels));
2247
2248    st->mode = mode;
2249    st->overlap = mode->overlap;
2250    st->stream_channels = st->channels = channels;
2251
2252    st->downsample = 1;
2253    st->start = 0;
2254    st->end = st->mode->effEBands;
2255    st->signalling = 1;
2256
2257    st->loss_count = 0;
2258
2259    opus_custom_decoder_ctl(st, OPUS_RESET_STATE);
2260
2261    return OPUS_OK;
2262 }
2263
2264 #ifdef CUSTOM_MODES
2265 void opus_custom_decoder_destroy(CELTDecoder *st)
2266 {
2267    opus_free(st);
2268 }
2269 #endif /* CUSTOM_MODES */
2270
2271 static void celt_decode_lost(CELTDecoder * restrict st, opus_val16 * restrict pcm, int N, int LM)
2272 {
2273    int c;
2274    int pitch_index;
2275    int overlap = st->mode->overlap;
2276    opus_val16 fade = Q15ONE;
2277    int i, len;
2278    const int C = st->channels;
2279    int offset;
2280    celt_sig *out_mem[2];
2281    celt_sig *decode_mem[2];
2282    celt_sig *overlap_mem[2];
2283    opus_val16 *lpc;
2284    opus_val32 *out_syn[2];
2285    opus_val16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE;
2286    SAVE_STACK;
2287
2288    c=0; do {
2289       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
2290       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
2291       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
2292    } while (++c<C);
2293    lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*C);
2294    oldBandE = lpc+C*LPC_ORDER;
2295    oldLogE = oldBandE + 2*st->mode->nbEBands;
2296    oldLogE2 = oldLogE + 2*st->mode->nbEBands;
2297    backgroundLogE = oldLogE2  + 2*st->mode->nbEBands;
2298
2299    out_syn[0] = out_mem[0]+MAX_PERIOD-N;
2300    if (C==2)
2301       out_syn[1] = out_mem[1]+MAX_PERIOD-N;
2302
2303    len = N+st->mode->overlap;
2304
2305    if (st->loss_count >= 5 || st->start!=0)
2306    {
2307       /* Noise-based PLC/CNG */
2308       VARDECL(celt_sig, freq);
2309       VARDECL(celt_norm, X);
2310       VARDECL(celt_ener, bandE);
2311       opus_uint32 seed;
2312       int effEnd;
2313
2314       effEnd = st->end;
2315       if (effEnd > st->mode->effEBands)
2316          effEnd = st->mode->effEBands;
2317
2318       ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
2319       ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
2320       ALLOC(bandE, st->mode->nbEBands*C, celt_ener);
2321
2322       if (st->loss_count >= 5)
2323          log2Amp(st->mode, st->start, st->end, bandE, backgroundLogE, C);
2324       else {
2325          /* Energy decay */
2326          opus_val16 decay = st->loss_count==0 ? QCONST16(1.5f, DB_SHIFT) : QCONST16(.5f, DB_SHIFT);
2327          c=0; do
2328          {
2329             for (i=st->start;i<st->end;i++)
2330                oldBandE[c*st->mode->nbEBands+i] -= decay;
2331          } while (++c<C);
2332          log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
2333       }
2334       seed = st->rng;
2335       for (c=0;c<C;c++)
2336       {
2337          for (i=0;i<(st->mode->eBands[st->start]<<LM);i++)
2338             X[c*N+i] = 0;
2339          for (i=st->start;i<st->mode->effEBands;i++)
2340          {
2341             int j;
2342             int boffs;
2343             int blen;
2344             boffs = N*c+(st->mode->eBands[i]<<LM);
2345             blen = (st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
2346             for (j=0;j<blen;j++)
2347             {
2348                seed = celt_lcg_rand(seed);
2349                X[boffs+j] = (celt_norm)((opus_int32)seed>>20);
2350             }
2351             renormalise_vector(X+boffs, blen, Q15ONE);
2352          }
2353          for (i=(st->mode->eBands[st->end]<<LM);i<N;i++)
2354             X[c*N+i] = 0;
2355       }
2356       st->rng = seed;
2357
2358       denormalise_bands(st->mode, X, freq, bandE, st->mode->effEBands, C, 1<<LM);
2359
2360       c=0; do
2361          for (i=0;i<st->mode->eBands[st->start]<<LM;i++)
2362             freq[c*N+i] = 0;
2363       while (++c<C);
2364       c=0; do {
2365          int bound = st->mode->eBands[effEnd]<<LM;
2366          if (st->downsample!=1)
2367             bound = IMIN(bound, N/st->downsample);
2368          for (i=bound;i<N;i++)
2369             freq[c*N+i] = 0;
2370       } while (++c<C);
2371       compute_inv_mdcts(st->mode, 0, freq, out_syn, overlap_mem, C, LM);
2372    } else {
2373       /* Pitch-based PLC */
2374       if (st->loss_count == 0)
2375       {
2376          opus_val16 pitch_buf[DECODE_BUFFER_SIZE>>1];
2377          /* Corresponds to a min pitch of 67 Hz. It's possible to save CPU in this
2378          search by using only part of the decode buffer */
2379          int poffset = 720;
2380          pitch_downsample(decode_mem, pitch_buf, DECODE_BUFFER_SIZE, C);
2381          /* Max pitch is 100 samples (480 Hz) */
2382          pitch_search(pitch_buf+((poffset)>>1), pitch_buf, DECODE_BUFFER_SIZE-poffset,
2383                poffset-100, &pitch_index);
2384          pitch_index = poffset-pitch_index;
2385          st->last_pitch_index = pitch_index;
2386       } else {
2387          pitch_index = st->last_pitch_index;
2388          fade = QCONST16(.8f,15);
2389       }
2390
2391       c=0; do {
2392          VARDECL(opus_val32, e);
2393          opus_val16 exc[MAX_PERIOD];
2394          opus_val32 ac[LPC_ORDER+1];
2395          opus_val16 decay = 1;
2396          opus_val32 S1=0;
2397          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};
2398
2399          ALLOC(e, MAX_PERIOD+2*st->mode->overlap, opus_val32);
2400
2401          offset = MAX_PERIOD-pitch_index;
2402          for (i=0;i<MAX_PERIOD;i++)
2403             exc[i] = ROUND16(out_mem[c][i], SIG_SHIFT);
2404
2405          if (st->loss_count == 0)
2406          {
2407             _celt_autocorr(exc, ac, st->mode->window, st->mode->overlap,
2408                   LPC_ORDER, MAX_PERIOD);
2409
2410             /* Noise floor -40 dB */
2411 #ifdef FIXED_POINT
2412             ac[0] += SHR32(ac[0],13);
2413 #else
2414             ac[0] *= 1.0001f;
2415 #endif
2416             /* Lag windowing */
2417             for (i=1;i<=LPC_ORDER;i++)
2418             {
2419                /*ac[i] *= exp(-.5*(2*M_PI*.002*i)*(2*M_PI*.002*i));*/
2420 #ifdef FIXED_POINT
2421                ac[i] -= MULT16_32_Q15(2*i*i, ac[i]);
2422 #else
2423                ac[i] -= ac[i]*(.008f*i)*(.008f*i);
2424 #endif
2425             }
2426
2427             _celt_lpc(lpc+c*LPC_ORDER, ac, LPC_ORDER);
2428          }
2429          for (i=0;i<LPC_ORDER;i++)
2430             mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT);
2431          celt_fir(exc, lpc+c*LPC_ORDER, exc, MAX_PERIOD, LPC_ORDER, mem);
2432          /*for (i=0;i<MAX_PERIOD;i++)printf("%d ", exc[i]); printf("\n");*/
2433          /* Check if the waveform is decaying (and if so how fast) */
2434          {
2435             opus_val32 E1=1, E2=1;
2436             int period;
2437             if (pitch_index <= MAX_PERIOD/2)
2438                period = pitch_index;
2439             else
2440                period = MAX_PERIOD/2;
2441             for (i=0;i<period;i++)
2442             {
2443                E1 += SHR32(MULT16_16(exc[MAX_PERIOD-period+i],exc[MAX_PERIOD-period+i]),8);
2444                E2 += SHR32(MULT16_16(exc[MAX_PERIOD-2*period+i],exc[MAX_PERIOD-2*period+i]),8);
2445             }
2446             if (E1 > E2)
2447                E1 = E2;
2448             decay = celt_sqrt(frac_div32(SHR32(E1,1),E2));
2449          }
2450
2451          /* Copy excitation, taking decay into account */
2452          for (i=0;i<len+st->mode->overlap;i++)
2453          {
2454             opus_val16 tmp;
2455             if (offset+i >= MAX_PERIOD)
2456             {
2457                offset -= pitch_index;
2458                decay = MULT16_16_Q15(decay, decay);
2459             }
2460             e[i] = SHL32(EXTEND32(MULT16_16_Q15(decay, exc[offset+i])), SIG_SHIFT);
2461             tmp = ROUND16(out_mem[c][offset+i],SIG_SHIFT);
2462             S1 += SHR32(MULT16_16(tmp,tmp),8);
2463          }
2464          for (i=0;i<LPC_ORDER;i++)
2465             mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT);
2466          for (i=0;i<len+st->mode->overlap;i++)
2467             e[i] = MULT16_32_Q15(fade, e[i]);
2468          celt_iir(e, lpc+c*LPC_ORDER, e, len+st->mode->overlap, LPC_ORDER, mem);
2469
2470          {
2471             opus_val32 S2=0;
2472             for (i=0;i<len+overlap;i++)
2473             {
2474                opus_val16 tmp = ROUND16(e[i],SIG_SHIFT);
2475                S2 += SHR32(MULT16_16(tmp,tmp),8);
2476             }
2477             /* This checks for an "explosion" in the synthesis */
2478 #ifdef FIXED_POINT
2479             if (!(S1 > SHR32(S2,2)))
2480 #else
2481                /* Float test is written this way to catch NaNs at the same time */
2482                if (!(S1 > 0.2f*S2))
2483 #endif
2484                {
2485                   for (i=0;i<len+overlap;i++)
2486                      e[i] = 0;
2487                } else if (S1 < S2)
2488                {
2489                   opus_val16 ratio = celt_sqrt(frac_div32(SHR32(S1,1)+1,S2+1));
2490                   for (i=0;i<len+overlap;i++)
2491                      e[i] = MULT16_32_Q15(ratio, e[i]);
2492                }
2493          }
2494
2495          /* Apply post-filter to the MDCT overlap of the previous frame */
2496          comb_filter(out_mem[c]+MAX_PERIOD, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap,
2497                st->postfilter_gain, st->postfilter_gain, st->postfilter_tapset, st->postfilter_tapset,
2498                NULL, 0);
2499
2500          for (i=0;i<MAX_PERIOD+st->mode->overlap-N;i++)
2501             out_mem[c][i] = out_mem[c][N+i];
2502
2503          /* Apply TDAC to the concealed audio so that it blends with the
2504          previous and next frames */
2505          for (i=0;i<overlap/2;i++)
2506          {
2507             opus_val32 tmp;
2508             tmp = MULT16_32_Q15(st->mode->window[i],           e[N+overlap-1-i]) +
2509                   MULT16_32_Q15(st->mode->window[overlap-i-1], e[N+i          ]);
2510             out_mem[c][MAX_PERIOD+i] = MULT16_32_Q15(st->mode->window[overlap-i-1], tmp);
2511             out_mem[c][MAX_PERIOD+overlap-i-1] = MULT16_32_Q15(st->mode->window[i], tmp);
2512          }
2513          for (i=0;i<N;i++)
2514             out_mem[c][MAX_PERIOD-N+i] = e[i];
2515
2516          /* Apply pre-filter to the MDCT overlap for the next frame (post-filter will be applied then) */
2517          comb_filter(e, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap,
2518                -st->postfilter_gain, -st->postfilter_gain, st->postfilter_tapset, st->postfilter_tapset,
2519                NULL, 0);
2520          for (i=0;i<overlap;i++)
2521             out_mem[c][MAX_PERIOD+i] = e[i];
2522       } while (++c<C);
2523    }
2524
2525    deemphasis(out_syn, pcm, N, C, st->downsample, st->mode->preemph, st->preemph_memD);
2526
2527    st->loss_count++;
2528
2529    RESTORE_STACK;
2530 }
2531
2532 int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, int len, opus_val16 * restrict pcm, int frame_size, ec_dec *dec)
2533 {
2534    int c, i, N;
2535    int spread_decision;
2536    opus_int32 bits;
2537    ec_dec _dec;
2538    VARDECL(celt_sig, freq);
2539    VARDECL(celt_norm, X);
2540    VARDECL(celt_ener, bandE);
2541    VARDECL(int, fine_quant);
2542    VARDECL(int, pulses);
2543    VARDECL(int, cap);
2544    VARDECL(int, offsets);
2545    VARDECL(int, fine_priority);
2546    VARDECL(int, tf_res);
2547    VARDECL(unsigned char, collapse_masks);
2548    celt_sig *out_mem[2];
2549    celt_sig *decode_mem[2];
2550    celt_sig *overlap_mem[2];
2551    celt_sig *out_syn[2];
2552    opus_val16 *lpc;
2553    opus_val16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE;
2554
2555    int shortBlocks;
2556    int isTransient;
2557    int intra_ener;
2558    const int CC = st->channels;
2559    int LM, M;
2560    int effEnd;
2561    int codedBands;
2562    int alloc_trim;
2563    int postfilter_pitch;
2564    opus_val16 postfilter_gain;
2565    int intensity=0;
2566    int dual_stereo=0;
2567    opus_int32 total_bits;
2568    opus_int32 balance;
2569    opus_int32 tell;
2570    int dynalloc_logp;
2571    int postfilter_tapset;
2572    int anti_collapse_rsv;
2573    int anti_collapse_on=0;
2574    int silence;
2575    int C = st->stream_channels;
2576    ALLOC_STACK;
2577
2578    frame_size *= st->downsample;
2579
2580    c=0; do {
2581       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
2582       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
2583       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
2584    } while (++c<CC);
2585    lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*CC);
2586    oldBandE = lpc+CC*LPC_ORDER;
2587    oldLogE = oldBandE + 2*st->mode->nbEBands;
2588    oldLogE2 = oldLogE + 2*st->mode->nbEBands;
2589    backgroundLogE = oldLogE2  + 2*st->mode->nbEBands;
2590
2591 #ifdef CUSTOM_MODES
2592    if (st->signalling && data!=NULL)
2593    {
2594       int data0=data[0];
2595       /* Convert "standard mode" to Opus header */
2596       if (st->mode->Fs==48000 && st->mode->shortMdctSize==120)
2597       {
2598          data0 = fromOpus(data0);
2599          if (data0<0)
2600             return OPUS_INVALID_PACKET;
2601       }
2602       st->end = IMAX(1, st->mode->effEBands-2*(data0>>5));
2603       LM = (data0>>3)&0x3;
2604       C = 1 + ((data0>>2)&0x1);
2605       data++;
2606       len--;
2607       if (LM>st->mode->maxLM)
2608          return OPUS_INVALID_PACKET;
2609       if (frame_size < st->mode->shortMdctSize<<LM)
2610          return OPUS_BUFFER_TOO_SMALL;
2611       else
2612          frame_size = st->mode->shortMdctSize<<LM;
2613    } else {
2614 #else
2615    {
2616 #endif
2617       for (LM=0;LM<=st->mode->maxLM;LM++)
2618          if (st->mode->shortMdctSize<<LM==frame_size)
2619             break;
2620       if (LM>st->mode->maxLM)
2621          return OPUS_BAD_ARG;
2622    }
2623    M=1<<LM;
2624
2625    if (len<0 || len>1275 || pcm==NULL)
2626       return OPUS_BAD_ARG;
2627
2628    N = M*st->mode->shortMdctSize;
2629
2630    effEnd = st->end;
2631    if (effEnd > st->mode->effEBands)
2632       effEnd = st->mode->effEBands;
2633
2634    ALLOC(freq, IMAX(CC,C)*N, celt_sig); /**< Interleaved signal MDCTs */
2635    ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
2636    ALLOC(bandE, st->mode->nbEBands*C, celt_ener);
2637    c=0; do
2638       for (i=0;i<M*st->mode->eBands[st->start];i++)
2639          X[c*N+i] = 0;
2640    while (++c<C);
2641    c=0; do
2642       for (i=M*st->mode->eBands[effEnd];i<N;i++)
2643          X[c*N+i] = 0;
2644    while (++c<C);
2645
2646    if (data == NULL || len<=1)
2647    {
2648       celt_decode_lost(st, pcm, N, LM);
2649       RESTORE_STACK;
2650       return frame_size/st->downsample;
2651    }
2652
2653    if (dec == NULL)
2654    {
2655       ec_dec_init(&_dec,(unsigned char*)data,len);
2656       dec = &_dec;
2657    }
2658
2659    if (C==1)
2660    {
2661       for (i=0;i<st->mode->nbEBands;i++)
2662          oldBandE[i]=MAX16(oldBandE[i],oldBandE[st->mode->nbEBands+i]);
2663    }
2664
2665    total_bits = len*8;
2666    tell = ec_tell(dec);
2667
2668    if (tell >= total_bits)
2669       silence = 1;
2670    else if (tell==1)
2671       silence = ec_dec_bit_logp(dec, 15);
2672    else
2673       silence = 0;
2674    if (silence)
2675    {
2676       /* Pretend we've read all the remaining bits */
2677       tell = len*8;
2678       dec->nbits_total+=tell-ec_tell(dec);
2679    }
2680
2681    postfilter_gain = 0;
2682    postfilter_pitch = 0;
2683    postfilter_tapset = 0;
2684    if (st->start==0 && tell+16 <= total_bits)
2685    {
2686       if(ec_dec_bit_logp(dec, 1))
2687       {
2688          int qg, octave;
2689          octave = ec_dec_uint(dec, 6);
2690          postfilter_pitch = (16<<octave)+ec_dec_bits(dec, 4+octave)-1;
2691          qg = ec_dec_bits(dec, 3);
2692          if (ec_tell(dec)+2<=total_bits)
2693             postfilter_tapset = ec_dec_icdf(dec, tapset_icdf, 2);
2694          postfilter_gain = QCONST16(.09375f,15)*(qg+1);
2695       }
2696       tell = ec_tell(dec);
2697    }
2698
2699    if (LM > 0 && tell+3 <= total_bits)
2700    {
2701       isTransient = ec_dec_bit_logp(dec, 3);
2702       tell = ec_tell(dec);
2703    }
2704    else
2705       isTransient = 0;
2706
2707    if (isTransient)
2708       shortBlocks = M;
2709    else
2710       shortBlocks = 0;
2711
2712    /* Decode the global flags (first symbols in the stream) */
2713    intra_ener = tell+3<=total_bits ? ec_dec_bit_logp(dec, 3) : 0;
2714    /* Get band energies */
2715    unquant_coarse_energy(st->mode, st->start, st->end, oldBandE,
2716          intra_ener, dec, C, LM);
2717
2718    ALLOC(tf_res, st->mode->nbEBands, int);
2719    tf_decode(st->start, st->end, isTransient, tf_res, LM, dec);
2720
2721    tell = ec_tell(dec);
2722    spread_decision = SPREAD_NORMAL;
2723    if (tell+4 <= total_bits)
2724       spread_decision = ec_dec_icdf(dec, spread_icdf, 5);
2725
2726    ALLOC(pulses, st->mode->nbEBands, int);
2727    ALLOC(cap, st->mode->nbEBands, int);
2728    ALLOC(offsets, st->mode->nbEBands, int);
2729    ALLOC(fine_priority, st->mode->nbEBands, int);
2730
2731    init_caps(st->mode,cap,LM,C);
2732
2733    dynalloc_logp = 6;
2734    total_bits<<=BITRES;
2735    tell = ec_tell_frac(dec);
2736    for (i=st->start;i<st->end;i++)
2737    {
2738       int width, quanta;
2739       int dynalloc_loop_logp;
2740       int boost;
2741       width = C*(st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
2742       /* quanta is 6 bits, but no more than 1 bit/sample
2743          and no less than 1/8 bit/sample */
2744       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
2745       dynalloc_loop_logp = dynalloc_logp;
2746       boost = 0;
2747       while (tell+(dynalloc_loop_logp<<BITRES) < total_bits && boost < cap[i])
2748       {
2749          int flag;
2750          flag = ec_dec_bit_logp(dec, dynalloc_loop_logp);
2751          tell = ec_tell_frac(dec);
2752          if (!flag)
2753             break;
2754          boost += quanta;
2755          total_bits -= quanta;
2756          dynalloc_loop_logp = 1;
2757       }
2758       offsets[i] = boost;
2759       /* Making dynalloc more likely */
2760       if (boost>0)
2761          dynalloc_logp = IMAX(2, dynalloc_logp-1);
2762    }
2763
2764    ALLOC(fine_quant, st->mode->nbEBands, int);
2765    alloc_trim = tell+(6<<BITRES) <= total_bits ?
2766          ec_dec_icdf(dec, trim_icdf, 7) : 5;
2767
2768    bits = (((opus_int32)len*8)<<BITRES) - ec_tell_frac(dec) - 1;
2769    anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0;
2770    bits -= anti_collapse_rsv;
2771    codedBands = compute_allocation(st->mode, st->start, st->end, offsets, cap,
2772          alloc_trim, &intensity, &dual_stereo, bits, &balance, pulses,
2773          fine_quant, fine_priority, C, LM, dec, 0, 0);
2774
2775    unquant_fine_energy(st->mode, st->start, st->end, oldBandE, fine_quant, dec, C);
2776
2777    /* Decode fixed codebook */
2778    ALLOC(collapse_masks, C*st->mode->nbEBands, unsigned char);
2779    quant_all_bands(0, st->mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
2780          NULL, pulses, shortBlocks, spread_decision, dual_stereo, intensity, tf_res,
2781          len*(8<<BITRES)-anti_collapse_rsv, balance, dec, LM, codedBands, &st->rng);
2782
2783    if (anti_collapse_rsv > 0)
2784    {
2785       anti_collapse_on = ec_dec_bits(dec, 1);
2786    }
2787
2788    unquant_energy_finalise(st->mode, st->start, st->end, oldBandE,
2789          fine_quant, fine_priority, len*8-ec_tell(dec), dec, C);
2790
2791    if (anti_collapse_on)
2792       anti_collapse(st->mode, X, collapse_masks, LM, C, N,
2793             st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
2794
2795    log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
2796
2797    if (silence)
2798    {
2799       for (i=0;i<C*st->mode->nbEBands;i++)
2800       {
2801          bandE[i] = 0;
2802          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
2803       }
2804    }
2805    /* Synthesis */
2806    denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
2807
2808    OPUS_MOVE(decode_mem[0], decode_mem[0]+N, DECODE_BUFFER_SIZE-N);
2809    if (CC==2)
2810       OPUS_MOVE(decode_mem[1], decode_mem[1]+N, DECODE_BUFFER_SIZE-N);
2811
2812    c=0; do
2813       for (i=0;i<M*st->mode->eBands[st->start];i++)
2814          freq[c*N+i] = 0;
2815    while (++c<C);
2816    c=0; do {
2817       int bound = M*st->mode->eBands[effEnd];
2818       if (st->downsample!=1)
2819          bound = IMIN(bound, N/st->downsample);
2820       for (i=bound;i<N;i++)
2821          freq[c*N+i] = 0;
2822    } while (++c<C);
2823
2824    out_syn[0] = out_mem[0]+MAX_PERIOD-N;
2825    if (CC==2)
2826       out_syn[1] = out_mem[1]+MAX_PERIOD-N;
2827
2828    if (CC==2&&C==1)
2829    {
2830       for (i=0;i<N;i++)
2831          freq[N+i] = freq[i];
2832    }
2833    if (CC==1&&C==2)
2834    {
2835       for (i=0;i<N;i++)
2836          freq[i] = HALF32(ADD32(freq[i],freq[N+i]));
2837    }
2838
2839    /* Compute inverse MDCTs */
2840    compute_inv_mdcts(st->mode, shortBlocks, freq, out_syn, overlap_mem, CC, LM);
2841
2842    c=0; do {
2843       st->postfilter_period=IMAX(st->postfilter_period, COMBFILTER_MINPERIOD);
2844       st->postfilter_period_old=IMAX(st->postfilter_period_old, COMBFILTER_MINPERIOD);
2845       comb_filter(out_syn[c], out_syn[c], st->postfilter_period_old, st->postfilter_period, st->mode->shortMdctSize,
2846             st->postfilter_gain_old, st->postfilter_gain, st->postfilter_tapset_old, st->postfilter_tapset,
2847             st->mode->window, st->overlap);
2848       if (LM!=0)
2849          comb_filter(out_syn[c]+st->mode->shortMdctSize, out_syn[c]+st->mode->shortMdctSize, st->postfilter_period, postfilter_pitch, N-st->mode->shortMdctSize,
2850                st->postfilter_gain, postfilter_gain, st->postfilter_tapset, postfilter_tapset,
2851                st->mode->window, st->mode->overlap);
2852
2853    } while (++c<CC);
2854    st->postfilter_period_old = st->postfilter_period;
2855    st->postfilter_gain_old = st->postfilter_gain;
2856    st->postfilter_tapset_old = st->postfilter_tapset;
2857    st->postfilter_period = postfilter_pitch;
2858    st->postfilter_gain = postfilter_gain;
2859    st->postfilter_tapset = postfilter_tapset;
2860    if (LM!=0)
2861    {
2862       st->postfilter_period_old = st->postfilter_period;
2863       st->postfilter_gain_old = st->postfilter_gain;
2864       st->postfilter_tapset_old = st->postfilter_tapset;
2865    }
2866
2867    if (C==1) {
2868       for (i=0;i<st->mode->nbEBands;i++)
2869          oldBandE[st->mode->nbEBands+i]=oldBandE[i];
2870    }
2871
2872    /* In case start or end were to change */
2873    if (!isTransient)
2874    {
2875       for (i=0;i<2*st->mode->nbEBands;i++)
2876          oldLogE2[i] = oldLogE[i];
2877       for (i=0;i<2*st->mode->nbEBands;i++)
2878          oldLogE[i] = oldBandE[i];
2879       for (i=0;i<2*st->mode->nbEBands;i++)
2880          backgroundLogE[i] = MIN16(backgroundLogE[i] + M*QCONST16(0.001f,DB_SHIFT), oldBandE[i]);
2881    } else {
2882       for (i=0;i<2*st->mode->nbEBands;i++)
2883          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
2884    }
2885    c=0; do
2886    {
2887       for (i=0;i<st->start;i++)
2888       {
2889          oldBandE[c*st->mode->nbEBands+i]=0;
2890          oldLogE[c*st->mode->nbEBands+i]=oldLogE2[c*st->mode->nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
2891       }
2892       for (i=st->end;i<st->mode->nbEBands;i++)
2893       {
2894          oldBandE[c*st->mode->nbEBands+i]=0;
2895          oldLogE[c*st->mode->nbEBands+i]=oldLogE2[c*st->mode->nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
2896       }
2897    } while (++c<2);
2898    st->rng = dec->rng;
2899
2900    deemphasis(out_syn, pcm, N, CC, st->downsample, st->mode->preemph, st->preemph_memD);
2901    st->loss_count = 0;
2902    RESTORE_STACK;
2903    if (ec_tell(dec) > 8*len)
2904       return OPUS_INTERNAL_ERROR;
2905    if(ec_get_error(dec))
2906       st->error = 1;
2907    return frame_size/st->downsample;
2908 }
2909
2910
2911 #ifdef CUSTOM_MODES
2912
2913 #ifdef FIXED_POINT
2914 int opus_custom_decode(CELTDecoder * restrict st, const unsigned char *data, int len, opus_int16 * restrict pcm, int frame_size)
2915 {
2916    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
2917 }
2918
2919 #ifndef DISABLE_FLOAT_API
2920 int opus_custom_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size)
2921 {
2922    int j, ret, C, N;
2923    VARDECL(opus_int16, out);
2924    ALLOC_STACK;
2925
2926    if (pcm==NULL)
2927       return OPUS_BAD_ARG;
2928
2929    C = st->channels;
2930    N = frame_size;
2931
2932    ALLOC(out, C*N, opus_int16);
2933    ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL);
2934    if (ret>0)
2935       for (j=0;j<C*ret;j++)
2936          pcm[j]=out[j]*(1.f/32768.f);
2937
2938    RESTORE_STACK;
2939    return ret;
2940 }
2941 #endif /* DISABLE_FLOAT_API */
2942
2943 #else
2944
2945 int opus_custom_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size)
2946 {
2947    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
2948 }
2949
2950 int opus_custom_decode(CELTDecoder * restrict st, const unsigned char *data, int len, opus_int16 * restrict pcm, int frame_size)
2951 {
2952    int j, ret, C, N;
2953    VARDECL(celt_sig, out);
2954    ALLOC_STACK;
2955
2956    if (pcm==NULL)
2957       return OPUS_BAD_ARG;
2958
2959    C = st->channels;
2960    N = frame_size;
2961    ALLOC(out, C*N, celt_sig);
2962
2963    ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL);
2964
2965    if (ret>0)
2966       for (j=0;j<C*ret;j++)
2967          pcm[j] = FLOAT2INT16 (out[j]);
2968
2969    RESTORE_STACK;
2970    return ret;
2971 }
2972
2973 #endif
2974 #endif /* CUSTOM_MODES */
2975
2976 int opus_custom_decoder_ctl(CELTDecoder * restrict st, int request, ...)
2977 {
2978    va_list ap;
2979
2980    va_start(ap, request);
2981    switch (request)
2982    {
2983       case CELT_SET_START_BAND_REQUEST:
2984       {
2985          opus_int32 value = va_arg(ap, opus_int32);
2986          if (value<0 || value>=st->mode->nbEBands)
2987             goto bad_arg;
2988          st->start = value;
2989       }
2990       break;
2991       case CELT_SET_END_BAND_REQUEST:
2992       {
2993          opus_int32 value = va_arg(ap, opus_int32);
2994          if (value<1 || value>st->mode->nbEBands)
2995             goto bad_arg;
2996          st->end = value;
2997       }
2998       break;
2999       case CELT_SET_CHANNELS_REQUEST:
3000       {
3001          opus_int32 value = va_arg(ap, opus_int32);
3002          if (value<1 || value>2)
3003             goto bad_arg;
3004          st->stream_channels = value;
3005       }
3006       break;
3007       case CELT_GET_AND_CLEAR_ERROR_REQUEST:
3008       {
3009          opus_int32 *value = va_arg(ap, opus_int32*);
3010          if (value==NULL)
3011             goto bad_arg;
3012          *value=st->error;
3013          st->error = 0;
3014       }
3015       break;
3016       case OPUS_GET_LOOKAHEAD_REQUEST:
3017       {
3018          opus_int32 *value = va_arg(ap, opus_int32*);
3019          if (value==NULL)
3020             goto bad_arg;
3021          *value = st->overlap/st->downsample;
3022       }
3023       break;
3024       case OPUS_RESET_STATE:
3025       {
3026          int i;
3027          opus_val16 *lpc, *oldBandE, *oldLogE, *oldLogE2;
3028          lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*st->channels);
3029          oldBandE = lpc+st->channels*LPC_ORDER;
3030          oldLogE = oldBandE + 2*st->mode->nbEBands;
3031          oldLogE2 = oldLogE + 2*st->mode->nbEBands;
3032          OPUS_CLEAR((char*)&st->DECODER_RESET_START,
3033                opus_custom_decoder_get_size(st->mode, st->channels)-
3034                ((char*)&st->DECODER_RESET_START - (char*)st));
3035          for (i=0;i<2*st->mode->nbEBands;i++)
3036             oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT);
3037       }
3038       break;
3039       case OPUS_GET_PITCH_REQUEST:
3040       {
3041          opus_int32 *value = va_arg(ap, opus_int32*);
3042          if (value==NULL)
3043             goto bad_arg;
3044          *value = st->postfilter_period;
3045       }
3046       break;
3047 #ifdef OPUS_BUILD
3048       case CELT_GET_MODE_REQUEST:
3049       {
3050          const CELTMode ** value = va_arg(ap, const CELTMode**);
3051          if (value==0)
3052             goto bad_arg;
3053          *value=st->mode;
3054       }
3055       break;
3056       case CELT_SET_SIGNALLING_REQUEST:
3057       {
3058          opus_int32 value = va_arg(ap, opus_int32);
3059          st->signalling = value;
3060       }
3061       break;
3062       case OPUS_GET_FINAL_RANGE_REQUEST:
3063       {
3064          opus_uint32 * value = va_arg(ap, opus_uint32 *);
3065          if (value==0)
3066             goto bad_arg;
3067          *value=st->rng;
3068       }
3069       break;
3070 #endif
3071       default:
3072          goto bad_request;
3073    }
3074    va_end(ap);
3075    return OPUS_OK;
3076 bad_arg:
3077    va_end(ap);
3078    return OPUS_BAD_ARG;
3079 bad_request:
3080       va_end(ap);
3081   return OPUS_UNIMPLEMENTED;
3082 }
3083
3084
3085
3086 const char *opus_strerror(int error)
3087 {
3088    static const char *error_strings[8] = {
3089       "success",
3090       "invalid argument",
3091       "buffer too small",
3092       "internal error",
3093       "corrupted stream",
3094       "request not implemented",
3095       "invalid state",
3096       "memory allocation failed"
3097    };
3098    if (error > 0 || error < -7)
3099       return "unknown error";
3100    else
3101       return error_strings[-error];
3102 }
3103
3104 const char *opus_get_version_string(void)
3105 {
3106     return "libopus " OPUS_VERSION
3107           "-exp_analysis"
3108 #ifdef FIXED_POINT
3109           "-fixed"
3110 #endif
3111 #ifdef FUZZING
3112           "-fuzzing"
3113 #endif
3114           ;
3115 }