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