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