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