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