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