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