Doing mid-side stereo when not doing intensity.
[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*C+nbCompressedBytes*8/5, st->mode->prob, &st->enc);
326
327    ALLOC(stereo_mode, st->mode->nbEBands, int);
328    stereo_decision(st->mode, X, stereo_mode, st->mode->nbEBands);
329
330    pitch_quant_bands(st->mode, P, gains);
331
332    /*for (i=0;i<B*N;i++) printf("%f ",P[i]);printf("\n");*/
333
334    /* Residual quantisation */
335    quant_bands(st->mode, X, P, NULL, bandE, stereo_mode, nbCompressedBytes*8, &st->enc);
336    
337    if (C==2)
338    {
339       renormalise_bands(st->mode, X);
340    }
341    /* Synthesis */
342    denormalise_bands(st->mode, X, freq, bandE);
343
344
345    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->overlap-N));
346
347    compute_inv_mdcts(st->mode, st->mode->window, freq, st->out_mem);
348    /* De-emphasis and put everything back at the right place in the synthesis history */
349 #ifndef SHORTCUTS
350    for (c=0;c<C;c++)
351    {
352       int j;
353       const celt_sig_t * restrict outp=st->out_mem+C*(MAX_PERIOD-N)+c;
354       celt_int16_t * restrict pcmp = pcm+c;
355       for (j=0;j<N;j++)
356       {
357          celt_sig_t tmp = ADD32(*outp, MULT16_32_Q15(preemph,st->preemph_memD[c]));
358          st->preemph_memD[c] = tmp;
359          *pcmp = SIG2INT16(tmp);
360          pcmp += C;
361          outp += C;
362       }
363    }
364 #endif
365    if (ec_enc_tell(&st->enc, 0) < nbCompressedBytes*8 - 7)
366       celt_warning_int ("many unused bits: ", nbCompressedBytes*8-ec_enc_tell(&st->enc, 0));
367    /*printf ("%d\n", ec_enc_tell(&st->enc, 0)-8*nbCompressedBytes);*/
368    /* Finishing the stream with a 0101... pattern so that the decoder can check is everything's right */
369    {
370       int val = 0;
371       while (ec_enc_tell(&st->enc, 0) < nbCompressedBytes*8)
372       {
373          ec_enc_uint(&st->enc, val, 2);
374          val = 1-val;
375       }
376    }
377    ec_enc_done(&st->enc);
378    {
379       unsigned char *data;
380       int nbBytes = ec_byte_bytes(&st->buf);
381       if (nbBytes > nbCompressedBytes)
382       {
383          celt_warning_int ("got too many bytes:", nbBytes);
384          RESTORE_STACK;
385          return CELT_INTERNAL_ERROR;
386       }
387       /*printf ("%d\n", *nbBytes);*/
388       data = ec_byte_get_buffer(&st->buf);
389       for (i=0;i<nbBytes;i++)
390          compressed[i] = data[i];
391       for (;i<nbCompressedBytes;i++)
392          compressed[i] = 0;
393    }
394    /* Reset the packing for the next encoding */
395    ec_byte_reset(&st->buf);
396    ec_enc_init(&st->enc,&st->buf);
397
398    RESTORE_STACK;
399    return nbCompressedBytes;
400 }
401
402
403 /****************************************************************************/
404 /*                                                                          */
405 /*                                DECODER                                   */
406 /*                                                                          */
407 /****************************************************************************/
408
409
410 /** Decoder state 
411  @brief Decoder state
412  */
413 struct CELTDecoder {
414    const CELTMode *mode;
415    int frame_size;
416    int block_size;
417    int overlap;
418
419    ec_byte_buffer buf;
420    ec_enc         enc;
421
422    celt_sig_t * restrict preemph_memD;
423
424    celt_sig_t *out_mem;
425
426    celt_word16_t *oldBandE;
427    
428    int last_pitch_index;
429 };
430
431 CELTDecoder EXPORT *celt_decoder_create(const CELTMode *mode)
432 {
433    int N, C;
434    CELTDecoder *st;
435
436    if (check_mode(mode) != CELT_OK)
437       return NULL;
438
439    N = mode->mdctSize;
440    C = CHANNELS(mode);
441    st = celt_alloc(sizeof(CELTDecoder));
442    
443    st->mode = mode;
444    st->frame_size = N;
445    st->block_size = N;
446    st->overlap = mode->overlap;
447
448    st->out_mem = celt_alloc((MAX_PERIOD+st->overlap)*C*sizeof(celt_sig_t));
449    
450    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
451
452    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));;
453
454    st->last_pitch_index = 0;
455    return st;
456 }
457
458 void EXPORT celt_decoder_destroy(CELTDecoder *st)
459 {
460    if (st == NULL)
461    {
462       celt_warning("NULL passed to celt_encoder_destroy");
463       return;
464    }
465    if (check_mode(st->mode) != CELT_OK)
466       return;
467
468
469    celt_free(st->out_mem);
470    
471    celt_free(st->oldBandE);
472    
473    celt_free(st->preemph_memD);
474
475    celt_free(st);
476 }
477
478 /** Handles lost packets by just copying past data with the same offset as the last
479     pitch period */
480 static void celt_decode_lost(CELTDecoder * restrict st, short * restrict pcm)
481 {
482    int c, N;
483    int pitch_index;
484    int i, len;
485    VARDECL(celt_sig_t, freq);
486    const int C = CHANNELS(st->mode);
487    int offset;
488    SAVE_STACK;
489    N = st->block_size;
490    ALLOC(freq,C*N, celt_sig_t);         /**< Interleaved signal MDCTs */
491    
492    len = N+st->mode->overlap;
493 #if 0
494    pitch_index = st->last_pitch_index;
495    
496    /* Use the pitch MDCT as the "guessed" signal */
497    compute_mdcts(st->mode, st->mode->window, st->out_mem+pitch_index*C, freq);
498
499 #else
500    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);
501    pitch_index = MAX_PERIOD-len-pitch_index;
502    offset = MAX_PERIOD-pitch_index;
503    while (offset+len >= MAX_PERIOD)
504       offset -= pitch_index;
505    compute_mdcts(st->mode, st->mode->window, st->out_mem+offset*C, freq);
506    for (i=0;i<N;i++)
507       freq[i] = MULT16_32_Q15(QCONST16(.9f,15),freq[i]);
508 #endif
509    
510    
511    
512    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->mode->overlap-N));
513    /* Compute inverse MDCTs */
514    compute_inv_mdcts(st->mode, st->mode->window, freq, st->out_mem);
515
516    for (c=0;c<C;c++)
517    {
518       int j;
519       for (j=0;j<N;j++)
520       {
521          celt_sig_t tmp = ADD32(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
522                                 MULT16_32_Q15(preemph,st->preemph_memD[c]));
523          st->preemph_memD[c] = tmp;
524          pcm[C*j+c] = SIG2INT16(tmp);
525       }
526    }
527    RESTORE_STACK;
528 }
529
530 int EXPORT celt_decode(CELTDecoder * restrict st, unsigned char *data, int len, celt_int16_t * restrict pcm)
531 {
532    int c, N, N4;
533    int has_pitch;
534    int pitch_index;
535    ec_dec dec;
536    ec_byte_buffer buf;
537    VARDECL(celt_sig_t, freq);
538    VARDECL(celt_norm_t, X);
539    VARDECL(celt_norm_t, P);
540    VARDECL(celt_ener_t, bandE);
541    VARDECL(celt_pgain_t, gains);
542    VARDECL(int, stereo_mode);
543    const int C = CHANNELS(st->mode);
544    SAVE_STACK;
545
546    if (check_mode(st->mode) != CELT_OK)
547       return CELT_INVALID_MODE;
548
549    N = st->block_size;
550    N4 = (N-st->overlap)>>1;
551
552    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
553    ALLOC(X, C*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
554    ALLOC(P, C*N, celt_norm_t);         /**< Interleaved normalised pitch MDCTs*/
555    ALLOC(bandE, st->mode->nbEBands*C, celt_ener_t);
556    ALLOC(gains, st->mode->nbPBands, celt_pgain_t);
557    
558    if (check_mode(st->mode) != CELT_OK)
559    {
560       RESTORE_STACK;
561       return CELT_INVALID_MODE;
562    }
563    if (data == NULL)
564    {
565       celt_decode_lost(st, pcm);
566       RESTORE_STACK;
567       return 0;
568    }
569    
570    ec_byte_readinit(&buf,data,len);
571    ec_dec_init(&dec,&buf);
572    
573    /* Get the pitch gains */
574    has_pitch = unquant_pitch(gains, st->mode->nbPBands, &dec);
575    
576    /* Get the pitch index */
577    if (has_pitch)
578    {
579       pitch_index = ec_dec_uint(&dec, MAX_PERIOD-(2*N-2*N4));
580       st->last_pitch_index = pitch_index;
581    } else {
582       /* FIXME: We could be more intelligent here and just not compute the MDCT */
583       pitch_index = 0;
584    }
585
586    /* Get band energies */
587    unquant_energy(st->mode, bandE, st->oldBandE, 20*C+len*8/5, st->mode->prob, &dec);
588
589    /* Pitch MDCT */
590    compute_mdcts(st->mode, st->mode->window, st->out_mem+pitch_index*C, freq);
591
592    {
593       VARDECL(celt_ener_t, bandEp);
594       ALLOC(bandEp, st->mode->nbEBands*C, celt_ener_t);
595       compute_band_energies(st->mode, freq, bandEp);
596       normalise_bands(st->mode, freq, P, bandEp);
597    }
598
599    ALLOC(stereo_mode, st->mode->nbEBands, int);
600    stereo_decision(st->mode, X, stereo_mode, st->mode->nbEBands);
601    /* Apply pitch gains */
602    pitch_quant_bands(st->mode, P, gains);
603
604    /* Decode fixed codebook and merge with pitch */
605    unquant_bands(st->mode, X, P, bandE, stereo_mode, len*8, &dec);
606
607    if (C==2)
608    {
609       renormalise_bands(st->mode, X);
610    }
611    /* Synthesis */
612    denormalise_bands(st->mode, X, freq, bandE);
613
614
615    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->overlap-N));
616    /* Compute inverse MDCTs */
617    compute_inv_mdcts(st->mode, st->mode->window, freq, st->out_mem);
618
619    for (c=0;c<C;c++)
620    {
621       int j;
622       const celt_sig_t * restrict outp=st->out_mem+C*(MAX_PERIOD-N)+c;
623       celt_int16_t * restrict pcmp = pcm+c;
624       for (j=0;j<N;j++)
625       {
626          celt_sig_t tmp = ADD32(*outp, MULT16_32_Q15(preemph,st->preemph_memD[c]));
627          st->preemph_memD[c] = tmp;
628          *pcmp = SIG2INT16(tmp);
629          pcmp += C;
630          outp += C;
631       }
632    }
633
634    {
635       unsigned int val = 0;
636       while (ec_dec_tell(&dec, 0) < len*8)
637       {
638          if (ec_dec_uint(&dec, 2) != val)
639          {
640             celt_warning("decode error");
641             RESTORE_STACK;
642             return CELT_CORRUPTED_DATA;
643          }
644          val = 1-val;
645       }
646    }
647
648    RESTORE_STACK;
649    return 0;
650    /*printf ("\n");*/
651 }
652