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