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