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