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