269b20e28e7403045b7149332421d424ebfdcf9f
[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_sig_t *preemph_memE;
70    celt_sig_t *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_sig_t*)celt_alloc(C*sizeof(celt_sig_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    if (x>32767)
145       x = 32767;
146    else if (x<-32767)
147       x = -32767;
148 #ifdef FIXED_POINT
149    return EXTRACT16(x);
150 #else
151    return (celt_int16_t)floor(.5+x);
152 #endif
153 }
154
155 /** Apply window and compute the MDCT for all sub-frames and all channels in a frame */
156 static void compute_mdcts(const CELTMode *mode, const celt_word16_t * restrict window, celt_sig_t * restrict in, celt_sig_t * restrict out, int N, int overlap)
157 {
158    int c, N4;
159    VARDECL(celt_word32_t, x);
160    VARDECL(celt_word32_t, tmp);
161    const int C = CHANNELS(mode);
162    const mdct_lookup *lookup = MDCT(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       for (j=0;j<N4;j++)
183       {
184          x[j] = 0;
185          x[2*N-j-1] = 0;
186       }
187       mdct_forward(lookup, x, tmp);
188       /* Interleaving the sub-frames */
189       for (j=0;j<N;j++)
190          out[C*j+c] = tmp[j];
191    }
192    RESTORE_STACK;
193 }
194
195 /** Compute the IMDCT and apply window for all sub-frames and all channels in a frame */
196 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, int N, int overlap)
197 {
198    int c, N4;
199    VARDECL(celt_word32_t, x);
200    VARDECL(celt_word32_t, tmp);
201    const int C = CHANNELS(mode);
202    const mdct_lookup *lookup = MDCT(mode);
203    SAVE_STACK;
204    ALLOC(x, 2*N, celt_word32_t);
205    ALLOC(tmp, N, celt_word32_t);
206    N4 = (N-overlap)>>1;
207    for (c=0;c<C;c++)
208    {
209       int j;
210       /* De-interleaving the sub-frames */
211       for (j=0;j<N;j++)
212          tmp[j] = X[C*j+c];
213       mdct_backward(lookup, tmp, x);
214          /* The first and last part would need to be set to zero if we actually
215       wanted to use them. */
216       for (j=0;j<overlap;j++)
217          out_mem[C*(MAX_PERIOD-N)+C*j+c] = 2*(mdct_overlap[C*j+c]+MULT16_32_Q15(window[j],x[j+N4]));
218       for (j=0;j<overlap;j++)
219          mdct_overlap[C*(overlap-j-1)+c] = MULT16_32_Q15(window[j],x[2*N-j-N4-1]);
220       for (j=0;j<2*N4;j++)
221          out_mem[C*(MAX_PERIOD-N)+C*(j+overlap)+c] = 2*x[j+N4+overlap];
222    }
223    RESTORE_STACK;
224 }
225
226 int EXPORT celt_encode(CELTEncoder *st, celt_int16_t *pcm, unsigned char *compressed, int nbCompressedBytes)
227 {
228    int i, c, N, N4;
229    int has_pitch;
230    int pitch_index;
231    celt_word32_t curr_power, pitch_power;
232    VARDECL(celt_sig_t, in);
233    VARDECL(celt_sig_t, freq);
234    VARDECL(celt_norm_t, X);
235    VARDECL(celt_norm_t, P);
236    VARDECL(celt_ener_t, bandE);
237    VARDECL(celt_pgain_t, gains);
238    const int C = CHANNELS(st->mode);
239    SAVE_STACK;
240
241    if (check_mode(st->mode) != CELT_OK)
242       return CELT_INVALID_MODE;
243
244    N = st->block_size;
245    N4 = (N-st->overlap)>>1;
246    ALLOC(in, 2*C*N-2*N4, celt_sig_t);
247    
248
249    for (c=0;c<C;c++)
250    {
251       for (i=0;i<st->overlap;i++)
252          in[C*i+c] = st->in_mem[C*i+c];
253       for (i=0;i<N;i++)
254       {
255          celt_sig_t tmp = SHL32(EXTEND32(pcm[C*i+c]), SIG_SHIFT);
256          in[C*(i+st->overlap)+c] = SUB32(tmp, MULT16_32_Q15(preemph,st->preemph_memE[c]));
257          st->preemph_memE[c] = tmp;
258       }
259       for (i=0;i<st->overlap;i++)
260          st->in_mem[C*i+c] = in[C*(2*N-2*N4-st->overlap+i)+c];
261    }
262    /* Pitch analysis: we do it early to save on the peak stack space */
263    find_spectral_pitch(st->fft, &st->mode->psy, in, st->out_mem, st->mode->window, st->overlap, MAX_PERIOD, 2*N-2*N4, C, &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, N, st->overlap);
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, N, st->overlap);
303    
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_uint(&st->enc, 0, 128);
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*N;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, N, st->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       for (j=0;j<N;j++)
372       {
373          celt_sig_t tmp = ADD32(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
374                                 MULT16_32_Q15(preemph,st->preemph_memD[c]));
375          st->preemph_memD[c] = tmp;
376          pcm[C*j+c] = SIG2INT16(tmp);
377       }
378    }
379    
380    if (ec_enc_tell(&st->enc, 0) < nbCompressedBytes*8 - 7)
381       celt_warning_int ("many unused bits: ", nbCompressedBytes*8-ec_enc_tell(&st->enc, 0));
382    /*printf ("%d\n", ec_enc_tell(&st->enc, 0)-8*nbCompressedBytes);*/
383    /* Finishing the stream with a 0101... pattern so that the decoder can check is everything's right */
384    {
385       int val = 0;
386       while (ec_enc_tell(&st->enc, 0) < nbCompressedBytes*8)
387       {
388          ec_enc_uint(&st->enc, val, 2);
389          val = 1-val;
390       }
391    }
392    ec_enc_done(&st->enc);
393    {
394       unsigned char *data;
395       int nbBytes = ec_byte_bytes(&st->buf);
396       if (nbBytes > nbCompressedBytes)
397       {
398          celt_warning_int ("got too many bytes:", nbBytes);
399          RESTORE_STACK;
400          return CELT_INTERNAL_ERROR;
401       }
402       /*printf ("%d\n", *nbBytes);*/
403       data = ec_byte_get_buffer(&st->buf);
404       for (i=0;i<nbBytes;i++)
405          compressed[i] = data[i];
406       for (;i<nbCompressedBytes;i++)
407          compressed[i] = 0;
408    }
409    /* Reset the packing for the next encoding */
410    ec_byte_reset(&st->buf);
411    ec_enc_init(&st->enc,&st->buf);
412
413    RESTORE_STACK;
414    return nbCompressedBytes;
415 }
416
417
418 /****************************************************************************/
419 /*                                                                          */
420 /*                                DECODER                                   */
421 /*                                                                          */
422 /****************************************************************************/
423
424
425 /** Decoder state 
426  @brief Decoder state
427  */
428 struct CELTDecoder {
429    const CELTMode *mode;
430    int frame_size;
431    int block_size;
432    int overlap;
433
434    ec_byte_buffer buf;
435    ec_enc         enc;
436
437    celt_sig_t *preemph_memD;
438
439    celt_sig_t *mdct_overlap;
440    celt_sig_t *out_mem;
441
442    celt_word16_t *oldBandE;
443    
444    int last_pitch_index;
445 };
446
447 CELTDecoder EXPORT *celt_decoder_create(const CELTMode *mode)
448 {
449    int N, C;
450    CELTDecoder *st;
451
452    if (check_mode(mode) != CELT_OK)
453       return NULL;
454
455    N = mode->mdctSize;
456    C = CHANNELS(mode);
457    st = celt_alloc(sizeof(CELTDecoder));
458    
459    st->mode = mode;
460    st->frame_size = N;
461    st->block_size = N;
462    st->overlap = mode->overlap;
463
464    st->mdct_overlap = celt_alloc(N*C*sizeof(celt_sig_t));
465    st->out_mem = celt_alloc(MAX_PERIOD*C*sizeof(celt_sig_t));
466    
467    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
468
469    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));;
470
471    st->last_pitch_index = 0;
472    return st;
473 }
474
475 void EXPORT celt_decoder_destroy(CELTDecoder *st)
476 {
477    if (st == NULL)
478    {
479       celt_warning("NULL passed to celt_encoder_destroy");
480       return;
481    }
482    if (check_mode(st->mode) != CELT_OK)
483       return;
484
485
486    celt_free(st->mdct_overlap);
487    celt_free(st->out_mem);
488    
489    celt_free(st->oldBandE);
490    
491    celt_free(st->preemph_memD);
492
493    celt_free(st);
494 }
495
496 /** Handles lost packets by just copying past data with the same offset as the last
497     pitch period */
498 static void celt_decode_lost(CELTDecoder *st, short *pcm)
499 {
500    int c, N;
501    int pitch_index;
502    VARDECL(celt_sig_t, freq);
503    const int C = CHANNELS(st->mode);
504    SAVE_STACK;
505    N = st->block_size;
506    ALLOC(freq,C*N, celt_sig_t);         /**< Interleaved signal MDCTs */
507    
508    pitch_index = st->last_pitch_index;
509    
510    /* Use the pitch MDCT as the "guessed" signal */
511    compute_mdcts(st->mode, st->mode->window, st->out_mem+pitch_index*C, freq, N, st->overlap);
512
513    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD-N));
514    /* Compute inverse MDCTs */
515    compute_inv_mdcts(st->mode, st->mode->window, freq, st->out_mem, st->mdct_overlap, N, st->overlap);
516
517    for (c=0;c<C;c++)
518    {
519       int j;
520       for (j=0;j<N;j++)
521       {
522          celt_sig_t tmp = ADD32(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
523                                 MULT16_32_Q15(preemph,st->preemph_memD[c]));
524          st->preemph_memD[c] = tmp;
525          pcm[C*j+c] = SIG2INT16(tmp);
526       }
527    }
528    RESTORE_STACK;
529 }
530
531 int EXPORT celt_decode(CELTDecoder *st, unsigned char *data, int len, celt_int16_t *pcm)
532 {
533    int c, N, N4;
534    int has_pitch;
535    int pitch_index;
536    ec_dec dec;
537    ec_byte_buffer buf;
538    VARDECL(celt_sig_t, freq);
539    VARDECL(celt_norm_t, X);
540    VARDECL(celt_norm_t, P);
541    VARDECL(celt_ener_t, bandE);
542    VARDECL(celt_pgain_t, gains);
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 band energies */
574    unquant_energy(st->mode, bandE, st->oldBandE, len*8/3, &dec);
575    
576    /* Get the pitch gains */
577    has_pitch = unquant_pitch(gains, st->mode->nbPBands, &dec);
578    
579    /* Get the pitch index */
580    if (has_pitch)
581    {
582       pitch_index = ec_dec_uint(&dec, MAX_PERIOD-(2*N-2*N4));
583       st->last_pitch_index = pitch_index;
584    } else {
585       /* FIXME: We could be more intelligent here and just not compute the MDCT */
586       pitch_index = 0;
587    }
588    
589    /* Pitch MDCT */
590    compute_mdcts(st->mode, st->mode->window, st->out_mem+pitch_index*C, freq, N, st->overlap);
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    if (C==2)
600       stereo_mix(st->mode, P, bandE, 1);
601
602    /* Apply pitch gains */
603    pitch_quant_bands(st->mode, P, gains);
604
605    /* Decode fixed codebook and merge with pitch */
606    unquant_bands(st->mode, X, P, len*8, &dec);
607
608    if (C==2)
609    {
610       stereo_mix(st->mode, X, bandE, -1);
611       renormalise_bands(st->mode, X);
612    }
613    /* Synthesis */
614    denormalise_bands(st->mode, X, freq, bandE);
615
616
617    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD-N));
618    /* Compute inverse MDCTs */
619    compute_inv_mdcts(st->mode, st->mode->window, freq, st->out_mem, st->mdct_overlap, N, st->overlap);
620
621    for (c=0;c<C;c++)
622    {
623       int j;
624       for (j=0;j<N;j++)
625       {
626          celt_sig_t tmp = ADD32(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
627                                 MULT16_32_Q15(preemph,st->preemph_memD[c]));
628          st->preemph_memD[c] = tmp;
629          pcm[C*j+c] = SIG2INT16(tmp);
630       }
631    }
632
633    {
634       unsigned int val = 0;
635       while (ec_dec_tell(&dec, 0) < len*8)
636       {
637          if (ec_dec_uint(&dec, 2) != val)
638          {
639             celt_warning("decode error");
640             RESTORE_STACK;
641             return CELT_CORRUPTED_DATA;
642          }
643          val = 1-val;
644       }
645    }
646
647    RESTORE_STACK;
648    return 0;
649    /*printf ("\n");*/
650 }
651