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