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