3ea92566bcde5e95aa21436fac108d7535a35658
[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 *out_mem;
76
77    celt_word16_t *oldBandE;
78 };
79
80 CELTEncoder EXPORT *celt_encoder_create(const CELTMode *mode)
81 {
82    int N, C;
83    CELTEncoder *st;
84
85    if (check_mode(mode) != CELT_OK)
86       return NULL;
87
88    N = mode->mdctSize;
89    C = mode->nbChannels;
90    st = celt_alloc(sizeof(CELTEncoder));
91    
92    st->mode = mode;
93    st->frame_size = N;
94    st->block_size = N;
95    st->overlap = mode->overlap;
96
97    ec_byte_writeinit(&st->buf);
98    ec_enc_init(&st->enc,&st->buf);
99
100    st->fft = pitch_state_alloc(MAX_PERIOD);
101    
102    st->in_mem = celt_alloc(st->overlap*C*sizeof(celt_sig_t));
103    st->out_mem = celt_alloc((MAX_PERIOD+st->overlap)*C*sizeof(celt_sig_t));
104
105    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
106
107    st->preemph_memE = (celt_word16_t*)celt_alloc(C*sizeof(celt_word16_t));;
108    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));;
109
110    return st;
111 }
112
113 void EXPORT celt_encoder_destroy(CELTEncoder *st)
114 {
115    if (st == NULL)
116    {
117       celt_warning("NULL passed to celt_encoder_destroy");
118       return;
119    }
120    if (check_mode(st->mode) != CELT_OK)
121       return;
122
123    ec_byte_writeclear(&st->buf);
124
125    pitch_state_free(st->fft);
126
127    celt_free(st->in_mem);
128    celt_free(st->out_mem);
129    
130    celt_free(st->oldBandE);
131    
132    celt_free(st->preemph_memE);
133    celt_free(st->preemph_memD);
134    
135    celt_free(st);
136 }
137
138 static inline celt_int16_t SIG2INT16(celt_sig_t x)
139 {
140    x = PSHR32(x, SIG_SHIFT);
141    x = MAX32(x, -32768);
142    x = MIN32(x, 32767);
143 #ifdef FIXED_POINT
144    return EXTRACT16(x);
145 #else
146    return (celt_int16_t)floor(.5+x);
147 #endif
148 }
149
150 /** Apply window and compute the MDCT for all sub-frames and all channels in a frame */
151 static void compute_mdcts(const CELTMode *mode, const celt_word16_t * restrict window, celt_sig_t * restrict in, celt_sig_t * restrict out)
152 {
153    const mdct_lookup *lookup = MDCT(mode);
154    const int N = FRAMESIZE(mode);
155    const int C = CHANNELS(mode);
156    const int overlap = OVERLAP(mode);
157    if (C==1)
158    {
159       mdct_forward(lookup, in, out, window, overlap);
160    } else {
161       int c;
162       VARDECL(celt_word32_t, x);
163       VARDECL(celt_word32_t, tmp);
164       SAVE_STACK;
165       ALLOC(x, N+overlap, celt_word32_t);
166       ALLOC(tmp, N, celt_word32_t);
167       for (c=0;c<C;c++)
168       {
169          int j;
170          for (j=0;j<N+overlap;j++)
171             x[j] = in[C*j+c];
172          mdct_forward(lookup, x, tmp, window, overlap);
173          /* Interleaving the sub-frames */
174          for (j=0;j<N;j++)
175             out[C*j+c] = tmp[j];
176       }
177       RESTORE_STACK;
178    }
179 }
180
181 /** Compute the IMDCT and apply window for all sub-frames and all channels in a frame */
182 static void compute_inv_mdcts(const CELTMode *mode, const celt_word16_t * restrict window, celt_sig_t *X, celt_sig_t * restrict out_mem)
183 {
184    int c, N4;
185    const int C = CHANNELS(mode);
186    const mdct_lookup *lookup = MDCT(mode);
187    const int N = FRAMESIZE(mode);
188    const int overlap = OVERLAP(mode);
189    N4 = (N-overlap)>>1;
190    for (c=0;c<C;c++)
191    {
192       int j;
193       if (C==1) {
194          mdct_backward(lookup, X, out_mem+C*(MAX_PERIOD-N-N4), window, overlap);
195       } else {
196          VARDECL(celt_word32_t, x);
197          VARDECL(celt_word32_t, tmp);
198          SAVE_STACK;
199          ALLOC(x, 2*N, celt_word32_t);
200          ALLOC(tmp, N, celt_word32_t);
201          /* De-interleaving the sub-frames */
202          for (j=0;j<N;j++)
203             tmp[j] = X[C*j+c];
204          /* Prevents problems from the imdct doing the overlap-add */
205          CELT_MEMSET(x+N4, 0, overlap);
206          mdct_backward(lookup, tmp, x, window, overlap);
207          /* The first and last part would need to be set to zero if we actually
208          wanted to use them. */
209          for (j=0;j<overlap;j++)
210             out_mem[C*(MAX_PERIOD-N)+C*j+c] += x[j+N4];
211          for (j=0;j<overlap;j++)
212             out_mem[C*(MAX_PERIOD)+C*(overlap-j-1)+c] = x[2*N-j-N4-1];
213          for (j=0;j<2*N4;j++)
214             out_mem[C*(MAX_PERIOD-N)+C*(j+overlap)+c] = x[j+N4+overlap];
215          RESTORE_STACK;
216       }
217    }
218 }
219
220 int EXPORT celt_encode(CELTEncoder * restrict st, celt_int16_t * restrict pcm, unsigned char *compressed, int nbCompressedBytes)
221 {
222    int i, c, N, N4;
223    int has_pitch;
224    int pitch_index;
225    celt_word32_t curr_power, pitch_power;
226    VARDECL(celt_sig_t, in);
227    VARDECL(celt_sig_t, freq);
228    VARDECL(celt_norm_t, X);
229    VARDECL(celt_norm_t, P);
230    VARDECL(celt_ener_t, bandE);
231    VARDECL(celt_pgain_t, gains);
232    const int C = CHANNELS(st->mode);
233    SAVE_STACK;
234
235    if (check_mode(st->mode) != CELT_OK)
236       return CELT_INVALID_MODE;
237
238    N = st->block_size;
239    N4 = (N-st->overlap)>>1;
240    ALLOC(in, 2*C*N-2*C*N4, celt_sig_t);
241
242    CELT_COPY(in, st->in_mem, C*st->overlap);
243    for (c=0;c<C;c++)
244    {
245       const celt_int16_t * restrict pcmp = pcm+c;
246       celt_sig_t * restrict inp = in+C*st->overlap+c;
247       for (i=0;i<N;i++)
248       {
249          /* Apply pre-emphasis */
250          celt_sig_t tmp = SHL32(EXTEND32(*pcmp), SIG_SHIFT);
251          *inp = SUB32(tmp, SHR32(MULT16_16(preemph,st->preemph_memE[c]),1));
252          st->preemph_memE[c] = *pcmp;
253          inp += C;
254          pcmp += 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->mode->prob, &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_bits(&st->enc, 0, 7);
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*st->mode->eBands[st->mode->nbEBands];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+st->overlap-N));
361
362    compute_inv_mdcts(st->mode, st->mode->window, freq, st->out_mem);
363    /* De-emphasis and put everything back at the right place in the synthesis history */
364 #ifndef SHORTCUTS
365    for (c=0;c<C;c++)
366    {
367       int j;
368       const celt_sig_t * restrict outp=st->out_mem+C*(MAX_PERIOD-N)+c;
369       celt_int16_t * restrict pcmp = pcm+c;
370       for (j=0;j<N;j++)
371       {
372          celt_sig_t tmp = ADD32(*outp, MULT16_32_Q15(preemph,st->preemph_memD[c]));
373          st->preemph_memD[c] = tmp;
374          *pcmp = SIG2INT16(tmp);
375          pcmp += C;
376          outp += C;
377       }
378    }
379 #endif
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 * restrict preemph_memD;
438
439    celt_sig_t *out_mem;
440
441    celt_word16_t *oldBandE;
442    
443    int last_pitch_index;
444 };
445
446 CELTDecoder EXPORT *celt_decoder_create(const CELTMode *mode)
447 {
448    int N, C;
449    CELTDecoder *st;
450
451    if (check_mode(mode) != CELT_OK)
452       return NULL;
453
454    N = mode->mdctSize;
455    C = CHANNELS(mode);
456    st = celt_alloc(sizeof(CELTDecoder));
457    
458    st->mode = mode;
459    st->frame_size = N;
460    st->block_size = N;
461    st->overlap = mode->overlap;
462
463    st->out_mem = celt_alloc((MAX_PERIOD+st->overlap)*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->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 * restrict st, short * restrict pcm)
496 {
497    int c, N;
498    int pitch_index;
499    VARDECL(celt_sig_t, freq);
500    const int C = CHANNELS(st->mode);
501    SAVE_STACK;
502    N = st->block_size;
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, st->mode->window, st->out_mem+pitch_index*C, freq);
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, st->mode->window, freq, st->out_mem);
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 * restrict st, unsigned char *data, int len, celt_int16_t * restrict pcm)
529 {
530    int c, N, 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    const int C = CHANNELS(st->mode);
541    SAVE_STACK;
542
543    if (check_mode(st->mode) != CELT_OK)
544       return CELT_INVALID_MODE;
545
546    N = st->block_size;
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, st->mode->prob, &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, st->mode->window, st->out_mem+pitch_index*C, freq);
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+st->overlap-N));
615    /* Compute inverse MDCTs */
616    compute_inv_mdcts(st->mode, st->mode->window, freq, st->out_mem);
617
618    for (c=0;c<C;c++)
619    {
620       int j;
621       const celt_sig_t * restrict outp=st->out_mem+C*(MAX_PERIOD-N)+c;
622       celt_int16_t * restrict pcmp = pcm+c;
623       for (j=0;j<N;j++)
624       {
625          celt_sig_t tmp = ADD32(*outp, MULT16_32_Q15(preemph,st->preemph_memD[c]));
626          st->preemph_memD[c] = tmp;
627          *pcmp = SIG2INT16(tmp);
628          pcmp += C;
629          outp += C;
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