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