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