Minor tuning
[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, 10, 23, 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       fir(exc, lpc+c*LPC_ORDER, exc, MAX_PERIOD, LPC_ORDER, mem);
1437       /*for (i=0;i<MAX_PERIOD;i++)printf("%d ", exc[i]); printf("\n");*/
1438       /* Check if the waveform is decaying (and if so how fast) */
1439       {
1440          celt_word32 E1=1, E2=1;
1441          int period;
1442          if (pitch_index <= MAX_PERIOD/2)
1443             period = pitch_index;
1444          else
1445             period = MAX_PERIOD/2;
1446          for (i=0;i<period;i++)
1447          {
1448             E1 += SHR32(MULT16_16(exc[MAX_PERIOD-period+i],exc[MAX_PERIOD-period+i]),8);
1449             E2 += SHR32(MULT16_16(exc[MAX_PERIOD-2*period+i],exc[MAX_PERIOD-2*period+i]),8);
1450          }
1451          if (E1 > E2)
1452             E1 = E2;
1453          decay = celt_sqrt(frac_div32(SHR(E1,1),E2));
1454       }
1455
1456       /* Copy excitation, taking decay into account */
1457       for (i=0;i<len+st->mode->overlap;i++)
1458       {
1459          if (offset+i >= MAX_PERIOD)
1460          {
1461             offset -= pitch_index;
1462             decay = MULT16_16_Q15(decay, decay);
1463          }
1464          e[i] = SHL32(EXTEND32(MULT16_16_Q15(decay, exc[offset+i])), SIG_SHIFT);
1465          S1 += SHR32(MULT16_16(out_mem[c][offset+i],out_mem[c][offset+i]),8);
1466       }
1467       for (i=0;i<LPC_ORDER;i++)
1468          mem[i] = out_mem[c][MAX_PERIOD-i];
1469       for (i=0;i<len+st->mode->overlap;i++)
1470          e[i] = MULT16_32_Q15(fade, e[i]);
1471       iir(e, lpc+c*LPC_ORDER, e, len+st->mode->overlap, LPC_ORDER, mem);
1472
1473       {
1474          celt_word32 S2=0;
1475          for (i=0;i<len+overlap;i++)
1476             S2 += SHR32(MULT16_16(e[i],e[i]),8);
1477          /* This checks for an "explosion" in the synthesis */
1478 #ifdef FIXED_POINT
1479          if (!(S1 > SHR32(S2,2)))
1480 #else
1481          /* Float test is written this way to catch NaNs at the same time */
1482          if (!(S1 > 0.2f*S2))
1483 #endif
1484          {
1485             for (i=0;i<len+overlap;i++)
1486                e[i] = 0;
1487          } else if (S1 < S2)
1488          {
1489             celt_word16 ratio = celt_sqrt(frac_div32(SHR32(S1,1)+1,S2+1));
1490             for (i=0;i<len+overlap;i++)
1491                e[i] = MULT16_16_Q15(ratio, e[i]);
1492          }
1493       }
1494
1495 #ifdef ENABLE_POSTFILTER
1496       /* Apply post-filter to the MDCT overlap of the previous frame */
1497       comb_filter(out_mem[c]+MAX_PERIOD, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap, C,
1498                   st->postfilter_gain, st->postfilter_gain, NULL, 0);
1499 #endif /* ENABLE_POSTFILTER */
1500
1501       for (i=0;i<MAX_PERIOD+st->mode->overlap-N;i++)
1502          out_mem[c][i] = out_mem[c][N+i];
1503
1504       /* Apply TDAC to the concealed audio so that it blends with the
1505          previous and next frames */
1506       for (i=0;i<overlap/2;i++)
1507       {
1508          celt_word32 tmp1, tmp2;
1509          tmp1 = MULT16_32_Q15(st->mode->window[i          ], e[i          ]) -
1510                 MULT16_32_Q15(st->mode->window[overlap-i-1], e[overlap-i-1]);
1511          tmp2 = MULT16_32_Q15(st->mode->window[i],           e[N+overlap-1-i]) +
1512                 MULT16_32_Q15(st->mode->window[overlap-i-1], e[N+i          ]);
1513          out_mem[c][MAX_PERIOD+i] = MULT16_32_Q15(st->mode->window[overlap-i-1], tmp2);
1514          out_mem[c][MAX_PERIOD+overlap-i-1] = MULT16_32_Q15(st->mode->window[i], tmp2);
1515          out_mem[c][MAX_PERIOD-N+i] += MULT16_32_Q15(st->mode->window[i], tmp1);
1516          out_mem[c][MAX_PERIOD-N+overlap-i-1] -= MULT16_32_Q15(st->mode->window[overlap-i-1], tmp1);
1517       }
1518       for (i=0;i<N-overlap;i++)
1519          out_mem[c][MAX_PERIOD-N+overlap+i] = e[overlap+i];
1520
1521 #ifdef ENABLE_POSTFILTER
1522       /* Apply pre-filter to the MDCT overlap for the next frame (post-filter will be applied then) */
1523       comb_filter(e, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap, C,
1524                   -st->postfilter_gain, -st->postfilter_gain, NULL, 0);
1525 #endif /* ENABLE_POSTFILTER */
1526       for (i=0;i<overlap;i++)
1527          out_mem[c][MAX_PERIOD+i] = e[i];
1528    } while (++c<C);
1529
1530    {
1531       celt_word32 *out_syn[2];
1532       out_syn[0] = out_mem[0]+MAX_PERIOD-N;
1533       if (C==2)
1534          out_syn[1] = out_mem[1]+MAX_PERIOD-N;
1535       deemphasis(out_syn, pcm, N, C, st->mode->preemph, st->preemph_memD);
1536    }
1537    
1538    st->loss_count++;
1539
1540    RESTORE_STACK;
1541 }
1542
1543 #ifdef FIXED_POINT
1544 int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size, ec_dec *dec)
1545 {
1546 #else
1547 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)
1548 {
1549 #endif
1550    int c, i, N;
1551    int has_fold;
1552    int bits;
1553    ec_dec _dec;
1554    ec_byte_buffer buf;
1555    VARDECL(celt_sig, freq);
1556    VARDECL(celt_norm, X);
1557    VARDECL(celt_ener, bandE);
1558    VARDECL(int, fine_quant);
1559    VARDECL(int, pulses);
1560    VARDECL(int, offsets);
1561    VARDECL(int, fine_priority);
1562    VARDECL(int, tf_res);
1563    celt_sig *out_mem[2];
1564    celt_sig *decode_mem[2];
1565    celt_sig *overlap_mem[2];
1566    celt_sig *out_syn[2];
1567    celt_word16 *lpc;
1568    celt_word16 *oldBandE;
1569
1570    int shortBlocks;
1571    int isTransient;
1572    int intra_ener;
1573    const int C = CHANNELS(st->channels);
1574    int LM, M;
1575    int nbFilledBytes, nbAvailableBytes;
1576    int effEnd;
1577    int codedBands;
1578    int alloc_trim;
1579    int postfilter_pitch;
1580    celt_word16 postfilter_gain;
1581    SAVE_STACK;
1582
1583    if (pcm==NULL)
1584       return CELT_BAD_ARG;
1585
1586    for (LM=0;LM<4;LM++)
1587       if (st->mode->shortMdctSize<<LM==frame_size)
1588          break;
1589    if (LM>=MAX_CONFIG_SIZES)
1590       return CELT_BAD_ARG;
1591    M=1<<LM;
1592
1593    c=0; do {
1594       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
1595       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
1596       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
1597    } while (++c<C);
1598    lpc = (celt_word16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*C);
1599    oldBandE = lpc+C*LPC_ORDER;
1600
1601    N = M*st->mode->shortMdctSize;
1602
1603    effEnd = st->end;
1604    if (effEnd > st->mode->effEBands)
1605       effEnd = st->mode->effEBands;
1606
1607    ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
1608    ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
1609    ALLOC(bandE, st->mode->nbEBands*C, celt_ener);
1610    c=0; do
1611       for (i=0;i<M*st->mode->eBands[st->start];i++)
1612          X[c*N+i] = 0;
1613    while (++c<C);
1614    c=0; do   
1615       for (i=M*st->mode->eBands[effEnd];i<N;i++)
1616          X[c*N+i] = 0;
1617    while (++c<C);
1618
1619    if (data == NULL)
1620    {
1621       celt_decode_lost(st, pcm, N, LM);
1622       RESTORE_STACK;
1623       return CELT_OK;
1624    }
1625    if (len<0) {
1626      RESTORE_STACK;
1627      return CELT_BAD_ARG;
1628    }
1629    
1630    if (dec == NULL)
1631    {
1632       ec_byte_readinit(&buf,(unsigned char*)data,len);
1633       ec_dec_init(&_dec,&buf);
1634       dec = &_dec;
1635       nbFilledBytes = 0;
1636    } else {
1637       nbFilledBytes = (ec_dec_tell(dec, 0)+4)>>3;
1638    }
1639    nbAvailableBytes = len-nbFilledBytes;
1640
1641    if (ec_dec_bit_prob(dec, 32768))
1642    {
1643 #ifdef ENABLE_POSTFILTER
1644       int qg, octave;
1645       octave = ec_dec_uint(dec, 6);
1646       postfilter_pitch = (16<<octave)+ec_dec_bits(dec, 4+octave);
1647       qg = ec_dec_bits(dec, 2);
1648       postfilter_gain = QCONST16(.125f,15)*(qg+2);
1649 #else /* ENABLE_POSTFILTER */
1650       RESTORE_STACK;
1651       return CELT_CORRUPTED_DATA;
1652 #endif /* ENABLE_POSTFILTER */
1653
1654    } else {
1655       postfilter_gain = 0;
1656       postfilter_pitch = 0;
1657    }
1658
1659    /* Decode the global flags (first symbols in the stream) */
1660    intra_ener = ec_dec_bit_prob(dec, 8192);
1661    /* Get band energies */
1662    unquant_coarse_energy(st->mode, st->start, st->end, bandE, oldBandE,
1663          intra_ener, st->mode->prob, dec, C, LM);
1664
1665    if (LM > 0)
1666       isTransient = ec_dec_bit_prob(dec, 8192);
1667    else
1668       isTransient = 0;
1669
1670    if (isTransient)
1671       shortBlocks = M;
1672    else
1673       shortBlocks = 0;
1674
1675    ALLOC(tf_res, st->mode->nbEBands, int);
1676    tf_decode(st->start, st->end, C, isTransient, tf_res, nbAvailableBytes, LM, dec);
1677
1678    has_fold = ec_dec_bit_prob(dec, 8192)<<1;
1679    has_fold |= ec_dec_bit_prob(dec, (has_fold>>1) ? 32768 : 49152);
1680
1681    ALLOC(pulses, st->mode->nbEBands, int);
1682    ALLOC(offsets, st->mode->nbEBands, int);
1683    ALLOC(fine_priority, st->mode->nbEBands, int);
1684
1685    for (i=0;i<st->mode->nbEBands;i++)
1686       offsets[i] = 0;
1687    for (i=0;i<st->mode->nbEBands;i++)
1688    {
1689       if (ec_dec_bit_prob(dec, 1024))
1690       {
1691          while (ec_dec_bit_prob(dec, 32768))
1692             offsets[i]++;
1693          offsets[i]++;
1694          offsets[i] *= (6<<BITRES);
1695       }
1696    }
1697
1698    ALLOC(fine_quant, st->mode->nbEBands, int);
1699    {
1700       int fl;
1701       alloc_trim = 0;
1702       fl = ec_decode_bin(dec, 7);
1703       while (trim_cdf[alloc_trim+1] <= fl)
1704          alloc_trim++;
1705       ec_dec_update(dec, trim_cdf[alloc_trim], trim_cdf[alloc_trim+1], 128);
1706    }
1707
1708    bits = len*8 - ec_dec_tell(dec, 0) - 1;
1709    codedBands = compute_allocation(st->mode, st->start, st->end, offsets, alloc_trim, bits, pulses, fine_quant, fine_priority, C, LM);
1710    
1711    unquant_fine_energy(st->mode, st->start, st->end, bandE, oldBandE, fine_quant, dec, C);
1712
1713    /* Decode fixed codebook */
1714    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);
1715
1716    unquant_energy_finalise(st->mode, st->start, st->end, bandE, oldBandE,
1717          fine_quant, fine_priority, len*8-ec_dec_tell(dec, 0), dec, C);
1718
1719    log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
1720
1721    /* Synthesis */
1722    denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
1723
1724    CELT_MOVE(decode_mem[0], decode_mem[0]+N, DECODE_BUFFER_SIZE-N);
1725    if (C==2)
1726       CELT_MOVE(decode_mem[1], decode_mem[1]+N, DECODE_BUFFER_SIZE-N);
1727
1728    c=0; do
1729       for (i=0;i<M*st->mode->eBands[st->start];i++)
1730          freq[c*N+i] = 0;
1731    while (++c<C);
1732    c=0; do
1733       for (i=M*st->mode->eBands[effEnd];i<N;i++)
1734          freq[c*N+i] = 0;
1735    while (++c<C);
1736
1737    out_syn[0] = out_mem[0]+MAX_PERIOD-N;
1738    if (C==2)
1739       out_syn[1] = out_mem[1]+MAX_PERIOD-N;
1740
1741    /* Compute inverse MDCTs */
1742    compute_inv_mdcts(st->mode, shortBlocks, freq, out_syn, overlap_mem, C, LM);
1743
1744 #ifdef ENABLE_POSTFILTER
1745    c=0; do {
1746       comb_filter(out_syn[c], out_syn[c], st->postfilter_period, st->postfilter_period, st->overlap, C,
1747             st->postfilter_gain, st->postfilter_gain, NULL, 0);
1748       comb_filter(out_syn[c]+st->overlap, out_syn[c]+st->overlap, st->postfilter_period, postfilter_pitch, N-st->overlap, C,
1749             st->postfilter_gain, postfilter_gain, st->mode->window, st->mode->overlap);
1750    } while (++c<C);
1751    st->postfilter_period = postfilter_pitch;
1752    st->postfilter_gain = postfilter_gain;
1753 #endif /* ENABLE_POSTFILTER */
1754
1755    deemphasis(out_syn, pcm, N, C, st->mode->preemph, st->preemph_memD);
1756    st->loss_count = 0;
1757    RESTORE_STACK;
1758    if (ec_dec_get_error(dec))
1759       return CELT_CORRUPTED_DATA;
1760    else
1761       return CELT_OK;
1762 }
1763
1764 #ifdef FIXED_POINT
1765 #ifndef DISABLE_FLOAT_API
1766 int celt_decode_with_ec_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size, ec_dec *dec)
1767 {
1768    int j, ret, C, N, LM, M;
1769    VARDECL(celt_int16, out);
1770    SAVE_STACK;
1771
1772    if (pcm==NULL)
1773       return CELT_BAD_ARG;
1774
1775    for (LM=0;LM<4;LM++)
1776       if (st->mode->shortMdctSize<<LM==frame_size)
1777          break;
1778    if (LM>=MAX_CONFIG_SIZES)
1779       return CELT_BAD_ARG;
1780    M=1<<LM;
1781
1782    C = CHANNELS(st->channels);
1783    N = M*st->mode->shortMdctSize;
1784    
1785    ALLOC(out, C*N, celt_int16);
1786    ret=celt_decode_with_ec(st, data, len, out, frame_size, dec);
1787    if (ret==0)
1788       for (j=0;j<C*N;j++)
1789          pcm[j]=out[j]*(1.f/32768.f);
1790      
1791    RESTORE_STACK;
1792    return ret;
1793 }
1794 #endif /*DISABLE_FLOAT_API*/
1795 #else
1796 int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size, ec_dec *dec)
1797 {
1798    int j, ret, C, N, LM, M;
1799    VARDECL(celt_sig, out);
1800    SAVE_STACK;
1801
1802    if (pcm==NULL)
1803       return CELT_BAD_ARG;
1804
1805    for (LM=0;LM<4;LM++)
1806       if (st->mode->shortMdctSize<<LM==frame_size)
1807          break;
1808    if (LM>=MAX_CONFIG_SIZES)
1809       return CELT_BAD_ARG;
1810    M=1<<LM;
1811
1812    C = CHANNELS(st->channels);
1813    N = M*st->mode->shortMdctSize;
1814    ALLOC(out, C*N, celt_sig);
1815
1816    ret=celt_decode_with_ec_float(st, data, len, out, frame_size, dec);
1817
1818    if (ret==0)
1819       for (j=0;j<C*N;j++)
1820          pcm[j] = FLOAT2INT16 (out[j]);
1821    
1822    RESTORE_STACK;
1823    return ret;
1824 }
1825 #endif
1826
1827 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size)
1828 {
1829    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
1830 }
1831
1832 #ifndef DISABLE_FLOAT_API
1833 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size)
1834 {
1835    return celt_decode_with_ec_float(st, data, len, pcm, frame_size, NULL);
1836 }
1837 #endif /* DISABLE_FLOAT_API */
1838
1839 int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
1840 {
1841    va_list ap;
1842
1843    va_start(ap, request);
1844    switch (request)
1845    {
1846       case CELT_GET_MODE_REQUEST:
1847       {
1848          const CELTMode ** value = va_arg(ap, const CELTMode**);
1849          if (value==0)
1850             goto bad_arg;
1851          *value=st->mode;
1852       }
1853       break;
1854       case CELT_SET_START_BAND_REQUEST:
1855       {
1856          celt_int32 value = va_arg(ap, celt_int32);
1857          if (value<0 || value>=st->mode->nbEBands)
1858             goto bad_arg;
1859          st->start = value;
1860       }
1861       break;
1862       case CELT_SET_END_BAND_REQUEST:
1863       {
1864          celt_int32 value = va_arg(ap, celt_int32);
1865          if (value<0 || value>=st->mode->nbEBands)
1866             goto bad_arg;
1867          st->end = value;
1868       }
1869       break;
1870       case CELT_RESET_STATE:
1871       {
1872          CELT_MEMSET((char*)&st->DECODER_RESET_START, 0,
1873                celt_decoder_get_size(st->mode, st->channels)-
1874                ((char*)&st->DECODER_RESET_START - (char*)st));
1875       }
1876       break;
1877       default:
1878          goto bad_request;
1879    }
1880    va_end(ap);
1881    return CELT_OK;
1882 bad_arg:
1883    va_end(ap);
1884    return CELT_BAD_ARG;
1885 bad_request:
1886       va_end(ap);
1887   return CELT_UNIMPLEMENTED;
1888 }
1889
1890 const char *celt_strerror(int error)
1891 {
1892    static const char *error_strings[8] = {
1893       "success",
1894       "invalid argument",
1895       "invalid mode",
1896       "internal error",
1897       "corrupted stream",
1898       "request not implemented",
1899       "invalid state",
1900       "memory allocation failed"
1901    };
1902    if (error > 0 || error < -7)
1903       return "unknown error";
1904    else 
1905       return error_strings[-error];
1906 }
1907