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