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