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