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