Now storing the band energies in de-interleaved format when doing stereo
[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[C*j+c] = 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[C*(j*B+b)+c] = 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[C*j+c];
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[C*(j*B+b)+c];
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    if (shortBlocks && !transient_shift) 
617    {
618       celt_word32_t sum[4]={1,1,1,1};
619       int m;
620       for (c=0;c<C;c++)
621       {
622          m=0;
623          do {
624             celt_word32_t tmp=0;
625             for (i=m*C+c;i<N;i+=C*st->mode->nbShortMdcts)
626                tmp += ABS32(freq[i]);
627             sum[m++] += tmp;
628          } while (m<st->mode->nbShortMdcts);
629       }
630       m=0;
631 #ifdef FIXED_POINT
632       do {
633          if (SHR32(sum[m+1],3) > sum[m])
634          {
635             mdct_weight_shift=2;
636             mdct_weight_pos = m;
637          } else if (SHR32(sum[m+1],1) > sum[m] && mdct_weight_shift < 2)
638          {
639             mdct_weight_shift=1;
640             mdct_weight_pos = m;
641          }
642          m++;
643       } while (m<st->mode->nbShortMdcts-1);
644       if (mdct_weight_shift)
645       {
646          for (c=0;c<C;c++)
647             for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
648                for (i=m*C+c;i<N;i+=C*st->mode->nbShortMdcts)
649                   freq[i] = SHR32(freq[i],mdct_weight_shift);
650       }
651 #else
652       do {
653          if (sum[m+1] > 8*sum[m])
654          {
655             mdct_weight_shift=2;
656             mdct_weight_pos = m;
657          } else if (sum[m+1] > 2*sum[m] && mdct_weight_shift < 2)
658          {
659             mdct_weight_shift=1;
660             mdct_weight_pos = m;
661          }
662          m++;
663       } while (m<st->mode->nbShortMdcts-1);
664       if (mdct_weight_shift)
665       {
666          for (c=0;c<C;c++)
667             for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
668                for (i=m*C+c;i<N;i+=C*st->mode->nbShortMdcts)
669                   freq[i] = (1./(1<<mdct_weight_shift))*freq[i];
670       }
671 #endif
672       /*printf ("%f\n", short_ratio);*/
673       /*if (short_ratio < 1)
674          short_ratio = 1;
675       short_ratio = 1<<(int)floor(.5+log2(short_ratio));
676       if (short_ratio>4)
677          short_ratio = 4;*/
678    }/* else if (transient_shift)
679       printf ("8\n");
680       else printf ("1\n");*/
681
682    compute_band_energies(st->mode, freq, bandE);
683    for (i=0;i<st->mode->nbEBands*C;i++)
684       bandLogE[i] = amp2Log(bandE[i]);
685
686    intra_ener = (st->force_intra || st->delayedIntra);
687    if (shortBlocks || intra_decision(bandLogE, st->oldBandE, st->mode->nbEBands))
688       st->delayedIntra = 1;
689    else
690       st->delayedIntra = 0;
691    /* Pitch analysis: we do it early to save on the peak stack space */
692    /* Don't use pitch if there isn't enough data available yet, 
693       or if we're using shortBlocks */
694    has_pitch = st->pitch_enabled && st->pitch_permitted && (st->pitch_available >= MAX_PERIOD) && (!shortBlocks) && !intra_ener;
695 #ifdef EXP_PSY
696    ALLOC(tonality, MAX_PERIOD/4, celt_word16_t);
697    {
698       VARDECL(celt_word16_t, X);
699       ALLOC(X, MAX_PERIOD/2, celt_word16_t);
700       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);
701       compute_tonality(st->mode, X, st->psy_mem, MAX_PERIOD, tonality, MAX_PERIOD/4);
702    }
703 #else
704    if (has_pitch)
705    {
706       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);
707    }
708 #endif
709
710 #ifdef EXP_PSY
711    ALLOC(mask, N, celt_sig_t);
712    compute_mdct_masking(&st->psy, freq, tonality, st->psy_mem, mask, C*N);
713    /*for (i=0;i<256;i++)
714       printf ("%f %f %f ", freq[i], tonality[i], mask[i]);
715    printf ("\n");*/
716 #endif
717
718    /* Deferred allocation after find_spectral_pitch() to reduce 
719       the peak memory usage */
720    ALLOC(X, C*N, celt_norm_t);         /**< Interleaved normalised MDCTs */
721    ALLOC(P, C*N, celt_norm_t);         /**< Interleaved normalised pitch MDCTs*/
722    ALLOC(gains,st->mode->nbPBands, celt_pgain_t);
723
724
725    /* Band normalisation */
726    normalise_bands(st->mode, freq, X, bandE);
727    if (!shortBlocks && !folding_decision(st->mode, X, &st->tonal_average, &st->fold_decision))
728       has_fold = 0;
729 #ifdef EXP_PSY
730    ALLOC(bandN,C*st->mode->nbEBands, celt_ener_t);
731    ALLOC(bandM,st->mode->nbEBands, celt_ener_t);
732    compute_noise_energies(st->mode, freq, tonality, bandN);
733
734    /*for (i=0;i<st->mode->nbEBands;i++)
735       printf ("%f ", (.1+bandN[i])/(.1+bandE[i]));
736    printf ("\n");*/
737    has_fold = 0;
738    for (i=st->mode->nbPBands;i<st->mode->nbEBands;i++)
739       if (bandN[i] < .4*bandE[i])
740          has_fold++;
741    /*printf ("%d\n", has_fold);*/
742    if (has_fold>=2)
743       has_fold = 0;
744    else
745       has_fold = 1;
746    for (i=0;i<N;i++)
747       mask[i] = sqrt(mask[i]);
748    compute_band_energies(st->mode, mask, bandM);
749    /*for (i=0;i<st->mode->nbEBands;i++)
750       printf ("%f %f ", bandE[i], bandM[i]);
751    printf ("\n");*/
752 #endif
753
754    /* Compute MDCTs of the pitch part */
755    if (has_pitch)
756    {
757       celt_word32_t curr_power, pitch_power=0;
758       /* Normalise the pitch vector as well (discard the energies) */
759       VARDECL(celt_ener_t, bandEp);
760       
761       compute_mdcts(st->mode, 0, st->out_mem+pitch_index*C, freq);
762       ALLOC(bandEp, st->mode->nbEBands*st->mode->nbChannels, celt_ener_t);
763       compute_band_energies(st->mode, freq, bandEp);
764       normalise_bands(st->mode, freq, P, bandEp);
765       pitch_power = bandEp[0]+bandEp[1]+bandEp[2];
766       curr_power = bandE[0]+bandE[1]+bandE[2];
767       if (C>1)
768       {
769          pitch_power += bandEp[0+st->mode->nbEBands]+bandEp[1+st->mode->nbEBands]+bandEp[2+st->mode->nbEBands];
770          curr_power += bandE[0+st->mode->nbEBands]+bandE[1+st->mode->nbEBands]+bandE[2+st->mode->nbEBands];
771       }
772       /* Check if we can safely use the pitch (i.e. effective gain 
773       isn't too high) */
774       if ((MULT16_32_Q15(QCONST16(.1f, 15),curr_power) + QCONST32(10.f,ENER_SHIFT) < pitch_power))
775       {
776          /* Pitch prediction */
777          has_pitch = compute_pitch_gain(st->mode, X, P, gains);
778       } else {
779          has_pitch = 0;
780       }
781    }
782    
783    encode_flags(&enc, intra_ener, has_pitch, shortBlocks, has_fold);
784    if (has_pitch)
785    {
786       ec_enc_uint(&enc, pitch_index, MAX_PERIOD-(2*N-2*N4));
787    } else {
788       for (i=0;i<st->mode->nbPBands;i++)
789          gains[i] = 0;
790       for (i=0;i<C*N;i++)
791          P[i] = 0;
792    }
793    if (shortBlocks)
794    {
795       if (transient_shift)
796       {
797          ec_enc_bits(&enc, transient_shift, 2);
798          ec_enc_uint(&enc, transient_time, N+st->overlap);
799       } else {
800          ec_enc_bits(&enc, mdct_weight_shift, 2);
801          if (mdct_weight_shift && st->mode->nbShortMdcts!=2)
802             ec_enc_uint(&enc, mdct_weight_pos, st->mode->nbShortMdcts-1);
803       }
804    }
805
806 #ifdef STDIN_TUNING2
807    static int fine_quant[30];
808    static int pulses[30];
809    static int init=0;
810    if (!init)
811    {
812       for (i=0;i<st->mode->nbEBands;i++)
813          scanf("%d ", &fine_quant[i]);
814       for (i=0;i<st->mode->nbEBands;i++)
815          scanf("%d ", &pulses[i]);
816       init = 1;
817    }
818 #else
819    ALLOC(fine_quant, st->mode->nbEBands, int);
820    ALLOC(pulses, st->mode->nbEBands, int);
821 #endif
822
823    /* Bit allocation */
824    ALLOC(error, C*st->mode->nbEBands, celt_word16_t);
825    coarse_needed = quant_coarse_energy(st->mode, bandLogE, st->oldBandE, nbCompressedBytes*8/3, intra_ener, st->mode->prob, error, &enc);
826    coarse_needed = ((coarse_needed*3-1)>>3)+1;
827
828    /* Variable bitrate */
829    if (st->VBR_rate>0)
830    {
831      /* The target rate in 16th bits per frame */
832      int target=st->VBR_rate;
833    
834      /* Shortblocks get a large boost in bitrate, but since they 
835         are uncommon long blocks are not greatly effected */
836      if (shortBlocks)
837        target*=2;
838      else if (st->mode->nbShortMdcts > 1)
839        target-=(target+14)/28;     
840
841      /* The average energy is removed from the target and the actual 
842         energy added*/
843      target=target-588+ec_enc_tell(&enc, 4);
844
845      /* In VBR mode the frame size must not be reduced so much that it would result in the coarse energy busting its budget */
846      target=IMAX(coarse_needed,(target+64)/128);
847      nbCompressedBytes=IMIN(nbCompressedBytes,target);
848    }
849
850    ALLOC(offsets, st->mode->nbEBands, int);
851    ALLOC(fine_priority, st->mode->nbEBands, int);
852
853    for (i=0;i<st->mode->nbEBands;i++)
854       offsets[i] = 0;
855    bits = nbCompressedBytes*8 - ec_enc_tell(&enc, 0) - 1;
856    if (has_pitch)
857       bits -= st->mode->nbPBands;
858 #ifndef STDIN_TUNING
859    compute_allocation(st->mode, offsets, bits, pulses, fine_quant, fine_priority);
860 #endif
861
862    quant_fine_energy(st->mode, bandE, st->oldBandE, error, fine_quant, &enc);
863
864    /* Residual quantisation */
865    if (C==1)
866       quant_bands(st->mode, X, P, NULL, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, &enc);
867 #ifndef DISABLE_STEREO
868    else
869       quant_bands_stereo(st->mode, X, P, NULL, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, nbCompressedBytes*8, &enc);
870 #endif
871
872    quant_energy_finalise(st->mode, bandE, st->oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_enc_tell(&enc, 0), &enc);
873
874    /* Re-synthesis of the coded audio if required */
875    if (st->pitch_available>0 || optional_synthesis!=NULL)
876    {
877       if (st->pitch_available>0 && st->pitch_available<MAX_PERIOD)
878         st->pitch_available+=st->frame_size;
879
880       /* Synthesis */
881       denormalise_bands(st->mode, X, freq, bandE);
882       
883       
884       CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->overlap-N));
885       
886       if (mdct_weight_shift)
887       {
888          int m;
889          for (c=0;c<C;c++)
890             for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
891                for (i=m*C+c;i<N;i+=C*st->mode->nbShortMdcts)
892 #ifdef FIXED_POINT
893                   freq[i] = SHL32(freq[i], mdct_weight_shift);
894 #else
895                   freq[i] = (1<<mdct_weight_shift)*freq[i];
896 #endif
897       }
898       compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem);
899       /* De-emphasis and put everything back at the right place 
900          in the synthesis history */
901       if (optional_synthesis != NULL) {
902          for (c=0;c<C;c++)
903          {
904             int j;
905             for (j=0;j<N;j++)
906             {
907                celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
908                                    preemph,st->preemph_memD[c]);
909                st->preemph_memD[c] = tmp;
910                optional_synthesis[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
911             }
912          }
913       }
914    }
915
916    ec_enc_done(&enc);
917    
918    RESTORE_STACK;
919    return nbCompressedBytes;
920 }
921
922 #ifdef FIXED_POINT
923 #ifndef DISABLE_FLOAT_API
924 int celt_encode_float(CELTEncoder * restrict st, const float * pcm, float * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
925 {
926    int j, ret, C, N;
927    VARDECL(celt_int16_t, in);
928
929    if (check_encoder(st) != CELT_OK)
930       return CELT_INVALID_STATE;
931
932    if (check_mode(st->mode) != CELT_OK)
933       return CELT_INVALID_MODE;
934
935    SAVE_STACK;
936    C = CHANNELS(st->mode);
937    N = st->block_size;
938    ALLOC(in, C*N, celt_int16_t);
939
940    for (j=0;j<C*N;j++)
941      in[j] = FLOAT2INT16(pcm[j]);
942
943    if (optional_synthesis != NULL) {
944      ret=celt_encode(st,in,in,compressed,nbCompressedBytes);
945       for (j=0;j<C*N;j++)
946          optional_synthesis[j]=in[j]*(1/32768.);
947    } else {
948      ret=celt_encode(st,in,NULL,compressed,nbCompressedBytes);
949    }
950    RESTORE_STACK;
951    return ret;
952
953 }
954 #endif /*DISABLE_FLOAT_API*/
955 #else
956 int celt_encode(CELTEncoder * restrict st, const celt_int16_t * pcm, celt_int16_t * optional_synthesis, unsigned char *compressed, int nbCompressedBytes)
957 {
958    int j, ret, C, N;
959    VARDECL(celt_sig_t, in);
960
961    if (check_encoder(st) != CELT_OK)
962       return CELT_INVALID_STATE;
963
964    if (check_mode(st->mode) != CELT_OK)
965       return CELT_INVALID_MODE;
966
967    SAVE_STACK;
968    C=CHANNELS(st->mode);
969    N=st->block_size;
970    ALLOC(in, C*N, celt_sig_t);
971    for (j=0;j<C*N;j++) {
972      in[j] = SCALEOUT(pcm[j]);
973    }
974
975    if (optional_synthesis != NULL) {
976       ret = celt_encode_float(st,in,in,compressed,nbCompressedBytes);
977       for (j=0;j<C*N;j++)
978          optional_synthesis[j] = FLOAT2INT16(in[j]);
979    } else {
980       ret = celt_encode_float(st,in,NULL,compressed,nbCompressedBytes);
981    }
982    RESTORE_STACK;
983    return ret;
984 }
985 #endif
986
987 int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
988 {
989    va_list ap;
990    
991    if (check_encoder(st) != CELT_OK)
992       return CELT_INVALID_STATE;
993
994    va_start(ap, request);
995    if ((request!=CELT_GET_MODE_REQUEST) && (check_mode(st->mode) != CELT_OK))
996      goto bad_mode;
997    switch (request)
998    {
999       case CELT_GET_MODE_REQUEST:
1000       {
1001          const CELTMode ** value = va_arg(ap, const CELTMode**);
1002          if (value==0)
1003             goto bad_arg;
1004          *value=st->mode;
1005       }
1006       break;
1007       case CELT_SET_COMPLEXITY_REQUEST:
1008       {
1009          int value = va_arg(ap, celt_int32_t);
1010          if (value<0 || value>10)
1011             goto bad_arg;
1012          if (value<=2) {
1013             st->pitch_enabled = 0; 
1014             st->pitch_available = 0;
1015          } else {
1016               st->pitch_enabled = 1;
1017               if (st->pitch_available<1)
1018                 st->pitch_available = 1;
1019          }   
1020       }
1021       break;
1022       case CELT_SET_PREDICTION_REQUEST:
1023       {
1024          int value = va_arg(ap, celt_int32_t);
1025          if (value<0 || value>2)
1026             goto bad_arg;
1027          if (value==0)
1028          {
1029             st->force_intra   = 1;
1030             st->pitch_permitted = 0;
1031          } else if (value=1) {
1032             st->force_intra   = 0;
1033             st->pitch_permitted = 0;
1034          } else {
1035             st->force_intra   = 0;
1036             st->pitch_permitted = 1;
1037          }   
1038       }
1039       break;
1040       case CELT_SET_VBR_RATE_REQUEST:
1041       {
1042          int value = va_arg(ap, celt_int32_t);
1043          if (value<0)
1044             goto bad_arg;
1045          if (value>3072000)
1046             value = 3072000;
1047          st->VBR_rate = ((st->mode->Fs<<3)+(st->block_size>>1))/st->block_size;
1048          st->VBR_rate = ((value<<7)+(st->VBR_rate>>1))/st->VBR_rate;
1049       }
1050       break;
1051       case CELT_RESET_STATE:
1052       {
1053          const CELTMode *mode = st->mode;
1054          int C = mode->nbChannels;
1055
1056          if (st->pitch_available > 0) st->pitch_available = 1;
1057
1058          CELT_MEMSET(st->in_mem, 0, st->overlap*C);
1059          CELT_MEMSET(st->out_mem, 0, (MAX_PERIOD+st->overlap)*C);
1060
1061          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
1062
1063          CELT_MEMSET(st->preemph_memE, 0, C);
1064          CELT_MEMSET(st->preemph_memD, 0, C);
1065          st->delayedIntra = 1;
1066       }
1067       break;
1068       default:
1069          goto bad_request;
1070    }
1071    va_end(ap);
1072    return CELT_OK;
1073 bad_mode:
1074   va_end(ap);
1075   return CELT_INVALID_MODE;
1076 bad_arg:
1077    va_end(ap);
1078    return CELT_BAD_ARG;
1079 bad_request:
1080    va_end(ap);
1081    return CELT_UNIMPLEMENTED;
1082 }
1083
1084 /**********************************************************************/
1085 /*                                                                    */
1086 /*                             DECODER                                */
1087 /*                                                                    */
1088 /**********************************************************************/
1089 #ifdef NEW_PLC
1090 #define DECODE_BUFFER_SIZE 2048
1091 #else
1092 #define DECODE_BUFFER_SIZE MAX_PERIOD
1093 #endif
1094
1095 #define DECODERVALID   0x4c434454
1096 #define DECODERPARTIAL 0x5444434c
1097 #define DECODERFREED   0x4c004400
1098
1099 /** Decoder state 
1100  @brief Decoder state
1101  */
1102 struct CELTDecoder {
1103    celt_uint32_t marker;
1104    const CELTMode *mode;
1105    int frame_size;
1106    int block_size;
1107    int overlap;
1108
1109    ec_byte_buffer buf;
1110    ec_enc         enc;
1111
1112    celt_sig_t * restrict preemph_memD;
1113
1114    celt_sig_t *out_mem;
1115    celt_sig_t *decode_mem;
1116
1117    celt_word16_t *oldBandE;
1118    
1119    int last_pitch_index;
1120 };
1121
1122 int check_decoder(const CELTDecoder *st) 
1123 {
1124    if (st==NULL)
1125    {
1126       celt_warning("NULL passed a decoder structure");  
1127       return CELT_INVALID_STATE;
1128    }
1129    if (st->marker == DECODERVALID)
1130       return CELT_OK;
1131    if (st->marker == DECODERFREED)
1132       celt_warning("Referencing a decoder that has already been freed");
1133    else
1134       celt_warning("This is not a valid CELT decoder structure");
1135    return CELT_INVALID_STATE;
1136 }
1137
1138 CELTDecoder *celt_decoder_create(const CELTMode *mode)
1139 {
1140    int N, C;
1141    CELTDecoder *st;
1142
1143    if (check_mode(mode) != CELT_OK)
1144       return NULL;
1145
1146    N = mode->mdctSize;
1147    C = CHANNELS(mode);
1148    st = celt_alloc(sizeof(CELTDecoder));
1149
1150    if (st==NULL)
1151       return NULL;
1152    
1153    st->marker = DECODERPARTIAL;
1154    st->mode = mode;
1155    st->frame_size = N;
1156    st->block_size = N;
1157    st->overlap = mode->overlap;
1158
1159    st->decode_mem = celt_alloc((DECODE_BUFFER_SIZE+st->overlap)*C*sizeof(celt_sig_t));
1160    st->out_mem = st->decode_mem+DECODE_BUFFER_SIZE-MAX_PERIOD;
1161    
1162    st->oldBandE = (celt_word16_t*)celt_alloc(C*mode->nbEBands*sizeof(celt_word16_t));
1163    
1164    st->preemph_memD = (celt_sig_t*)celt_alloc(C*sizeof(celt_sig_t));
1165
1166    st->last_pitch_index = 0;
1167
1168    if ((st->decode_mem!=NULL) && (st->out_mem!=NULL) && (st->oldBandE!=NULL) &&
1169        (st->preemph_memD!=NULL))
1170    {
1171       st->marker = DECODERVALID;
1172       return st;
1173    }
1174    /* If the setup fails for some reason deallocate it. */
1175    celt_decoder_destroy(st);
1176    return NULL;
1177 }
1178
1179 void celt_decoder_destroy(CELTDecoder *st)
1180 {
1181    if (st == NULL)
1182    {
1183       celt_warning("NULL passed to celt_decoder_destroy");
1184       return;
1185    }
1186
1187    if (st->marker == DECODERFREED) 
1188    {
1189       celt_warning("Freeing a decoder which has already been freed"); 
1190       return;
1191    }
1192    
1193    if (st->marker != DECODERVALID && st->marker != DECODERPARTIAL)
1194    {
1195       celt_warning("This is not a valid CELT decoder structure");
1196       return;
1197    }
1198    
1199    /*Check_mode is non-fatal here because we can still free
1200      the encoder memory even if the mode is bad, although calling
1201      the free functions in this order is a violation of the API.*/
1202    check_mode(st->mode);
1203    
1204    celt_free(st->decode_mem);
1205    celt_free(st->oldBandE);
1206    celt_free(st->preemph_memD);
1207    
1208    st->marker = DECODERFREED;
1209    
1210    celt_free(st);
1211 }
1212
1213 /** Handles lost packets by just copying past data with the same
1214     offset as the last
1215     pitch period */
1216 #ifdef NEW_PLC
1217 #include "plc.c"
1218 #else
1219 static void celt_decode_lost(CELTDecoder * restrict st, celt_word16_t * restrict pcm)
1220 {
1221    int c, N;
1222    int pitch_index;
1223    int i, len;
1224    VARDECL(celt_sig_t, freq);
1225    const int C = CHANNELS(st->mode);
1226    int offset;
1227    SAVE_STACK;
1228    N = st->block_size;
1229    ALLOC(freq,C*N, celt_sig_t); /**< Interleaved signal MDCTs */
1230    
1231    len = N+st->mode->overlap;
1232 #if 0
1233    pitch_index = st->last_pitch_index;
1234    
1235    /* Use the pitch MDCT as the "guessed" signal */
1236    compute_mdcts(st->mode, st->mode->window, st->out_mem+pitch_index*C, freq);
1237
1238 #else
1239    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);
1240    pitch_index = MAX_PERIOD-len-pitch_index;
1241    offset = MAX_PERIOD-pitch_index;
1242    while (offset+len >= MAX_PERIOD)
1243       offset -= pitch_index;
1244    compute_mdcts(st->mode, 0, st->out_mem+offset*C, freq);
1245    for (i=0;i<N;i++)
1246       freq[i] = ADD32(EPSILON, MULT16_32_Q15(QCONST16(.9f,15),freq[i]));
1247 #endif
1248    
1249    
1250    
1251    CELT_MOVE(st->out_mem, st->out_mem+C*N, C*(MAX_PERIOD+st->mode->overlap-N));
1252    /* Compute inverse MDCTs */
1253    compute_inv_mdcts(st->mode, 0, freq, -1, 0, st->out_mem);
1254
1255    for (c=0;c<C;c++)
1256    {
1257       int j;
1258       for (j=0;j<N;j++)
1259       {
1260          celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
1261                                 preemph,st->preemph_memD[c]);
1262          st->preemph_memD[c] = tmp;
1263          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
1264       }
1265    }
1266    RESTORE_STACK;
1267 }
1268 #endif
1269
1270 #ifdef FIXED_POINT
1271 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16_t * restrict pcm)
1272 {
1273 #else
1274 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, celt_sig_t * restrict pcm)
1275 {
1276 #endif
1277    int i, c, N, N4;
1278    int has_pitch, has_fold;
1279    int pitch_index;
1280    int bits;
1281    ec_dec dec;
1282    ec_byte_buffer buf;
1283    VARDECL(celt_sig_t, freq);
1284    VARDECL(celt_norm_t, X);
1285    VARDECL(celt_norm_t, P);
1286    VARDECL(celt_ener_t, bandE);
1287    VARDECL(celt_pgain_t, gains);
1288    VARDECL(int, fine_quant);
1289    VARDECL(int, pulses);
1290    VARDECL(int, offsets);
1291    VARDECL(int, fine_priority);
1292
1293    int shortBlocks;
1294    int intra_ener;
1295    int transient_time;
1296    int transient_shift;
1297    int mdct_weight_shift=0;
1298    const int C = CHANNELS(st->mode);
1299    int mdct_weight_pos=0;
1300    SAVE_STACK;
1301
1302    if (check_decoder(st) != CELT_OK)
1303       return CELT_INVALID_STATE;
1304
1305    if (check_mode(st->mode) != CELT_OK)
1306       return CELT_INVALID_MODE;
1307
1308    N = st->block_size;
1309    N4 = (N-st->overlap)>>1;
1310
1311    ALLOC(freq, C*N, celt_sig_t); /**< Interleaved signal MDCTs */
1312    ALLOC(X, C*N, celt_norm_t);   /**< Interleaved normalised MDCTs */
1313    ALLOC(P, C*N, celt_norm_t);   /**< Interleaved normalised pitch MDCTs*/
1314    ALLOC(bandE, st->mode->nbEBands*C, celt_ener_t);
1315    ALLOC(gains, st->mode->nbPBands, celt_pgain_t);
1316    
1317    if (data == NULL)
1318    {
1319       celt_decode_lost(st, pcm);
1320       RESTORE_STACK;
1321       return 0;
1322    }
1323    if (len<0) {
1324      RESTORE_STACK;
1325      return CELT_BAD_ARG;
1326    }
1327    
1328    ec_byte_readinit(&buf,(unsigned char*)data,len);
1329    ec_dec_init(&dec,&buf);
1330    
1331    decode_flags(&dec, &intra_ener, &has_pitch, &shortBlocks, &has_fold);
1332    if (shortBlocks)
1333    {
1334       transient_shift = ec_dec_bits(&dec, 2);
1335       if (transient_shift == 3)
1336       {
1337          transient_time = ec_dec_uint(&dec, N+st->mode->overlap);
1338       } else {
1339          mdct_weight_shift = transient_shift;
1340          if (mdct_weight_shift && st->mode->nbShortMdcts>2)
1341             mdct_weight_pos = ec_dec_uint(&dec, st->mode->nbShortMdcts-1);
1342          transient_shift = 0;
1343          transient_time = 0;
1344       }
1345    } else {
1346       transient_time = -1;
1347       transient_shift = 0;
1348    }
1349    
1350    if (has_pitch)
1351    {
1352       pitch_index = ec_dec_uint(&dec, MAX_PERIOD-(2*N-2*N4));
1353       st->last_pitch_index = pitch_index;
1354    } else {
1355       pitch_index = 0;
1356       for (i=0;i<st->mode->nbPBands;i++)
1357          gains[i] = 0;
1358    }
1359
1360    ALLOC(fine_quant, st->mode->nbEBands, int);
1361    /* Get band energies */
1362    unquant_coarse_energy(st->mode, bandE, st->oldBandE, len*8/3, intra_ener, st->mode->prob, &dec);
1363    
1364    ALLOC(pulses, st->mode->nbEBands, int);
1365    ALLOC(offsets, st->mode->nbEBands, int);
1366    ALLOC(fine_priority, st->mode->nbEBands, int);
1367
1368    for (i=0;i<st->mode->nbEBands;i++)
1369       offsets[i] = 0;
1370
1371    bits = len*8 - ec_dec_tell(&dec, 0) - 1;
1372    if (has_pitch)
1373       bits -= st->mode->nbPBands;
1374    compute_allocation(st->mode, offsets, bits, pulses, fine_quant, fine_priority);
1375    /*bits = ec_dec_tell(&dec, 0);
1376    compute_fine_allocation(st->mode, fine_quant, (20*C+len*8/5-(ec_dec_tell(&dec, 0)-bits))/C);*/
1377    
1378    unquant_fine_energy(st->mode, bandE, st->oldBandE, fine_quant, &dec);
1379
1380
1381    if (has_pitch) 
1382    {
1383       VARDECL(celt_ener_t, bandEp);
1384       
1385       /* Pitch MDCT */
1386       compute_mdcts(st->mode, 0, st->out_mem+pitch_index*C, freq);
1387       ALLOC(bandEp, st->mode->nbEBands*C, celt_ener_t);
1388       compute_band_energies(st->mode, freq, bandEp);
1389       normalise_bands(st->mode, freq, P, bandEp);
1390       /* Apply pitch gains */
1391    } else {
1392       for (i=0;i<C*N;i++)
1393          P[i] = 0;
1394    }
1395
1396    /* Decode fixed codebook and merge with pitch */
1397    if (C==1)
1398       unquant_bands(st->mode, X, P, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
1399 #ifndef DISABLE_STEREO
1400    else
1401       unquant_bands_stereo(st->mode, X, P, has_pitch, gains, bandE, pulses, shortBlocks, has_fold, len*8, &dec);
1402 #endif
1403    unquant_energy_finalise(st->mode, bandE, st->oldBandE, fine_quant, fine_priority, len*8-ec_dec_tell(&dec, 0), &dec);
1404    
1405    /* Synthesis */
1406    denormalise_bands(st->mode, X, freq, bandE);
1407
1408
1409    CELT_MOVE(st->decode_mem, st->decode_mem+C*N, C*(DECODE_BUFFER_SIZE+st->overlap-N));
1410    if (mdct_weight_shift)
1411    {
1412       int m;
1413       for (c=0;c<C;c++)
1414          for (m=mdct_weight_pos+1;m<st->mode->nbShortMdcts;m++)
1415             for (i=m*C+c;i<N;i+=C*st->mode->nbShortMdcts)
1416 #ifdef FIXED_POINT
1417                freq[i] = SHL32(freq[i], mdct_weight_shift);
1418 #else
1419                freq[i] = (1<<mdct_weight_shift)*freq[i];
1420 #endif
1421    }
1422    /* Compute inverse MDCTs */
1423    compute_inv_mdcts(st->mode, shortBlocks, freq, transient_time, transient_shift, st->out_mem);
1424
1425    for (c=0;c<C;c++)
1426    {
1427       int j;
1428       for (j=0;j<N;j++)
1429       {
1430          celt_sig_t tmp = MAC16_32_Q15(st->out_mem[C*(MAX_PERIOD-N)+C*j+c],
1431                                 preemph,st->preemph_memD[c]);
1432          st->preemph_memD[c] = tmp;
1433          pcm[C*j+c] = SCALEOUT(SIG2WORD16(tmp));
1434       }
1435    }
1436
1437    RESTORE_STACK;
1438    return 0;
1439    /*printf ("\n");*/
1440 }
1441
1442 #ifdef FIXED_POINT
1443 #ifndef DISABLE_FLOAT_API
1444 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm)
1445 {
1446    int j, ret, C, N;
1447    VARDECL(celt_int16_t, out);
1448
1449    if (check_decoder(st) != CELT_OK)
1450       return CELT_INVALID_STATE;
1451
1452    if (check_mode(st->mode) != CELT_OK)
1453       return CELT_INVALID_MODE;
1454
1455    SAVE_STACK;
1456    C = CHANNELS(st->mode);
1457    N = st->block_size;
1458    ALLOC(out, C*N, celt_int16_t);
1459
1460    ret=celt_decode(st, data, len, out);
1461
1462    for (j=0;j<C*N;j++)
1463      pcm[j]=out[j]*(1/32768.);
1464    RESTORE_STACK;
1465    return ret;
1466 }
1467 #endif /*DISABLE_FLOAT_API*/
1468 #else
1469 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16_t * restrict pcm)
1470 {
1471    int j, ret, C, N;
1472    VARDECL(celt_sig_t, out);
1473
1474    if (check_decoder(st) != CELT_OK)
1475       return CELT_INVALID_STATE;
1476
1477    if (check_mode(st->mode) != CELT_OK)
1478       return CELT_INVALID_MODE;
1479
1480    SAVE_STACK;
1481    C = CHANNELS(st->mode);
1482    N = st->block_size;
1483    ALLOC(out, C*N, celt_sig_t);
1484
1485    ret=celt_decode_float(st, data, len, out);
1486
1487    for (j=0;j<C*N;j++)
1488      pcm[j] = FLOAT2INT16 (out[j]);
1489
1490    RESTORE_STACK;
1491    return ret;
1492 }
1493 #endif
1494
1495 int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
1496 {
1497    va_list ap;
1498
1499    if (check_decoder(st) != CELT_OK)
1500       return CELT_INVALID_STATE;
1501
1502    va_start(ap, request);
1503    if ((request!=CELT_GET_MODE_REQUEST) && (check_mode(st->mode) != CELT_OK))
1504      goto bad_mode;
1505    switch (request)
1506    {
1507       case CELT_GET_MODE_REQUEST:
1508       {
1509          const CELTMode ** value = va_arg(ap, const CELTMode**);
1510          if (value==0)
1511             goto bad_arg;
1512          *value=st->mode;
1513       }
1514       break;
1515       case CELT_RESET_STATE:
1516       {
1517          const CELTMode *mode = st->mode;
1518          int C = mode->nbChannels;
1519
1520          CELT_MEMSET(st->decode_mem, 0, (DECODE_BUFFER_SIZE+st->overlap)*C);
1521          CELT_MEMSET(st->oldBandE, 0, C*mode->nbEBands);
1522
1523          CELT_MEMSET(st->preemph_memD, 0, C);
1524
1525          st->last_pitch_index = 0;
1526       }
1527       break;
1528       default:
1529          goto bad_request;
1530    }
1531    va_end(ap);
1532    return CELT_OK;
1533 bad_mode:
1534   va_end(ap);
1535   return CELT_INVALID_MODE;
1536 bad_arg:
1537    va_end(ap);
1538    return CELT_BAD_ARG;
1539 bad_request:
1540       va_end(ap);
1541   return CELT_UNIMPLEMENTED;
1542 }