Changing some double constants to float
[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 one byte 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+7>>3)-nbFilledBytes,
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    }
1428    if (isTransient)
1429       st->consec_transient++;
1430    else
1431       st->consec_transient=0;
1432    st->rng = enc->rng;
1433
1434    /* If there's any room left (can only happen for very high rates),
1435       it's already filled with zeros */
1436    ec_enc_done(enc);
1437    
1438    RESTORE_STACK;
1439    if (ec_enc_get_error(enc))
1440       return CELT_CORRUPTED_DATA;
1441    else
1442       return nbCompressedBytes;
1443 }
1444
1445 #ifdef FIXED_POINT
1446 #ifndef DISABLE_FLOAT_API
1447 int celt_encode_with_ec_float(CELTEncoder * restrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
1448 {
1449    int j, ret, C, N, LM, M;
1450    VARDECL(celt_int16, in);
1451    SAVE_STACK;
1452
1453    if (pcm==NULL)
1454       return CELT_BAD_ARG;
1455
1456    for (LM=0;LM<4;LM++)
1457       if (st->mode->shortMdctSize<<LM==frame_size)
1458          break;
1459    if (LM>=MAX_CONFIG_SIZES)
1460       return CELT_BAD_ARG;
1461    M=1<<LM;
1462
1463    C = CHANNELS(st->channels);
1464    N = M*st->mode->shortMdctSize;
1465    ALLOC(in, C*N, celt_int16);
1466
1467    for (j=0;j<C*N;j++)
1468      in[j] = FLOAT2INT16(pcm[j]);
1469
1470    ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, enc);
1471 #ifdef RESYNTH
1472    for (j=0;j<C*N;j++)
1473       ((float*)pcm)[j]=in[j]*(1.f/32768.f);
1474 #endif
1475    RESTORE_STACK;
1476    return ret;
1477
1478 }
1479 #endif /*DISABLE_FLOAT_API*/
1480 #else
1481 int celt_encode_with_ec(CELTEncoder * restrict st, const celt_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
1482 {
1483    int j, ret, C, N, LM, M;
1484    VARDECL(celt_sig, in);
1485    SAVE_STACK;
1486
1487    if (pcm==NULL)
1488       return CELT_BAD_ARG;
1489
1490    for (LM=0;LM<4;LM++)
1491       if (st->mode->shortMdctSize<<LM==frame_size)
1492          break;
1493    if (LM>=MAX_CONFIG_SIZES)
1494       return CELT_BAD_ARG;
1495    M=1<<LM;
1496
1497    C=CHANNELS(st->channels);
1498    N=M*st->mode->shortMdctSize;
1499    ALLOC(in, C*N, celt_sig);
1500    for (j=0;j<C*N;j++) {
1501      in[j] = SCALEOUT(pcm[j]);
1502    }
1503
1504    ret = celt_encode_with_ec_float(st,in,frame_size,compressed,nbCompressedBytes, enc);
1505 #ifdef RESYNTH
1506    for (j=0;j<C*N;j++)
1507       ((celt_int16*)pcm)[j] = FLOAT2INT16(in[j]);
1508 #endif
1509    RESTORE_STACK;
1510    return ret;
1511 }
1512 #endif
1513
1514 int celt_encode(CELTEncoder * restrict st, const celt_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1515 {
1516    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1517 }
1518
1519 #ifndef DISABLE_FLOAT_API
1520 int celt_encode_float(CELTEncoder * restrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1521 {
1522    return celt_encode_with_ec_float(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1523 }
1524 #endif /* DISABLE_FLOAT_API */
1525
1526 int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
1527 {
1528    va_list ap;
1529    
1530    va_start(ap, request);
1531    switch (request)
1532    {
1533       case CELT_GET_MODE_REQUEST:
1534       {
1535          const CELTMode ** value = va_arg(ap, const CELTMode**);
1536          if (value==0)
1537             goto bad_arg;
1538          *value=st->mode;
1539       }
1540       break;
1541       case CELT_SET_COMPLEXITY_REQUEST:
1542       {
1543          int value = va_arg(ap, celt_int32);
1544          if (value<0 || value>10)
1545             goto bad_arg;
1546          st->complexity = value;
1547       }
1548       break;
1549       case CELT_SET_START_BAND_REQUEST:
1550       {
1551          celt_int32 value = va_arg(ap, celt_int32);
1552          if (value<0 || value>=st->mode->nbEBands)
1553             goto bad_arg;
1554          st->start = value;
1555       }
1556       break;
1557       case CELT_SET_END_BAND_REQUEST:
1558       {
1559          celt_int32 value = va_arg(ap, celt_int32);
1560          if (value<1 || value>st->mode->nbEBands)
1561             goto bad_arg;
1562          st->end = value;
1563       }
1564       break;
1565       case CELT_SET_PREDICTION_REQUEST:
1566       {
1567          int value = va_arg(ap, celt_int32);
1568          if (value<0 || value>2)
1569             goto bad_arg;
1570          if (value==0)
1571          {
1572             st->force_intra   = 1;
1573          } else if (value==1) {
1574             st->force_intra   = 0;
1575          } else {
1576             st->force_intra   = 0;
1577          }   
1578       }
1579       break;
1580       case CELT_SET_VBR_CONSTRAINT_REQUEST:
1581       {
1582          celt_int32 value = va_arg(ap, celt_int32);
1583          st->constrained_vbr = value;
1584       }
1585       break;
1586       case CELT_SET_VBR_RATE_REQUEST:
1587       {
1588          celt_int32 value = va_arg(ap, celt_int32);
1589          int frame_rate;
1590          int N = st->mode->shortMdctSize;
1591          if (value<0)
1592             goto bad_arg;
1593          if (value>3072000)
1594             value = 3072000;
1595          frame_rate = ((st->mode->Fs<<3)+(N>>1))/N;
1596          st->vbr_rate_norm = ((value<<(BITRES+3))+(frame_rate>>1))/frame_rate;
1597       }
1598       break;
1599       case CELT_RESET_STATE:
1600       {
1601          CELT_MEMSET((char*)&st->ENCODER_RESET_START, 0,
1602                celt_encoder_get_size(st->mode, st->channels)-
1603                ((char*)&st->ENCODER_RESET_START - (char*)st));
1604          st->vbr_offset = 0;
1605          st->delayedIntra = 1;
1606          st->spread_decision = SPREAD_NORMAL;
1607          st->tonal_average = QCONST16(1.f,8);
1608       }
1609       break;
1610       default:
1611          goto bad_request;
1612    }
1613    va_end(ap);
1614    return CELT_OK;
1615 bad_arg:
1616    va_end(ap);
1617    return CELT_BAD_ARG;
1618 bad_request:
1619    va_end(ap);
1620    return CELT_UNIMPLEMENTED;
1621 }
1622
1623 /**********************************************************************/
1624 /*                                                                    */
1625 /*                             DECODER                                */
1626 /*                                                                    */
1627 /**********************************************************************/
1628 #define DECODE_BUFFER_SIZE 2048
1629
1630 /** Decoder state 
1631  @brief Decoder state
1632  */
1633 struct CELTDecoder {
1634    const CELTMode *mode;
1635    int overlap;
1636    int channels;
1637
1638    int start, end;
1639
1640    /* Everything beyond this point gets cleared on a reset */
1641 #define DECODER_RESET_START rng
1642
1643    ec_uint32 rng;
1644    int last_pitch_index;
1645    int loss_count;
1646    int postfilter_period;
1647    int postfilter_period_old;
1648    celt_word16 postfilter_gain;
1649    celt_word16 postfilter_gain_old;
1650    int postfilter_tapset;
1651    int postfilter_tapset_old;
1652
1653    celt_sig preemph_memD[2];
1654    
1655    celt_sig _decode_mem[1]; /* Size = channels*(DECODE_BUFFER_SIZE+mode->overlap) */
1656    /* celt_word16 lpc[],  Size = channels*LPC_ORDER */
1657    /* celt_word16 oldEBands[], Size = channels*mode->nbEBands */
1658    /* celt_word16 oldLogE[], Size = channels*mode->nbEBands */
1659    /* celt_word16 oldLogE2[], Size = channels*mode->nbEBands */
1660    /* celt_word16 backgroundLogE[], Size = channels*mode->nbEBands */
1661 };
1662
1663 int celt_decoder_get_size(const CELTMode *mode, int channels)
1664 {
1665    int size = sizeof(struct CELTDecoder)
1666             + (channels*(DECODE_BUFFER_SIZE+mode->overlap)-1)*sizeof(celt_sig)
1667             + channels*LPC_ORDER*sizeof(celt_word16)
1668             + 4*channels*mode->nbEBands*sizeof(celt_word16);
1669    return size;
1670 }
1671
1672 CELTDecoder *celt_decoder_create(const CELTMode *mode, int channels, int *error)
1673 {
1674    return celt_decoder_init(
1675          (CELTDecoder *)celt_alloc(celt_decoder_get_size(mode, channels)),
1676          mode, channels, error);
1677 }
1678
1679 CELTDecoder *celt_decoder_init(CELTDecoder *st, const CELTMode *mode, int channels, int *error)
1680 {
1681    if (channels < 0 || channels > 2)
1682    {
1683       if (error)
1684          *error = CELT_BAD_ARG;
1685       return NULL;
1686    }
1687
1688    if (st==NULL)
1689    {
1690       if (error)
1691          *error = CELT_ALLOC_FAIL;
1692       return NULL;
1693    }
1694
1695    CELT_MEMSET((char*)st, 0, celt_decoder_get_size(mode, channels));
1696
1697    st->mode = mode;
1698    st->overlap = mode->overlap;
1699    st->channels = channels;
1700
1701    st->start = 0;
1702    st->end = st->mode->effEBands;
1703
1704    st->loss_count = 0;
1705
1706    if (error)
1707       *error = CELT_OK;
1708    return st;
1709 }
1710
1711 void celt_decoder_destroy(CELTDecoder *st)
1712 {
1713    celt_free(st);
1714 }
1715
1716 static void celt_decode_lost(CELTDecoder * restrict st, celt_word16 * restrict pcm, int N, int LM)
1717 {
1718    int c;
1719    int pitch_index;
1720    int overlap = st->mode->overlap;
1721    celt_word16 fade = Q15ONE;
1722    int i, len;
1723    const int C = CHANNELS(st->channels);
1724    int offset;
1725    celt_sig *out_mem[2];
1726    celt_sig *decode_mem[2];
1727    celt_sig *overlap_mem[2];
1728    celt_word16 *lpc;
1729    celt_word32 *out_syn[2];
1730    celt_word16 *oldBandE, *oldLogE2, *backgroundLogE;
1731    SAVE_STACK;
1732    
1733    c=0; do {
1734       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
1735       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
1736       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
1737    } while (++c<C);
1738    lpc = (celt_word16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*C);
1739    oldBandE = lpc+C*LPC_ORDER;
1740    oldLogE2 = oldBandE + C*st->mode->nbEBands;
1741    backgroundLogE = oldLogE2  + C*st->mode->nbEBands;
1742
1743    out_syn[0] = out_mem[0]+MAX_PERIOD-N;
1744    if (C==2)
1745       out_syn[1] = out_mem[1]+MAX_PERIOD-N;
1746
1747    len = N+st->mode->overlap;
1748    
1749    if (st->loss_count >= 5)
1750    {
1751       VARDECL(celt_sig, freq);
1752       VARDECL(celt_norm, X);
1753       VARDECL(celt_ener, bandE);
1754       celt_uint32 seed;
1755
1756       ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
1757       ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
1758       ALLOC(bandE, st->mode->nbEBands*C, celt_ener);
1759
1760       log2Amp(st->mode, st->start, st->end, bandE, backgroundLogE, C);
1761
1762       seed = st->rng;
1763       for (i=0;i<C*N;i++)
1764       {
1765             seed = lcg_rand(seed);
1766             X[i] = (celt_int32)(seed)>>20;
1767       }
1768       st->rng = seed;
1769       for (c=0;c<C;c++)
1770          for (i=0;i<st->mode->nbEBands;i++)
1771             renormalise_vector(X+N*c+(st->mode->eBands[i]<<LM), (st->mode->eBands[i+1]-st->mode->eBands[i])<<LM, Q15ONE);
1772
1773       denormalise_bands(st->mode, X, freq, bandE, st->mode->nbEBands, C, 1<<LM);
1774
1775       compute_inv_mdcts(st->mode, 0, freq, out_syn, overlap_mem, C, LM);
1776    } else if (st->loss_count == 0)
1777    {
1778       celt_word16 pitch_buf[MAX_PERIOD>>1];
1779       int len2 = len;
1780       /* FIXME: This is a kludge */
1781       if (len2>MAX_PERIOD>>1)
1782          len2 = MAX_PERIOD>>1;
1783       pitch_downsample(out_mem, pitch_buf, MAX_PERIOD, C);
1784       pitch_search(pitch_buf+((MAX_PERIOD-len2)>>1), pitch_buf, len2,
1785                    MAX_PERIOD-len2-100, &pitch_index);
1786       pitch_index = MAX_PERIOD-len2-pitch_index;
1787       st->last_pitch_index = pitch_index;
1788    } else {
1789       pitch_index = st->last_pitch_index;
1790       fade = QCONST16(.8f,15);
1791    }
1792
1793    c=0; do {
1794       /* FIXME: This is more memory than necessary */
1795       celt_word32 e[2*MAX_PERIOD];
1796       celt_word16 exc[2*MAX_PERIOD];
1797       celt_word32 ac[LPC_ORDER+1];
1798       celt_word16 decay = 1;
1799       celt_word32 S1=0;
1800       celt_word16 mem[LPC_ORDER]={0};
1801
1802       offset = MAX_PERIOD-pitch_index;
1803       for (i=0;i<MAX_PERIOD;i++)
1804          exc[i] = ROUND16(out_mem[c][i], SIG_SHIFT);
1805
1806       if (st->loss_count == 0)
1807       {
1808          _celt_autocorr(exc, ac, st->mode->window, st->mode->overlap,
1809                         LPC_ORDER, MAX_PERIOD);
1810
1811          /* Noise floor -40 dB */
1812 #ifdef FIXED_POINT
1813          ac[0] += SHR32(ac[0],13);
1814 #else
1815          ac[0] *= 1.0001f;
1816 #endif
1817          /* Lag windowing */
1818          for (i=1;i<=LPC_ORDER;i++)
1819          {
1820             /*ac[i] *= exp(-.5*(2*M_PI*.002*i)*(2*M_PI*.002*i));*/
1821 #ifdef FIXED_POINT
1822             ac[i] -= MULT16_32_Q15(2*i*i, ac[i]);
1823 #else
1824             ac[i] -= ac[i]*(.008f*i)*(.008f*i);
1825 #endif
1826          }
1827
1828          _celt_lpc(lpc+c*LPC_ORDER, ac, LPC_ORDER);
1829       }
1830       for (i=0;i<LPC_ORDER;i++)
1831          mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT);
1832       fir(exc, lpc+c*LPC_ORDER, exc, MAX_PERIOD, LPC_ORDER, mem);
1833       /*for (i=0;i<MAX_PERIOD;i++)printf("%d ", exc[i]); printf("\n");*/
1834       /* Check if the waveform is decaying (and if so how fast) */
1835       {
1836          celt_word32 E1=1, E2=1;
1837          int period;
1838          if (pitch_index <= MAX_PERIOD/2)
1839             period = pitch_index;
1840          else
1841             period = MAX_PERIOD/2;
1842          for (i=0;i<period;i++)
1843          {
1844             E1 += SHR32(MULT16_16(exc[MAX_PERIOD-period+i],exc[MAX_PERIOD-period+i]),8);
1845             E2 += SHR32(MULT16_16(exc[MAX_PERIOD-2*period+i],exc[MAX_PERIOD-2*period+i]),8);
1846          }
1847          if (E1 > E2)
1848             E1 = E2;
1849          decay = celt_sqrt(frac_div32(SHR(E1,1),E2));
1850       }
1851
1852       /* Copy excitation, taking decay into account */
1853       for (i=0;i<len+st->mode->overlap;i++)
1854       {
1855          celt_word16 tmp;
1856          if (offset+i >= MAX_PERIOD)
1857          {
1858             offset -= pitch_index;
1859             decay = MULT16_16_Q15(decay, decay);
1860          }
1861          e[i] = SHL32(EXTEND32(MULT16_16_Q15(decay, exc[offset+i])), SIG_SHIFT);
1862          tmp = ROUND16(out_mem[c][offset+i],SIG_SHIFT);
1863          S1 += SHR32(MULT16_16(tmp,tmp),8);
1864       }
1865       for (i=0;i<LPC_ORDER;i++)
1866          mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT);
1867       for (i=0;i<len+st->mode->overlap;i++)
1868          e[i] = MULT16_32_Q15(fade, e[i]);
1869       iir(e, lpc+c*LPC_ORDER, e, len+st->mode->overlap, LPC_ORDER, mem);
1870
1871       {
1872          celt_word32 S2=0;
1873          for (i=0;i<len+overlap;i++)
1874          {
1875             celt_word16 tmp = ROUND16(e[i],SIG_SHIFT);
1876             S2 += SHR32(MULT16_16(tmp,tmp),8);
1877          }
1878          /* This checks for an "explosion" in the synthesis */
1879 #ifdef FIXED_POINT
1880          if (!(S1 > SHR32(S2,2)))
1881 #else
1882          /* Float test is written this way to catch NaNs at the same time */
1883          if (!(S1 > 0.2f*S2))
1884 #endif
1885          {
1886             for (i=0;i<len+overlap;i++)
1887                e[i] = 0;
1888          } else if (S1 < S2)
1889          {
1890             celt_word16 ratio = celt_sqrt(frac_div32(SHR32(S1,1)+1,S2+1));
1891             for (i=0;i<len+overlap;i++)
1892                e[i] = MULT16_32_Q15(ratio, e[i]);
1893          }
1894       }
1895
1896 #ifdef ENABLE_POSTFILTER
1897       /* Apply post-filter to the MDCT overlap of the previous frame */
1898       comb_filter(out_mem[c]+MAX_PERIOD, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap,
1899                   st->postfilter_gain, st->postfilter_gain, st->postfilter_tapset, st->postfilter_tapset,
1900                   NULL, 0);
1901 #endif /* ENABLE_POSTFILTER */
1902
1903       for (i=0;i<MAX_PERIOD+st->mode->overlap-N;i++)
1904          out_mem[c][i] = out_mem[c][N+i];
1905
1906       /* Apply TDAC to the concealed audio so that it blends with the
1907          previous and next frames */
1908       for (i=0;i<overlap/2;i++)
1909       {
1910          celt_word32 tmp;
1911          tmp = MULT16_32_Q15(st->mode->window[i],           e[N+overlap-1-i]) +
1912                MULT16_32_Q15(st->mode->window[overlap-i-1], e[N+i          ]);
1913          out_mem[c][MAX_PERIOD+i] = MULT16_32_Q15(st->mode->window[overlap-i-1], tmp);
1914          out_mem[c][MAX_PERIOD+overlap-i-1] = MULT16_32_Q15(st->mode->window[i], tmp);
1915       }
1916       for (i=0;i<N;i++)
1917          out_mem[c][MAX_PERIOD-N+i] = e[i];
1918
1919 #ifdef ENABLE_POSTFILTER
1920       /* Apply pre-filter to the MDCT overlap for the next frame (post-filter will be applied then) */
1921       comb_filter(e, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap,
1922                   -st->postfilter_gain, -st->postfilter_gain, st->postfilter_tapset, st->postfilter_tapset,
1923                   NULL, 0);
1924 #endif /* ENABLE_POSTFILTER */
1925       for (i=0;i<overlap;i++)
1926          out_mem[c][MAX_PERIOD+i] = e[i];
1927    } while (++c<C);
1928
1929    deemphasis(out_syn, pcm, N, C, st->mode->preemph, st->preemph_memD);
1930    
1931    st->loss_count++;
1932
1933    RESTORE_STACK;
1934 }
1935
1936 #ifdef FIXED_POINT
1937 int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size, ec_dec *dec)
1938 {
1939 #else
1940 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)
1941 {
1942 #endif
1943    int c, i, N;
1944    int spread_decision;
1945    int bits;
1946    ec_dec _dec;
1947    ec_byte_buffer buf;
1948    VARDECL(celt_sig, freq);
1949    VARDECL(celt_norm, X);
1950    VARDECL(celt_ener, bandE);
1951    VARDECL(int, fine_quant);
1952    VARDECL(int, pulses);
1953    VARDECL(int, offsets);
1954    VARDECL(int, fine_priority);
1955    VARDECL(int, tf_res);
1956    VARDECL(unsigned char, collapse_masks);
1957    celt_sig *out_mem[2];
1958    celt_sig *decode_mem[2];
1959    celt_sig *overlap_mem[2];
1960    celt_sig *out_syn[2];
1961    celt_word16 *lpc;
1962    celt_word16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE;
1963
1964    int shortBlocks;
1965    int isTransient;
1966    int intra_ener;
1967    const int C = CHANNELS(st->channels);
1968    int LM, M;
1969    int effEnd;
1970    int codedBands;
1971    int alloc_trim;
1972    int postfilter_pitch;
1973    celt_word16 postfilter_gain;
1974    int intensity=0;
1975    int dual_stereo=0;
1976    celt_int32 total_bits;
1977    celt_int32 tell;
1978    int dynalloc_logp;
1979    int postfilter_tapset;
1980    int anti_collapse_rsv;
1981    int anti_collapse_on=0;
1982    int silence;
1983
1984    SAVE_STACK;
1985
1986    if (pcm==NULL)
1987       return CELT_BAD_ARG;
1988
1989    for (LM=0;LM<4;LM++)
1990       if (st->mode->shortMdctSize<<LM==frame_size)
1991          break;
1992    if (LM>=MAX_CONFIG_SIZES)
1993       return CELT_BAD_ARG;
1994    M=1<<LM;
1995
1996    c=0; do {
1997       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
1998       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
1999       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
2000    } while (++c<C);
2001    lpc = (celt_word16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*C);
2002    oldBandE = lpc+C*LPC_ORDER;
2003    oldLogE = oldBandE + C*st->mode->nbEBands;
2004    oldLogE2 = oldLogE + C*st->mode->nbEBands;
2005    backgroundLogE = oldLogE2  + C*st->mode->nbEBands;
2006
2007    N = M*st->mode->shortMdctSize;
2008
2009    effEnd = st->end;
2010    if (effEnd > st->mode->effEBands)
2011       effEnd = st->mode->effEBands;
2012
2013    ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
2014    ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
2015    ALLOC(bandE, st->mode->nbEBands*C, celt_ener);
2016    c=0; do
2017       for (i=0;i<M*st->mode->eBands[st->start];i++)
2018          X[c*N+i] = 0;
2019    while (++c<C);
2020    c=0; do   
2021       for (i=M*st->mode->eBands[effEnd];i<N;i++)
2022          X[c*N+i] = 0;
2023    while (++c<C);
2024
2025    if (data == NULL || len<=1)
2026    {
2027       celt_decode_lost(st, pcm, N, LM);
2028       RESTORE_STACK;
2029       return CELT_OK;
2030    }
2031    if (len<0) {
2032      RESTORE_STACK;
2033      return CELT_BAD_ARG;
2034    }
2035    
2036    if (dec == NULL)
2037    {
2038       ec_byte_readinit(&buf,(unsigned char*)data,len);
2039       ec_dec_init(&_dec,&buf);
2040       dec = &_dec;
2041    }
2042
2043    total_bits = len*8;
2044    tell = ec_dec_tell(dec, 0);
2045
2046    if (tell==1)
2047       silence = ec_dec_bit_logp(dec, 15);
2048    else
2049       silence = 0;
2050    if (silence)
2051    {
2052       /* Pretend we've read all the remaining bits */
2053       tell = len*8;
2054       dec->nbits_total+=tell-ec_dec_tell(dec,0);
2055    }
2056
2057    postfilter_gain = 0;
2058    postfilter_pitch = 0;
2059    postfilter_tapset = 0;
2060    if (st->start==0 && tell+17 <= total_bits)
2061    {
2062       if(ec_dec_bit_logp(dec, 1))
2063       {
2064 #ifdef ENABLE_POSTFILTER
2065          int qg, octave;
2066          octave = ec_dec_uint(dec, 6);
2067          postfilter_pitch = (16<<octave)+ec_dec_bits(dec, 4+octave)-1;
2068          qg = ec_dec_bits(dec, 2);
2069          postfilter_tapset = ec_dec_icdf(dec, tapset_icdf, 2);
2070          postfilter_gain = QCONST16(.125f,15)*(qg+2);
2071 #else /* ENABLE_POSTFILTER */
2072          RESTORE_STACK;
2073          return CELT_CORRUPTED_DATA;
2074 #endif /* ENABLE_POSTFILTER */
2075       }
2076       tell = ec_dec_tell(dec, 0);
2077    }
2078
2079    if (LM > 0 && tell+3 <= total_bits)
2080    {
2081       isTransient = ec_dec_bit_logp(dec, 3);
2082       tell = ec_dec_tell(dec, 0);
2083    }
2084    else
2085       isTransient = 0;
2086
2087    if (isTransient)
2088       shortBlocks = M;
2089    else
2090       shortBlocks = 0;
2091
2092    /* Decode the global flags (first symbols in the stream) */
2093    intra_ener = tell+3<=total_bits ? ec_dec_bit_logp(dec, 3) : 0;
2094    /* Get band energies */
2095    unquant_coarse_energy(st->mode, st->start, st->end, oldBandE,
2096          intra_ener, dec, C, LM);
2097
2098    ALLOC(tf_res, st->mode->nbEBands, int);
2099    tf_decode(st->start, st->end, isTransient, tf_res, LM, dec);
2100
2101    tell = ec_dec_tell(dec, 0);
2102    spread_decision = SPREAD_NORMAL;
2103    if (tell+4 <= total_bits)
2104       spread_decision = ec_dec_icdf(dec, spread_icdf, 5);
2105
2106    ALLOC(pulses, st->mode->nbEBands, int);
2107    ALLOC(offsets, st->mode->nbEBands, int);
2108    ALLOC(fine_priority, st->mode->nbEBands, int);
2109
2110    dynalloc_logp = 6;
2111    total_bits<<=BITRES;
2112    tell = ec_dec_tell(dec, BITRES);
2113    for (i=st->start;i<st->end;i++)
2114    {
2115       int width, quanta;
2116       int dynalloc_loop_logp;
2117       int boost;
2118       width = C*(st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
2119       /* quanta is 6 bits, but no more than 1 bit/sample
2120          and no less than 1/8 bit/sample */
2121       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
2122       dynalloc_loop_logp = dynalloc_logp;
2123       boost = 0;
2124       while (tell+(dynalloc_loop_logp<<BITRES) < total_bits &&
2125             boost < (64<<LM)*(C<<BITRES))
2126       {
2127          int flag;
2128          flag = ec_dec_bit_logp(dec, dynalloc_loop_logp);
2129          tell = ec_dec_tell(dec, BITRES);
2130          if (!flag)
2131             break;
2132          boost += quanta;
2133          total_bits -= quanta;
2134          dynalloc_loop_logp = 1;
2135       }
2136       offsets[i] = boost;
2137       /* Making dynalloc more likely */
2138       if (boost>0)
2139          dynalloc_logp = IMAX(2, dynalloc_logp-1);
2140    }
2141
2142    ALLOC(fine_quant, st->mode->nbEBands, int);
2143    alloc_trim = tell+(6<<BITRES) <= total_bits ?
2144          ec_dec_icdf(dec, trim_icdf, 7) : 5;
2145
2146    bits = (len*8<<BITRES) - ec_dec_tell(dec, BITRES) - 1;
2147    anti_collapse_rsv = isTransient&&LM>=2&&bits>=(LM+2<<BITRES) ? (1<<BITRES) : 0;
2148    bits -= anti_collapse_rsv;
2149    codedBands = compute_allocation(st->mode, st->start, st->end, offsets,
2150          alloc_trim, &intensity, &dual_stereo, bits, pulses, fine_quant,
2151          fine_priority, C, LM, dec, 0, 0);
2152    
2153    unquant_fine_energy(st->mode, st->start, st->end, oldBandE, fine_quant, dec, C);
2154
2155    /* Decode fixed codebook */
2156    ALLOC(collapse_masks, st->mode->nbEBands, unsigned char);
2157    quant_all_bands(0, st->mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
2158          NULL, pulses, shortBlocks, spread_decision, dual_stereo, intensity, tf_res, 1,
2159          len*(8<<BITRES)-anti_collapse_rsv, dec, LM, codedBands, &st->rng);
2160
2161    if (anti_collapse_rsv > 0)
2162    {
2163       anti_collapse_on = ec_dec_bits(dec, 1);
2164    }
2165
2166    unquant_energy_finalise(st->mode, st->start, st->end, oldBandE,
2167          fine_quant, fine_priority, len*8-ec_dec_tell(dec, 0), dec, C);
2168
2169    if (anti_collapse_on)
2170       anti_collapse(st->mode, X, collapse_masks, LM, C, N,
2171             st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
2172
2173    log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
2174
2175    if (silence)
2176    {
2177       for (i=0;i<C*st->mode->nbEBands;i++)
2178       {
2179          bandE[i] = 0;
2180          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
2181       }
2182    }
2183    /* Synthesis */
2184    denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
2185
2186    CELT_MOVE(decode_mem[0], decode_mem[0]+N, DECODE_BUFFER_SIZE-N);
2187    if (C==2)
2188       CELT_MOVE(decode_mem[1], decode_mem[1]+N, DECODE_BUFFER_SIZE-N);
2189
2190    c=0; do
2191       for (i=0;i<M*st->mode->eBands[st->start];i++)
2192          freq[c*N+i] = 0;
2193    while (++c<C);
2194    c=0; do
2195       for (i=M*st->mode->eBands[effEnd];i<N;i++)
2196          freq[c*N+i] = 0;
2197    while (++c<C);
2198
2199    out_syn[0] = out_mem[0]+MAX_PERIOD-N;
2200    if (C==2)
2201       out_syn[1] = out_mem[1]+MAX_PERIOD-N;
2202
2203    /* Compute inverse MDCTs */
2204    compute_inv_mdcts(st->mode, shortBlocks, freq, out_syn, overlap_mem, C, LM);
2205
2206 #ifdef ENABLE_POSTFILTER
2207    c=0; do {
2208       st->postfilter_period=IMAX(st->postfilter_period, COMBFILTER_MINPERIOD);
2209       st->postfilter_period_old=IMAX(st->postfilter_period_old, COMBFILTER_MINPERIOD);
2210       if (LM!=0)
2211       {
2212          comb_filter(out_syn[c], out_syn[c], st->postfilter_period, st->postfilter_period, st->overlap,
2213                st->postfilter_gain, st->postfilter_gain, st->postfilter_tapset, st->postfilter_tapset,
2214                NULL, 0);
2215          comb_filter(out_syn[c]+st->overlap, out_syn[c]+st->overlap, st->postfilter_period, postfilter_pitch, N-st->overlap,
2216                st->postfilter_gain, postfilter_gain, st->postfilter_tapset, postfilter_tapset,
2217                st->mode->window, st->mode->overlap);
2218       } else {
2219          comb_filter(out_syn[c], out_syn[c], st->postfilter_period_old, st->postfilter_period, N-st->overlap,
2220                st->postfilter_gain_old, st->postfilter_gain, st->postfilter_tapset_old, st->postfilter_tapset,
2221                st->mode->window, st->mode->overlap);
2222       }
2223    } while (++c<C);
2224    st->postfilter_period_old = st->postfilter_period;
2225    st->postfilter_gain_old = st->postfilter_gain;
2226    st->postfilter_tapset_old = st->postfilter_tapset;
2227    st->postfilter_period = postfilter_pitch;
2228    st->postfilter_gain = postfilter_gain;
2229    st->postfilter_tapset = postfilter_tapset;
2230 #endif /* ENABLE_POSTFILTER */
2231
2232    /* In case start or end were to change */
2233    c=0; do
2234    {
2235       for (i=0;i<st->start;i++)
2236          oldBandE[c*st->mode->nbEBands+i]=0;
2237       for (i=st->end;i<st->mode->nbEBands;i++)
2238          oldBandE[c*st->mode->nbEBands+i]=0;
2239    } while (++c<C);
2240    if (!isTransient)
2241    {
2242       for (i=0;i<C*st->mode->nbEBands;i++)
2243          oldLogE2[i] = oldLogE[i];
2244       for (i=0;i<C*st->mode->nbEBands;i++)
2245          oldLogE[i] = oldBandE[i];
2246       for (i=0;i<C*st->mode->nbEBands;i++)
2247          backgroundLogE[i] = MIN16(backgroundLogE[i] + M*QCONST16(0.001f,DB_SHIFT), oldBandE[i]);
2248    }
2249    st->rng = dec->rng;
2250
2251    deemphasis(out_syn, pcm, N, C, st->mode->preemph, st->preemph_memD);
2252    st->loss_count = 0;
2253    RESTORE_STACK;
2254    if (ec_dec_tell(dec,0) > 8*len || ec_dec_get_error(dec))
2255       return CELT_CORRUPTED_DATA;
2256    else
2257       return CELT_OK;
2258 }
2259
2260 #ifdef FIXED_POINT
2261 #ifndef DISABLE_FLOAT_API
2262 int celt_decode_with_ec_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size, ec_dec *dec)
2263 {
2264    int j, ret, C, N, LM, M;
2265    VARDECL(celt_int16, out);
2266    SAVE_STACK;
2267
2268    if (pcm==NULL)
2269       return CELT_BAD_ARG;
2270
2271    for (LM=0;LM<4;LM++)
2272       if (st->mode->shortMdctSize<<LM==frame_size)
2273          break;
2274    if (LM>=MAX_CONFIG_SIZES)
2275       return CELT_BAD_ARG;
2276    M=1<<LM;
2277
2278    C = CHANNELS(st->channels);
2279    N = M*st->mode->shortMdctSize;
2280    
2281    ALLOC(out, C*N, celt_int16);
2282    ret=celt_decode_with_ec(st, data, len, out, frame_size, dec);
2283    if (ret==0)
2284       for (j=0;j<C*N;j++)
2285          pcm[j]=out[j]*(1.f/32768.f);
2286      
2287    RESTORE_STACK;
2288    return ret;
2289 }
2290 #endif /*DISABLE_FLOAT_API*/
2291 #else
2292 int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size, ec_dec *dec)
2293 {
2294    int j, ret, C, N, LM, M;
2295    VARDECL(celt_sig, out);
2296    SAVE_STACK;
2297
2298    if (pcm==NULL)
2299       return CELT_BAD_ARG;
2300
2301    for (LM=0;LM<4;LM++)
2302       if (st->mode->shortMdctSize<<LM==frame_size)
2303          break;
2304    if (LM>=MAX_CONFIG_SIZES)
2305       return CELT_BAD_ARG;
2306    M=1<<LM;
2307
2308    C = CHANNELS(st->channels);
2309    N = M*st->mode->shortMdctSize;
2310    ALLOC(out, C*N, celt_sig);
2311
2312    ret=celt_decode_with_ec_float(st, data, len, out, frame_size, dec);
2313
2314    if (ret==0)
2315       for (j=0;j<C*N;j++)
2316          pcm[j] = FLOAT2INT16 (out[j]);
2317    
2318    RESTORE_STACK;
2319    return ret;
2320 }
2321 #endif
2322
2323 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size)
2324 {
2325    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
2326 }
2327
2328 #ifndef DISABLE_FLOAT_API
2329 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size)
2330 {
2331    return celt_decode_with_ec_float(st, data, len, pcm, frame_size, NULL);
2332 }
2333 #endif /* DISABLE_FLOAT_API */
2334
2335 int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
2336 {
2337    va_list ap;
2338
2339    va_start(ap, request);
2340    switch (request)
2341    {
2342       case CELT_GET_MODE_REQUEST:
2343       {
2344          const CELTMode ** value = va_arg(ap, const CELTMode**);
2345          if (value==0)
2346             goto bad_arg;
2347          *value=st->mode;
2348       }
2349       break;
2350       case CELT_SET_START_BAND_REQUEST:
2351       {
2352          celt_int32 value = va_arg(ap, celt_int32);
2353          if (value<0 || value>=st->mode->nbEBands)
2354             goto bad_arg;
2355          st->start = value;
2356       }
2357       break;
2358       case CELT_SET_END_BAND_REQUEST:
2359       {
2360          celt_int32 value = va_arg(ap, celt_int32);
2361          if (value<0 || value>=st->mode->nbEBands)
2362             goto bad_arg;
2363          st->end = value;
2364       }
2365       break;
2366       case CELT_RESET_STATE:
2367       {
2368          CELT_MEMSET((char*)&st->DECODER_RESET_START, 0,
2369                celt_decoder_get_size(st->mode, st->channels)-
2370                ((char*)&st->DECODER_RESET_START - (char*)st));
2371       }
2372       break;
2373       default:
2374          goto bad_request;
2375    }
2376    va_end(ap);
2377    return CELT_OK;
2378 bad_arg:
2379    va_end(ap);
2380    return CELT_BAD_ARG;
2381 bad_request:
2382       va_end(ap);
2383   return CELT_UNIMPLEMENTED;
2384 }
2385
2386 const char *celt_strerror(int error)
2387 {
2388    static const char *error_strings[8] = {
2389       "success",
2390       "invalid argument",
2391       "invalid mode",
2392       "internal error",
2393       "corrupted stream",
2394       "request not implemented",
2395       "invalid state",
2396       "memory allocation failed"
2397    };
2398    if (error > 0 || error < -7)
2399       return "unknown error";
2400    else 
2401       return error_strings[-error];
2402 }
2403