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