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