compute_band_energies() merged with normalised_bands()
[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, N4;
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    N4 = (N-st->overlap)/2;
523    ALLOC(freq,C*B*N, celt_sig_t);         /**< Interleaved signal MDCTs */
524    
525    pitch_index = st->last_pitch_index;
526    
527    /* Use the pitch MDCT as the "guessed" signal */
528    compute_mdcts(&st->mode->mdct, st->mode->window, st->out_mem+pitch_index*C, freq, N, st->overlap, B, C);
529
530    CELT_MOVE(st->out_mem, st->out_mem+C*B*N, C*(MAX_PERIOD-B*N));
531    /* Compute inverse MDCTs */
532    compute_inv_mdcts(&st->mode->mdct, st->mode->window, freq, st->out_mem, st->mdct_overlap, N, st->overlap, B, C);
533
534    for (c=0;c<C;c++)
535    {
536       for (i=0;i<B;i++)
537       {
538          int j;
539          for (j=0;j<N;j++)
540          {
541             celt_sig_t tmp = ADD32(st->out_mem[C*(MAX_PERIOD+(i-B)*N)+C*j+c],
542                                    MULT16_32_Q15(preemph,st->preemph_memD[c]));
543             st->preemph_memD[c] = tmp;
544             pcm[C*i*N+C*j+c] = SIG2INT16(tmp);
545          }
546       }
547    }
548    RESTORE_STACK;
549 }
550
551 int celt_decode(CELTDecoder *st, unsigned char *data, int len, celt_int16_t *pcm)
552 {
553    int i, c, N, B, C, N4;
554    int has_pitch;
555    int pitch_index;
556    ec_dec dec;
557    ec_byte_buffer buf;
558    VARDECL(celt_sig_t *freq);
559    VARDECL(celt_norm_t *X);
560    VARDECL(celt_norm_t *P);
561    VARDECL(celt_ener_t *bandE);
562    VARDECL(celt_pgain_t *gains);
563    SAVE_STACK;
564
565    if (check_mode(st->mode) != CELT_OK)
566       return CELT_INVALID_MODE;
567
568    N = st->block_size;
569    B = st->nb_blocks;
570    C = st->mode->nbChannels;
571    N4 = (N-st->overlap)/2;
572
573    ALLOC(freq, C*B*N, celt_sig_t); /**< Interleaved signal MDCTs */
574    ALLOC(X, C*B*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
575    ALLOC(P, C*B*N, celt_norm_t);         /**< Interleaved normalised pitch MDCTs*/
576    ALLOC(bandE, st->mode->nbEBands*C, celt_ener_t);
577    ALLOC(gains, st->mode->nbPBands, celt_pgain_t);
578    
579    if (check_mode(st->mode) != CELT_OK)
580    {
581       RESTORE_STACK;
582       return CELT_INVALID_MODE;
583    }
584    if (data == NULL)
585    {
586       celt_decode_lost(st, pcm);
587       RESTORE_STACK;
588       return 0;
589    }
590    
591    ec_byte_readinit(&buf,data,len);
592    ec_dec_init(&dec,&buf);
593    
594    /* Get band energies */
595    unquant_energy(st->mode, bandE, st->oldBandE, len*8/3, &dec);
596    
597    /* Get the pitch gains */
598    has_pitch = unquant_pitch(gains, st->mode->nbPBands, &dec);
599    
600    /* Get the pitch index */
601    if (has_pitch)
602    {
603       pitch_index = ec_dec_uint(&dec, MAX_PERIOD-((B+1)*N-2*N4));
604       st->last_pitch_index = pitch_index;
605    } else {
606       /* FIXME: We could be more intelligent here and just not compute the MDCT */
607       pitch_index = 0;
608    }
609    
610    /* Pitch MDCT */
611    compute_mdcts(&st->mode->mdct, st->mode->window, st->out_mem+pitch_index*C, freq, N, st->overlap, B, C);
612
613    {
614       VARDECL(celt_ener_t *bandEp);
615       ALLOC(bandEp, st->mode->nbEBands*C, celt_ener_t);
616       normalise_bands(st->mode, freq, P, bandEp);
617    }
618
619    if (C==2)
620       stereo_mix(st->mode, P, bandE, 1);
621
622    /* Apply pitch gains */
623    pitch_quant_bands(st->mode, P, gains);
624
625    /* Decode fixed codebook and merge with pitch */
626    unquant_bands(st->mode, X, P, len*8, &dec);
627
628    if (C==2)
629    {
630       stereo_mix(st->mode, X, bandE, -1);
631       renormalise_bands(st->mode, X);
632    }
633    /* Synthesis */
634    denormalise_bands(st->mode, X, freq, bandE);
635
636
637    CELT_MOVE(st->out_mem, st->out_mem+C*B*N, C*(MAX_PERIOD-B*N));
638    /* Compute inverse MDCTs */
639    compute_inv_mdcts(&st->mode->mdct, st->mode->window, freq, st->out_mem, st->mdct_overlap, N, st->overlap, B, C);
640
641    for (c=0;c<C;c++)
642    {
643       for (i=0;i<B;i++)
644       {
645          int j;
646          for (j=0;j<N;j++)
647          {
648             celt_sig_t tmp = ADD32(st->out_mem[C*(MAX_PERIOD+(i-B)*N)+C*j+c],
649                                    MULT16_32_Q15(preemph,st->preemph_memD[c]));
650             st->preemph_memD[c] = tmp;
651             pcm[C*i*N+C*j+c] = SIG2INT16(tmp);
652          }
653       }
654    }
655
656    {
657       unsigned int val = 0;
658       while (ec_dec_tell(&dec, 0) < len*8)
659       {
660          if (ec_dec_uint(&dec, 2) != val)
661          {
662             celt_warning("decode error");
663             RESTORE_STACK;
664             return CELT_CORRUPTED_DATA;
665          }
666          val = 1-val;
667       }
668    }
669
670    RESTORE_STACK;
671    return 0;
672    /*printf ("\n");*/
673 }
674