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