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