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