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