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