Initial support for a managed stack/scratchpad. Still needs some work.
[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(X, B*C*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
265    ALLOC(P, B*C*N, celt_norm_t);         /**< Interleaved normalised pitch MDCTs*/
266    ALLOC(bandE,st->mode->nbEBands*C, celt_ener_t);
267    ALLOC(gains,st->mode->nbPBands, celt_pgain_t);
268    
269    N4 = (N-st->overlap)/2;
270
271    for (c=0;c<C;c++)
272    {
273       for (i=0;i<N4;i++)
274          in[C*i+c] = 0;
275       for (i=0;i<st->overlap;i++)
276          in[C*(i+N4)+c] = st->in_mem[C*i+c];
277       for (i=0;i<B*N;i++)
278       {
279          celt_sig_t tmp = SHL32(EXTEND32(pcm[C*i+c]), SIG_SHIFT);
280          in[C*(i+st->overlap+N4)+c] = SUB32(tmp, MULT16_32_Q15(st->preemph,st->preemph_memE[c]));
281          st->preemph_memE[c] = tmp;
282       }
283       for (i=N*(B+1)-N4;i<N*(B+1);i++)
284          in[C*i+c] = 0;
285       for (i=0;i<st->overlap;i++)
286          st->in_mem[C*i+c] = in[C*(N*(B+1)-N4-st->overlap+i)+c];
287    }
288    /*for (i=0;i<(B+1)*C*N;i++) printf ("%f(%d) ", in[i], i); printf ("\n");*/
289    /* Compute MDCTs */
290    curr_power = compute_mdcts(&st->mdct_lookup, st->window, in, freq, N, B, C);
291
292 #if 0 /* Mask disabled until it can be made to do something useful */
293    compute_mdct_masking(X, mask, B*C*N, st->Fs);
294
295    /* Invert and stretch the mask to length of X 
296       For some reason, I get better results by using the sqrt instead,
297       although there's no valid reason to. Must investigate further */
298    for (i=0;i<B*C*N;i++)
299       mask[i] = 1/(.1+mask[i]);
300 #endif
301    /* Pitch analysis */
302    for (c=0;c<C;c++)
303    {
304       for (i=0;i<N;i++)
305       {
306          in[C*i+c] = MULT16_32_Q15(st->window[i], in[C*i+c]);
307          in[C*(B*N+i)+c] = MULT16_32_Q15(st->window[N+i], in[C*(B*N+i)+c]);
308       }
309    }
310    find_spectral_pitch(st->fft, &st->psy, in, st->out_mem, MAX_PERIOD, (B+1)*N, C, &pitch_index);
311    
312    /*printf ("%f %f\n", curr_power, pitch_power);*/
313    /*int j;
314    for (j=0;j<B*N;j++)
315       printf ("%f ", X[j]);
316    for (j=0;j<B*N;j++)
317       printf ("%f ", P[j]);
318    printf ("\n");*/
319
320    /* Band normalisation */
321    compute_band_energies(st->mode, freq, bandE);
322    normalise_bands(st->mode, freq, X, bandE);
323    /*for (i=0;i<st->mode->nbEBands;i++)printf("%f ", bandE[i]);printf("\n");*/
324    /*for (i=0;i<N*B*C;i++)printf("%f ", X[i]);printf("\n");*/
325
326    /* Compute MDCTs of the pitch part */
327    pitch_power = compute_mdcts(&st->mdct_lookup, st->window, st->out_mem+pitch_index*C, freq, N, B, C);
328    
329
330    quant_energy(st->mode, bandE, st->oldBandE, nbCompressedBytes*8/3, &st->enc);
331
332    if (C==2)
333    {
334       stereo_mix(st->mode, X, bandE, 1);
335    }
336
337    /* Check if we can safely use the pitch (i.e. effective gain isn't too high) */
338    if (curr_power + 1e5f*(1.f/SHL16(1,8)) < 10.f*pitch_power)
339    {
340       /* Normalise the pitch vector as well (discard the energies) */
341       VARDECL(celt_ener_t *bandEp);
342       ALLOC(bandEp, st->mode->nbEBands*st->mode->nbChannels, celt_ener_t);
343       compute_band_energies(st->mode, freq, bandEp);
344       normalise_bands(st->mode, freq, P, bandEp);
345
346       if (C==2)
347          stereo_mix(st->mode, P, bandE, 1);
348       /* Simulates intensity stereo */
349       /*for (i=30;i<N*B;i++)
350          X[i*C+1] = P[i*C+1] = 0;*/
351
352       /* Pitch prediction */
353       compute_pitch_gain(st->mode, X, P, gains);
354       has_pitch = quant_pitch(gains, st->mode->nbPBands, &st->enc);
355       if (has_pitch)
356          ec_enc_uint(&st->enc, pitch_index, MAX_PERIOD-(B+1)*N);
357    } else {
358       /* No pitch, so we just pretend we found a gain of zero */
359       for (i=0;i<st->mode->nbPBands;i++)
360          gains[i] = 0;
361       ec_enc_uint(&st->enc, 0, 128);
362       for (i=0;i<B*C*N;i++)
363          P[i] = 0;
364    }
365    
366
367    pitch_quant_bands(st->mode, P, gains);
368
369    /*for (i=0;i<B*N;i++) printf("%f ",P[i]);printf("\n");*/
370    /* Compute residual that we're going to encode */
371    for (i=0;i<B*C*N;i++)
372       X[i] -= P[i];
373
374    /* Residual quantisation */
375    quant_bands(st->mode, X, P, NULL, nbCompressedBytes*8, &st->enc);
376    
377    if (C==2)
378    {
379       stereo_mix(st->mode, X, bandE, -1);
380       renormalise_bands(st->mode, X);
381    }
382    /* Synthesis */
383    denormalise_bands(st->mode, X, freq, bandE);
384
385
386    CELT_MOVE(st->out_mem, st->out_mem+C*B*N, C*(MAX_PERIOD-B*N));
387
388    compute_inv_mdcts(&st->mdct_lookup, st->window, freq, st->out_mem, st->mdct_overlap, N, st->overlap, B, C);
389    /* De-emphasis and put everything back at the right place in the synthesis history */
390    for (c=0;c<C;c++)
391    {
392       for (i=0;i<B;i++)
393       {
394          int j;
395          for (j=0;j<N;j++)
396          {
397             celt_sig_t tmp = ADD32(st->out_mem[C*(MAX_PERIOD+(i-B)*N)+C*j+c],
398                                    MULT16_32_Q15(st->preemph,st->preemph_memD[c]));
399             st->preemph_memD[c] = tmp;
400             pcm[C*i*N+C*j+c] = SIG2INT16(tmp);
401          }
402       }
403    }
404    
405    if (ec_enc_tell(&st->enc, 0) < nbCompressedBytes*8 - 7)
406       celt_warning_int ("many unused bits: ", nbCompressedBytes*8-ec_enc_tell(&st->enc, 0));
407    /*printf ("%d\n", ec_enc_tell(&st->enc, 0)-8*nbCompressedBytes);*/
408    /* Finishing the stream with a 0101... pattern so that the decoder can check is everything's right */
409    {
410       int val = 0;
411       while (ec_enc_tell(&st->enc, 0) < nbCompressedBytes*8)
412       {
413          ec_enc_uint(&st->enc, val, 2);
414          val = 1-val;
415       }
416    }
417    ec_enc_done(&st->enc);
418    {
419       unsigned char *data;
420       int nbBytes = ec_byte_bytes(&st->buf);
421       if (nbBytes > nbCompressedBytes)
422       {
423          celt_warning_int ("got too many bytes:", nbBytes);
424          RESTORE_STACK;
425          return CELT_INTERNAL_ERROR;
426       }
427       /*printf ("%d\n", *nbBytes);*/
428       data = ec_byte_get_buffer(&st->buf);
429       for (i=0;i<nbBytes;i++)
430          compressed[i] = data[i];
431       for (;i<nbCompressedBytes;i++)
432          compressed[i] = 0;
433    }
434    /* Reset the packing for the next encoding */
435    ec_byte_reset(&st->buf);
436    ec_enc_init(&st->enc,&st->buf);
437
438    RESTORE_STACK;
439    return nbCompressedBytes;
440 }
441
442
443 /****************************************************************************/
444 /*                                                                          */
445 /*                                DECODER                                   */
446 /*                                                                          */
447 /****************************************************************************/
448
449
450 /** Decoder state 
451  @brief Decoder state
452  */
453 struct CELTDecoder {
454    const CELTMode *mode;
455    int frame_size;
456    int block_size;
457    int nb_blocks;
458    int overlap;
459
460    ec_byte_buffer buf;
461    ec_enc         enc;
462
463    celt_word16_t preemph;
464    celt_sig_t *preemph_memD;
465    
466    mdct_lookup mdct_lookup;
467    
468    celt_word16_t *window;
469    celt_sig_t *mdct_overlap;
470    celt_sig_t *out_mem;
471
472    celt_word16_t *oldBandE;
473    
474    int last_pitch_index;
475 };
476
477 CELTDecoder *celt_decoder_create(const CELTMode *mode)
478 {
479    int i, N, B, C, N4;
480    CELTDecoder *st;
481
482    if (check_mode(mode) != CELT_OK)
483       return NULL;
484
485    N = mode->mdctSize;
486    B = mode->nbMdctBlocks;
487    C = mode->nbChannels;
488    st = celt_alloc(sizeof(CELTDecoder));
489    
490    st->mode = mode;
491    st->frame_size = B*N;
492    st->block_size = N;
493    st->nb_blocks  = B;
494    st->overlap = mode->overlap;
495
496    N4 = (N-st->overlap)/2;
497    
498    mdct_init(&st->mdct_lookup, 2*N);
499    
500    st->window = (celt_word16_t*)celt_alloc(2*N*sizeof(celt_word16_t));
501    st->mdct_overlap = celt_alloc(N*C*sizeof(celt_sig_t));
502    st->out_mem = celt_alloc(MAX_PERIOD*C*sizeof(celt_sig_t));
503
504    for (i=0;i<2*N;i++)
505       st->window[i] = 0;
506    for (i=0;i<st->overlap;i++)
507       st->window[N4+i] = st->window[2*N-N4-i-1] 
508             = Q15ONE*sin(.5*M_PI* sin(.5*M_PI*(i+.5)/st->overlap) * sin(.5*M_PI*(i+.5)/st->overlap));
509    for (i=0;i<2*N4;i++)
510       st->window[N-N4+i] = Q15ONE;
511    
512    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
513
514    st->preemph = QCONST16(0.8f,15);
515    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));;
516
517    st->last_pitch_index = 0;
518    return st;
519 }
520
521 void celt_decoder_destroy(CELTDecoder *st)
522 {
523    if (st == NULL)
524    {
525       celt_warning("NULL passed to celt_encoder_destroy");
526       return;
527    }
528    if (check_mode(st->mode) != CELT_OK)
529       return;
530
531    mdct_clear(&st->mdct_lookup);
532
533    celt_free(st->window);
534    celt_free(st->mdct_overlap);
535    celt_free(st->out_mem);
536    
537    celt_free(st->oldBandE);
538    
539    celt_free(st->preemph_memD);
540
541    celt_free(st);
542 }
543
544 /** Handles lost packets by just copying past data with the same offset as the last
545     pitch period */
546 static void celt_decode_lost(CELTDecoder *st, short *pcm)
547 {
548    int i, c, N, B, C;
549    int pitch_index;
550    VARDECL(celt_sig_t *freq);
551    SAVE_STACK;
552    N = st->block_size;
553    B = st->nb_blocks;
554    C = st->mode->nbChannels;
555    ALLOC(freq,C*B*N, celt_sig_t);         /**< Interleaved signal MDCTs */
556    
557    pitch_index = st->last_pitch_index;
558    
559    /* Use the pitch MDCT as the "guessed" signal */
560    compute_mdcts(&st->mdct_lookup, st->window, st->out_mem+pitch_index*C, freq, N, B, C);
561
562    CELT_MOVE(st->out_mem, st->out_mem+C*B*N, C*(MAX_PERIOD-B*N));
563    /* Compute inverse MDCTs */
564    compute_inv_mdcts(&st->mdct_lookup, st->window, freq, st->out_mem, st->mdct_overlap, N, st->overlap, B, C);
565
566    for (c=0;c<C;c++)
567    {
568       for (i=0;i<B;i++)
569       {
570          int j;
571          for (j=0;j<N;j++)
572          {
573             celt_sig_t tmp = ADD32(st->out_mem[C*(MAX_PERIOD+(i-B)*N)+C*j+c],
574                                    MULT16_32_Q15(st->preemph,st->preemph_memD[c]));
575             st->preemph_memD[c] = tmp;
576             pcm[C*i*N+C*j+c] = SIG2INT16(tmp);
577          }
578       }
579    }
580    RESTORE_STACK;
581 }
582
583 int celt_decode(CELTDecoder *st, unsigned char *data, int len, celt_int16_t *pcm)
584 {
585    int i, c, N, B, C;
586    int has_pitch;
587    int pitch_index;
588    ec_dec dec;
589    ec_byte_buffer buf;
590    VARDECL(celt_sig_t *freq);
591    VARDECL(celt_norm_t *X);
592    VARDECL(celt_norm_t *P);
593    VARDECL(celt_ener_t *bandE);
594    VARDECL(celt_pgain_t *gains);
595    SAVE_STACK;
596
597    if (check_mode(st->mode) != CELT_OK)
598       return CELT_INVALID_MODE;
599
600    N = st->block_size;
601    B = st->nb_blocks;
602    C = st->mode->nbChannels;
603    
604    ALLOC(freq, C*B*N, celt_sig_t); /**< Interleaved signal MDCTs */
605    ALLOC(X, C*B*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
606    ALLOC(P, C*B*N, celt_norm_t);         /**< Interleaved normalised pitch MDCTs*/
607    ALLOC(bandE, st->mode->nbEBands*C, celt_ener_t);
608    ALLOC(gains, st->mode->nbPBands, celt_pgain_t);
609    
610    if (check_mode(st->mode) != CELT_OK)
611    {
612       RESTORE_STACK;
613       return CELT_INVALID_MODE;
614    }
615    if (data == NULL)
616    {
617       celt_decode_lost(st, pcm);
618       RESTORE_STACK;
619       return 0;
620    }
621    
622    ec_byte_readinit(&buf,data,len);
623    ec_dec_init(&dec,&buf);
624    
625    /* Get band energies */
626    unquant_energy(st->mode, bandE, st->oldBandE, len*8/3, &dec);
627    
628    /* Get the pitch gains */
629    has_pitch = unquant_pitch(gains, st->mode->nbPBands, &dec);
630    
631    /* Get the pitch index */
632    if (has_pitch)
633    {
634       pitch_index = ec_dec_uint(&dec, MAX_PERIOD-(B+1)*N);
635       st->last_pitch_index = pitch_index;
636    } else {
637       /* FIXME: We could be more intelligent here and just not compute the MDCT */
638       pitch_index = 0;
639    }
640    
641    /* Pitch MDCT */
642    compute_mdcts(&st->mdct_lookup, st->window, st->out_mem+pitch_index*C, freq, N, B, C);
643
644    {
645       VARDECL(celt_ener_t *bandEp);
646       ALLOC(bandEp, st->mode->nbEBands*C, celt_ener_t);
647       compute_band_energies(st->mode, freq, bandEp);
648       normalise_bands(st->mode, freq, P, bandEp);
649    }
650
651    if (C==2)
652       stereo_mix(st->mode, P, bandE, 1);
653
654    /* Apply pitch gains */
655    pitch_quant_bands(st->mode, P, gains);
656
657    /* Decode fixed codebook and merge with pitch */
658    unquant_bands(st->mode, X, P, len*8, &dec);
659
660    if (C==2)
661    {
662       stereo_mix(st->mode, X, bandE, -1);
663       renormalise_bands(st->mode, X);
664    }
665    /* Synthesis */
666    denormalise_bands(st->mode, X, freq, bandE);
667
668
669    CELT_MOVE(st->out_mem, st->out_mem+C*B*N, C*(MAX_PERIOD-B*N));
670    /* Compute inverse MDCTs */
671    compute_inv_mdcts(&st->mdct_lookup, st->window, freq, st->out_mem, st->mdct_overlap, N, st->overlap, B, C);
672
673    for (c=0;c<C;c++)
674    {
675       for (i=0;i<B;i++)
676       {
677          int j;
678          for (j=0;j<N;j++)
679          {
680             celt_sig_t tmp = ADD32(st->out_mem[C*(MAX_PERIOD+(i-B)*N)+C*j+c],
681                                    MULT16_32_Q15(st->preemph,st->preemph_memD[c]));
682             st->preemph_memD[c] = tmp;
683             pcm[C*i*N+C*j+c] = SIG2INT16(tmp);
684          }
685       }
686    }
687
688    {
689       unsigned int val = 0;
690       while (ec_dec_tell(&dec, 0) < len*8)
691       {
692          if (ec_dec_uint(&dec, 2) != val)
693          {
694             celt_warning("decode error");
695             RESTORE_STACK;
696             return CELT_CORRUPTED_DATA;
697          }
698          val = 1-val;
699       }
700    }
701
702    RESTORE_STACK;
703    return 0;
704    /*printf ("\n");*/
705 }
706