Setting bandE[] to zero after log2Amp when silence=1
[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.30690f, 15), QCONST16(0.21701f, 15), QCONST16(0.12954f, 15)},
410          {QCONST16(0.46410f, 15), QCONST16(0.26795f, 15), QCONST16(0.f, 15)},
411          {QCONST16(0.8f, 15),     QCONST16(0.1f, 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<0 || 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       ec_enc_bit_logp(enc, silence, 15);
928       if (silence)
929       {
930          /*In VBR mode there is no need to send more than the minimum. */
931          if (vbr_rate>0)
932          {
933             effectiveBytes=nbCompressedBytes=nbFilledBytes+2;
934             total_bits=nbCompressedBytes*8;
935             nbAvailableBytes=2;
936             ec_byte_shrink(&buf, nbCompressedBytes);
937          }
938          /* Pretend we've filled all the remaining bits with zeros
939             (that's what the initialiser did anyway) */
940          tell = nbCompressedBytes*8;
941          enc->nbits_total+=tell-ec_enc_tell(enc,0);
942       }
943 #ifdef ENABLE_POSTFILTER
944       if (nbAvailableBytes>12*C && st->start==0 && !silence)
945       {
946          VARDECL(celt_word16, pitch_buf);
947          ALLOC(pitch_buf, (COMBFILTER_MAXPERIOD+N)>>1, celt_word16);
948
949          pitch_downsample(pre, pitch_buf, COMBFILTER_MAXPERIOD+N, C);
950          pitch_search(pitch_buf+(COMBFILTER_MAXPERIOD>>1), pitch_buf, N,
951                COMBFILTER_MAXPERIOD-COMBFILTER_MINPERIOD, &pitch_index);
952          pitch_index = COMBFILTER_MAXPERIOD-pitch_index;
953
954          gain1 = remove_doubling(pitch_buf, COMBFILTER_MAXPERIOD, COMBFILTER_MINPERIOD,
955                N, &pitch_index, st->prefilter_period, st->prefilter_gain);
956          if (pitch_index > COMBFILTER_MAXPERIOD-2)
957             pitch_index = COMBFILTER_MAXPERIOD-2;
958          gain1 = MULT16_16_Q15(QCONST16(.7f,15),gain1);
959          prefilter_tapset = st->tapset_decision;
960       } else {
961          gain1 = 0;
962       }
963
964       /* Gain threshold for enabling the prefilter/postfilter */
965       pf_threshold = QCONST16(.2f,15);
966
967       /* Adjusting the threshold based on rate and continuity */
968       if (abs(pitch_index-st->prefilter_period)*10>pitch_index)
969          pf_threshold += QCONST16(.2f,15);
970       if (nbAvailableBytes<25)
971          pf_threshold += QCONST16(.1f,15);
972       if (nbAvailableBytes<35)
973          pf_threshold += QCONST16(.1f,15);
974       if (st->prefilter_gain > QCONST16(.4f,15))
975          pf_threshold -= QCONST16(.1f,15);
976       if (st->prefilter_gain > QCONST16(.55f,15))
977          pf_threshold -= QCONST16(.1f,15);
978
979       /* Hard threshold at 0.2 */
980       pf_threshold = MAX16(pf_threshold, QCONST16(.2f,15));
981       if (gain1<pf_threshold)
982       {
983          if(st->start==0 && tell+17<=total_bits)
984             ec_enc_bit_logp(enc, 0, 1);
985          gain1 = 0;
986          pf_on = 0;
987       } else {
988          int qg;
989          int octave;
990
991          if (gain1 > QCONST16(.6f,15))
992             gain1 = QCONST16(.6f,15);
993          if (ABS16(gain1-st->prefilter_gain)<QCONST16(.1,15))
994             gain1=st->prefilter_gain;
995
996 #ifdef FIXED_POINT
997          qg = ((gain1+2048)>>12)-2;
998 #else
999          qg = floor(.5+gain1*8)-2;
1000 #endif
1001          ec_enc_bit_logp(enc, 1, 1);
1002          pitch_index += 1;
1003          octave = EC_ILOG(pitch_index)-5;
1004          ec_enc_uint(enc, octave, 6);
1005          ec_enc_bits(enc, pitch_index-(16<<octave), 4+octave);
1006          pitch_index -= 1;
1007          ec_enc_bits(enc, qg, 2);
1008          gain1 = QCONST16(.125f,15)*(qg+2);
1009          ec_enc_icdf(enc, prefilter_tapset, tapset_icdf, 2);
1010          pf_on = 1;
1011       }
1012       /*printf("%d %f\n", pitch_index, gain1);*/
1013 #else /* ENABLE_POSTFILTER */
1014       if(st->start==0 && tell+17<=total_bits)
1015          ec_enc_bit_logp(enc, 0, 1);
1016       pf_on = 0;
1017 #endif /* ENABLE_POSTFILTER */
1018
1019       c=0; do {
1020          st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
1021          CELT_COPY(in+c*(N+st->overlap), st->in_mem+c*(st->overlap), st->overlap);
1022 #ifdef ENABLE_POSTFILTER
1023          comb_filter(in+c*(N+st->overlap)+st->overlap, pre[c]+COMBFILTER_MAXPERIOD,
1024                st->prefilter_period, pitch_index, N, -st->prefilter_gain, -gain1,
1025                st->prefilter_tapset, prefilter_tapset, st->mode->window, st->mode->overlap);
1026 #endif /* ENABLE_POSTFILTER */
1027          CELT_COPY(st->in_mem+c*(st->overlap), in+c*(N+st->overlap)+N, st->overlap);
1028
1029 #ifdef ENABLE_POSTFILTER
1030          if (N>COMBFILTER_MAXPERIOD)
1031          {
1032             CELT_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, pre[c]+N, COMBFILTER_MAXPERIOD);
1033          } else {
1034             CELT_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, prefilter_mem+c*COMBFILTER_MAXPERIOD+N, COMBFILTER_MAXPERIOD-N);
1035             CELT_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD+COMBFILTER_MAXPERIOD-N, pre[c]+COMBFILTER_MAXPERIOD, N);
1036          }
1037 #endif /* ENABLE_POSTFILTER */
1038       } while (++c<C);
1039
1040       RESTORE_STACK;
1041    }
1042
1043 #ifdef RESYNTH
1044    resynth = 1;
1045 #else
1046    resynth = 0;
1047 #endif
1048
1049    isTransient = 0;
1050    shortBlocks = 0;
1051    if (LM>0 && ec_enc_tell(enc, 0)+3<=total_bits)
1052    {
1053       if (st->complexity > 1)
1054       {
1055          isTransient = transient_analysis(in, N+st->overlap, C,
1056                   st->overlap);
1057          if (isTransient)
1058             shortBlocks = M;
1059       }
1060       ec_enc_bit_logp(enc, isTransient, 3);
1061    }
1062
1063    ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
1064    ALLOC(bandE,st->mode->nbEBands*C, celt_ener);
1065    ALLOC(bandLogE,st->mode->nbEBands*C, celt_word16);
1066    /* Compute MDCTs */
1067    compute_mdcts(st->mode, shortBlocks, in, freq, C, LM);
1068
1069    ALLOC(X, C*N, celt_norm);         /**< Interleaved normalised MDCTs */
1070
1071    compute_band_energies(st->mode, freq, bandE, effEnd, C, M);
1072
1073    amp2Log2(st->mode, effEnd, st->end, bandE, bandLogE, C);
1074
1075    /* Band normalisation */
1076    normalise_bands(st->mode, freq, X, bandE, effEnd, C, M);
1077
1078    ALLOC(tf_res, st->mode->nbEBands, int);
1079    /* Needs to be before coarse energy quantization because otherwise the energy gets modified */
1080    tf_select = tf_analysis(st->mode, bandLogE, oldBandE, effEnd, C, isTransient, tf_res, effectiveBytes, X, N, LM, &tf_sum);
1081    for (i=effEnd;i<st->end;i++)
1082       tf_res[i] = tf_res[effEnd-1];
1083
1084    ALLOC(error, C*st->mode->nbEBands, celt_word16);
1085    quant_coarse_energy(st->mode, st->start, st->end, effEnd, bandLogE,
1086          oldBandE, total_bits, error, enc,
1087          C, LM, nbAvailableBytes, st->force_intra,
1088          &st->delayedIntra, st->complexity >= 4);
1089
1090    tf_encode(st->start, st->end, isTransient, tf_res, LM, tf_select, enc);
1091
1092    st->spread_decision = SPREAD_NORMAL;
1093    if (ec_enc_tell(enc, 0)+4<=total_bits)
1094    {
1095       if (shortBlocks || st->complexity < 3 || nbAvailableBytes < 10*C)
1096       {
1097          if (st->complexity == 0)
1098             st->spread_decision = SPREAD_NONE;
1099       } else {
1100          st->spread_decision = spreading_decision(st->mode, X,
1101                &st->tonal_average, st->spread_decision, &st->hf_average,
1102                &st->tapset_decision, pf_on&&!shortBlocks, effEnd, C, M);
1103       }
1104       ec_enc_icdf(enc, st->spread_decision, spread_icdf, 5);
1105    }
1106
1107    ALLOC(offsets, st->mode->nbEBands, int);
1108
1109    for (i=0;i<st->mode->nbEBands;i++)
1110       offsets[i] = 0;
1111    /* Dynamic allocation code */
1112    /* Make sure that dynamic allocation can't make us bust the budget */
1113    if (effectiveBytes > 50 && LM>=1)
1114    {
1115       int t1, t2;
1116       if (LM <= 1)
1117       {
1118          t1 = 3;
1119          t2 = 5;
1120       } else {
1121          t1 = 2;
1122          t2 = 4;
1123       }
1124       for (i=1;i<st->mode->nbEBands-1;i++)
1125       {
1126          celt_word32 d2;
1127          d2 = 2*bandLogE[i]-bandLogE[i-1]-bandLogE[i+1];
1128          if (C==2)
1129             d2 = HALF32(d2 + 2*bandLogE[i+st->mode->nbEBands]-
1130                   bandLogE[i-1+st->mode->nbEBands]-bandLogE[i+1+st->mode->nbEBands]);
1131          if (d2 > SHL16(t1,DB_SHIFT))
1132             offsets[i] += 1;
1133          if (d2 > SHL16(t2,DB_SHIFT))
1134             offsets[i] += 1;
1135       }
1136    }
1137    dynalloc_logp = 6;
1138    total_bits<<=BITRES;
1139    total_boost = 0;
1140    tell = ec_enc_tell(enc, BITRES);
1141    for (i=st->start;i<st->end;i++)
1142    {
1143       int width, quanta;
1144       int dynalloc_loop_logp;
1145       int boost;
1146       int j;
1147       width = C*(st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
1148       /* quanta is 6 bits, but no more than 1 bit/sample
1149          and no less than 1/8 bit/sample */
1150       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
1151       dynalloc_loop_logp = dynalloc_logp;
1152       boost = 0;
1153       for (j = 0; tell+(dynalloc_loop_logp<<BITRES) < total_bits-total_boost
1154             && boost < (64<<LM)*(C<<BITRES); j++)
1155       {
1156          int flag;
1157          flag = j<offsets[i];
1158          ec_enc_bit_logp(enc, flag, dynalloc_loop_logp);
1159          tell = ec_enc_tell(enc, BITRES);
1160          if (!flag)
1161             break;
1162          boost += quanta;
1163          total_boost += quanta;
1164          dynalloc_loop_logp = 1;
1165       }
1166       /* Making dynalloc more likely */
1167       if (j)
1168          dynalloc_logp = IMAX(2, dynalloc_logp-1);
1169       offsets[i] = boost;
1170    }
1171    alloc_trim = 5;
1172    if (tell+(6<<BITRES) <= total_bits - total_boost)
1173    {
1174       alloc_trim = alloc_trim_analysis(st->mode, X, bandLogE,
1175             st->mode->nbEBands, LM, C, N);
1176       ec_enc_icdf(enc, alloc_trim, trim_icdf, 7);
1177       tell = ec_enc_tell(enc, BITRES);
1178    }
1179
1180    /* Variable bitrate */
1181    if (vbr_rate>0)
1182    {
1183      celt_word16 alpha;
1184      celt_int32 delta;
1185      /* The target rate in 8th bits per frame */
1186      celt_int32 target;
1187      celt_int32 min_allowed;
1188
1189      target = vbr_rate + st->vbr_offset - ((40*C+20)<<BITRES);
1190
1191      /* Shortblocks get a large boost in bitrate, but since they
1192         are uncommon long blocks are not greatly affected */
1193      if (shortBlocks || tf_sum < -2*(st->end-st->start))
1194         target = 7*target/4;
1195      else if (tf_sum < -(st->end-st->start))
1196         target = 3*target/2;
1197      else if (M > 1)
1198         target-=(target+14)/28;
1199
1200      /* The current offset is removed from the target and the space used
1201         so far is added*/
1202      target=target+tell;
1203
1204      /* In VBR mode the frame size must not be reduced so much that it would
1205          result in the encoder running out of bits.
1206         The margin of 2 bytes ensures that none of the bust-prevention logic
1207          in the decoder will have triggered so far. */
1208      min_allowed = (tell+total_boost+(1<<BITRES+3)-1>>(BITRES+3)) + 2 - nbFilledBytes;
1209
1210      nbAvailableBytes = target+(1<<(BITRES+2))>>(BITRES+3);
1211      nbAvailableBytes = IMAX(min_allowed,nbAvailableBytes);
1212      nbAvailableBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes) - nbFilledBytes;
1213
1214      if(silence)
1215      {
1216        nbAvailableBytes = 2;
1217        target = 2*8<<BITRES;
1218      }
1219
1220      /* By how much did we "miss" the target on that frame */
1221      delta = target - vbr_rate;
1222
1223      target=nbAvailableBytes<<(BITRES+3);
1224
1225      if (st->vbr_count < 970)
1226      {
1227         st->vbr_count++;
1228         alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+20),16));
1229      } else
1230         alpha = QCONST16(.001f,15);
1231      /* How many bits have we used in excess of what we're allowed */
1232      if (st->constrained_vbr)
1233         st->vbr_reservoir += target - vbr_rate;
1234      /*printf ("%d\n", st->vbr_reservoir);*/
1235
1236      /* Compute the offset we need to apply in order to reach the target */
1237      st->vbr_drift += (celt_int32)MULT16_32_Q15(alpha,delta-st->vbr_offset-st->vbr_drift);
1238      st->vbr_offset = -st->vbr_drift;
1239      /*printf ("%d\n", st->vbr_drift);*/
1240
1241      if (st->constrained_vbr && st->vbr_reservoir < 0)
1242      {
1243         /* We're under the min value -- increase rate */
1244         int adjust = (-st->vbr_reservoir)/(8<<BITRES);
1245         /* Unless we're just coding silence */
1246         nbAvailableBytes += silence?0:adjust;
1247         st->vbr_reservoir = 0;
1248         /*printf ("+%d\n", adjust);*/
1249      }
1250      nbCompressedBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes);
1251      /* This moves the raw bits to take into account the new compressed size */
1252      ec_byte_shrink(&buf, nbCompressedBytes);
1253    }
1254    if (C==2)
1255    {
1256       int effectiveRate;
1257
1258       /* Always use MS for 2.5 ms frames until we can do a better analysis */
1259       if (LM!=0)
1260          dual_stereo = stereo_analysis(st->mode, X, LM, N);
1261
1262       /* Account for coarse energy */
1263       effectiveRate = (8*effectiveBytes - 80)>>LM;
1264
1265       /* effectiveRate in kb/s */
1266       effectiveRate = 2*effectiveRate/5;
1267       if (effectiveRate<35)
1268          intensity = 8;
1269       else if (effectiveRate<50)
1270          intensity = 12;
1271       else if (effectiveRate<68)
1272          intensity = 16;
1273       else if (effectiveRate<84)
1274          intensity = 18;
1275       else if (effectiveRate<102)
1276          intensity = 19;
1277       else if (effectiveRate<130)
1278          intensity = 20;
1279       else
1280          intensity = 100;
1281       intensity = IMIN(st->end,IMAX(st->start, intensity));
1282    }
1283
1284    /* Bit allocation */
1285    ALLOC(fine_quant, st->mode->nbEBands, int);
1286    ALLOC(pulses, st->mode->nbEBands, int);
1287    ALLOC(fine_priority, st->mode->nbEBands, int);
1288
1289    /* bits =   packet size        -       where we are         - safety*/
1290    bits = (nbCompressedBytes*8<<BITRES) - ec_enc_tell(enc, BITRES) - 1;
1291    anti_collapse_rsv = isTransient&&LM>=2&&bits>=(LM+2<<BITRES) ? (1<<BITRES) : 0;
1292    bits -= anti_collapse_rsv;
1293    codedBands = compute_allocation(st->mode, st->start, st->end, offsets,
1294          alloc_trim, &intensity, &dual_stereo, bits, pulses, fine_quant,
1295          fine_priority, C, LM, enc, 1, st->lastCodedBands);
1296    st->lastCodedBands = codedBands;
1297
1298    quant_fine_energy(st->mode, st->start, st->end, oldBandE, error, fine_quant, enc, C);
1299
1300 #ifdef MEASURE_NORM_MSE
1301    float X0[3000];
1302    float bandE0[60];
1303    c=0; do 
1304       for (i=0;i<N;i++)
1305          X0[i+c*N] = X[i+c*N];
1306    while (++c<C);
1307    for (i=0;i<C*st->mode->nbEBands;i++)
1308       bandE0[i] = bandE[i];
1309 #endif
1310
1311    /* Residual quantisation */
1312    ALLOC(collapse_masks, st->mode->nbEBands, unsigned char);
1313    quant_all_bands(1, st->mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
1314          bandE, pulses, shortBlocks, st->spread_decision, dual_stereo, intensity, tf_res, resynth,
1315          nbCompressedBytes*8, enc, LM, codedBands, &st->rng);
1316
1317    if (anti_collapse_rsv > 0)
1318    {
1319       anti_collapse_on = st->consec_transient<2;
1320       ec_enc_bits(enc, anti_collapse_on, 1);
1321    }
1322    quant_energy_finalise(st->mode, st->start, st->end, oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_enc_tell(enc, 0), enc, C);
1323
1324    if (silence)
1325    {
1326       for (i=0;i<C*st->mode->nbEBands;i++)
1327          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
1328    }
1329
1330 #ifdef RESYNTH
1331    /* Re-synthesis of the coded audio if required */
1332    if (resynth)
1333    {
1334       celt_sig *out_mem[2];
1335       celt_sig *overlap_mem[2];
1336
1337       log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
1338       if (silence)
1339       {
1340          for (i=0;i<C*st->mode->nbEBands;i++)
1341             bandE[i] = 0;
1342       }
1343
1344 #ifdef MEASURE_NORM_MSE
1345       measure_norm_mse(st->mode, X, X0, bandE, bandE0, M, N, C);
1346 #endif
1347       if (anti_collapse_on)
1348       {
1349          anti_collapse(st->mode, X, collapse_masks, LM, C, N,
1350                st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
1351       }
1352
1353       /* Synthesis */
1354       denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
1355
1356       CELT_MOVE(st->syn_mem[0], st->syn_mem[0]+N, MAX_PERIOD);
1357       if (C==2)
1358          CELT_MOVE(st->syn_mem[1], st->syn_mem[1]+N, MAX_PERIOD);
1359
1360       c=0; do
1361          for (i=0;i<M*st->mode->eBands[st->start];i++)
1362             freq[c*N+i] = 0;
1363       while (++c<C);
1364       c=0; do
1365          for (i=M*st->mode->eBands[st->end];i<N;i++)
1366             freq[c*N+i] = 0;
1367       while (++c<C);
1368
1369       out_mem[0] = st->syn_mem[0]+MAX_PERIOD;
1370       if (C==2)
1371          out_mem[1] = st->syn_mem[1]+MAX_PERIOD;
1372
1373       c=0; do
1374          overlap_mem[c] = _overlap_mem + c*st->overlap;
1375       while (++c<C);
1376
1377       compute_inv_mdcts(st->mode, shortBlocks, freq, out_mem, overlap_mem, C, LM);
1378
1379 #ifdef ENABLE_POSTFILTER
1380       c=0; do {
1381          st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
1382          st->prefilter_period_old=IMAX(st->prefilter_period_old, COMBFILTER_MINPERIOD);
1383          if (LM!=0)
1384          {
1385             comb_filter(out_mem[c], out_mem[c], st->prefilter_period, st->prefilter_period, st->overlap,
1386                   st->prefilter_gain, st->prefilter_gain, st->prefilter_tapset, st->prefilter_tapset,
1387                   NULL, 0);
1388             comb_filter(out_mem[c]+st->overlap, out_mem[c]+st->overlap, st->prefilter_period, pitch_index, N-st->overlap,
1389                   st->prefilter_gain, gain1, st->prefilter_tapset, prefilter_tapset,
1390                   st->mode->window, st->mode->overlap);
1391          } else {
1392             comb_filter(out_mem[c], out_mem[c], st->prefilter_period_old, st->prefilter_period, N,
1393                   st->prefilter_gain_old, st->prefilter_gain, st->prefilter_tapset_old, st->prefilter_tapset,
1394                   st->mode->window, st->mode->overlap);
1395          }
1396       } while (++c<C);
1397 #endif /* ENABLE_POSTFILTER */
1398
1399       deemphasis(out_mem, (celt_word16*)pcm, N, C, st->mode->preemph, st->preemph_memD);
1400       st->prefilter_period_old = st->prefilter_period;
1401       st->prefilter_gain_old = st->prefilter_gain;
1402       st->prefilter_tapset_old = st->prefilter_tapset;
1403    }
1404 #endif
1405
1406    st->prefilter_period = pitch_index;
1407    st->prefilter_gain = gain1;
1408    st->prefilter_tapset = prefilter_tapset;
1409
1410    /* In case start or end were to change */
1411    c=0; do
1412    {
1413       for (i=0;i<st->start;i++)
1414          oldBandE[c*st->mode->nbEBands+i]=0;
1415       for (i=st->end;i<st->mode->nbEBands;i++)
1416          oldBandE[c*st->mode->nbEBands+i]=0;
1417    } while (++c<C);
1418    if (!isTransient)
1419    {
1420       for (i=0;i<C*st->mode->nbEBands;i++)
1421          oldLogE2[i] = oldLogE[i];
1422       for (i=0;i<C*st->mode->nbEBands;i++)
1423          oldLogE[i] = oldBandE[i];
1424    }
1425    if (isTransient)
1426       st->consec_transient++;
1427    else
1428       st->consec_transient=0;
1429    st->rng = enc->rng;
1430
1431    /* If there's any room left (can only happen for very high rates),
1432       it's already filled with zeros */
1433    ec_enc_done(enc);
1434    
1435    RESTORE_STACK;
1436    if (ec_enc_get_error(enc))
1437       return CELT_CORRUPTED_DATA;
1438    else
1439       return nbCompressedBytes;
1440 }
1441
1442 #ifdef FIXED_POINT
1443 #ifndef DISABLE_FLOAT_API
1444 int celt_encode_with_ec_float(CELTEncoder * restrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
1445 {
1446    int j, ret, C, N, LM, M;
1447    VARDECL(celt_int16, in);
1448    SAVE_STACK;
1449
1450    if (pcm==NULL)
1451       return CELT_BAD_ARG;
1452
1453    for (LM=0;LM<4;LM++)
1454       if (st->mode->shortMdctSize<<LM==frame_size)
1455          break;
1456    if (LM>=MAX_CONFIG_SIZES)
1457       return CELT_BAD_ARG;
1458    M=1<<LM;
1459
1460    C = CHANNELS(st->channels);
1461    N = M*st->mode->shortMdctSize;
1462    ALLOC(in, C*N, celt_int16);
1463
1464    for (j=0;j<C*N;j++)
1465      in[j] = FLOAT2INT16(pcm[j]);
1466
1467    ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, enc);
1468 #ifdef RESYNTH
1469    for (j=0;j<C*N;j++)
1470       ((float*)pcm)[j]=in[j]*(1.f/32768.f);
1471 #endif
1472    RESTORE_STACK;
1473    return ret;
1474
1475 }
1476 #endif /*DISABLE_FLOAT_API*/
1477 #else
1478 int celt_encode_with_ec(CELTEncoder * restrict st, const celt_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
1479 {
1480    int j, ret, C, N, LM, M;
1481    VARDECL(celt_sig, in);
1482    SAVE_STACK;
1483
1484    if (pcm==NULL)
1485       return CELT_BAD_ARG;
1486
1487    for (LM=0;LM<4;LM++)
1488       if (st->mode->shortMdctSize<<LM==frame_size)
1489          break;
1490    if (LM>=MAX_CONFIG_SIZES)
1491       return CELT_BAD_ARG;
1492    M=1<<LM;
1493
1494    C=CHANNELS(st->channels);
1495    N=M*st->mode->shortMdctSize;
1496    ALLOC(in, C*N, celt_sig);
1497    for (j=0;j<C*N;j++) {
1498      in[j] = SCALEOUT(pcm[j]);
1499    }
1500
1501    ret = celt_encode_with_ec_float(st,in,frame_size,compressed,nbCompressedBytes, enc);
1502 #ifdef RESYNTH
1503    for (j=0;j<C*N;j++)
1504       ((celt_int16*)pcm)[j] = FLOAT2INT16(in[j]);
1505 #endif
1506    RESTORE_STACK;
1507    return ret;
1508 }
1509 #endif
1510
1511 int celt_encode(CELTEncoder * restrict st, const celt_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1512 {
1513    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1514 }
1515
1516 #ifndef DISABLE_FLOAT_API
1517 int celt_encode_float(CELTEncoder * restrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1518 {
1519    return celt_encode_with_ec_float(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1520 }
1521 #endif /* DISABLE_FLOAT_API */
1522
1523 int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
1524 {
1525    va_list ap;
1526    
1527    va_start(ap, request);
1528    switch (request)
1529    {
1530       case CELT_GET_MODE_REQUEST:
1531       {
1532          const CELTMode ** value = va_arg(ap, const CELTMode**);
1533          if (value==0)
1534             goto bad_arg;
1535          *value=st->mode;
1536       }
1537       break;
1538       case CELT_SET_COMPLEXITY_REQUEST:
1539       {
1540          int value = va_arg(ap, celt_int32);
1541          if (value<0 || value>10)
1542             goto bad_arg;
1543          st->complexity = value;
1544       }
1545       break;
1546       case CELT_SET_START_BAND_REQUEST:
1547       {
1548          celt_int32 value = va_arg(ap, celt_int32);
1549          if (value<0 || value>=st->mode->nbEBands)
1550             goto bad_arg;
1551          st->start = value;
1552       }
1553       break;
1554       case CELT_SET_END_BAND_REQUEST:
1555       {
1556          celt_int32 value = va_arg(ap, celt_int32);
1557          if (value<1 || value>st->mode->nbEBands)
1558             goto bad_arg;
1559          st->end = value;
1560       }
1561       break;
1562       case CELT_SET_PREDICTION_REQUEST:
1563       {
1564          int value = va_arg(ap, celt_int32);
1565          if (value<0 || value>2)
1566             goto bad_arg;
1567          if (value==0)
1568          {
1569             st->force_intra   = 1;
1570          } else if (value==1) {
1571             st->force_intra   = 0;
1572          } else {
1573             st->force_intra   = 0;
1574          }   
1575       }
1576       break;
1577       case CELT_SET_VBR_CONSTRAINT_REQUEST:
1578       {
1579          celt_int32 value = va_arg(ap, celt_int32);
1580          st->constrained_vbr = value;
1581       }
1582       break;
1583       case CELT_SET_VBR_RATE_REQUEST:
1584       {
1585          celt_int32 value = va_arg(ap, celt_int32);
1586          int frame_rate;
1587          int N = st->mode->shortMdctSize;
1588          if (value<0)
1589             goto bad_arg;
1590          if (value>3072000)
1591             value = 3072000;
1592          frame_rate = ((st->mode->Fs<<3)+(N>>1))/N;
1593          st->vbr_rate_norm = ((value<<(BITRES+3))+(frame_rate>>1))/frame_rate;
1594       }
1595       break;
1596       case CELT_RESET_STATE:
1597       {
1598          CELT_MEMSET((char*)&st->ENCODER_RESET_START, 0,
1599                celt_encoder_get_size(st->mode, st->channels)-
1600                ((char*)&st->ENCODER_RESET_START - (char*)st));
1601          st->vbr_offset = 0;
1602          st->delayedIntra = 1;
1603          st->spread_decision = SPREAD_NORMAL;
1604          st->tonal_average = QCONST16(1.f,8);
1605       }
1606       break;
1607       default:
1608          goto bad_request;
1609    }
1610    va_end(ap);
1611    return CELT_OK;
1612 bad_arg:
1613    va_end(ap);
1614    return CELT_BAD_ARG;
1615 bad_request:
1616    va_end(ap);
1617    return CELT_UNIMPLEMENTED;
1618 }
1619
1620 /**********************************************************************/
1621 /*                                                                    */
1622 /*                             DECODER                                */
1623 /*                                                                    */
1624 /**********************************************************************/
1625 #define DECODE_BUFFER_SIZE 2048
1626
1627 /** Decoder state 
1628  @brief Decoder state
1629  */
1630 struct CELTDecoder {
1631    const CELTMode *mode;
1632    int overlap;
1633    int channels;
1634
1635    int start, end;
1636
1637    /* Everything beyond this point gets cleared on a reset */
1638 #define DECODER_RESET_START rng
1639
1640    ec_uint32 rng;
1641    int last_pitch_index;
1642    int loss_count;
1643    int postfilter_period;
1644    int postfilter_period_old;
1645    celt_word16 postfilter_gain;
1646    celt_word16 postfilter_gain_old;
1647    int postfilter_tapset;
1648    int postfilter_tapset_old;
1649
1650    celt_sig preemph_memD[2];
1651    
1652    celt_sig _decode_mem[1]; /* Size = channels*(DECODE_BUFFER_SIZE+mode->overlap) */
1653    /* celt_word16 lpc[],  Size = channels*LPC_ORDER */
1654    /* celt_word16 oldEBands[], Size = channels*mode->nbEBands */
1655    /* celt_word16 oldLogE[], Size = channels*mode->nbEBands */
1656    /* celt_word16 oldLogE2[], Size = channels*mode->nbEBands */
1657    /* celt_word16 backgroundLogE[], Size = channels*mode->nbEBands */
1658 };
1659
1660 int celt_decoder_get_size(const CELTMode *mode, int channels)
1661 {
1662    int size = sizeof(struct CELTDecoder)
1663             + (channels*(DECODE_BUFFER_SIZE+mode->overlap)-1)*sizeof(celt_sig)
1664             + channels*LPC_ORDER*sizeof(celt_word16)
1665             + 4*channels*mode->nbEBands*sizeof(celt_word16);
1666    return size;
1667 }
1668
1669 CELTDecoder *celt_decoder_create(const CELTMode *mode, int channels, int *error)
1670 {
1671    return celt_decoder_init(
1672          (CELTDecoder *)celt_alloc(celt_decoder_get_size(mode, channels)),
1673          mode, channels, error);
1674 }
1675
1676 CELTDecoder *celt_decoder_init(CELTDecoder *st, const CELTMode *mode, int channels, int *error)
1677 {
1678    if (channels < 0 || channels > 2)
1679    {
1680       if (error)
1681          *error = CELT_BAD_ARG;
1682       return NULL;
1683    }
1684
1685    if (st==NULL)
1686    {
1687       if (error)
1688          *error = CELT_ALLOC_FAIL;
1689       return NULL;
1690    }
1691
1692    CELT_MEMSET((char*)st, 0, celt_decoder_get_size(mode, channels));
1693
1694    st->mode = mode;
1695    st->overlap = mode->overlap;
1696    st->channels = channels;
1697
1698    st->start = 0;
1699    st->end = st->mode->effEBands;
1700
1701    st->loss_count = 0;
1702
1703    if (error)
1704       *error = CELT_OK;
1705    return st;
1706 }
1707
1708 void celt_decoder_destroy(CELTDecoder *st)
1709 {
1710    celt_free(st);
1711 }
1712
1713 static void celt_decode_lost(CELTDecoder * restrict st, celt_word16 * restrict pcm, int N, int LM)
1714 {
1715    int c;
1716    int pitch_index;
1717    int overlap = st->mode->overlap;
1718    celt_word16 fade = Q15ONE;
1719    int i, len;
1720    const int C = CHANNELS(st->channels);
1721    int offset;
1722    celt_sig *out_mem[2];
1723    celt_sig *decode_mem[2];
1724    celt_sig *overlap_mem[2];
1725    celt_word16 *lpc;
1726    celt_word32 *out_syn[2];
1727    celt_word16 *oldBandE, *oldLogE2, *backgroundLogE;
1728    SAVE_STACK;
1729    
1730    c=0; do {
1731       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
1732       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
1733       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
1734    } while (++c<C);
1735    lpc = (celt_word16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*C);
1736    oldBandE = lpc+C*LPC_ORDER;
1737    oldLogE2 = oldBandE + C*st->mode->nbEBands;
1738    backgroundLogE = oldLogE2  + C*st->mode->nbEBands;
1739
1740    out_syn[0] = out_mem[0]+MAX_PERIOD-N;
1741    if (C==2)
1742       out_syn[1] = out_mem[1]+MAX_PERIOD-N;
1743
1744    len = N+st->mode->overlap;
1745    
1746    if (st->loss_count >= 5)
1747    {
1748       VARDECL(celt_sig, freq);
1749       VARDECL(celt_norm, X);
1750       VARDECL(celt_ener, bandE);
1751       celt_uint32 seed;
1752
1753       ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
1754       ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
1755       ALLOC(bandE, st->mode->nbEBands*C, celt_ener);
1756
1757       log2Amp(st->mode, st->start, st->end, bandE, backgroundLogE, C);
1758
1759       seed = st->rng;
1760       for (i=0;i<C*N;i++)
1761       {
1762             seed = lcg_rand(seed);
1763             X[i] = (celt_int32)(seed)>>20;
1764       }
1765       st->rng = seed;
1766       for (c=0;c<C;c++)
1767          for (i=0;i<st->mode->nbEBands;i++)
1768             renormalise_vector(X+N*c+(st->mode->eBands[i]<<LM), (st->mode->eBands[i+1]-st->mode->eBands[i])<<LM, Q15ONE);
1769
1770       denormalise_bands(st->mode, X, freq, bandE, st->mode->nbEBands, C, 1<<LM);
1771
1772       compute_inv_mdcts(st->mode, 0, freq, out_syn, overlap_mem, C, LM);
1773    } else if (st->loss_count == 0)
1774    {
1775       celt_word16 pitch_buf[MAX_PERIOD>>1];
1776       int len2 = len;
1777       /* FIXME: This is a kludge */
1778       if (len2>MAX_PERIOD>>1)
1779          len2 = MAX_PERIOD>>1;
1780       pitch_downsample(out_mem, pitch_buf, MAX_PERIOD, C);
1781       pitch_search(pitch_buf+((MAX_PERIOD-len2)>>1), pitch_buf, len2,
1782                    MAX_PERIOD-len2-100, &pitch_index);
1783       pitch_index = MAX_PERIOD-len2-pitch_index;
1784       st->last_pitch_index = pitch_index;
1785    } else {
1786       pitch_index = st->last_pitch_index;
1787       fade = QCONST16(.8f,15);
1788    }
1789
1790    c=0; do {
1791       /* FIXME: This is more memory than necessary */
1792       celt_word32 e[2*MAX_PERIOD];
1793       celt_word16 exc[2*MAX_PERIOD];
1794       celt_word32 ac[LPC_ORDER+1];
1795       celt_word16 decay = 1;
1796       celt_word32 S1=0;
1797       celt_word16 mem[LPC_ORDER]={0};
1798
1799       offset = MAX_PERIOD-pitch_index;
1800       for (i=0;i<MAX_PERIOD;i++)
1801          exc[i] = ROUND16(out_mem[c][i], SIG_SHIFT);
1802
1803       if (st->loss_count == 0)
1804       {
1805          _celt_autocorr(exc, ac, st->mode->window, st->mode->overlap,
1806                         LPC_ORDER, MAX_PERIOD);
1807
1808          /* Noise floor -40 dB */
1809 #ifdef FIXED_POINT
1810          ac[0] += SHR32(ac[0],13);
1811 #else
1812          ac[0] *= 1.0001f;
1813 #endif
1814          /* Lag windowing */
1815          for (i=1;i<=LPC_ORDER;i++)
1816          {
1817             /*ac[i] *= exp(-.5*(2*M_PI*.002*i)*(2*M_PI*.002*i));*/
1818 #ifdef FIXED_POINT
1819             ac[i] -= MULT16_32_Q15(2*i*i, ac[i]);
1820 #else
1821             ac[i] -= ac[i]*(.008f*i)*(.008f*i);
1822 #endif
1823          }
1824
1825          _celt_lpc(lpc+c*LPC_ORDER, ac, LPC_ORDER);
1826       }
1827       for (i=0;i<LPC_ORDER;i++)
1828          mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT);
1829       fir(exc, lpc+c*LPC_ORDER, exc, MAX_PERIOD, LPC_ORDER, mem);
1830       /*for (i=0;i<MAX_PERIOD;i++)printf("%d ", exc[i]); printf("\n");*/
1831       /* Check if the waveform is decaying (and if so how fast) */
1832       {
1833          celt_word32 E1=1, E2=1;
1834          int period;
1835          if (pitch_index <= MAX_PERIOD/2)
1836             period = pitch_index;
1837          else
1838             period = MAX_PERIOD/2;
1839          for (i=0;i<period;i++)
1840          {
1841             E1 += SHR32(MULT16_16(exc[MAX_PERIOD-period+i],exc[MAX_PERIOD-period+i]),8);
1842             E2 += SHR32(MULT16_16(exc[MAX_PERIOD-2*period+i],exc[MAX_PERIOD-2*period+i]),8);
1843          }
1844          if (E1 > E2)
1845             E1 = E2;
1846          decay = celt_sqrt(frac_div32(SHR(E1,1),E2));
1847       }
1848
1849       /* Copy excitation, taking decay into account */
1850       for (i=0;i<len+st->mode->overlap;i++)
1851       {
1852          celt_word16 tmp;
1853          if (offset+i >= MAX_PERIOD)
1854          {
1855             offset -= pitch_index;
1856             decay = MULT16_16_Q15(decay, decay);
1857          }
1858          e[i] = SHL32(EXTEND32(MULT16_16_Q15(decay, exc[offset+i])), SIG_SHIFT);
1859          tmp = ROUND16(out_mem[c][offset+i],SIG_SHIFT);
1860          S1 += SHR32(MULT16_16(tmp,tmp),8);
1861       }
1862       for (i=0;i<LPC_ORDER;i++)
1863          mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT);
1864       for (i=0;i<len+st->mode->overlap;i++)
1865          e[i] = MULT16_32_Q15(fade, e[i]);
1866       iir(e, lpc+c*LPC_ORDER, e, len+st->mode->overlap, LPC_ORDER, mem);
1867
1868       {
1869          celt_word32 S2=0;
1870          for (i=0;i<len+overlap;i++)
1871          {
1872             celt_word16 tmp = ROUND16(e[i],SIG_SHIFT);
1873             S2 += SHR32(MULT16_16(tmp,tmp),8);
1874          }
1875          /* This checks for an "explosion" in the synthesis */
1876 #ifdef FIXED_POINT
1877          if (!(S1 > SHR32(S2,2)))
1878 #else
1879          /* Float test is written this way to catch NaNs at the same time */
1880          if (!(S1 > 0.2f*S2))
1881 #endif
1882          {
1883             for (i=0;i<len+overlap;i++)
1884                e[i] = 0;
1885          } else if (S1 < S2)
1886          {
1887             celt_word16 ratio = celt_sqrt(frac_div32(SHR32(S1,1)+1,S2+1));
1888             for (i=0;i<len+overlap;i++)
1889                e[i] = MULT16_32_Q15(ratio, e[i]);
1890          }
1891       }
1892
1893 #ifdef ENABLE_POSTFILTER
1894       /* Apply post-filter to the MDCT overlap of the previous frame */
1895       comb_filter(out_mem[c]+MAX_PERIOD, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap,
1896                   st->postfilter_gain, st->postfilter_gain, st->postfilter_tapset, st->postfilter_tapset,
1897                   NULL, 0);
1898 #endif /* ENABLE_POSTFILTER */
1899
1900       for (i=0;i<MAX_PERIOD+st->mode->overlap-N;i++)
1901          out_mem[c][i] = out_mem[c][N+i];
1902
1903       /* Apply TDAC to the concealed audio so that it blends with the
1904          previous and next frames */
1905       for (i=0;i<overlap/2;i++)
1906       {
1907          celt_word32 tmp;
1908          tmp = MULT16_32_Q15(st->mode->window[i],           e[N+overlap-1-i]) +
1909                MULT16_32_Q15(st->mode->window[overlap-i-1], e[N+i          ]);
1910          out_mem[c][MAX_PERIOD+i] = MULT16_32_Q15(st->mode->window[overlap-i-1], tmp);
1911          out_mem[c][MAX_PERIOD+overlap-i-1] = MULT16_32_Q15(st->mode->window[i], tmp);
1912       }
1913       for (i=0;i<N;i++)
1914          out_mem[c][MAX_PERIOD-N+i] = e[i];
1915
1916 #ifdef ENABLE_POSTFILTER
1917       /* Apply pre-filter to the MDCT overlap for the next frame (post-filter will be applied then) */
1918       comb_filter(e, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap,
1919                   -st->postfilter_gain, -st->postfilter_gain, st->postfilter_tapset, st->postfilter_tapset,
1920                   NULL, 0);
1921 #endif /* ENABLE_POSTFILTER */
1922       for (i=0;i<overlap;i++)
1923          out_mem[c][MAX_PERIOD+i] = e[i];
1924    } while (++c<C);
1925
1926    deemphasis(out_syn, pcm, N, C, st->mode->preemph, st->preemph_memD);
1927    
1928    st->loss_count++;
1929
1930    RESTORE_STACK;
1931 }
1932
1933 #ifdef FIXED_POINT
1934 int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size, ec_dec *dec)
1935 {
1936 #else
1937 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)
1938 {
1939 #endif
1940    int c, i, N;
1941    int spread_decision;
1942    int bits;
1943    ec_dec _dec;
1944    ec_byte_buffer buf;
1945    VARDECL(celt_sig, freq);
1946    VARDECL(celt_norm, X);
1947    VARDECL(celt_ener, bandE);
1948    VARDECL(int, fine_quant);
1949    VARDECL(int, pulses);
1950    VARDECL(int, offsets);
1951    VARDECL(int, fine_priority);
1952    VARDECL(int, tf_res);
1953    VARDECL(unsigned char, collapse_masks);
1954    celt_sig *out_mem[2];
1955    celt_sig *decode_mem[2];
1956    celt_sig *overlap_mem[2];
1957    celt_sig *out_syn[2];
1958    celt_word16 *lpc;
1959    celt_word16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE;
1960
1961    int shortBlocks;
1962    int isTransient;
1963    int intra_ener;
1964    const int C = CHANNELS(st->channels);
1965    int LM, M;
1966    int effEnd;
1967    int codedBands;
1968    int alloc_trim;
1969    int postfilter_pitch;
1970    celt_word16 postfilter_gain;
1971    int intensity=0;
1972    int dual_stereo=0;
1973    celt_int32 total_bits;
1974    celt_int32 tell;
1975    int dynalloc_logp;
1976    int postfilter_tapset;
1977    int anti_collapse_rsv;
1978    int anti_collapse_on=0;
1979    int silence;
1980
1981    SAVE_STACK;
1982
1983    if (pcm==NULL)
1984       return CELT_BAD_ARG;
1985
1986    for (LM=0;LM<4;LM++)
1987       if (st->mode->shortMdctSize<<LM==frame_size)
1988          break;
1989    if (LM>=MAX_CONFIG_SIZES)
1990       return CELT_BAD_ARG;
1991    M=1<<LM;
1992
1993    c=0; do {
1994       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
1995       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
1996       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
1997    } while (++c<C);
1998    lpc = (celt_word16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*C);
1999    oldBandE = lpc+C*LPC_ORDER;
2000    oldLogE = oldBandE + C*st->mode->nbEBands;
2001    oldLogE2 = oldLogE + C*st->mode->nbEBands;
2002    backgroundLogE = oldLogE2  + C*st->mode->nbEBands;
2003
2004    N = M*st->mode->shortMdctSize;
2005
2006    effEnd = st->end;
2007    if (effEnd > st->mode->effEBands)
2008       effEnd = st->mode->effEBands;
2009
2010    ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
2011    ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
2012    ALLOC(bandE, st->mode->nbEBands*C, celt_ener);
2013    c=0; do
2014       for (i=0;i<M*st->mode->eBands[st->start];i++)
2015          X[c*N+i] = 0;
2016    while (++c<C);
2017    c=0; do   
2018       for (i=M*st->mode->eBands[effEnd];i<N;i++)
2019          X[c*N+i] = 0;
2020    while (++c<C);
2021
2022    if (data == NULL)
2023    {
2024       celt_decode_lost(st, pcm, N, LM);
2025       RESTORE_STACK;
2026       return CELT_OK;
2027    }
2028    if (len<0) {
2029      RESTORE_STACK;
2030      return CELT_BAD_ARG;
2031    }
2032    
2033    if (dec == NULL)
2034    {
2035       ec_byte_readinit(&buf,(unsigned char*)data,len);
2036       ec_dec_init(&_dec,&buf);
2037       dec = &_dec;
2038    }
2039
2040    total_bits = len*8;
2041    tell = ec_dec_tell(dec, 0);
2042
2043    silence = ec_dec_bit_logp(dec, 15);
2044    if (silence)
2045    {
2046       /* Pretend we've read all the remaining bits */
2047       tell = len*8;
2048       dec->nbits_total+=tell-ec_dec_tell(dec,0);
2049    }
2050
2051    postfilter_gain = 0;
2052    postfilter_pitch = 0;
2053    postfilter_tapset = 0;
2054    if (st->start==0 && tell+17 <= total_bits)
2055    {
2056       if(ec_dec_bit_logp(dec, 1))
2057       {
2058 #ifdef ENABLE_POSTFILTER
2059          int qg, octave;
2060          octave = ec_dec_uint(dec, 6);
2061          postfilter_pitch = (16<<octave)+ec_dec_bits(dec, 4+octave)-1;
2062          qg = ec_dec_bits(dec, 2);
2063          postfilter_tapset = ec_dec_icdf(dec, tapset_icdf, 2);
2064          postfilter_gain = QCONST16(.125f,15)*(qg+2);
2065 #else /* ENABLE_POSTFILTER */
2066          RESTORE_STACK;
2067          return CELT_CORRUPTED_DATA;
2068 #endif /* ENABLE_POSTFILTER */
2069       }
2070       tell = ec_dec_tell(dec, 0);
2071    }
2072
2073    if (LM > 0 && tell+3 <= total_bits)
2074    {
2075       isTransient = ec_dec_bit_logp(dec, 3);
2076       tell = ec_dec_tell(dec, 0);
2077    }
2078    else
2079       isTransient = 0;
2080
2081    if (isTransient)
2082       shortBlocks = M;
2083    else
2084       shortBlocks = 0;
2085
2086    /* Decode the global flags (first symbols in the stream) */
2087    intra_ener = tell+3<=total_bits ? ec_dec_bit_logp(dec, 3) : 0;
2088    /* Get band energies */
2089    unquant_coarse_energy(st->mode, st->start, st->end, oldBandE,
2090          intra_ener, dec, C, LM);
2091
2092    ALLOC(tf_res, st->mode->nbEBands, int);
2093    tf_decode(st->start, st->end, isTransient, tf_res, LM, dec);
2094
2095    tell = ec_dec_tell(dec, 0);
2096    spread_decision = SPREAD_NORMAL;
2097    if (tell+4 <= total_bits)
2098       spread_decision = ec_dec_icdf(dec, spread_icdf, 5);
2099
2100    ALLOC(pulses, st->mode->nbEBands, int);
2101    ALLOC(offsets, st->mode->nbEBands, int);
2102    ALLOC(fine_priority, st->mode->nbEBands, int);
2103
2104    dynalloc_logp = 6;
2105    total_bits<<=BITRES;
2106    tell = ec_dec_tell(dec, BITRES);
2107    for (i=st->start;i<st->end;i++)
2108    {
2109       int width, quanta;
2110       int dynalloc_loop_logp;
2111       int boost;
2112       width = C*(st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
2113       /* quanta is 6 bits, but no more than 1 bit/sample
2114          and no less than 1/8 bit/sample */
2115       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
2116       dynalloc_loop_logp = dynalloc_logp;
2117       boost = 0;
2118       while (tell+(dynalloc_loop_logp<<BITRES) < total_bits &&
2119             boost < (64<<LM)*(C<<BITRES))
2120       {
2121          int flag;
2122          flag = ec_dec_bit_logp(dec, dynalloc_loop_logp);
2123          tell = ec_dec_tell(dec, BITRES);
2124          if (!flag)
2125             break;
2126          boost += quanta;
2127          total_bits -= quanta;
2128          dynalloc_loop_logp = 1;
2129       }
2130       offsets[i] = boost;
2131       /* Making dynalloc more likely */
2132       if (boost>0)
2133          dynalloc_logp = IMAX(2, dynalloc_logp-1);
2134    }
2135
2136    ALLOC(fine_quant, st->mode->nbEBands, int);
2137    alloc_trim = tell+(6<<BITRES) <= total_bits ?
2138          ec_dec_icdf(dec, trim_icdf, 7) : 5;
2139
2140    bits = (len*8<<BITRES) - ec_dec_tell(dec, BITRES) - 1;
2141    anti_collapse_rsv = isTransient&&LM>=2&&bits>=(LM+2<<BITRES) ? (1<<BITRES) : 0;
2142    bits -= anti_collapse_rsv;
2143    codedBands = compute_allocation(st->mode, st->start, st->end, offsets,
2144          alloc_trim, &intensity, &dual_stereo, bits, pulses, fine_quant,
2145          fine_priority, C, LM, dec, 0, 0);
2146    
2147    unquant_fine_energy(st->mode, st->start, st->end, oldBandE, fine_quant, dec, C);
2148
2149    /* Decode fixed codebook */
2150    ALLOC(collapse_masks, st->mode->nbEBands, unsigned char);
2151    quant_all_bands(0, st->mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
2152          NULL, pulses, shortBlocks, spread_decision, dual_stereo, intensity, tf_res, 1,
2153          len*8, dec, LM, codedBands, &st->rng);
2154
2155    if (anti_collapse_rsv > 0)
2156    {
2157       anti_collapse_on = ec_dec_bits(dec, 1);
2158    }
2159
2160    unquant_energy_finalise(st->mode, st->start, st->end, oldBandE,
2161          fine_quant, fine_priority, len*8-ec_dec_tell(dec, 0), dec, C);
2162
2163    if (anti_collapse_on)
2164       anti_collapse(st->mode, X, collapse_masks, LM, C, N,
2165             st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
2166
2167    log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
2168
2169    if (silence)
2170    {
2171       for (i=0;i<C*st->mode->nbEBands;i++)
2172       {
2173          bandE[i] = 0;
2174          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
2175       }
2176    }
2177    /* Synthesis */
2178    denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
2179
2180    CELT_MOVE(decode_mem[0], decode_mem[0]+N, DECODE_BUFFER_SIZE-N);
2181    if (C==2)
2182       CELT_MOVE(decode_mem[1], decode_mem[1]+N, DECODE_BUFFER_SIZE-N);
2183
2184    c=0; do
2185       for (i=0;i<M*st->mode->eBands[st->start];i++)
2186          freq[c*N+i] = 0;
2187    while (++c<C);
2188    c=0; do
2189       for (i=M*st->mode->eBands[effEnd];i<N;i++)
2190          freq[c*N+i] = 0;
2191    while (++c<C);
2192
2193    out_syn[0] = out_mem[0]+MAX_PERIOD-N;
2194    if (C==2)
2195       out_syn[1] = out_mem[1]+MAX_PERIOD-N;
2196
2197    /* Compute inverse MDCTs */
2198    compute_inv_mdcts(st->mode, shortBlocks, freq, out_syn, overlap_mem, C, LM);
2199
2200 #ifdef ENABLE_POSTFILTER
2201    c=0; do {
2202       st->postfilter_period=IMAX(st->postfilter_period, COMBFILTER_MINPERIOD);
2203       st->postfilter_period_old=IMAX(st->postfilter_period_old, COMBFILTER_MINPERIOD);
2204       if (LM!=0)
2205       {
2206          comb_filter(out_syn[c], out_syn[c], st->postfilter_period, st->postfilter_period, st->overlap,
2207                st->postfilter_gain, st->postfilter_gain, st->postfilter_tapset, st->postfilter_tapset,
2208                NULL, 0);
2209          comb_filter(out_syn[c]+st->overlap, out_syn[c]+st->overlap, st->postfilter_period, postfilter_pitch, N-st->overlap,
2210                st->postfilter_gain, postfilter_gain, st->postfilter_tapset, postfilter_tapset,
2211                st->mode->window, st->mode->overlap);
2212       } else {
2213          comb_filter(out_syn[c], out_syn[c], st->postfilter_period_old, st->postfilter_period, N-st->overlap,
2214                st->postfilter_gain_old, st->postfilter_gain, st->postfilter_tapset_old, st->postfilter_tapset,
2215                st->mode->window, st->mode->overlap);
2216       }
2217    } while (++c<C);
2218    st->postfilter_period_old = st->postfilter_period;
2219    st->postfilter_gain_old = st->postfilter_gain;
2220    st->postfilter_tapset_old = st->postfilter_tapset;
2221    st->postfilter_period = postfilter_pitch;
2222    st->postfilter_gain = postfilter_gain;
2223    st->postfilter_tapset = postfilter_tapset;
2224 #endif /* ENABLE_POSTFILTER */
2225
2226    /* In case start or end were to change */
2227    c=0; do
2228    {
2229       for (i=0;i<st->start;i++)
2230          oldBandE[c*st->mode->nbEBands+i]=0;
2231       for (i=st->end;i<st->mode->nbEBands;i++)
2232          oldBandE[c*st->mode->nbEBands+i]=0;
2233    } while (++c<C);
2234    if (!isTransient)
2235    {
2236       for (i=0;i<C*st->mode->nbEBands;i++)
2237          oldLogE2[i] = oldLogE[i];
2238       for (i=0;i<C*st->mode->nbEBands;i++)
2239          oldLogE[i] = oldBandE[i];
2240       for (i=0;i<C*st->mode->nbEBands;i++)
2241          backgroundLogE[i] = MIN16(backgroundLogE[i] + M*QCONST16(0.001f,DB_SHIFT), oldBandE[i]);
2242    }
2243    st->rng = dec->rng;
2244
2245    deemphasis(out_syn, pcm, N, C, st->mode->preemph, st->preemph_memD);
2246    st->loss_count = 0;
2247    RESTORE_STACK;
2248    if (ec_dec_tell(dec,0) > 8*len || ec_dec_get_error(dec))
2249       return CELT_CORRUPTED_DATA;
2250    else
2251       return CELT_OK;
2252 }
2253
2254 #ifdef FIXED_POINT
2255 #ifndef DISABLE_FLOAT_API
2256 int celt_decode_with_ec_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size, ec_dec *dec)
2257 {
2258    int j, ret, C, N, LM, M;
2259    VARDECL(celt_int16, out);
2260    SAVE_STACK;
2261
2262    if (pcm==NULL)
2263       return CELT_BAD_ARG;
2264
2265    for (LM=0;LM<4;LM++)
2266       if (st->mode->shortMdctSize<<LM==frame_size)
2267          break;
2268    if (LM>=MAX_CONFIG_SIZES)
2269       return CELT_BAD_ARG;
2270    M=1<<LM;
2271
2272    C = CHANNELS(st->channels);
2273    N = M*st->mode->shortMdctSize;
2274    
2275    ALLOC(out, C*N, celt_int16);
2276    ret=celt_decode_with_ec(st, data, len, out, frame_size, dec);
2277    if (ret==0)
2278       for (j=0;j<C*N;j++)
2279          pcm[j]=out[j]*(1.f/32768.f);
2280      
2281    RESTORE_STACK;
2282    return ret;
2283 }
2284 #endif /*DISABLE_FLOAT_API*/
2285 #else
2286 int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size, ec_dec *dec)
2287 {
2288    int j, ret, C, N, LM, M;
2289    VARDECL(celt_sig, out);
2290    SAVE_STACK;
2291
2292    if (pcm==NULL)
2293       return CELT_BAD_ARG;
2294
2295    for (LM=0;LM<4;LM++)
2296       if (st->mode->shortMdctSize<<LM==frame_size)
2297          break;
2298    if (LM>=MAX_CONFIG_SIZES)
2299       return CELT_BAD_ARG;
2300    M=1<<LM;
2301
2302    C = CHANNELS(st->channels);
2303    N = M*st->mode->shortMdctSize;
2304    ALLOC(out, C*N, celt_sig);
2305
2306    ret=celt_decode_with_ec_float(st, data, len, out, frame_size, dec);
2307
2308    if (ret==0)
2309       for (j=0;j<C*N;j++)
2310          pcm[j] = FLOAT2INT16 (out[j]);
2311    
2312    RESTORE_STACK;
2313    return ret;
2314 }
2315 #endif
2316
2317 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size)
2318 {
2319    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
2320 }
2321
2322 #ifndef DISABLE_FLOAT_API
2323 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size)
2324 {
2325    return celt_decode_with_ec_float(st, data, len, pcm, frame_size, NULL);
2326 }
2327 #endif /* DISABLE_FLOAT_API */
2328
2329 int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
2330 {
2331    va_list ap;
2332
2333    va_start(ap, request);
2334    switch (request)
2335    {
2336       case CELT_GET_MODE_REQUEST:
2337       {
2338          const CELTMode ** value = va_arg(ap, const CELTMode**);
2339          if (value==0)
2340             goto bad_arg;
2341          *value=st->mode;
2342       }
2343       break;
2344       case CELT_SET_START_BAND_REQUEST:
2345       {
2346          celt_int32 value = va_arg(ap, celt_int32);
2347          if (value<0 || value>=st->mode->nbEBands)
2348             goto bad_arg;
2349          st->start = value;
2350       }
2351       break;
2352       case CELT_SET_END_BAND_REQUEST:
2353       {
2354          celt_int32 value = va_arg(ap, celt_int32);
2355          if (value<0 || value>=st->mode->nbEBands)
2356             goto bad_arg;
2357          st->end = value;
2358       }
2359       break;
2360       case CELT_RESET_STATE:
2361       {
2362          CELT_MEMSET((char*)&st->DECODER_RESET_START, 0,
2363                celt_decoder_get_size(st->mode, st->channels)-
2364                ((char*)&st->DECODER_RESET_START - (char*)st));
2365       }
2366       break;
2367       default:
2368          goto bad_request;
2369    }
2370    va_end(ap);
2371    return CELT_OK;
2372 bad_arg:
2373    va_end(ap);
2374    return CELT_BAD_ARG;
2375 bad_request:
2376       va_end(ap);
2377   return CELT_UNIMPLEMENTED;
2378 }
2379
2380 const char *celt_strerror(int error)
2381 {
2382    static const char *error_strings[8] = {
2383       "success",
2384       "invalid argument",
2385       "invalid mode",
2386       "internal error",
2387       "corrupted stream",
2388       "request not implemented",
2389       "invalid state",
2390       "memory allocation failed"
2391    };
2392    if (error > 0 || error < -7)
2393       return "unknown error";
2394    else 
2395       return error_strings[-error];
2396 }
2397