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