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