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