Add get_mode CTL for the encoder and decoder.
[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_GET_MODE_REQUEST:
922       {
923          const CELTMode ** value = va_arg(ap, const CELTMode**);
924          if (value==0)
925             goto bad_arg;
926          *value=st->mode;
927       }
928       break;
929       case CELT_SET_COMPLEXITY_REQUEST:
930       {
931          int value = va_arg(ap, celt_int32_t);
932          if (value<0 || value>10)
933             goto bad_arg;
934          if (value<=2) {
935             st->pitch_enabled = 0; 
936             st->pitch_available = 0;
937          } else {
938               st->pitch_enabled = 1;
939               if (st->pitch_available<1)
940                 st->pitch_available = 1;
941          }   
942       }
943       break;
944       case CELT_SET_LTP_REQUEST:
945       {
946          int value = va_arg(ap, celt_int32_t);
947          if (value<0 || value>1 || (value==1 && st->pitch_available==0))
948             goto bad_arg;
949          if (value==0)
950             st->pitch_enabled = 0;
951          else
952             st->pitch_enabled = 1;
953       }
954       break;
955       case CELT_SET_VBR_RATE_REQUEST:
956       {
957          int value = va_arg(ap, celt_int32_t);
958          if (value<0)
959             goto bad_arg;
960          if (value>3072000)
961             value = 3072000;
962          st->VBR_rate = ((st->mode->Fs<<3)+(st->block_size>>1))/st->block_size;
963          st->VBR_rate = ((value<<7)+(st->VBR_rate>>1))/st->VBR_rate;
964       }
965       break;
966       case CELT_RESET_STATE:
967       {
968          const CELTMode *mode = st->mode;
969          int C = mode->nbChannels;
970
971          if (st->pitch_available > 0) st->pitch_available = 1;
972
973          CELT_MEMSET(st->in_mem, 0, st->overlap*C);
974          CELT_MEMSET(st->out_mem, 0, (MAX_PERIOD+st->overlap)*C);
975
976          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
977
978          CELT_MEMSET(st->preemph_memE, 0, C);
979          CELT_MEMSET(st->preemph_memD, 0, C);
980          st->delayedIntra = 1;
981       }
982       break;
983       default:
984          goto bad_request;
985    }
986    va_end(ap);
987    return CELT_OK;
988 bad_arg:
989    va_end(ap);
990    return CELT_BAD_ARG;
991 bad_request:
992    va_end(ap);
993    return CELT_UNIMPLEMENTED;
994 }
995
996 /****************************************************************************/
997 /*                                                                          */
998 /*                                DECODER                                   */
999 /*                                                                          */
1000 /****************************************************************************/
1001 #ifdef NEW_PLC
1002 #define DECODE_BUFFER_SIZE 2048
1003 #else
1004 #define DECODE_BUFFER_SIZE MAX_PERIOD
1005 #endif
1006
1007 /** Decoder state 
1008  @brief Decoder state
1009  */
1010 struct CELTDecoder {
1011    const CELTMode *mode;
1012    int frame_size;
1013    int block_size;
1014    int overlap;
1015
1016    ec_byte_buffer buf;
1017    ec_enc         enc;
1018
1019    celt_sig_t * restrict preemph_memD;
1020
1021    celt_sig_t *out_mem;
1022    celt_sig_t *decode_mem;
1023
1024    celt_word16_t *oldBandE;
1025    
1026    int last_pitch_index;
1027 };
1028
1029 CELTDecoder *celt_decoder_create(const CELTMode *mode)
1030 {
1031    int N, C;
1032    CELTDecoder *st;
1033
1034    if (check_mode(mode) != CELT_OK)
1035       return NULL;
1036
1037    N = mode->mdctSize;
1038    C = CHANNELS(mode);
1039    st = celt_alloc(sizeof(CELTDecoder));
1040    
1041    st->mode = mode;
1042    st->frame_size = N;
1043    st->block_size = N;
1044    st->overlap = mode->overlap;
1045
1046    st->decode_mem = celt_alloc((DECODE_BUFFER_SIZE+st->overlap)*C*sizeof(celt_sig_t));
1047    st->out_mem = st->decode_mem+DECODE_BUFFER_SIZE-MAX_PERIOD;
1048    
1049    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
1050
1051    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));
1052
1053    st->last_pitch_index = 0;
1054    return st;
1055 }
1056
1057 void celt_decoder_destroy(CELTDecoder *st)
1058 {
1059    if (st == NULL)
1060    {
1061       celt_warning("NULL passed to celt_encoder_destroy");
1062       return;
1063    }
1064    if (check_mode(st->mode) != CELT_OK)
1065       return;
1066
1067
1068    celt_free(st->decode_mem);
1069    
1070    celt_free(st->oldBandE);
1071    
1072    celt_free(st->preemph_memD);
1073
1074    celt_free(st);
1075 }
1076
1077 /** Handles lost packets by just copying past data with the same offset as the last
1078     pitch period */
1079 #ifdef NEW_PLC
1080 #include "plc.c"
1081 #else
1082 static void celt_decode_lost(CELTDecoder * restrict st, celt_word16_t * restrict pcm)
1083 {
1084    int c, N;
1085    int pitch_index;
1086    int i, len;
1087    VARDECL(celt_sig_t, freq);
1088    const int C = CHANNELS(st->mode);
1089    int offset;
1090    SAVE_STACK;
1091    N = st->block_size;
1092    ALLOC(freq,C*N, celt_sig_t);         /**< Interleaved signal MDCTs */
1093    
1094    len = N+st->mode->overlap;
1095 #if 0
1096    pitch_index = st->last_pitch_index;
1097    
1098    /* Use the pitch MDCT as the "guessed" signal */
1099    compute_mdcts(st->mode, st->mode->window, st->out_mem+pitch_index*C, freq);
1100
1101 #else
1102    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);
1103    pitch_index = MAX_PERIOD-len-pitch_index;
1104    offset = MAX_PERIOD-pitch_index;
1105    while (offset+len >= MAX_PERIOD)
1106       offset -= pitch_index;
1107    compute_mdcts(st->mode, 0, st->out_mem+offset*C, freq);
1108    for (i=0;i<N;i++)
1109       freq[i] = ADD32(EPSILON, MULT16_32_Q15(QCONST16(.9f,15),freq[i]));
1110 #endif
1111    
1112    
1113    
1114    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->mode->overlap-N));
1115    /* Compute inverse MDCTs */
1116    compute_inv_mdcts(st->mode, 0, freq, -1, 0, st->out_mem);
1117
1118    for (c=0;c<C;c++)
1119    {
1120       int j;
1121       for (j=0;j<N;j++)
1122       {
1123          celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
1124                                 preemph,st->preemph_memD[c]);
1125          st->preemph_memD[c] = tmp;
1126          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
1127       }
1128    }
1129    RESTORE_STACK;
1130 }
1131 #endif
1132
1133 #ifdef FIXED_POINT
1134 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16_t * restrict pcm)
1135 {
1136 #else
1137 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, celt_sig_t * restrict pcm)
1138 {
1139 #endif
1140    int i, c, N, N4;
1141    int has_pitch, has_fold;
1142    int pitch_index;
1143    int bits;
1144    ec_dec dec;
1145    ec_byte_buffer buf;
1146    VARDECL(celt_sig_t, freq);
1147    VARDECL(celt_norm_t, X);
1148    VARDECL(celt_norm_t, P);
1149    VARDECL(celt_ener_t, bandE);
1150    VARDECL(celt_pgain_t, gains);
1151    VARDECL(int, fine_quant);
1152    VARDECL(int, pulses);
1153    VARDECL(int, offsets);
1154
1155    int shortBlocks;
1156    int intra_ener;
1157    int transient_time;
1158    int transient_shift;
1159    int mdct_weight_shift=0;
1160    const int C = CHANNELS(st->mode);
1161    int mdct_weight_pos=0;
1162    SAVE_STACK;
1163
1164    if (check_mode(st->mode) != CELT_OK)
1165       return CELT_INVALID_MODE;
1166
1167    N = st->block_size;
1168    N4 = (N-st->overlap)>>1;
1169
1170    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
1171    ALLOC(X, C*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
1172    ALLOC(P, C*N, celt_norm_t);         /**< Interleaved normalised pitch MDCTs*/
1173    ALLOC(bandE, st->mode->nbEBands*C, celt_ener_t);
1174    ALLOC(gains, st->mode->nbPBands, celt_pgain_t);
1175    
1176    if (check_mode(st->mode) != CELT_OK)
1177    {
1178       RESTORE_STACK;
1179       return CELT_INVALID_MODE;
1180    }
1181    if (data == NULL)
1182    {
1183       celt_decode_lost(st, pcm);
1184       RESTORE_STACK;
1185       return 0;
1186    }
1187    if (len<0) {
1188      RESTORE_STACK;
1189      return CELT_BAD_ARG;
1190    }
1191    
1192    ec_byte_readinit(&buf,(unsigned char*)data,len);
1193    ec_dec_init(&dec,&buf);
1194    
1195    decode_flags(&dec, &intra_ener, &has_pitch, &shortBlocks, &has_fold);
1196    if (shortBlocks)
1197    {
1198       transient_shift = ec_dec_bits(&dec, 2);
1199       if (transient_shift == 3)
1200       {
1201          transient_time = ec_dec_uint(&dec, N+st->mode->overlap);
1202       } else {
1203          mdct_weight_shift = transient_shift;
1204          if (mdct_weight_shift && st->mode->nbShortMdcts>2)
1205             mdct_weight_pos = ec_dec_uint(&dec, st->mode->nbShortMdcts-1);
1206          transient_shift = 0;
1207          transient_time = 0;
1208       }
1209    } else {
1210       transient_time = -1;
1211       transient_shift = 0;
1212    }
1213    
1214    if (has_pitch)
1215    {
1216       pitch_index = ec_dec_uint(&dec, MAX_PERIOD-(2*N-2*N4));
1217       st->last_pitch_index = pitch_index;
1218    } else {
1219       pitch_index = 0;
1220       for (i=0;i<st->mode->nbPBands;i++)
1221          gains[i] = 0;
1222    }
1223
1224    ALLOC(fine_quant, st->mode->nbEBands, int);
1225    /* Get band energies */
1226    unquant_coarse_energy(st->mode, bandE, st->oldBandE, len*8/3, intra_ener, st->mode->prob, &dec);
1227    
1228    ALLOC(pulses, st->mode->nbEBands, int);
1229    ALLOC(offsets, st->mode->nbEBands, int);
1230
1231    for (i=0;i<st->mode->nbEBands;i++)
1232       offsets[i] = 0;
1233
1234    bits = len*8 - ec_dec_tell(&dec, 0) - 1;
1235    if (has_pitch)
1236       bits -= st->mode->nbPBands;
1237    compute_allocation(st->mode, offsets, bits, pulses, fine_quant);
1238    /*bits = ec_dec_tell(&dec, 0);
1239    compute_fine_allocation(st->mode, fine_quant, (20*C+len*8/5-(ec_dec_tell(&dec, 0)-bits))/C);*/
1240    
1241    unquant_fine_energy(st->mode, bandE, st->oldBandE, fine_quant, &dec);
1242
1243
1244    if (has_pitch) 
1245    {
1246       VARDECL(celt_ener_t, bandEp);
1247       
1248       /* Pitch MDCT */
1249       compute_mdcts(st->mode, 0, st->out_mem+pitch_index*C, freq);
1250       ALLOC(bandEp, st->mode->nbEBands*C, celt_ener_t);
1251       compute_band_energies(st->mode, freq, bandEp);
1252       normalise_bands(st->mode, freq, P, bandEp);
1253       /* Apply pitch gains */
1254    } else {
1255       for (i=0;i<C*N;i++)
1256          P[i] = 0;
1257    }
1258
1259    /* Decode fixed codebook and merge with pitch */
1260    if (C==1)
1261       unquant_bands(st->mode, X, P, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
1262 #ifndef DISABLE_STEREO
1263    else
1264       unquant_bands_stereo(st->mode, X, P, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
1265 #endif
1266    /* Synthesis */
1267    denormalise_bands(st->mode, X, freq, bandE);
1268
1269
1270    CELT_MOVE(st->decode_mem, st->decode_mem+C*N, C*(DECODE_BUFFER_SIZE+st->overlap-N));
1271    if (mdct_weight_shift)
1272    {
1273       int m;
1274       for (c=0;c<C;c++)
1275          for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
1276             for (i=m*C+c;i<N;i+=C*st->mode->nbShortMdcts)
1277 #ifdef FIXED_POINT
1278                freq[i] = SHL32(freq[i], mdct_weight_shift);
1279 #else
1280                freq[i] = (1<<mdct_weight_shift)*freq[i];
1281 #endif
1282    }
1283    /* Compute inverse MDCTs */
1284    compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem);
1285
1286    for (c=0;c<C;c++)
1287    {
1288       int j;
1289       for (j=0;j<N;j++)
1290       {
1291          celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
1292                                 preemph,st->preemph_memD[c]);
1293          st->preemph_memD[c] = tmp;
1294          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
1295       }
1296    }
1297
1298    {
1299       unsigned int val = 0;
1300       while (ec_dec_tell(&dec, 0) < len*8)
1301       {
1302          if (ec_dec_uint(&dec, 2) != val)
1303          {
1304             celt_warning("decode error");
1305             RESTORE_STACK;
1306             return CELT_CORRUPTED_DATA;
1307          }
1308          val = 1-val;
1309       }
1310    }
1311
1312    RESTORE_STACK;
1313    return 0;
1314    /*printf ("\n");*/
1315 }
1316
1317 #ifdef FIXED_POINT
1318 #ifndef DISABLE_FLOAT_API
1319 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm)
1320 {
1321    int j, ret;
1322    const int C = CHANNELS(st->mode);
1323    const int N = st->block_size;
1324    VARDECL(celt_int16_t, out);
1325    SAVE_STACK;
1326    ALLOC(out, C*N, celt_int16_t);
1327
1328    ret=celt_decode(st, data, len, out);
1329
1330    for (j=0;j<C*N;j++)
1331      pcm[j]=out[j]*(1/32768.);
1332    RESTORE_STACK;
1333    return ret;
1334 }
1335 #endif /*DISABLE_FLOAT_API*/
1336 #else
1337 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16_t * restrict pcm)
1338 {
1339    int j, ret;
1340    VARDECL(celt_sig_t, out);
1341    const int C = CHANNELS(st->mode);
1342    const int N = st->block_size;
1343    SAVE_STACK;
1344    ALLOC(out, C*N, celt_sig_t);
1345
1346    ret=celt_decode_float(st, data, len, out);
1347
1348    for (j=0;j<C*N;j++)
1349      pcm[j] = FLOAT2INT16 (out[j]);
1350
1351    RESTORE_STACK;
1352    return ret;
1353 }
1354 #endif
1355
1356 int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
1357 {
1358    va_list ap;
1359    va_start(ap, request);
1360    switch (request)
1361    {
1362       case CELT_GET_MODE_REQUEST:
1363       {
1364          const CELTMode ** value = va_arg(ap, const CELTMode**);
1365          if (value==0)
1366             goto bad_arg;
1367          *value=st->mode;
1368       }
1369       break;
1370       case CELT_RESET_STATE:
1371       {
1372          const CELTMode *mode = st->mode;
1373          int C = mode->nbChannels;
1374
1375          CELT_MEMSET(st->decode_mem, 0, (DECODE_BUFFER_SIZE+st->overlap)*C);
1376          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
1377
1378          CELT_MEMSET(st->preemph_memD, 0, C);
1379
1380          st->last_pitch_index = 0;
1381       }
1382       break;
1383       default:
1384          goto bad_request;
1385    }
1386    va_end(ap);
1387    return CELT_OK;
1388 bad_arg:
1389    va_end(ap);
1390    return CELT_BAD_ARG;
1391 bad_request:
1392       va_end(ap);
1393   return CELT_UNIMPLEMENTED;
1394 }