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