more use of CELT_COPY in celt_encode(). Also fixed a stack size bug for stereo
[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       mdct_forward(lookup, x, tmp);
185       /* Interleaving the sub-frames */
186       for (j=0;j<N;j++)
187          out[C*j+c] = tmp[j];
188    }
189    RESTORE_STACK;
190 }
191
192 /** Compute the IMDCT and apply window for all sub-frames and all channels in a frame */
193 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)
194 {
195    int c, N4;
196    VARDECL(celt_word32_t, x);
197    VARDECL(celt_word32_t, tmp);
198    const int C = CHANNELS(mode);
199    const mdct_lookup *lookup = MDCT(mode);
200    const int N = FRAMESIZE(mode);
201    const int overlap = OVERLAP(mode);
202    SAVE_STACK;
203    ALLOC(x, 2*N, celt_word32_t);
204    ALLOC(tmp, N, celt_word32_t);
205    N4 = (N-overlap)>>1;
206    for (c=0;c<C;c++)
207    {
208       int j;
209       /* De-interleaving the sub-frames */
210       for (j=0;j<N;j++)
211          tmp[j] = X[C*j+c];
212       mdct_backward(lookup, tmp, x);
213          /* The first and last part would need to be set to zero if we actually
214       wanted to use them. */
215       for (j=0;j<overlap;j++)
216          out_mem[C*(MAX_PERIOD-N)+C*j+c] = 2*(mdct_overlap[C*j+c]+MULT16_32_Q15(window[j],x[j+N4]));
217       for (j=0;j<overlap;j++)
218          mdct_overlap[C*(overlap-j-1)+c] = MULT16_32_Q15(window[j],x[2*N-j-N4-1]);
219       for (j=0;j<2*N4;j++)
220          out_mem[C*(MAX_PERIOD-N)+C*(j+overlap)+c] = 2*x[j+N4+overlap];
221    }
222    RESTORE_STACK;
223 }
224
225 int EXPORT celt_encode(CELTEncoder * restrict st, celt_int16_t * restrict pcm, unsigned char *compressed, int nbCompressedBytes)
226 {
227    int i, c, N, N4;
228    int has_pitch;
229    int pitch_index;
230    celt_word32_t curr_power, pitch_power;
231    VARDECL(celt_sig_t, in);
232    VARDECL(celt_sig_t, freq);
233    VARDECL(celt_norm_t, X);
234    VARDECL(celt_norm_t, P);
235    VARDECL(celt_ener_t, bandE);
236    VARDECL(celt_pgain_t, gains);
237    const int C = CHANNELS(st->mode);
238    SAVE_STACK;
239
240    if (check_mode(st->mode) != CELT_OK)
241       return CELT_INVALID_MODE;
242
243    N = st->block_size;
244    N4 = (N-st->overlap)>>1;
245    ALLOC(in, 2*C*N-2*C*N4, celt_sig_t);
246
247    CELT_COPY(in, st->in_mem, C*st->overlap);
248    for (c=0;c<C;c++)
249    {
250       for (i=0;i<N;i++)
251       {
252          celt_sig_t tmp = SHL32(EXTEND32(pcm[C*i+c]), SIG_SHIFT);
253          in[C*(i+st->overlap)+c] = SUB32(tmp, SHR32(MULT16_16(preemph,st->preemph_memE[c]),1));
254          st->preemph_memE[c] = pcm[C*i+c];
255       }
256    }
257    CELT_COPY(st->in_mem, in+C*(2*N-2*N4-st->overlap), C*st->overlap);
258
259    /* Pitch analysis: we do it early to save on the peak stack space */
260    find_spectral_pitch(st->mode, st->fft, &st->mode->psy, in, st->out_mem, st->mode->window, 2*N-2*N4, &pitch_index);
261
262    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
263    
264    /*for (i=0;i<(B+1)*C*N;i++) printf ("%f(%d) ", in[i], i); printf ("\n");*/
265    /* Compute MDCTs */
266    compute_mdcts(st->mode, st->mode->window, in, freq);
267
268 #if 0 /* Mask disabled until it can be made to do something useful */
269    compute_mdct_masking(X, mask, B*C*N, st->Fs);
270
271    /* Invert and stretch the mask to length of X 
272       For some reason, I get better results by using the sqrt instead,
273       although there's no valid reason to. Must investigate further */
274    for (i=0;i<B*C*N;i++)
275       mask[i] = 1/(.1+mask[i]);
276 #endif
277    
278    /* Deferred allocation after find_spectral_pitch() to reduce the peak memory usage */
279    ALLOC(X, C*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
280    ALLOC(P, C*N, celt_norm_t);         /**< Interleaved normalised pitch MDCTs*/
281    ALLOC(bandE,st->mode->nbEBands*C, celt_ener_t);
282    ALLOC(gains,st->mode->nbPBands, celt_pgain_t);
283
284    /*printf ("%f %f\n", curr_power, pitch_power);*/
285    /*int j;
286    for (j=0;j<B*N;j++)
287       printf ("%f ", X[j]);
288    for (j=0;j<B*N;j++)
289       printf ("%f ", P[j]);
290    printf ("\n");*/
291
292    /* Band normalisation */
293    compute_band_energies(st->mode, freq, bandE);
294    normalise_bands(st->mode, freq, X, bandE);
295    /*for (i=0;i<st->mode->nbEBands;i++)printf("%f ", bandE[i]);printf("\n");*/
296    /*for (i=0;i<N*B*C;i++)printf("%f ", X[i]);printf("\n");*/
297
298    /* Compute MDCTs of the pitch part */
299    compute_mdcts(st->mode, st->mode->window, st->out_mem+pitch_index*C, freq);
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, st->mode->window, freq, st->out_mem, st->mdct_overlap);
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 * restrict 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 = CHANNELS(mode);
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 * restrict st, short * restrict pcm)
495 {
496    int c, N;
497    int pitch_index;
498    VARDECL(celt_sig_t, freq);
499    const int C = CHANNELS(st->mode);
500    SAVE_STACK;
501    N = st->block_size;
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, st->mode->window, st->out_mem+pitch_index*C, freq);
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, st->mode->window, freq, st->out_mem, st->mdct_overlap);
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 * restrict st, unsigned char *data, int len, celt_int16_t * restrict pcm)
528 {
529    int c, N, 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    const int C = CHANNELS(st->mode);
540    SAVE_STACK;
541
542    if (check_mode(st->mode) != CELT_OK)
543       return CELT_INVALID_MODE;
544
545    N = st->block_size;
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, st->mode->window, st->out_mem+pitch_index*C, freq);
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, st->mode->window, freq, st->out_mem, st->mdct_overlap);
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