ca40eb6eead3d14ff9ec1251eef69451623d027b
[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, int _C)
288 {
289    const int C = CHANNELS(_C);
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, int _C)
332 {
333    int c, N4;
334    const int C = CHANNELS(_C);
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    const int C = CHANNELS(_C);
467    int c;
468    for (c=0;c<C;c++)
469    {
470       int j;
471       for (j=0;j<N;j++)
472       {
473          celt_sig_t tmp = MAC16_32_Q15(in[C*(MAX_PERIOD-N)+C*j+c],
474                                        coef,mem[c]);
475          mem[c] = tmp;
476          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
477       }
478    }
479
480 }
481
482 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)
483 {
484    int m, i, c;
485    const int C = CHANNELS(_C);
486    for (c=0;c<C;c++)
487       for (m=start;m<end;m++)
488          for (i=m+c*N;i<(c+1)*N;i+=nbShortMdcts)
489 #ifdef FIXED_POINT
490             X[i] = SHR16(X[i], mdct_weight_shift);
491 #else
492             X[i] = (1.f/(1<<mdct_weight_shift))*X[i];
493 #endif
494    renormalise_bands(mode, X, C);
495 }
496
497
498 #ifdef FIXED_POINT
499 int celt_encode(CELTEncoder * restrict st, const celt_int16_t * pcm, celt_int16_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
500 {
501 #else
502 int celt_encode_float(CELTEncoder * restrict st, const celt_sig_t * pcm, celt_sig_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
503 {
504 #endif
505    int i, c, N, NN, N4;
506    int has_pitch;
507    int pitch_index;
508    int bits;
509    int has_fold=1;
510    unsigned coarse_needed;
511    ec_byte_buffer buf;
512    ec_enc         enc;
513    VARDECL(celt_sig_t, in);
514    VARDECL(celt_sig_t, freq);
515    VARDECL(celt_sig_t, pitch_freq);
516    VARDECL(celt_norm_t, X);
517    VARDECL(celt_ener_t, bandE);
518    VARDECL(celt_word16_t, bandLogE);
519    VARDECL(int, fine_quant);
520    VARDECL(celt_word16_t, error);
521    VARDECL(int, pulses);
522    VARDECL(int, offsets);
523    VARDECL(int, fine_priority);
524    int intra_ener = 0;
525    int shortBlocks=0;
526    int transient_time;
527    int transient_shift;
528    const int C = MCHANNELS(st->mode);
529    int mdct_weight_shift = 0;
530    int mdct_weight_pos=0;
531    int gain_id=0;
532    int norm_rate;
533    SAVE_STACK;
534
535    if (check_encoder(st) != CELT_OK)
536       return CELT_INVALID_STATE;
537
538    if (check_mode(st->mode) != CELT_OK)
539       return CELT_INVALID_MODE;
540
541    if (nbCompressedBytes<0 || pcm==NULL)
542      return CELT_BAD_ARG; 
543
544    /* The memset is important for now in case the encoder doesn't 
545       fill up all the bytes */
546    CELT_MEMSET(compressed, 0, nbCompressedBytes);
547    ec_byte_writeinit_buffer(&buf, compressed, nbCompressedBytes);
548    ec_enc_init(&enc,&buf);
549
550    N = st->block_size;
551    N4 = (N-st->overlap)>>1;
552    ALLOC(in, 2*C*N-2*C*N4, celt_sig_t);
553
554    CELT_COPY(in, st->in_mem, C*st->overlap);
555    for (c=0;c<C;c++)
556    {
557       const celt_word16_t * restrict pcmp = pcm+c;
558       celt_sig_t * restrict inp = in+C*st->overlap+c;
559       for (i=0;i<N;i++)
560       {
561          /* Apply pre-emphasis */
562          celt_sig_t tmp = SCALEIN(SHL32(EXTEND32(*pcmp), SIG_SHIFT));
563          *inp = SUB32(tmp, SHR32(MULT16_16(preemph,st->preemph_memE[c]),3));
564          st->preemph_memE[c] = SCALEIN(*pcmp);
565          inp += C;
566          pcmp += C;
567       }
568    }
569    CELT_COPY(st->in_mem, in+C*(2*N-2*N4-st->overlap), C*st->overlap);
570
571    /* Transient handling */
572    transient_time = -1;
573    transient_shift = 0;
574    shortBlocks = 0;
575
576    if (st->mode->nbShortMdcts > 1 && transient_analysis(in, N+st->overlap, C, &transient_time, &transient_shift))
577    {
578 #ifndef FIXED_POINT
579       float gain_1;
580 #endif
581       /* Apply the inverse shaping window */
582       if (transient_shift)
583       {
584 #ifdef FIXED_POINT
585          for (c=0;c<C;c++)
586             for (i=0;i<16;i++)
587                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]);
588          for (c=0;c<C;c++)
589             for (i=transient_time;i<N+st->overlap;i++)
590                in[C*i+c] = SHR32(in[C*i+c], transient_shift);
591 #else
592          for (c=0;c<C;c++)
593             for (i=0;i<16;i++)
594                in[C*(transient_time+i-16)+c] /= 1+transientWindow[i]*((1<<transient_shift)-1);
595          gain_1 = 1./(1<<transient_shift);
596          for (c=0;c<C;c++)
597             for (i=transient_time;i<N+st->overlap;i++)
598                in[C*i+c] *= gain_1;
599 #endif
600       }
601       shortBlocks = 1;
602       has_fold = 1;
603    }
604
605    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
606    ALLOC(bandE,st->mode->nbEBands*C, celt_ener_t);
607    ALLOC(bandLogE,st->mode->nbEBands*C, celt_word16_t);
608    /* Compute MDCTs */
609    compute_mdcts(st->mode, shortBlocks, in, freq, C);
610
611
612    norm_rate = (nbCompressedBytes-5)*8*(celt_uint32_t)st->mode->Fs/(C*N)>>10;
613    /* Pitch analysis: we do it early to save on the peak stack space */
614    /* Don't use pitch if there isn't enough data available yet, 
615       or if we're using shortBlocks */
616    has_pitch = st->pitch_enabled && st->pitch_permitted && (N <= 512) 
617             && (st->pitch_available >= MAX_PERIOD) && (!shortBlocks)
618             && norm_rate < 50;
619    if (has_pitch)
620    {
621       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);
622    }
623
624    /* Deferred allocation after find_spectral_pitch() to reduce 
625       the peak memory usage */
626    ALLOC(X, C*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
627
628    ALLOC(pitch_freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
629    if (has_pitch)
630    {
631       
632       compute_mdcts(st->mode, 0, st->out_mem+pitch_index*C, pitch_freq, C);
633       has_pitch = compute_pitch_gain(st->mode, freq, pitch_freq, norm_rate, &gain_id, C);
634    }
635    
636    if (has_pitch)
637       apply_pitch(st->mode, freq, pitch_freq, gain_id, 1, C);
638
639    compute_band_energies(st->mode, freq, bandE, C);
640    for (i=0;i<st->mode->nbEBands*C;i++)
641       bandLogE[i] = amp2Log(bandE[i]);
642    
643    /* Band normalisation */
644    normalise_bands(st->mode, freq, X, bandE, C);
645    if (!shortBlocks && !folding_decision(st->mode, X, &st->tonal_average, &st->fold_decision, C))
646       has_fold = 0;
647
648    /* Don't use intra energy when we're operating at low bit-rate */
649    intra_ener = st->force_intra || (!has_pitch && st->delayedIntra && nbCompressedBytes > st->mode->nbEBands);
650    if (shortBlocks || intra_decision(bandLogE, st->oldBandE, st->mode->nbEBands))
651       st->delayedIntra = 1;
652    else
653       st->delayedIntra = 0;
654
655    NN = st->mode->eBands[st->mode->nbEBands];
656    if (shortBlocks && !transient_shift) 
657    {
658       celt_word32_t sum[8]={1,1,1,1,1,1,1,1};
659       int m;
660       for (c=0;c<C;c++)
661       {
662          m=0;
663          do {
664             celt_word32_t tmp=0;
665             for (i=m+c*N;i<c*N+NN;i+=st->mode->nbShortMdcts)
666                tmp += ABS32(X[i]);
667             sum[m++] += tmp;
668          } while (m<st->mode->nbShortMdcts);
669       }
670       m=0;
671 #ifdef FIXED_POINT
672       do {
673          if (SHR32(sum[m+1],3) > sum[m])
674          {
675             mdct_weight_shift=2;
676             mdct_weight_pos = m;
677          } else if (SHR32(sum[m+1],1) > sum[m] && mdct_weight_shift < 2)
678          {
679             mdct_weight_shift=1;
680             mdct_weight_pos = m;
681          }
682          m++;
683       } while (m<st->mode->nbShortMdcts-1);
684 #else
685       do {
686          if (sum[m+1] > 8*sum[m])
687          {
688             mdct_weight_shift=2;
689             mdct_weight_pos = m;
690          } else if (sum[m+1] > 2*sum[m] && mdct_weight_shift < 2)
691          {
692             mdct_weight_shift=1;
693             mdct_weight_pos = m;
694          }
695          m++;
696       } while (m<st->mode->nbShortMdcts-1);
697 #endif
698       if (mdct_weight_shift)
699       {
700          mdct_shape(st->mode, X, mdct_weight_pos+1, st->mode->nbShortMdcts, N, st->mode->nbShortMdcts, mdct_weight_shift, C);
701          renormalise_bands(st->mode, X, C);
702       }
703    }
704
705
706    encode_flags(&enc, intra_ener, has_pitch, shortBlocks, has_fold);
707    if (has_pitch)
708    {
709       ec_enc_uint(&enc, pitch_index, MAX_PERIOD-(2*N-2*N4));
710       ec_enc_uint(&enc, gain_id, 16);
711    }
712    if (shortBlocks)
713    {
714       if (transient_shift)
715       {
716          ec_enc_uint(&enc, transient_shift, 4);
717          ec_enc_uint(&enc, transient_time, N+st->overlap);
718       } else {
719          ec_enc_uint(&enc, mdct_weight_shift, 4);
720          if (mdct_weight_shift && st->mode->nbShortMdcts!=2)
721             ec_enc_uint(&enc, mdct_weight_pos, st->mode->nbShortMdcts-1);
722       }
723    }
724
725    ALLOC(fine_quant, st->mode->nbEBands, int);
726    ALLOC(pulses, st->mode->nbEBands, int);
727
728    /* Bit allocation */
729    ALLOC(error, C*st->mode->nbEBands, celt_word16_t);
730    coarse_needed = quant_coarse_energy(st->mode, bandLogE, st->oldBandE, nbCompressedBytes*8/3, intra_ener, st->mode->prob, error, &enc, C);
731    coarse_needed = ((coarse_needed*3-1)>>3)+1;
732
733    /* Variable bitrate */
734    if (st->VBR_rate>0)
735    {
736      /* The target rate in 16th bits per frame */
737      int target=st->VBR_rate;
738    
739      /* Shortblocks get a large boost in bitrate, but since they 
740         are uncommon long blocks are not greatly effected */
741      if (shortBlocks)
742        target*=2;
743      else if (st->mode->nbShortMdcts > 1)
744        target-=(target+14)/28;     
745
746      /* The average energy is removed from the target and the actual 
747         energy added*/
748      target=target-588+ec_enc_tell(&enc, BITRES);
749
750      /* In VBR mode the frame size must not be reduced so much that it would result in the coarse energy busting its budget */
751      target=IMAX(coarse_needed,(target+64)/128);
752      nbCompressedBytes=IMIN(nbCompressedBytes,target);
753      ec_byte_shrink(&buf, nbCompressedBytes);
754    }
755
756    ALLOC(offsets, st->mode->nbEBands, int);
757    ALLOC(fine_priority, st->mode->nbEBands, int);
758
759    for (i=0;i<st->mode->nbEBands;i++)
760       offsets[i] = 0;
761    bits = nbCompressedBytes*8 - ec_enc_tell(&enc, 0) - 1;
762    compute_allocation(st->mode, offsets, bits, pulses, fine_quant, fine_priority, C);
763
764    quant_fine_energy(st->mode, bandE, st->oldBandE, error, fine_quant, &enc, C);
765
766    /* Residual quantisation */
767    if (C==1)
768       quant_bands(st->mode, X, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, 1, &enc);
769 #ifndef DISABLE_STEREO
770    else
771       quant_bands_stereo(st->mode, X, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, &enc);
772 #endif
773
774    quant_energy_finalise(st->mode, bandE, st->oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_enc_tell(&enc, 0), &enc, C);
775
776    /* Re-synthesis of the coded audio if required */
777    if (st->pitch_available>0 || optional_synthesis!=NULL)
778    {
779       if (st->pitch_available>0 && st->pitch_available<MAX_PERIOD)
780         st->pitch_available+=st->frame_size;
781
782       if (mdct_weight_shift)
783       {
784          mdct_shape(st->mode, X, 0, mdct_weight_pos+1, N, st->mode->nbShortMdcts, mdct_weight_shift, C);
785       }
786
787       /* Synthesis */
788       denormalise_bands(st->mode, X, freq, bandE, C);
789
790       CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->overlap-N));
791
792       if (has_pitch)
793          apply_pitch(st->mode, freq, pitch_freq, gain_id, 0, C);
794       
795       compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem, C);
796
797       /* De-emphasis and put everything back at the right place 
798          in the synthesis history */
799       if (optional_synthesis != NULL) {
800          deemphasis(st->out_mem, optional_synthesis, N, C, preemph, st->preemph_memD);
801
802       }
803    }
804
805    ec_enc_done(&enc);
806    
807    RESTORE_STACK;
808    return nbCompressedBytes;
809 }
810
811 #ifdef FIXED_POINT
812 #ifndef DISABLE_FLOAT_API
813 int celt_encode_float(CELTEncoder * restrict st, const float * pcm, float * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
814 {
815    int j, ret, C, N;
816    VARDECL(celt_int16_t, in);
817    SAVE_STACK;
818
819    if (check_encoder(st) != CELT_OK)
820       return CELT_INVALID_STATE;
821
822    if (check_mode(st->mode) != CELT_OK)
823       return CELT_INVALID_MODE;
824
825    if (pcm==NULL)
826       return CELT_BAD_ARG;
827
828    C = MCHANNELS(st->mode);
829    N = st->block_size;
830    ALLOC(in, C*N, celt_int16_t);
831
832    for (j=0;j<C*N;j++)
833      in[j] = FLOAT2INT16(pcm[j]);
834
835    if (optional_synthesis != NULL) {
836      ret=celt_encode(st,in,in,compressed,nbCompressedBytes);
837       for (j=0;j<C*N;j++)
838          optional_synthesis[j]=in[j]*(1/32768.);
839    } else {
840      ret=celt_encode(st,in,NULL,compressed,nbCompressedBytes);
841    }
842    RESTORE_STACK;
843    return ret;
844
845 }
846 #endif /*DISABLE_FLOAT_API*/
847 #else
848 int celt_encode(CELTEncoder * restrict st, const celt_int16_t * pcm, celt_int16_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
849 {
850    int j, ret, C, N;
851    VARDECL(celt_sig_t, in);
852    SAVE_STACK;
853
854    if (check_encoder(st) != CELT_OK)
855       return CELT_INVALID_STATE;
856
857    if (check_mode(st->mode) != CELT_OK)
858       return CELT_INVALID_MODE;
859
860    if (pcm==NULL)
861       return CELT_BAD_ARG;
862
863    C=MCHANNELS(st->mode);
864    N=st->block_size;
865    ALLOC(in, C*N, celt_sig_t);
866    for (j=0;j<C*N;j++) {
867      in[j] = SCALEOUT(pcm[j]);
868    }
869
870    if (optional_synthesis != NULL) {
871       ret = celt_encode_float(st,in,in,compressed,nbCompressedBytes);
872       for (j=0;j<C*N;j++)
873          optional_synthesis[j] = FLOAT2INT16(in[j]);
874    } else {
875       ret = celt_encode_float(st,in,NULL,compressed,nbCompressedBytes);
876    }
877    RESTORE_STACK;
878    return ret;
879 }
880 #endif
881
882 int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
883 {
884    va_list ap;
885    
886    if (check_encoder(st) != CELT_OK)
887       return CELT_INVALID_STATE;
888
889    va_start(ap, request);
890    if ((request!=CELT_GET_MODE_REQUEST) && (check_mode(st->mode) != CELT_OK))
891      goto bad_mode;
892    switch (request)
893    {
894       case CELT_GET_MODE_REQUEST:
895       {
896          const CELTMode ** value = va_arg(ap, const CELTMode**);
897          if (value==0)
898             goto bad_arg;
899          *value=st->mode;
900       }
901       break;
902       case CELT_SET_COMPLEXITY_REQUEST:
903       {
904          int value = va_arg(ap, celt_int32_t);
905          if (value<0 || value>10)
906             goto bad_arg;
907          if (value<=2) {
908             st->pitch_enabled = 0; 
909             st->pitch_available = 0;
910          } else {
911               st->pitch_enabled = 1;
912               if (st->pitch_available<1)
913                 st->pitch_available = 1;
914          }   
915       }
916       break;
917       case CELT_SET_PREDICTION_REQUEST:
918       {
919          int value = va_arg(ap, celt_int32_t);
920          if (value<0 || value>2)
921             goto bad_arg;
922          if (value==0)
923          {
924             st->force_intra   = 1;
925             st->pitch_permitted = 0;
926          } else if (value==1) {
927             st->force_intra   = 0;
928             st->pitch_permitted = 0;
929          } else {
930             st->force_intra   = 0;
931             st->pitch_permitted = 1;
932          }   
933       }
934       break;
935       case CELT_SET_VBR_RATE_REQUEST:
936       {
937          celt_int32_t value = va_arg(ap, celt_int32_t);
938          if (value<0)
939             goto bad_arg;
940          if (value>3072000)
941             value = 3072000;
942          st->VBR_rate = ((st->mode->Fs<<3)+(st->block_size>>1))/st->block_size;
943          st->VBR_rate = ((value<<7)+(st->VBR_rate>>1))/st->VBR_rate;
944       }
945       break;
946       case CELT_RESET_STATE:
947       {
948          const CELTMode *mode = st->mode;
949          int C = mode->nbChannels;
950
951          if (st->pitch_available > 0) st->pitch_available = 1;
952
953          CELT_MEMSET(st->in_mem, 0, st->overlap*C);
954          CELT_MEMSET(st->out_mem, 0, (MAX_PERIOD+st->overlap)*C);
955
956          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
957
958          CELT_MEMSET(st->preemph_memE, 0, C);
959          CELT_MEMSET(st->preemph_memD, 0, C);
960          st->delayedIntra = 1;
961       }
962       break;
963       default:
964          goto bad_request;
965    }
966    va_end(ap);
967    return CELT_OK;
968 bad_mode:
969   va_end(ap);
970   return CELT_INVALID_MODE;
971 bad_arg:
972    va_end(ap);
973    return CELT_BAD_ARG;
974 bad_request:
975    va_end(ap);
976    return CELT_UNIMPLEMENTED;
977 }
978
979 /**********************************************************************/
980 /*                                                                    */
981 /*                             DECODER                                */
982 /*                                                                    */
983 /**********************************************************************/
984 #ifdef NEW_PLC
985 #define DECODE_BUFFER_SIZE 2048
986 #else
987 #define DECODE_BUFFER_SIZE MAX_PERIOD
988 #endif
989
990 #define DECODERVALID   0x4c434454
991 #define DECODERPARTIAL 0x5444434c
992 #define DECODERFREED   0x4c004400
993
994 /** Decoder state 
995  @brief Decoder state
996  */
997 struct CELTDecoder {
998    celt_uint32_t marker;
999    const CELTMode *mode;
1000    int frame_size;
1001    int block_size;
1002    int overlap;
1003
1004    ec_byte_buffer buf;
1005    ec_enc         enc;
1006
1007    celt_sig_t * restrict preemph_memD;
1008
1009    celt_sig_t *out_mem;
1010    celt_sig_t *decode_mem;
1011
1012    celt_word16_t *oldBandE;
1013    
1014    int last_pitch_index;
1015    int loss_count;
1016 };
1017
1018 int check_decoder(const CELTDecoder *st) 
1019 {
1020    if (st==NULL)
1021    {
1022       celt_warning("NULL passed a decoder structure");  
1023       return CELT_INVALID_STATE;
1024    }
1025    if (st->marker == DECODERVALID)
1026       return CELT_OK;
1027    if (st->marker == DECODERFREED)
1028       celt_warning("Referencing a decoder that has already been freed");
1029    else
1030       celt_warning("This is not a valid CELT decoder structure");
1031    return CELT_INVALID_STATE;
1032 }
1033
1034 CELTDecoder *celt_decoder_create(const CELTMode *mode)
1035 {
1036    int N, C;
1037    CELTDecoder *st;
1038
1039    if (check_mode(mode) != CELT_OK)
1040       return NULL;
1041
1042    N = mode->mdctSize;
1043    C = MCHANNELS(mode);
1044    st = celt_alloc(sizeof(CELTDecoder));
1045
1046    if (st==NULL)
1047       return NULL;
1048    
1049    st->marker = DECODERPARTIAL;
1050    st->mode = mode;
1051    st->frame_size = N;
1052    st->block_size = N;
1053    st->overlap = mode->overlap;
1054
1055    st->decode_mem = celt_alloc((DECODE_BUFFER_SIZE+st->overlap)*C*sizeof(celt_sig_t));
1056    st->out_mem = st->decode_mem+DECODE_BUFFER_SIZE-MAX_PERIOD;
1057    
1058    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
1059    
1060    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));
1061
1062    st->loss_count = 0;
1063
1064    if ((st->decode_mem!=NULL) && (st->out_mem!=NULL) && (st->oldBandE!=NULL) &&
1065        (st->preemph_memD!=NULL))
1066    {
1067       st->marker = DECODERVALID;
1068       return st;
1069    }
1070    /* If the setup fails for some reason deallocate it. */
1071    celt_decoder_destroy(st);
1072    return NULL;
1073 }
1074
1075 void celt_decoder_destroy(CELTDecoder *st)
1076 {
1077    if (st == NULL)
1078    {
1079       celt_warning("NULL passed to celt_decoder_destroy");
1080       return;
1081    }
1082
1083    if (st->marker == DECODERFREED) 
1084    {
1085       celt_warning("Freeing a decoder which has already been freed"); 
1086       return;
1087    }
1088    
1089    if (st->marker != DECODERVALID && st->marker != DECODERPARTIAL)
1090    {
1091       celt_warning("This is not a valid CELT decoder structure");
1092       return;
1093    }
1094    
1095    /*Check_mode is non-fatal here because we can still free
1096      the encoder memory even if the mode is bad, although calling
1097      the free functions in this order is a violation of the API.*/
1098    check_mode(st->mode);
1099    
1100    celt_free(st->decode_mem);
1101    celt_free(st->oldBandE);
1102    celt_free(st->preemph_memD);
1103    
1104    st->marker = DECODERFREED;
1105    
1106    celt_free(st);
1107 }
1108
1109 /** Handles lost packets by just copying past data with the same
1110     offset as the last
1111     pitch period */
1112 #ifdef NEW_PLC
1113 #include "plc.c"
1114 #else
1115 static void celt_decode_lost(CELTDecoder * restrict st, celt_word16_t * restrict pcm)
1116 {
1117    int c, N;
1118    int pitch_index;
1119    celt_word16_t fade = Q15ONE;
1120    int i, len;
1121    VARDECL(celt_sig_t, freq);
1122    const int C = MCHANNELS(st->mode);
1123    int offset;
1124    SAVE_STACK;
1125    N = st->block_size;
1126    ALLOC(freq,C*N, celt_sig_t); /**< Interleaved signal MDCTs */
1127    
1128    len = N+st->mode->overlap;
1129    
1130    if (st->loss_count == 0)
1131    {
1132       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);
1133       pitch_index = MAX_PERIOD-len-pitch_index;
1134       st->last_pitch_index = pitch_index;
1135    } else {
1136       pitch_index = st->last_pitch_index;
1137       if (st->loss_count < 5)
1138          fade = QCONST16(.8f,15);
1139       else
1140          fade = 0;
1141    }
1142
1143    offset = MAX_PERIOD-pitch_index;
1144    while (offset+len >= MAX_PERIOD)
1145       offset -= pitch_index;
1146    compute_mdcts(st->mode, 0, st->out_mem+offset*C, freq, C);
1147    for (i=0;i<C*N;i++)
1148       freq[i] = ADD32(VERY_SMALL, MULT16_32_Q15(fade,freq[i]));
1149
1150    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->mode->overlap-N));
1151    /* Compute inverse MDCTs */
1152    compute_inv_mdcts(st->mode, 0, freq, -1, 0, st->out_mem, C);
1153
1154    for (c=0;c<C;c++)
1155    {
1156       int j;
1157       for (j=0;j<N;j++)
1158       {
1159          celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
1160                                 preemph,st->preemph_memD[c]);
1161          st->preemph_memD[c] = tmp;
1162          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
1163       }
1164    }
1165    
1166    st->loss_count++;
1167
1168    RESTORE_STACK;
1169 }
1170 #endif
1171
1172 #ifdef FIXED_POINT
1173 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16_t * restrict pcm)
1174 {
1175 #else
1176 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, celt_sig_t * restrict pcm)
1177 {
1178 #endif
1179    int i, N, N4;
1180    int has_pitch, has_fold;
1181    int pitch_index;
1182    int bits;
1183    ec_dec dec;
1184    ec_byte_buffer buf;
1185    VARDECL(celt_sig_t, freq);
1186    VARDECL(celt_sig_t, pitch_freq);
1187    VARDECL(celt_norm_t, X);
1188    VARDECL(celt_ener_t, bandE);
1189    VARDECL(int, fine_quant);
1190    VARDECL(int, pulses);
1191    VARDECL(int, offsets);
1192    VARDECL(int, fine_priority);
1193
1194    int shortBlocks;
1195    int intra_ener;
1196    int transient_time;
1197    int transient_shift;
1198    int mdct_weight_shift=0;
1199    const int C = MCHANNELS(st->mode);
1200    int mdct_weight_pos=0;
1201    int gain_id=0;
1202    SAVE_STACK;
1203
1204    if (check_decoder(st) != CELT_OK)
1205       return CELT_INVALID_STATE;
1206
1207    if (check_mode(st->mode) != CELT_OK)
1208       return CELT_INVALID_MODE;
1209
1210    if (pcm==NULL)
1211       return CELT_BAD_ARG;
1212
1213    N = st->block_size;
1214    N4 = (N-st->overlap)>>1;
1215
1216    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
1217    ALLOC(X, C*N, celt_norm_t);   /**< Interleaved normalised MDCTs */
1218    ALLOC(bandE, st->mode->nbEBands*C, celt_ener_t);
1219    
1220    if (data == NULL)
1221    {
1222       celt_decode_lost(st, pcm);
1223       RESTORE_STACK;
1224       return 0;
1225    } else {
1226       st->loss_count = 0;
1227    }
1228    if (len<0) {
1229      RESTORE_STACK;
1230      return CELT_BAD_ARG;
1231    }
1232    
1233    ec_byte_readinit(&buf,(unsigned char*)data,len);
1234    ec_dec_init(&dec,&buf);
1235    
1236    decode_flags(&dec, &intra_ener, &has_pitch, &shortBlocks, &has_fold);
1237    if (shortBlocks)
1238    {
1239       transient_shift = ec_dec_uint(&dec, 4);
1240       if (transient_shift == 3)
1241       {
1242          transient_time = ec_dec_uint(&dec, N+st->mode->overlap);
1243       } else {
1244          mdct_weight_shift = transient_shift;
1245          if (mdct_weight_shift && st->mode->nbShortMdcts>2)
1246             mdct_weight_pos = ec_dec_uint(&dec, st->mode->nbShortMdcts-1);
1247          transient_shift = 0;
1248          transient_time = 0;
1249       }
1250    } else {
1251       transient_time = -1;
1252       transient_shift = 0;
1253    }
1254    
1255    if (has_pitch)
1256    {
1257       pitch_index = ec_dec_uint(&dec, MAX_PERIOD-(2*N-2*N4));
1258       gain_id = ec_dec_uint(&dec, 16);
1259    } else {
1260       pitch_index = 0;
1261    }
1262
1263    ALLOC(fine_quant, st->mode->nbEBands, int);
1264    /* Get band energies */
1265    unquant_coarse_energy(st->mode, bandE, st->oldBandE, len*8/3, intra_ener, st->mode->prob, &dec, C);
1266    
1267    ALLOC(pulses, st->mode->nbEBands, int);
1268    ALLOC(offsets, st->mode->nbEBands, int);
1269    ALLOC(fine_priority, st->mode->nbEBands, int);
1270
1271    for (i=0;i<st->mode->nbEBands;i++)
1272       offsets[i] = 0;
1273
1274    bits = len*8 - ec_dec_tell(&dec, 0) - 1;
1275    compute_allocation(st->mode, offsets, bits, pulses, fine_quant, fine_priority, C);
1276    /*bits = ec_dec_tell(&dec, 0);
1277    compute_fine_allocation(st->mode, fine_quant, (20*C+len*8/5-(ec_dec_tell(&dec, 0)-bits))/C);*/
1278    
1279    unquant_fine_energy(st->mode, bandE, st->oldBandE, fine_quant, &dec, C);
1280
1281    ALLOC(pitch_freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
1282    if (has_pitch) 
1283    {
1284       /* Pitch MDCT */
1285       compute_mdcts(st->mode, 0, st->out_mem+pitch_index*C, pitch_freq, C);
1286    }
1287
1288    /* Decode fixed codebook and merge with pitch */
1289    if (C==1)
1290       quant_bands(st->mode, X, bandE, pulses, shortBlocks, has_fold, len*8, 0, &dec);
1291 #ifndef DISABLE_STEREO
1292    else
1293       unquant_bands_stereo(st->mode, X, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
1294 #endif
1295    unquant_energy_finalise(st->mode, bandE, st->oldBandE, fine_quant, fine_priority, len*8-ec_dec_tell(&dec, 0), &dec, C);
1296    
1297    if (mdct_weight_shift)
1298    {
1299       mdct_shape(st->mode, X, 0, mdct_weight_pos+1, N, st->mode->nbShortMdcts, mdct_weight_shift, C);
1300    }
1301
1302    /* Synthesis */
1303    denormalise_bands(st->mode, X, freq, bandE, C);
1304
1305
1306    CELT_MOVE(st->decode_mem, st->decode_mem+C*N, C*(DECODE_BUFFER_SIZE+st->overlap-N));
1307
1308    if (has_pitch)
1309       apply_pitch(st->mode, freq, pitch_freq, gain_id, 0, C);
1310
1311    /* Compute inverse MDCTs */
1312    compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem, C);
1313
1314    deemphasis(st->out_mem, pcm, N, C, preemph, st->preemph_memD);
1315
1316    RESTORE_STACK;
1317    return 0;
1318 }
1319
1320 #ifdef FIXED_POINT
1321 #ifndef DISABLE_FLOAT_API
1322 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm)
1323 {
1324    int j, ret, C, N;
1325    VARDECL(celt_int16_t, out);
1326    SAVE_STACK;
1327
1328    if (check_decoder(st) != CELT_OK)
1329       return CELT_INVALID_STATE;
1330
1331    if (check_mode(st->mode) != CELT_OK)
1332       return CELT_INVALID_MODE;
1333
1334    if (pcm==NULL)
1335       return CELT_BAD_ARG;
1336
1337    C = MCHANNELS(st->mode);
1338    N = st->block_size;
1339    
1340    ALLOC(out, C*N, celt_int16_t);
1341    ret=celt_decode(st, data, len, out);
1342    for (j=0;j<C*N;j++)
1343       pcm[j]=out[j]*(1/32768.);
1344      
1345    RESTORE_STACK;
1346    return ret;
1347 }
1348 #endif /*DISABLE_FLOAT_API*/
1349 #else
1350 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16_t * restrict pcm)
1351 {
1352    int j, ret, C, N;
1353    VARDECL(celt_sig_t, out);
1354    SAVE_STACK;
1355
1356    if (check_decoder(st) != CELT_OK)
1357       return CELT_INVALID_STATE;
1358
1359    if (check_mode(st->mode) != CELT_OK)
1360       return CELT_INVALID_MODE;
1361
1362    if (pcm==NULL)
1363       return CELT_BAD_ARG;
1364
1365    C = MCHANNELS(st->mode);
1366    N = st->block_size;
1367    ALLOC(out, C*N, celt_sig_t);
1368
1369    ret=celt_decode_float(st, data, len, out);
1370
1371    for (j=0;j<C*N;j++)
1372       pcm[j] = FLOAT2INT16 (out[j]);
1373    
1374    RESTORE_STACK;
1375    return ret;
1376 }
1377 #endif
1378
1379 int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
1380 {
1381    va_list ap;
1382
1383    if (check_decoder(st) != CELT_OK)
1384       return CELT_INVALID_STATE;
1385
1386    va_start(ap, request);
1387    if ((request!=CELT_GET_MODE_REQUEST) && (check_mode(st->mode) != CELT_OK))
1388      goto bad_mode;
1389    switch (request)
1390    {
1391       case CELT_GET_MODE_REQUEST:
1392       {
1393          const CELTMode ** value = va_arg(ap, const CELTMode**);
1394          if (value==0)
1395             goto bad_arg;
1396          *value=st->mode;
1397       }
1398       break;
1399       case CELT_RESET_STATE:
1400       {
1401          const CELTMode *mode = st->mode;
1402          int C = mode->nbChannels;
1403
1404          CELT_MEMSET(st->decode_mem, 0, (DECODE_BUFFER_SIZE+st->overlap)*C);
1405          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
1406
1407          CELT_MEMSET(st->preemph_memD, 0, C);
1408
1409          st->loss_count = 0;
1410       }
1411       break;
1412       default:
1413          goto bad_request;
1414    }
1415    va_end(ap);
1416    return CELT_OK;
1417 bad_mode:
1418   va_end(ap);
1419   return CELT_INVALID_MODE;
1420 bad_arg:
1421    va_end(ap);
1422    return CELT_BAD_ARG;
1423 bad_request:
1424       va_end(ap);
1425   return CELT_UNIMPLEMENTED;
1426 }