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