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