Doing intra-frame prediction backwards (and a few comments)
[opus.git] / libcelt / celt.c
1 /* (C) 2007 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 #include "os_support.h"
37 #include "mdct.h"
38 #include <math.h>
39 #include "celt.h"
40 #include "pitch.h"
41 #include "kiss_fftr.h"
42 #include "bands.h"
43 #include "modes.h"
44 #include "entcode.h"
45 #include "quant_pitch.h"
46 #include "quant_bands.h"
47 #include "psy.h"
48 #include "rate.h"
49
50 #define MAX_PERIOD 1024
51
52 #ifndef M_PI
53 #define M_PI 3.14159263
54 #endif
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 nb_blocks;
64    int overlap;
65    int channels;
66    
67    ec_byte_buffer buf;
68    ec_enc         enc;
69
70    float preemph;
71    float *preemph_memE;
72    float *preemph_memD;
73    
74    mdct_lookup mdct_lookup;
75    kiss_fftr_cfg fft;
76    struct PsyDecay psy;
77    
78    float *window;
79    float *in_mem;
80    float *mdct_overlap;
81    float *out_mem;
82
83    float *oldBandE;
84 };
85
86
87
88 CELTEncoder *celt_encoder_create(const CELTMode *mode)
89 {
90    int i, N, B, C, N4;
91    CELTEncoder *st;
92    N = mode->mdctSize;
93    B = mode->nbMdctBlocks;
94    C = mode->nbChannels;
95    st = celt_alloc(sizeof(CELTEncoder));
96    
97    st->mode = mode;
98    st->frame_size = B*N;
99    st->block_size = N;
100    st->nb_blocks  = B;
101    st->overlap = mode->overlap;
102
103    N4 = (N-st->overlap)/2;
104    ec_byte_writeinit(&st->buf);
105    ec_enc_init(&st->enc,&st->buf);
106
107    mdct_init(&st->mdct_lookup, 2*N);
108    st->fft = kiss_fftr_alloc(MAX_PERIOD*C, 0, 0);
109    psydecay_init(&st->psy, MAX_PERIOD*C/2, st->mode->Fs);
110    
111    st->window = celt_alloc(2*N*sizeof(float));
112    st->in_mem = celt_alloc(N*C*sizeof(float));
113    st->mdct_overlap = celt_alloc(N*C*sizeof(float));
114    st->out_mem = celt_alloc(MAX_PERIOD*C*sizeof(float));
115    for (i=0;i<2*N;i++)
116       st->window[i] = 0;
117    for (i=0;i<st->overlap;i++)
118       st->window[N4+i] = st->window[2*N-N4-i-1] 
119             = sin(.5*M_PI* sin(.5*M_PI*(i+.5)/st->overlap) * sin(.5*M_PI*(i+.5)/st->overlap));
120    for (i=0;i<2*N4;i++)
121       st->window[N-N4+i] = 1;
122    st->oldBandE = celt_alloc(C*mode->nbEBands*sizeof(float));
123
124    st->preemph = 0.8;
125    st->preemph_memE = celt_alloc(C*sizeof(float));;
126    st->preemph_memD = celt_alloc(C*sizeof(float));;
127
128    return st;
129 }
130
131 void celt_encoder_destroy(CELTEncoder *st)
132 {
133    if (st == NULL)
134    {
135       celt_warning("NULL passed to celt_encoder_destroy");
136       return;
137    }
138    ec_byte_writeclear(&st->buf);
139
140    mdct_clear(&st->mdct_lookup);
141    kiss_fft_free(st->fft);
142    psydecay_clear(&st->psy);
143
144    celt_free(st->window);
145    celt_free(st->in_mem);
146    celt_free(st->mdct_overlap);
147    celt_free(st->out_mem);
148    
149    celt_free(st->oldBandE);
150    
151    celt_free(st->preemph_memE);
152    celt_free(st->preemph_memD);
153    
154    celt_free(st);
155 }
156
157 /** Apply window and compute the MDCT for all sub-frames and all channels in a frame */
158 static float compute_mdcts(mdct_lookup *mdct_lookup, float *window, float *in, float *out, int N, int B, int C)
159 {
160    int i, c;
161    float E = 1e-15;
162    VARDECL(float *x);
163    VARDECL(float *tmp);
164    ALLOC(x, 2*N, float);
165    ALLOC(tmp, N, float);
166    for (c=0;c<C;c++)
167    {
168       for (i=0;i<B;i++)
169       {
170          int j;
171          for (j=0;j<2*N;j++)
172          {
173             x[j] = window[j]*in[C*i*N+C*j+c];
174             E += x[j]*x[j];
175          }
176          mdct_forward(mdct_lookup, x, tmp);
177          /* Interleaving the sub-frames */
178          for (j=0;j<N;j++)
179             out[C*B*j+C*i+c] = tmp[j];
180       }
181    }
182    return E;
183 }
184
185 /** Compute the IMDCT and apply window for all sub-frames and all channels in a frame */
186 static void compute_inv_mdcts(mdct_lookup *mdct_lookup, float *window, float *X, float *out_mem, float *mdct_overlap, int N, int overlap, int B, int C)
187 {
188    int i, c, N4;
189    VARDECL(float *x);
190    VARDECL(float *tmp);
191    ALLOC(x, 2*N, float);
192    ALLOC(tmp, N, float);
193    N4 = (N-overlap)/2;
194    for (c=0;c<C;c++)
195    {
196       for (i=0;i<B;i++)
197       {
198          int j;
199          /* De-interleaving the sub-frames */
200          for (j=0;j<N;j++)
201             tmp[j] = X[C*B*j+C*i+c];
202          mdct_backward(mdct_lookup, tmp, x);
203          for (j=0;j<2*N;j++)
204             x[j] = window[j]*x[j];
205          for (j=0;j<overlap;j++)
206             out_mem[C*(MAX_PERIOD+(i-B)*N)+C*j+c] = x[N4+j]+mdct_overlap[C*j+c];
207          for (j=0;j<2*N4;j++)
208             out_mem[C*(MAX_PERIOD+(i-B)*N)+C*(j+overlap)+c] = x[j+N4+overlap];
209          for (j=0;j<overlap;j++)
210             mdct_overlap[C*j+c] = x[N+N4+j];
211       }
212    }
213 }
214
215 int celt_encode(CELTEncoder *st, celt_int16_t *pcm, unsigned char *compressed, int nbCompressedBytes)
216 {
217    int i, c, N, B, C, N4;
218    int has_pitch;
219    int pitch_index;
220    float curr_power, pitch_power;
221    VARDECL(float *in);
222    VARDECL(float *X);
223    VARDECL(float *P);
224    VARDECL(float *mask);
225    VARDECL(float *bandE);
226    VARDECL(float *gains);
227    N = st->block_size;
228    B = st->nb_blocks;
229    C = st->mode->nbChannels;
230    ALLOC(in, (B+1)*C*N, float);
231    ALLOC(X, B*C*N, float);         /**< Interleaved signal MDCTs */
232    ALLOC(P, B*C*N, float);         /**< Interleaved pitch MDCTs*/
233    ALLOC(mask, B*C*N, float);      /**< Masking curve */
234    ALLOC(bandE,st->mode->nbEBands*C, float);
235    ALLOC(gains,st->mode->nbPBands, float);
236    
237    N4 = (N-st->overlap)/2;
238
239    for (c=0;c<C;c++)
240    {
241       for (i=0;i<N4;i++)
242          in[C*i+c] = 0;
243       for (i=0;i<st->overlap;i++)
244          in[C*(i+N4)+c] = st->in_mem[C*i+c];
245       for (i=0;i<B*N;i++)
246       {
247          float tmp = pcm[C*i+c];
248          in[C*(i+st->overlap+N4)+c] = tmp - st->preemph*st->preemph_memE[c];
249          st->preemph_memE[c] = tmp;
250       }
251       for (i=N*(B+1)-N4;i<N*(B+1);i++)
252          in[C*i+c] = 0;
253       for (i=0;i<st->overlap;i++)
254          st->in_mem[C*i+c] = in[C*(N*(B+1)-N4-st->overlap+i)+c];
255    }
256    /*for (i=0;i<(B+1)*C*N;i++) printf ("%f(%d) ", in[i], i); printf ("\n");*/
257    /* Compute MDCTs */
258    curr_power = compute_mdcts(&st->mdct_lookup, st->window, in, X, N, B, C);
259
260 #if 0 /* Mask disabled until it can be made to do something useful */
261    compute_mdct_masking(X, mask, B*C*N, st->Fs);
262
263    /* Invert and stretch the mask to length of X 
264       For some reason, I get better results by using the sqrt instead,
265       although there's no valid reason to. Must investigate further */
266    for (i=0;i<B*C*N;i++)
267       mask[i] = 1/(.1+mask[i]);
268 #else
269    for (i=0;i<B*C*N;i++)
270       mask[i] = 1;
271 #endif
272    /* Pitch analysis */
273    for (c=0;c<C;c++)
274    {
275       for (i=0;i<N;i++)
276       {
277          in[C*i+c] *= st->window[i];
278          in[C*(B*N+i)+c] *= st->window[N+i];
279       }
280    }
281    find_spectral_pitch(st->fft, &st->psy, in, st->out_mem, MAX_PERIOD, (B+1)*N, C, &pitch_index);
282    
283    /* Compute MDCTs of the pitch part */
284    pitch_power = compute_mdcts(&st->mdct_lookup, st->window, st->out_mem+pitch_index*C, P, N, B, C);
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, X, bandE);
296    normalise_bands(st->mode, 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    quant_energy(st->mode, bandE, st->oldBandE, nbCompressedBytes*8/3, &st->enc);
301
302    if (C==2)
303    {
304       stereo_mix(st->mode, X, bandE, 1);
305    }
306
307    /* Check if we can safely use the pitch (i.e. effective gain isn't too high) */
308    if (curr_power + 1e5f < 10.f*pitch_power)
309    {
310       /* Normalise the pitch vector as well (discard the energies) */
311       VARDECL(float *bandEp);
312       ALLOC(bandEp, st->mode->nbEBands*st->mode->nbChannels, float);
313       compute_band_energies(st->mode, P, bandEp);
314       normalise_bands(st->mode, P, bandEp);
315
316       if (C==2)
317          stereo_mix(st->mode, P, bandE, 1);
318       /* Simulates intensity stereo */
319       /*for (i=30;i<N*B;i++)
320          X[i*C+1] = P[i*C+1] = 0;*/
321
322       /* Pitch prediction */
323       compute_pitch_gain(st->mode, X, P, gains, bandE);
324       has_pitch = quant_pitch(gains, st->mode->nbPBands, &st->enc);
325       if (has_pitch)
326          ec_enc_uint(&st->enc, pitch_index, MAX_PERIOD-(B+1)*N);
327    } else {
328       /* No pitch, so we just pretend we found a gain of zero */
329       for (i=0;i<st->mode->nbPBands;i++)
330          gains[i] = 0;
331       ec_enc_uint(&st->enc, 0, 128);
332       for (i=0;i<B*C*N;i++)
333          P[i] = 0;
334    }
335    
336
337    pitch_quant_bands(st->mode, X, P, gains);
338
339    /*for (i=0;i<B*N;i++) printf("%f ",P[i]);printf("\n");*/
340    /* Compute residual that we're going to encode */
341    for (i=0;i<B*C*N;i++)
342       X[i] -= P[i];
343
344    /*float sum=0;
345    for (i=0;i<B*N;i++)
346       sum += X[i]*X[i];
347    printf ("%f\n", sum);*/
348    /* Residual quantisation */
349    quant_bands(st->mode, X, P, mask, nbCompressedBytes*8, &st->enc);
350    
351    if (C==2)
352       stereo_mix(st->mode, X, bandE, -1);
353
354    renormalise_bands(st->mode, X);
355    /* Synthesis */
356    denormalise_bands(st->mode, X, bandE);
357
358
359    CELT_MOVE(st->out_mem, st->out_mem+C*B*N, C*(MAX_PERIOD-B*N));
360
361    compute_inv_mdcts(&st->mdct_lookup, st->window, X, st->out_mem, st->mdct_overlap, N, st->overlap, B, C);
362    /* De-emphasis and put everything back at the right place in the synthesis history */
363    for (c=0;c<C;c++)
364    {
365       for (i=0;i<B;i++)
366       {
367          int j;
368          for (j=0;j<N;j++)
369          {
370             float tmp = st->out_mem[C*(MAX_PERIOD+(i-B)*N)+C*j+c] + st->preemph*st->preemph_memD[c];
371             st->preemph_memD[c] = tmp;
372             if (tmp > 32767) tmp = 32767;
373             if (tmp < -32767) tmp = -32767;
374             pcm[C*i*N+C*j+c] = (short)floor(.5+tmp);
375          }
376       }
377    }
378    
379    if (ec_enc_tell(&st->enc, 0) < nbCompressedBytes*8 - 7)
380       celt_warning_int ("many unused bits: ", nbCompressedBytes*8-ec_enc_tell(&st->enc, 0));
381    /*printf ("%d\n", ec_enc_tell(&st->enc, 0)-8*nbCompressedBytes);*/
382    /* Finishing the stream with a 0101... pattern so that the decoder can check is everything's right */
383    {
384       int val = 0;
385       while (ec_enc_tell(&st->enc, 0) < nbCompressedBytes*8)
386       {
387          ec_enc_uint(&st->enc, val, 2);
388          val = 1-val;
389       }
390    }
391    ec_enc_done(&st->enc);
392    {
393       unsigned char *data;
394       int nbBytes = ec_byte_bytes(&st->buf);
395       if (nbBytes > nbCompressedBytes)
396       {
397          celt_warning_int ("got too many bytes:", nbBytes);
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    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 nb_blocks;
430    int overlap;
431
432    ec_byte_buffer buf;
433    ec_enc         enc;
434
435    float preemph;
436    float *preemph_memD;
437    
438    mdct_lookup mdct_lookup;
439    
440    float *window;
441    float *mdct_overlap;
442    float *out_mem;
443
444    float *oldBandE;
445    
446    int last_pitch_index;
447 };
448
449 CELTDecoder *celt_decoder_create(const CELTMode *mode)
450 {
451    int i, N, B, C, N4;
452    CELTDecoder *st;
453    N = mode->mdctSize;
454    B = mode->nbMdctBlocks;
455    C = mode->nbChannels;
456    st = celt_alloc(sizeof(CELTDecoder));
457    
458    st->mode = mode;
459    st->frame_size = B*N;
460    st->block_size = N;
461    st->nb_blocks  = B;
462    st->overlap = mode->overlap;
463
464    N4 = (N-st->overlap)/2;
465    
466    mdct_init(&st->mdct_lookup, 2*N);
467    
468    st->window = celt_alloc(2*N*sizeof(float));
469    st->mdct_overlap = celt_alloc(N*C*sizeof(float));
470    st->out_mem = celt_alloc(MAX_PERIOD*C*sizeof(float));
471
472    for (i=0;i<2*N;i++)
473       st->window[i] = 0;
474    for (i=0;i<st->overlap;i++)
475       st->window[N4+i] = st->window[2*N-N4-i-1] 
476             = sin(.5*M_PI* sin(.5*M_PI*(i+.5)/st->overlap) * sin(.5*M_PI*(i+.5)/st->overlap));
477    for (i=0;i<2*N4;i++)
478       st->window[N-N4+i] = 1;
479    
480    st->oldBandE = celt_alloc(C*mode->nbEBands*sizeof(float));
481
482    st->preemph = 0.8;
483    st->preemph_memD = celt_alloc(C*sizeof(float));;
484
485    st->last_pitch_index = 0;
486    return st;
487 }
488
489 void celt_decoder_destroy(CELTDecoder *st)
490 {
491    if (st == NULL)
492    {
493       celt_warning("NULL passed to celt_encoder_destroy");
494       return;
495    }
496
497    mdct_clear(&st->mdct_lookup);
498
499    celt_free(st->window);
500    celt_free(st->mdct_overlap);
501    celt_free(st->out_mem);
502    
503    celt_free(st->oldBandE);
504    
505    celt_free(st->preemph_memD);
506
507    celt_free(st);
508 }
509
510 /** Handles lost packets by just copying past data with the same offset as the last
511     pitch period */
512 static void celt_decode_lost(CELTDecoder *st, short *pcm)
513 {
514    int i, c, N, B, C;
515    int pitch_index;
516    VARDECL(float *X);
517    N = st->block_size;
518    B = st->nb_blocks;
519    C = st->mode->nbChannels;
520    ALLOC(X,C*B*N, float);         /**< Interleaved signal MDCTs */
521    
522    pitch_index = st->last_pitch_index;
523    
524    /* Use the pitch MDCT as the "guessed" signal */
525    compute_mdcts(&st->mdct_lookup, st->window, st->out_mem+pitch_index*C, X, N, B, C);
526
527    CELT_MOVE(st->out_mem, st->out_mem+C*B*N, C*(MAX_PERIOD-B*N));
528    /* Compute inverse MDCTs */
529    compute_inv_mdcts(&st->mdct_lookup, st->window, X, st->out_mem, st->mdct_overlap, N, st->overlap, B, C);
530
531    for (c=0;c<C;c++)
532    {
533       for (i=0;i<B;i++)
534       {
535          int j;
536          for (j=0;j<N;j++)
537          {
538             float tmp = st->out_mem[C*(MAX_PERIOD+(i-B)*N)+C*j+c] + st->preemph*st->preemph_memD[c];
539             st->preemph_memD[c] = tmp;
540             if (tmp > 32767) tmp = 32767;
541             if (tmp < -32767) tmp = -32767;
542             pcm[C*i*N+C*j+c] = (short)floor(.5+tmp);
543          }
544       }
545    }
546 }
547
548 int celt_decode(CELTDecoder *st, unsigned char *data, int len, celt_int16_t *pcm)
549 {
550    int i, c, N, B, C;
551    int has_pitch;
552    int pitch_index;
553    ec_dec dec;
554    ec_byte_buffer buf;
555    VARDECL(float *X);
556    VARDECL(float *P);
557    VARDECL(float *bandE);
558    VARDECL(float *gains);
559    N = st->block_size;
560    B = st->nb_blocks;
561    C = st->mode->nbChannels;
562    
563    ALLOC(X, C*B*N, float);         /**< Interleaved signal MDCTs */
564    ALLOC(P, C*B*N, float);         /**< Interleaved pitch MDCTs*/
565    ALLOC(bandE, st->mode->nbEBands*C, float);
566    ALLOC(gains, st->mode->nbPBands, float);
567    
568    if (data == NULL)
569    {
570       celt_decode_lost(st, pcm);
571       return 0;
572    }
573    
574    ec_byte_readinit(&buf,data,len);
575    ec_dec_init(&dec,&buf);
576    
577    /* Get band energies */
578    unquant_energy(st->mode, bandE, st->oldBandE, len*8/3, &dec);
579    
580    /* Get the pitch gains */
581    has_pitch = unquant_pitch(gains, st->mode->nbPBands, &dec);
582    
583    /* Get the pitch index */
584    if (has_pitch)
585    {
586       pitch_index = ec_dec_uint(&dec, MAX_PERIOD-(B+1)*N);
587       st->last_pitch_index = pitch_index;
588    } else {
589       /* FIXME: We could be more intelligent here and just not compute the MDCT */
590       pitch_index = 0;
591    }
592    
593    /* Pitch MDCT */
594    compute_mdcts(&st->mdct_lookup, st->window, st->out_mem+pitch_index*C, P, N, B, C);
595
596    {
597       VARDECL(float *bandEp);
598       ALLOC(bandEp, st->mode->nbEBands*C, float);
599       compute_band_energies(st->mode, P, bandEp);
600       normalise_bands(st->mode, P, bandEp);
601    }
602
603    if (C==2)
604       stereo_mix(st->mode, P, bandE, 1);
605
606    /* Apply pitch gains */
607    pitch_quant_bands(st->mode, X, P, gains);
608
609    /* Decode fixed codebook and merge with pitch */
610    unquant_bands(st->mode, X, P, len*8, &dec);
611
612    if (C==2)
613       stereo_mix(st->mode, X, bandE, -1);
614
615    renormalise_bands(st->mode, X);
616    
617    /* Synthesis */
618    denormalise_bands(st->mode, X, bandE);
619
620
621    CELT_MOVE(st->out_mem, st->out_mem+C*B*N, C*(MAX_PERIOD-B*N));
622    /* Compute inverse MDCTs */
623    compute_inv_mdcts(&st->mdct_lookup, st->window, X, st->out_mem, st->mdct_overlap, N, st->overlap, B, C);
624
625    for (c=0;c<C;c++)
626    {
627       for (i=0;i<B;i++)
628       {
629          int j;
630          for (j=0;j<N;j++)
631          {
632             float tmp = st->out_mem[C*(MAX_PERIOD+(i-B)*N)+C*j+c] + st->preemph*st->preemph_memD[c];
633             st->preemph_memD[c] = tmp;
634             if (tmp > 32767) tmp = 32767;
635             if (tmp < -32767) tmp = -32767;
636             pcm[C*i*N+C*j+c] = (short)floor(.5+tmp);
637          }
638       }
639    }
640
641    {
642       int val = 0;
643       while (ec_dec_tell(&dec, 0) < len*8)
644       {
645          if (ec_dec_uint(&dec, 2) != val)
646          {
647             celt_warning("decode error");
648             return CELT_CORRUPTED_DATA;
649          }
650          val = 1-val;
651       }
652    }
653
654    return 0;
655    /*printf ("\n");*/
656 }
657