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