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