Removed support for band-per-band stereo_mode that was never really used
[opus.git] / libcelt / celt.c
1 /* (C) 2007-2008 Jean-Marc Valin, CSIRO
2    (C) 2008 Gregory Maxwell */
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_bands.h"
48 #include "psy.h"
49 #include "rate.h"
50 #include "stack_alloc.h"
51 #include "mathops.h"
52 #include "float_cast.h"
53 #include <stdarg.h>
54
55 static const celt_word16_t preemph = QCONST16(0.8f,15);
56
57 #ifdef FIXED_POINT
58 static const celt_word16_t transientWindow[16] = {
59      279,  1106,  2454,  4276,  6510,  9081, 11900, 14872,
60    17896, 20868, 23687, 26258, 28492, 30314, 31662, 32489};
61 #else
62 static const float transientWindow[16] = {
63    0.0085135, 0.0337639, 0.0748914, 0.1304955, 0.1986827, 0.2771308, 0.3631685, 0.4538658,
64    0.5461342, 0.6368315, 0.7228692, 0.8013173, 0.8695045, 0.9251086, 0.9662361, 0.9914865};
65 #endif
66
67    
68 /** Encoder state 
69  @brief Encoder state
70  */
71 struct CELTEncoder {
72    const CELTMode *mode;     /**< Mode used by the encoder */
73    int frame_size;
74    int block_size;
75    int overlap;
76    int channels;
77    
78    int pitch_enabled;
79    int pitch_available;
80    int delayedIntra;
81    celt_word16_t tonal_average;
82    int fold_decision;
83
84    int VBR_rate; /* Target number of 16th bits per frame */
85    celt_word16_t * restrict preemph_memE; /* Input is 16-bit, so why bother with 32 */
86    celt_sig_t    * restrict preemph_memD;
87
88    celt_sig_t *in_mem;
89    celt_sig_t *out_mem;
90
91    celt_word16_t *oldBandE;
92 #ifdef EXP_PSY
93    celt_word16_t *psy_mem;
94    struct PsyDecay psy;
95 #endif
96 };
97
98 CELTEncoder *celt_encoder_create(const CELTMode *mode)
99 {
100    int N, C;
101    CELTEncoder *st;
102
103    if (check_mode(mode) != CELT_OK)
104       return NULL;
105
106    N = mode->mdctSize;
107    C = mode->nbChannels;
108    st = celt_alloc(sizeof(CELTEncoder));
109    
110    st->mode = mode;
111    st->frame_size = N;
112    st->block_size = N;
113    st->overlap = mode->overlap;
114
115    st->VBR_rate = 0;
116    st->pitch_enabled = 1;
117    st->pitch_available = 1;
118    st->delayedIntra = 1;
119    st->tonal_average = QCONST16(1.,8);
120    st->fold_decision = 1;
121
122    st->in_mem = celt_alloc(st->overlap*C*sizeof(celt_sig_t));
123    st->out_mem = celt_alloc((MAX_PERIOD+st->overlap)*C*sizeof(celt_sig_t));
124
125    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
126
127    st->preemph_memE = (celt_word16_t*)celt_alloc(C*sizeof(celt_word16_t));
128    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));
129
130 #ifdef EXP_PSY
131    st->psy_mem = celt_alloc(MAX_PERIOD*sizeof(celt_word16_t));
132    psydecay_init(&st->psy, MAX_PERIOD/2, st->mode->Fs);
133 #endif
134
135    return st;
136 }
137
138 void celt_encoder_destroy(CELTEncoder *st)
139 {
140    if (st == NULL)
141    {
142       celt_warning("NULL passed to celt_encoder_destroy");
143       return;
144    }
145    if (check_mode(st->mode) != CELT_OK)
146       return;
147
148    celt_free(st->in_mem);
149    celt_free(st->out_mem);
150    
151    celt_free(st->oldBandE);
152    
153    celt_free(st->preemph_memE);
154    celt_free(st->preemph_memD);
155    
156 #ifdef EXP_PSY
157    celt_free (st->psy_mem);
158    psydecay_clear(&st->psy);
159 #endif
160    
161    celt_free(st);
162 }
163
164 static inline celt_int16_t FLOAT2INT16(float x)
165 {
166    x = x*CELT_SIG_SCALE;
167    x = MAX32(x, -32768);
168    x = MIN32(x, 32767);
169    return (celt_int16_t)float2int(x);
170 }
171
172 static inline celt_word16_t SIG2WORD16(celt_sig_t x)
173 {
174 #ifdef FIXED_POINT
175    x = PSHR32(x, SIG_SHIFT);
176    x = MAX32(x, -32768);
177    x = MIN32(x, 32767);
178    return EXTRACT16(x);
179 #else
180    return (celt_word16_t)x;
181 #endif
182 }
183
184 static int transient_analysis(celt_word32_t *in, int len, int C, int *transient_time, int *transient_shift)
185 {
186    int c, i, n;
187    celt_word32_t ratio;
188    /* FIXME: Remove the floats here */
189    VARDECL(celt_word32_t, begin);
190    SAVE_STACK;
191    ALLOC(begin, len, celt_word32_t);
192    for (i=0;i<len;i++)
193       begin[i] = ABS32(SHR32(in[C*i],SIG_SHIFT));
194    for (c=1;c<C;c++)
195    {
196       for (i=0;i<len;i++)
197          begin[i] = MAX32(begin[i], ABS32(SHR32(in[C*i+c],SIG_SHIFT)));
198    }
199    for (i=1;i<len;i++)
200       begin[i] = MAX32(begin[i-1],begin[i]);
201    n = -1;
202    for (i=8;i<len-8;i++)
203    {
204       if (begin[i] < MULT16_32_Q15(QCONST16(.2f,15),begin[len-1]))
205          n=i;
206    }
207    if (n<32)
208    {
209       n = -1;
210       ratio = 0;
211    } else {
212       ratio = DIV32(begin[len-1],1+begin[n-16]);
213    }
214    /*printf ("%d %f\n", n, ratio*ratio);*/
215    if (ratio < 0)
216       ratio = 0;
217    if (ratio > 1000)
218       ratio = 1000;
219    ratio *= ratio;
220    
221    if (ratio > 2048)
222       *transient_shift = 3;
223    else
224       *transient_shift = 0;
225    
226    *transient_time = n;
227    
228    RESTORE_STACK;
229    return ratio > 20;
230 }
231
232 /** Apply window and compute the MDCT for all sub-frames and all channels in a frame */
233 static void compute_mdcts(const CELTMode *mode, int shortBlocks, celt_sig_t * restrict in, celt_sig_t * restrict out)
234 {
235    const int C = CHANNELS(mode);
236    if (C==1 && !shortBlocks)
237    {
238       const mdct_lookup *lookup = MDCT(mode);
239       const int overlap = OVERLAP(mode);
240       mdct_forward(lookup, in, out, mode->window, overlap);
241    } else if (!shortBlocks) {
242       const mdct_lookup *lookup = MDCT(mode);
243       const int overlap = OVERLAP(mode);
244       const int N = FRAMESIZE(mode);
245       int c;
246       VARDECL(celt_word32_t, x);
247       VARDECL(celt_word32_t, tmp);
248       SAVE_STACK;
249       ALLOC(x, N+overlap, celt_word32_t);
250       ALLOC(tmp, N, celt_word32_t);
251       for (c=0;c<C;c++)
252       {
253          int j;
254          for (j=0;j<N+overlap;j++)
255             x[j] = in[C*j+c];
256          mdct_forward(lookup, x, tmp, mode->window, overlap);
257          /* Interleaving the sub-frames */
258          for (j=0;j<N;j++)
259             out[C*j+c] = tmp[j];
260       }
261       RESTORE_STACK;
262    } else {
263       const mdct_lookup *lookup = &mode->shortMdct;
264       const int overlap = mode->overlap;
265       const int N = mode->shortMdctSize;
266       int b, c;
267       VARDECL(celt_word32_t, x);
268       VARDECL(celt_word32_t, tmp);
269       SAVE_STACK;
270       ALLOC(x, N+overlap, celt_word32_t);
271       ALLOC(tmp, N, celt_word32_t);
272       for (c=0;c<C;c++)
273       {
274          int B = mode->nbShortMdcts;
275          for (b=0;b<B;b++)
276          {
277             int j;
278             for (j=0;j<N+overlap;j++)
279                x[j] = in[C*(b*N+j)+c];
280             mdct_forward(lookup, x, tmp, mode->window, overlap);
281             /* Interleaving the sub-frames */
282             for (j=0;j<N;j++)
283                out[C*(j*B+b)+c] = tmp[j];
284          }
285       }
286       RESTORE_STACK;
287    }
288 }
289
290 /** Compute the IMDCT and apply window for all sub-frames and all channels in a frame */
291 static void compute_inv_mdcts(const CELTMode *mode, int shortBlocks, celt_sig_t *X, int transient_time, int transient_shift, celt_sig_t * restrict out_mem)
292 {
293    int c, N4;
294    const int C = CHANNELS(mode);
295    const int N = FRAMESIZE(mode);
296    const int overlap = OVERLAP(mode);
297    N4 = (N-overlap)>>1;
298    for (c=0;c<C;c++)
299    {
300       int j;
301       if (transient_shift==0 && C==1 && !shortBlocks) {
302          const mdct_lookup *lookup = MDCT(mode);
303          mdct_backward(lookup, X, out_mem+C*(MAX_PERIOD-N-N4), mode->window, overlap);
304       } else if (!shortBlocks) {
305          const mdct_lookup *lookup = MDCT(mode);
306          VARDECL(celt_word32_t, x);
307          VARDECL(celt_word32_t, tmp);
308          SAVE_STACK;
309          ALLOC(x, 2*N, celt_word32_t);
310          ALLOC(tmp, N, celt_word32_t);
311          /* De-interleaving the sub-frames */
312          for (j=0;j<N;j++)
313             tmp[j] = X[C*j+c];
314          /* Prevents problems from the imdct doing the overlap-add */
315          CELT_MEMSET(x+N4, 0, N);
316          mdct_backward(lookup, tmp, x, mode->window, overlap);
317          celt_assert(transient_shift == 0);
318          /* The first and last part would need to be set to zero if we actually
319             wanted to use them. */
320          for (j=0;j<overlap;j++)
321             out_mem[C*(MAX_PERIOD-N)+C*j+c] += x[j+N4];
322          for (j=0;j<overlap;j++)
323             out_mem[C*(MAX_PERIOD)+C*(overlap-j-1)+c] = x[2*N-j-N4-1];
324          for (j=0;j<2*N4;j++)
325             out_mem[C*(MAX_PERIOD-N)+C*(j+overlap)+c] = x[j+N4+overlap];
326          RESTORE_STACK;
327       } else {
328          int b;
329          const int N2 = mode->shortMdctSize;
330          const int B = mode->nbShortMdcts;
331          const mdct_lookup *lookup = &mode->shortMdct;
332          VARDECL(celt_word32_t, x);
333          VARDECL(celt_word32_t, tmp);
334          SAVE_STACK;
335          ALLOC(x, 2*N, celt_word32_t);
336          ALLOC(tmp, N, celt_word32_t);
337          /* Prevents problems from the imdct doing the overlap-add */
338          CELT_MEMSET(x+N4, 0, N2);
339          for (b=0;b<B;b++)
340          {
341             /* De-interleaving the sub-frames */
342             for (j=0;j<N2;j++)
343                tmp[j] = X[C*(j*B+b)+c];
344             mdct_backward(lookup, tmp, x+N4+N2*b, mode->window, overlap);
345          }
346          if (transient_shift > 0)
347          {
348 #ifdef FIXED_POINT
349             for (j=0;j<16;j++)
350                x[N4+transient_time+j-16] = MULT16_32_Q15(SHR16(Q15_ONE-transientWindow[j],transient_shift)+transientWindow[j], SHL32(x[N4+transient_time+j-16],transient_shift));
351             for (j=transient_time;j<N+overlap;j++)
352                x[N4+j] = SHL32(x[N4+j], transient_shift);
353 #else
354             for (j=0;j<16;j++)
355                x[N4+transient_time+j-16] *= 1+transientWindow[j]*((1<<transient_shift)-1);
356             for (j=transient_time;j<N+overlap;j++)
357                x[N4+j] *= 1<<transient_shift;
358 #endif
359          }
360          /* The first and last part would need to be set to zero if we actually
361          wanted to use them. */
362          for (j=0;j<overlap;j++)
363             out_mem[C*(MAX_PERIOD-N)+C*j+c] += x[j+N4];
364          for (j=0;j<overlap;j++)
365             out_mem[C*(MAX_PERIOD)+C*(overlap-j-1)+c] = x[2*N-j-N4-1];
366          for (j=0;j<2*N4;j++)
367             out_mem[C*(MAX_PERIOD-N)+C*(j+overlap)+c] = x[j+N4+overlap];
368          RESTORE_STACK;
369       }
370    }
371 }
372
373 #define FLAG_NONE        0
374 #define FLAG_INTRA       1U<<16
375 #define FLAG_PITCH       1U<<15
376 #define FLAG_SHORT       1U<<14
377 #define FLAG_FOLD        1U<<13
378 #define FLAG_MASK        (FLAG_INTRA|FLAG_PITCH|FLAG_SHORT|FLAG_FOLD)
379
380 celt_int32_t flaglist[8] = {
381       0 /*00  */ | FLAG_FOLD,
382       1 /*01  */ | FLAG_PITCH|FLAG_FOLD,
383       8 /*1000*/ | FLAG_NONE,
384       9 /*1001*/ | FLAG_SHORT|FLAG_FOLD,
385      10 /*1010*/ | FLAG_PITCH,
386      11 /*1011*/ | FLAG_INTRA,
387       6 /*110 */ | FLAG_INTRA|FLAG_FOLD,
388       7 /*111 */ | FLAG_INTRA|FLAG_SHORT|FLAG_FOLD
389 };
390
391 void encode_flags(ec_enc *enc, int intra_ener, int has_pitch, int shortBlocks, int has_fold)
392 {
393    int i;
394    int flags=FLAG_NONE;
395    int flag_bits;
396    flags |= intra_ener   ? FLAG_INTRA : 0;
397    flags |= has_pitch    ? FLAG_PITCH : 0;
398    flags |= shortBlocks  ? FLAG_SHORT : 0;
399    flags |= has_fold     ? FLAG_FOLD  : 0;
400    for (i=0;i<8;i++)
401       if (flags == (flaglist[i]&FLAG_MASK))
402          break;
403    celt_assert(i<8);
404    flag_bits = flaglist[i]&0xf;
405    /*printf ("enc %d: %d %d %d %d\n", flag_bits, intra_ener, has_pitch, shortBlocks, has_fold);*/
406    if (i<2)
407       ec_enc_bits(enc, flag_bits, 2);
408    else if (i<6)
409       ec_enc_bits(enc, flag_bits, 4);
410    else
411       ec_enc_bits(enc, flag_bits, 3);
412 }
413
414 void decode_flags(ec_dec *dec, int *intra_ener, int *has_pitch, int *shortBlocks, int *has_fold)
415 {
416    int i;
417    int flag_bits;
418    flag_bits = ec_dec_bits(dec, 2);
419    /*printf ("(%d) ", flag_bits);*/
420    if (flag_bits==2)
421       flag_bits = (flag_bits<<2) | ec_dec_bits(dec, 2);
422    else if (flag_bits==3)
423       flag_bits = (flag_bits<<1) | ec_dec_bits(dec, 1);
424    for (i=0;i<8;i++)
425       if (flag_bits == (flaglist[i]&0xf))
426          break;
427    celt_assert(i<8);
428    *intra_ener  = (flaglist[i]&FLAG_INTRA) != 0;
429    *has_pitch   = (flaglist[i]&FLAG_PITCH) != 0;
430    *shortBlocks = (flaglist[i]&FLAG_SHORT) != 0;
431    *has_fold    = (flaglist[i]&FLAG_FOLD ) != 0;
432    /*printf ("dec %d: %d %d %d %d\n", flag_bits, *intra_ener, *has_pitch, *shortBlocks, *has_fold);*/
433 }
434
435 #ifdef FIXED_POINT
436 int celt_encode(CELTEncoder * restrict st, const celt_int16_t * pcm, celt_int16_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
437 {
438 #else
439 int celt_encode_float(CELTEncoder * restrict st, const celt_sig_t * pcm, celt_sig_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
440 {
441 #endif
442    int i, c, N, N4;
443    int has_pitch;
444    int pitch_index;
445    int bits;
446    int has_fold=1;
447    unsigned coarse_needed;
448    ec_byte_buffer buf;
449    ec_enc         enc;
450    VARDECL(celt_sig_t, in);
451    VARDECL(celt_sig_t, freq);
452    VARDECL(celt_norm_t, X);
453    VARDECL(celt_norm_t, P);
454    VARDECL(celt_ener_t, bandE);
455    VARDECL(celt_pgain_t, gains);
456    VARDECL(int, fine_quant);
457    VARDECL(celt_word16_t, error);
458    VARDECL(int, pulses);
459    VARDECL(int, offsets);
460 #ifdef EXP_PSY
461    VARDECL(celt_word32_t, mask);
462    VARDECL(celt_word32_t, tonality);
463    VARDECL(celt_word32_t, bandM);
464    VARDECL(celt_ener_t, bandN);
465 #endif
466    int intra_ener = 0;
467    int shortBlocks=0;
468    int transient_time;
469    int transient_shift;
470    const int C = CHANNELS(st->mode);
471    int mdct_weight_shift = 0;
472    int mdct_weight_pos=0;
473    SAVE_STACK;
474
475    if (check_mode(st->mode) != CELT_OK)
476       return CELT_INVALID_MODE;
477
478    if (nbCompressedBytes<0)
479      return CELT_BAD_ARG; 
480
481    /* The memset is important for now in case the encoder doesn't fill up all the bytes */
482    CELT_MEMSET(compressed, 0, nbCompressedBytes);
483    ec_byte_writeinit_buffer(&buf, compressed, nbCompressedBytes);
484    ec_enc_init(&enc,&buf);
485
486    N = st->block_size;
487    N4 = (N-st->overlap)>>1;
488    ALLOC(in, 2*C*N-2*C*N4, celt_sig_t);
489
490    CELT_COPY(in, st->in_mem, C*st->overlap);
491    for (c=0;c<C;c++)
492    {
493       const celt_word16_t * restrict pcmp = pcm+c;
494       celt_sig_t * restrict inp = in+C*st->overlap+c;
495       for (i=0;i<N;i++)
496       {
497          /* Apply pre-emphasis */
498          celt_sig_t tmp = SCALEIN(SHL32(EXTEND32(*pcmp), SIG_SHIFT));
499          *inp = SUB32(tmp, SHR32(MULT16_16(preemph,st->preemph_memE[c]),3));
500          st->preemph_memE[c] = SCALEIN(*pcmp);
501          inp += C;
502          pcmp += C;
503       }
504    }
505    CELT_COPY(st->in_mem, in+C*(2*N-2*N4-st->overlap), C*st->overlap);
506    
507    /* Transient handling */
508    if (st->mode->nbShortMdcts > 1)
509    {
510       if (transient_analysis(in, N+st->overlap, C, &transient_time, &transient_shift))
511       {
512 #ifndef FIXED_POINT
513          float gain_1;
514 #endif
515          /* Apply the inverse shaping window */
516          if (transient_shift)
517          {
518 #ifdef FIXED_POINT
519             for (c=0;c<C;c++)
520                for (i=0;i<16;i++)
521                   in[C*(transient_time+i-16)+c] = MULT16_32_Q15(EXTRACT16(SHR32(celt_rcp(Q15ONE+MULT16_16(transientWindow[i],((1<<transient_shift)-1))),1)), in[C*(transient_time+i-16)+c]);
522             for (c=0;c<C;c++)
523                for (i=transient_time;i<N+st->overlap;i++)
524                   in[C*i+c] = SHR32(in[C*i+c], transient_shift);
525 #else
526             for (c=0;c<C;c++)
527                for (i=0;i<16;i++)
528                   in[C*(transient_time+i-16)+c] /= 1+transientWindow[i]*((1<<transient_shift)-1);
529             gain_1 = 1./(1<<transient_shift);
530             for (c=0;c<C;c++)
531                for (i=transient_time;i<N+st->overlap;i++)
532                   in[C*i+c] *= gain_1;
533 #endif
534          }
535          shortBlocks = 1;
536          has_fold = 1;
537       } else {
538          transient_time = -1;
539          transient_shift = 0;
540          shortBlocks = 0;
541       }
542    } else {
543       transient_time = -1;
544       transient_shift = 0;
545       shortBlocks = 0;
546    }
547
548    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
549    ALLOC(bandE,st->mode->nbEBands*C, celt_ener_t);
550    /* Compute MDCTs */
551    compute_mdcts(st->mode, shortBlocks, in, freq);
552    if (shortBlocks && !transient_shift) 
553    {
554       celt_word32_t sum[4]={1,1,1,1};
555       int m;
556       for (c=0;c<C;c++)
557       {
558          m=0;
559          do {
560             celt_word32_t tmp=0;
561             for (i=m*C+c;i<N;i+=C*st->mode->nbShortMdcts)
562                tmp += ABS32(freq[i]);
563             sum[m++] += tmp;
564          } while (m<st->mode->nbShortMdcts);
565       }
566       m=0;
567 #ifdef FIXED_POINT
568       do {
569          if (SHR32(sum[m+1],3) > sum[m])
570          {
571             mdct_weight_shift=2;
572             mdct_weight_pos = m;
573          } else if (SHR32(sum[m+1],1) > sum[m] && mdct_weight_shift < 2)
574          {
575             mdct_weight_shift=1;
576             mdct_weight_pos = m;
577          }
578          m++;
579       } while (m<st->mode->nbShortMdcts-1);
580       if (mdct_weight_shift)
581       {
582          for (c=0;c<C;c++)
583             for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
584                for (i=m*C+c;i<N;i+=C*st->mode->nbShortMdcts)
585                   freq[i] = SHR32(freq[i],mdct_weight_shift);
586       }
587 #else
588       do {
589          if (sum[m+1] > 8*sum[m])
590          {
591             mdct_weight_shift=2;
592             mdct_weight_pos = m;
593          } else if (sum[m+1] > 2*sum[m] && mdct_weight_shift < 2)
594          {
595             mdct_weight_shift=1;
596             mdct_weight_pos = m;
597          }
598          m++;
599       } while (m<st->mode->nbShortMdcts-1);
600       if (mdct_weight_shift)
601       {
602          for (c=0;c<C;c++)
603             for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
604                for (i=m*C+c;i<N;i+=C*st->mode->nbShortMdcts)
605                   freq[i] = (1./(1<<mdct_weight_shift))*freq[i];
606       }
607 #endif
608       /*printf ("%f\n", short_ratio);*/
609       /*if (short_ratio < 1)
610          short_ratio = 1;
611       short_ratio = 1<<(int)floor(.5+log2(short_ratio));
612       if (short_ratio>4)
613          short_ratio = 4;*/
614    }/* else if (transient_shift)
615       printf ("8\n");
616       else printf ("1\n");*/
617
618    compute_band_energies(st->mode, freq, bandE);
619
620    intra_ener = st->delayedIntra;
621    if (intra_decision(bandE, st->oldBandE, st->mode->nbEBands) || shortBlocks)
622       st->delayedIntra = 1;
623    else
624       st->delayedIntra = 0;
625    /* Pitch analysis: we do it early to save on the peak stack space */
626    /* Don't use pitch if there isn't enough data available yet, or if we're using shortBlocks */
627    has_pitch = st->pitch_enabled && (st->pitch_available >= MAX_PERIOD) && (!shortBlocks) && !intra_ener;
628 #ifdef EXP_PSY
629    ALLOC(tonality, MAX_PERIOD/4, celt_word16_t);
630    {
631       VARDECL(celt_word16_t, X);
632       ALLOC(X, MAX_PERIOD/2, celt_word16_t);
633       find_spectral_pitch(st->mode, st->mode->fft, &st->mode->psy, in, st->out_mem, st->mode->window, X, 2*N-2*N4, MAX_PERIOD-(2*N-2*N4), &pitch_index);
634       compute_tonality(st->mode, X, st->psy_mem, MAX_PERIOD, tonality, MAX_PERIOD/4);
635    }
636 #else
637    if (has_pitch)
638    {
639       find_spectral_pitch(st->mode, st->mode->fft, &st->mode->psy, in, st->out_mem, st->mode->window, NULL, 2*N-2*N4, MAX_PERIOD-(2*N-2*N4), &pitch_index);
640    }
641 #endif
642
643 #ifdef EXP_PSY
644    ALLOC(mask, N, celt_sig_t);
645    compute_mdct_masking(&st->psy, freq, tonality, st->psy_mem, mask, C*N);
646    /*for (i=0;i<256;i++)
647       printf ("%f %f %f ", freq[i], tonality[i], mask[i]);
648    printf ("\n");*/
649 #endif
650
651    /* Deferred allocation after find_spectral_pitch() to reduce the peak memory usage */
652    ALLOC(X, C*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
653    ALLOC(P, C*N, celt_norm_t);         /**< Interleaved normalised pitch MDCTs*/
654    ALLOC(gains,st->mode->nbPBands, celt_pgain_t);
655
656
657    /* Band normalisation */
658    normalise_bands(st->mode, freq, X, bandE);
659    if (!shortBlocks && !folding_decision(st->mode, X, &st->tonal_average, &st->fold_decision))
660       has_fold = 0;
661 #ifdef EXP_PSY
662    ALLOC(bandN,C*st->mode->nbEBands, celt_ener_t);
663    ALLOC(bandM,st->mode->nbEBands, celt_ener_t);
664    compute_noise_energies(st->mode, freq, tonality, bandN);
665
666    /*for (i=0;i<st->mode->nbEBands;i++)
667       printf ("%f ", (.1+bandN[i])/(.1+bandE[i]));
668    printf ("\n");*/
669    has_fold = 0;
670    for (i=st->mode->nbPBands;i<st->mode->nbEBands;i++)
671       if (bandN[i] < .4*bandE[i])
672          has_fold++;
673    /*printf ("%d\n", has_fold);*/
674    if (has_fold>=2)
675       has_fold = 0;
676    else
677       has_fold = 1;
678    for (i=0;i<N;i++)
679       mask[i] = sqrt(mask[i]);
680    compute_band_energies(st->mode, mask, bandM);
681    /*for (i=0;i<st->mode->nbEBands;i++)
682       printf ("%f %f ", bandE[i], bandM[i]);
683    printf ("\n");*/
684 #endif
685
686    /* Compute MDCTs of the pitch part */
687    if (has_pitch)
688    {
689       celt_word32_t curr_power, pitch_power=0;
690       /* Normalise the pitch vector as well (discard the energies) */
691       VARDECL(celt_ener_t, bandEp);
692       
693       compute_mdcts(st->mode, 0, st->out_mem+pitch_index*C, freq);
694       ALLOC(bandEp, st->mode->nbEBands*st->mode->nbChannels, celt_ener_t);
695       compute_band_energies(st->mode, freq, bandEp);
696       normalise_bands(st->mode, freq, P, bandEp);
697       pitch_power = bandEp[0]+bandEp[1]+bandEp[2];
698       /* Check if we can safely use the pitch (i.e. effective gain isn't too high) */
699       curr_power = bandE[0]+bandE[1]+bandE[2];
700       if ((MULT16_32_Q15(QCONST16(.1f, 15),curr_power) + QCONST32(10.f,ENER_SHIFT) < pitch_power))
701       {
702          /* Pitch prediction */
703          has_pitch = compute_pitch_gain(st->mode, X, P, gains);
704       } else {
705          has_pitch = 0;
706       }
707    }
708    
709    encode_flags(&enc, intra_ener, has_pitch, shortBlocks, has_fold);
710    if (has_pitch)
711    {
712       ec_enc_uint(&enc, pitch_index, MAX_PERIOD-(2*N-2*N4));
713    } else {
714       for (i=0;i<st->mode->nbPBands;i++)
715          gains[i] = 0;
716       for (i=0;i<C*N;i++)
717          P[i] = 0;
718    }
719    if (shortBlocks)
720    {
721       if (transient_shift)
722       {
723          ec_enc_bits(&enc, transient_shift, 2);
724          ec_enc_uint(&enc, transient_time, N+st->overlap);
725       } else {
726          ec_enc_bits(&enc, mdct_weight_shift, 2);
727          if (mdct_weight_shift && st->mode->nbShortMdcts!=2)
728             ec_enc_uint(&enc, mdct_weight_pos, st->mode->nbShortMdcts-1);
729       }
730    }
731
732 #ifdef STDIN_TUNING2
733    static int fine_quant[30];
734    static int pulses[30];
735    static int init=0;
736    if (!init)
737    {
738       for (i=0;i<st->mode->nbEBands;i++)
739          scanf("%d ", &fine_quant[i]);
740       for (i=0;i<st->mode->nbEBands;i++)
741          scanf("%d ", &pulses[i]);
742       init = 1;
743    }
744 #else
745    ALLOC(fine_quant, st->mode->nbEBands, int);
746    ALLOC(pulses, st->mode->nbEBands, int);
747 #endif
748
749    /* Bit allocation */
750    ALLOC(error, C*st->mode->nbEBands, celt_word16_t);
751    coarse_needed = quant_coarse_energy(st->mode, bandE, st->oldBandE, nbCompressedBytes*8/3, intra_ener, st->mode->prob, error, &enc);
752    coarse_needed = ((coarse_needed*3-1)>>3)+1;
753
754    /* Variable bitrate */
755    if (st->VBR_rate>0)
756    {
757      /* The target rate in 16th bits per frame */
758      int target=st->VBR_rate;
759    
760      /* Shortblocks get a large boost in bitrate, but since they are uncommon long blocks are not greatly effected */
761      if (shortBlocks)
762        target*=2;
763      else if (st->mode->nbShortMdcts > 1)
764        target-=(target+14)/28;     
765
766      /*The average energy is removed from the target and the actual energy added*/
767      target=target-588+ec_enc_tell(&enc, 4);
768
769      /* In VBR mode the frame size must not be reduced so much that it would result in the coarse energy busting its budget */
770      target=IMAX(coarse_needed,(target+64)/128);
771      nbCompressedBytes=IMIN(nbCompressedBytes,target);
772    }
773
774    ALLOC(offsets, st->mode->nbEBands, int);
775
776    for (i=0;i<st->mode->nbEBands;i++)
777       offsets[i] = 0;
778    bits = nbCompressedBytes*8 - ec_enc_tell(&enc, 0) - 1;
779    if (has_pitch)
780       bits -= st->mode->nbPBands;
781 #ifndef STDIN_TUNING
782    compute_allocation(st->mode, offsets, bits, pulses, fine_quant);
783 #endif
784
785    quant_fine_energy(st->mode, bandE, st->oldBandE, error, fine_quant, &enc);
786
787    /* Residual quantisation */
788    if (C==1)
789       quant_bands(st->mode, X, P, NULL, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, &enc);
790 #ifndef DISABLE_STEREO
791    else
792       quant_bands_stereo(st->mode, X, P, NULL, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, &enc);
793 #endif
794    /* Re-synthesis of the coded audio if required */
795    if (st->pitch_available>0 || optional_synthesis!=NULL)
796    {
797       if (st->pitch_available>0 && st->pitch_available<MAX_PERIOD)
798         st->pitch_available+=st->frame_size;
799
800       /* Synthesis */
801       denormalise_bands(st->mode, X, freq, bandE);
802       
803       
804       CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->overlap-N));
805       
806       if (mdct_weight_shift)
807       {
808          int m;
809          for (c=0;c<C;c++)
810             for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
811                for (i=m*C+c;i<N;i+=C*st->mode->nbShortMdcts)
812 #ifdef FIXED_POINT
813                   freq[i] = SHL32(freq[i], mdct_weight_shift);
814 #else
815                   freq[i] = (1<<mdct_weight_shift)*freq[i];
816 #endif
817       }
818       compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem);
819       /* De-emphasis and put everything back at the right place in the synthesis history */
820       if (optional_synthesis != NULL) {
821          for (c=0;c<C;c++)
822          {
823             int j;
824             for (j=0;j<N;j++)
825             {
826                celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
827                                    preemph,st->preemph_memD[c]);
828                st->preemph_memD[c] = tmp;
829                optional_synthesis[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
830             }
831          }
832       }
833    }
834
835    /*fprintf (stderr, "remaining bits after encode = %d\n", nbCompressedBytes*8-ec_enc_tell(&enc, 0));*/
836    /*if (ec_enc_tell(&enc, 0) < nbCompressedBytes*8 - 7)
837       celt_warning_int ("many unused bits: ", nbCompressedBytes*8-ec_enc_tell(&enc, 0));*/
838
839    /* Finishing the stream with a 0101... pattern so that the decoder can check is everything's right */
840    {
841       int val = 0;
842       while (ec_enc_tell(&enc, 0) < nbCompressedBytes*8)
843       {
844          ec_enc_uint(&enc, val, 2);
845          val = 1-val;
846       }
847    }
848    ec_enc_done(&enc);
849    {
850       /*unsigned char *data;*/
851       int nbBytes = ec_byte_bytes(&buf);
852       if (nbBytes > nbCompressedBytes)
853       {
854          celt_warning_int ("got too many bytes:", nbBytes);
855          RESTORE_STACK;
856          return CELT_INTERNAL_ERROR;
857       }
858    }
859
860    RESTORE_STACK;
861    return nbCompressedBytes;
862 }
863
864 #ifdef FIXED_POINT
865 #ifndef DISABLE_FLOAT_API
866 int celt_encode_float(CELTEncoder * restrict st, const float * pcm, float * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
867 {
868    int j, ret;
869    const int C = CHANNELS(st->mode);
870    const int N = st->block_size;
871    VARDECL(celt_int16_t, in);
872    SAVE_STACK;
873    ALLOC(in, C*N, celt_int16_t);
874
875    for (j=0;j<C*N;j++)
876      in[j] = FLOAT2INT16(pcm[j]);
877
878    if (optional_synthesis != NULL) {
879      ret=celt_encode(st,in,in,compressed,nbCompressedBytes);
880       for (j=0;j<C*N;j++)
881          optional_synthesis[j]=in[j]*(1/32768.);
882    } else {
883      ret=celt_encode(st,in,NULL,compressed,nbCompressedBytes);
884    }
885    RESTORE_STACK;
886    return ret;
887
888 }
889 #endif /*DISABLE_FLOAT_API*/
890 #else
891 int celt_encode(CELTEncoder * restrict st, const celt_int16_t * pcm, celt_int16_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
892 {
893    int j, ret;
894    VARDECL(celt_sig_t, in);
895    const int C = CHANNELS(st->mode);
896    const int N = st->block_size;
897    SAVE_STACK;
898    ALLOC(in, C*N, celt_sig_t);
899    for (j=0;j<C*N;j++) {
900      in[j] = SCALEOUT(pcm[j]);
901    }
902
903    if (optional_synthesis != NULL) {
904       ret = celt_encode_float(st,in,in,compressed,nbCompressedBytes);
905       for (j=0;j<C*N;j++)
906          optional_synthesis[j] = FLOAT2INT16(in[j]);
907    } else {
908       ret = celt_encode_float(st,in,NULL,compressed,nbCompressedBytes);
909    }
910    RESTORE_STACK;
911    return ret;
912 }
913 #endif
914
915 int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
916 {
917    va_list ap;
918    va_start(ap, request);
919    switch (request)
920    {
921       case CELT_SET_COMPLEXITY_REQUEST:
922       {
923          int value = va_arg(ap, celt_int32_t);
924          if (value<0 || value>10)
925             goto bad_arg;
926          if (value<=2) {
927             st->pitch_enabled = 0; 
928             st->pitch_available = 0;
929          } else {
930               st->pitch_enabled = 1;
931               if (st->pitch_available<1)
932                 st->pitch_available = 1;
933          }   
934       }
935       break;
936       case CELT_SET_LTP_REQUEST:
937       {
938          int value = va_arg(ap, celt_int32_t);
939          if (value<0 || value>1 || (value==1 && st->pitch_available==0))
940             goto bad_arg;
941          if (value==0)
942             st->pitch_enabled = 0;
943          else
944             st->pitch_enabled = 1;
945       }
946       break;
947       case CELT_SET_VBR_RATE_REQUEST:
948       {
949          int value = va_arg(ap, celt_int32_t);
950          if (value<0)
951             goto bad_arg;
952          if (value>3072000)
953             value = 3072000;
954          st->VBR_rate = ((st->mode->Fs<<3)+(st->block_size>>1))/st->block_size;
955          st->VBR_rate = ((value<<7)+(st->VBR_rate>>1))/st->VBR_rate;
956       }
957       break;
958       case CELT_RESET_STATE:
959       {
960          const CELTMode *mode = st->mode;
961          int C = mode->nbChannels;
962
963          if (st->pitch_available > 0) st->pitch_available = 1;
964
965          CELT_MEMSET(st->in_mem, 0, st->overlap*C);
966          CELT_MEMSET(st->out_mem, 0, (MAX_PERIOD+st->overlap)*C);
967
968          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
969
970          CELT_MEMSET(st->preemph_memE, 0, C);
971          CELT_MEMSET(st->preemph_memD, 0, C);
972          st->delayedIntra = 1;
973       }
974       break;
975       default:
976          goto bad_request;
977    }
978    va_end(ap);
979    return CELT_OK;
980 bad_arg:
981    va_end(ap);
982    return CELT_BAD_ARG;
983 bad_request:
984    va_end(ap);
985    return CELT_UNIMPLEMENTED;
986 }
987
988 /****************************************************************************/
989 /*                                                                          */
990 /*                                DECODER                                   */
991 /*                                                                          */
992 /****************************************************************************/
993 #ifdef NEW_PLC
994 #define DECODE_BUFFER_SIZE 2048
995 #else
996 #define DECODE_BUFFER_SIZE MAX_PERIOD
997 #endif
998
999 /** Decoder state 
1000  @brief Decoder state
1001  */
1002 struct CELTDecoder {
1003    const CELTMode *mode;
1004    int frame_size;
1005    int block_size;
1006    int overlap;
1007
1008    ec_byte_buffer buf;
1009    ec_enc         enc;
1010
1011    celt_sig_t * restrict preemph_memD;
1012
1013    celt_sig_t *out_mem;
1014    celt_sig_t *decode_mem;
1015
1016    celt_word16_t *oldBandE;
1017    
1018    int last_pitch_index;
1019 };
1020
1021 CELTDecoder *celt_decoder_create(const CELTMode *mode)
1022 {
1023    int N, C;
1024    CELTDecoder *st;
1025
1026    if (check_mode(mode) != CELT_OK)
1027       return NULL;
1028
1029    N = mode->mdctSize;
1030    C = CHANNELS(mode);
1031    st = celt_alloc(sizeof(CELTDecoder));
1032    
1033    st->mode = mode;
1034    st->frame_size = N;
1035    st->block_size = N;
1036    st->overlap = mode->overlap;
1037
1038    st->decode_mem = celt_alloc((DECODE_BUFFER_SIZE+st->overlap)*C*sizeof(celt_sig_t));
1039    st->out_mem = st->decode_mem+DECODE_BUFFER_SIZE-MAX_PERIOD;
1040    
1041    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
1042
1043    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));
1044
1045    st->last_pitch_index = 0;
1046    return st;
1047 }
1048
1049 void celt_decoder_destroy(CELTDecoder *st)
1050 {
1051    if (st == NULL)
1052    {
1053       celt_warning("NULL passed to celt_encoder_destroy");
1054       return;
1055    }
1056    if (check_mode(st->mode) != CELT_OK)
1057       return;
1058
1059
1060    celt_free(st->decode_mem);
1061    
1062    celt_free(st->oldBandE);
1063    
1064    celt_free(st->preemph_memD);
1065
1066    celt_free(st);
1067 }
1068
1069 /** Handles lost packets by just copying past data with the same offset as the last
1070     pitch period */
1071 #ifdef NEW_PLC
1072 #include "plc.c"
1073 #else
1074 static void celt_decode_lost(CELTDecoder * restrict st, celt_word16_t * restrict pcm)
1075 {
1076    int c, N;
1077    int pitch_index;
1078    int i, len;
1079    VARDECL(celt_sig_t, freq);
1080    const int C = CHANNELS(st->mode);
1081    int offset;
1082    SAVE_STACK;
1083    N = st->block_size;
1084    ALLOC(freq,C*N, celt_sig_t);         /**< Interleaved signal MDCTs */
1085    
1086    len = N+st->mode->overlap;
1087 #if 0
1088    pitch_index = st->last_pitch_index;
1089    
1090    /* Use the pitch MDCT as the "guessed" signal */
1091    compute_mdcts(st->mode, st->mode->window, st->out_mem+pitch_index*C, freq);
1092
1093 #else
1094    find_spectral_pitch(st->mode, st->mode->fft, &st->mode->psy, st->out_mem+MAX_PERIOD-len, st->out_mem, st->mode->window, NULL, len, MAX_PERIOD-len-100, &pitch_index);
1095    pitch_index = MAX_PERIOD-len-pitch_index;
1096    offset = MAX_PERIOD-pitch_index;
1097    while (offset+len >= MAX_PERIOD)
1098       offset -= pitch_index;
1099    compute_mdcts(st->mode, 0, st->out_mem+offset*C, freq);
1100    for (i=0;i<N;i++)
1101       freq[i] = ADD32(EPSILON, MULT16_32_Q15(QCONST16(.9f,15),freq[i]));
1102 #endif
1103    
1104    
1105    
1106    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->mode->overlap-N));
1107    /* Compute inverse MDCTs */
1108    compute_inv_mdcts(st->mode, 0, freq, -1, 0, st->out_mem);
1109
1110    for (c=0;c<C;c++)
1111    {
1112       int j;
1113       for (j=0;j<N;j++)
1114       {
1115          celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
1116                                 preemph,st->preemph_memD[c]);
1117          st->preemph_memD[c] = tmp;
1118          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
1119       }
1120    }
1121    RESTORE_STACK;
1122 }
1123 #endif
1124
1125 #ifdef FIXED_POINT
1126 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16_t * restrict pcm)
1127 {
1128 #else
1129 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, celt_sig_t * restrict pcm)
1130 {
1131 #endif
1132    int i, c, N, N4;
1133    int has_pitch, has_fold;
1134    int pitch_index;
1135    int bits;
1136    ec_dec dec;
1137    ec_byte_buffer buf;
1138    VARDECL(celt_sig_t, freq);
1139    VARDECL(celt_norm_t, X);
1140    VARDECL(celt_norm_t, P);
1141    VARDECL(celt_ener_t, bandE);
1142    VARDECL(celt_pgain_t, gains);
1143    VARDECL(int, fine_quant);
1144    VARDECL(int, pulses);
1145    VARDECL(int, offsets);
1146
1147    int shortBlocks;
1148    int intra_ener;
1149    int transient_time;
1150    int transient_shift;
1151    int mdct_weight_shift=0;
1152    const int C = CHANNELS(st->mode);
1153    int mdct_weight_pos=0;
1154    SAVE_STACK;
1155
1156    if (check_mode(st->mode) != CELT_OK)
1157       return CELT_INVALID_MODE;
1158
1159    N = st->block_size;
1160    N4 = (N-st->overlap)>>1;
1161
1162    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
1163    ALLOC(X, C*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
1164    ALLOC(P, C*N, celt_norm_t);         /**< Interleaved normalised pitch MDCTs*/
1165    ALLOC(bandE, st->mode->nbEBands*C, celt_ener_t);
1166    ALLOC(gains, st->mode->nbPBands, celt_pgain_t);
1167    
1168    if (check_mode(st->mode) != CELT_OK)
1169    {
1170       RESTORE_STACK;
1171       return CELT_INVALID_MODE;
1172    }
1173    if (data == NULL)
1174    {
1175       celt_decode_lost(st, pcm);
1176       RESTORE_STACK;
1177       return 0;
1178    }
1179    if (len<0) {
1180      RESTORE_STACK;
1181      return CELT_BAD_ARG;
1182    }
1183    
1184    ec_byte_readinit(&buf,(unsigned char*)data,len);
1185    ec_dec_init(&dec,&buf);
1186    
1187    decode_flags(&dec, &intra_ener, &has_pitch, &shortBlocks, &has_fold);
1188    if (shortBlocks)
1189    {
1190       transient_shift = ec_dec_bits(&dec, 2);
1191       if (transient_shift == 3)
1192       {
1193          transient_time = ec_dec_uint(&dec, N+st->mode->overlap);
1194       } else {
1195          mdct_weight_shift = transient_shift;
1196          if (mdct_weight_shift && st->mode->nbShortMdcts>2)
1197             mdct_weight_pos = ec_dec_uint(&dec, st->mode->nbShortMdcts-1);
1198          transient_shift = 0;
1199          transient_time = 0;
1200       }
1201    } else {
1202       transient_time = -1;
1203       transient_shift = 0;
1204    }
1205    
1206    if (has_pitch)
1207    {
1208       pitch_index = ec_dec_uint(&dec, MAX_PERIOD-(2*N-2*N4));
1209       st->last_pitch_index = pitch_index;
1210    } else {
1211       pitch_index = 0;
1212       for (i=0;i<st->mode->nbPBands;i++)
1213          gains[i] = 0;
1214    }
1215
1216    ALLOC(fine_quant, st->mode->nbEBands, int);
1217    /* Get band energies */
1218    unquant_coarse_energy(st->mode, bandE, st->oldBandE, len*8/3, intra_ener, st->mode->prob, &dec);
1219    
1220    ALLOC(pulses, st->mode->nbEBands, int);
1221    ALLOC(offsets, st->mode->nbEBands, int);
1222
1223    for (i=0;i<st->mode->nbEBands;i++)
1224       offsets[i] = 0;
1225
1226    bits = len*8 - ec_dec_tell(&dec, 0) - 1;
1227    if (has_pitch)
1228       bits -= st->mode->nbPBands;
1229    compute_allocation(st->mode, offsets, bits, pulses, fine_quant);
1230    /*bits = ec_dec_tell(&dec, 0);
1231    compute_fine_allocation(st->mode, fine_quant, (20*C+len*8/5-(ec_dec_tell(&dec, 0)-bits))/C);*/
1232    
1233    unquant_fine_energy(st->mode, bandE, st->oldBandE, fine_quant, &dec);
1234
1235
1236    if (has_pitch) 
1237    {
1238       VARDECL(celt_ener_t, bandEp);
1239       
1240       /* Pitch MDCT */
1241       compute_mdcts(st->mode, 0, st->out_mem+pitch_index*C, freq);
1242       ALLOC(bandEp, st->mode->nbEBands*C, celt_ener_t);
1243       compute_band_energies(st->mode, freq, bandEp);
1244       normalise_bands(st->mode, freq, P, bandEp);
1245       /* Apply pitch gains */
1246    } else {
1247       for (i=0;i<C*N;i++)
1248          P[i] = 0;
1249    }
1250
1251    /* Decode fixed codebook and merge with pitch */
1252    if (C==1)
1253       unquant_bands(st->mode, X, P, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
1254 #ifndef DISABLE_STEREO
1255    else
1256       unquant_bands_stereo(st->mode, X, P, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
1257 #endif
1258    /* Synthesis */
1259    denormalise_bands(st->mode, X, freq, bandE);
1260
1261
1262    CELT_MOVE(st->decode_mem, st->decode_mem+C*N, C*(DECODE_BUFFER_SIZE+st->overlap-N));
1263    if (mdct_weight_shift)
1264    {
1265       int m;
1266       for (c=0;c<C;c++)
1267          for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
1268             for (i=m*C+c;i<N;i+=C*st->mode->nbShortMdcts)
1269 #ifdef FIXED_POINT
1270                freq[i] = SHL32(freq[i], mdct_weight_shift);
1271 #else
1272                freq[i] = (1<<mdct_weight_shift)*freq[i];
1273 #endif
1274    }
1275    /* Compute inverse MDCTs */
1276    compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem);
1277
1278    for (c=0;c<C;c++)
1279    {
1280       int j;
1281       for (j=0;j<N;j++)
1282       {
1283          celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
1284                                 preemph,st->preemph_memD[c]);
1285          st->preemph_memD[c] = tmp;
1286          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
1287       }
1288    }
1289
1290    {
1291       unsigned int val = 0;
1292       while (ec_dec_tell(&dec, 0) < len*8)
1293       {
1294          if (ec_dec_uint(&dec, 2) != val)
1295          {
1296             celt_warning("decode error");
1297             RESTORE_STACK;
1298             return CELT_CORRUPTED_DATA;
1299          }
1300          val = 1-val;
1301       }
1302    }
1303
1304    RESTORE_STACK;
1305    return 0;
1306    /*printf ("\n");*/
1307 }
1308
1309 #ifdef FIXED_POINT
1310 #ifndef DISABLE_FLOAT_API
1311 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm)
1312 {
1313    int j, ret;
1314    const int C = CHANNELS(st->mode);
1315    const int N = st->block_size;
1316    VARDECL(celt_int16_t, out);
1317    SAVE_STACK;
1318    ALLOC(out, C*N, celt_int16_t);
1319
1320    ret=celt_decode(st, data, len, out);
1321
1322    for (j=0;j<C*N;j++)
1323      pcm[j]=out[j]*(1/32768.);
1324    RESTORE_STACK;
1325    return ret;
1326 }
1327 #endif /*DISABLE_FLOAT_API*/
1328 #else
1329 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16_t * restrict pcm)
1330 {
1331    int j, ret;
1332    VARDECL(celt_sig_t, out);
1333    const int C = CHANNELS(st->mode);
1334    const int N = st->block_size;
1335    SAVE_STACK;
1336    ALLOC(out, C*N, celt_sig_t);
1337
1338    ret=celt_decode_float(st, data, len, out);
1339
1340    for (j=0;j<C*N;j++)
1341      pcm[j] = FLOAT2INT16 (out[j]);
1342
1343    RESTORE_STACK;
1344    return ret;
1345 }
1346 #endif
1347
1348 int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
1349 {
1350    va_list ap;
1351    va_start(ap, request);
1352    switch (request)
1353    {
1354       case CELT_RESET_STATE:
1355       {
1356          const CELTMode *mode = st->mode;
1357          int C = mode->nbChannels;
1358
1359          CELT_MEMSET(st->decode_mem, 0, (DECODE_BUFFER_SIZE+st->overlap)*C);
1360          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
1361
1362          CELT_MEMSET(st->preemph_memD, 0, C);
1363
1364          st->last_pitch_index = 0;
1365       }
1366       break;
1367       default:
1368          goto bad_request;
1369    }
1370    va_end(ap);
1371    return CELT_OK;
1372 #if 0    /* Put this back in if you ever need "bad_arg" */
1373 bad_arg:
1374    va_end(ap);
1375    return CELT_BAD_ARG;
1376 #endif
1377 bad_request:
1378       va_end(ap);
1379   return CELT_UNIMPLEMENTED;
1380 }