Saved on stack usage by changing the order of the allocation
[opus.git] / libcelt / celt.c
1 /* (C) 2007 Jean-Marc Valin, CSIRO
2 */
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_pitch.h"
48 #include "quant_bands.h"
49 #include "psy.h"
50 #include "rate.h"
51
52 #define MAX_PERIOD 1024
53
54 #ifndef M_PI
55 #define M_PI 3.141592653
56 #endif
57
58 /** Encoder state 
59  @brief Encoder state
60  */
61 struct CELTEncoder {
62    const CELTMode *mode;     /**< Mode used by the encoder */
63    int frame_size;
64    int block_size;
65    int nb_blocks;
66    int overlap;
67    int channels;
68    
69    ec_byte_buffer buf;
70    ec_enc         enc;
71
72    celt_word16_t preemph;
73    celt_sig_t *preemph_memE;
74    celt_sig_t *preemph_memD;
75    
76    mdct_lookup mdct_lookup;
77    kiss_fftr_cfg fft;
78    struct PsyDecay psy;
79    
80    celt_word16_t *window;
81    celt_sig_t *in_mem;
82    celt_sig_t *mdct_overlap;
83    celt_sig_t *out_mem;
84
85    celt_word16_t *oldBandE;
86 };
87
88
89
90 CELTEncoder *celt_encoder_create(const CELTMode *mode)
91 {
92    int i, N, B, C, N4;
93    CELTEncoder *st;
94
95    if (check_mode(mode) != CELT_OK)
96       return NULL;
97
98    N = mode->mdctSize;
99    B = mode->nbMdctBlocks;
100    C = mode->nbChannels;
101    st = celt_alloc(sizeof(CELTEncoder));
102    
103    st->mode = mode;
104    st->frame_size = B*N;
105    st->block_size = N;
106    st->nb_blocks  = B;
107    st->overlap = mode->overlap;
108
109    N4 = (N-st->overlap)/2;
110    ec_byte_writeinit(&st->buf);
111    ec_enc_init(&st->enc,&st->buf);
112
113    mdct_init(&st->mdct_lookup, 2*N);
114    st->fft = kiss_fftr_alloc(MAX_PERIOD*C, 0, 0);
115    psydecay_init(&st->psy, MAX_PERIOD*C/2, st->mode->Fs);
116    
117    st->window = (celt_word16_t*)celt_alloc(2*N*sizeof(celt_word16_t));
118    st->in_mem = celt_alloc(N*C*sizeof(celt_sig_t));
119    st->mdct_overlap = celt_alloc(N*C*sizeof(celt_sig_t));
120    st->out_mem = celt_alloc(MAX_PERIOD*C*sizeof(celt_sig_t));
121    for (i=0;i<2*N;i++)
122       st->window[i] = 0;
123    for (i=0;i<st->overlap;i++)
124       st->window[N4+i] = st->window[2*N-N4-i-1] 
125             = Q15ONE*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/st->overlap) * sin(.5*M_PI*(i+.5)/st->overlap));
126    for (i=0;i<2*N4;i++)
127       st->window[N-N4+i] = Q15ONE;
128    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
129
130    st->preemph = QCONST16(0.8f,15);
131    st->preemph_memE = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));;
132    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));;
133
134    return st;
135 }
136
137 void celt_encoder_destroy(CELTEncoder *st)
138 {
139    if (st == NULL)
140    {
141       celt_warning("NULL passed to celt_encoder_destroy");
142       return;
143    }
144    if (check_mode(st->mode) != CELT_OK)
145       return;
146
147    ec_byte_writeclear(&st->buf);
148
149    mdct_clear(&st->mdct_lookup);
150    kiss_fft_free(st->fft);
151    psydecay_clear(&st->psy);
152
153    celt_free(st->window);
154    celt_free(st->in_mem);
155    celt_free(st->mdct_overlap);
156    celt_free(st->out_mem);
157    
158    celt_free(st->oldBandE);
159    
160    celt_free(st->preemph_memE);
161    celt_free(st->preemph_memD);
162    
163    celt_free(st);
164 }
165
166 inline celt_int16_t SIG2INT16(celt_sig_t x)
167 {
168    x = PSHR32(x, SIG_SHIFT);
169    if (x>32767)
170       x = 32767;
171    else if (x<-32767)
172       x = -32767;
173 #ifdef FIXED_POINT
174    return EXTRACT16(x);
175 #else
176    return (celt_int16_t)floor(.5+x);
177 #endif
178 }
179
180 /** Apply window and compute the MDCT for all sub-frames and all channels in a frame */
181 static celt_word32_t compute_mdcts(mdct_lookup *mdct_lookup, celt_word16_t *window, celt_sig_t *in, celt_sig_t *out, int N, int B, int C)
182 {
183    int i, c;
184    celt_word32_t E = 0;
185    VARDECL(celt_word32_t *x);
186    VARDECL(celt_word32_t *tmp);
187    SAVE_STACK;
188    ALLOC(x, 2*N, celt_word32_t);
189    ALLOC(tmp, N, celt_word32_t);
190    for (c=0;c<C;c++)
191    {
192       for (i=0;i<B;i++)
193       {
194          int j;
195          for (j=0;j<2*N;j++)
196          {
197             x[j] = MULT16_32_Q15(window[j],in[C*i*N+C*j+c]);
198             E += MULT16_16(EXTRACT16(SHR32(x[j],SIG_SHIFT+4)),EXTRACT16(SHR32(x[j],SIG_SHIFT+4)));
199          }
200          mdct_forward(mdct_lookup, x, tmp);
201          /* Interleaving the sub-frames */
202          for (j=0;j<N;j++)
203             out[C*B*j+C*i+c] = tmp[j];
204       }
205    }
206    RESTORE_STACK;
207    return E;
208 }
209
210 /** Compute the IMDCT and apply window for all sub-frames and all channels in a frame */
211 static void compute_inv_mdcts(mdct_lookup *mdct_lookup, celt_word16_t *window, celt_sig_t *X, celt_sig_t *out_mem, celt_sig_t *mdct_overlap, int N, int overlap, int B, int C)
212 {
213    int i, c, N4;
214    VARDECL(celt_word32_t *x);
215    VARDECL(celt_word32_t *tmp);
216    SAVE_STACK;
217    ALLOC(x, 2*N, celt_word32_t);
218    ALLOC(tmp, N, celt_word32_t);
219    N4 = (N-overlap)/2;
220    for (c=0;c<C;c++)
221    {
222       for (i=0;i<B;i++)
223       {
224          int j;
225          /* De-interleaving the sub-frames */
226          for (j=0;j<N;j++)
227             tmp[j] = X[C*B*j+C*i+c];
228          mdct_backward(mdct_lookup, tmp, x);
229          for (j=0;j<2*N;j++)
230             x[j] = MULT16_32_Q15(window[j],x[j]);
231          for (j=0;j<overlap;j++)
232             out_mem[C*(MAX_PERIOD+(i-B)*N)+C*j+c] = 2*(x[N4+j]+mdct_overlap[C*j+c]);
233          for (j=0;j<2*N4;j++)
234             out_mem[C*(MAX_PERIOD+(i-B)*N)+C*(j+overlap)+c] = 2*x[j+N4+overlap];
235          for (j=0;j<overlap;j++)
236             mdct_overlap[C*j+c] = x[N+N4+j];
237       }
238    }
239    RESTORE_STACK;
240 }
241
242 int celt_encode(CELTEncoder *st, celt_int16_t *pcm, unsigned char *compressed, int nbCompressedBytes)
243 {
244    int i, c, N, B, C, N4;
245    int has_pitch;
246    int pitch_index;
247    celt_word32_t curr_power, pitch_power;
248    VARDECL(celt_sig_t *in);
249    VARDECL(celt_sig_t *freq);
250    VARDECL(celt_norm_t *X);
251    VARDECL(celt_norm_t *P);
252    VARDECL(celt_ener_t *bandE);
253    VARDECL(celt_pgain_t *gains);
254    SAVE_STACK;
255
256    if (check_mode(st->mode) != CELT_OK)
257       return CELT_INVALID_MODE;
258
259    N = st->block_size;
260    B = st->nb_blocks;
261    C = st->mode->nbChannels;
262    ALLOC(in, (B+1)*C*N, celt_sig_t);
263    ALLOC(freq, B*C*N, celt_sig_t); /**< Interleaved signal MDCTs */
264    ALLOC(bandE,st->mode->nbEBands*C, celt_ener_t);
265    ALLOC(gains,st->mode->nbPBands, celt_pgain_t);
266    
267    N4 = (N-st->overlap)/2;
268
269    for (c=0;c<C;c++)
270    {
271       for (i=0;i<N4;i++)
272          in[C*i+c] = 0;
273       for (i=0;i<st->overlap;i++)
274          in[C*(i+N4)+c] = st->in_mem[C*i+c];
275       for (i=0;i<B*N;i++)
276       {
277          celt_sig_t tmp = SHL32(EXTEND32(pcm[C*i+c]), SIG_SHIFT);
278          in[C*(i+st->overlap+N4)+c] = SUB32(tmp, MULT16_32_Q15(st->preemph,st->preemph_memE[c]));
279          st->preemph_memE[c] = tmp;
280       }
281       for (i=N*(B+1)-N4;i<N*(B+1);i++)
282          in[C*i+c] = 0;
283       for (i=0;i<st->overlap;i++)
284          st->in_mem[C*i+c] = in[C*(N*(B+1)-N4-st->overlap+i)+c];
285    }
286    /*for (i=0;i<(B+1)*C*N;i++) printf ("%f(%d) ", in[i], i); printf ("\n");*/
287    /* Compute MDCTs */
288    curr_power = compute_mdcts(&st->mdct_lookup, st->window, in, freq, N, B, C);
289
290 #if 0 /* Mask disabled until it can be made to do something useful */
291    compute_mdct_masking(X, mask, B*C*N, st->Fs);
292
293    /* Invert and stretch the mask to length of X 
294       For some reason, I get better results by using the sqrt instead,
295       although there's no valid reason to. Must investigate further */
296    for (i=0;i<B*C*N;i++)
297       mask[i] = 1/(.1+mask[i]);
298 #endif
299    /* Pitch analysis */
300    for (c=0;c<C;c++)
301    {
302       for (i=0;i<N;i++)
303       {
304          in[C*i+c] = MULT16_32_Q15(st->window[i], in[C*i+c]);
305          in[C*(B*N+i)+c] = MULT16_32_Q15(st->window[N+i], in[C*(B*N+i)+c]);
306       }
307    }
308    find_spectral_pitch(st->fft, &st->psy, in, st->out_mem, MAX_PERIOD, (B+1)*N, C, &pitch_index);
309    
310    /* Deferred allocation after find_spectral_pitch() to reduce the peak memory usage */
311    ALLOC(X, B*C*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
312    ALLOC(P, B*C*N, celt_norm_t);         /**< Interleaved normalised pitch MDCTs*/
313
314    /*printf ("%f %f\n", curr_power, pitch_power);*/
315    /*int j;
316    for (j=0;j<B*N;j++)
317       printf ("%f ", X[j]);
318    for (j=0;j<B*N;j++)
319       printf ("%f ", P[j]);
320    printf ("\n");*/
321
322    /* Band normalisation */
323    compute_band_energies(st->mode, freq, bandE);
324    normalise_bands(st->mode, freq, X, bandE);
325    /*for (i=0;i<st->mode->nbEBands;i++)printf("%f ", bandE[i]);printf("\n");*/
326    /*for (i=0;i<N*B*C;i++)printf("%f ", X[i]);printf("\n");*/
327
328    /* Compute MDCTs of the pitch part */
329    pitch_power = compute_mdcts(&st->mdct_lookup, st->window, st->out_mem+pitch_index*C, freq, N, B, C);
330    
331
332    quant_energy(st->mode, bandE, st->oldBandE, nbCompressedBytes*8/3, &st->enc);
333
334    if (C==2)
335    {
336       stereo_mix(st->mode, X, bandE, 1);
337    }
338
339    /* Check if we can safely use the pitch (i.e. effective gain isn't too high) */
340    if (curr_power + 1e5f*(1.f/SHL16(1,8)) < 10.f*pitch_power)
341    {
342       /* Normalise the pitch vector as well (discard the energies) */
343       VARDECL(celt_ener_t *bandEp);
344       ALLOC(bandEp, st->mode->nbEBands*st->mode->nbChannels, celt_ener_t);
345       compute_band_energies(st->mode, freq, bandEp);
346       normalise_bands(st->mode, freq, P, bandEp);
347
348       if (C==2)
349          stereo_mix(st->mode, P, bandE, 1);
350       /* Simulates intensity stereo */
351       /*for (i=30;i<N*B;i++)
352          X[i*C+1] = P[i*C+1] = 0;*/
353
354       /* Pitch prediction */
355       compute_pitch_gain(st->mode, X, P, gains);
356       has_pitch = quant_pitch(gains, st->mode->nbPBands, &st->enc);
357       if (has_pitch)
358          ec_enc_uint(&st->enc, pitch_index, MAX_PERIOD-(B+1)*N);
359    } else {
360       /* No pitch, so we just pretend we found a gain of zero */
361       for (i=0;i<st->mode->nbPBands;i++)
362          gains[i] = 0;
363       ec_enc_uint(&st->enc, 0, 128);
364       for (i=0;i<B*C*N;i++)
365          P[i] = 0;
366    }
367    
368
369    pitch_quant_bands(st->mode, P, gains);
370
371    /*for (i=0;i<B*N;i++) printf("%f ",P[i]);printf("\n");*/
372    /* Compute residual that we're going to encode */
373    for (i=0;i<B*C*N;i++)
374       X[i] -= P[i];
375
376    /* Residual quantisation */
377    quant_bands(st->mode, X, P, NULL, nbCompressedBytes*8, &st->enc);
378    
379    if (C==2)
380    {
381       stereo_mix(st->mode, X, bandE, -1);
382       renormalise_bands(st->mode, X);
383    }
384    /* Synthesis */
385    denormalise_bands(st->mode, X, freq, bandE);
386
387
388    CELT_MOVE(st->out_mem, st->out_mem+C*B*N, C*(MAX_PERIOD-B*N));
389
390    compute_inv_mdcts(&st->mdct_lookup, st->window, freq, st->out_mem, st->mdct_overlap, N, st->overlap, B, C);
391    /* De-emphasis and put everything back at the right place in the synthesis history */
392    for (c=0;c<C;c++)
393    {
394       for (i=0;i<B;i++)
395       {
396          int j;
397          for (j=0;j<N;j++)
398          {
399             celt_sig_t tmp = ADD32(st->out_mem[C*(MAX_PERIOD+(i-B)*N)+C*j+c],
400                                    MULT16_32_Q15(st->preemph,st->preemph_memD[c]));
401             st->preemph_memD[c] = tmp;
402             pcm[C*i*N+C*j+c] = SIG2INT16(tmp);
403          }
404       }
405    }
406    
407    if (ec_enc_tell(&st->enc, 0) < nbCompressedBytes*8 - 7)
408       celt_warning_int ("many unused bits: ", nbCompressedBytes*8-ec_enc_tell(&st->enc, 0));
409    /*printf ("%d\n", ec_enc_tell(&st->enc, 0)-8*nbCompressedBytes);*/
410    /* Finishing the stream with a 0101... pattern so that the decoder can check is everything's right */
411    {
412       int val = 0;
413       while (ec_enc_tell(&st->enc, 0) < nbCompressedBytes*8)
414       {
415          ec_enc_uint(&st->enc, val, 2);
416          val = 1-val;
417       }
418    }
419    ec_enc_done(&st->enc);
420    {
421       unsigned char *data;
422       int nbBytes = ec_byte_bytes(&st->buf);
423       if (nbBytes > nbCompressedBytes)
424       {
425          celt_warning_int ("got too many bytes:", nbBytes);
426          RESTORE_STACK;
427          return CELT_INTERNAL_ERROR;
428       }
429       /*printf ("%d\n", *nbBytes);*/
430       data = ec_byte_get_buffer(&st->buf);
431       for (i=0;i<nbBytes;i++)
432          compressed[i] = data[i];
433       for (;i<nbCompressedBytes;i++)
434          compressed[i] = 0;
435    }
436    /* Reset the packing for the next encoding */
437    ec_byte_reset(&st->buf);
438    ec_enc_init(&st->enc,&st->buf);
439
440    RESTORE_STACK;
441    return nbCompressedBytes;
442 }
443
444
445 /****************************************************************************/
446 /*                                                                          */
447 /*                                DECODER                                   */
448 /*                                                                          */
449 /****************************************************************************/
450
451
452 /** Decoder state 
453  @brief Decoder state
454  */
455 struct CELTDecoder {
456    const CELTMode *mode;
457    int frame_size;
458    int block_size;
459    int nb_blocks;
460    int overlap;
461
462    ec_byte_buffer buf;
463    ec_enc         enc;
464
465    celt_word16_t preemph;
466    celt_sig_t *preemph_memD;
467    
468    mdct_lookup mdct_lookup;
469    
470    celt_word16_t *window;
471    celt_sig_t *mdct_overlap;
472    celt_sig_t *out_mem;
473
474    celt_word16_t *oldBandE;
475    
476    int last_pitch_index;
477 };
478
479 CELTDecoder *celt_decoder_create(const CELTMode *mode)
480 {
481    int i, N, B, C, N4;
482    CELTDecoder *st;
483
484    if (check_mode(mode) != CELT_OK)
485       return NULL;
486
487    N = mode->mdctSize;
488    B = mode->nbMdctBlocks;
489    C = mode->nbChannels;
490    st = celt_alloc(sizeof(CELTDecoder));
491    
492    st->mode = mode;
493    st->frame_size = B*N;
494    st->block_size = N;
495    st->nb_blocks  = B;
496    st->overlap = mode->overlap;
497
498    N4 = (N-st->overlap)/2;
499    
500    mdct_init(&st->mdct_lookup, 2*N);
501    
502    st->window = (celt_word16_t*)celt_alloc(2*N*sizeof(celt_word16_t));
503    st->mdct_overlap = celt_alloc(N*C*sizeof(celt_sig_t));
504    st->out_mem = celt_alloc(MAX_PERIOD*C*sizeof(celt_sig_t));
505
506    for (i=0;i<2*N;i++)
507       st->window[i] = 0;
508    for (i=0;i<st->overlap;i++)
509       st->window[N4+i] = st->window[2*N-N4-i-1] 
510             = Q15ONE*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/st->overlap) * sin(.5*M_PI*(i+.5)/st->overlap));
511    for (i=0;i<2*N4;i++)
512       st->window[N-N4+i] = Q15ONE;
513    
514    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
515
516    st->preemph = QCONST16(0.8f,15);
517    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));;
518
519    st->last_pitch_index = 0;
520    return st;
521 }
522
523 void celt_decoder_destroy(CELTDecoder *st)
524 {
525    if (st == NULL)
526    {
527       celt_warning("NULL passed to celt_encoder_destroy");
528       return;
529    }
530    if (check_mode(st->mode) != CELT_OK)
531       return;
532
533    mdct_clear(&st->mdct_lookup);
534
535    celt_free(st->window);
536    celt_free(st->mdct_overlap);
537    celt_free(st->out_mem);
538    
539    celt_free(st->oldBandE);
540    
541    celt_free(st->preemph_memD);
542
543    celt_free(st);
544 }
545
546 /** Handles lost packets by just copying past data with the same offset as the last
547     pitch period */
548 static void celt_decode_lost(CELTDecoder *st, short *pcm)
549 {
550    int i, c, N, B, C;
551    int pitch_index;
552    VARDECL(celt_sig_t *freq);
553    SAVE_STACK;
554    N = st->block_size;
555    B = st->nb_blocks;
556    C = st->mode->nbChannels;
557    ALLOC(freq,C*B*N, celt_sig_t);         /**< Interleaved signal MDCTs */
558    
559    pitch_index = st->last_pitch_index;
560    
561    /* Use the pitch MDCT as the "guessed" signal */
562    compute_mdcts(&st->mdct_lookup, st->window, st->out_mem+pitch_index*C, freq, N, B, C);
563
564    CELT_MOVE(st->out_mem, st->out_mem+C*B*N, C*(MAX_PERIOD-B*N));
565    /* Compute inverse MDCTs */
566    compute_inv_mdcts(&st->mdct_lookup, st->window, freq, st->out_mem, st->mdct_overlap, N, st->overlap, B, C);
567
568    for (c=0;c<C;c++)
569    {
570       for (i=0;i<B;i++)
571       {
572          int j;
573          for (j=0;j<N;j++)
574          {
575             celt_sig_t tmp = ADD32(st->out_mem[C*(MAX_PERIOD+(i-B)*N)+C*j+c],
576                                    MULT16_32_Q15(st->preemph,st->preemph_memD[c]));
577             st->preemph_memD[c] = tmp;
578             pcm[C*i*N+C*j+c] = SIG2INT16(tmp);
579          }
580       }
581    }
582    RESTORE_STACK;
583 }
584
585 int celt_decode(CELTDecoder *st, unsigned char *data, int len, celt_int16_t *pcm)
586 {
587    int i, c, N, B, C;
588    int has_pitch;
589    int pitch_index;
590    ec_dec dec;
591    ec_byte_buffer buf;
592    VARDECL(celt_sig_t *freq);
593    VARDECL(celt_norm_t *X);
594    VARDECL(celt_norm_t *P);
595    VARDECL(celt_ener_t *bandE);
596    VARDECL(celt_pgain_t *gains);
597    SAVE_STACK;
598
599    if (check_mode(st->mode) != CELT_OK)
600       return CELT_INVALID_MODE;
601
602    N = st->block_size;
603    B = st->nb_blocks;
604    C = st->mode->nbChannels;
605    
606    ALLOC(freq, C*B*N, celt_sig_t); /**< Interleaved signal MDCTs */
607    ALLOC(X, C*B*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
608    ALLOC(P, C*B*N, celt_norm_t);         /**< Interleaved normalised pitch MDCTs*/
609    ALLOC(bandE, st->mode->nbEBands*C, celt_ener_t);
610    ALLOC(gains, st->mode->nbPBands, celt_pgain_t);
611    
612    if (check_mode(st->mode) != CELT_OK)
613    {
614       RESTORE_STACK;
615       return CELT_INVALID_MODE;
616    }
617    if (data == NULL)
618    {
619       celt_decode_lost(st, pcm);
620       RESTORE_STACK;
621       return 0;
622    }
623    
624    ec_byte_readinit(&buf,data,len);
625    ec_dec_init(&dec,&buf);
626    
627    /* Get band energies */
628    unquant_energy(st->mode, bandE, st->oldBandE, len*8/3, &dec);
629    
630    /* Get the pitch gains */
631    has_pitch = unquant_pitch(gains, st->mode->nbPBands, &dec);
632    
633    /* Get the pitch index */
634    if (has_pitch)
635    {
636       pitch_index = ec_dec_uint(&dec, MAX_PERIOD-(B+1)*N);
637       st->last_pitch_index = pitch_index;
638    } else {
639       /* FIXME: We could be more intelligent here and just not compute the MDCT */
640       pitch_index = 0;
641    }
642    
643    /* Pitch MDCT */
644    compute_mdcts(&st->mdct_lookup, st->window, st->out_mem+pitch_index*C, freq, N, B, C);
645
646    {
647       VARDECL(celt_ener_t *bandEp);
648       ALLOC(bandEp, st->mode->nbEBands*C, celt_ener_t);
649       compute_band_energies(st->mode, freq, bandEp);
650       normalise_bands(st->mode, freq, P, bandEp);
651    }
652
653    if (C==2)
654       stereo_mix(st->mode, P, bandE, 1);
655
656    /* Apply pitch gains */
657    pitch_quant_bands(st->mode, P, gains);
658
659    /* Decode fixed codebook and merge with pitch */
660    unquant_bands(st->mode, X, P, len*8, &dec);
661
662    if (C==2)
663    {
664       stereo_mix(st->mode, X, bandE, -1);
665       renormalise_bands(st->mode, X);
666    }
667    /* Synthesis */
668    denormalise_bands(st->mode, X, freq, bandE);
669
670
671    CELT_MOVE(st->out_mem, st->out_mem+C*B*N, C*(MAX_PERIOD-B*N));
672    /* Compute inverse MDCTs */
673    compute_inv_mdcts(&st->mdct_lookup, st->window, freq, st->out_mem, st->mdct_overlap, N, st->overlap, B, C);
674
675    for (c=0;c<C;c++)
676    {
677       for (i=0;i<B;i++)
678       {
679          int j;
680          for (j=0;j<N;j++)
681          {
682             celt_sig_t tmp = ADD32(st->out_mem[C*(MAX_PERIOD+(i-B)*N)+C*j+c],
683                                    MULT16_32_Q15(st->preemph,st->preemph_memD[c]));
684             st->preemph_memD[c] = tmp;
685             pcm[C*i*N+C*j+c] = SIG2INT16(tmp);
686          }
687       }
688    }
689
690    {
691       unsigned int val = 0;
692       while (ec_dec_tell(&dec, 0) < len*8)
693       {
694          if (ec_dec_uint(&dec, 2) != val)
695          {
696             celt_warning("decode error");
697             RESTORE_STACK;
698             return CELT_CORRUPTED_DATA;
699          }
700          val = 1-val;
701       }
702    }
703
704    RESTORE_STACK;
705    return 0;
706    /*printf ("\n");*/
707 }
708