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