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