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