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