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