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