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