Removed support for more than one MDCT blocks per frame. I don't think there's
[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 celt_word32_t 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    celt_word32_t E = 0;
160    VARDECL(celt_word32_t, x);
161    VARDECL(celt_word32_t, tmp);
162    SAVE_STACK;
163    N4 = (N-overlap)>>1;
164    ALLOC(x, 2*N, celt_word32_t);
165    ALLOC(tmp, N, celt_word32_t);
166    for (c=0;c<C;c++)
167    {
168       int j;
169       celt_word32_t * restrict x1, * restrict x2;
170       for (j=0;j<2*N-2*N4;j++)
171          x[j+N4] = in[C*j+c];
172       x1 = x+N4;
173       x2 = x+2*N-N4-1;
174       for (j=0;j<overlap;j++)
175       {
176          *x1 = MULT16_32_Q15(window[j],*x1);
177          *x2 = MULT16_32_Q15(window[j],*x2);
178          x1++;
179          x2--;
180       }
181       for (j=0;j<N4;j++)
182       {
183          x[j] = 0;
184          x[2*N-j-1] = 0;
185       }
186       for (j=0;j<2*N;j++)
187          E += MULT16_16(EXTRACT16(SHR32(x[j],SIG_SHIFT+4)),EXTRACT16(SHR32(x[j],SIG_SHIFT+4)));
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    RESTORE_STACK;
194    return E;
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 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)
199 {
200    int c, N4;
201    VARDECL(celt_word32_t, x);
202    VARDECL(celt_word32_t, tmp);
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, C, 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    SAVE_STACK;
239
240    if (check_mode(st->mode) != CELT_OK)
241       return CELT_INVALID_MODE;
242
243    N = st->block_size;
244    C = st->mode->nbChannels;
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    curr_power = compute_mdcts(&st->mode->mdct, st->mode->window, in, freq, N, st->overlap, C);
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    pitch_power = compute_mdcts(&st->mode->mdct, st->mode->window, st->out_mem+pitch_index*C, freq, N, st->overlap, C);
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    /* Check if we can safely use the pitch (i.e. effective gain isn't too high) */
313    if (MULT16_32_Q15(QCONST16(.1f, 15),curr_power) + SHR16(10000,8) < pitch_power)
314    {
315       /* Normalise the pitch vector as well (discard the energies) */
316       VARDECL(celt_ener_t, bandEp);
317       ALLOC(bandEp, st->mode->nbEBands*st->mode->nbChannels, celt_ener_t);
318       compute_band_energies(st->mode, freq, bandEp);
319       normalise_bands(st->mode, freq, P, bandEp);
320
321       if (C==2)
322          stereo_mix(st->mode, P, bandE, 1);
323       /* Simulates intensity stereo */
324       /*for (i=30;i<N*B;i++)
325          X[i*C+1] = P[i*C+1] = 0;*/
326
327       /* Pitch prediction */
328       compute_pitch_gain(st->mode, X, P, gains);
329       has_pitch = quant_pitch(gains, st->mode->nbPBands, &st->enc);
330       if (has_pitch)
331          ec_enc_uint(&st->enc, pitch_index, MAX_PERIOD-(2*N-2*N4));
332    } else {
333       /* No pitch, so we just pretend we found a gain of zero */
334       for (i=0;i<st->mode->nbPBands;i++)
335          gains[i] = 0;
336       ec_enc_uint(&st->enc, 0, 128);
337       for (i=0;i<C*N;i++)
338          P[i] = 0;
339    }
340    
341
342    pitch_quant_bands(st->mode, P, gains);
343
344    /*for (i=0;i<B*N;i++) printf("%f ",P[i]);printf("\n");*/
345    /* Compute residual that we're going to encode */
346    for (i=0;i<C*N;i++)
347       X[i] -= P[i];
348
349    /* Residual quantisation */
350    quant_bands(st->mode, X, P, NULL, nbCompressedBytes*8, &st->enc);
351    
352    if (C==2)
353    {
354       stereo_mix(st->mode, X, bandE, -1);
355       renormalise_bands(st->mode, X);
356    }
357    /* Synthesis */
358    denormalise_bands(st->mode, X, freq, bandE);
359
360
361    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD-N));
362
363    compute_inv_mdcts(&st->mode->mdct, st->mode->window, freq, st->out_mem, st->mdct_overlap, N, st->overlap, C);
364    /* De-emphasis and put everything back at the right place in the synthesis history */
365    for (c=0;c<C;c++)
366    {
367       int j;
368       for (j=0;j<N;j++)
369       {
370          celt_sig_t tmp = ADD32(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
371                                 MULT16_32_Q15(preemph,st->preemph_memD[c]));
372          st->preemph_memD[c] = tmp;
373          pcm[C*j+c] = SIG2INT16(tmp);
374       }
375    }
376    
377    if (ec_enc_tell(&st->enc, 0) < nbCompressedBytes*8 - 7)
378       celt_warning_int ("many unused bits: ", nbCompressedBytes*8-ec_enc_tell(&st->enc, 0));
379    /*printf ("%d\n", ec_enc_tell(&st->enc, 0)-8*nbCompressedBytes);*/
380    /* Finishing the stream with a 0101... pattern so that the decoder can check is everything's right */
381    {
382       int val = 0;
383       while (ec_enc_tell(&st->enc, 0) < nbCompressedBytes*8)
384       {
385          ec_enc_uint(&st->enc, val, 2);
386          val = 1-val;
387       }
388    }
389    ec_enc_done(&st->enc);
390    {
391       unsigned char *data;
392       int nbBytes = ec_byte_bytes(&st->buf);
393       if (nbBytes > nbCompressedBytes)
394       {
395          celt_warning_int ("got too many bytes:", nbBytes);
396          RESTORE_STACK;
397          return CELT_INTERNAL_ERROR;
398       }
399       /*printf ("%d\n", *nbBytes);*/
400       data = ec_byte_get_buffer(&st->buf);
401       for (i=0;i<nbBytes;i++)
402          compressed[i] = data[i];
403       for (;i<nbCompressedBytes;i++)
404          compressed[i] = 0;
405    }
406    /* Reset the packing for the next encoding */
407    ec_byte_reset(&st->buf);
408    ec_enc_init(&st->enc,&st->buf);
409
410    RESTORE_STACK;
411    return nbCompressedBytes;
412 }
413
414
415 /****************************************************************************/
416 /*                                                                          */
417 /*                                DECODER                                   */
418 /*                                                                          */
419 /****************************************************************************/
420
421
422 /** Decoder state 
423  @brief Decoder state
424  */
425 struct CELTDecoder {
426    const CELTMode *mode;
427    int frame_size;
428    int block_size;
429    int overlap;
430
431    ec_byte_buffer buf;
432    ec_enc         enc;
433
434    celt_sig_t *preemph_memD;
435
436    celt_sig_t *mdct_overlap;
437    celt_sig_t *out_mem;
438
439    celt_word16_t *oldBandE;
440    
441    int last_pitch_index;
442 };
443
444 CELTDecoder EXPORT *celt_decoder_create(const CELTMode *mode)
445 {
446    int N, C;
447    CELTDecoder *st;
448
449    if (check_mode(mode) != CELT_OK)
450       return NULL;
451
452    N = mode->mdctSize;
453    C = mode->nbChannels;
454    st = celt_alloc(sizeof(CELTDecoder));
455    
456    st->mode = mode;
457    st->frame_size = N;
458    st->block_size = N;
459    st->overlap = mode->overlap;
460
461    st->mdct_overlap = celt_alloc(N*C*sizeof(celt_sig_t));
462    st->out_mem = celt_alloc(MAX_PERIOD*C*sizeof(celt_sig_t));
463    
464    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
465
466    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));;
467
468    st->last_pitch_index = 0;
469    return st;
470 }
471
472 void EXPORT celt_decoder_destroy(CELTDecoder *st)
473 {
474    if (st == NULL)
475    {
476       celt_warning("NULL passed to celt_encoder_destroy");
477       return;
478    }
479    if (check_mode(st->mode) != CELT_OK)
480       return;
481
482
483    celt_free(st->mdct_overlap);
484    celt_free(st->out_mem);
485    
486    celt_free(st->oldBandE);
487    
488    celt_free(st->preemph_memD);
489
490    celt_free(st);
491 }
492
493 /** Handles lost packets by just copying past data with the same offset as the last
494     pitch period */
495 static void celt_decode_lost(CELTDecoder *st, short *pcm)
496 {
497    int c, N, C;
498    int pitch_index;
499    VARDECL(celt_sig_t, freq);
500    SAVE_STACK;
501    N = st->block_size;
502    C = st->mode->nbChannels;
503    ALLOC(freq,C*N, celt_sig_t);         /**< Interleaved signal MDCTs */
504    
505    pitch_index = st->last_pitch_index;
506    
507    /* Use the pitch MDCT as the "guessed" signal */
508    compute_mdcts(&st->mode->mdct, st->mode->window, st->out_mem+pitch_index*C, freq, N, st->overlap, C);
509
510    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD-N));
511    /* Compute inverse MDCTs */
512    compute_inv_mdcts(&st->mode->mdct, st->mode->window, freq, st->out_mem, st->mdct_overlap, N, st->overlap, C);
513
514    for (c=0;c<C;c++)
515    {
516       int j;
517       for (j=0;j<N;j++)
518       {
519          celt_sig_t tmp = ADD32(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
520                                 MULT16_32_Q15(preemph,st->preemph_memD[c]));
521          st->preemph_memD[c] = tmp;
522          pcm[C*j+c] = SIG2INT16(tmp);
523       }
524    }
525    RESTORE_STACK;
526 }
527
528 int EXPORT celt_decode(CELTDecoder *st, unsigned char *data, int len, celt_int16_t *pcm)
529 {
530    int c, N, C, N4;
531    int has_pitch;
532    int pitch_index;
533    ec_dec dec;
534    ec_byte_buffer buf;
535    VARDECL(celt_sig_t, freq);
536    VARDECL(celt_norm_t, X);
537    VARDECL(celt_norm_t, P);
538    VARDECL(celt_ener_t, bandE);
539    VARDECL(celt_pgain_t, gains);
540    SAVE_STACK;
541
542    if (check_mode(st->mode) != CELT_OK)
543       return CELT_INVALID_MODE;
544
545    N = st->block_size;
546    C = st->mode->nbChannels;
547    N4 = (N-st->overlap)>>1;
548
549    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
550    ALLOC(X, C*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
551    ALLOC(P, C*N, celt_norm_t);         /**< Interleaved normalised pitch MDCTs*/
552    ALLOC(bandE, st->mode->nbEBands*C, celt_ener_t);
553    ALLOC(gains, st->mode->nbPBands, celt_pgain_t);
554    
555    if (check_mode(st->mode) != CELT_OK)
556    {
557       RESTORE_STACK;
558       return CELT_INVALID_MODE;
559    }
560    if (data == NULL)
561    {
562       celt_decode_lost(st, pcm);
563       RESTORE_STACK;
564       return 0;
565    }
566    
567    ec_byte_readinit(&buf,data,len);
568    ec_dec_init(&dec,&buf);
569    
570    /* Get band energies */
571    unquant_energy(st->mode, bandE, st->oldBandE, len*8/3, &dec);
572    
573    /* Get the pitch gains */
574    has_pitch = unquant_pitch(gains, st->mode->nbPBands, &dec);
575    
576    /* Get the pitch index */
577    if (has_pitch)
578    {
579       pitch_index = ec_dec_uint(&dec, MAX_PERIOD-(2*N-2*N4));
580       st->last_pitch_index = pitch_index;
581    } else {
582       /* FIXME: We could be more intelligent here and just not compute the MDCT */
583       pitch_index = 0;
584    }
585    
586    /* Pitch MDCT */
587    compute_mdcts(&st->mode->mdct, st->mode->window, st->out_mem+pitch_index*C, freq, N, st->overlap, C);
588
589    {
590       VARDECL(celt_ener_t, bandEp);
591       ALLOC(bandEp, st->mode->nbEBands*C, celt_ener_t);
592       compute_band_energies(st->mode, freq, bandEp);
593       normalise_bands(st->mode, freq, P, bandEp);
594    }
595
596    if (C==2)
597       stereo_mix(st->mode, P, bandE, 1);
598
599    /* Apply pitch gains */
600    pitch_quant_bands(st->mode, P, gains);
601
602    /* Decode fixed codebook and merge with pitch */
603    unquant_bands(st->mode, X, P, len*8, &dec);
604
605    if (C==2)
606    {
607       stereo_mix(st->mode, X, bandE, -1);
608       renormalise_bands(st->mode, X);
609    }
610    /* Synthesis */
611    denormalise_bands(st->mode, X, freq, bandE);
612
613
614    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD-N));
615    /* Compute inverse MDCTs */
616    compute_inv_mdcts(&st->mode->mdct, st->mode->window, freq, st->out_mem, st->mdct_overlap, N, st->overlap, C);
617
618    for (c=0;c<C;c++)
619    {
620       int j;
621       for (j=0;j<N;j++)
622       {
623          celt_sig_t tmp = ADD32(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
624                                 MULT16_32_Q15(preemph,st->preemph_memD[c]));
625          st->preemph_memD[c] = tmp;
626          pcm[C*j+c] = SIG2INT16(tmp);
627       }
628    }
629
630    {
631       unsigned int val = 0;
632       while (ec_dec_tell(&dec, 0) < len*8)
633       {
634          if (ec_dec_uint(&dec, 2) != val)
635          {
636             celt_warning("decode error");
637             RESTORE_STACK;
638             return CELT_CORRUPTED_DATA;
639          }
640          val = 1-val;
641       }
642    }
643
644    RESTORE_STACK;
645    return 0;
646    /*printf ("\n");*/
647 }
648