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