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