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