Wrapping all allocation within opus_alloc() and opus_free()
[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 *)opus_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 *)opus_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    opus_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      int lm_diff = st->mode->maxLM - LM;
1386
1387      target = vbr_rate + (st->vbr_offset>>lm_diff) - ((40*C+20)<<BITRES);
1388
1389      /* Shortblocks get a large boost in bitrate, but since they
1390         are uncommon long blocks are not greatly affected */
1391      if (shortBlocks || tf_sum < -2*(st->end-st->start))
1392         target = 7*target/4;
1393      else if (tf_sum < -(st->end-st->start))
1394         target = 3*target/2;
1395      else if (M > 1)
1396         target-=(target+14)/28;
1397
1398      /* The current offset is removed from the target and the space used
1399         so far is added*/
1400      target=target+tell;
1401
1402      /* In VBR mode the frame size must not be reduced so much that it would
1403          result in the encoder running out of bits.
1404         The margin of 2 bytes ensures that none of the bust-prevention logic
1405          in the decoder will have triggered so far. */
1406      min_allowed = (tell+total_boost+(1<<BITRES+3)-1>>(BITRES+3)) + 2 - nbFilledBytes;
1407
1408      nbAvailableBytes = target+(1<<(BITRES+2))>>(BITRES+3);
1409      nbAvailableBytes = IMAX(min_allowed,nbAvailableBytes);
1410      nbAvailableBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes) - nbFilledBytes;
1411
1412      /* By how much did we "miss" the target on that frame */
1413      delta = target - vbr_rate;
1414
1415      target=nbAvailableBytes<<(BITRES+3);
1416
1417      /*If the frame is silent we don't adjust our drift, otherwise
1418        the encoder will shoot to very high rates after hitting a
1419        span of silence, but we do allow the bitres to refill.
1420        This means that we'll undershoot our target in CVBR/VBR modes
1421        on files with lots of silence. */
1422      if(silence)
1423      {
1424        nbAvailableBytes = 2;
1425        target = 2*8<<BITRES;
1426        delta = 0;
1427      }
1428
1429      if (st->vbr_count < 970)
1430      {
1431         st->vbr_count++;
1432         alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+20),16));
1433      } else
1434         alpha = QCONST16(.001f,15);
1435      /* How many bits have we used in excess of what we're allowed */
1436      if (st->constrained_vbr)
1437         st->vbr_reservoir += target - vbr_rate;
1438      /*printf ("%d\n", st->vbr_reservoir);*/
1439
1440      /* Compute the offset we need to apply in order to reach the target */
1441      st->vbr_drift += (opus_int32)MULT16_32_Q15(alpha,(delta<<lm_diff)-st->vbr_offset-st->vbr_drift);
1442      st->vbr_offset = -st->vbr_drift;
1443      /*printf ("%d\n", st->vbr_drift);*/
1444
1445      if (st->constrained_vbr && st->vbr_reservoir < 0)
1446      {
1447         /* We're under the min value -- increase rate */
1448         int adjust = (-st->vbr_reservoir)/(8<<BITRES);
1449         /* Unless we're just coding silence */
1450         nbAvailableBytes += silence?0:adjust;
1451         st->vbr_reservoir = 0;
1452         /*printf ("+%d\n", adjust);*/
1453      }
1454      nbCompressedBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes);
1455      /* This moves the raw bits to take into account the new compressed size */
1456      ec_enc_shrink(enc, nbCompressedBytes);
1457    }
1458    if (C==2)
1459    {
1460       int effectiveRate;
1461
1462       /* Always use MS for 2.5 ms frames until we can do a better analysis */
1463       if (LM!=0)
1464          dual_stereo = stereo_analysis(st->mode, X, LM, N);
1465
1466       /* Account for coarse energy */
1467       effectiveRate = (8*effectiveBytes - 80)>>LM;
1468
1469       /* effectiveRate in kb/s */
1470       effectiveRate = 2*effectiveRate/5;
1471       if (effectiveRate<35)
1472          intensity = 8;
1473       else if (effectiveRate<50)
1474          intensity = 12;
1475       else if (effectiveRate<68)
1476          intensity = 16;
1477       else if (effectiveRate<84)
1478          intensity = 18;
1479       else if (effectiveRate<102)
1480          intensity = 19;
1481       else if (effectiveRate<130)
1482          intensity = 20;
1483       else
1484          intensity = 100;
1485       intensity = IMIN(st->end,IMAX(st->start, intensity));
1486    }
1487
1488    /* Bit allocation */
1489    ALLOC(fine_quant, st->mode->nbEBands, int);
1490    ALLOC(pulses, st->mode->nbEBands, int);
1491    ALLOC(fine_priority, st->mode->nbEBands, int);
1492
1493    /* bits =           packet size                    - where we are - safety*/
1494    bits = ((opus_int32)nbCompressedBytes*8<<BITRES) - ec_tell_frac(enc) - 1;
1495    anti_collapse_rsv = isTransient&&LM>=2&&bits>=(LM+2<<BITRES) ? (1<<BITRES) : 0;
1496    bits -= anti_collapse_rsv;
1497    codedBands = compute_allocation(st->mode, st->start, st->end, offsets, cap,
1498          alloc_trim, &intensity, &dual_stereo, bits, &balance, pulses,
1499          fine_quant, fine_priority, C, LM, enc, 1, st->lastCodedBands);
1500    st->lastCodedBands = codedBands;
1501
1502    quant_fine_energy(st->mode, st->start, st->end, oldBandE, error, fine_quant, enc, C);
1503
1504 #ifdef MEASURE_NORM_MSE
1505    float X0[3000];
1506    float bandE0[60];
1507    c=0; do
1508       for (i=0;i<N;i++)
1509          X0[i+c*N] = X[i+c*N];
1510    while (++c<C);
1511    for (i=0;i<C*st->mode->nbEBands;i++)
1512       bandE0[i] = bandE[i];
1513 #endif
1514
1515    /* Residual quantisation */
1516    ALLOC(collapse_masks, C*st->mode->nbEBands, unsigned char);
1517    quant_all_bands(1, st->mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
1518          bandE, pulses, shortBlocks, st->spread_decision, dual_stereo, intensity, tf_res,
1519          nbCompressedBytes*(8<<BITRES)-anti_collapse_rsv, balance, enc, LM, codedBands, &st->rng);
1520
1521    if (anti_collapse_rsv > 0)
1522    {
1523       anti_collapse_on = st->consec_transient<2;
1524 #ifdef FUZZING
1525       anti_collapse_on = rand()&0x1;
1526 #endif
1527       ec_enc_bits(enc, anti_collapse_on, 1);
1528    }
1529    quant_energy_finalise(st->mode, st->start, st->end, oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_tell(enc), enc, C);
1530
1531    if (silence)
1532    {
1533       for (i=0;i<C*st->mode->nbEBands;i++)
1534          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
1535    }
1536
1537 #ifdef RESYNTH
1538    /* Re-synthesis of the coded audio if required */
1539    {
1540       celt_sig *out_mem[2];
1541       celt_sig *overlap_mem[2];
1542
1543       log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
1544       if (silence)
1545       {
1546          for (i=0;i<C*st->mode->nbEBands;i++)
1547             bandE[i] = 0;
1548       }
1549
1550 #ifdef MEASURE_NORM_MSE
1551       measure_norm_mse(st->mode, X, X0, bandE, bandE0, M, N, C);
1552 #endif
1553       if (anti_collapse_on)
1554       {
1555          anti_collapse(st->mode, X, collapse_masks, LM, C, CC, N,
1556                st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
1557       }
1558
1559       /* Synthesis */
1560       denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
1561
1562       CELT_MOVE(st->syn_mem[0], st->syn_mem[0]+N, MAX_PERIOD);
1563       if (CC==2)
1564          CELT_MOVE(st->syn_mem[1], st->syn_mem[1]+N, MAX_PERIOD);
1565
1566       c=0; do
1567          for (i=0;i<M*st->mode->eBands[st->start];i++)
1568             freq[c*N+i] = 0;
1569       while (++c<C);
1570       c=0; do
1571          for (i=M*st->mode->eBands[st->end];i<N;i++)
1572             freq[c*N+i] = 0;
1573       while (++c<C);
1574
1575       if (CC==2&&C==1)
1576       {
1577          for (i=0;i<N;i++)
1578             freq[N+i] = freq[i];
1579       }
1580
1581       out_mem[0] = st->syn_mem[0]+MAX_PERIOD;
1582       if (CC==2)
1583          out_mem[1] = st->syn_mem[1]+MAX_PERIOD;
1584
1585       overlap_mem[0] = prefilter_mem+CC*COMBFILTER_MAXPERIOD;
1586       if (CC==2)
1587          overlap_mem[1] = overlap_mem[0] + st->overlap;
1588
1589       compute_inv_mdcts(st->mode, shortBlocks, freq, out_mem, overlap_mem, CC, LM);
1590
1591       c=0; do {
1592          st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
1593          st->prefilter_period_old=IMAX(st->prefilter_period_old, COMBFILTER_MINPERIOD);
1594          comb_filter(out_mem[c], out_mem[c], st->prefilter_period_old, st->prefilter_period, st->mode->shortMdctSize,
1595                st->prefilter_gain_old, st->prefilter_gain, st->prefilter_tapset_old, st->prefilter_tapset,
1596                st->mode->window, st->overlap);
1597          if (LM!=0)
1598             comb_filter(out_mem[c]+st->mode->shortMdctSize, out_mem[c]+st->mode->shortMdctSize, st->prefilter_period, pitch_index, N-st->mode->shortMdctSize,
1599                   st->prefilter_gain, gain1, st->prefilter_tapset, prefilter_tapset,
1600                   st->mode->window, st->mode->overlap);
1601       } while (++c<CC);
1602
1603       deemphasis(out_mem, (opus_val16*)pcm, N, CC, st->upsample, st->mode->preemph, st->preemph_memD);
1604       st->prefilter_period_old = st->prefilter_period;
1605       st->prefilter_gain_old = st->prefilter_gain;
1606       st->prefilter_tapset_old = st->prefilter_tapset;
1607    }
1608 #endif
1609
1610    st->prefilter_period = pitch_index;
1611    st->prefilter_gain = gain1;
1612    st->prefilter_tapset = prefilter_tapset;
1613 #ifdef RESYNTH
1614    if (LM!=0)
1615    {
1616       st->prefilter_period_old = st->prefilter_period;
1617       st->prefilter_gain_old = st->prefilter_gain;
1618       st->prefilter_tapset_old = st->prefilter_tapset;
1619    }
1620 #endif
1621
1622    if (CC==2&&C==1) {
1623       for (i=0;i<st->mode->nbEBands;i++)
1624          oldBandE[st->mode->nbEBands+i]=oldBandE[i];
1625    }
1626
1627    /* In case start or end were to change */
1628    c=0; do
1629    {
1630       for (i=0;i<st->start;i++)
1631          oldBandE[c*st->mode->nbEBands+i]=0;
1632       for (i=st->end;i<st->mode->nbEBands;i++)
1633          oldBandE[c*st->mode->nbEBands+i]=0;
1634    } while (++c<CC);
1635    if (!isTransient)
1636    {
1637       for (i=0;i<CC*st->mode->nbEBands;i++)
1638          oldLogE2[i] = oldLogE[i];
1639       for (i=0;i<CC*st->mode->nbEBands;i++)
1640          oldLogE[i] = oldBandE[i];
1641    } else {
1642       for (i=0;i<CC*st->mode->nbEBands;i++)
1643          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
1644    }
1645    if (isTransient)
1646       st->consec_transient++;
1647    else
1648       st->consec_transient=0;
1649    st->rng = enc->rng;
1650
1651    /* If there's any room left (can only happen for very high rates),
1652       it's already filled with zeros */
1653    ec_enc_done(enc);
1654
1655    if (st->signalling)
1656       nbCompressedBytes++;
1657
1658    RESTORE_STACK;
1659    if (ec_get_error(enc))
1660       return CELT_INTERNAL_ERROR;
1661    else
1662       return nbCompressedBytes;
1663 }
1664
1665
1666
1667 #ifdef FIXED_POINT
1668 int celt_encode(CELTEncoder * restrict st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1669 {
1670    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1671 }
1672
1673 #ifndef DISABLE_FLOAT_API
1674 int celt_encode_float(CELTEncoder * restrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1675 {
1676    int j, ret, C, N;
1677    VARDECL(opus_int16, in);
1678    ALLOC_STACK;
1679
1680    if (pcm==NULL)
1681       return CELT_BAD_ARG;
1682
1683    C = CHANNELS(st->channels);
1684    N = frame_size;
1685    ALLOC(in, C*N, opus_int16);
1686
1687    for (j=0;j<C*N;j++)
1688      in[j] = FLOAT2INT16(pcm[j]);
1689
1690    ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
1691 #ifdef RESYNTH
1692    for (j=0;j<C*N;j++)
1693       ((float*)pcm)[j]=in[j]*(1.f/32768.f);
1694 #endif
1695    RESTORE_STACK;
1696    return ret;
1697 }
1698 #endif /* DISABLE_FLOAT_API */
1699 #else
1700
1701 int celt_encode(CELTEncoder * restrict st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1702 {
1703    int j, ret, C, N;
1704    VARDECL(celt_sig, in);
1705    ALLOC_STACK;
1706
1707    if (pcm==NULL)
1708       return CELT_BAD_ARG;
1709
1710    C=CHANNELS(st->channels);
1711    N=frame_size;
1712    ALLOC(in, C*N, celt_sig);
1713    for (j=0;j<C*N;j++) {
1714      in[j] = SCALEOUT(pcm[j]);
1715    }
1716
1717    ret = celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
1718 #ifdef RESYNTH
1719    for (j=0;j<C*N;j++)
1720       ((opus_int16*)pcm)[j] = FLOAT2INT16(in[j]);
1721 #endif
1722    RESTORE_STACK;
1723    return ret;
1724 }
1725
1726 int celt_encode_float(CELTEncoder * restrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1727 {
1728    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1729 }
1730
1731
1732 #endif
1733 int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
1734 {
1735    va_list ap;
1736
1737    va_start(ap, request);
1738    switch (request)
1739    {
1740       case CELT_SET_COMPLEXITY_REQUEST:
1741       {
1742          int value = va_arg(ap, opus_int32);
1743          if (value<0 || value>10)
1744             goto bad_arg;
1745          st->complexity = value;
1746       }
1747       break;
1748       case CELT_SET_START_BAND_REQUEST:
1749       {
1750          opus_int32 value = va_arg(ap, opus_int32);
1751          if (value<0 || value>=st->mode->nbEBands)
1752             goto bad_arg;
1753          st->start = value;
1754       }
1755       break;
1756       case CELT_SET_END_BAND_REQUEST:
1757       {
1758          opus_int32 value = va_arg(ap, opus_int32);
1759          if (value<1 || value>st->mode->nbEBands)
1760             goto bad_arg;
1761          st->end = value;
1762       }
1763       break;
1764       case CELT_SET_PREDICTION_REQUEST:
1765       {
1766          int value = va_arg(ap, opus_int32);
1767          if (value<0 || value>2)
1768             goto bad_arg;
1769          st->disable_pf = value<=1;
1770          st->force_intra = value==0;
1771       }
1772       break;
1773       case CELT_SET_LOSS_PERC_REQUEST:
1774       {
1775          int value = va_arg(ap, opus_int32);
1776          if (value<0 || value>100)
1777             goto bad_arg;
1778          st->loss_rate = value;
1779       }
1780       break;
1781       case CELT_SET_VBR_CONSTRAINT_REQUEST:
1782       {
1783          opus_int32 value = va_arg(ap, opus_int32);
1784          st->constrained_vbr = value;
1785       }
1786       break;
1787       case CELT_SET_VBR_REQUEST:
1788       {
1789          opus_int32 value = va_arg(ap, opus_int32);
1790          st->vbr = value;
1791       }
1792       break;
1793       case CELT_SET_BITRATE_REQUEST:
1794       {
1795          opus_int32 value = va_arg(ap, opus_int32);
1796          if (value<=500 && value!=-1)
1797             goto bad_arg;
1798          value = IMIN(value, 260000*st->channels);
1799          st->bitrate = value;
1800       }
1801       break;
1802       case CELT_SET_CHANNELS_REQUEST:
1803       {
1804          opus_int32 value = va_arg(ap, opus_int32);
1805          if (value<1 || value>2)
1806             goto bad_arg;
1807          st->stream_channels = value;
1808       }
1809       break;
1810       case CELT_RESET_STATE:
1811       {
1812          CELT_MEMSET((char*)&st->ENCODER_RESET_START, 0,
1813                celt_encoder_get_size_custom(st->mode, st->channels)-
1814                ((char*)&st->ENCODER_RESET_START - (char*)st));
1815          st->vbr_offset = 0;
1816          st->delayedIntra = 1;
1817          st->spread_decision = SPREAD_NORMAL;
1818          st->tonal_average = QCONST16(1.f,8);
1819       }
1820       break;
1821       case CELT_SET_INPUT_CLIPPING_REQUEST:
1822       {
1823          opus_int32 value = va_arg(ap, opus_int32);
1824          st->clip = value;
1825       }
1826       break;
1827 #ifdef OPUS_BUILD
1828       case CELT_SET_SIGNALLING_REQUEST:
1829       {
1830          opus_int32 value = va_arg(ap, opus_int32);
1831          st->signalling = value;
1832       }
1833       break;
1834       case CELT_GET_MODE_REQUEST:
1835       {
1836          const CELTMode ** value = va_arg(ap, const CELTMode**);
1837          if (value==0)
1838             goto bad_arg;
1839          *value=st->mode;
1840       }
1841       break;
1842       case CELT_GET_RANGE_REQUEST:
1843       {
1844          opus_uint32 * value = va_arg(ap, opus_uint32 *);
1845          if (value==0)
1846             goto bad_arg;
1847          *value=st->rng;
1848       }
1849       break;
1850 #endif
1851       default:
1852          goto bad_request;
1853    }
1854    va_end(ap);
1855    return CELT_OK;
1856 bad_arg:
1857    va_end(ap);
1858    return CELT_BAD_ARG;
1859 bad_request:
1860    va_end(ap);
1861    return CELT_UNIMPLEMENTED;
1862 }
1863
1864 /**********************************************************************/
1865 /*                                                                    */
1866 /*                             DECODER                                */
1867 /*                                                                    */
1868 /**********************************************************************/
1869 #define DECODE_BUFFER_SIZE 2048
1870
1871 /** Decoder state
1872  @brief Decoder state
1873  */
1874 struct CELTDecoder {
1875    const CELTMode *mode;
1876    int overlap;
1877    int channels;
1878    int stream_channels;
1879
1880    int downsample;
1881    int start, end;
1882    int signalling;
1883
1884    /* Everything beyond this point gets cleared on a reset */
1885 #define DECODER_RESET_START rng
1886
1887    opus_uint32 rng;
1888    int error;
1889    int last_pitch_index;
1890    int loss_count;
1891    int postfilter_period;
1892    int postfilter_period_old;
1893    opus_val16 postfilter_gain;
1894    opus_val16 postfilter_gain_old;
1895    int postfilter_tapset;
1896    int postfilter_tapset_old;
1897
1898    celt_sig preemph_memD[2];
1899
1900    celt_sig _decode_mem[1]; /* Size = channels*(DECODE_BUFFER_SIZE+mode->overlap) */
1901    /* opus_val16 lpc[],  Size = channels*LPC_ORDER */
1902    /* opus_val16 oldEBands[], Size = 2*mode->nbEBands */
1903    /* opus_val16 oldLogE[], Size = 2*mode->nbEBands */
1904    /* opus_val16 oldLogE2[], Size = 2*mode->nbEBands */
1905    /* opus_val16 backgroundLogE[], Size = 2*mode->nbEBands */
1906 };
1907
1908 int celt_decoder_get_size(int channels)
1909 {
1910    const CELTMode *mode = celt_mode_create(48000, 960, NULL);
1911    return celt_decoder_get_size_custom(mode, channels);
1912 }
1913
1914 int celt_decoder_get_size_custom(const CELTMode *mode, int channels)
1915 {
1916    int size = sizeof(struct CELTDecoder)
1917             + (channels*(DECODE_BUFFER_SIZE+mode->overlap)-1)*sizeof(celt_sig)
1918             + channels*LPC_ORDER*sizeof(opus_val16)
1919             + 4*2*mode->nbEBands*sizeof(opus_val16);
1920    return size;
1921 }
1922
1923 CELTDecoder *celt_decoder_create(int sampling_rate, int channels, int *error)
1924 {
1925    CELTDecoder *st;
1926    st = (CELTDecoder *)opus_alloc(celt_decoder_get_size(channels));
1927    if (st!=NULL && celt_decoder_init(st, sampling_rate, channels, error)==NULL)
1928    {
1929       celt_decoder_destroy(st);
1930       st = NULL;
1931    }
1932    return st;
1933 }
1934
1935 CELTDecoder *celt_decoder_create_custom(const CELTMode *mode, int channels, int *error)
1936 {
1937    CELTDecoder *st = (CELTDecoder *)opus_alloc(celt_decoder_get_size_custom(mode, channels));
1938    if (st!=NULL && celt_decoder_init_custom(st, mode, channels, error)==NULL)
1939    {
1940       celt_decoder_destroy(st);
1941       st = NULL;
1942    }
1943    return st;
1944 }
1945
1946 CELTDecoder *celt_decoder_init(CELTDecoder *st, int sampling_rate, int channels, int *error)
1947 {
1948    celt_decoder_init_custom(st, celt_mode_create(48000, 960, NULL), channels, error);
1949    st->downsample = resampling_factor(sampling_rate);
1950    if (st->downsample==0)
1951    {
1952       if (error)
1953          *error = CELT_BAD_ARG;
1954       return NULL;
1955    }
1956    return st;
1957 }
1958
1959 CELTDecoder *celt_decoder_init_custom(CELTDecoder *st, const CELTMode *mode, int channels, int *error)
1960 {
1961    if (channels < 0 || channels > 2)
1962    {
1963       if (error)
1964          *error = CELT_BAD_ARG;
1965       return NULL;
1966    }
1967
1968    if (st==NULL)
1969    {
1970       if (error)
1971          *error = CELT_ALLOC_FAIL;
1972       return NULL;
1973    }
1974
1975    CELT_MEMSET((char*)st, 0, celt_decoder_get_size_custom(mode, channels));
1976
1977    st->mode = mode;
1978    st->overlap = mode->overlap;
1979    st->stream_channels = st->channels = channels;
1980
1981    st->downsample = 1;
1982    st->start = 0;
1983    st->end = st->mode->effEBands;
1984    st->signalling = 1;
1985
1986    st->loss_count = 0;
1987
1988    if (error)
1989       *error = CELT_OK;
1990    return st;
1991 }
1992
1993 void celt_decoder_destroy(CELTDecoder *st)
1994 {
1995    opus_free(st);
1996 }
1997
1998 static void celt_decode_lost(CELTDecoder * restrict st, opus_val16 * restrict pcm, int N, int LM)
1999 {
2000    int c;
2001    int pitch_index;
2002    int overlap = st->mode->overlap;
2003    opus_val16 fade = Q15ONE;
2004    int i, len;
2005    const int C = CHANNELS(st->channels);
2006    int offset;
2007    celt_sig *out_mem[2];
2008    celt_sig *decode_mem[2];
2009    celt_sig *overlap_mem[2];
2010    opus_val16 *lpc;
2011    opus_val32 *out_syn[2];
2012    opus_val16 *oldBandE, *oldLogE2, *backgroundLogE;
2013    int plc=1;
2014    SAVE_STACK;
2015
2016    c=0; do {
2017       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
2018       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
2019       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
2020    } while (++c<C);
2021    lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*C);
2022    oldBandE = lpc+C*LPC_ORDER;
2023    oldLogE2 = oldBandE + C*st->mode->nbEBands;
2024    backgroundLogE = oldLogE2  + C*st->mode->nbEBands;
2025
2026    out_syn[0] = out_mem[0]+MAX_PERIOD-N;
2027    if (C==2)
2028       out_syn[1] = out_mem[1]+MAX_PERIOD-N;
2029
2030    len = N+st->mode->overlap;
2031
2032    if (st->loss_count >= 5)
2033    {
2034       VARDECL(celt_sig, freq);
2035       VARDECL(celt_norm, X);
2036       VARDECL(celt_ener, bandE);
2037       opus_uint32 seed;
2038       int effEnd;
2039
2040       effEnd = st->end;
2041       if (effEnd > st->mode->effEBands)
2042          effEnd = st->mode->effEBands;
2043
2044       ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
2045       ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
2046       ALLOC(bandE, st->mode->nbEBands*C, celt_ener);
2047
2048       log2Amp(st->mode, st->start, st->end, bandE, backgroundLogE, C);
2049
2050       seed = st->rng;
2051       for (c=0;c<C;c++)
2052       {
2053          for (i=0;i<(st->mode->eBands[st->start]<<LM);i++)
2054             X[c*N+i] = 0;
2055          for (i=0;i<st->mode->effEBands;i++)
2056          {
2057             int j;
2058             int boffs;
2059             int blen;
2060             boffs = N*c+(st->mode->eBands[i]<<LM);
2061             blen = (st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
2062             for (j=0;j<blen;j++)
2063             {
2064                seed = lcg_rand(seed);
2065                X[boffs+j] = (opus_int32)(seed)>>20;
2066             }
2067             renormalise_vector(X+boffs, blen, Q15ONE);
2068          }
2069          for (i=(st->mode->eBands[st->end]<<LM);i<N;i++)
2070             X[c*N+i] = 0;
2071       }
2072       st->rng = seed;
2073
2074       denormalise_bands(st->mode, X, freq, bandE, st->mode->effEBands, C, 1<<LM);
2075
2076       c=0; do
2077          for (i=0;i<st->mode->eBands[st->start]<<LM;i++)
2078             freq[c*N+i] = 0;
2079       while (++c<C);
2080       c=0; do {
2081          int bound = st->mode->eBands[effEnd]<<LM;
2082          if (st->downsample!=1)
2083             bound = IMIN(bound, N/st->downsample);
2084          for (i=bound;i<N;i++)
2085             freq[c*N+i] = 0;
2086       } while (++c<C);
2087       compute_inv_mdcts(st->mode, 0, freq, out_syn, overlap_mem, C, LM);
2088       plc = 0;
2089    } else if (st->loss_count == 0)
2090    {
2091       opus_val16 pitch_buf[DECODE_BUFFER_SIZE>>1];
2092       /* Corresponds to a min pitch of 67 Hz. It's possible to save CPU in this
2093          search by using only part of the decode buffer */
2094       int poffset = 720;
2095       pitch_downsample(decode_mem, pitch_buf, DECODE_BUFFER_SIZE, C);
2096       /* Max pitch is 100 samples (480 Hz) */
2097       pitch_search(pitch_buf+((poffset)>>1), pitch_buf, DECODE_BUFFER_SIZE-poffset,
2098             poffset-100, &pitch_index);
2099       pitch_index = poffset-pitch_index;
2100       st->last_pitch_index = pitch_index;
2101    } else {
2102       pitch_index = st->last_pitch_index;
2103       fade = QCONST16(.8f,15);
2104    }
2105
2106    if (plc)
2107    {
2108       c=0; do {
2109          VARDECL(opus_val32, e);
2110          opus_val16 exc[MAX_PERIOD];
2111          opus_val32 ac[LPC_ORDER+1];
2112          opus_val16 decay = 1;
2113          opus_val32 S1=0;
2114          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};
2115
2116          ALLOC(e, MAX_PERIOD+2*st->mode->overlap, opus_val32);
2117
2118          offset = MAX_PERIOD-pitch_index;
2119          for (i=0;i<MAX_PERIOD;i++)
2120             exc[i] = ROUND16(out_mem[c][i], SIG_SHIFT);
2121
2122          if (st->loss_count == 0)
2123          {
2124             _celt_autocorr(exc, ac, st->mode->window, st->mode->overlap,
2125                   LPC_ORDER, MAX_PERIOD);
2126
2127             /* Noise floor -40 dB */
2128 #ifdef FIXED_POINT
2129             ac[0] += SHR32(ac[0],13);
2130 #else
2131             ac[0] *= 1.0001f;
2132 #endif
2133             /* Lag windowing */
2134             for (i=1;i<=LPC_ORDER;i++)
2135             {
2136                /*ac[i] *= exp(-.5*(2*M_PI*.002*i)*(2*M_PI*.002*i));*/
2137 #ifdef FIXED_POINT
2138                ac[i] -= MULT16_32_Q15(2*i*i, ac[i]);
2139 #else
2140                ac[i] -= ac[i]*(.008f*i)*(.008f*i);
2141 #endif
2142             }
2143
2144             _celt_lpc(lpc+c*LPC_ORDER, ac, LPC_ORDER);
2145          }
2146          for (i=0;i<LPC_ORDER;i++)
2147             mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT);
2148          fir(exc, lpc+c*LPC_ORDER, exc, MAX_PERIOD, LPC_ORDER, mem);
2149          /*for (i=0;i<MAX_PERIOD;i++)printf("%d ", exc[i]); printf("\n");*/
2150          /* Check if the waveform is decaying (and if so how fast) */
2151          {
2152             opus_val32 E1=1, E2=1;
2153             int period;
2154             if (pitch_index <= MAX_PERIOD/2)
2155                period = pitch_index;
2156             else
2157                period = MAX_PERIOD/2;
2158             for (i=0;i<period;i++)
2159             {
2160                E1 += SHR32(MULT16_16(exc[MAX_PERIOD-period+i],exc[MAX_PERIOD-period+i]),8);
2161                E2 += SHR32(MULT16_16(exc[MAX_PERIOD-2*period+i],exc[MAX_PERIOD-2*period+i]),8);
2162             }
2163             if (E1 > E2)
2164                E1 = E2;
2165             decay = celt_sqrt(frac_div32(SHR(E1,1),E2));
2166          }
2167
2168          /* Copy excitation, taking decay into account */
2169          for (i=0;i<len+st->mode->overlap;i++)
2170          {
2171             opus_val16 tmp;
2172             if (offset+i >= MAX_PERIOD)
2173             {
2174                offset -= pitch_index;
2175                decay = MULT16_16_Q15(decay, decay);
2176             }
2177             e[i] = SHL32(EXTEND32(MULT16_16_Q15(decay, exc[offset+i])), SIG_SHIFT);
2178             tmp = ROUND16(out_mem[c][offset+i],SIG_SHIFT);
2179             S1 += SHR32(MULT16_16(tmp,tmp),8);
2180          }
2181          for (i=0;i<LPC_ORDER;i++)
2182             mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT);
2183          for (i=0;i<len+st->mode->overlap;i++)
2184             e[i] = MULT16_32_Q15(fade, e[i]);
2185          iir(e, lpc+c*LPC_ORDER, e, len+st->mode->overlap, LPC_ORDER, mem);
2186
2187          {
2188             opus_val32 S2=0;
2189             for (i=0;i<len+overlap;i++)
2190             {
2191                opus_val16 tmp = ROUND16(e[i],SIG_SHIFT);
2192                S2 += SHR32(MULT16_16(tmp,tmp),8);
2193             }
2194             /* This checks for an "explosion" in the synthesis */
2195 #ifdef FIXED_POINT
2196             if (!(S1 > SHR32(S2,2)))
2197 #else
2198                /* Float test is written this way to catch NaNs at the same time */
2199                if (!(S1 > 0.2f*S2))
2200 #endif
2201                {
2202                   for (i=0;i<len+overlap;i++)
2203                      e[i] = 0;
2204                } else if (S1 < S2)
2205                {
2206                   opus_val16 ratio = celt_sqrt(frac_div32(SHR32(S1,1)+1,S2+1));
2207                   for (i=0;i<len+overlap;i++)
2208                      e[i] = MULT16_32_Q15(ratio, e[i]);
2209                }
2210          }
2211
2212          /* Apply post-filter to the MDCT overlap of the previous frame */
2213          comb_filter(out_mem[c]+MAX_PERIOD, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap,
2214                st->postfilter_gain, st->postfilter_gain, st->postfilter_tapset, st->postfilter_tapset,
2215                NULL, 0);
2216
2217          for (i=0;i<MAX_PERIOD+st->mode->overlap-N;i++)
2218             out_mem[c][i] = out_mem[c][N+i];
2219
2220          /* Apply TDAC to the concealed audio so that it blends with the
2221          previous and next frames */
2222          for (i=0;i<overlap/2;i++)
2223          {
2224             opus_val32 tmp;
2225             tmp = MULT16_32_Q15(st->mode->window[i],           e[N+overlap-1-i]) +
2226                   MULT16_32_Q15(st->mode->window[overlap-i-1], e[N+i          ]);
2227             out_mem[c][MAX_PERIOD+i] = MULT16_32_Q15(st->mode->window[overlap-i-1], tmp);
2228             out_mem[c][MAX_PERIOD+overlap-i-1] = MULT16_32_Q15(st->mode->window[i], tmp);
2229          }
2230          for (i=0;i<N;i++)
2231             out_mem[c][MAX_PERIOD-N+i] = e[i];
2232
2233          /* Apply pre-filter to the MDCT overlap for the next frame (post-filter will be applied then) */
2234          comb_filter(e, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap,
2235                -st->postfilter_gain, -st->postfilter_gain, st->postfilter_tapset, st->postfilter_tapset,
2236                NULL, 0);
2237          for (i=0;i<overlap;i++)
2238             out_mem[c][MAX_PERIOD+i] = e[i];
2239       } while (++c<C);
2240    }
2241
2242    deemphasis(out_syn, pcm, N, C, st->downsample, st->mode->preemph, st->preemph_memD);
2243
2244    st->loss_count++;
2245
2246    RESTORE_STACK;
2247 }
2248
2249 CELT_STATIC
2250 int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, int len, opus_val16 * restrict pcm, int frame_size, ec_dec *dec)
2251 {
2252    int c, i, N;
2253    int spread_decision;
2254    opus_int32 bits;
2255    ec_dec _dec;
2256    VARDECL(celt_sig, freq);
2257    VARDECL(celt_norm, X);
2258    VARDECL(celt_ener, bandE);
2259    VARDECL(int, fine_quant);
2260    VARDECL(int, pulses);
2261    VARDECL(int, cap);
2262    VARDECL(int, offsets);
2263    VARDECL(int, fine_priority);
2264    VARDECL(int, tf_res);
2265    VARDECL(unsigned char, collapse_masks);
2266    celt_sig *out_mem[2];
2267    celt_sig *decode_mem[2];
2268    celt_sig *overlap_mem[2];
2269    celt_sig *out_syn[2];
2270    opus_val16 *lpc;
2271    opus_val16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE;
2272
2273    int shortBlocks;
2274    int isTransient;
2275    int intra_ener;
2276    const int CC = CHANNELS(st->channels);
2277    int LM, M;
2278    int effEnd;
2279    int codedBands;
2280    int alloc_trim;
2281    int postfilter_pitch;
2282    opus_val16 postfilter_gain;
2283    int intensity=0;
2284    int dual_stereo=0;
2285    opus_int32 total_bits;
2286    opus_int32 balance;
2287    opus_int32 tell;
2288    int dynalloc_logp;
2289    int postfilter_tapset;
2290    int anti_collapse_rsv;
2291    int anti_collapse_on=0;
2292    int silence;
2293    int C = CHANNELS(st->stream_channels);
2294    ALLOC_STACK;
2295
2296    frame_size *= st->downsample;
2297
2298    c=0; do {
2299       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
2300       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
2301       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
2302    } while (++c<CC);
2303    lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*CC);
2304    oldBandE = lpc+LPC_ORDER;
2305    oldLogE = oldBandE + 2*st->mode->nbEBands;
2306    oldLogE2 = oldLogE + 2*st->mode->nbEBands;
2307    backgroundLogE = oldLogE2  + 2*st->mode->nbEBands;
2308
2309    if (st->signalling && data!=NULL)
2310    {
2311       int data0=data[0];
2312       /* Convert "standard mode" to Opus header */
2313       if (st->mode->Fs==48000 && st->mode->shortMdctSize==120)
2314       {
2315          data0 = fromOpus(data0);
2316          if (data0<0)
2317             return CELT_CORRUPTED_DATA;
2318       }
2319       st->end = IMAX(1, st->mode->effEBands-2*(data0>>5));
2320       LM = (data0>>3)&0x3;
2321       C = 1 + ((data0>>2)&0x1);
2322       data++;
2323       len--;
2324       if (LM>st->mode->maxLM)
2325          return CELT_CORRUPTED_DATA;
2326       if (frame_size < st->mode->shortMdctSize<<LM)
2327          return CELT_BUFFER_TOO_SMALL;
2328       else
2329          frame_size = st->mode->shortMdctSize<<LM;
2330    } else {
2331       for (LM=0;LM<=st->mode->maxLM;LM++)
2332          if (st->mode->shortMdctSize<<LM==frame_size)
2333             break;
2334       if (LM>st->mode->maxLM)
2335          return CELT_BAD_ARG;
2336    }
2337    M=1<<LM;
2338
2339    if (len<0 || len>1275 || pcm==NULL)
2340       return CELT_BAD_ARG;
2341
2342    N = M*st->mode->shortMdctSize;
2343
2344    effEnd = st->end;
2345    if (effEnd > st->mode->effEBands)
2346       effEnd = st->mode->effEBands;
2347
2348    ALLOC(freq, IMAX(CC,C)*N, celt_sig); /**< Interleaved signal MDCTs */
2349    ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
2350    ALLOC(bandE, st->mode->nbEBands*C, celt_ener);
2351    c=0; do
2352       for (i=0;i<M*st->mode->eBands[st->start];i++)
2353          X[c*N+i] = 0;
2354    while (++c<C);
2355    c=0; do
2356       for (i=M*st->mode->eBands[effEnd];i<N;i++)
2357          X[c*N+i] = 0;
2358    while (++c<C);
2359
2360    if (data == NULL || len<=1)
2361    {
2362       celt_decode_lost(st, pcm, N, LM);
2363       RESTORE_STACK;
2364       return frame_size/st->downsample;
2365    }
2366
2367    if (dec == NULL)
2368    {
2369       ec_dec_init(&_dec,(unsigned char*)data,len);
2370       dec = &_dec;
2371    }
2372
2373    if (C<CC)
2374    {
2375       for (i=0;i<st->mode->nbEBands;i++)
2376          oldBandE[i]=MAX16(oldBandE[i],oldBandE[st->mode->nbEBands+i]);
2377    }
2378
2379    total_bits = len*8;
2380    tell = ec_tell(dec);
2381
2382    if (tell >= total_bits)
2383            silence = 1;
2384    else if (tell==1)
2385       silence = ec_dec_bit_logp(dec, 15);
2386    else
2387       silence = 0;
2388    if (silence)
2389    {
2390       /* Pretend we've read all the remaining bits */
2391       tell = len*8;
2392       dec->nbits_total+=tell-ec_tell(dec);
2393    }
2394
2395    postfilter_gain = 0;
2396    postfilter_pitch = 0;
2397    postfilter_tapset = 0;
2398    if (st->start==0 && tell+16 <= total_bits)
2399    {
2400       if(ec_dec_bit_logp(dec, 1))
2401       {
2402          int qg, octave;
2403          octave = ec_dec_uint(dec, 6);
2404          postfilter_pitch = (16<<octave)+ec_dec_bits(dec, 4+octave)-1;
2405          qg = ec_dec_bits(dec, 3);
2406          if (ec_tell(dec)+2<=total_bits)
2407             postfilter_tapset = ec_dec_icdf(dec, tapset_icdf, 2);
2408          postfilter_gain = QCONST16(.09375f,15)*(qg+1);
2409       }
2410       tell = ec_tell(dec);
2411    }
2412
2413    if (LM > 0 && tell+3 <= total_bits)
2414    {
2415       isTransient = ec_dec_bit_logp(dec, 3);
2416       tell = ec_tell(dec);
2417    }
2418    else
2419       isTransient = 0;
2420
2421    if (isTransient)
2422       shortBlocks = M;
2423    else
2424       shortBlocks = 0;
2425
2426    /* Decode the global flags (first symbols in the stream) */
2427    intra_ener = tell+3<=total_bits ? ec_dec_bit_logp(dec, 3) : 0;
2428    /* Get band energies */
2429    unquant_coarse_energy(st->mode, st->start, st->end, oldBandE,
2430          intra_ener, dec, C, LM);
2431
2432    ALLOC(tf_res, st->mode->nbEBands, int);
2433    tf_decode(st->start, st->end, isTransient, tf_res, LM, dec);
2434
2435    tell = ec_tell(dec);
2436    spread_decision = SPREAD_NORMAL;
2437    if (tell+4 <= total_bits)
2438       spread_decision = ec_dec_icdf(dec, spread_icdf, 5);
2439
2440    ALLOC(pulses, st->mode->nbEBands, int);
2441    ALLOC(cap, st->mode->nbEBands, int);
2442    ALLOC(offsets, st->mode->nbEBands, int);
2443    ALLOC(fine_priority, st->mode->nbEBands, int);
2444
2445    init_caps(st->mode,cap,LM,C);
2446
2447    dynalloc_logp = 6;
2448    total_bits<<=BITRES;
2449    tell = ec_tell_frac(dec);
2450    for (i=st->start;i<st->end;i++)
2451    {
2452       int width, quanta;
2453       int dynalloc_loop_logp;
2454       int boost;
2455       width = C*(st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
2456       /* quanta is 6 bits, but no more than 1 bit/sample
2457          and no less than 1/8 bit/sample */
2458       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
2459       dynalloc_loop_logp = dynalloc_logp;
2460       boost = 0;
2461       while (tell+(dynalloc_loop_logp<<BITRES) < total_bits && boost < cap[i])
2462       {
2463          int flag;
2464          flag = ec_dec_bit_logp(dec, dynalloc_loop_logp);
2465          tell = ec_tell_frac(dec);
2466          if (!flag)
2467             break;
2468          boost += quanta;
2469          total_bits -= quanta;
2470          dynalloc_loop_logp = 1;
2471       }
2472       offsets[i] = boost;
2473       /* Making dynalloc more likely */
2474       if (boost>0)
2475          dynalloc_logp = IMAX(2, dynalloc_logp-1);
2476    }
2477
2478    ALLOC(fine_quant, st->mode->nbEBands, int);
2479    alloc_trim = tell+(6<<BITRES) <= total_bits ?
2480          ec_dec_icdf(dec, trim_icdf, 7) : 5;
2481
2482    bits = ((opus_int32)len*8<<BITRES) - ec_tell_frac(dec) - 1;
2483    anti_collapse_rsv = isTransient&&LM>=2&&bits>=(LM+2<<BITRES) ? (1<<BITRES) : 0;
2484    bits -= anti_collapse_rsv;
2485    codedBands = compute_allocation(st->mode, st->start, st->end, offsets, cap,
2486          alloc_trim, &intensity, &dual_stereo, bits, &balance, pulses,
2487          fine_quant, fine_priority, C, LM, dec, 0, 0);
2488
2489    unquant_fine_energy(st->mode, st->start, st->end, oldBandE, fine_quant, dec, C);
2490
2491    /* Decode fixed codebook */
2492    ALLOC(collapse_masks, C*st->mode->nbEBands, unsigned char);
2493    quant_all_bands(0, st->mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
2494          NULL, pulses, shortBlocks, spread_decision, dual_stereo, intensity, tf_res,
2495          len*(8<<BITRES)-anti_collapse_rsv, balance, dec, LM, codedBands, &st->rng);
2496
2497    if (anti_collapse_rsv > 0)
2498    {
2499       anti_collapse_on = ec_dec_bits(dec, 1);
2500    }
2501
2502    unquant_energy_finalise(st->mode, st->start, st->end, oldBandE,
2503          fine_quant, fine_priority, len*8-ec_tell(dec), dec, C);
2504
2505    if (anti_collapse_on)
2506       anti_collapse(st->mode, X, collapse_masks, LM, C, CC, N,
2507             st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
2508
2509    log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
2510
2511    if (silence)
2512    {
2513       for (i=0;i<C*st->mode->nbEBands;i++)
2514       {
2515          bandE[i] = 0;
2516          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
2517       }
2518    }
2519    /* Synthesis */
2520    denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
2521
2522    CELT_MOVE(decode_mem[0], decode_mem[0]+N, DECODE_BUFFER_SIZE-N);
2523    if (CC==2)
2524       CELT_MOVE(decode_mem[1], decode_mem[1]+N, DECODE_BUFFER_SIZE-N);
2525
2526    c=0; do
2527       for (i=0;i<M*st->mode->eBands[st->start];i++)
2528          freq[c*N+i] = 0;
2529    while (++c<C);
2530    c=0; do {
2531       int bound = M*st->mode->eBands[effEnd];
2532       if (st->downsample!=1)
2533          bound = IMIN(bound, N/st->downsample);
2534       for (i=bound;i<N;i++)
2535          freq[c*N+i] = 0;
2536    } while (++c<C);
2537
2538    out_syn[0] = out_mem[0]+MAX_PERIOD-N;
2539    if (CC==2)
2540       out_syn[1] = out_mem[1]+MAX_PERIOD-N;
2541
2542    if (CC==2&&C==1)
2543    {
2544       for (i=0;i<N;i++)
2545          freq[N+i] = freq[i];
2546    }
2547    if (CC==1&&C==2)
2548    {
2549       for (i=0;i<N;i++)
2550          freq[i] = HALF32(ADD32(freq[i],freq[N+i]));
2551    }
2552
2553    /* Compute inverse MDCTs */
2554    compute_inv_mdcts(st->mode, shortBlocks, freq, out_syn, overlap_mem, CC, LM);
2555
2556    c=0; do {
2557       st->postfilter_period=IMAX(st->postfilter_period, COMBFILTER_MINPERIOD);
2558       st->postfilter_period_old=IMAX(st->postfilter_period_old, COMBFILTER_MINPERIOD);
2559       comb_filter(out_syn[c], out_syn[c], st->postfilter_period_old, st->postfilter_period, st->mode->shortMdctSize,
2560             st->postfilter_gain_old, st->postfilter_gain, st->postfilter_tapset_old, st->postfilter_tapset,
2561             st->mode->window, st->overlap);
2562       if (LM!=0)
2563          comb_filter(out_syn[c]+st->mode->shortMdctSize, out_syn[c]+st->mode->shortMdctSize, st->postfilter_period, postfilter_pitch, N-st->mode->shortMdctSize,
2564                st->postfilter_gain, postfilter_gain, st->postfilter_tapset, postfilter_tapset,
2565                st->mode->window, st->mode->overlap);
2566
2567    } while (++c<CC);
2568    st->postfilter_period_old = st->postfilter_period;
2569    st->postfilter_gain_old = st->postfilter_gain;
2570    st->postfilter_tapset_old = st->postfilter_tapset;
2571    st->postfilter_period = postfilter_pitch;
2572    st->postfilter_gain = postfilter_gain;
2573    st->postfilter_tapset = postfilter_tapset;
2574    if (LM!=0)
2575    {
2576       st->postfilter_period_old = st->postfilter_period;
2577       st->postfilter_gain_old = st->postfilter_gain;
2578       st->postfilter_tapset_old = st->postfilter_tapset;
2579    }
2580
2581    if (C==1) {
2582       for (i=0;i<st->mode->nbEBands;i++)
2583          oldBandE[st->mode->nbEBands+i]=oldBandE[i];
2584    }
2585
2586    /* In case start or end were to change */
2587    c=0; do
2588    {
2589       for (i=0;i<st->start;i++)
2590          oldBandE[c*st->mode->nbEBands+i]=0;
2591       for (i=st->end;i<st->mode->nbEBands;i++)
2592          oldBandE[c*st->mode->nbEBands+i]=0;
2593    } while (++c<2);
2594    if (!isTransient)
2595    {
2596       for (i=0;i<2*st->mode->nbEBands;i++)
2597          oldLogE2[i] = oldLogE[i];
2598       for (i=0;i<2*st->mode->nbEBands;i++)
2599          oldLogE[i] = oldBandE[i];
2600       for (i=0;i<2*st->mode->nbEBands;i++)
2601          backgroundLogE[i] = MIN16(backgroundLogE[i] + M*QCONST16(0.001f,DB_SHIFT), oldBandE[i]);
2602    } else {
2603       for (i=0;i<2*st->mode->nbEBands;i++)
2604          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
2605    }
2606    st->rng = dec->rng;
2607
2608    deemphasis(out_syn, pcm, N, CC, st->downsample, st->mode->preemph, st->preemph_memD);
2609    st->loss_count = 0;
2610    RESTORE_STACK;
2611    if (ec_tell(dec) > 8*len)
2612       return CELT_INTERNAL_ERROR;
2613    if(ec_get_error(dec))
2614       st->error = 1;
2615    return frame_size/st->downsample;
2616 }
2617
2618
2619
2620 #ifdef FIXED_POINT
2621 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, opus_int16 * restrict pcm, int frame_size)
2622 {
2623    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
2624 }
2625
2626 #ifndef DISABLE_FLOAT_API
2627 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size)
2628 {
2629    int j, ret, C, N;
2630    VARDECL(opus_int16, out);
2631    ALLOC_STACK;
2632
2633    if (pcm==NULL)
2634       return CELT_BAD_ARG;
2635
2636    C = CHANNELS(st->channels);
2637    N = frame_size;
2638
2639    ALLOC(out, C*N, opus_int16);
2640    ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL);
2641    if (ret>0)
2642       for (j=0;j<C*ret;j++)
2643          pcm[j]=out[j]*(1.f/32768.f);
2644
2645    RESTORE_STACK;
2646    return ret;
2647 }
2648 #endif /* DISABLE_FLOAT_API */
2649
2650 #else
2651
2652 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size)
2653 {
2654    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
2655 }
2656
2657 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, opus_int16 * restrict pcm, int frame_size)
2658 {
2659    int j, ret, C, N;
2660    VARDECL(celt_sig, out);
2661    ALLOC_STACK;
2662
2663    if (pcm==NULL)
2664       return CELT_BAD_ARG;
2665
2666    C = CHANNELS(st->channels);
2667    N = frame_size;
2668    ALLOC(out, C*N, celt_sig);
2669
2670    ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL);
2671
2672    if (ret>0)
2673       for (j=0;j<C*ret;j++)
2674          pcm[j] = FLOAT2INT16 (out[j]);
2675
2676    RESTORE_STACK;
2677    return ret;
2678 }
2679
2680 #endif
2681
2682
2683 int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
2684 {
2685    va_list ap;
2686
2687    va_start(ap, request);
2688    switch (request)
2689    {
2690       case CELT_SET_START_BAND_REQUEST:
2691       {
2692          opus_int32 value = va_arg(ap, opus_int32);
2693          if (value<0 || value>=st->mode->nbEBands)
2694             goto bad_arg;
2695          st->start = value;
2696       }
2697       break;
2698       case CELT_SET_END_BAND_REQUEST:
2699       {
2700          opus_int32 value = va_arg(ap, opus_int32);
2701          if (value<1 || value>st->mode->nbEBands)
2702             goto bad_arg;
2703          st->end = value;
2704       }
2705       break;
2706       case CELT_SET_CHANNELS_REQUEST:
2707       {
2708          opus_int32 value = va_arg(ap, opus_int32);
2709          if (value<1 || value>2)
2710             goto bad_arg;
2711          st->stream_channels = value;
2712       }
2713       break;
2714       case CELT_GET_AND_CLEAR_ERROR_REQUEST:
2715       {
2716          int *value = va_arg(ap, int*);
2717          if (value==NULL)
2718             goto bad_arg;
2719          *value=st->error;
2720          st->error = 0;
2721       }
2722       break;
2723       case CELT_GET_LOOKAHEAD_REQUEST:
2724       {
2725          int *value = va_arg(ap, int*);
2726          if (value==NULL)
2727             goto bad_arg;
2728          *value = st->overlap/st->downsample;
2729       }
2730       break;
2731       case CELT_RESET_STATE:
2732       {
2733          CELT_MEMSET((char*)&st->DECODER_RESET_START, 0,
2734                celt_decoder_get_size_custom(st->mode, st->channels)-
2735                ((char*)&st->DECODER_RESET_START - (char*)st));
2736       }
2737       break;
2738 #ifdef OPUS_BUILD
2739       case CELT_GET_MODE_REQUEST:
2740       {
2741          const CELTMode ** value = va_arg(ap, const CELTMode**);
2742          if (value==0)
2743             goto bad_arg;
2744          *value=st->mode;
2745       }
2746       break;
2747       case CELT_SET_SIGNALLING_REQUEST:
2748       {
2749          opus_int32 value = va_arg(ap, opus_int32);
2750          st->signalling = value;
2751       }
2752       break;
2753       case CELT_GET_RANGE_REQUEST:
2754       {
2755          opus_uint32 * value = va_arg(ap, opus_uint32 *);
2756          if (value==0)
2757             goto bad_arg;
2758          *value=st->rng;
2759       }
2760       break;
2761 #endif
2762       default:
2763          goto bad_request;
2764    }
2765    va_end(ap);
2766    return CELT_OK;
2767 bad_arg:
2768    va_end(ap);
2769    return CELT_BAD_ARG;
2770 bad_request:
2771       va_end(ap);
2772   return CELT_UNIMPLEMENTED;
2773 }
2774
2775 const char *celt_strerror(int error)
2776 {
2777    static const char *error_strings[8] = {
2778       "success",
2779       "invalid argument",
2780       "buffer too small",
2781       "internal error",
2782       "corrupted stream",
2783       "request not implemented",
2784       "invalid state",
2785       "memory allocation failed"
2786    };
2787    if (error > 0 || error < -7)
2788       return "unknown error";
2789    else
2790       return error_strings[-error];
2791 }