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