Implemented rate-dependant allocation for the fine energy quantisation.
[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    const int C = CHANNELS(st->mode);
227    SAVE_STACK;
228
229    if (check_mode(st->mode) != CELT_OK)
230       return CELT_INVALID_MODE;
231
232    N = st->block_size;
233    N4 = (N-st->overlap)>>1;
234    ALLOC(in, 2*C*N-2*C*N4, celt_sig_t);
235
236    CELT_COPY(in, st->in_mem, C*st->overlap);
237    for (c=0;c<C;c++)
238    {
239       const celt_int16_t * restrict pcmp = pcm+c;
240       celt_sig_t * restrict inp = in+C*st->overlap+c;
241       for (i=0;i<N;i++)
242       {
243          /* Apply pre-emphasis */
244          celt_sig_t tmp = SHL32(EXTEND32(*pcmp), SIG_SHIFT);
245          *inp = SUB32(tmp, SHR32(MULT16_16(preemph,st->preemph_memE[c]),1));
246          st->preemph_memE[c] = *pcmp;
247          inp += C;
248          pcmp += C;
249       }
250    }
251    CELT_COPY(st->in_mem, in+C*(2*N-2*N4-st->overlap), C*st->overlap);
252
253    /* Pitch analysis: we do it early to save on the peak stack space */
254    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);
255
256    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
257    
258    /*for (i=0;i<(B+1)*C*N;i++) printf ("%f(%d) ", in[i], i); printf ("\n");*/
259    /* Compute MDCTs */
260    compute_mdcts(st->mode, st->mode->window, in, freq);
261
262 #if 0 /* Mask disabled until it can be made to do something useful */
263    compute_mdct_masking(X, mask, B*C*N, st->Fs);
264
265    /* Invert and stretch the mask to length of X 
266       For some reason, I get better results by using the sqrt instead,
267       although there's no valid reason to. Must investigate further */
268    for (i=0;i<B*C*N;i++)
269       mask[i] = 1/(.1+mask[i]);
270 #endif
271    
272    /* Deferred allocation after find_spectral_pitch() to reduce the peak memory usage */
273    ALLOC(X, C*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
274    ALLOC(P, C*N, celt_norm_t);         /**< Interleaved normalised pitch MDCTs*/
275    ALLOC(bandE,st->mode->nbEBands*C, celt_ener_t);
276    ALLOC(gains,st->mode->nbPBands, celt_pgain_t);
277
278    /*printf ("%f %f\n", curr_power, pitch_power);*/
279    /*int j;
280    for (j=0;j<B*N;j++)
281       printf ("%f ", X[j]);
282    for (j=0;j<B*N;j++)
283       printf ("%f ", P[j]);
284    printf ("\n");*/
285
286    /* Band normalisation */
287    compute_band_energies(st->mode, freq, bandE);
288    normalise_bands(st->mode, freq, X, bandE);
289    /*for (i=0;i<st->mode->nbEBands;i++)printf("%f ", bandE[i]);printf("\n");*/
290    /*for (i=0;i<N*B*C;i++)printf("%f ", X[i]);printf("\n");*/
291
292    /* Compute MDCTs of the pitch part */
293    compute_mdcts(st->mode, st->mode->window, st->out_mem+pitch_index*C, freq);
294
295    {
296       /* Normalise the pitch vector as well (discard the energies) */
297       VARDECL(celt_ener_t, bandEp);
298       ALLOC(bandEp, st->mode->nbEBands*st->mode->nbChannels, celt_ener_t);
299       compute_band_energies(st->mode, freq, bandEp);
300       normalise_bands(st->mode, freq, P, bandEp);
301       pitch_power = bandEp[0]+bandEp[1]+bandEp[2];
302    }
303    curr_power = bandE[0]+bandE[1]+bandE[2];
304    /* Check if we can safely use the pitch (i.e. effective gain isn't too high) */
305    if (MULT16_32_Q15(QCONST16(.1f, 15),curr_power) + QCONST32(10.f,ENER_SHIFT) < pitch_power)
306    {
307       /* Simulates intensity stereo */
308       /*for (i=30;i<N*B;i++)
309          X[i*C+1] = P[i*C+1] = 0;*/
310
311       /* Pitch prediction */
312       compute_pitch_gain(st->mode, X, P, gains);
313       has_pitch = quant_pitch(gains, st->mode->nbPBands, &st->enc);
314       if (has_pitch)
315          ec_enc_uint(&st->enc, pitch_index, MAX_PERIOD-(2*N-2*N4));
316    } else {
317       /* No pitch, so we just pretend we found a gain of zero */
318       for (i=0;i<st->mode->nbPBands;i++)
319          gains[i] = 0;
320       ec_enc_bits(&st->enc, 0, 7);
321       for (i=0;i<C*N;i++)
322          P[i] = 0;
323    }
324    quant_energy(st->mode, bandE, st->oldBandE, 20+nbCompressedBytes*8/5, st->mode->prob, &st->enc);
325
326    if (C==2)
327    {
328       stereo_mix(st->mode, X, bandE, 1);
329       stereo_mix(st->mode, P, bandE, 1);
330    }
331
332    pitch_quant_bands(st->mode, P, gains);
333
334    /*for (i=0;i<B*N;i++) printf("%f ",P[i]);printf("\n");*/
335    /* Compute residual that we're going to encode */
336    for (i=0;i<C*st->mode->eBands[st->mode->nbEBands];i++)
337       X[i] -= P[i];
338
339    /* Residual quantisation */
340    quant_bands(st->mode, X, P, NULL, nbCompressedBytes*8, &st->enc);
341    
342    if (C==2)
343    {
344       stereo_mix(st->mode, X, bandE, -1);
345       renormalise_bands(st->mode, X);
346    }
347    /* Synthesis */
348    denormalise_bands(st->mode, X, freq, bandE);
349
350
351    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->overlap-N));
352
353    compute_inv_mdcts(st->mode, st->mode->window, freq, st->out_mem);
354    /* De-emphasis and put everything back at the right place in the synthesis history */
355 #ifndef SHORTCUTS
356    for (c=0;c<C;c++)
357    {
358       int j;
359       const celt_sig_t * restrict outp=st->out_mem+C*(MAX_PERIOD-N)+c;
360       celt_int16_t * restrict pcmp = pcm+c;
361       for (j=0;j<N;j++)
362       {
363          celt_sig_t tmp = ADD32(*outp, MULT16_32_Q15(preemph,st->preemph_memD[c]));
364          st->preemph_memD[c] = tmp;
365          *pcmp = SIG2INT16(tmp);
366          pcmp += C;
367          outp += C;
368       }
369    }
370 #endif
371    if (ec_enc_tell(&st->enc, 0) < nbCompressedBytes*8 - 7)
372       celt_warning_int ("many unused bits: ", nbCompressedBytes*8-ec_enc_tell(&st->enc, 0));
373    /*printf ("%d\n", ec_enc_tell(&st->enc, 0)-8*nbCompressedBytes);*/
374    /* Finishing the stream with a 0101... pattern so that the decoder can check is everything's right */
375    {
376       int val = 0;
377       while (ec_enc_tell(&st->enc, 0) < nbCompressedBytes*8)
378       {
379          ec_enc_uint(&st->enc, val, 2);
380          val = 1-val;
381       }
382    }
383    ec_enc_done(&st->enc);
384    {
385       unsigned char *data;
386       int nbBytes = ec_byte_bytes(&st->buf);
387       if (nbBytes > nbCompressedBytes)
388       {
389          celt_warning_int ("got too many bytes:", nbBytes);
390          RESTORE_STACK;
391          return CELT_INTERNAL_ERROR;
392       }
393       /*printf ("%d\n", *nbBytes);*/
394       data = ec_byte_get_buffer(&st->buf);
395       for (i=0;i<nbBytes;i++)
396          compressed[i] = data[i];
397       for (;i<nbCompressedBytes;i++)
398          compressed[i] = 0;
399    }
400    /* Reset the packing for the next encoding */
401    ec_byte_reset(&st->buf);
402    ec_enc_init(&st->enc,&st->buf);
403
404    RESTORE_STACK;
405    return nbCompressedBytes;
406 }
407
408
409 /****************************************************************************/
410 /*                                                                          */
411 /*                                DECODER                                   */
412 /*                                                                          */
413 /****************************************************************************/
414
415
416 /** Decoder state 
417  @brief Decoder state
418  */
419 struct CELTDecoder {
420    const CELTMode *mode;
421    int frame_size;
422    int block_size;
423    int overlap;
424
425    ec_byte_buffer buf;
426    ec_enc         enc;
427
428    celt_sig_t * restrict preemph_memD;
429
430    celt_sig_t *out_mem;
431
432    celt_word16_t *oldBandE;
433    
434    int last_pitch_index;
435 };
436
437 CELTDecoder EXPORT *celt_decoder_create(const CELTMode *mode)
438 {
439    int N, C;
440    CELTDecoder *st;
441
442    if (check_mode(mode) != CELT_OK)
443       return NULL;
444
445    N = mode->mdctSize;
446    C = CHANNELS(mode);
447    st = celt_alloc(sizeof(CELTDecoder));
448    
449    st->mode = mode;
450    st->frame_size = N;
451    st->block_size = N;
452    st->overlap = mode->overlap;
453
454    st->out_mem = celt_alloc((MAX_PERIOD+st->overlap)*C*sizeof(celt_sig_t));
455    
456    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
457
458    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));;
459
460    st->last_pitch_index = 0;
461    return st;
462 }
463
464 void EXPORT celt_decoder_destroy(CELTDecoder *st)
465 {
466    if (st == NULL)
467    {
468       celt_warning("NULL passed to celt_encoder_destroy");
469       return;
470    }
471    if (check_mode(st->mode) != CELT_OK)
472       return;
473
474
475    celt_free(st->out_mem);
476    
477    celt_free(st->oldBandE);
478    
479    celt_free(st->preemph_memD);
480
481    celt_free(st);
482 }
483
484 /** Handles lost packets by just copying past data with the same offset as the last
485     pitch period */
486 static void celt_decode_lost(CELTDecoder * restrict st, short * restrict pcm)
487 {
488    int c, N;
489    int pitch_index;
490    int i, len;
491    VARDECL(celt_sig_t, freq);
492    const int C = CHANNELS(st->mode);
493    int offset;
494    SAVE_STACK;
495    N = st->block_size;
496    ALLOC(freq,C*N, celt_sig_t);         /**< Interleaved signal MDCTs */
497    
498    len = N+st->mode->overlap;
499 #if 0
500    pitch_index = st->last_pitch_index;
501    
502    /* Use the pitch MDCT as the "guessed" signal */
503    compute_mdcts(st->mode, st->mode->window, st->out_mem+pitch_index*C, freq);
504
505 #else
506    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);
507    pitch_index = MAX_PERIOD-len-pitch_index;
508    offset = MAX_PERIOD-pitch_index;
509    while (offset+len >= MAX_PERIOD)
510       offset -= pitch_index;
511    compute_mdcts(st->mode, st->mode->window, st->out_mem+offset*C, freq);
512    for (i=0;i<N;i++)
513       freq[i] = MULT16_32_Q15(QCONST16(.9f,15),freq[i]);
514 #endif
515    
516    
517    
518    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->mode->overlap-N));
519    /* Compute inverse MDCTs */
520    compute_inv_mdcts(st->mode, st->mode->window, freq, st->out_mem);
521
522    for (c=0;c<C;c++)
523    {
524       int j;
525       for (j=0;j<N;j++)
526       {
527          celt_sig_t tmp = ADD32(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
528                                 MULT16_32_Q15(preemph,st->preemph_memD[c]));
529          st->preemph_memD[c] = tmp;
530          pcm[C*j+c] = SIG2INT16(tmp);
531       }
532    }
533    RESTORE_STACK;
534 }
535
536 int EXPORT celt_decode(CELTDecoder * restrict st, unsigned char *data, int len, celt_int16_t * restrict pcm)
537 {
538    int c, N, N4;
539    int has_pitch;
540    int pitch_index;
541    ec_dec dec;
542    ec_byte_buffer buf;
543    VARDECL(celt_sig_t, freq);
544    VARDECL(celt_norm_t, X);
545    VARDECL(celt_norm_t, P);
546    VARDECL(celt_ener_t, bandE);
547    VARDECL(celt_pgain_t, gains);
548    const int C = CHANNELS(st->mode);
549    SAVE_STACK;
550
551    if (check_mode(st->mode) != CELT_OK)
552       return CELT_INVALID_MODE;
553
554    N = st->block_size;
555    N4 = (N-st->overlap)>>1;
556
557    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
558    ALLOC(X, C*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
559    ALLOC(P, C*N, celt_norm_t);         /**< Interleaved normalised pitch MDCTs*/
560    ALLOC(bandE, st->mode->nbEBands*C, celt_ener_t);
561    ALLOC(gains, st->mode->nbPBands, celt_pgain_t);
562    
563    if (check_mode(st->mode) != CELT_OK)
564    {
565       RESTORE_STACK;
566       return CELT_INVALID_MODE;
567    }
568    if (data == NULL)
569    {
570       celt_decode_lost(st, pcm);
571       RESTORE_STACK;
572       return 0;
573    }
574    
575    ec_byte_readinit(&buf,data,len);
576    ec_dec_init(&dec,&buf);
577    
578    /* Get the pitch gains */
579    has_pitch = unquant_pitch(gains, st->mode->nbPBands, &dec);
580    
581    /* Get the pitch index */
582    if (has_pitch)
583    {
584       pitch_index = ec_dec_uint(&dec, MAX_PERIOD-(2*N-2*N4));
585       st->last_pitch_index = pitch_index;
586    } else {
587       /* FIXME: We could be more intelligent here and just not compute the MDCT */
588       pitch_index = 0;
589    }
590
591    /* Get band energies */
592    unquant_energy(st->mode, bandE, st->oldBandE, 20+len*8/5, st->mode->prob, &dec);
593
594    /* Pitch MDCT */
595    compute_mdcts(st->mode, st->mode->window, st->out_mem+pitch_index*C, freq);
596
597    {
598       VARDECL(celt_ener_t, bandEp);
599       ALLOC(bandEp, st->mode->nbEBands*C, celt_ener_t);
600       compute_band_energies(st->mode, freq, bandEp);
601       normalise_bands(st->mode, freq, P, bandEp);
602    }
603
604    if (C==2)
605       stereo_mix(st->mode, P, bandE, 1);
606
607    /* Apply pitch gains */
608    pitch_quant_bands(st->mode, P, gains);
609
610    /* Decode fixed codebook and merge with pitch */
611    unquant_bands(st->mode, X, P, len*8, &dec);
612
613    if (C==2)
614    {
615       stereo_mix(st->mode, X, bandE, -1);
616       renormalise_bands(st->mode, X);
617    }
618    /* Synthesis */
619    denormalise_bands(st->mode, X, freq, bandE);
620
621
622    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->overlap-N));
623    /* Compute inverse MDCTs */
624    compute_inv_mdcts(st->mode, st->mode->window, freq, st->out_mem);
625
626    for (c=0;c<C;c++)
627    {
628       int j;
629       const celt_sig_t * restrict outp=st->out_mem+C*(MAX_PERIOD-N)+c;
630       celt_int16_t * restrict pcmp = pcm+c;
631       for (j=0;j<N;j++)
632       {
633          celt_sig_t tmp = ADD32(*outp, MULT16_32_Q15(preemph,st->preemph_memD[c]));
634          st->preemph_memD[c] = tmp;
635          *pcmp = SIG2INT16(tmp);
636          pcmp += C;
637          outp += C;
638       }
639    }
640
641    {
642       unsigned int val = 0;
643       while (ec_dec_tell(&dec, 0) < len*8)
644       {
645          if (ec_dec_uint(&dec, 2) != val)
646          {
647             celt_warning("decode error");
648             RESTORE_STACK;
649             return CELT_CORRUPTED_DATA;
650          }
651          val = 1-val;
652       }
653    }
654
655    RESTORE_STACK;
656    return 0;
657    /*printf ("\n");*/
658 }
659