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