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