Improved error handling, and implemented celt_strerror()
[opus.git] / libcelt / celt.c
1 /* (C) 2007-2008 Jean-Marc Valin, CSIRO
2    (C) 2008 Gregory Maxwell */
3 /*
4    Redistribution and use in source and binary forms, with or without
5    modification, are permitted provided that the following conditions
6    are met:
7    
8    - Redistributions of source code must retain the above copyright
9    notice, this list of conditions and the following disclaimer.
10    
11    - Redistributions in binary form must reproduce the above copyright
12    notice, this list of conditions and the following disclaimer in the
13    documentation and/or other materials provided with the distribution.
14    
15    - Neither the name of the Xiph.org Foundation nor the names of its
16    contributors may be used to endorse or promote products derived from
17    this software without specific prior written permission.
18    
19    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
23    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #ifdef HAVE_CONFIG_H
33 #include "config.h"
34 #endif
35
36 #define CELT_C
37
38 #include "os_support.h"
39 #include "mdct.h"
40 #include <math.h>
41 #include "celt.h"
42 #include "pitch.h"
43 #include "kiss_fftr.h"
44 #include "bands.h"
45 #include "modes.h"
46 #include "entcode.h"
47 #include "quant_bands.h"
48 #include "psy.h"
49 #include "rate.h"
50 #include "stack_alloc.h"
51 #include "mathops.h"
52 #include "float_cast.h"
53 #include <stdarg.h>
54
55 static const celt_word16_t preemph = QCONST16(0.8f,15);
56
57 #ifdef FIXED_POINT
58 static const celt_word16_t transientWindow[16] = {
59      279,  1106,  2454,  4276,  6510,  9081, 11900, 14872,
60    17896, 20868, 23687, 26258, 28492, 30314, 31662, 32489};
61 #else
62 static const float transientWindow[16] = {
63    0.0085135, 0.0337639, 0.0748914, 0.1304955, 
64    0.1986827, 0.2771308, 0.3631685, 0.4538658,
65    0.5461342, 0.6368315, 0.7228692, 0.8013173, 
66    0.8695045, 0.9251086, 0.9662361, 0.9914865};
67 #endif
68
69 #define ENCODERVALID   0x4c434554
70 #define ENCODERPARTIAL 0x5445434c
71 #define ENCODERFREED   0x4c004500
72    
73 /** Encoder state 
74  @brief Encoder state
75  */
76 struct CELTEncoder {
77    celt_uint32_t marker;
78    const CELTMode *mode;     /**< Mode used by the encoder */
79    int frame_size;
80    int block_size;
81    int overlap;
82    int channels;
83    
84    int pitch_enabled;       /* Complexity level is allowed to use pitch */
85    int pitch_permitted;     /*  Use of the LTP is permitted by the user */
86    int pitch_available;     /*  Amount of pitch buffer available */
87    int force_intra;
88    int delayedIntra;
89    celt_word16_t tonal_average;
90    int fold_decision;
91
92    int VBR_rate; /* Target number of 16th bits per frame */
93    celt_word16_t * restrict preemph_memE; 
94    celt_sig_t    * restrict preemph_memD;
95
96    celt_sig_t *in_mem;
97    celt_sig_t *out_mem;
98
99    celt_word16_t *oldBandE;
100 #ifdef EXP_PSY
101    celt_word16_t *psy_mem;
102    struct PsyDecay psy;
103 #endif
104 };
105
106 static int check_encoder(const CELTEncoder *st) 
107 {
108    if (st==NULL)
109    {
110       celt_warning("NULL passed as an encoder structure");  
111       return CELT_INVALID_STATE;
112    }
113    if (st->marker == ENCODERVALID)
114       return CELT_OK;
115    if (st->marker == ENCODERFREED)
116       celt_warning("Referencing an encoder that has already been freed");
117    else
118       celt_warning("This is not a valid CELT encoder structure");
119    return CELT_INVALID_STATE;
120 }
121
122 CELTEncoder *celt_encoder_create(const CELTMode *mode, int channels, int *error)
123 {
124    int N, C;
125    CELTEncoder *st;
126
127    if (check_mode(mode) != CELT_OK)
128    {
129       if (error)
130          *error = CELT_INVALID_MODE;
131       return NULL;
132    }
133    if (channels < 0 || channels > 2)
134    {
135       celt_warning("Only mono and stereo supported");
136       if (error)
137          *error = CELT_BAD_ARG;
138       return NULL;
139    }
140
141    N = mode->mdctSize;
142    C = channels;
143    st = celt_alloc(sizeof(CELTEncoder));
144    
145    if (st==NULL)
146    {
147       if (error)
148          *error = CELT_ALLOC_FAIL;
149       return NULL;
150    }
151    st->marker = ENCODERPARTIAL;
152    st->mode = mode;
153    st->frame_size = N;
154    st->block_size = N;
155    st->overlap = mode->overlap;
156    st->channels = channels;
157
158    st->VBR_rate = 0;
159    st->pitch_enabled = 1;
160    st->pitch_permitted = 1;
161    st->pitch_available = 1;
162    st->force_intra  = 0;
163    st->delayedIntra = 1;
164    st->tonal_average = QCONST16(1.,8);
165    st->fold_decision = 1;
166
167    st->in_mem = celt_alloc(st->overlap*C*sizeof(celt_sig_t));
168    st->out_mem = celt_alloc((MAX_PERIOD+st->overlap)*C*sizeof(celt_sig_t));
169
170    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
171
172    st->preemph_memE = (celt_word16_t*)celt_alloc(C*sizeof(celt_word16_t));
173    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));
174
175 #ifdef EXP_PSY
176    st->psy_mem = celt_alloc(MAX_PERIOD*sizeof(celt_word16_t));
177    psydecay_init(&st->psy, MAX_PERIOD/2, st->mode->Fs);
178 #endif
179
180    if ((st->in_mem!=NULL) && (st->out_mem!=NULL) && (st->oldBandE!=NULL) 
181 #ifdef EXP_PSY
182        && (st->psy_mem!=NULL) 
183 #endif   
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    
225    celt_free(st->oldBandE);
226    
227    celt_free(st->preemph_memE);
228    celt_free(st->preemph_memD);
229    
230 #ifdef EXP_PSY
231    celt_free (st->psy_mem);
232    psydecay_clear(&st->psy);
233 #endif
234    st->marker = ENCODERFREED;
235    
236    celt_free(st);
237 }
238
239 static inline celt_int16_t FLOAT2INT16(float x)
240 {
241    x = x*CELT_SIG_SCALE;
242    x = MAX32(x, -32768);
243    x = MIN32(x, 32767);
244    return (celt_int16_t)float2int(x);
245 }
246
247 static inline celt_word16_t SIG2WORD16(celt_sig_t x)
248 {
249 #ifdef FIXED_POINT
250    x = PSHR32(x, SIG_SHIFT);
251    x = MAX32(x, -32768);
252    x = MIN32(x, 32767);
253    return EXTRACT16(x);
254 #else
255    return (celt_word16_t)x;
256 #endif
257 }
258
259 static int transient_analysis(celt_word32_t *in, int len, int C, int *transient_time, int *transient_shift)
260 {
261    int c, i, n;
262    celt_word32_t ratio;
263    VARDECL(celt_word32_t, begin);
264    SAVE_STACK;
265    ALLOC(begin, len, celt_word32_t);
266    for (i=0;i<len;i++)
267       begin[i] = ABS32(SHR32(in[C*i],SIG_SHIFT));
268    for (c=1;c<C;c++)
269    {
270       for (i=0;i<len;i++)
271          begin[i] = MAX32(begin[i], ABS32(SHR32(in[C*i+c],SIG_SHIFT)));
272    }
273    for (i=1;i<len;i++)
274       begin[i] = MAX32(begin[i-1],begin[i]);
275    n = -1;
276    for (i=8;i<len-8;i++)
277    {
278       if (begin[i] < MULT16_32_Q15(QCONST16(.2f,15),begin[len-1]))
279          n=i;
280    }
281    if (n<32)
282    {
283       n = -1;
284       ratio = 0;
285    } else {
286       ratio = DIV32(begin[len-1],1+begin[n-16]);
287    }
288    if (ratio < 0)
289       ratio = 0;
290    if (ratio > 1000)
291       ratio = 1000;
292    ratio *= ratio;
293    
294    if (ratio > 2048)
295       *transient_shift = 3;
296    else
297       *transient_shift = 0;
298    
299    *transient_time = n;
300    
301    RESTORE_STACK;
302    return ratio > 20;
303 }
304
305 /** Apply window and compute the MDCT for all sub-frames and 
306     all channels in a frame */
307 static void compute_mdcts(const CELTMode *mode, int shortBlocks, celt_sig_t * restrict in, celt_sig_t * restrict out, int _C)
308 {
309    const int C = CHANNELS(_C);
310    if (C==1 && !shortBlocks)
311    {
312       const mdct_lookup *lookup = MDCT(mode);
313       const int overlap = OVERLAP(mode);
314       mdct_forward(lookup, in, out, mode->window, overlap);
315    } else {
316       const mdct_lookup *lookup = MDCT(mode);
317       const int overlap = OVERLAP(mode);
318       int N = FRAMESIZE(mode);
319       int B = 1;
320       int b, c;
321       VARDECL(celt_word32_t, x);
322       VARDECL(celt_word32_t, tmp);
323       SAVE_STACK;
324       if (shortBlocks)
325       {
326          lookup = &mode->shortMdct;
327          N = mode->shortMdctSize;
328          B = mode->nbShortMdcts;
329       }
330       ALLOC(x, N+overlap, celt_word32_t);
331       ALLOC(tmp, N, celt_word32_t);
332       for (c=0;c<C;c++)
333       {
334          for (b=0;b<B;b++)
335          {
336             int j;
337             for (j=0;j<N+overlap;j++)
338                x[j] = in[C*(b*N+j)+c];
339             mdct_forward(lookup, x, tmp, mode->window, overlap);
340             /* Interleaving the sub-frames */
341             for (j=0;j<N;j++)
342                out[(j*B+b)+c*N*B] = tmp[j];
343          }
344       }
345       RESTORE_STACK;
346    }
347 }
348
349 /** Compute the IMDCT and apply window for all sub-frames and 
350     all channels in a frame */
351 static void compute_inv_mdcts(const CELTMode *mode, int shortBlocks, celt_sig_t *X, int transient_time, int transient_shift, celt_sig_t * restrict out_mem, int _C)
352 {
353    int c, N4;
354    const int C = CHANNELS(_C);
355    const int N = FRAMESIZE(mode);
356    const int overlap = OVERLAP(mode);
357    N4 = (N-overlap)>>1;
358    for (c=0;c<C;c++)
359    {
360       int j;
361       if (transient_shift==0 && C==1 && !shortBlocks) {
362          const mdct_lookup *lookup = MDCT(mode);
363          mdct_backward(lookup, X, out_mem+C*(MAX_PERIOD-N-N4), mode->window, overlap);
364       } else {
365          VARDECL(celt_word32_t, x);
366          VARDECL(celt_word32_t, tmp);
367          int b;
368          int N2 = N;
369          int B = 1;
370          int n4offset=0;
371          const mdct_lookup *lookup = MDCT(mode);
372          SAVE_STACK;
373          
374          ALLOC(x, 2*N, celt_word32_t);
375          ALLOC(tmp, N, celt_word32_t);
376
377          if (shortBlocks)
378          {
379             lookup = &mode->shortMdct;
380             N2 = mode->shortMdctSize;
381             B = mode->nbShortMdcts;
382             n4offset = N4;
383          }
384          /* Prevents problems from the imdct doing the overlap-add */
385          CELT_MEMSET(x+N4, 0, N2);
386
387          for (b=0;b<B;b++)
388          {
389             /* De-interleaving the sub-frames */
390             for (j=0;j<N2;j++)
391                tmp[j] = X[(j*B+b)+c*N2*B];
392             mdct_backward(lookup, tmp, x+n4offset+N2*b, mode->window, overlap);
393          }
394
395          if (transient_shift > 0)
396          {
397 #ifdef FIXED_POINT
398             for (j=0;j<16;j++)
399                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));
400             for (j=transient_time;j<N+overlap;j++)
401                x[N4+j] = SHL32(x[N4+j], transient_shift);
402 #else
403             for (j=0;j<16;j++)
404                x[N4+transient_time+j-16] *= 1+transientWindow[j]*((1<<transient_shift)-1);
405             for (j=transient_time;j<N+overlap;j++)
406                x[N4+j] *= 1<<transient_shift;
407 #endif
408          }
409          /* The first and last part would need to be set to zero 
410             if we actually wanted to use them. */
411          for (j=0;j<overlap;j++)
412             out_mem[C*(MAX_PERIOD-N)+C*j+c] += x[j+N4];
413          for (j=0;j<overlap;j++)
414             out_mem[C*(MAX_PERIOD)+C*(overlap-j-1)+c] = x[2*N-j-N4-1];
415          for (j=0;j<2*N4;j++)
416             out_mem[C*(MAX_PERIOD-N)+C*(j+overlap)+c] = x[j+N4+overlap];
417          RESTORE_STACK;
418       }
419    }
420 }
421
422 #define FLAG_NONE        0
423 #define FLAG_INTRA       (1U<<13)
424 #define FLAG_PITCH       (1U<<12)
425 #define FLAG_SHORT       (1U<<11)
426 #define FLAG_FOLD        (1U<<10)
427 #define FLAG_MASK        (FLAG_INTRA|FLAG_PITCH|FLAG_SHORT|FLAG_FOLD)
428
429 static const int flaglist[8] = {
430       0 /*00  */ | FLAG_FOLD,
431       1 /*01  */ | FLAG_PITCH|FLAG_FOLD,
432       8 /*1000*/ | FLAG_NONE,
433       9 /*1001*/ | FLAG_SHORT|FLAG_FOLD,
434      10 /*1010*/ | FLAG_PITCH,
435      11 /*1011*/ | FLAG_INTRA,
436       6 /*110 */ | FLAG_INTRA|FLAG_FOLD,
437       7 /*111 */ | FLAG_INTRA|FLAG_SHORT|FLAG_FOLD
438 };
439
440 static void encode_flags(ec_enc *enc, int intra_ener, int has_pitch, int shortBlocks, int has_fold)
441 {
442    int i;
443    int flags=FLAG_NONE;
444    int flag_bits;
445    flags |= intra_ener   ? FLAG_INTRA : 0;
446    flags |= has_pitch    ? FLAG_PITCH : 0;
447    flags |= shortBlocks  ? FLAG_SHORT : 0;
448    flags |= has_fold     ? FLAG_FOLD  : 0;
449    for (i=0;i<8;i++)
450       if (flags == (flaglist[i]&FLAG_MASK))
451          break;
452    celt_assert(i<8);
453    flag_bits = flaglist[i]&0xf;
454    /*printf ("enc %d: %d %d %d %d\n", flag_bits, intra_ener, has_pitch, shortBlocks, has_fold);*/
455    if (i<2)
456       ec_enc_uint(enc, flag_bits, 4);
457    else if (i<6)
458       ec_enc_uint(enc, flag_bits, 16);
459    else
460       ec_enc_uint(enc, flag_bits, 8);
461 }
462
463 static void decode_flags(ec_dec *dec, int *intra_ener, int *has_pitch, int *shortBlocks, int *has_fold)
464 {
465    int i;
466    int flag_bits;
467    flag_bits = ec_dec_uint(dec, 4);
468    /*printf ("(%d) ", flag_bits);*/
469    if (flag_bits==2)
470       flag_bits = (flag_bits<<2) | ec_dec_uint(dec, 4);
471    else if (flag_bits==3)
472       flag_bits = (flag_bits<<1) | ec_dec_uint(dec, 2);
473    for (i=0;i<8;i++)
474       if (flag_bits == (flaglist[i]&0xf))
475          break;
476    celt_assert(i<8);
477    *intra_ener  = (flaglist[i]&FLAG_INTRA) != 0;
478    *has_pitch   = (flaglist[i]&FLAG_PITCH) != 0;
479    *shortBlocks = (flaglist[i]&FLAG_SHORT) != 0;
480    *has_fold    = (flaglist[i]&FLAG_FOLD ) != 0;
481    /*printf ("dec %d: %d %d %d %d\n", flag_bits, *intra_ener, *has_pitch, *shortBlocks, *has_fold);*/
482 }
483
484 static void deemphasis(celt_sig_t *in, celt_word16_t *pcm, int N, int _C, celt_word16_t coef, celt_sig_t *mem)
485 {
486    const int C = CHANNELS(_C);
487    int c;
488    for (c=0;c<C;c++)
489    {
490       int j;
491       for (j=0;j<N;j++)
492       {
493          celt_sig_t tmp = MAC16_32_Q15(in[C*(MAX_PERIOD-N)+C*j+c],
494                                        coef,mem[c]);
495          mem[c] = tmp;
496          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
497       }
498    }
499
500 }
501
502 static void mdct_shape(const CELTMode *mode, celt_norm_t *X, int start, int end, int N, int nbShortMdcts, int mdct_weight_shift, int _C)
503 {
504    int m, i, c;
505    const int C = CHANNELS(_C);
506    for (c=0;c<C;c++)
507       for (m=start;m<end;m++)
508          for (i=m+c*N;i<(c+1)*N;i+=nbShortMdcts)
509 #ifdef FIXED_POINT
510             X[i] = SHR16(X[i], mdct_weight_shift);
511 #else
512             X[i] = (1.f/(1<<mdct_weight_shift))*X[i];
513 #endif
514    renormalise_bands(mode, X, C);
515 }
516
517
518 #ifdef FIXED_POINT
519 int celt_encode(CELTEncoder * restrict st, const celt_int16_t * pcm, celt_int16_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
520 {
521 #else
522 int celt_encode_float(CELTEncoder * restrict st, const celt_sig_t * pcm, celt_sig_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
523 {
524 #endif
525    int i, c, N, NN, N4;
526    int has_pitch;
527    int pitch_index;
528    int bits;
529    int has_fold=1;
530    unsigned coarse_needed;
531    ec_byte_buffer buf;
532    ec_enc         enc;
533    VARDECL(celt_sig_t, in);
534    VARDECL(celt_sig_t, freq);
535    VARDECL(celt_sig_t, pitch_freq);
536    VARDECL(celt_norm_t, X);
537    VARDECL(celt_ener_t, bandE);
538    VARDECL(celt_word16_t, bandLogE);
539    VARDECL(int, fine_quant);
540    VARDECL(celt_word16_t, error);
541    VARDECL(int, pulses);
542    VARDECL(int, offsets);
543    VARDECL(int, fine_priority);
544    int intra_ener = 0;
545    int shortBlocks=0;
546    int transient_time;
547    int transient_shift;
548    const int C = CHANNELS(st->channels);
549    int mdct_weight_shift = 0;
550    int mdct_weight_pos=0;
551    int gain_id=0;
552    int norm_rate;
553    SAVE_STACK;
554
555    if (check_encoder(st) != CELT_OK)
556       return CELT_INVALID_STATE;
557
558    if (check_mode(st->mode) != CELT_OK)
559       return CELT_INVALID_MODE;
560
561    if (nbCompressedBytes<0 || pcm==NULL)
562      return CELT_BAD_ARG; 
563
564    /* The memset is important for now in case the encoder doesn't 
565       fill up all the bytes */
566    CELT_MEMSET(compressed, 0, nbCompressedBytes);
567    ec_byte_writeinit_buffer(&buf, compressed, nbCompressedBytes);
568    ec_enc_init(&enc,&buf);
569
570    N = st->block_size;
571    N4 = (N-st->overlap)>>1;
572    ALLOC(in, 2*C*N-2*C*N4, celt_sig_t);
573
574    CELT_COPY(in, st->in_mem, C*st->overlap);
575    for (c=0;c<C;c++)
576    {
577       const celt_word16_t * restrict pcmp = pcm+c;
578       celt_sig_t * restrict inp = in+C*st->overlap+c;
579       for (i=0;i<N;i++)
580       {
581          /* Apply pre-emphasis */
582          celt_sig_t tmp = SCALEIN(SHL32(EXTEND32(*pcmp), SIG_SHIFT));
583          *inp = SUB32(tmp, SHR32(MULT16_16(preemph,st->preemph_memE[c]),3));
584          st->preemph_memE[c] = SCALEIN(*pcmp);
585          inp += C;
586          pcmp += C;
587       }
588    }
589    CELT_COPY(st->in_mem, in+C*(2*N-2*N4-st->overlap), C*st->overlap);
590
591    /* Transient handling */
592    transient_time = -1;
593    transient_shift = 0;
594    shortBlocks = 0;
595
596    if (st->mode->nbShortMdcts > 1 && transient_analysis(in, N+st->overlap, C, &transient_time, &transient_shift))
597    {
598 #ifndef FIXED_POINT
599       float gain_1;
600 #endif
601       /* Apply the inverse shaping window */
602       if (transient_shift)
603       {
604 #ifdef FIXED_POINT
605          for (c=0;c<C;c++)
606             for (i=0;i<16;i++)
607                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]);
608          for (c=0;c<C;c++)
609             for (i=transient_time;i<N+st->overlap;i++)
610                in[C*i+c] = SHR32(in[C*i+c], transient_shift);
611 #else
612          for (c=0;c<C;c++)
613             for (i=0;i<16;i++)
614                in[C*(transient_time+i-16)+c] /= 1+transientWindow[i]*((1<<transient_shift)-1);
615          gain_1 = 1./(1<<transient_shift);
616          for (c=0;c<C;c++)
617             for (i=transient_time;i<N+st->overlap;i++)
618                in[C*i+c] *= gain_1;
619 #endif
620       }
621       shortBlocks = 1;
622       has_fold = 1;
623    }
624
625    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
626    ALLOC(bandE,st->mode->nbEBands*C, celt_ener_t);
627    ALLOC(bandLogE,st->mode->nbEBands*C, celt_word16_t);
628    /* Compute MDCTs */
629    compute_mdcts(st->mode, shortBlocks, in, freq, C);
630
631
632    norm_rate = (nbCompressedBytes-5)*8*(celt_uint32_t)st->mode->Fs/(C*N)>>10;
633    /* Pitch analysis: we do it early to save on the peak stack space */
634    /* Don't use pitch if there isn't enough data available yet, 
635       or if we're using shortBlocks */
636    has_pitch = st->pitch_enabled && st->pitch_permitted && (N <= 512) 
637             && (st->pitch_available >= MAX_PERIOD) && (!shortBlocks)
638             && norm_rate < 50;
639    if (has_pitch)
640    {
641       find_spectral_pitch(st->mode, st->mode->fft, &st->mode->psy, in, st->out_mem, st->mode->window, NULL, 2*N-2*N4, MAX_PERIOD-(2*N-2*N4), &pitch_index, C);
642    }
643
644    /* Deferred allocation after find_spectral_pitch() to reduce 
645       the peak memory usage */
646    ALLOC(X, C*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
647
648    ALLOC(pitch_freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
649    if (has_pitch)
650    {
651       
652       compute_mdcts(st->mode, 0, st->out_mem+pitch_index*C, pitch_freq, C);
653       has_pitch = compute_pitch_gain(st->mode, freq, pitch_freq, norm_rate, &gain_id, C);
654    }
655    
656    if (has_pitch)
657       apply_pitch(st->mode, freq, pitch_freq, gain_id, 1, C);
658
659    compute_band_energies(st->mode, freq, bandE, C);
660    for (i=0;i<st->mode->nbEBands*C;i++)
661       bandLogE[i] = amp2Log(bandE[i]);
662    
663    /* Band normalisation */
664    normalise_bands(st->mode, freq, X, bandE, C);
665    if (!shortBlocks && !folding_decision(st->mode, X, &st->tonal_average, &st->fold_decision, C))
666       has_fold = 0;
667
668    /* Don't use intra energy when we're operating at low bit-rate */
669    intra_ener = st->force_intra || (!has_pitch && st->delayedIntra && nbCompressedBytes > st->mode->nbEBands);
670    if (shortBlocks || intra_decision(bandLogE, st->oldBandE, st->mode->nbEBands))
671       st->delayedIntra = 1;
672    else
673       st->delayedIntra = 0;
674
675    NN = st->mode->eBands[st->mode->nbEBands];
676    if (shortBlocks && !transient_shift) 
677    {
678       celt_word32_t sum[8]={1,1,1,1,1,1,1,1};
679       int m;
680       for (c=0;c<C;c++)
681       {
682          m=0;
683          do {
684             celt_word32_t tmp=0;
685             for (i=m+c*N;i<c*N+NN;i+=st->mode->nbShortMdcts)
686                tmp += ABS32(X[i]);
687             sum[m++] += tmp;
688          } while (m<st->mode->nbShortMdcts);
689       }
690       m=0;
691 #ifdef FIXED_POINT
692       do {
693          if (SHR32(sum[m+1],3) > sum[m])
694          {
695             mdct_weight_shift=2;
696             mdct_weight_pos = m;
697          } else if (SHR32(sum[m+1],1) > sum[m] && mdct_weight_shift < 2)
698          {
699             mdct_weight_shift=1;
700             mdct_weight_pos = m;
701          }
702          m++;
703       } while (m<st->mode->nbShortMdcts-1);
704 #else
705       do {
706          if (sum[m+1] > 8*sum[m])
707          {
708             mdct_weight_shift=2;
709             mdct_weight_pos = m;
710          } else if (sum[m+1] > 2*sum[m] && mdct_weight_shift < 2)
711          {
712             mdct_weight_shift=1;
713             mdct_weight_pos = m;
714          }
715          m++;
716       } while (m<st->mode->nbShortMdcts-1);
717 #endif
718       if (mdct_weight_shift)
719       {
720          mdct_shape(st->mode, X, mdct_weight_pos+1, st->mode->nbShortMdcts, N, st->mode->nbShortMdcts, mdct_weight_shift, C);
721          renormalise_bands(st->mode, X, C);
722       }
723    }
724
725
726    encode_flags(&enc, intra_ener, has_pitch, shortBlocks, has_fold);
727    if (has_pitch)
728    {
729       ec_enc_uint(&enc, pitch_index, MAX_PERIOD-(2*N-2*N4));
730       ec_enc_uint(&enc, gain_id, 16);
731    }
732    if (shortBlocks)
733    {
734       if (transient_shift)
735       {
736          ec_enc_uint(&enc, transient_shift, 4);
737          ec_enc_uint(&enc, transient_time, N+st->overlap);
738       } else {
739          ec_enc_uint(&enc, mdct_weight_shift, 4);
740          if (mdct_weight_shift && st->mode->nbShortMdcts!=2)
741             ec_enc_uint(&enc, mdct_weight_pos, st->mode->nbShortMdcts-1);
742       }
743    }
744
745    ALLOC(fine_quant, st->mode->nbEBands, int);
746    ALLOC(pulses, st->mode->nbEBands, int);
747
748    /* Bit allocation */
749    ALLOC(error, C*st->mode->nbEBands, celt_word16_t);
750    coarse_needed = quant_coarse_energy(st->mode, bandLogE, st->oldBandE, nbCompressedBytes*8/3, intra_ener, st->mode->prob, error, &enc, C);
751    coarse_needed = ((coarse_needed*3-1)>>3)+1;
752
753    /* Variable bitrate */
754    if (st->VBR_rate>0)
755    {
756      /* The target rate in 16th bits per frame */
757      int target=st->VBR_rate;
758    
759      /* Shortblocks get a large boost in bitrate, but since they 
760         are uncommon long blocks are not greatly effected */
761      if (shortBlocks)
762        target*=2;
763      else if (st->mode->nbShortMdcts > 1)
764        target-=(target+14)/28;     
765
766      /* The average energy is removed from the target and the actual 
767         energy added*/
768      target=target-588+ec_enc_tell(&enc, BITRES);
769
770      /* In VBR mode the frame size must not be reduced so much that it would result in the coarse energy busting its budget */
771      target=IMAX(coarse_needed,(target+64)/128);
772      nbCompressedBytes=IMIN(nbCompressedBytes,target);
773      ec_byte_shrink(&buf, nbCompressedBytes);
774    }
775
776    ALLOC(offsets, st->mode->nbEBands, int);
777    ALLOC(fine_priority, st->mode->nbEBands, int);
778
779    for (i=0;i<st->mode->nbEBands;i++)
780       offsets[i] = 0;
781    bits = nbCompressedBytes*8 - ec_enc_tell(&enc, 0) - 1;
782    compute_allocation(st->mode, offsets, bits, pulses, fine_quant, fine_priority, C);
783
784    quant_fine_energy(st->mode, bandE, st->oldBandE, error, fine_quant, &enc, C);
785
786    /* Residual quantisation */
787    if (C==1)
788       quant_bands(st->mode, X, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, 1, &enc);
789 #ifndef DISABLE_STEREO
790    else
791       quant_bands_stereo(st->mode, X, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, &enc);
792 #endif
793
794    quant_energy_finalise(st->mode, bandE, st->oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_enc_tell(&enc, 0), &enc, C);
795
796    /* Re-synthesis of the coded audio if required */
797    if (st->pitch_available>0 || optional_synthesis!=NULL)
798    {
799       if (st->pitch_available>0 && st->pitch_available<MAX_PERIOD)
800         st->pitch_available+=st->frame_size;
801
802       if (mdct_weight_shift)
803       {
804          mdct_shape(st->mode, X, 0, mdct_weight_pos+1, N, st->mode->nbShortMdcts, mdct_weight_shift, C);
805       }
806
807       /* Synthesis */
808       denormalise_bands(st->mode, X, freq, bandE, C);
809
810       CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->overlap-N));
811
812       if (has_pitch)
813          apply_pitch(st->mode, freq, pitch_freq, gain_id, 0, C);
814       
815       compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem, C);
816
817       /* De-emphasis and put everything back at the right place 
818          in the synthesis history */
819       if (optional_synthesis != NULL) {
820          deemphasis(st->out_mem, optional_synthesis, N, C, preemph, st->preemph_memD);
821
822       }
823    }
824
825    ec_enc_done(&enc);
826    
827    RESTORE_STACK;
828    return nbCompressedBytes;
829 }
830
831 #ifdef FIXED_POINT
832 #ifndef DISABLE_FLOAT_API
833 int celt_encode_float(CELTEncoder * restrict st, const float * pcm, float * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
834 {
835    int j, ret, C, N;
836    VARDECL(celt_int16_t, in);
837    SAVE_STACK;
838
839    if (check_encoder(st) != CELT_OK)
840       return CELT_INVALID_STATE;
841
842    if (check_mode(st->mode) != CELT_OK)
843       return CELT_INVALID_MODE;
844
845    if (pcm==NULL)
846       return CELT_BAD_ARG;
847
848    C = CHANNELS(st->channels);
849    N = st->block_size;
850    ALLOC(in, C*N, celt_int16_t);
851
852    for (j=0;j<C*N;j++)
853      in[j] = FLOAT2INT16(pcm[j]);
854
855    if (optional_synthesis != NULL) {
856      ret=celt_encode(st,in,in,compressed,nbCompressedBytes);
857       for (j=0;j<C*N;j++)
858          optional_synthesis[j]=in[j]*(1/32768.);
859    } else {
860      ret=celt_encode(st,in,NULL,compressed,nbCompressedBytes);
861    }
862    RESTORE_STACK;
863    return ret;
864
865 }
866 #endif /*DISABLE_FLOAT_API*/
867 #else
868 int celt_encode(CELTEncoder * restrict st, const celt_int16_t * pcm, celt_int16_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
869 {
870    int j, ret, C, N;
871    VARDECL(celt_sig_t, in);
872    SAVE_STACK;
873
874    if (check_encoder(st) != CELT_OK)
875       return CELT_INVALID_STATE;
876
877    if (check_mode(st->mode) != CELT_OK)
878       return CELT_INVALID_MODE;
879
880    if (pcm==NULL)
881       return CELT_BAD_ARG;
882
883    C=CHANNELS(st->channels);
884    N=st->block_size;
885    ALLOC(in, C*N, celt_sig_t);
886    for (j=0;j<C*N;j++) {
887      in[j] = SCALEOUT(pcm[j]);
888    }
889
890    if (optional_synthesis != NULL) {
891       ret = celt_encode_float(st,in,in,compressed,nbCompressedBytes);
892       for (j=0;j<C*N;j++)
893          optional_synthesis[j] = FLOAT2INT16(in[j]);
894    } else {
895       ret = celt_encode_float(st,in,NULL,compressed,nbCompressedBytes);
896    }
897    RESTORE_STACK;
898    return ret;
899 }
900 #endif
901
902 int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
903 {
904    va_list ap;
905    
906    if (check_encoder(st) != CELT_OK)
907       return CELT_INVALID_STATE;
908
909    va_start(ap, request);
910    if ((request!=CELT_GET_MODE_REQUEST) && (check_mode(st->mode) != CELT_OK))
911      goto bad_mode;
912    switch (request)
913    {
914       case CELT_GET_MODE_REQUEST:
915       {
916          const CELTMode ** value = va_arg(ap, const CELTMode**);
917          if (value==0)
918             goto bad_arg;
919          *value=st->mode;
920       }
921       break;
922       case CELT_SET_COMPLEXITY_REQUEST:
923       {
924          int value = va_arg(ap, celt_int32_t);
925          if (value<0 || value>10)
926             goto bad_arg;
927          if (value<=2) {
928             st->pitch_enabled = 0; 
929             st->pitch_available = 0;
930          } else {
931               st->pitch_enabled = 1;
932               if (st->pitch_available<1)
933                 st->pitch_available = 1;
934          }   
935       }
936       break;
937       case CELT_SET_PREDICTION_REQUEST:
938       {
939          int value = va_arg(ap, celt_int32_t);
940          if (value<0 || value>2)
941             goto bad_arg;
942          if (value==0)
943          {
944             st->force_intra   = 1;
945             st->pitch_permitted = 0;
946          } else if (value==1) {
947             st->force_intra   = 0;
948             st->pitch_permitted = 0;
949          } else {
950             st->force_intra   = 0;
951             st->pitch_permitted = 1;
952          }   
953       }
954       break;
955       case CELT_SET_VBR_RATE_REQUEST:
956       {
957          celt_int32_t value = va_arg(ap, celt_int32_t);
958          if (value<0)
959             goto bad_arg;
960          if (value>3072000)
961             value = 3072000;
962          st->VBR_rate = ((st->mode->Fs<<3)+(st->block_size>>1))/st->block_size;
963          st->VBR_rate = ((value<<7)+(st->VBR_rate>>1))/st->VBR_rate;
964       }
965       break;
966       case CELT_RESET_STATE:
967       {
968          const CELTMode *mode = st->mode;
969          int C = st->channels;
970
971          if (st->pitch_available > 0) st->pitch_available = 1;
972
973          CELT_MEMSET(st->in_mem, 0, st->overlap*C);
974          CELT_MEMSET(st->out_mem, 0, (MAX_PERIOD+st->overlap)*C);
975
976          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
977
978          CELT_MEMSET(st->preemph_memE, 0, C);
979          CELT_MEMSET(st->preemph_memD, 0, C);
980          st->delayedIntra = 1;
981       }
982       break;
983       default:
984          goto bad_request;
985    }
986    va_end(ap);
987    return CELT_OK;
988 bad_mode:
989   va_end(ap);
990   return CELT_INVALID_MODE;
991 bad_arg:
992    va_end(ap);
993    return CELT_BAD_ARG;
994 bad_request:
995    va_end(ap);
996    return CELT_UNIMPLEMENTED;
997 }
998
999 /**********************************************************************/
1000 /*                                                                    */
1001 /*                             DECODER                                */
1002 /*                                                                    */
1003 /**********************************************************************/
1004 #ifdef NEW_PLC
1005 #define DECODE_BUFFER_SIZE 2048
1006 #else
1007 #define DECODE_BUFFER_SIZE MAX_PERIOD
1008 #endif
1009
1010 #define DECODERVALID   0x4c434454
1011 #define DECODERPARTIAL 0x5444434c
1012 #define DECODERFREED   0x4c004400
1013
1014 /** Decoder state 
1015  @brief Decoder state
1016  */
1017 struct CELTDecoder {
1018    celt_uint32_t marker;
1019    const CELTMode *mode;
1020    int frame_size;
1021    int block_size;
1022    int overlap;
1023    int channels;
1024
1025    ec_byte_buffer buf;
1026    ec_enc         enc;
1027
1028    celt_sig_t * restrict preemph_memD;
1029
1030    celt_sig_t *out_mem;
1031    celt_sig_t *decode_mem;
1032
1033    celt_word16_t *oldBandE;
1034    
1035    int last_pitch_index;
1036    int loss_count;
1037 };
1038
1039 int check_decoder(const CELTDecoder *st) 
1040 {
1041    if (st==NULL)
1042    {
1043       celt_warning("NULL passed a decoder structure");  
1044       return CELT_INVALID_STATE;
1045    }
1046    if (st->marker == DECODERVALID)
1047       return CELT_OK;
1048    if (st->marker == DECODERFREED)
1049       celt_warning("Referencing a decoder that has already been freed");
1050    else
1051       celt_warning("This is not a valid CELT decoder structure");
1052    return CELT_INVALID_STATE;
1053 }
1054
1055 CELTDecoder *celt_decoder_create(const CELTMode *mode, int channels, int *error)
1056 {
1057    int N, C;
1058    CELTDecoder *st;
1059
1060    if (check_mode(mode) != CELT_OK)
1061    {
1062       if (error)
1063          *error = CELT_INVALID_MODE;
1064       return NULL;
1065    }
1066    if (channels < 0 || channels > 2)
1067    {
1068       celt_warning("Only mono and stereo supported");
1069       if (error)
1070          *error = CELT_BAD_ARG;
1071       return NULL;
1072    }
1073
1074    N = mode->mdctSize;
1075    C = CHANNELS(channels);
1076    st = celt_alloc(sizeof(CELTDecoder));
1077
1078    if (st==NULL)
1079    {
1080       if (error)
1081          *error = CELT_ALLOC_FAIL;
1082       return NULL;
1083    }
1084
1085    st->marker = DECODERPARTIAL;
1086    st->mode = mode;
1087    st->frame_size = N;
1088    st->block_size = N;
1089    st->overlap = mode->overlap;
1090    st->channels = channels;
1091
1092    st->decode_mem = celt_alloc((DECODE_BUFFER_SIZE+st->overlap)*C*sizeof(celt_sig_t));
1093    st->out_mem = st->decode_mem+DECODE_BUFFER_SIZE-MAX_PERIOD;
1094    
1095    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
1096    
1097    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));
1098
1099    st->loss_count = 0;
1100
1101    if ((st->decode_mem!=NULL) && (st->out_mem!=NULL) && (st->oldBandE!=NULL) &&
1102        (st->preemph_memD!=NULL))
1103    {
1104       if (error)
1105          *error = CELT_OK;
1106       st->marker = DECODERVALID;
1107       return st;
1108    }
1109    /* If the setup fails for some reason deallocate it. */
1110    celt_decoder_destroy(st);
1111    if (error)
1112       *error = CELT_ALLOC_FAIL;
1113    return NULL;
1114 }
1115
1116 void celt_decoder_destroy(CELTDecoder *st)
1117 {
1118    if (st == NULL)
1119    {
1120       celt_warning("NULL passed to celt_decoder_destroy");
1121       return;
1122    }
1123
1124    if (st->marker == DECODERFREED) 
1125    {
1126       celt_warning("Freeing a decoder which has already been freed"); 
1127       return;
1128    }
1129    
1130    if (st->marker != DECODERVALID && st->marker != DECODERPARTIAL)
1131    {
1132       celt_warning("This is not a valid CELT decoder structure");
1133       return;
1134    }
1135    
1136    /*Check_mode is non-fatal here because we can still free
1137      the encoder memory even if the mode is bad, although calling
1138      the free functions in this order is a violation of the API.*/
1139    check_mode(st->mode);
1140    
1141    celt_free(st->decode_mem);
1142    celt_free(st->oldBandE);
1143    celt_free(st->preemph_memD);
1144    
1145    st->marker = DECODERFREED;
1146    
1147    celt_free(st);
1148 }
1149
1150 /** Handles lost packets by just copying past data with the same
1151     offset as the last
1152     pitch period */
1153 #ifdef NEW_PLC
1154 #include "plc.c"
1155 #else
1156 static void celt_decode_lost(CELTDecoder * restrict st, celt_word16_t * restrict pcm)
1157 {
1158    int c, N;
1159    int pitch_index;
1160    celt_word16_t fade = Q15ONE;
1161    int i, len;
1162    VARDECL(celt_sig_t, freq);
1163    const int C = CHANNELS(st->channels);
1164    int offset;
1165    SAVE_STACK;
1166    N = st->block_size;
1167    ALLOC(freq,C*N, celt_sig_t); /**< Interleaved signal MDCTs */
1168    
1169    len = N+st->mode->overlap;
1170    
1171    if (st->loss_count == 0)
1172    {
1173       find_spectral_pitch(st->mode, st->mode->fft, &st->mode->psy, st->out_mem+MAX_PERIOD-len, st->out_mem, st->mode->window, NULL, len, MAX_PERIOD-len-100, &pitch_index, C);
1174       pitch_index = MAX_PERIOD-len-pitch_index;
1175       st->last_pitch_index = pitch_index;
1176    } else {
1177       pitch_index = st->last_pitch_index;
1178       if (st->loss_count < 5)
1179          fade = QCONST16(.8f,15);
1180       else
1181          fade = 0;
1182    }
1183
1184    offset = MAX_PERIOD-pitch_index;
1185    while (offset+len >= MAX_PERIOD)
1186       offset -= pitch_index;
1187    compute_mdcts(st->mode, 0, st->out_mem+offset*C, freq, C);
1188    for (i=0;i<C*N;i++)
1189       freq[i] = ADD32(VERY_SMALL, MULT16_32_Q15(fade,freq[i]));
1190
1191    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->mode->overlap-N));
1192    /* Compute inverse MDCTs */
1193    compute_inv_mdcts(st->mode, 0, freq, -1, 0, st->out_mem, C);
1194
1195    for (c=0;c<C;c++)
1196    {
1197       int j;
1198       for (j=0;j<N;j++)
1199       {
1200          celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
1201                                 preemph,st->preemph_memD[c]);
1202          st->preemph_memD[c] = tmp;
1203          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
1204       }
1205    }
1206    
1207    st->loss_count++;
1208
1209    RESTORE_STACK;
1210 }
1211 #endif
1212
1213 #ifdef FIXED_POINT
1214 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16_t * restrict pcm)
1215 {
1216 #else
1217 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, celt_sig_t * restrict pcm)
1218 {
1219 #endif
1220    int i, N, N4;
1221    int has_pitch, has_fold;
1222    int pitch_index;
1223    int bits;
1224    ec_dec dec;
1225    ec_byte_buffer buf;
1226    VARDECL(celt_sig_t, freq);
1227    VARDECL(celt_sig_t, pitch_freq);
1228    VARDECL(celt_norm_t, X);
1229    VARDECL(celt_ener_t, bandE);
1230    VARDECL(int, fine_quant);
1231    VARDECL(int, pulses);
1232    VARDECL(int, offsets);
1233    VARDECL(int, fine_priority);
1234
1235    int shortBlocks;
1236    int intra_ener;
1237    int transient_time;
1238    int transient_shift;
1239    int mdct_weight_shift=0;
1240    const int C = CHANNELS(st->channels);
1241    int mdct_weight_pos=0;
1242    int gain_id=0;
1243    SAVE_STACK;
1244
1245    if (check_decoder(st) != CELT_OK)
1246       return CELT_INVALID_STATE;
1247
1248    if (check_mode(st->mode) != CELT_OK)
1249       return CELT_INVALID_MODE;
1250
1251    if (pcm==NULL)
1252       return CELT_BAD_ARG;
1253
1254    N = st->block_size;
1255    N4 = (N-st->overlap)>>1;
1256
1257    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
1258    ALLOC(X, C*N, celt_norm_t);   /**< Interleaved normalised MDCTs */
1259    ALLOC(bandE, st->mode->nbEBands*C, celt_ener_t);
1260    
1261    if (data == NULL)
1262    {
1263       celt_decode_lost(st, pcm);
1264       RESTORE_STACK;
1265       return 0;
1266    } else {
1267       st->loss_count = 0;
1268    }
1269    if (len<0) {
1270      RESTORE_STACK;
1271      return CELT_BAD_ARG;
1272    }
1273    
1274    ec_byte_readinit(&buf,(unsigned char*)data,len);
1275    ec_dec_init(&dec,&buf);
1276    
1277    decode_flags(&dec, &intra_ener, &has_pitch, &shortBlocks, &has_fold);
1278    if (shortBlocks)
1279    {
1280       transient_shift = ec_dec_uint(&dec, 4);
1281       if (transient_shift == 3)
1282       {
1283          transient_time = ec_dec_uint(&dec, N+st->mode->overlap);
1284       } else {
1285          mdct_weight_shift = transient_shift;
1286          if (mdct_weight_shift && st->mode->nbShortMdcts>2)
1287             mdct_weight_pos = ec_dec_uint(&dec, st->mode->nbShortMdcts-1);
1288          transient_shift = 0;
1289          transient_time = 0;
1290       }
1291    } else {
1292       transient_time = -1;
1293       transient_shift = 0;
1294    }
1295    
1296    if (has_pitch)
1297    {
1298       pitch_index = ec_dec_uint(&dec, MAX_PERIOD-(2*N-2*N4));
1299       gain_id = ec_dec_uint(&dec, 16);
1300    } else {
1301       pitch_index = 0;
1302    }
1303
1304    ALLOC(fine_quant, st->mode->nbEBands, int);
1305    /* Get band energies */
1306    unquant_coarse_energy(st->mode, bandE, st->oldBandE, len*8/3, intra_ener, st->mode->prob, &dec, C);
1307    
1308    ALLOC(pulses, st->mode->nbEBands, int);
1309    ALLOC(offsets, st->mode->nbEBands, int);
1310    ALLOC(fine_priority, st->mode->nbEBands, int);
1311
1312    for (i=0;i<st->mode->nbEBands;i++)
1313       offsets[i] = 0;
1314
1315    bits = len*8 - ec_dec_tell(&dec, 0) - 1;
1316    compute_allocation(st->mode, offsets, bits, pulses, fine_quant, fine_priority, C);
1317    /*bits = ec_dec_tell(&dec, 0);
1318    compute_fine_allocation(st->mode, fine_quant, (20*C+len*8/5-(ec_dec_tell(&dec, 0)-bits))/C);*/
1319    
1320    unquant_fine_energy(st->mode, bandE, st->oldBandE, fine_quant, &dec, C);
1321
1322    ALLOC(pitch_freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
1323    if (has_pitch) 
1324    {
1325       /* Pitch MDCT */
1326       compute_mdcts(st->mode, 0, st->out_mem+pitch_index*C, pitch_freq, C);
1327    }
1328
1329    /* Decode fixed codebook and merge with pitch */
1330    if (C==1)
1331       quant_bands(st->mode, X, bandE, pulses, shortBlocks, has_fold, len*8, 0, &dec);
1332 #ifndef DISABLE_STEREO
1333    else
1334       unquant_bands_stereo(st->mode, X, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
1335 #endif
1336    unquant_energy_finalise(st->mode, bandE, st->oldBandE, fine_quant, fine_priority, len*8-ec_dec_tell(&dec, 0), &dec, C);
1337    
1338    if (mdct_weight_shift)
1339    {
1340       mdct_shape(st->mode, X, 0, mdct_weight_pos+1, N, st->mode->nbShortMdcts, mdct_weight_shift, C);
1341    }
1342
1343    /* Synthesis */
1344    denormalise_bands(st->mode, X, freq, bandE, C);
1345
1346
1347    CELT_MOVE(st->decode_mem, st->decode_mem+C*N, C*(DECODE_BUFFER_SIZE+st->overlap-N));
1348
1349    if (has_pitch)
1350       apply_pitch(st->mode, freq, pitch_freq, gain_id, 0, C);
1351
1352    /* Compute inverse MDCTs */
1353    compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem, C);
1354
1355    deemphasis(st->out_mem, pcm, N, C, preemph, st->preemph_memD);
1356
1357    RESTORE_STACK;
1358    return 0;
1359 }
1360
1361 #ifdef FIXED_POINT
1362 #ifndef DISABLE_FLOAT_API
1363 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm)
1364 {
1365    int j, ret, C, N;
1366    VARDECL(celt_int16_t, out);
1367    SAVE_STACK;
1368
1369    if (check_decoder(st) != CELT_OK)
1370       return CELT_INVALID_STATE;
1371
1372    if (check_mode(st->mode) != CELT_OK)
1373       return CELT_INVALID_MODE;
1374
1375    if (pcm==NULL)
1376       return CELT_BAD_ARG;
1377
1378    C = CHANNELS(st->channels);
1379    N = st->block_size;
1380    
1381    ALLOC(out, C*N, celt_int16_t);
1382    ret=celt_decode(st, data, len, out);
1383    for (j=0;j<C*N;j++)
1384       pcm[j]=out[j]*(1/32768.);
1385      
1386    RESTORE_STACK;
1387    return ret;
1388 }
1389 #endif /*DISABLE_FLOAT_API*/
1390 #else
1391 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16_t * restrict pcm)
1392 {
1393    int j, ret, C, N;
1394    VARDECL(celt_sig_t, out);
1395    SAVE_STACK;
1396
1397    if (check_decoder(st) != CELT_OK)
1398       return CELT_INVALID_STATE;
1399
1400    if (check_mode(st->mode) != CELT_OK)
1401       return CELT_INVALID_MODE;
1402
1403    if (pcm==NULL)
1404       return CELT_BAD_ARG;
1405
1406    C = CHANNELS(st->channels);
1407    N = st->block_size;
1408    ALLOC(out, C*N, celt_sig_t);
1409
1410    ret=celt_decode_float(st, data, len, out);
1411
1412    for (j=0;j<C*N;j++)
1413       pcm[j] = FLOAT2INT16 (out[j]);
1414    
1415    RESTORE_STACK;
1416    return ret;
1417 }
1418 #endif
1419
1420 int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
1421 {
1422    va_list ap;
1423
1424    if (check_decoder(st) != CELT_OK)
1425       return CELT_INVALID_STATE;
1426
1427    va_start(ap, request);
1428    if ((request!=CELT_GET_MODE_REQUEST) && (check_mode(st->mode) != CELT_OK))
1429      goto bad_mode;
1430    switch (request)
1431    {
1432       case CELT_GET_MODE_REQUEST:
1433       {
1434          const CELTMode ** value = va_arg(ap, const CELTMode**);
1435          if (value==0)
1436             goto bad_arg;
1437          *value=st->mode;
1438       }
1439       break;
1440       case CELT_RESET_STATE:
1441       {
1442          const CELTMode *mode = st->mode;
1443          int C = st->channels;
1444
1445          CELT_MEMSET(st->decode_mem, 0, (DECODE_BUFFER_SIZE+st->overlap)*C);
1446          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
1447
1448          CELT_MEMSET(st->preemph_memD, 0, C);
1449
1450          st->loss_count = 0;
1451       }
1452       break;
1453       default:
1454          goto bad_request;
1455    }
1456    va_end(ap);
1457    return CELT_OK;
1458 bad_mode:
1459   va_end(ap);
1460   return CELT_INVALID_MODE;
1461 bad_arg:
1462    va_end(ap);
1463    return CELT_BAD_ARG;
1464 bad_request:
1465       va_end(ap);
1466   return CELT_UNIMPLEMENTED;
1467 }
1468
1469 const char *celt_strerror(int error)
1470 {
1471    static const char *error_strings[8] = {
1472       "success",
1473       "invalid argument",
1474       "invalid mode",
1475       "internal error",
1476       "corrupted stream",
1477       "request not implemented",
1478       "invalid state",
1479       "memory allocation failed"
1480    };
1481    if (error > 0 || error < -7)
1482       return "unknown error";
1483    else 
1484       return error_strings[-error];
1485 }
1486