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