450bde5a9b0869f02acb7e167f87cf493981be99
[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
56 static const int trim_cdf[7] = {0, 4, 11, 65, 119, 125, 128};
57 #define COMBFILTER_MAXPERIOD 1024
58 #define COMBFILTER_MINPERIOD 16
59
60 /** Encoder state 
61  @brief Encoder state
62  */
63 struct CELTEncoder {
64    const CELTMode *mode;     /**< Mode used by the encoder */
65    int overlap;
66    int channels;
67    
68    int force_intra;
69    int complexity;
70    int start, end;
71
72    celt_int32 vbr_rate_norm; /* Target number of 8th bits per frame */
73
74    /* Everything beyond this point gets cleared on a reset */
75 #define ENCODER_RESET_START frame_max
76
77    celt_word32 frame_max;
78    int fold_decision;
79    int delayedIntra;
80    int tonal_average;
81
82    int prefilter_period;
83    celt_word16 prefilter_gain;
84
85    /* VBR-related parameters */
86    celt_int32 vbr_reservoir;
87    celt_int32 vbr_drift;
88    celt_int32 vbr_offset;
89    celt_int32 vbr_count;
90
91    celt_word32 preemph_memE[2];
92    celt_word32 preemph_memD[2];
93
94 #ifdef RESYNTH
95    celt_sig syn_mem[2][2*MAX_PERIOD];
96 #endif
97
98    celt_sig in_mem[1]; /* Size = channels*mode->overlap */
99    /* celt_sig prefilter_mem[],  Size = channels*COMBFILTER_PERIOD */
100    /* celt_sig overlap_mem[],  Size = channels*mode->overlap */
101    /* celt_word16 oldEBands[], Size = channels*mode->nbEBands */
102 };
103
104 int celt_encoder_get_size(const CELTMode *mode, int channels)
105 {
106    int size = sizeof(struct CELTEncoder)
107          + (2*channels*mode->overlap-1)*sizeof(celt_sig)
108          + channels*COMBFILTER_MAXPERIOD*sizeof(celt_sig)
109          + channels*mode->nbEBands*sizeof(celt_word16);
110    return size;
111 }
112
113 CELTEncoder *celt_encoder_create(const CELTMode *mode, int channels, int *error)
114 {
115    return celt_encoder_init(
116          (CELTEncoder *)celt_alloc(celt_encoder_get_size(mode, channels)),
117          mode, channels, error);
118 }
119
120 CELTEncoder *celt_encoder_init(CELTEncoder *st, const CELTMode *mode, int channels, int *error)
121 {
122    if (channels < 0 || channels > 2)
123    {
124       if (error)
125          *error = CELT_BAD_ARG;
126       return NULL;
127    }
128
129    if (st==NULL)
130    {
131       if (error)
132          *error = CELT_ALLOC_FAIL;
133       return NULL;
134    }
135
136    CELT_MEMSET((char*)st, 0, celt_encoder_get_size(mode, channels));
137    
138    st->mode = mode;
139    st->overlap = mode->overlap;
140    st->channels = channels;
141
142    st->start = 0;
143    st->end = st->mode->effEBands;
144
145    st->vbr_rate_norm = 0;
146    st->vbr_offset = -(64<<BITRES);
147    st->force_intra  = 0;
148    st->delayedIntra = 1;
149    st->tonal_average = 256;
150    st->fold_decision = 1;
151    st->complexity = 5;
152
153    if (error)
154       *error = CELT_OK;
155    return st;
156 }
157
158 void celt_encoder_destroy(CELTEncoder *st)
159 {
160    celt_free(st);
161 }
162
163 static inline celt_int16 FLOAT2INT16(float x)
164 {
165    x = x*CELT_SIG_SCALE;
166    x = MAX32(x, -32768);
167    x = MIN32(x, 32767);
168    return (celt_int16)float2int(x);
169 }
170
171 static inline celt_word16 SIG2WORD16(celt_sig x)
172 {
173 #ifdef FIXED_POINT
174    x = PSHR32(x, SIG_SHIFT);
175    x = MAX32(x, -32768);
176    x = MIN32(x, 32767);
177    return EXTRACT16(x);
178 #else
179    return (celt_word16)x;
180 #endif
181 }
182
183 static int transient_analysis(const celt_word32 * restrict in, int len, int C,
184                               celt_word32 *frame_max, int overlap)
185 {
186    int i, n;
187    celt_word32 threshold;
188    VARDECL(celt_word32, begin);
189    VARDECL(celt_word16, tmp);
190    celt_word32 mem0=0,mem1=0;
191    SAVE_STACK;
192    ALLOC(tmp, len, celt_word16);
193    ALLOC(begin, len+1, celt_word32);
194
195    if (C==1)
196    {
197       for (i=0;i<len;i++)
198          tmp[i] = SHR32(in[i],SIG_SHIFT);
199    } else {
200       for (i=0;i<len;i++)
201          tmp[i] = SHR32(ADD32(in[i],in[i+len]), SIG_SHIFT+1);
202    }
203
204    /* High-pass filter: (1 - 2*z^-1 + z^-2) / (1 - z^-1 + .5*z^-2) */
205    for (i=0;i<len;i++)
206    {
207       celt_word32 x,y;
208       x = tmp[i];
209       y = ADD32(mem0, x);
210 #ifdef FIXED_POINT
211       mem0 = mem1 + y - SHL32(x,1);
212       mem1 = x - SHR32(y,1);
213 #else
214       mem0 = mem1 + y - 2*x;
215       mem1 = x - .5f*y;
216 #endif
217       tmp[i] = EXTRACT16(SHR(y,2));
218    }
219    /* First few samples are bad because we don't propagate the memory */
220    for (i=0;i<24;i++)
221       tmp[i] = 0;
222
223    begin[0] = 0;
224    for (i=0;i<len;i++)
225       begin[i+1] = MAX32(begin[i], ABS32(tmp[i]));
226
227    n = -1;
228
229    threshold = MULT16_32_Q15(QCONST16(.4f,15),begin[len]);
230    /* If the following condition isn't met, there's just no way
231       we'll have a transient*/
232    if (*frame_max < threshold)
233    {
234       /* It's likely we have a transient, now find it */
235       for (i=8;i<len-8;i++)
236       {
237          if (begin[i+1] < threshold)
238             n=i;
239       }
240    }
241
242    *frame_max = begin[len-overlap];
243    /* Only consider the last 7.5 ms for the next transient */
244    if (len>360+overlap)
245    {
246       *frame_max = 0;
247       for (i=len-360-overlap;i<len-overlap;i++)
248          *frame_max = MAX32(*frame_max, ABS32(tmp[i]));
249    }
250    RESTORE_STACK;
251    return n>=32;
252 }
253
254 /** Apply window and compute the MDCT for all sub-frames and 
255     all channels in a frame */
256 static void compute_mdcts(const CELTMode *mode, int shortBlocks, celt_sig * restrict in, celt_sig * restrict out, int _C, int LM)
257 {
258    const int C = CHANNELS(_C);
259    if (C==1 && !shortBlocks)
260    {
261       const int overlap = OVERLAP(mode);
262       clt_mdct_forward(&mode->mdct, in, out, mode->window, overlap, mode->maxLM-LM);
263    } else {
264       const int overlap = OVERLAP(mode);
265       int N = mode->shortMdctSize<<LM;
266       int B = 1;
267       int b, c;
268       VARDECL(celt_word32, tmp);
269       SAVE_STACK;
270       if (shortBlocks)
271       {
272          /*lookup = &mode->mdct[0];*/
273          N = mode->shortMdctSize;
274          B = shortBlocks;
275       }
276       ALLOC(tmp, N, celt_word32);
277       c=0; do {
278          for (b=0;b<B;b++)
279          {
280             int j;
281             clt_mdct_forward(&mode->mdct, in+c*(B*N+overlap)+b*N, tmp, mode->window, overlap, shortBlocks ? mode->maxLM : mode->maxLM-LM);
282             /* Interleaving the sub-frames */
283             for (j=0;j<N;j++)
284                out[(j*B+b)+c*N*B] = tmp[j];
285          }
286       } while (++c<C);
287       RESTORE_STACK;
288    }
289 }
290
291 /** Compute the IMDCT and apply window for all sub-frames and 
292     all channels in a frame */
293 static void compute_inv_mdcts(const CELTMode *mode, int shortBlocks, celt_sig *X,
294       celt_sig * restrict out_mem[],
295       celt_sig * restrict overlap_mem[], int _C, int LM)
296 {
297    int c;
298    const int C = CHANNELS(_C);
299    const int N = mode->shortMdctSize<<LM;
300    const int overlap = OVERLAP(mode);
301    c=0; do {
302       int j;
303          VARDECL(celt_word32, x);
304          VARDECL(celt_word32, tmp);
305          int b;
306          int N2 = N;
307          int B = 1;
308          SAVE_STACK;
309          
310          ALLOC(x, N+overlap, celt_word32);
311          ALLOC(tmp, N, celt_word32);
312
313          if (shortBlocks)
314          {
315             N2 = mode->shortMdctSize;
316             B = shortBlocks;
317          }
318          /* Prevents problems from the imdct doing the overlap-add */
319          CELT_MEMSET(x, 0, overlap);
320
321          for (b=0;b<B;b++)
322          {
323             /* De-interleaving the sub-frames */
324             for (j=0;j<N2;j++)
325                tmp[j] = X[(j*B+b)+c*N2*B];
326             clt_mdct_backward(&mode->mdct, tmp, x+N2*b, mode->window, overlap, shortBlocks ? mode->maxLM : mode->maxLM-LM);
327          }
328
329          for (j=0;j<overlap;j++)
330             out_mem[c][j] = x[j] + overlap_mem[c][j];
331          for (;j<N;j++)
332             out_mem[c][j] = x[j];
333          for (j=0;j<overlap;j++)
334             overlap_mem[c][j] = x[N+j];
335          RESTORE_STACK;
336    } while (++c<C);
337 }
338
339 static void deemphasis(celt_sig *in[], celt_word16 *pcm, int N, int _C, const celt_word16 *coef, celt_sig *mem)
340 {
341    const int C = CHANNELS(_C);
342    int c;
343    c=0; do {
344       int j;
345       celt_sig * restrict x;
346       celt_word16  * restrict y;
347       celt_sig m = mem[c];
348       x =in[c];
349       y = pcm+c;
350       for (j=0;j<N;j++)
351       {
352          celt_sig tmp = *x + m;
353          m = MULT16_32_Q15(coef[0], tmp)
354            - MULT16_32_Q15(coef[1], *x);
355          tmp = SHL32(MULT16_32_Q15(coef[3], tmp), 2);
356          *y = SCALEOUT(SIG2WORD16(tmp));
357          x++;
358          y+=C;
359       }
360       mem[c] = m;
361    } while (++c<C);
362 }
363
364 #ifdef ENABLE_POSTFILTER
365 /* FIXME: Handle the case where T = maxperiod */
366 static void comb_filter(celt_word32 *y, celt_word32 *x, int T0, int T1, int N,
367       int C, celt_word16 g0, celt_word16 g1, const celt_word16 *window, int overlap)
368 {
369    int i;
370    /* printf ("%d %d %f %f\n", T0, T1, g0, g1); */
371    celt_word16 g00, g01, g02, g10, g11, g12;
372    celt_word16 t0, t1, t2;
373    /* zeros at theta = +/- 5*pi/6 */
374    t0 = QCONST16(.26795f, 15);
375    t1 = QCONST16(.46410f, 15);
376    t2 = QCONST16(.26795f, 15);
377    g00 = MULT16_16_Q15(g0, t0);
378    g01 = MULT16_16_Q15(g0, t1);
379    g02 = MULT16_16_Q15(g0, t2);
380    g10 = MULT16_16_Q15(g1, t0);
381    g11 = MULT16_16_Q15(g1, t1);
382    g12 = MULT16_16_Q15(g1, t2);
383    for (i=0;i<overlap;i++)
384    {
385       celt_word16 f;
386       f = MULT16_16_Q15(window[i],window[i]);
387       y[i] = x[i]
388                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g01),x[i-T0])
389                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g00),x[i-T0-1])
390                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g02),x[i-T0+1])
391                + MULT16_32_Q15(MULT16_16_Q15(f,g11),x[i-T1])
392                + MULT16_32_Q15(MULT16_16_Q15(f,g10),x[i-T1-1])
393                + MULT16_32_Q15(MULT16_16_Q15(f,g12),x[i-T1+1]);
394
395    }
396    for (i=overlap;i<N;i++)
397       y[i] = x[i]
398                + MULT16_32_Q15(g11,x[i-T1])
399                + MULT16_32_Q15(g10,x[i-T1-1])
400                + MULT16_32_Q15(g12,x[i-T1+1]);
401 }
402 #endif /* ENABLE_POSTFILTER */
403
404 static const signed char tf_select_table[4][8] = {
405       {0, -1, 0, -1,    0,-1, 0,-1},
406       {0, -1, 0, -2,    1, 0, 1 -1},
407       {0, -2, 0, -3,    2, 0, 1 -1},
408       {0, -2, 0, -3,    2, 0, 1 -1},
409 };
410
411 static celt_word32 l1_metric(const celt_norm *tmp, int N, int LM, int width)
412 {
413    int i, j;
414    static const celt_word16 sqrtM_1[4] = {Q15ONE, QCONST16(0.70711f,15), QCONST16(0.5f,15), QCONST16(0.35355f,15)};
415    celt_word32 L1;
416    celt_word16 bias;
417    L1=0;
418    for (i=0;i<1<<LM;i++)
419    {
420       celt_word32 L2 = 0;
421       for (j=0;j<N>>LM;j++)
422          L2 = MAC16_16(L2, tmp[(j<<LM)+i], tmp[(j<<LM)+i]);
423       L1 += celt_sqrt(L2);
424    }
425    L1 = MULT16_32_Q15(sqrtM_1[LM], L1);
426    if (width==1)
427       bias = QCONST16(.12f,15)*LM;
428    else if (width==2)
429       bias = QCONST16(.05f,15)*LM;
430    else
431       bias = QCONST16(.02f,15)*LM;
432    L1 = MAC16_32_Q15(L1, bias, L1);
433    return L1;
434 }
435
436 static int tf_analysis(const CELTMode *m, celt_word16 *bandLogE, celt_word16 *oldBandE,
437       int len, int C, int isTransient, int *tf_res, int nbCompressedBytes, celt_norm *X,
438       int N0, int LM, int *tf_sum)
439 {
440    int i;
441    VARDECL(int, metric);
442    int cost0;
443    int cost1;
444    VARDECL(int, path0);
445    VARDECL(int, path1);
446    VARDECL(celt_norm, tmp);
447    int lambda;
448    int tf_select=0;
449    SAVE_STACK;
450
451    /* FIXME: Should check number of bytes *left* */
452    if (nbCompressedBytes<15*C)
453    {
454       *tf_sum = 0;
455       for (i=0;i<len;i++)
456          tf_res[i] = isTransient;
457       return 0;
458    }
459    if (nbCompressedBytes<40)
460       lambda = 12;
461    else if (nbCompressedBytes<60)
462       lambda = 6;
463    else if (nbCompressedBytes<100)
464       lambda = 4;
465    else
466       lambda = 3;
467
468    ALLOC(metric, len, int);
469    ALLOC(tmp, (m->eBands[len]-m->eBands[len-1])<<LM, celt_norm);
470    ALLOC(path0, len, int);
471    ALLOC(path1, len, int);
472
473    *tf_sum = 0;
474    for (i=0;i<len;i++)
475    {
476       int j, k, N;
477       celt_word32 L1, best_L1;
478       int best_level=0;
479       N = (m->eBands[i+1]-m->eBands[i])<<LM;
480       for (j=0;j<N;j++)
481          tmp[j] = X[j+(m->eBands[i]<<LM)];
482       /* FIXME: Do something with the right channel */
483       if (C==2)
484          for (j=0;j<N;j++)
485             tmp[j] = ADD16(tmp[j],X[N0+j+(m->eBands[i]<<LM)]);
486       L1 = l1_metric(tmp, N, isTransient ? LM : 0, N>>LM);
487       best_L1 = L1;
488       /*printf ("%f ", L1);*/
489       for (k=0;k<LM;k++)
490       {
491          int B;
492
493          if (isTransient)
494             B = (LM-k-1);
495          else
496             B = k+1;
497
498          if (isTransient)
499             haar1(tmp, N>>(LM-k), 1<<(LM-k));
500          else
501             haar1(tmp, N>>k, 1<<k);
502
503          L1 = l1_metric(tmp, N, B, N>>LM);
504
505          if (L1 < best_L1)
506          {
507             best_L1 = L1;
508             best_level = k+1;
509          }
510       }
511       /*printf ("%d ", isTransient ? LM-best_level : best_level);*/
512       if (isTransient)
513          metric[i] = best_level;
514       else
515          metric[i] = -best_level;
516       *tf_sum += metric[i];
517    }
518    /*printf("\n");*/
519    /* FIXME: Figure out how to set this */
520    tf_select = 0;
521
522    cost0 = 0;
523    cost1 = isTransient ? 0 : lambda;
524    /* Viterbi forward pass */
525    for (i=1;i<len;i++)
526    {
527       int curr0, curr1;
528       int from0, from1;
529
530       from0 = cost0;
531       from1 = cost1 + lambda;
532       if (from0 < from1)
533       {
534          curr0 = from0;
535          path0[i]= 0;
536       } else {
537          curr0 = from1;
538          path0[i]= 1;
539       }
540
541       from0 = cost0 + lambda;
542       from1 = cost1;
543       if (from0 < from1)
544       {
545          curr1 = from0;
546          path1[i]= 0;
547       } else {
548          curr1 = from1;
549          path1[i]= 1;
550       }
551       cost0 = curr0 + abs(metric[i]-tf_select_table[LM][4*isTransient+2*tf_select+0]);
552       cost1 = curr1 + abs(metric[i]-tf_select_table[LM][4*isTransient+2*tf_select+1]);
553    }
554    tf_res[len-1] = cost0 < cost1 ? 0 : 1;
555    /* Viterbi backward pass to check the decisions */
556    for (i=len-2;i>=0;i--)
557    {
558       if (tf_res[i+1] == 1)
559          tf_res[i] = path1[i+1];
560       else
561          tf_res[i] = path0[i+1];
562    }
563    RESTORE_STACK;
564    return tf_select;
565 }
566
567 static void tf_encode(int start, int end, int isTransient, int *tf_res, int nbCompressedBytes, int LM, int tf_select, ec_enc *enc)
568 {
569    int curr, i;
570    ec_enc_bit_prob(enc, tf_res[start], isTransient ? 16384 : 4096);
571    curr = tf_res[start];
572    for (i=start+1;i<end;i++)
573    {
574       ec_enc_bit_prob(enc, tf_res[i] ^ curr, isTransient ? 4096 : 2048);
575       curr = tf_res[i];
576    }
577    ec_enc_bits(enc, tf_select, 1);
578    for (i=start;i<end;i++)
579       tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]];
580    /*printf("%d %d ", isTransient, tf_select); for(i=0;i<end;i++)printf("%d ", tf_res[i]);printf("\n");*/
581 }
582
583 static void tf_decode(int start, int end, int C, int isTransient, int *tf_res, int nbCompressedBytes, int LM, ec_dec *dec)
584 {
585    int i, curr, tf_select;
586    tf_res[start] = ec_dec_bit_prob(dec, isTransient ? 16384 : 4096);
587    curr = tf_res[start];
588    for (i=start+1;i<end;i++)
589    {
590       tf_res[i] = ec_dec_bit_prob(dec, isTransient ? 4096 : 2048) ^ curr;
591       curr = tf_res[i];
592    }
593    tf_select = ec_dec_bits(dec, 1);
594    for (i=start;i<end;i++)
595       tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]];
596 }
597
598 static int alloc_trim_analysis(const CELTMode *m, const celt_norm *X,
599       const celt_word16 *bandLogE, int nbEBands, int LM, int C, int N0)
600 {
601    int i;
602    int trim_index = 2;
603    if (C==2)
604    {
605       celt_word16 sum = 0; /* Q10 */
606       /* Compute inter-channel correlation for low frequencies */
607       for (i=0;i<8;i++)
608       {
609          int j;
610          celt_word32 partial = 0;
611          for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++)
612             partial = MAC16_16(partial, X[j], X[N0+j]);
613          sum = ADD16(sum, EXTRACT16(SHR32(partial, 18)));
614       }
615       sum = MULT16_16_Q15(QCONST16(1.f/8, 15), sum);
616       /*printf ("%f\n", sum);*/
617       if (sum > QCONST16(.995f,10))
618          trim_index-=3;
619       else if (sum > QCONST16(.92f,10))
620          trim_index-=2;
621       else if (sum > QCONST16(.8f,10))
622          trim_index-=1;
623    }
624 #if 0
625    float diff=0;
626    int c;
627    c=0; do {
628       for (i=0;i<nbEBands-1;i++)
629       {
630          diff += bandLogE[i+c*nbEBands]*(i-.5*nbEBands);
631       }
632    } while (++c<0);
633    diff /= C*(nbEBands-1);
634    /*printf("%f\n", diff);*/
635    if (diff > 4)
636       trim_index--;
637    if (diff > 8)
638       trim_index--;
639    if (diff < -4)
640       trim_index++;
641 #endif
642    if (trim_index<0)
643       trim_index = 0;
644    if (trim_index>5)
645       trim_index = 5;
646    return trim_index;
647 }
648
649 #ifdef FIXED_POINT
650 int celt_encode_with_ec(CELTEncoder * restrict st, const celt_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
651 {
652 #else
653 int celt_encode_with_ec_float(CELTEncoder * restrict st, const celt_sig * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
654 {
655 #endif
656    int i, c, N;
657    int bits;
658    int has_fold=1;
659    ec_byte_buffer buf;
660    ec_enc         _enc;
661    VARDECL(celt_sig, in);
662    VARDECL(celt_sig, freq);
663    VARDECL(celt_norm, X);
664    VARDECL(celt_ener, bandE);
665    VARDECL(celt_word16, bandLogE);
666    VARDECL(int, fine_quant);
667    VARDECL(celt_word16, error);
668    VARDECL(int, pulses);
669    VARDECL(int, offsets);
670    VARDECL(int, fine_priority);
671    VARDECL(int, tf_res);
672    celt_sig *_overlap_mem;
673    celt_sig *prefilter_mem;
674    celt_word16 *oldBandE;
675    int shortBlocks=0;
676    int isTransient=0;
677    int resynth;
678    const int C = CHANNELS(st->channels);
679    int LM, M;
680    int tf_select;
681    int nbFilledBytes, nbAvailableBytes;
682    int effEnd;
683    int codedBands;
684    int tf_sum;
685    int alloc_trim;
686    int pitch_index=0;
687    celt_word16 gain1 = 0;
688    SAVE_STACK;
689
690    if (nbCompressedBytes<0 || pcm==NULL)
691      return CELT_BAD_ARG;
692
693    for (LM=0;LM<4;LM++)
694       if (st->mode->shortMdctSize<<LM==frame_size)
695          break;
696    if (LM>=MAX_CONFIG_SIZES)
697       return CELT_BAD_ARG;
698    M=1<<LM;
699
700    prefilter_mem = st->in_mem+C*(st->overlap);
701    _overlap_mem = prefilter_mem+C*COMBFILTER_MAXPERIOD;
702    /*_overlap_mem = st->in_mem+C*(st->overlap);*/
703    oldBandE = (celt_word16*)(st->in_mem+C*(2*st->overlap+COMBFILTER_MAXPERIOD));
704
705    if (enc==NULL)
706    {
707       ec_byte_writeinit_buffer(&buf, compressed, nbCompressedBytes);
708       ec_enc_init(&_enc,&buf);
709       enc = &_enc;
710       nbFilledBytes=0;
711    } else {
712       nbFilledBytes=(ec_enc_tell(enc, 0)+4)>>3;
713    }
714    nbAvailableBytes = nbCompressedBytes - nbFilledBytes;
715
716    effEnd = st->end;
717    if (effEnd > st->mode->effEBands)
718       effEnd = st->mode->effEBands;
719
720    N = M*st->mode->shortMdctSize;
721    ALLOC(in, C*(N+st->overlap), celt_sig);
722
723    /* Find pitch period and gain */
724    {
725       VARDECL(celt_sig, _pre);
726       celt_sig *pre[2];
727       SAVE_STACK;
728       c = 0;
729       ALLOC(_pre, C*(N+COMBFILTER_MAXPERIOD), celt_sig);
730
731       pre[0] = _pre;
732       pre[1] = _pre + (N+COMBFILTER_MAXPERIOD);
733
734       c=0; do {
735          const celt_word16 * restrict pcmp = pcm+c;
736          celt_sig * restrict inp = in+c*(N+st->overlap)+st->overlap;
737
738          for (i=0;i<N;i++)
739          {
740             /* Apply pre-emphasis */
741             celt_sig tmp = MULT16_16(st->mode->preemph[2], SCALEIN(*pcmp));
742             *inp = tmp + st->preemph_memE[c];
743             st->preemph_memE[c] = MULT16_32_Q15(st->mode->preemph[1], *inp)
744                                    - MULT16_32_Q15(st->mode->preemph[0], tmp);
745             inp++;
746             pcmp+=C;
747          }
748          CELT_COPY(pre[c], prefilter_mem+c*COMBFILTER_MAXPERIOD, COMBFILTER_MAXPERIOD);
749          CELT_COPY(pre[c]+COMBFILTER_MAXPERIOD, in+c*(N+st->overlap)+st->overlap, N);
750       } while (++c<C);
751
752 #ifdef ENABLE_POSTFILTER
753       {
754          VARDECL(celt_word16, pitch_buf);
755          ALLOC(pitch_buf, (COMBFILTER_MAXPERIOD+N)>>1, celt_word16);
756          celt_word32 tmp=0;
757          celt_word32 mem0[2]={0,0};
758          celt_word16 mem1[2]={0,0};
759
760          pitch_downsample(pre, pitch_buf, COMBFILTER_MAXPERIOD+N, COMBFILTER_MAXPERIOD+N,
761                           C, mem0, mem1);
762          pitch_search(st->mode, pitch_buf+(COMBFILTER_MAXPERIOD>>1), pitch_buf, N,
763                COMBFILTER_MAXPERIOD-COMBFILTER_MINPERIOD, &pitch_index, &tmp, 1<<LM);
764          pitch_index = COMBFILTER_MAXPERIOD-pitch_index;
765
766          gain1 = remove_doubling(pitch_buf, COMBFILTER_MAXPERIOD, COMBFILTER_MINPERIOD,
767                N, &pitch_index, st->prefilter_period, st->prefilter_gain);
768       }
769       if (pitch_index > COMBFILTER_MAXPERIOD)
770          pitch_index = COMBFILTER_MAXPERIOD;
771       gain1 = MULT16_16_Q15(QCONST16(.7f,15),gain1);
772       if (gain1 > QCONST16(.6f,15))
773          gain1 = QCONST16(.6f,15);
774       if (ABS16(gain1-st->prefilter_gain)<QCONST16(.1,15))
775          gain1=st->prefilter_gain;
776       if (gain1<QCONST16(.2f,15))
777       {
778          ec_enc_bit_prob(enc, 0, 32768);
779          gain1 = 0;
780       } else {
781          int qg;
782          int octave;
783 #ifdef FIXED_POINT
784          qg = ((gain1+2048)>>12)-2;
785 #else
786          qg = floor(.5+gain1*8)-2;
787 #endif
788          ec_enc_bit_prob(enc, 1, 32768);
789          octave = EC_ILOG(pitch_index)-5;
790          ec_enc_uint(enc, octave, 6);
791          ec_enc_bits(enc, pitch_index-(16<<octave), 4+octave);
792          ec_enc_bits(enc, qg, 2);
793          gain1 = QCONST16(.125f,15)*(qg+2);
794       }
795       /*printf("%d %f\n", pitch_index, gain1);*/
796 #else /* ENABLE_POSTFILTER */
797       ec_enc_bit_prob(enc, 0, 32768);
798 #endif /* ENABLE_POSTFILTER */
799
800       c=0; do {
801          CELT_COPY(in+c*(N+st->overlap), st->in_mem+c*(st->overlap), st->overlap);
802 #ifdef ENABLE_POSTFILTER
803          comb_filter(in+c*(N+st->overlap)+st->overlap, pre[c]+COMBFILTER_MAXPERIOD,
804                st->prefilter_period, pitch_index, N, C, -st->prefilter_gain, -gain1, st->mode->window, st->mode->overlap);
805 #endif /* ENABLE_POSTFILTER */
806          CELT_COPY(st->in_mem+c*(st->overlap), in+c*(N+st->overlap)+N, st->overlap);
807
808 #ifdef ENABLE_POSTFILTER
809          if (N>COMBFILTER_MAXPERIOD)
810          {
811             CELT_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, pre[c]+N, COMBFILTER_MAXPERIOD);
812          } else {
813             CELT_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, prefilter_mem+c*COMBFILTER_MAXPERIOD+N, COMBFILTER_MAXPERIOD-N);
814             CELT_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD+COMBFILTER_MAXPERIOD-N, pre[c]+COMBFILTER_MAXPERIOD, N);
815          }
816 #endif /* ENABLE_POSTFILTER */
817       } while (++c<C);
818
819       RESTORE_STACK;
820    }
821
822 #ifdef RESYNTH
823    resynth = 1;
824 #else
825    resynth = 0;
826 #endif
827
828    if (st->complexity > 1 && LM>0)
829    {
830       isTransient = M > 1 &&
831          transient_analysis(in, N+st->overlap, C, &st->frame_max, st->overlap);
832    } else {
833       isTransient = 0;
834    }
835
836    if (isTransient)
837       shortBlocks = M;
838    else
839       shortBlocks = 0;
840
841    ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
842    ALLOC(bandE,st->mode->nbEBands*C, celt_ener);
843    ALLOC(bandLogE,st->mode->nbEBands*C, celt_word16);
844    /* Compute MDCTs */
845    compute_mdcts(st->mode, shortBlocks, in, freq, C, LM);
846
847    ALLOC(X, C*N, celt_norm);         /**< Interleaved normalised MDCTs */
848
849    compute_band_energies(st->mode, freq, bandE, effEnd, C, M);
850
851    amp2Log2(st->mode, effEnd, st->end, bandE, bandLogE, C);
852
853    /* Band normalisation */
854    normalise_bands(st->mode, freq, X, bandE, effEnd, C, M);
855
856    ALLOC(tf_res, st->mode->nbEBands, int);
857    /* Needs to be before coarse energy quantization because otherwise the energy gets modified */
858    tf_select = tf_analysis(st->mode, bandLogE, oldBandE, effEnd, C, isTransient, tf_res, nbAvailableBytes, X, N, LM, &tf_sum);
859    for (i=effEnd;i<st->end;i++)
860       tf_res[i] = tf_res[effEnd-1];
861
862    ALLOC(error, C*st->mode->nbEBands, celt_word16);
863    quant_coarse_energy(st->mode, st->start, st->end, effEnd, bandLogE,
864          oldBandE, nbCompressedBytes*8, st->mode->prob,
865          error, enc, C, LM, nbAvailableBytes, st->force_intra,
866          &st->delayedIntra, st->complexity >= 4);
867
868    if (LM > 0)
869       ec_enc_bit_prob(enc, shortBlocks!=0, 8192);
870
871    tf_encode(st->start, st->end, isTransient, tf_res, nbAvailableBytes, LM, tf_select, enc);
872
873    if (shortBlocks || st->complexity < 3)
874    {
875       if (st->complexity == 0)
876       {
877          has_fold = 0;
878          st->fold_decision = 3;
879       } else {
880          has_fold = 1;
881          st->fold_decision = 1;
882       }
883    } else {
884       has_fold = folding_decision(st->mode, X, &st->tonal_average, &st->fold_decision, effEnd, C, M);
885    }
886    ec_enc_bit_prob(enc, has_fold>>1, 8192);
887    ec_enc_bit_prob(enc, has_fold&1, (has_fold>>1) ? 32768 : 49152);
888
889    ALLOC(offsets, st->mode->nbEBands, int);
890
891    for (i=0;i<st->mode->nbEBands;i++)
892       offsets[i] = 0;
893    /* Dynamic allocation code */
894    /* Make sure that dynamic allocation can't make us bust the budget */
895    if (nbCompressedBytes > 30 && LM>=1)
896    {
897       int t1, t2;
898       if (LM <= 1)
899       {
900          t1 = 3;
901          t2 = 5;
902       } else {
903          t1 = 2;
904          t2 = 4;
905       }
906       for (i=1;i<st->mode->nbEBands-1;i++)
907       {
908          celt_word32 d2;
909          d2 = 2*bandLogE[i]-bandLogE[i-1]-bandLogE[i+1];
910          if (C==2)
911             d2 = HALF32(d2 + 2*bandLogE[i+st->mode->nbEBands]-
912                   bandLogE[i-1+st->mode->nbEBands]-bandLogE[i+1+st->mode->nbEBands]);
913          if (d2 > SHL16(t1,DB_SHIFT))
914             offsets[i] += 1;
915          if (d2 > SHL16(t2,DB_SHIFT))
916             offsets[i] += 1;
917       }
918    }
919    for (i=0;i<st->mode->nbEBands;i++)
920    {
921       int j;
922       ec_enc_bit_prob(enc, offsets[i]!=0, 1024);
923       if (offsets[i]!=0)
924       {
925          for (j=0;j<offsets[i]-1;j++)
926             ec_enc_bit_prob(enc, 1, 32768);
927          ec_enc_bit_prob(enc, 0, 32768);
928       }
929       offsets[i] *= (6<<BITRES);
930    }
931    alloc_trim = alloc_trim_analysis(st->mode, X, bandLogE, st->mode->nbEBands, LM, C, N);
932    ec_encode_bin(enc, trim_cdf[alloc_trim], trim_cdf[alloc_trim+1], 7);
933
934    /* Variable bitrate */
935    if (st->vbr_rate_norm>0)
936    {
937      celt_word16 alpha;
938      celt_int32 delta;
939      /* The target rate in 8th bits per frame */
940      celt_int32 vbr_rate;
941      celt_int32 target;
942      celt_int32 vbr_bound, max_allowed;
943
944      target = vbr_rate = M*st->vbr_rate_norm;
945
946      /* Shortblocks get a large boost in bitrate, but since they
947         are uncommon long blocks are not greatly affected */
948      if (shortBlocks || tf_sum < -2*(st->end-st->start))
949         target*=2;
950      else if (tf_sum < -(st->end-st->start))
951         target = 3*target/2;
952      else if (M > 1)
953         target-=(target+14)/28;
954
955      /* The current offset is removed from the target and the space used
956         so far is added*/
957      target=target+st->vbr_offset+ec_enc_tell(enc, BITRES);
958
959      /* Computes the max bit-rate allowed in VBR more to avoid violating the target rate and buffering */
960      vbr_bound = vbr_rate;
961      max_allowed = IMIN(vbr_rate+vbr_bound-st->vbr_reservoir>>(BITRES+3),nbAvailableBytes);
962
963      /* In VBR mode the frame size must not be reduced so much that it would result in the encoder running out of bits */
964      nbAvailableBytes = target+(1<<(BITRES+2))>>(BITRES+3);
965      nbAvailableBytes=IMAX(16,IMIN(max_allowed,nbAvailableBytes));
966      target=nbAvailableBytes<<(BITRES+3);
967
968      if (st->vbr_count < 970)
969      {
970         st->vbr_count++;
971         alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+20),16));
972      } else
973         alpha = QCONST16(.001f,15);
974      /* By how much did we "miss" the target on that frame */
975      delta = (celt_int32)target - vbr_rate;
976      /* How many bits have we used in excess of what we're allowed */
977      st->vbr_reservoir += delta;
978      /*printf ("%d\n", st->vbr_reservoir);*/
979
980      /* Compute the offset we need to apply in order to reach the target */
981      st->vbr_drift += (celt_int32)MULT16_32_Q15(alpha,delta-st->vbr_offset-st->vbr_drift);
982      st->vbr_offset = -st->vbr_drift;
983      /*printf ("%d\n", st->vbr_drift);*/
984
985      /* We could use any multiple of vbr_rate as bound (depending on the delay) */
986      if (st->vbr_reservoir < 0)
987      {
988         /* We're under the min value -- increase rate */
989         int adjust = (-st->vbr_reservoir)/(8<<BITRES);
990         nbAvailableBytes += adjust;
991         st->vbr_reservoir = 0;
992         /*printf ("+%d\n", adjust);*/
993      }
994      nbCompressedBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes);
995
996      /* This moves the raw bits to take into account the new compressed size */
997      ec_byte_shrink(&buf, nbCompressedBytes);
998    }
999
1000    /* Bit allocation */
1001    ALLOC(fine_quant, st->mode->nbEBands, int);
1002    ALLOC(pulses, st->mode->nbEBands, int);
1003    ALLOC(fine_priority, st->mode->nbEBands, int);
1004
1005    bits = nbCompressedBytes*8 - ec_enc_tell(enc, 0) - 1;
1006    codedBands = compute_allocation(st->mode, st->start, st->end, offsets, alloc_trim, bits, pulses, fine_quant, fine_priority, C, LM);
1007
1008    quant_fine_energy(st->mode, st->start, st->end, bandE, oldBandE, error, fine_quant, enc, C);
1009
1010 #ifdef MEASURE_NORM_MSE
1011    float X0[3000];
1012    float bandE0[60];
1013    c=0; do 
1014       for (i=0;i<N;i++)
1015          X0[i+c*N] = X[i+c*N];
1016    while (++c<C);
1017    for (i=0;i<C*st->mode->nbEBands;i++)
1018       bandE0[i] = bandE[i];
1019 #endif
1020
1021    /* Residual quantisation */
1022    quant_all_bands(1, st->mode, st->start, st->end, X, C==2 ? X+N : NULL, bandE, pulses, shortBlocks, has_fold, tf_res, resynth, nbCompressedBytes*8, enc, LM, codedBands);
1023
1024    quant_energy_finalise(st->mode, st->start, st->end, bandE, oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_enc_tell(enc, 0), enc, C);
1025
1026 #ifdef RESYNTH
1027    /* Re-synthesis of the coded audio if required */
1028    if (resynth)
1029    {
1030       celt_sig *out_mem[2];
1031       celt_sig *overlap_mem[2];
1032
1033       log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
1034
1035 #ifdef MEASURE_NORM_MSE
1036       measure_norm_mse(st->mode, X, X0, bandE, bandE0, M, N, C);
1037 #endif
1038
1039       /* Synthesis */
1040       denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
1041
1042       CELT_MOVE(st->syn_mem[0], st->syn_mem[0]+N, MAX_PERIOD);
1043       if (C==2)
1044          CELT_MOVE(st->syn_mem[1], st->syn_mem[1]+N, MAX_PERIOD);
1045
1046       c=0; do
1047          for (i=0;i<M*st->mode->eBands[st->start];i++)
1048             freq[c*N+i] = 0;
1049       while (++c<C);
1050       c=0; do
1051          for (i=M*st->mode->eBands[st->end];i<N;i++)
1052             freq[c*N+i] = 0;
1053       while (++c<C);
1054
1055       out_mem[0] = st->syn_mem[0]+MAX_PERIOD;
1056       if (C==2)
1057          out_mem[1] = st->syn_mem[1]+MAX_PERIOD;
1058
1059       c=0; do
1060          overlap_mem[c] = _overlap_mem + c*st->overlap;
1061       while (++c<C);
1062
1063       compute_inv_mdcts(st->mode, shortBlocks, freq, out_mem, overlap_mem, C, LM);
1064
1065 #ifdef ENABLE_POSTFILTER
1066       c=0; do {
1067          comb_filter(out_mem[c], out_mem[c], st->prefilter_period, st->prefilter_period, st->overlap, C,
1068                st->prefilter_gain, st->prefilter_gain, NULL, 0);
1069          comb_filter(out_mem[c]+st->overlap, out_mem[c]+st->overlap, st->prefilter_period, pitch_index, N-st->overlap, C,
1070                st->prefilter_gain, gain1, st->mode->window, st->mode->overlap);
1071       } while (++c<C);
1072 #endif /* ENABLE_POSTFILTER */
1073
1074       deemphasis(out_mem, (celt_word16*)pcm, N, C, st->mode->preemph, st->preemph_memD);
1075    }
1076 #endif
1077
1078    st->prefilter_period = pitch_index;
1079    st->prefilter_gain = gain1;
1080
1081    /* If there's any room left (can only happen for very high rates),
1082       fill it with zeros */
1083    while (ec_enc_tell(enc,0) + 8 <= nbCompressedBytes*8)
1084       ec_enc_bits(enc, 0, 8);
1085    ec_enc_done(enc);
1086    
1087    RESTORE_STACK;
1088    if (ec_enc_get_error(enc))
1089       return CELT_CORRUPTED_DATA;
1090    else
1091       return nbCompressedBytes;
1092 }
1093
1094 #ifdef FIXED_POINT
1095 #ifndef DISABLE_FLOAT_API
1096 int celt_encode_with_ec_float(CELTEncoder * restrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
1097 {
1098    int j, ret, C, N, LM, M;
1099    VARDECL(celt_int16, in);
1100    SAVE_STACK;
1101
1102    if (pcm==NULL)
1103       return CELT_BAD_ARG;
1104
1105    for (LM=0;LM<4;LM++)
1106       if (st->mode->shortMdctSize<<LM==frame_size)
1107          break;
1108    if (LM>=MAX_CONFIG_SIZES)
1109       return CELT_BAD_ARG;
1110    M=1<<LM;
1111
1112    C = CHANNELS(st->channels);
1113    N = M*st->mode->shortMdctSize;
1114    ALLOC(in, C*N, celt_int16);
1115
1116    for (j=0;j<C*N;j++)
1117      in[j] = FLOAT2INT16(pcm[j]);
1118
1119    ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, enc);
1120 #ifdef RESYNTH
1121    for (j=0;j<C*N;j++)
1122       ((float*)pcm)[j]=in[j]*(1.f/32768.f);
1123 #endif
1124    RESTORE_STACK;
1125    return ret;
1126
1127 }
1128 #endif /*DISABLE_FLOAT_API*/
1129 #else
1130 int celt_encode_with_ec(CELTEncoder * restrict st, const celt_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
1131 {
1132    int j, ret, C, N, LM, M;
1133    VARDECL(celt_sig, in);
1134    SAVE_STACK;
1135
1136    if (pcm==NULL)
1137       return CELT_BAD_ARG;
1138
1139    for (LM=0;LM<4;LM++)
1140       if (st->mode->shortMdctSize<<LM==frame_size)
1141          break;
1142    if (LM>=MAX_CONFIG_SIZES)
1143       return CELT_BAD_ARG;
1144    M=1<<LM;
1145
1146    C=CHANNELS(st->channels);
1147    N=M*st->mode->shortMdctSize;
1148    ALLOC(in, C*N, celt_sig);
1149    for (j=0;j<C*N;j++) {
1150      in[j] = SCALEOUT(pcm[j]);
1151    }
1152
1153    ret = celt_encode_with_ec_float(st,in,frame_size,compressed,nbCompressedBytes, enc);
1154 #ifdef RESYNTH
1155    for (j=0;j<C*N;j++)
1156       ((celt_int16*)pcm)[j] = FLOAT2INT16(in[j]);
1157 #endif
1158    RESTORE_STACK;
1159    return ret;
1160 }
1161 #endif
1162
1163 int celt_encode(CELTEncoder * restrict st, const celt_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1164 {
1165    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1166 }
1167
1168 #ifndef DISABLE_FLOAT_API
1169 int celt_encode_float(CELTEncoder * restrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1170 {
1171    return celt_encode_with_ec_float(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1172 }
1173 #endif /* DISABLE_FLOAT_API */
1174
1175 int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
1176 {
1177    va_list ap;
1178    
1179    va_start(ap, request);
1180    switch (request)
1181    {
1182       case CELT_GET_MODE_REQUEST:
1183       {
1184          const CELTMode ** value = va_arg(ap, const CELTMode**);
1185          if (value==0)
1186             goto bad_arg;
1187          *value=st->mode;
1188       }
1189       break;
1190       case CELT_SET_COMPLEXITY_REQUEST:
1191       {
1192          int value = va_arg(ap, celt_int32);
1193          if (value<0 || value>10)
1194             goto bad_arg;
1195          st->complexity = value;
1196       }
1197       break;
1198       case CELT_SET_START_BAND_REQUEST:
1199       {
1200          celt_int32 value = va_arg(ap, celt_int32);
1201          if (value<0 || value>=st->mode->nbEBands)
1202             goto bad_arg;
1203          st->start = value;
1204       }
1205       break;
1206       case CELT_SET_END_BAND_REQUEST:
1207       {
1208          celt_int32 value = va_arg(ap, celt_int32);
1209          if (value<0 || value>=st->mode->nbEBands)
1210             goto bad_arg;
1211          st->end = value;
1212       }
1213       break;
1214       case CELT_SET_PREDICTION_REQUEST:
1215       {
1216          int value = va_arg(ap, celt_int32);
1217          if (value<0 || value>2)
1218             goto bad_arg;
1219          if (value==0)
1220          {
1221             st->force_intra   = 1;
1222          } else if (value==1) {
1223             st->force_intra   = 0;
1224          } else {
1225             st->force_intra   = 0;
1226          }   
1227       }
1228       break;
1229       case CELT_SET_VBR_RATE_REQUEST:
1230       {
1231          celt_int32 value = va_arg(ap, celt_int32);
1232          int frame_rate;
1233          int N = st->mode->shortMdctSize;
1234          if (value<0)
1235             goto bad_arg;
1236          if (value>3072000)
1237             value = 3072000;
1238          frame_rate = ((st->mode->Fs<<3)+(N>>1))/N;
1239          st->vbr_rate_norm = ((value<<(BITRES+3))+(frame_rate>>1))/frame_rate;
1240       }
1241       break;
1242       case CELT_RESET_STATE:
1243       {
1244          CELT_MEMSET((char*)&st->ENCODER_RESET_START, 0,
1245                celt_encoder_get_size(st->mode, st->channels)-
1246                ((char*)&st->ENCODER_RESET_START - (char*)st));
1247          st->vbr_offset = -(64<<BITRES);
1248          st->delayedIntra = 1;
1249          st->fold_decision = 1;
1250          st->tonal_average = QCONST16(1.f,8);
1251       }
1252       break;
1253       default:
1254          goto bad_request;
1255    }
1256    va_end(ap);
1257    return CELT_OK;
1258 bad_arg:
1259    va_end(ap);
1260    return CELT_BAD_ARG;
1261 bad_request:
1262    va_end(ap);
1263    return CELT_UNIMPLEMENTED;
1264 }
1265
1266 /**********************************************************************/
1267 /*                                                                    */
1268 /*                             DECODER                                */
1269 /*                                                                    */
1270 /**********************************************************************/
1271 #define DECODE_BUFFER_SIZE 2048
1272
1273 /** Decoder state 
1274  @brief Decoder state
1275  */
1276 struct CELTDecoder {
1277    const CELTMode *mode;
1278    int overlap;
1279    int channels;
1280
1281    int start, end;
1282
1283    /* Everything beyond this point gets cleared on a reset */
1284 #define DECODER_RESET_START last_pitch_index
1285
1286    int last_pitch_index;
1287    int loss_count;
1288    int postfilter_period;
1289    celt_word16 postfilter_gain;
1290
1291    celt_sig preemph_memD[2];
1292    
1293    celt_sig _decode_mem[1]; /* Size = channels*(DECODE_BUFFER_SIZE+mode->overlap) */
1294    /* celt_word16 lpc[],  Size = channels*LPC_ORDER */
1295    /* celt_word16 oldEBands[], Size = channels*mode->nbEBands */
1296 };
1297
1298 int celt_decoder_get_size(const CELTMode *mode, int channels)
1299 {
1300    int size = sizeof(struct CELTDecoder)
1301             + (channels*(DECODE_BUFFER_SIZE+mode->overlap)-1)*sizeof(celt_sig)
1302             + channels*LPC_ORDER*sizeof(celt_word16)
1303             + channels*mode->nbEBands*sizeof(celt_word16);
1304    return size;
1305 }
1306
1307 CELTDecoder *celt_decoder_create(const CELTMode *mode, int channels, int *error)
1308 {
1309    return celt_decoder_init(
1310          (CELTDecoder *)celt_alloc(celt_decoder_get_size(mode, channels)),
1311          mode, channels, error);
1312 }
1313
1314 CELTDecoder *celt_decoder_init(CELTDecoder *st, const CELTMode *mode, int channels, int *error)
1315 {
1316    if (channels < 0 || channels > 2)
1317    {
1318       if (error)
1319          *error = CELT_BAD_ARG;
1320       return NULL;
1321    }
1322
1323    if (st==NULL)
1324    {
1325       if (error)
1326          *error = CELT_ALLOC_FAIL;
1327       return NULL;
1328    }
1329
1330    CELT_MEMSET((char*)st, 0, celt_decoder_get_size(mode, channels));
1331
1332    st->mode = mode;
1333    st->overlap = mode->overlap;
1334    st->channels = channels;
1335
1336    st->start = 0;
1337    st->end = st->mode->effEBands;
1338
1339    st->loss_count = 0;
1340
1341    if (error)
1342       *error = CELT_OK;
1343    return st;
1344 }
1345
1346 void celt_decoder_destroy(CELTDecoder *st)
1347 {
1348    celt_free(st);
1349 }
1350
1351 static void celt_decode_lost(CELTDecoder * restrict st, celt_word16 * restrict pcm, int N, int LM)
1352 {
1353    int c;
1354    int pitch_index;
1355    int overlap = st->mode->overlap;
1356    celt_word16 fade = Q15ONE;
1357    int i, len;
1358    const int C = CHANNELS(st->channels);
1359    int offset;
1360    celt_sig *out_mem[2];
1361    celt_sig *decode_mem[2];
1362    celt_sig *overlap_mem[2];
1363    celt_word16 *lpc;
1364    SAVE_STACK;
1365    
1366    c=0; do {
1367       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
1368       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
1369       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
1370    } while (++c<C);
1371    lpc = (celt_word16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*C);
1372
1373    len = N+st->mode->overlap;
1374    
1375    if (st->loss_count == 0)
1376    {
1377       celt_word16 pitch_buf[MAX_PERIOD>>1];
1378       celt_word32 tmp=0;
1379       celt_word32 mem0[2]={0,0};
1380       celt_word16 mem1[2]={0,0};
1381       int len2 = len;
1382       /* FIXME: This is a kludge */
1383       if (len2>MAX_PERIOD>>1)
1384          len2 = MAX_PERIOD>>1;
1385       pitch_downsample(out_mem, pitch_buf, MAX_PERIOD, MAX_PERIOD,
1386                        C, mem0, mem1);
1387       pitch_search(st->mode, pitch_buf+((MAX_PERIOD-len2)>>1), pitch_buf, len2,
1388                    MAX_PERIOD-len2-100, &pitch_index, &tmp, 1<<LM);
1389       pitch_index = MAX_PERIOD-len2-pitch_index;
1390       st->last_pitch_index = pitch_index;
1391    } else {
1392       pitch_index = st->last_pitch_index;
1393       if (st->loss_count < 5)
1394          fade = QCONST16(.8f,15);
1395       else
1396          fade = 0;
1397    }
1398
1399    c=0; do {
1400       /* FIXME: This is more memory than necessary */
1401       celt_word32 e[2*MAX_PERIOD];
1402       celt_word16 exc[2*MAX_PERIOD];
1403       celt_word32 ac[LPC_ORDER+1];
1404       celt_word16 decay = 1;
1405       celt_word32 S1=0;
1406       celt_word16 mem[LPC_ORDER]={0};
1407
1408       offset = MAX_PERIOD-pitch_index;
1409       for (i=0;i<MAX_PERIOD;i++)
1410          exc[i] = ROUND16(out_mem[c][i], SIG_SHIFT);
1411
1412       if (st->loss_count == 0)
1413       {
1414          _celt_autocorr(exc, ac, st->mode->window, st->mode->overlap,
1415                         LPC_ORDER, MAX_PERIOD);
1416
1417          /* Noise floor -40 dB */
1418 #ifdef FIXED_POINT
1419          ac[0] += SHR32(ac[0],13);
1420 #else
1421          ac[0] *= 1.0001f;
1422 #endif
1423          /* Lag windowing */
1424          for (i=1;i<=LPC_ORDER;i++)
1425          {
1426             /*ac[i] *= exp(-.5*(2*M_PI*.002*i)*(2*M_PI*.002*i));*/
1427 #ifdef FIXED_POINT
1428             ac[i] -= MULT16_32_Q15(2*i*i, ac[i]);
1429 #else
1430             ac[i] -= ac[i]*(.008f*i)*(.008f*i);
1431 #endif
1432          }
1433
1434          _celt_lpc(lpc+c*LPC_ORDER, ac, LPC_ORDER);
1435       }
1436       for (i=0;i<LPC_ORDER;i++)
1437          mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT);
1438       fir(exc, lpc+c*LPC_ORDER, exc, MAX_PERIOD, LPC_ORDER, mem);
1439       /*for (i=0;i<MAX_PERIOD;i++)printf("%d ", exc[i]); printf("\n");*/
1440       /* Check if the waveform is decaying (and if so how fast) */
1441       {
1442          celt_word32 E1=1, E2=1;
1443          int period;
1444          if (pitch_index <= MAX_PERIOD/2)
1445             period = pitch_index;
1446          else
1447             period = MAX_PERIOD/2;
1448          for (i=0;i<period;i++)
1449          {
1450             E1 += SHR32(MULT16_16(exc[MAX_PERIOD-period+i],exc[MAX_PERIOD-period+i]),8);
1451             E2 += SHR32(MULT16_16(exc[MAX_PERIOD-2*period+i],exc[MAX_PERIOD-2*period+i]),8);
1452          }
1453          if (E1 > E2)
1454             E1 = E2;
1455          decay = celt_sqrt(frac_div32(SHR(E1,1),E2));
1456       }
1457
1458       /* Copy excitation, taking decay into account */
1459       for (i=0;i<len+st->mode->overlap;i++)
1460       {
1461          celt_word16 tmp;
1462          if (offset+i >= MAX_PERIOD)
1463          {
1464             offset -= pitch_index;
1465             decay = MULT16_16_Q15(decay, decay);
1466          }
1467          e[i] = SHL32(EXTEND32(MULT16_16_Q15(decay, exc[offset+i])), SIG_SHIFT);
1468          tmp = ROUND16(out_mem[c][offset+i],SIG_SHIFT);
1469          S1 += SHR32(MULT16_16(tmp,tmp),8);
1470       }
1471       for (i=0;i<LPC_ORDER;i++)
1472          mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT);
1473       for (i=0;i<len+st->mode->overlap;i++)
1474          e[i] = MULT16_32_Q15(fade, e[i]);
1475       iir(e, lpc+c*LPC_ORDER, e, len+st->mode->overlap, LPC_ORDER, mem);
1476
1477       {
1478          celt_word32 S2=0;
1479          for (i=0;i<len+overlap;i++)
1480          {
1481             celt_word16 tmp = ROUND16(e[i],SIG_SHIFT);
1482             S2 += SHR32(MULT16_16(tmp,tmp),8);
1483          }
1484          /* This checks for an "explosion" in the synthesis */
1485 #ifdef FIXED_POINT
1486          if (!(S1 > SHR32(S2,2)))
1487 #else
1488          /* Float test is written this way to catch NaNs at the same time */
1489          if (!(S1 > 0.2f*S2))
1490 #endif
1491          {
1492             for (i=0;i<len+overlap;i++)
1493                e[i] = 0;
1494          } else if (S1 < S2)
1495          {
1496             celt_word16 ratio = celt_sqrt(frac_div32(SHR32(S1,1)+1,S2+1));
1497             for (i=0;i<len+overlap;i++)
1498                e[i] = MULT16_32_Q15(ratio, e[i]);
1499          }
1500       }
1501
1502 #ifdef ENABLE_POSTFILTER
1503       /* Apply post-filter to the MDCT overlap of the previous frame */
1504       comb_filter(out_mem[c]+MAX_PERIOD, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap, C,
1505                   st->postfilter_gain, st->postfilter_gain, NULL, 0);
1506 #endif /* ENABLE_POSTFILTER */
1507
1508       for (i=0;i<MAX_PERIOD+st->mode->overlap-N;i++)
1509          out_mem[c][i] = out_mem[c][N+i];
1510
1511       /* Apply TDAC to the concealed audio so that it blends with the
1512          previous and next frames */
1513       for (i=0;i<overlap/2;i++)
1514       {
1515          celt_word32 tmp;
1516          tmp = MULT16_32_Q15(st->mode->window[i],           e[N+overlap-1-i]) +
1517                MULT16_32_Q15(st->mode->window[overlap-i-1], e[N+i          ]);
1518          out_mem[c][MAX_PERIOD+i] = MULT16_32_Q15(st->mode->window[overlap-i-1], tmp);
1519          out_mem[c][MAX_PERIOD+overlap-i-1] = MULT16_32_Q15(st->mode->window[i], tmp);
1520       }
1521       for (i=0;i<N;i++)
1522          out_mem[c][MAX_PERIOD-N+i] = e[i];
1523
1524 #ifdef ENABLE_POSTFILTER
1525       /* Apply pre-filter to the MDCT overlap for the next frame (post-filter will be applied then) */
1526       comb_filter(e, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap, C,
1527                   -st->postfilter_gain, -st->postfilter_gain, NULL, 0);
1528 #endif /* ENABLE_POSTFILTER */
1529       for (i=0;i<overlap;i++)
1530          out_mem[c][MAX_PERIOD+i] = e[i];
1531    } while (++c<C);
1532
1533    {
1534       celt_word32 *out_syn[2];
1535       out_syn[0] = out_mem[0]+MAX_PERIOD-N;
1536       if (C==2)
1537          out_syn[1] = out_mem[1]+MAX_PERIOD-N;
1538       deemphasis(out_syn, pcm, N, C, st->mode->preemph, st->preemph_memD);
1539    }
1540    
1541    st->loss_count++;
1542
1543    RESTORE_STACK;
1544 }
1545
1546 #ifdef FIXED_POINT
1547 int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size, ec_dec *dec)
1548 {
1549 #else
1550 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)
1551 {
1552 #endif
1553    int c, i, N;
1554    int has_fold;
1555    int bits;
1556    ec_dec _dec;
1557    ec_byte_buffer buf;
1558    VARDECL(celt_sig, freq);
1559    VARDECL(celt_norm, X);
1560    VARDECL(celt_ener, bandE);
1561    VARDECL(int, fine_quant);
1562    VARDECL(int, pulses);
1563    VARDECL(int, offsets);
1564    VARDECL(int, fine_priority);
1565    VARDECL(int, tf_res);
1566    celt_sig *out_mem[2];
1567    celt_sig *decode_mem[2];
1568    celt_sig *overlap_mem[2];
1569    celt_sig *out_syn[2];
1570    celt_word16 *lpc;
1571    celt_word16 *oldBandE;
1572
1573    int shortBlocks;
1574    int isTransient;
1575    int intra_ener;
1576    const int C = CHANNELS(st->channels);
1577    int LM, M;
1578    int nbFilledBytes, nbAvailableBytes;
1579    int effEnd;
1580    int codedBands;
1581    int alloc_trim;
1582    int postfilter_pitch;
1583    celt_word16 postfilter_gain;
1584    SAVE_STACK;
1585
1586    if (pcm==NULL)
1587       return CELT_BAD_ARG;
1588
1589    for (LM=0;LM<4;LM++)
1590       if (st->mode->shortMdctSize<<LM==frame_size)
1591          break;
1592    if (LM>=MAX_CONFIG_SIZES)
1593       return CELT_BAD_ARG;
1594    M=1<<LM;
1595
1596    c=0; do {
1597       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
1598       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
1599       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
1600    } while (++c<C);
1601    lpc = (celt_word16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*C);
1602    oldBandE = lpc+C*LPC_ORDER;
1603
1604    N = M*st->mode->shortMdctSize;
1605
1606    effEnd = st->end;
1607    if (effEnd > st->mode->effEBands)
1608       effEnd = st->mode->effEBands;
1609
1610    ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
1611    ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
1612    ALLOC(bandE, st->mode->nbEBands*C, celt_ener);
1613    c=0; do
1614       for (i=0;i<M*st->mode->eBands[st->start];i++)
1615          X[c*N+i] = 0;
1616    while (++c<C);
1617    c=0; do   
1618       for (i=M*st->mode->eBands[effEnd];i<N;i++)
1619          X[c*N+i] = 0;
1620    while (++c<C);
1621
1622    if (data == NULL)
1623    {
1624       celt_decode_lost(st, pcm, N, LM);
1625       RESTORE_STACK;
1626       return CELT_OK;
1627    }
1628    if (len<0) {
1629      RESTORE_STACK;
1630      return CELT_BAD_ARG;
1631    }
1632    
1633    if (dec == NULL)
1634    {
1635       ec_byte_readinit(&buf,(unsigned char*)data,len);
1636       ec_dec_init(&_dec,&buf);
1637       dec = &_dec;
1638       nbFilledBytes = 0;
1639    } else {
1640       nbFilledBytes = (ec_dec_tell(dec, 0)+4)>>3;
1641    }
1642    nbAvailableBytes = len-nbFilledBytes;
1643
1644    if (ec_dec_bit_prob(dec, 32768))
1645    {
1646 #ifdef ENABLE_POSTFILTER
1647       int qg, octave;
1648       octave = ec_dec_uint(dec, 6);
1649       postfilter_pitch = (16<<octave)+ec_dec_bits(dec, 4+octave);
1650       qg = ec_dec_bits(dec, 2);
1651       postfilter_gain = QCONST16(.125f,15)*(qg+2);
1652 #else /* ENABLE_POSTFILTER */
1653       RESTORE_STACK;
1654       return CELT_CORRUPTED_DATA;
1655 #endif /* ENABLE_POSTFILTER */
1656
1657    } else {
1658       postfilter_gain = 0;
1659       postfilter_pitch = 0;
1660    }
1661
1662    /* Decode the global flags (first symbols in the stream) */
1663    intra_ener = ec_dec_bit_prob(dec, 8192);
1664    /* Get band energies */
1665    unquant_coarse_energy(st->mode, st->start, st->end, bandE, oldBandE,
1666          intra_ener, st->mode->prob, dec, C, LM);
1667
1668    if (LM > 0)
1669       isTransient = ec_dec_bit_prob(dec, 8192);
1670    else
1671       isTransient = 0;
1672
1673    if (isTransient)
1674       shortBlocks = M;
1675    else
1676       shortBlocks = 0;
1677
1678    ALLOC(tf_res, st->mode->nbEBands, int);
1679    tf_decode(st->start, st->end, C, isTransient, tf_res, nbAvailableBytes, LM, dec);
1680
1681    has_fold = ec_dec_bit_prob(dec, 8192)<<1;
1682    has_fold |= ec_dec_bit_prob(dec, (has_fold>>1) ? 32768 : 49152);
1683
1684    ALLOC(pulses, st->mode->nbEBands, int);
1685    ALLOC(offsets, st->mode->nbEBands, int);
1686    ALLOC(fine_priority, st->mode->nbEBands, int);
1687
1688    for (i=0;i<st->mode->nbEBands;i++)
1689       offsets[i] = 0;
1690    for (i=0;i<st->mode->nbEBands;i++)
1691    {
1692       if (ec_dec_bit_prob(dec, 1024))
1693       {
1694          while (ec_dec_bit_prob(dec, 32768))
1695             offsets[i]++;
1696          offsets[i]++;
1697          offsets[i] *= (6<<BITRES);
1698       }
1699    }
1700
1701    ALLOC(fine_quant, st->mode->nbEBands, int);
1702    {
1703       int fl;
1704       alloc_trim = 0;
1705       fl = ec_decode_bin(dec, 7);
1706       while (trim_cdf[alloc_trim+1] <= fl)
1707          alloc_trim++;
1708       ec_dec_update(dec, trim_cdf[alloc_trim], trim_cdf[alloc_trim+1], 128);
1709    }
1710
1711    bits = len*8 - ec_dec_tell(dec, 0) - 1;
1712    codedBands = compute_allocation(st->mode, st->start, st->end, offsets, alloc_trim, bits, pulses, fine_quant, fine_priority, C, LM);
1713    
1714    unquant_fine_energy(st->mode, st->start, st->end, bandE, oldBandE, fine_quant, dec, C);
1715
1716    /* Decode fixed codebook */
1717    quant_all_bands(0, st->mode, st->start, st->end, X, C==2 ? X+N : NULL, NULL, pulses, shortBlocks, has_fold, tf_res, 1, len*8, dec, LM, codedBands);
1718
1719    unquant_energy_finalise(st->mode, st->start, st->end, bandE, oldBandE,
1720          fine_quant, fine_priority, len*8-ec_dec_tell(dec, 0), dec, C);
1721
1722    log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
1723
1724    /* Synthesis */
1725    denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
1726
1727    CELT_MOVE(decode_mem[0], decode_mem[0]+N, DECODE_BUFFER_SIZE-N);
1728    if (C==2)
1729       CELT_MOVE(decode_mem[1], decode_mem[1]+N, DECODE_BUFFER_SIZE-N);
1730
1731    c=0; do
1732       for (i=0;i<M*st->mode->eBands[st->start];i++)
1733          freq[c*N+i] = 0;
1734    while (++c<C);
1735    c=0; do
1736       for (i=M*st->mode->eBands[effEnd];i<N;i++)
1737          freq[c*N+i] = 0;
1738    while (++c<C);
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    /* Compute inverse MDCTs */
1745    compute_inv_mdcts(st->mode, shortBlocks, freq, out_syn, overlap_mem, C, LM);
1746
1747 #ifdef ENABLE_POSTFILTER
1748    c=0; do {
1749       comb_filter(out_syn[c], out_syn[c], st->postfilter_period, st->postfilter_period, st->overlap, C,
1750             st->postfilter_gain, st->postfilter_gain, NULL, 0);
1751       comb_filter(out_syn[c]+st->overlap, out_syn[c]+st->overlap, st->postfilter_period, postfilter_pitch, N-st->overlap, C,
1752             st->postfilter_gain, postfilter_gain, st->mode->window, st->mode->overlap);
1753    } while (++c<C);
1754    st->postfilter_period = postfilter_pitch;
1755    st->postfilter_gain = postfilter_gain;
1756 #endif /* ENABLE_POSTFILTER */
1757
1758    deemphasis(out_syn, pcm, N, C, st->mode->preemph, st->preemph_memD);
1759    st->loss_count = 0;
1760    RESTORE_STACK;
1761    if (ec_dec_get_error(dec))
1762       return CELT_CORRUPTED_DATA;
1763    else
1764       return CELT_OK;
1765 }
1766
1767 #ifdef FIXED_POINT
1768 #ifndef DISABLE_FLOAT_API
1769 int celt_decode_with_ec_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size, ec_dec *dec)
1770 {
1771    int j, ret, C, N, LM, M;
1772    VARDECL(celt_int16, out);
1773    SAVE_STACK;
1774
1775    if (pcm==NULL)
1776       return CELT_BAD_ARG;
1777
1778    for (LM=0;LM<4;LM++)
1779       if (st->mode->shortMdctSize<<LM==frame_size)
1780          break;
1781    if (LM>=MAX_CONFIG_SIZES)
1782       return CELT_BAD_ARG;
1783    M=1<<LM;
1784
1785    C = CHANNELS(st->channels);
1786    N = M*st->mode->shortMdctSize;
1787    
1788    ALLOC(out, C*N, celt_int16);
1789    ret=celt_decode_with_ec(st, data, len, out, frame_size, dec);
1790    if (ret==0)
1791       for (j=0;j<C*N;j++)
1792          pcm[j]=out[j]*(1.f/32768.f);
1793      
1794    RESTORE_STACK;
1795    return ret;
1796 }
1797 #endif /*DISABLE_FLOAT_API*/
1798 #else
1799 int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size, ec_dec *dec)
1800 {
1801    int j, ret, C, N, LM, M;
1802    VARDECL(celt_sig, out);
1803    SAVE_STACK;
1804
1805    if (pcm==NULL)
1806       return CELT_BAD_ARG;
1807
1808    for (LM=0;LM<4;LM++)
1809       if (st->mode->shortMdctSize<<LM==frame_size)
1810          break;
1811    if (LM>=MAX_CONFIG_SIZES)
1812       return CELT_BAD_ARG;
1813    M=1<<LM;
1814
1815    C = CHANNELS(st->channels);
1816    N = M*st->mode->shortMdctSize;
1817    ALLOC(out, C*N, celt_sig);
1818
1819    ret=celt_decode_with_ec_float(st, data, len, out, frame_size, dec);
1820
1821    if (ret==0)
1822       for (j=0;j<C*N;j++)
1823          pcm[j] = FLOAT2INT16 (out[j]);
1824    
1825    RESTORE_STACK;
1826    return ret;
1827 }
1828 #endif
1829
1830 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size)
1831 {
1832    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
1833 }
1834
1835 #ifndef DISABLE_FLOAT_API
1836 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size)
1837 {
1838    return celt_decode_with_ec_float(st, data, len, pcm, frame_size, NULL);
1839 }
1840 #endif /* DISABLE_FLOAT_API */
1841
1842 int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
1843 {
1844    va_list ap;
1845
1846    va_start(ap, request);
1847    switch (request)
1848    {
1849       case CELT_GET_MODE_REQUEST:
1850       {
1851          const CELTMode ** value = va_arg(ap, const CELTMode**);
1852          if (value==0)
1853             goto bad_arg;
1854          *value=st->mode;
1855       }
1856       break;
1857       case CELT_SET_START_BAND_REQUEST:
1858       {
1859          celt_int32 value = va_arg(ap, celt_int32);
1860          if (value<0 || value>=st->mode->nbEBands)
1861             goto bad_arg;
1862          st->start = value;
1863       }
1864       break;
1865       case CELT_SET_END_BAND_REQUEST:
1866       {
1867          celt_int32 value = va_arg(ap, celt_int32);
1868          if (value<0 || value>=st->mode->nbEBands)
1869             goto bad_arg;
1870          st->end = value;
1871       }
1872       break;
1873       case CELT_RESET_STATE:
1874       {
1875          CELT_MEMSET((char*)&st->DECODER_RESET_START, 0,
1876                celt_decoder_get_size(st->mode, st->channels)-
1877                ((char*)&st->DECODER_RESET_START - (char*)st));
1878       }
1879       break;
1880       default:
1881          goto bad_request;
1882    }
1883    va_end(ap);
1884    return CELT_OK;
1885 bad_arg:
1886    va_end(ap);
1887    return CELT_BAD_ARG;
1888 bad_request:
1889       va_end(ap);
1890   return CELT_UNIMPLEMENTED;
1891 }
1892
1893 const char *celt_strerror(int error)
1894 {
1895    static const char *error_strings[8] = {
1896       "success",
1897       "invalid argument",
1898       "invalid mode",
1899       "internal error",
1900       "corrupted stream",
1901       "request not implemented",
1902       "invalid state",
1903       "memory allocation failed"
1904    };
1905    if (error > 0 || error < -7)
1906       return "unknown error";
1907    else 
1908       return error_strings[-error];
1909 }
1910