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