Adding a decision mechanism for turning folding on or off depending on the
[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    stereo_decision(st->mode, X, stereo_mode, st->mode->nbEBands);
778
779    for (i=0;i<st->mode->nbEBands;i++)
780       offsets[i] = 0;
781    bits = nbCompressedBytes*8 - ec_enc_tell(&enc, 0) - 1;
782    if (has_pitch)
783       bits -= st->mode->nbPBands;
784 #ifndef STDIN_TUNING
785    compute_allocation(st->mode, offsets, stereo_mode, bits, pulses, fine_quant);
786 #endif
787
788    quant_fine_energy(st->mode, bandE, st->oldBandE, error, fine_quant, &enc);
789
790    /* Residual quantisation */
791    if (C==1)
792       quant_bands(st->mode, X, P, NULL, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, &enc);
793    else
794       quant_bands_stereo(st->mode, X, P, NULL, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, &enc);
795
796    /* Re-synthesis of the coded audio if required */
797    if (st->pitch_available>0 || optional_synthesis!=NULL)
798    {
799       if (st->pitch_available>0 && st->pitch_available<MAX_PERIOD)
800         st->pitch_available+=st->frame_size;
801
802       /* Synthesis */
803       denormalise_bands(st->mode, X, freq, bandE);
804       
805       
806       CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->overlap-N));
807       
808       if (mdct_weight_shift)
809       {
810          int m;
811          for (c=0;c<C;c++)
812             for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
813                for (i=m*C+c;i<N;i+=C*st->mode->nbShortMdcts)
814 #ifdef FIXED_POINT
815                   freq[i] = SHL32(freq[i], mdct_weight_shift);
816 #else
817                   freq[i] = (1<<mdct_weight_shift)*freq[i];
818 #endif
819       }
820       compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem);
821       /* De-emphasis and put everything back at the right place in the synthesis history */
822       if (optional_synthesis != NULL) {
823          for (c=0;c<C;c++)
824          {
825             int j;
826             for (j=0;j<N;j++)
827             {
828                celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
829                                    preemph,st->preemph_memD[c]);
830                st->preemph_memD[c] = tmp;
831                optional_synthesis[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
832             }
833          }
834       }
835    }
836
837    /*fprintf (stderr, "remaining bits after encode = %d\n", nbCompressedBytes*8-ec_enc_tell(&enc, 0));*/
838    /*if (ec_enc_tell(&enc, 0) < nbCompressedBytes*8 - 7)
839       celt_warning_int ("many unused bits: ", nbCompressedBytes*8-ec_enc_tell(&enc, 0));*/
840
841    /* Finishing the stream with a 0101... pattern so that the decoder can check is everything's right */
842    {
843       int val = 0;
844       while (ec_enc_tell(&enc, 0) < nbCompressedBytes*8)
845       {
846          ec_enc_uint(&enc, val, 2);
847          val = 1-val;
848       }
849    }
850    ec_enc_done(&enc);
851    {
852       /*unsigned char *data;*/
853       int nbBytes = ec_byte_bytes(&buf);
854       if (nbBytes > nbCompressedBytes)
855       {
856          celt_warning_int ("got too many bytes:", nbBytes);
857          RESTORE_STACK;
858          return CELT_INTERNAL_ERROR;
859       }
860    }
861
862    RESTORE_STACK;
863    return nbCompressedBytes;
864 }
865
866 #ifdef FIXED_POINT
867 #ifndef DISABLE_FLOAT_API
868 int celt_encode_float(CELTEncoder * restrict st, const float * pcm, float * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
869 {
870    int j, ret;
871    const int C = CHANNELS(st->mode);
872    const int N = st->block_size;
873    VARDECL(celt_int16_t, in);
874    SAVE_STACK;
875    ALLOC(in, C*N, celt_int16_t);
876
877    for (j=0;j<C*N;j++)
878      in[j] = FLOAT2INT16(pcm[j]);
879
880    if (optional_synthesis != NULL) {
881      ret=celt_encode(st,in,in,compressed,nbCompressedBytes);
882       for (j=0;j<C*N;j++)
883          optional_synthesis[j]=in[j]*(1/32768.);
884    } else {
885      ret=celt_encode(st,in,NULL,compressed,nbCompressedBytes);
886    }
887    RESTORE_STACK;
888    return ret;
889
890 }
891 #endif /*DISABLE_FLOAT_API*/
892 #else
893 int celt_encode(CELTEncoder * restrict st, const celt_int16_t * pcm, celt_int16_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
894 {
895    int j, ret;
896    VARDECL(celt_sig_t, in);
897    const int C = CHANNELS(st->mode);
898    const int N = st->block_size;
899    SAVE_STACK;
900    ALLOC(in, C*N, celt_sig_t);
901    for (j=0;j<C*N;j++) {
902      in[j] = SCALEOUT(pcm[j]);
903    }
904
905    if (optional_synthesis != NULL) {
906       ret = celt_encode_float(st,in,in,compressed,nbCompressedBytes);
907       for (j=0;j<C*N;j++)
908          optional_synthesis[j] = FLOAT2INT16(in[j]);
909    } else {
910       ret = celt_encode_float(st,in,NULL,compressed,nbCompressedBytes);
911    }
912    RESTORE_STACK;
913    return ret;
914 }
915 #endif
916
917 int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
918 {
919    va_list ap;
920    va_start(ap, request);
921    switch (request)
922    {
923       case CELT_SET_COMPLEXITY_REQUEST:
924       {
925          int value = va_arg(ap, celt_int32_t);
926          if (value<0 || value>10)
927             goto bad_arg;
928          if (value<=2) {
929             st->pitch_enabled = 0; 
930             st->pitch_available = 0;
931          } else {
932               st->pitch_enabled = 1;
933               if (st->pitch_available<1)
934                 st->pitch_available = 1;
935          }   
936       }
937       break;
938       case CELT_SET_LTP_REQUEST:
939       {
940          int value = va_arg(ap, celt_int32_t);
941          if (value<0 || value>1 || (value==1 && st->pitch_available==0))
942             goto bad_arg;
943          if (value==0)
944             st->pitch_enabled = 0;
945          else
946             st->pitch_enabled = 1;
947       }
948       break;
949       case CELT_SET_VBR_RATE_REQUEST:
950       {
951          int value = va_arg(ap, celt_int32_t);
952          if (value<0)
953             goto bad_arg;
954          if (value>3072000)
955             value = 3072000;
956          st->VBR_rate = ((st->mode->Fs<<3)+(st->block_size>>1))/st->block_size;
957          st->VBR_rate = ((value<<7)+(st->VBR_rate>>1))/st->VBR_rate;
958       }
959       break;
960       case CELT_RESET_STATE:
961       {
962          const CELTMode *mode = st->mode;
963          int C = mode->nbChannels;
964
965          if (st->pitch_available > 0) st->pitch_available = 1;
966
967          CELT_MEMSET(st->in_mem, 0, st->overlap*C);
968          CELT_MEMSET(st->out_mem, 0, (MAX_PERIOD+st->overlap)*C);
969
970          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
971
972          CELT_MEMSET(st->preemph_memE, 0, C);
973          CELT_MEMSET(st->preemph_memD, 0, C);
974          st->delayedIntra = 1;
975       }
976       break;
977       default:
978          goto bad_request;
979    }
980    va_end(ap);
981    return CELT_OK;
982 bad_arg:
983    va_end(ap);
984    return CELT_BAD_ARG;
985 bad_request:
986    va_end(ap);
987    return CELT_UNIMPLEMENTED;
988 }
989
990 /****************************************************************************/
991 /*                                                                          */
992 /*                                DECODER                                   */
993 /*                                                                          */
994 /****************************************************************************/
995 #ifdef NEW_PLC
996 #define DECODE_BUFFER_SIZE 2048
997 #else
998 #define DECODE_BUFFER_SIZE MAX_PERIOD
999 #endif
1000
1001 /** Decoder state 
1002  @brief Decoder state
1003  */
1004 struct CELTDecoder {
1005    const CELTMode *mode;
1006    int frame_size;
1007    int block_size;
1008    int overlap;
1009
1010    ec_byte_buffer buf;
1011    ec_enc         enc;
1012
1013    celt_sig_t * restrict preemph_memD;
1014
1015    celt_sig_t *out_mem;
1016    celt_sig_t *decode_mem;
1017
1018    celt_word16_t *oldBandE;
1019    
1020    int last_pitch_index;
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    st->mode = mode;
1036    st->frame_size = N;
1037    st->block_size = N;
1038    st->overlap = mode->overlap;
1039
1040    st->decode_mem = celt_alloc((DECODE_BUFFER_SIZE+st->overlap)*C*sizeof(celt_sig_t));
1041    st->out_mem = st->decode_mem+DECODE_BUFFER_SIZE-MAX_PERIOD;
1042    
1043    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
1044
1045    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));
1046
1047    st->last_pitch_index = 0;
1048    return st;
1049 }
1050
1051 void celt_decoder_destroy(CELTDecoder *st)
1052 {
1053    if (st == NULL)
1054    {
1055       celt_warning("NULL passed to celt_encoder_destroy");
1056       return;
1057    }
1058    if (check_mode(st->mode) != CELT_OK)
1059       return;
1060
1061
1062    celt_free(st->decode_mem);
1063    
1064    celt_free(st->oldBandE);
1065    
1066    celt_free(st->preemph_memD);
1067
1068    celt_free(st);
1069 }
1070
1071 /** Handles lost packets by just copying past data with the same offset as the last
1072     pitch period */
1073 #ifdef NEW_PLC
1074 #include "plc.c"
1075 #else
1076 static void celt_decode_lost(CELTDecoder * restrict st, celt_word16_t * restrict pcm)
1077 {
1078    int c, N;
1079    int pitch_index;
1080    int i, len;
1081    VARDECL(celt_sig_t, freq);
1082    const int C = CHANNELS(st->mode);
1083    int offset;
1084    SAVE_STACK;
1085    N = st->block_size;
1086    ALLOC(freq,C*N, celt_sig_t);         /**< Interleaved signal MDCTs */
1087    
1088    len = N+st->mode->overlap;
1089 #if 0
1090    pitch_index = st->last_pitch_index;
1091    
1092    /* Use the pitch MDCT as the "guessed" signal */
1093    compute_mdcts(st->mode, st->mode->window, st->out_mem+pitch_index*C, freq);
1094
1095 #else
1096    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);
1097    pitch_index = MAX_PERIOD-len-pitch_index;
1098    offset = MAX_PERIOD-pitch_index;
1099    while (offset+len >= MAX_PERIOD)
1100       offset -= pitch_index;
1101    compute_mdcts(st->mode, 0, st->out_mem+offset*C, freq);
1102    for (i=0;i<N;i++)
1103       freq[i] = ADD32(EPSILON, MULT16_32_Q15(QCONST16(.9f,15),freq[i]));
1104 #endif
1105    
1106    
1107    
1108    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->mode->overlap-N));
1109    /* Compute inverse MDCTs */
1110    compute_inv_mdcts(st->mode, 0, freq, -1, 0, st->out_mem);
1111
1112    for (c=0;c<C;c++)
1113    {
1114       int j;
1115       for (j=0;j<N;j++)
1116       {
1117          celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
1118                                 preemph,st->preemph_memD[c]);
1119          st->preemph_memD[c] = tmp;
1120          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
1121       }
1122    }
1123    RESTORE_STACK;
1124 }
1125 #endif
1126
1127 #ifdef FIXED_POINT
1128 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16_t * restrict pcm)
1129 {
1130 #else
1131 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, celt_sig_t * restrict pcm)
1132 {
1133 #endif
1134    int i, c, N, N4;
1135    int has_pitch, has_fold;
1136    int pitch_index;
1137    int bits;
1138    ec_dec dec;
1139    ec_byte_buffer buf;
1140    VARDECL(celt_sig_t, freq);
1141    VARDECL(celt_norm_t, X);
1142    VARDECL(celt_norm_t, P);
1143    VARDECL(celt_ener_t, bandE);
1144    VARDECL(celt_pgain_t, gains);
1145    VARDECL(int, stereo_mode);
1146    VARDECL(int, fine_quant);
1147    VARDECL(int, pulses);
1148    VARDECL(int, offsets);
1149
1150    int shortBlocks;
1151    int intra_ener;
1152    int transient_time;
1153    int transient_shift;
1154    int mdct_weight_shift=0;
1155    const int C = CHANNELS(st->mode);
1156    int mdct_weight_pos=0;
1157    SAVE_STACK;
1158
1159    if (check_mode(st->mode) != CELT_OK)
1160       return CELT_INVALID_MODE;
1161
1162    N = st->block_size;
1163    N4 = (N-st->overlap)>>1;
1164
1165    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
1166    ALLOC(X, C*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
1167    ALLOC(P, C*N, celt_norm_t);         /**< Interleaved normalised pitch MDCTs*/
1168    ALLOC(bandE, st->mode->nbEBands*C, celt_ener_t);
1169    ALLOC(gains, st->mode->nbPBands, celt_pgain_t);
1170    
1171    if (check_mode(st->mode) != CELT_OK)
1172    {
1173       RESTORE_STACK;
1174       return CELT_INVALID_MODE;
1175    }
1176    if (data == NULL)
1177    {
1178       celt_decode_lost(st, pcm);
1179       RESTORE_STACK;
1180       return 0;
1181    }
1182    if (len<0) {
1183      RESTORE_STACK;
1184      return CELT_BAD_ARG;
1185    }
1186    
1187    ec_byte_readinit(&buf,(unsigned char*)data,len);
1188    ec_dec_init(&dec,&buf);
1189    
1190    decode_flags(&dec, &intra_ener, &has_pitch, &shortBlocks, &has_fold);
1191    if (shortBlocks)
1192    {
1193       transient_shift = ec_dec_bits(&dec, 2);
1194       if (transient_shift == 3)
1195       {
1196          transient_time = ec_dec_uint(&dec, N+st->mode->overlap);
1197       } else {
1198          mdct_weight_shift = transient_shift;
1199          if (mdct_weight_shift && st->mode->nbShortMdcts>2)
1200             mdct_weight_pos = ec_dec_uint(&dec, st->mode->nbShortMdcts-1);
1201          transient_shift = 0;
1202          transient_time = 0;
1203       }
1204    } else {
1205       transient_time = -1;
1206       transient_shift = 0;
1207    }
1208    
1209    if (has_pitch)
1210    {
1211       pitch_index = ec_dec_uint(&dec, MAX_PERIOD-(2*N-2*N4));
1212       st->last_pitch_index = pitch_index;
1213    } else {
1214       pitch_index = 0;
1215       for (i=0;i<st->mode->nbPBands;i++)
1216          gains[i] = 0;
1217    }
1218
1219    ALLOC(fine_quant, st->mode->nbEBands, int);
1220    /* Get band energies */
1221    unquant_coarse_energy(st->mode, bandE, st->oldBandE, len*8/3, intra_ener, st->mode->prob, &dec);
1222    
1223    ALLOC(pulses, st->mode->nbEBands, int);
1224    ALLOC(offsets, st->mode->nbEBands, int);
1225    ALLOC(stereo_mode, st->mode->nbEBands, int);
1226    stereo_decision(st->mode, X, stereo_mode, st->mode->nbEBands);
1227
1228    for (i=0;i<st->mode->nbEBands;i++)
1229       offsets[i] = 0;
1230
1231    bits = len*8 - ec_dec_tell(&dec, 0) - 1;
1232    if (has_pitch)
1233       bits -= st->mode->nbPBands;
1234    compute_allocation(st->mode, offsets, stereo_mode, bits, pulses, fine_quant);
1235    /*bits = ec_dec_tell(&dec, 0);
1236    compute_fine_allocation(st->mode, fine_quant, (20*C+len*8/5-(ec_dec_tell(&dec, 0)-bits))/C);*/
1237    
1238    unquant_fine_energy(st->mode, bandE, st->oldBandE, fine_quant, &dec);
1239
1240
1241    if (has_pitch) 
1242    {
1243       VARDECL(celt_ener_t, bandEp);
1244       
1245       /* Pitch MDCT */
1246       compute_mdcts(st->mode, 0, st->out_mem+pitch_index*C, freq);
1247       ALLOC(bandEp, st->mode->nbEBands*C, celt_ener_t);
1248       compute_band_energies(st->mode, freq, bandEp);
1249       normalise_bands(st->mode, freq, P, bandEp);
1250       /* Apply pitch gains */
1251    } else {
1252       for (i=0;i<C*N;i++)
1253          P[i] = 0;
1254    }
1255
1256    /* Decode fixed codebook and merge with pitch */
1257    if (C==1)
1258       unquant_bands(st->mode, X, P, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
1259    else
1260       unquant_bands_stereo(st->mode, X, P, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
1261
1262    /* Synthesis */
1263    denormalise_bands(st->mode, X, freq, bandE);
1264
1265
1266    CELT_MOVE(st->decode_mem, st->decode_mem+C*N, C*(DECODE_BUFFER_SIZE+st->overlap-N));
1267    if (mdct_weight_shift)
1268    {
1269       int m;
1270       for (c=0;c<C;c++)
1271          for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
1272             for (i=m*C+c;i<N;i+=C*st->mode->nbShortMdcts)
1273 #ifdef FIXED_POINT
1274                freq[i] = SHL32(freq[i], mdct_weight_shift);
1275 #else
1276                freq[i] = (1<<mdct_weight_shift)*freq[i];
1277 #endif
1278    }
1279    /* Compute inverse MDCTs */
1280    compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem);
1281
1282    for (c=0;c<C;c++)
1283    {
1284       int j;
1285       for (j=0;j<N;j++)
1286       {
1287          celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
1288                                 preemph,st->preemph_memD[c]);
1289          st->preemph_memD[c] = tmp;
1290          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
1291       }
1292    }
1293
1294    {
1295       unsigned int val = 0;
1296       while (ec_dec_tell(&dec, 0) < len*8)
1297       {
1298          if (ec_dec_uint(&dec, 2) != val)
1299          {
1300             celt_warning("decode error");
1301             RESTORE_STACK;
1302             return CELT_CORRUPTED_DATA;
1303          }
1304          val = 1-val;
1305       }
1306    }
1307
1308    RESTORE_STACK;
1309    return 0;
1310    /*printf ("\n");*/
1311 }
1312
1313 #ifdef FIXED_POINT
1314 #ifndef DISABLE_FLOAT_API
1315 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm)
1316 {
1317    int j, ret;
1318    const int C = CHANNELS(st->mode);
1319    const int N = st->block_size;
1320    VARDECL(celt_int16_t, out);
1321    SAVE_STACK;
1322    ALLOC(out, C*N, celt_int16_t);
1323
1324    ret=celt_decode(st, data, len, out);
1325
1326    for (j=0;j<C*N;j++)
1327      pcm[j]=out[j]*(1/32768.);
1328    RESTORE_STACK;
1329    return ret;
1330 }
1331 #endif /*DISABLE_FLOAT_API*/
1332 #else
1333 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16_t * restrict pcm)
1334 {
1335    int j, ret;
1336    VARDECL(celt_sig_t, out);
1337    const int C = CHANNELS(st->mode);
1338    const int N = st->block_size;
1339    SAVE_STACK;
1340    ALLOC(out, C*N, celt_sig_t);
1341
1342    ret=celt_decode_float(st, data, len, out);
1343
1344    for (j=0;j<C*N;j++)
1345      pcm[j] = FLOAT2INT16 (out[j]);
1346
1347    RESTORE_STACK;
1348    return ret;
1349 }
1350 #endif
1351
1352 int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
1353 {
1354    va_list ap;
1355    va_start(ap, request);
1356    switch (request)
1357    {
1358       case CELT_RESET_STATE:
1359       {
1360          const CELTMode *mode = st->mode;
1361          int C = mode->nbChannels;
1362
1363          CELT_MEMSET(st->decode_mem, 0, (DECODE_BUFFER_SIZE+st->overlap)*C);
1364          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
1365
1366          CELT_MEMSET(st->preemph_memD, 0, C);
1367
1368          st->last_pitch_index = 0;
1369       }
1370       break;
1371       default:
1372          goto bad_request;
1373    }
1374    va_end(ap);
1375    return CELT_OK;
1376 #if 0    /* Put this back in if you ever need "bad_arg" */
1377 bad_arg:
1378    va_end(ap);
1379    return CELT_BAD_ARG;
1380 #endif
1381 bad_request:
1382       va_end(ap);
1383   return CELT_UNIMPLEMENTED;
1384 }