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