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