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