Fix missing break statements
[opus.git] / libcelt / celt.c
1 /* Copyright (c) 2007-2008 CSIRO
2    Copyright (c) 2007-2010 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    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
21    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
23    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
24    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
25    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
26    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 #ifdef HAVE_CONFIG_H
31 #include "config.h"
32 #endif
33
34 #define CELT_C
35
36 /* Always enable postfilter for Opus */
37 #if defined(OPUS_BUILD) && !defined(ENABLE_POSTFILTER)
38 #define ENABLE_POSTFILTER
39 #endif
40
41 #include "os_support.h"
42 #include "mdct.h"
43 #include <math.h>
44 #include "celt.h"
45 #include "pitch.h"
46 #include "bands.h"
47 #include "modes.h"
48 #include "entcode.h"
49 #include "quant_bands.h"
50 #include "rate.h"
51 #include "stack_alloc.h"
52 #include "mathops.h"
53 #include "float_cast.h"
54 #include <stdarg.h>
55 #include "plc.h"
56 #include "vq.h"
57
58 static const unsigned char trim_icdf[11] = {126, 124, 119, 109, 87, 41, 19, 9, 4, 2, 0};
59 /* Probs: NONE: 21.875%, LIGHT: 6.25%, NORMAL: 65.625%, AGGRESSIVE: 6.25% */
60 static const unsigned char spread_icdf[4] = {25, 23, 2, 0};
61
62 static const unsigned char tapset_icdf[3]={2,1,0};
63
64 #define COMBFILTER_MAXPERIOD 1024
65 #define COMBFILTER_MINPERIOD 15
66
67 static int resampling_factor(celt_int32 rate)
68 {
69    int ret;
70    switch (rate)
71    {
72    case 48000:
73       ret = 1;
74       break;
75    case 24000:
76       ret = 2;
77       break;
78    case 16000:
79       ret = 3;
80       break;
81    case 12000:
82       ret = 4;
83       break;
84    case 8000:
85       ret = 6;
86       break;
87    default:
88       ret = 0;
89    }
90    return ret;
91 }
92
93 /** Encoder state 
94  @brief Encoder state
95  */
96 struct CELTEncoder {
97    const CELTMode *mode;     /**< Mode used by the encoder */
98    int overlap;
99    int channels;
100    int stream_channels;
101    
102    int force_intra;
103    int clip;
104    int disable_pf;
105    int complexity;
106    int upsample;
107    int start, end;
108
109    celt_int32 bitrate;
110    int vbr;
111    int signalling;
112    int constrained_vbr;      /* If zero, VBR can do whatever it likes with the rate */
113
114    /* Everything beyond this point gets cleared on a reset */
115 #define ENCODER_RESET_START rng
116
117    celt_uint32 rng;
118    int spread_decision;
119    int delayedIntra;
120    int tonal_average;
121    int lastCodedBands;
122    int hf_average;
123    int tapset_decision;
124
125    int prefilter_period;
126    celt_word16 prefilter_gain;
127    int prefilter_tapset;
128 #ifdef RESYNTH
129    int prefilter_period_old;
130    celt_word16 prefilter_gain_old;
131    int prefilter_tapset_old;
132 #endif
133    int consec_transient;
134
135    /* VBR-related parameters */
136    celt_int32 vbr_reservoir;
137    celt_int32 vbr_drift;
138    celt_int32 vbr_offset;
139    celt_int32 vbr_count;
140
141    celt_word32 preemph_memE[2];
142    celt_word32 preemph_memD[2];
143
144 #ifdef RESYNTH
145    celt_sig syn_mem[2][2*MAX_PERIOD];
146 #endif
147
148    celt_sig in_mem[1]; /* Size = channels*mode->overlap */
149    /* celt_sig prefilter_mem[],  Size = channels*COMBFILTER_PERIOD */
150    /* celt_sig overlap_mem[],  Size = channels*mode->overlap */
151    /* celt_word16 oldEBands[], Size = 2*channels*mode->nbEBands */
152 };
153
154 int celt_encoder_get_size(int channels)
155 {
156    CELTMode *mode = celt_mode_create(48000, 960, NULL);
157    return celt_encoder_get_size_custom(mode, channels);
158 }
159
160 int celt_encoder_get_size_custom(const CELTMode *mode, int channels)
161 {
162    int size = sizeof(struct CELTEncoder)
163          + (2*channels*mode->overlap-1)*sizeof(celt_sig)
164          + channels*COMBFILTER_MAXPERIOD*sizeof(celt_sig)
165          + 3*channels*mode->nbEBands*sizeof(celt_word16);
166    return size;
167 }
168
169 CELTEncoder *celt_encoder_create(int sampling_rate, int channels, int *error)
170 {
171    CELTEncoder *st;
172    st = (CELTEncoder *)celt_alloc(celt_encoder_get_size(channels));
173    if (st!=NULL && celt_encoder_init(st, sampling_rate, channels, error)==NULL)
174    {
175       celt_encoder_destroy(st);
176       st = NULL;
177    }
178    return st;
179 }
180
181 CELTEncoder *celt_encoder_create_custom(const CELTMode *mode, int channels, int *error)
182 {
183    CELTEncoder *st = (CELTEncoder *)celt_alloc(celt_encoder_get_size_custom(mode, channels));
184    if (st!=NULL && celt_encoder_init_custom(st, mode, channels, error)==NULL)
185    {
186       celt_encoder_destroy(st);
187       st = NULL;
188    }
189    return st;
190 }
191
192 CELTEncoder *celt_encoder_init(CELTEncoder *st, int sampling_rate, int channels, int *error)
193 {
194    celt_encoder_init_custom(st, celt_mode_create(48000, 960, NULL), channels, error);
195    st->upsample = resampling_factor(sampling_rate);
196    if (st->upsample==0)
197    {
198       if (error)
199          *error = CELT_BAD_ARG;
200       return NULL;
201    }
202    return st;
203 }
204
205 CELTEncoder *celt_encoder_init_custom(CELTEncoder *st, const CELTMode *mode, int channels, int *error)
206 {
207    if (channels < 0 || channels > 2)
208    {
209       if (error)
210          *error = CELT_BAD_ARG;
211       return NULL;
212    }
213
214    if (st==NULL || mode==NULL)
215    {
216       if (error)
217          *error = CELT_ALLOC_FAIL;
218       return NULL;
219    }
220
221    CELT_MEMSET((char*)st, 0, celt_encoder_get_size_custom(mode, channels));
222    
223    st->mode = mode;
224    st->overlap = mode->overlap;
225    st->stream_channels = st->channels = channels;
226
227    st->upsample = 1;
228    st->start = 0;
229    st->end = st->mode->effEBands;
230    st->signalling = 1;
231
232    st->constrained_vbr = 1;
233    st->clip = 1;
234
235    st->bitrate = 255000*channels;
236    st->vbr = 0;
237    st->vbr_offset = 0;
238    st->force_intra  = 0;
239    st->delayedIntra = 1;
240    st->tonal_average = 256;
241    st->spread_decision = SPREAD_NORMAL;
242    st->hf_average = 0;
243    st->tapset_decision = 0;
244    st->complexity = 5;
245
246    if (error)
247       *error = CELT_OK;
248    return st;
249 }
250
251 void celt_encoder_destroy(CELTEncoder *st)
252 {
253    celt_free(st);
254 }
255
256 static inline celt_int16 FLOAT2INT16(float x)
257 {
258    x = x*CELT_SIG_SCALE;
259    x = MAX32(x, -32768);
260    x = MIN32(x, 32767);
261    return (celt_int16)float2int(x);
262 }
263
264 static inline celt_word16 SIG2WORD16(celt_sig x)
265 {
266 #ifdef FIXED_POINT
267    x = PSHR32(x, SIG_SHIFT);
268    x = MAX32(x, -32768);
269    x = MIN32(x, 32767);
270    return EXTRACT16(x);
271 #else
272    return (celt_word16)x;
273 #endif
274 }
275
276 static int transient_analysis(const celt_word32 * restrict in, int len, int C,
277                               int overlap)
278 {
279    int i;
280    VARDECL(celt_word16, tmp);
281    celt_word32 mem0=0,mem1=0;
282    int is_transient = 0;
283    int block;
284    int N;
285    /* FIXME: Make that smaller */
286    celt_word16 bins[50];
287    SAVE_STACK;
288    ALLOC(tmp, len, celt_word16);
289
290    block = overlap/2;
291    N=len/block;
292    if (C==1)
293    {
294       for (i=0;i<len;i++)
295          tmp[i] = SHR32(in[i],SIG_SHIFT);
296    } else {
297       for (i=0;i<len;i++)
298          tmp[i] = SHR32(ADD32(in[i],in[i+len]), SIG_SHIFT+1);
299    }
300
301    /* High-pass filter: (1 - 2*z^-1 + z^-2) / (1 - z^-1 + .5*z^-2) */
302    for (i=0;i<len;i++)
303    {
304       celt_word32 x,y;
305       x = tmp[i];
306       y = ADD32(mem0, x);
307 #ifdef FIXED_POINT
308       mem0 = mem1 + y - SHL32(x,1);
309       mem1 = x - SHR32(y,1);
310 #else
311       mem0 = mem1 + y - 2*x;
312       mem1 = x - .5f*y;
313 #endif
314       tmp[i] = EXTRACT16(SHR(y,2));
315    }
316    /* First few samples are bad because we don't propagate the memory */
317    for (i=0;i<12;i++)
318       tmp[i] = 0;
319
320    for (i=0;i<N;i++)
321    {
322       int j;
323       celt_word16 max_abs=0;
324       for (j=0;j<block;j++)
325          max_abs = MAX16(max_abs, ABS16(tmp[i*block+j]));
326       bins[i] = max_abs;
327    }
328    for (i=0;i<N;i++)
329    {
330       int j;
331       int conseq=0;
332       celt_word16 t1, t2, t3;
333
334       t1 = MULT16_16_Q15(QCONST16(.15f, 15), bins[i]);
335       t2 = MULT16_16_Q15(QCONST16(.4f, 15), bins[i]);
336       t3 = MULT16_16_Q15(QCONST16(.15f, 15), bins[i]);
337       for (j=0;j<i;j++)
338       {
339          if (bins[j] < t1)
340             conseq++;
341          if (bins[j] < t2)
342             conseq++;
343          else
344             conseq = 0;
345       }
346       if (conseq>=3)
347          is_transient=1;
348       conseq = 0;
349       for (j=i+1;j<N;j++)
350       {
351          if (bins[j] < t3)
352             conseq++;
353          else
354             conseq = 0;
355       }
356       if (conseq>=7)
357          is_transient=1;
358    }
359    RESTORE_STACK;
360    return is_transient;
361 }
362
363 /** Apply window and compute the MDCT for all sub-frames and 
364     all channels in a frame */
365 static void compute_mdcts(const CELTMode *mode, int shortBlocks, celt_sig * restrict in, celt_sig * restrict out, int _C, int LM)
366 {
367    const int C = CHANNELS(_C);
368    if (C==1 && !shortBlocks)
369    {
370       const int overlap = OVERLAP(mode);
371       clt_mdct_forward(&mode->mdct, in, out, mode->window, overlap, mode->maxLM-LM);
372    } else {
373       const int overlap = OVERLAP(mode);
374       int N = mode->shortMdctSize<<LM;
375       int B = 1;
376       int b, c;
377       VARDECL(celt_word32, tmp);
378       SAVE_STACK;
379       if (shortBlocks)
380       {
381          /*lookup = &mode->mdct[0];*/
382          N = mode->shortMdctSize;
383          B = shortBlocks;
384       }
385       ALLOC(tmp, N, celt_word32);
386       c=0; do {
387          for (b=0;b<B;b++)
388          {
389             int j;
390             clt_mdct_forward(&mode->mdct, in+c*(B*N+overlap)+b*N, tmp, mode->window, overlap, shortBlocks ? mode->maxLM : mode->maxLM-LM);
391             /* Interleaving the sub-frames */
392             for (j=0;j<N;j++)
393                out[(j*B+b)+c*N*B] = tmp[j];
394          }
395       } while (++c<C);
396       RESTORE_STACK;
397    }
398 }
399
400 /** Compute the IMDCT and apply window for all sub-frames and 
401     all channels in a frame */
402 static void compute_inv_mdcts(const CELTMode *mode, int shortBlocks, celt_sig *X,
403       celt_sig * restrict out_mem[],
404       celt_sig * restrict overlap_mem[], int _C, int LM)
405 {
406    int c;
407    const int C = CHANNELS(_C);
408    const int N = mode->shortMdctSize<<LM;
409    const int overlap = OVERLAP(mode);
410    c=0; do {
411       int j;
412          VARDECL(celt_word32, x);
413          VARDECL(celt_word32, tmp);
414          int b;
415          int N2 = N;
416          int B = 1;
417          SAVE_STACK;
418          
419          ALLOC(x, N+overlap, celt_word32);
420          ALLOC(tmp, N, celt_word32);
421
422          if (shortBlocks)
423          {
424             N2 = mode->shortMdctSize;
425             B = shortBlocks;
426          }
427          /* Prevents problems from the imdct doing the overlap-add */
428          CELT_MEMSET(x, 0, overlap);
429
430          for (b=0;b<B;b++)
431          {
432             /* De-interleaving the sub-frames */
433             for (j=0;j<N2;j++)
434                tmp[j] = X[(j*B+b)+c*N2*B];
435             clt_mdct_backward(&mode->mdct, tmp, x+N2*b, mode->window, overlap, shortBlocks ? mode->maxLM : mode->maxLM-LM);
436          }
437
438          for (j=0;j<overlap;j++)
439             out_mem[c][j] = x[j] + overlap_mem[c][j];
440          for (;j<N;j++)
441             out_mem[c][j] = x[j];
442          for (j=0;j<overlap;j++)
443             overlap_mem[c][j] = x[N+j];
444          RESTORE_STACK;
445    } while (++c<C);
446 }
447
448 static void deemphasis(celt_sig *in[], celt_word16 *pcm, int N, int _C, int downsample, const celt_word16 *coef, celt_sig *mem)
449 {
450    const int C = CHANNELS(_C);
451    int c;
452    int count=0;
453    c=0; do {
454       int j;
455       celt_sig * restrict x;
456       celt_word16  * restrict y;
457       celt_sig m = mem[c];
458       x =in[c];
459       y = pcm+c;
460       for (j=0;j<N;j++)
461       {
462          celt_sig tmp = *x + m;
463          m = MULT16_32_Q15(coef[0], tmp)
464            - MULT16_32_Q15(coef[1], *x);
465          tmp = SHL32(MULT16_32_Q15(coef[3], tmp), 2);
466          x++;
467          /* Technically the store could be moved outside of the if because
468             the stores we don't want will just be overwritten */
469          if (++count==downsample)
470          {
471             *y = SCALEOUT(SIG2WORD16(tmp));
472             y+=C;
473             count=0;
474          }
475       }
476       mem[c] = m;
477    } while (++c<C);
478 }
479
480 #ifdef ENABLE_POSTFILTER
481 static void comb_filter(celt_word32 *y, celt_word32 *x, int T0, int T1, int N,
482       celt_word16 g0, celt_word16 g1, int tapset0, int tapset1,
483       const celt_word16 *window, int overlap)
484 {
485    int i;
486    /* printf ("%d %d %f %f\n", T0, T1, g0, g1); */
487    celt_word16 g00, g01, g02, g10, g11, g12;
488    static const celt_word16 gains[3][3] = {
489          {QCONST16(0.3066406250f, 15), QCONST16(0.2170410156f, 15), QCONST16(0.1296386719f, 15)},
490          {QCONST16(0.4638671875f, 15), QCONST16(0.2680664062f, 15), QCONST16(0.f, 15)},
491          {QCONST16(0.7998046875f, 15), QCONST16(0.1000976562f, 15), QCONST16(0.f, 15)}};
492    g00 = MULT16_16_Q15(g0, gains[tapset0][0]);
493    g01 = MULT16_16_Q15(g0, gains[tapset0][1]);
494    g02 = MULT16_16_Q15(g0, gains[tapset0][2]);
495    g10 = MULT16_16_Q15(g1, gains[tapset1][0]);
496    g11 = MULT16_16_Q15(g1, gains[tapset1][1]);
497    g12 = MULT16_16_Q15(g1, gains[tapset1][2]);
498    for (i=0;i<overlap;i++)
499    {
500       celt_word16 f;
501       f = MULT16_16_Q15(window[i],window[i]);
502       y[i] = x[i]
503                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g00),x[i-T0])
504                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g01),x[i-T0-1])
505                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g01),x[i-T0+1])
506                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g02),x[i-T0-2])
507                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g02),x[i-T0+2])
508                + MULT16_32_Q15(MULT16_16_Q15(f,g10),x[i-T1])
509                + MULT16_32_Q15(MULT16_16_Q15(f,g11),x[i-T1-1])
510                + MULT16_32_Q15(MULT16_16_Q15(f,g11),x[i-T1+1])
511                + MULT16_32_Q15(MULT16_16_Q15(f,g12),x[i-T1-2])
512                + MULT16_32_Q15(MULT16_16_Q15(f,g12),x[i-T1+2]);
513
514    }
515    for (i=overlap;i<N;i++)
516       y[i] = x[i]
517                + MULT16_32_Q15(g10,x[i-T1])
518                + MULT16_32_Q15(g11,x[i-T1-1])
519                + MULT16_32_Q15(g11,x[i-T1+1])
520                + MULT16_32_Q15(g12,x[i-T1-2])
521                + MULT16_32_Q15(g12,x[i-T1+2]);
522 }
523 #endif /* ENABLE_POSTFILTER */
524
525 static const signed char tf_select_table[4][8] = {
526       {0, -1, 0, -1,    0,-1, 0,-1},
527       {0, -1, 0, -2,    1, 0, 1,-1},
528       {0, -2, 0, -3,    2, 0, 1,-1},
529       {0, -2, 0, -3,    3, 0, 1,-1},
530 };
531
532 static celt_word32 l1_metric(const celt_norm *tmp, int N, int LM, int width)
533 {
534    int i, j;
535    static const celt_word16 sqrtM_1[4] = {Q15ONE, QCONST16(.70710678f,15), QCONST16(0.5f,15), QCONST16(0.35355339f,15)};
536    celt_word32 L1;
537    celt_word16 bias;
538    L1=0;
539    for (i=0;i<1<<LM;i++)
540    {
541       celt_word32 L2 = 0;
542       for (j=0;j<N>>LM;j++)
543          L2 = MAC16_16(L2, tmp[(j<<LM)+i], tmp[(j<<LM)+i]);
544       L1 += celt_sqrt(L2);
545    }
546    L1 = MULT16_32_Q15(sqrtM_1[LM], L1);
547    if (width==1)
548       bias = QCONST16(.12f,15)*LM;
549    else if (width==2)
550       bias = QCONST16(.05f,15)*LM;
551    else
552       bias = QCONST16(.02f,15)*LM;
553    L1 = MAC16_32_Q15(L1, bias, L1);
554    return L1;
555 }
556
557 static int tf_analysis(const CELTMode *m, celt_word16 *bandLogE, celt_word16 *oldBandE,
558       int len, int C, int isTransient, int *tf_res, int nbCompressedBytes, celt_norm *X,
559       int N0, int LM, int *tf_sum)
560 {
561    int i;
562    VARDECL(int, metric);
563    int cost0;
564    int cost1;
565    VARDECL(int, path0);
566    VARDECL(int, path1);
567    VARDECL(celt_norm, tmp);
568    int lambda;
569    int tf_select=0;
570    SAVE_STACK;
571
572    if (nbCompressedBytes<15*C)
573    {
574       *tf_sum = 0;
575       for (i=0;i<len;i++)
576          tf_res[i] = isTransient;
577       return 0;
578    }
579    if (nbCompressedBytes<40)
580       lambda = 12;
581    else if (nbCompressedBytes<60)
582       lambda = 6;
583    else if (nbCompressedBytes<100)
584       lambda = 4;
585    else
586       lambda = 3;
587
588    ALLOC(metric, len, int);
589    ALLOC(tmp, (m->eBands[len]-m->eBands[len-1])<<LM, celt_norm);
590    ALLOC(path0, len, int);
591    ALLOC(path1, len, int);
592
593    *tf_sum = 0;
594    for (i=0;i<len;i++)
595    {
596       int j, k, N;
597       celt_word32 L1, best_L1;
598       int best_level=0;
599       N = (m->eBands[i+1]-m->eBands[i])<<LM;
600       for (j=0;j<N;j++)
601          tmp[j] = X[j+(m->eBands[i]<<LM)];
602       /* Just add the right channel if we're in stereo */
603       if (C==2)
604          for (j=0;j<N;j++)
605             tmp[j] = ADD16(tmp[j],X[N0+j+(m->eBands[i]<<LM)]);
606       L1 = l1_metric(tmp, N, isTransient ? LM : 0, N>>LM);
607       best_L1 = L1;
608       /*printf ("%f ", L1);*/
609       for (k=0;k<LM;k++)
610       {
611          int B;
612
613          if (isTransient)
614             B = (LM-k-1);
615          else
616             B = k+1;
617
618          if (isTransient)
619             haar1(tmp, N>>(LM-k), 1<<(LM-k));
620          else
621             haar1(tmp, N>>k, 1<<k);
622
623          L1 = l1_metric(tmp, N, B, N>>LM);
624
625          if (L1 < best_L1)
626          {
627             best_L1 = L1;
628             best_level = k+1;
629          }
630       }
631       /*printf ("%d ", isTransient ? LM-best_level : best_level);*/
632       if (isTransient)
633          metric[i] = best_level;
634       else
635          metric[i] = -best_level;
636       *tf_sum += metric[i];
637    }
638    /*printf("\n");*/
639    /* FIXME: Figure out how to set this */
640    tf_select = 0;
641
642    cost0 = 0;
643    cost1 = isTransient ? 0 : lambda;
644    /* Viterbi forward pass */
645    for (i=1;i<len;i++)
646    {
647       int curr0, curr1;
648       int from0, from1;
649
650       from0 = cost0;
651       from1 = cost1 + lambda;
652       if (from0 < from1)
653       {
654          curr0 = from0;
655          path0[i]= 0;
656       } else {
657          curr0 = from1;
658          path0[i]= 1;
659       }
660
661       from0 = cost0 + lambda;
662       from1 = cost1;
663       if (from0 < from1)
664       {
665          curr1 = from0;
666          path1[i]= 0;
667       } else {
668          curr1 = from1;
669          path1[i]= 1;
670       }
671       cost0 = curr0 + abs(metric[i]-tf_select_table[LM][4*isTransient+2*tf_select+0]);
672       cost1 = curr1 + abs(metric[i]-tf_select_table[LM][4*isTransient+2*tf_select+1]);
673    }
674    tf_res[len-1] = cost0 < cost1 ? 0 : 1;
675    /* Viterbi backward pass to check the decisions */
676    for (i=len-2;i>=0;i--)
677    {
678       if (tf_res[i+1] == 1)
679          tf_res[i] = path1[i+1];
680       else
681          tf_res[i] = path0[i+1];
682    }
683    RESTORE_STACK;
684    return tf_select;
685 }
686
687 static void tf_encode(int start, int end, int isTransient, int *tf_res, int LM, int tf_select, ec_enc *enc)
688 {
689    int curr, i;
690    int tf_select_rsv;
691    int tf_changed;
692    int logp;
693    celt_uint32 budget;
694    celt_uint32 tell;
695    budget = enc->storage*8;
696    tell = ec_tell(enc);
697    logp = isTransient ? 2 : 4;
698    /* Reserve space to code the tf_select decision. */
699    tf_select_rsv = LM>0 && tell+logp+1 <= budget;
700    budget -= tf_select_rsv;
701    curr = tf_changed = 0;
702    for (i=start;i<end;i++)
703    {
704       if (tell+logp<=budget)
705       {
706          ec_enc_bit_logp(enc, tf_res[i] ^ curr, logp);
707          tell = ec_tell(enc);
708          curr = tf_res[i];
709          tf_changed |= curr;
710       }
711       else
712          tf_res[i] = curr;
713       logp = isTransient ? 4 : 5;
714    }
715    /* Only code tf_select if it would actually make a difference. */
716    if (tf_select_rsv &&
717          tf_select_table[LM][4*isTransient+0+tf_changed]!=
718          tf_select_table[LM][4*isTransient+2+tf_changed])
719       ec_enc_bit_logp(enc, tf_select, 1);
720    else
721       tf_select = 0;
722    for (i=start;i<end;i++)
723       tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]];
724    /*printf("%d %d ", isTransient, tf_select); for(i=0;i<end;i++)printf("%d ", tf_res[i]);printf("\n");*/
725 }
726
727 static void tf_decode(int start, int end, int isTransient, int *tf_res, int LM, ec_dec *dec)
728 {
729    int i, curr, tf_select;
730    int tf_select_rsv;
731    int tf_changed;
732    int logp;
733    celt_uint32 budget;
734    celt_uint32 tell;
735
736    budget = dec->storage*8;
737    tell = ec_tell(dec);
738    logp = isTransient ? 2 : 4;
739    tf_select_rsv = LM>0 && tell+logp+1<=budget;
740    budget -= tf_select_rsv;
741    tf_changed = curr = 0;
742    for (i=start;i<end;i++)
743    {
744       if (tell+logp<=budget)
745       {
746          curr ^= ec_dec_bit_logp(dec, logp);
747          tell = ec_tell(dec);
748          tf_changed |= curr;
749       }
750       tf_res[i] = curr;
751       logp = isTransient ? 4 : 5;
752    }
753    tf_select = 0;
754    if (tf_select_rsv &&
755      tf_select_table[LM][4*isTransient+0+tf_changed] !=
756      tf_select_table[LM][4*isTransient+2+tf_changed])
757    {
758       tf_select = ec_dec_bit_logp(dec, 1);
759    }
760    for (i=start;i<end;i++)
761    {
762       tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]];
763    }
764 }
765
766 static void init_caps(const CELTMode *m,int *cap,int LM,int C)
767 {
768    int i;
769    for (i=0;i<m->nbEBands;i++)
770    {
771       int N;
772       N=(m->eBands[i+1]-m->eBands[i])<<LM;
773       cap[i] = (m->cache.caps[m->nbEBands*(2*LM+C-1)+i]+64)*C*N>>2;
774    }
775 }
776
777 static int alloc_trim_analysis(const CELTMode *m, const celt_norm *X,
778       const celt_word16 *bandLogE, int end, int LM, int C, int N0)
779 {
780    int i;
781    celt_word32 diff=0;
782    int c;
783    int trim_index = 5;
784    if (C==2)
785    {
786       celt_word16 sum = 0; /* Q10 */
787       /* Compute inter-channel correlation for low frequencies */
788       for (i=0;i<8;i++)
789       {
790          int j;
791          celt_word32 partial = 0;
792          for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++)
793             partial = MAC16_16(partial, X[j], X[N0+j]);
794          sum = ADD16(sum, EXTRACT16(SHR32(partial, 18)));
795       }
796       sum = MULT16_16_Q15(QCONST16(1.f/8, 15), sum);
797       /*printf ("%f\n", sum);*/
798       if (sum > QCONST16(.995f,10))
799          trim_index-=4;
800       else if (sum > QCONST16(.92f,10))
801          trim_index-=3;
802       else if (sum > QCONST16(.85f,10))
803          trim_index-=2;
804       else if (sum > QCONST16(.8f,10))
805          trim_index-=1;
806    }
807
808    /* Estimate spectral tilt */
809    c=0; do {
810       for (i=0;i<end-1;i++)
811       {
812          diff += bandLogE[i+c*m->nbEBands]*(celt_int32)(2+2*i-m->nbEBands);
813       }
814    } while (++c<0);
815    diff /= C*(end-1);
816    /*printf("%f\n", diff);*/
817    if (diff > QCONST16(2.f, DB_SHIFT))
818       trim_index--;
819    if (diff > QCONST16(8.f, DB_SHIFT))
820       trim_index--;
821    if (diff < -QCONST16(4.f, DB_SHIFT))
822       trim_index++;
823    if (diff < -QCONST16(10.f, DB_SHIFT))
824       trim_index++;
825
826    if (trim_index<0)
827       trim_index = 0;
828    if (trim_index>10)
829       trim_index = 10;
830    return trim_index;
831 }
832
833 static int stereo_analysis(const CELTMode *m, const celt_norm *X,
834       int LM, int N0)
835 {
836    int i;
837    int thetas;
838    celt_word32 sumLR = EPSILON, sumMS = EPSILON;
839
840    /* Use the L1 norm to model the entropy of the L/R signal vs the M/S signal */
841    for (i=0;i<13;i++)
842    {
843       int j;
844       for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++)
845       {
846          celt_word16 L, R, M, S;
847          L = X[j];
848          R = X[N0+j];
849          M = L+R;
850          S = L-R;
851          sumLR += EXTEND32(ABS16(L)) + EXTEND32(ABS16(R));
852          sumMS += EXTEND32(ABS16(M)) + EXTEND32(ABS16(S));
853       }
854    }
855    sumMS = MULT16_32_Q15(QCONST16(0.707107f, 15), sumMS);
856    thetas = 13;
857    /* We don't need thetas for lower bands with LM<=1 */
858    if (LM<=1)
859       thetas -= 8;
860    return MULT16_32_Q15((m->eBands[13]<<(LM+1))+thetas, sumMS)
861          > MULT16_32_Q15(m->eBands[13]<<(LM+1), sumLR);
862 }
863
864 #ifdef FIXED_POINT
865 CELT_STATIC
866 int celt_encode_with_ec(CELTEncoder * restrict st, const celt_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
867 {
868 #else
869 CELT_STATIC
870 int celt_encode_with_ec_float(CELTEncoder * restrict st, const celt_sig * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
871 {
872 #endif
873    int i, c, N;
874    celt_int32 bits;
875    ec_enc _enc;
876    VARDECL(celt_sig, in);
877    VARDECL(celt_sig, freq);
878    VARDECL(celt_norm, X);
879    VARDECL(celt_ener, bandE);
880    VARDECL(celt_word16, bandLogE);
881    VARDECL(int, fine_quant);
882    VARDECL(celt_word16, error);
883    VARDECL(int, pulses);
884    VARDECL(int, cap);
885    VARDECL(int, offsets);
886    VARDECL(int, fine_priority);
887    VARDECL(int, tf_res);
888    VARDECL(unsigned char, collapse_masks);
889    celt_sig *_overlap_mem;
890    celt_sig *prefilter_mem;
891    celt_word16 *oldBandE, *oldLogE, *oldLogE2;
892    int shortBlocks=0;
893    int isTransient=0;
894    int resynth;
895    const int CC = CHANNELS(st->channels);
896    const int C = CHANNELS(st->stream_channels);
897    int LM, M;
898    int tf_select;
899    int nbFilledBytes, nbAvailableBytes;
900    int effEnd;
901    int codedBands;
902    int tf_sum;
903    int alloc_trim;
904    int pitch_index=COMBFILTER_MINPERIOD;
905    celt_word16 gain1 = 0;
906    int intensity=0;
907    int dual_stereo=0;
908    int effectiveBytes;
909    celt_word16 pf_threshold;
910    int dynalloc_logp;
911    celt_int32 vbr_rate;
912    celt_int32 total_bits;
913    celt_int32 total_boost;
914    celt_int32 balance;
915    celt_int32 tell;
916    int prefilter_tapset=0;
917    int pf_on;
918    int anti_collapse_rsv;
919    int anti_collapse_on=0;
920    int silence=0;
921    ALLOC_STACK;
922    SAVE_STACK;
923
924    if (nbCompressedBytes<2 || pcm==NULL)
925      return CELT_BAD_ARG;
926
927    frame_size *= st->upsample;
928    for (LM=0;LM<=st->mode->maxLM;LM++)
929       if (st->mode->shortMdctSize<<LM==frame_size)
930          break;
931    if (LM>st->mode->maxLM)
932       return CELT_BAD_ARG;
933    M=1<<LM;
934    N = M*st->mode->shortMdctSize;
935
936    prefilter_mem = st->in_mem+CC*(st->overlap);
937    _overlap_mem = prefilter_mem+CC*COMBFILTER_MAXPERIOD;
938    /*_overlap_mem = st->in_mem+C*(st->overlap);*/
939    oldBandE = (celt_word16*)(st->in_mem+CC*(2*st->overlap+COMBFILTER_MAXPERIOD));
940    oldLogE = oldBandE + CC*st->mode->nbEBands;
941    oldLogE2 = oldLogE + CC*st->mode->nbEBands;
942
943    if (enc==NULL)
944    {
945       tell=1;
946       nbFilledBytes=0;
947    } else {
948       tell=ec_tell(enc);
949       nbFilledBytes=(tell+4)>>3;
950    }
951
952    if (st->signalling && enc==NULL)
953    {
954       int tmp = (st->mode->effEBands-st->end)>>1;
955       st->end = IMAX(1, st->mode->effEBands-tmp);
956       compressed[0] = tmp<<5;
957       compressed[0] |= LM<<3;
958       compressed[0] |= (C==2)<<2;
959       compressed++;
960       nbCompressedBytes--;
961    }
962
963    /* Can't produce more than 1275 output bytes */
964    nbCompressedBytes = IMIN(nbCompressedBytes,1275);
965    nbAvailableBytes = nbCompressedBytes - nbFilledBytes;
966
967    if (st->vbr)
968    {
969       celt_int32 den=st->mode->Fs>>BITRES;
970       vbr_rate=(st->bitrate*frame_size+(den>>1))/den;
971       if (st->signalling)
972          vbr_rate -= 8<<BITRES;
973       effectiveBytes = vbr_rate>>(3+BITRES);
974    } else {
975       celt_int32 tmp;
976       vbr_rate = 0;
977       tmp = st->bitrate*frame_size;
978       if (tell>1)
979          tmp += tell;
980       nbCompressedBytes = IMAX(2, IMIN(nbCompressedBytes,
981             (tmp+4*st->mode->Fs)/(8*st->mode->Fs)-!!st->signalling));
982       effectiveBytes = nbCompressedBytes;
983    }
984
985    if (enc==NULL)
986    {
987       ec_enc_init(&_enc, compressed, nbCompressedBytes);
988       enc = &_enc;
989    }
990
991    if (vbr_rate>0)
992    {
993       /* Computes the max bit-rate allowed in VBR mode to avoid violating the
994           target rate and buffering.
995          We must do this up front so that bust-prevention logic triggers
996           correctly if we don't have enough bits. */
997       if (st->constrained_vbr)
998       {
999          celt_int32 vbr_bound;
1000          celt_int32 max_allowed;
1001          /* We could use any multiple of vbr_rate as bound (depending on the
1002              delay).
1003             This is clamped to ensure we use at least two bytes if the encoder
1004              was entirely empty, but to allow 0 in hybrid mode. */
1005          vbr_bound = vbr_rate;
1006          max_allowed = IMIN(IMAX(tell==1?2:0,
1007                vbr_rate+vbr_bound-st->vbr_reservoir>>(BITRES+3)),
1008                nbAvailableBytes);
1009          if(max_allowed < nbAvailableBytes)
1010          {
1011             nbCompressedBytes = nbFilledBytes+max_allowed;
1012             nbAvailableBytes = max_allowed;
1013             ec_enc_shrink(enc, nbCompressedBytes);
1014          }
1015       }
1016    }
1017    total_bits = nbCompressedBytes*8;
1018
1019    effEnd = st->end;
1020    if (effEnd > st->mode->effEBands)
1021       effEnd = st->mode->effEBands;
1022
1023    ALLOC(in, CC*(N+st->overlap), celt_sig);
1024
1025    /* Find pitch period and gain */
1026    {
1027       VARDECL(celt_sig, _pre);
1028       celt_sig *pre[2];
1029       SAVE_STACK;
1030       ALLOC(_pre, CC*(N+COMBFILTER_MAXPERIOD), celt_sig);
1031
1032       pre[0] = _pre;
1033       pre[1] = _pre + (N+COMBFILTER_MAXPERIOD);
1034
1035       silence = 1;
1036       c=0; do {
1037          int count = 0;
1038          const celt_word16 * restrict pcmp = pcm+c;
1039          celt_sig * restrict inp = in+c*(N+st->overlap)+st->overlap;
1040
1041          for (i=0;i<N;i++)
1042          {
1043             celt_sig x, tmp;
1044
1045             x = SCALEIN(*pcmp);
1046 #ifndef FIXED_POINT
1047             if (st->clip)
1048                x = MAX32(-65536.f, MIN32(65536.f,x));
1049 #endif
1050             if (++count==st->upsample)
1051             {
1052                count=0;
1053                pcmp+=CC;
1054             } else {
1055                x = 0;
1056             }
1057             /* Apply pre-emphasis */
1058             tmp = MULT16_16(st->mode->preemph[2], x);
1059             *inp = tmp + st->preemph_memE[c];
1060             st->preemph_memE[c] = MULT16_32_Q15(st->mode->preemph[1], *inp)
1061                                    - MULT16_32_Q15(st->mode->preemph[0], tmp);
1062             silence = silence && *inp == 0;
1063             inp++;
1064          }
1065          CELT_COPY(pre[c], prefilter_mem+c*COMBFILTER_MAXPERIOD, COMBFILTER_MAXPERIOD);
1066          CELT_COPY(pre[c]+COMBFILTER_MAXPERIOD, in+c*(N+st->overlap)+st->overlap, N);
1067       } while (++c<CC);
1068
1069       if (tell==1)
1070          ec_enc_bit_logp(enc, silence, 15);
1071       else
1072          silence=0;
1073       if (silence)
1074       {
1075          /*In VBR mode there is no need to send more than the minimum. */
1076          if (vbr_rate>0)
1077          {
1078             effectiveBytes=nbCompressedBytes=IMIN(nbCompressedBytes, nbFilledBytes+2);
1079             total_bits=nbCompressedBytes*8;
1080             nbAvailableBytes=2;
1081             ec_enc_shrink(enc, nbCompressedBytes);
1082          }
1083          /* Pretend we've filled all the remaining bits with zeros
1084             (that's what the initialiser did anyway) */
1085          tell = nbCompressedBytes*8;
1086          enc->nbits_total+=tell-ec_tell(enc);
1087       }
1088 #ifdef ENABLE_POSTFILTER
1089       if (nbAvailableBytes>12*C && st->start==0 && !silence && !st->disable_pf && st->complexity >= 5)
1090       {
1091          VARDECL(celt_word16, pitch_buf);
1092          ALLOC(pitch_buf, (COMBFILTER_MAXPERIOD+N)>>1, celt_word16);
1093
1094          pitch_downsample(pre, pitch_buf, COMBFILTER_MAXPERIOD+N, CC);
1095          pitch_search(pitch_buf+(COMBFILTER_MAXPERIOD>>1), pitch_buf, N,
1096                COMBFILTER_MAXPERIOD-COMBFILTER_MINPERIOD, &pitch_index);
1097          pitch_index = COMBFILTER_MAXPERIOD-pitch_index;
1098
1099          gain1 = remove_doubling(pitch_buf, COMBFILTER_MAXPERIOD, COMBFILTER_MINPERIOD,
1100                N, &pitch_index, st->prefilter_period, st->prefilter_gain);
1101          if (pitch_index > COMBFILTER_MAXPERIOD-2)
1102             pitch_index = COMBFILTER_MAXPERIOD-2;
1103          gain1 = MULT16_16_Q15(QCONST16(.7f,15),gain1);
1104          prefilter_tapset = st->tapset_decision;
1105       } else {
1106          gain1 = 0;
1107       }
1108
1109       /* Gain threshold for enabling the prefilter/postfilter */
1110       pf_threshold = QCONST16(.2f,15);
1111
1112       /* Adjusting the threshold based on rate and continuity */
1113       if (abs(pitch_index-st->prefilter_period)*10>pitch_index)
1114          pf_threshold += QCONST16(.2f,15);
1115       if (nbAvailableBytes<25)
1116          pf_threshold += QCONST16(.1f,15);
1117       if (nbAvailableBytes<35)
1118          pf_threshold += QCONST16(.1f,15);
1119       if (st->prefilter_gain > QCONST16(.4f,15))
1120          pf_threshold -= QCONST16(.1f,15);
1121       if (st->prefilter_gain > QCONST16(.55f,15))
1122          pf_threshold -= QCONST16(.1f,15);
1123
1124       /* Hard threshold at 0.2 */
1125       pf_threshold = MAX16(pf_threshold, QCONST16(.2f,15));
1126       if (gain1<pf_threshold)
1127       {
1128          if(st->start==0 && tell+16<=total_bits)
1129             ec_enc_bit_logp(enc, 0, 1);
1130          gain1 = 0;
1131          pf_on = 0;
1132       } else {
1133          /*This block is not gated by a total bits check only because
1134            of the nbAvailableBytes check above.*/
1135          int qg;
1136          int octave;
1137
1138          if (ABS16(gain1-st->prefilter_gain)<QCONST16(.1f,15))
1139             gain1=st->prefilter_gain;
1140
1141 #ifdef FIXED_POINT
1142          qg = ((gain1+1536)>>10)/3-1;
1143 #else
1144          qg = floor(.5+gain1*32/3)-1;
1145 #endif
1146          qg = IMAX(0, IMIN(7, qg));
1147          ec_enc_bit_logp(enc, 1, 1);
1148          pitch_index += 1;
1149          octave = EC_ILOG(pitch_index)-5;
1150          ec_enc_uint(enc, octave, 6);
1151          ec_enc_bits(enc, pitch_index-(16<<octave), 4+octave);
1152          pitch_index -= 1;
1153          ec_enc_bits(enc, qg, 3);
1154          if (ec_tell(enc)+2<=total_bits)
1155             ec_enc_icdf(enc, prefilter_tapset, tapset_icdf, 2);
1156          else
1157            prefilter_tapset = 0;
1158          gain1 = QCONST16(0.09375f,15)*(qg+1);
1159          pf_on = 1;
1160       }
1161       /*printf("%d %f\n", pitch_index, gain1);*/
1162 #else /* ENABLE_POSTFILTER */
1163       if(st->start==0 && tell+16<=total_bits)
1164          ec_enc_bit_logp(enc, 0, 1);
1165       pf_on = 0;
1166 #endif /* ENABLE_POSTFILTER */
1167
1168       c=0; do {
1169          int offset = st->mode->shortMdctSize-st->mode->overlap;
1170          st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
1171          CELT_COPY(in+c*(N+st->overlap), st->in_mem+c*(st->overlap), st->overlap);
1172 #ifdef ENABLE_POSTFILTER
1173          if (offset)
1174             comb_filter(in+c*(N+st->overlap)+st->overlap, pre[c]+COMBFILTER_MAXPERIOD,
1175                   st->prefilter_period, st->prefilter_period, offset, -st->prefilter_gain, -st->prefilter_gain,
1176                   st->prefilter_tapset, st->prefilter_tapset, NULL, 0);
1177
1178          comb_filter(in+c*(N+st->overlap)+st->overlap+offset, pre[c]+COMBFILTER_MAXPERIOD+offset,
1179                st->prefilter_period, pitch_index, N-offset, -st->prefilter_gain, -gain1,
1180                st->prefilter_tapset, prefilter_tapset, st->mode->window, st->mode->overlap);
1181 #endif /* ENABLE_POSTFILTER */
1182          CELT_COPY(st->in_mem+c*(st->overlap), in+c*(N+st->overlap)+N, st->overlap);
1183
1184 #ifdef ENABLE_POSTFILTER
1185          if (N>COMBFILTER_MAXPERIOD)
1186          {
1187             CELT_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, pre[c]+N, COMBFILTER_MAXPERIOD);
1188          } else {
1189             CELT_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, prefilter_mem+c*COMBFILTER_MAXPERIOD+N, COMBFILTER_MAXPERIOD-N);
1190             CELT_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD+COMBFILTER_MAXPERIOD-N, pre[c]+COMBFILTER_MAXPERIOD, N);
1191          }
1192 #endif /* ENABLE_POSTFILTER */
1193       } while (++c<CC);
1194
1195       RESTORE_STACK;
1196    }
1197
1198 #ifdef RESYNTH
1199    resynth = 1;
1200 #else
1201    resynth = 0;
1202 #endif
1203
1204    isTransient = 0;
1205    shortBlocks = 0;
1206    if (LM>0 && ec_tell(enc)+3<=total_bits)
1207    {
1208       if (st->complexity > 1)
1209       {
1210          isTransient = transient_analysis(in, N+st->overlap, CC,
1211                   st->overlap);
1212          if (isTransient)
1213             shortBlocks = M;
1214       }
1215       ec_enc_bit_logp(enc, isTransient, 3);
1216    }
1217
1218    ALLOC(freq, CC*N, celt_sig); /**< Interleaved signal MDCTs */
1219    ALLOC(bandE,st->mode->nbEBands*CC, celt_ener);
1220    ALLOC(bandLogE,st->mode->nbEBands*CC, celt_word16);
1221    /* Compute MDCTs */
1222    compute_mdcts(st->mode, shortBlocks, in, freq, CC, LM);
1223
1224    if (CC==2&&C==1)
1225    {
1226       for (i=0;i<N;i++)
1227          freq[i] = ADD32(HALF32(freq[i]), HALF32(freq[N+i]));
1228    }
1229    if (st->upsample != 1)
1230    {
1231       c=0; do
1232       {
1233          int bound = N/st->upsample;
1234          for (i=0;i<bound;i++)
1235             freq[c*N+i] *= st->upsample;
1236          for (;i<N;i++)
1237             freq[c*N+i] = 0;
1238       } while (++c<C);
1239    }
1240    ALLOC(X, C*N, celt_norm);         /**< Interleaved normalised MDCTs */
1241
1242    compute_band_energies(st->mode, freq, bandE, effEnd, C, M);
1243
1244    amp2Log2(st->mode, effEnd, st->end, bandE, bandLogE, C);
1245
1246    /* Band normalisation */
1247    normalise_bands(st->mode, freq, X, bandE, effEnd, C, M);
1248
1249    ALLOC(tf_res, st->mode->nbEBands, int);
1250    /* Needs to be before coarse energy quantization because otherwise the energy gets modified */
1251    tf_select = tf_analysis(st->mode, bandLogE, oldBandE, effEnd, C, isTransient, tf_res, effectiveBytes, X, N, LM, &tf_sum);
1252    for (i=effEnd;i<st->end;i++)
1253       tf_res[i] = tf_res[effEnd-1];
1254
1255    ALLOC(error, C*st->mode->nbEBands, celt_word16);
1256    quant_coarse_energy(st->mode, st->start, st->end, effEnd, bandLogE,
1257          oldBandE, total_bits, error, enc,
1258          C, LM, nbAvailableBytes, st->force_intra,
1259          &st->delayedIntra, st->complexity >= 4);
1260
1261    tf_encode(st->start, st->end, isTransient, tf_res, LM, tf_select, enc);
1262
1263    st->spread_decision = SPREAD_NORMAL;
1264    if (ec_tell(enc)+4<=total_bits)
1265    {
1266       if (shortBlocks || st->complexity < 3 || nbAvailableBytes < 10*C)
1267       {
1268          if (st->complexity == 0)
1269             st->spread_decision = SPREAD_NONE;
1270       } else {
1271          st->spread_decision = spreading_decision(st->mode, X,
1272                &st->tonal_average, st->spread_decision, &st->hf_average,
1273                &st->tapset_decision, pf_on&&!shortBlocks, effEnd, C, M);
1274       }
1275       ec_enc_icdf(enc, st->spread_decision, spread_icdf, 5);
1276    }
1277
1278    ALLOC(cap, st->mode->nbEBands, int);
1279    ALLOC(offsets, st->mode->nbEBands, int);
1280
1281    init_caps(st->mode,cap,LM,C);
1282    for (i=0;i<st->mode->nbEBands;i++)
1283       offsets[i] = 0;
1284    /* Dynamic allocation code */
1285    /* Make sure that dynamic allocation can't make us bust the budget */
1286    if (effectiveBytes > 50 && LM>=1)
1287    {
1288       int t1, t2;
1289       if (LM <= 1)
1290       {
1291          t1 = 3;
1292          t2 = 5;
1293       } else {
1294          t1 = 2;
1295          t2 = 4;
1296       }
1297       for (i=st->start+1;i<st->end-1;i++)
1298       {
1299          celt_word32 d2;
1300          d2 = 2*bandLogE[i]-bandLogE[i-1]-bandLogE[i+1];
1301          if (C==2)
1302             d2 = HALF32(d2 + 2*bandLogE[i+st->mode->nbEBands]-
1303                   bandLogE[i-1+st->mode->nbEBands]-bandLogE[i+1+st->mode->nbEBands]);
1304          if (d2 > SHL16(t1,DB_SHIFT))
1305             offsets[i] += 1;
1306          if (d2 > SHL16(t2,DB_SHIFT))
1307             offsets[i] += 1;
1308       }
1309    }
1310    dynalloc_logp = 6;
1311    total_bits<<=BITRES;
1312    total_boost = 0;
1313    tell = ec_tell_frac(enc);
1314    for (i=st->start;i<st->end;i++)
1315    {
1316       int width, quanta;
1317       int dynalloc_loop_logp;
1318       int boost;
1319       int j;
1320       width = C*(st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
1321       /* quanta is 6 bits, but no more than 1 bit/sample
1322          and no less than 1/8 bit/sample */
1323       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
1324       dynalloc_loop_logp = dynalloc_logp;
1325       boost = 0;
1326       for (j = 0; tell+(dynalloc_loop_logp<<BITRES) < total_bits-total_boost
1327             && boost < cap[i]; j++)
1328       {
1329          int flag;
1330          flag = j<offsets[i];
1331          ec_enc_bit_logp(enc, flag, dynalloc_loop_logp);
1332          tell = ec_tell_frac(enc);
1333          if (!flag)
1334             break;
1335          boost += quanta;
1336          total_boost += quanta;
1337          dynalloc_loop_logp = 1;
1338       }
1339       /* Making dynalloc more likely */
1340       if (j)
1341          dynalloc_logp = IMAX(2, dynalloc_logp-1);
1342       offsets[i] = boost;
1343    }
1344    alloc_trim = 5;
1345    if (tell+(6<<BITRES) <= total_bits - total_boost)
1346    {
1347       alloc_trim = alloc_trim_analysis(st->mode, X, bandLogE,
1348             st->end, LM, C, N);
1349       ec_enc_icdf(enc, alloc_trim, trim_icdf, 7);
1350       tell = ec_tell_frac(enc);
1351    }
1352
1353    /* Variable bitrate */
1354    if (vbr_rate>0)
1355    {
1356      celt_word16 alpha;
1357      celt_int32 delta;
1358      /* The target rate in 8th bits per frame */
1359      celt_int32 target;
1360      celt_int32 min_allowed;
1361
1362      target = vbr_rate + st->vbr_offset - ((40*C+20)<<BITRES);
1363
1364      /* Shortblocks get a large boost in bitrate, but since they
1365         are uncommon long blocks are not greatly affected */
1366      if (shortBlocks || tf_sum < -2*(st->end-st->start))
1367         target = 7*target/4;
1368      else if (tf_sum < -(st->end-st->start))
1369         target = 3*target/2;
1370      else if (M > 1)
1371         target-=(target+14)/28;
1372
1373      /* The current offset is removed from the target and the space used
1374         so far is added*/
1375      target=target+tell;
1376
1377      /* In VBR mode the frame size must not be reduced so much that it would
1378          result in the encoder running out of bits.
1379         The margin of 2 bytes ensures that none of the bust-prevention logic
1380          in the decoder will have triggered so far. */
1381      min_allowed = (tell+total_boost+(1<<BITRES+3)-1>>(BITRES+3)) + 2 - nbFilledBytes;
1382
1383      nbAvailableBytes = target+(1<<(BITRES+2))>>(BITRES+3);
1384      nbAvailableBytes = IMAX(min_allowed,nbAvailableBytes);
1385      nbAvailableBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes) - nbFilledBytes;
1386
1387      if(silence)
1388      {
1389        nbAvailableBytes = 2;
1390        target = 2*8<<BITRES;
1391      }
1392
1393      /* By how much did we "miss" the target on that frame */
1394      delta = target - vbr_rate;
1395
1396      target=nbAvailableBytes<<(BITRES+3);
1397
1398      if (st->vbr_count < 970)
1399      {
1400         st->vbr_count++;
1401         alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+20),16));
1402      } else
1403         alpha = QCONST16(.001f,15);
1404      /* How many bits have we used in excess of what we're allowed */
1405      if (st->constrained_vbr)
1406         st->vbr_reservoir += target - vbr_rate;
1407      /*printf ("%d\n", st->vbr_reservoir);*/
1408
1409      /* Compute the offset we need to apply in order to reach the target */
1410      st->vbr_drift += (celt_int32)MULT16_32_Q15(alpha,delta-st->vbr_offset-st->vbr_drift);
1411      st->vbr_offset = -st->vbr_drift;
1412      /*printf ("%d\n", st->vbr_drift);*/
1413
1414      if (st->constrained_vbr && st->vbr_reservoir < 0)
1415      {
1416         /* We're under the min value -- increase rate */
1417         int adjust = (-st->vbr_reservoir)/(8<<BITRES);
1418         /* Unless we're just coding silence */
1419         nbAvailableBytes += silence?0:adjust;
1420         st->vbr_reservoir = 0;
1421         /*printf ("+%d\n", adjust);*/
1422      }
1423      nbCompressedBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes);
1424      /* This moves the raw bits to take into account the new compressed size */
1425      ec_enc_shrink(enc, nbCompressedBytes);
1426    }
1427    if (C==2)
1428    {
1429       int effectiveRate;
1430
1431       /* Always use MS for 2.5 ms frames until we can do a better analysis */
1432       if (LM!=0)
1433          dual_stereo = stereo_analysis(st->mode, X, LM, N);
1434
1435       /* Account for coarse energy */
1436       effectiveRate = (8*effectiveBytes - 80)>>LM;
1437
1438       /* effectiveRate in kb/s */
1439       effectiveRate = 2*effectiveRate/5;
1440       if (effectiveRate<35)
1441          intensity = 8;
1442       else if (effectiveRate<50)
1443          intensity = 12;
1444       else if (effectiveRate<68)
1445          intensity = 16;
1446       else if (effectiveRate<84)
1447          intensity = 18;
1448       else if (effectiveRate<102)
1449          intensity = 19;
1450       else if (effectiveRate<130)
1451          intensity = 20;
1452       else
1453          intensity = 100;
1454       intensity = IMIN(st->end,IMAX(st->start, intensity));
1455    }
1456
1457    /* Bit allocation */
1458    ALLOC(fine_quant, st->mode->nbEBands, int);
1459    ALLOC(pulses, st->mode->nbEBands, int);
1460    ALLOC(fine_priority, st->mode->nbEBands, int);
1461
1462    /* bits =           packet size                    - where we are - safety*/
1463    bits = ((celt_int32)nbCompressedBytes*8<<BITRES) - ec_tell_frac(enc) - 1;
1464    anti_collapse_rsv = isTransient&&LM>=2&&bits>=(LM+2<<BITRES) ? (1<<BITRES) : 0;
1465    bits -= anti_collapse_rsv;
1466    codedBands = compute_allocation(st->mode, st->start, st->end, offsets, cap,
1467          alloc_trim, &intensity, &dual_stereo, bits, &balance, pulses,
1468          fine_quant, fine_priority, C, LM, enc, 1, st->lastCodedBands);
1469    st->lastCodedBands = codedBands;
1470
1471    quant_fine_energy(st->mode, st->start, st->end, oldBandE, error, fine_quant, enc, C);
1472
1473 #ifdef MEASURE_NORM_MSE
1474    float X0[3000];
1475    float bandE0[60];
1476    c=0; do 
1477       for (i=0;i<N;i++)
1478          X0[i+c*N] = X[i+c*N];
1479    while (++c<C);
1480    for (i=0;i<C*st->mode->nbEBands;i++)
1481       bandE0[i] = bandE[i];
1482 #endif
1483
1484    /* Residual quantisation */
1485    ALLOC(collapse_masks, C*st->mode->nbEBands, unsigned char);
1486    quant_all_bands(1, st->mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
1487          bandE, pulses, shortBlocks, st->spread_decision, dual_stereo, intensity, tf_res, resynth,
1488          nbCompressedBytes*(8<<BITRES)-anti_collapse_rsv, balance, enc, LM, codedBands, &st->rng);
1489
1490    if (anti_collapse_rsv > 0)
1491    {
1492       anti_collapse_on = st->consec_transient<2;
1493       ec_enc_bits(enc, anti_collapse_on, 1);
1494    }
1495    quant_energy_finalise(st->mode, st->start, st->end, oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_tell(enc), enc, C);
1496
1497    if (silence)
1498    {
1499       for (i=0;i<C*st->mode->nbEBands;i++)
1500          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
1501    }
1502
1503 #ifdef RESYNTH
1504    /* Re-synthesis of the coded audio if required */
1505    if (resynth)
1506    {
1507       celt_sig *out_mem[2];
1508       celt_sig *overlap_mem[2];
1509
1510       log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
1511       if (silence)
1512       {
1513          for (i=0;i<C*st->mode->nbEBands;i++)
1514             bandE[i] = 0;
1515       }
1516
1517 #ifdef MEASURE_NORM_MSE
1518       measure_norm_mse(st->mode, X, X0, bandE, bandE0, M, N, C);
1519 #endif
1520       if (anti_collapse_on)
1521       {
1522          anti_collapse(st->mode, X, collapse_masks, LM, C, CC, N,
1523                st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
1524       }
1525
1526       /* Synthesis */
1527       denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
1528
1529       CELT_MOVE(st->syn_mem[0], st->syn_mem[0]+N, MAX_PERIOD);
1530       if (CC==2)
1531          CELT_MOVE(st->syn_mem[1], st->syn_mem[1]+N, MAX_PERIOD);
1532
1533       c=0; do
1534          for (i=0;i<M*st->mode->eBands[st->start];i++)
1535             freq[c*N+i] = 0;
1536       while (++c<C);
1537       c=0; do
1538          for (i=M*st->mode->eBands[st->end];i<N;i++)
1539             freq[c*N+i] = 0;
1540       while (++c<C);
1541
1542       if (CC==2&&C==1)
1543       {
1544          for (i=0;i<N;i++)
1545             freq[N+i] = freq[i];
1546       }
1547
1548       out_mem[0] = st->syn_mem[0]+MAX_PERIOD;
1549       if (CC==2)
1550          out_mem[1] = st->syn_mem[1]+MAX_PERIOD;
1551
1552       c=0; do
1553          overlap_mem[c] = _overlap_mem + c*st->overlap;
1554       while (++c<CC);
1555
1556       compute_inv_mdcts(st->mode, shortBlocks, freq, out_mem, overlap_mem, CC, LM);
1557
1558 #ifdef ENABLE_POSTFILTER
1559       c=0; do {
1560          st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
1561          st->prefilter_period_old=IMAX(st->prefilter_period_old, COMBFILTER_MINPERIOD);
1562          comb_filter(out_mem[c], out_mem[c], st->prefilter_period_old, st->prefilter_period, st->mode->shortMdctSize,
1563                st->prefilter_gain_old, st->prefilter_gain, st->prefilter_tapset_old, st->prefilter_tapset,
1564                st->mode->window, st->overlap);
1565          if (LM!=0)
1566             comb_filter(out_mem[c]+st->mode->shortMdctSize, out_mem[c]+st->mode->shortMdctSize, st->prefilter_period, pitch_index, N-st->mode->shortMdctSize,
1567                   st->prefilter_gain, gain1, st->prefilter_tapset, prefilter_tapset,
1568                   st->mode->window, st->mode->overlap);
1569       } while (++c<CC);
1570 #endif /* ENABLE_POSTFILTER */
1571
1572       deemphasis(out_mem, (celt_word16*)pcm, N, CC, st->upsample, st->mode->preemph, st->preemph_memD);
1573       st->prefilter_period_old = st->prefilter_period;
1574       st->prefilter_gain_old = st->prefilter_gain;
1575       st->prefilter_tapset_old = st->prefilter_tapset;
1576    }
1577 #endif
1578
1579    st->prefilter_period = pitch_index;
1580    st->prefilter_gain = gain1;
1581    st->prefilter_tapset = prefilter_tapset;
1582 #ifdef RESYNTH
1583    if (LM!=0)
1584    {
1585       st->prefilter_period_old = st->prefilter_period;
1586       st->prefilter_gain_old = st->prefilter_gain;
1587       st->prefilter_tapset_old = st->prefilter_tapset;
1588    }
1589 #endif
1590
1591    if (CC==2&&C==1) {
1592       for (i=0;i<st->mode->nbEBands;i++)
1593          oldBandE[st->mode->nbEBands+i]=oldBandE[i];
1594    }
1595
1596    /* In case start or end were to change */
1597    c=0; do
1598    {
1599       for (i=0;i<st->start;i++)
1600          oldBandE[c*st->mode->nbEBands+i]=0;
1601       for (i=st->end;i<st->mode->nbEBands;i++)
1602          oldBandE[c*st->mode->nbEBands+i]=0;
1603    } while (++c<CC);
1604    if (!isTransient)
1605    {
1606       for (i=0;i<CC*st->mode->nbEBands;i++)
1607          oldLogE2[i] = oldLogE[i];
1608       for (i=0;i<CC*st->mode->nbEBands;i++)
1609          oldLogE[i] = oldBandE[i];
1610    } else {
1611       for (i=0;i<CC*st->mode->nbEBands;i++)
1612          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
1613    }
1614    if (isTransient)
1615       st->consec_transient++;
1616    else
1617       st->consec_transient=0;
1618    st->rng = enc->rng;
1619
1620    /* If there's any room left (can only happen for very high rates),
1621       it's already filled with zeros */
1622    ec_enc_done(enc);
1623    
1624    if (st->signalling)
1625       nbCompressedBytes++;
1626
1627    RESTORE_STACK;
1628    if (ec_get_error(enc))
1629       return CELT_CORRUPTED_DATA;
1630    else
1631       return nbCompressedBytes;
1632 }
1633
1634 #ifdef FIXED_POINT
1635 #ifndef DISABLE_FLOAT_API
1636 CELT_STATIC
1637 int celt_encode_with_ec_float(CELTEncoder * restrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
1638 {
1639    int j, ret, C, N;
1640    VARDECL(celt_int16, in);
1641    ALLOC_STACK;
1642    SAVE_STACK;
1643
1644    if (pcm==NULL)
1645       return CELT_BAD_ARG;
1646
1647    C = CHANNELS(st->channels);
1648    N = frame_size;
1649    ALLOC(in, C*N, celt_int16);
1650
1651    for (j=0;j<C*N;j++)
1652      in[j] = FLOAT2INT16(pcm[j]);
1653
1654    ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, enc);
1655 #ifdef RESYNTH
1656    for (j=0;j<C*N;j++)
1657       ((float*)pcm)[j]=in[j]*(1.f/32768.f);
1658 #endif
1659    RESTORE_STACK;
1660    return ret;
1661
1662 }
1663 #endif /*DISABLE_FLOAT_API*/
1664 #else
1665 CELT_STATIC
1666 int celt_encode_with_ec(CELTEncoder * restrict st, const celt_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
1667 {
1668    int j, ret, C, N;
1669    VARDECL(celt_sig, in);
1670    ALLOC_STACK;
1671    SAVE_STACK;
1672
1673    if (pcm==NULL)
1674       return CELT_BAD_ARG;
1675
1676    C=CHANNELS(st->channels);
1677    N=frame_size;
1678    ALLOC(in, C*N, celt_sig);
1679    for (j=0;j<C*N;j++) {
1680      in[j] = SCALEOUT(pcm[j]);
1681    }
1682
1683    ret = celt_encode_with_ec_float(st,in,frame_size,compressed,nbCompressedBytes, enc);
1684 #ifdef RESYNTH
1685    for (j=0;j<C*N;j++)
1686       ((celt_int16*)pcm)[j] = FLOAT2INT16(in[j]);
1687 #endif
1688    RESTORE_STACK;
1689    return ret;
1690 }
1691 #endif
1692
1693 int celt_encode(CELTEncoder * restrict st, const celt_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1694 {
1695    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1696 }
1697
1698 #ifndef DISABLE_FLOAT_API
1699 int celt_encode_float(CELTEncoder * restrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1700 {
1701    return celt_encode_with_ec_float(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1702 }
1703 #endif /* DISABLE_FLOAT_API */
1704
1705 int celt_encoder_ctl(CELTEncoder * restrict st, int request, ...)
1706 {
1707    va_list ap;
1708    
1709    va_start(ap, request);
1710    switch (request)
1711    {
1712       case CELT_GET_MODE_REQUEST:
1713       {
1714          const CELTMode ** value = va_arg(ap, const CELTMode**);
1715          if (value==0)
1716             goto bad_arg;
1717          *value=st->mode;
1718       }
1719       break;
1720       case CELT_SET_COMPLEXITY_REQUEST:
1721       {
1722          int value = va_arg(ap, celt_int32);
1723          if (value<0 || value>10)
1724             goto bad_arg;
1725          st->complexity = value;
1726       }
1727       break;
1728       case CELT_SET_START_BAND_REQUEST:
1729       {
1730          celt_int32 value = va_arg(ap, celt_int32);
1731          if (value<0 || value>=st->mode->nbEBands)
1732             goto bad_arg;
1733          st->start = value;
1734       }
1735       break;
1736       case CELT_SET_END_BAND_REQUEST:
1737       {
1738          celt_int32 value = va_arg(ap, celt_int32);
1739          if (value<1 || value>st->mode->nbEBands)
1740             goto bad_arg;
1741          st->end = value;
1742       }
1743       break;
1744       case CELT_SET_PREDICTION_REQUEST:
1745       {
1746          int value = va_arg(ap, celt_int32);
1747          if (value<0 || value>2)
1748             goto bad_arg;
1749          st->disable_pf = value<=1;
1750          st->force_intra = value==0;
1751       }
1752       break;
1753       case CELT_SET_VBR_CONSTRAINT_REQUEST:
1754       {
1755          celt_int32 value = va_arg(ap, celt_int32);
1756          st->constrained_vbr = value;
1757       }
1758       break;
1759       case CELT_SET_VBR_REQUEST:
1760       {
1761          celt_int32 value = va_arg(ap, celt_int32);
1762          st->vbr = value;
1763       }
1764       break;
1765       case CELT_SET_BITRATE_REQUEST:
1766       {
1767          celt_int32 value = va_arg(ap, celt_int32);
1768          if (value<=500)
1769             goto bad_arg;
1770          value = IMIN(value, 260000*st->channels);
1771          st->bitrate = value;
1772       }
1773       break;
1774       case CELT_SET_CHANNELS_REQUEST:
1775       {
1776          celt_int32 value = va_arg(ap, celt_int32);
1777          if (value<1 || value>2)
1778             goto bad_arg;
1779          st->stream_channels = value;
1780       }
1781       break;
1782       case CELT_SET_SIGNALLING_REQUEST:
1783       {
1784          celt_int32 value = va_arg(ap, celt_int32);
1785          st->signalling = value;
1786       }
1787       break;
1788       case CELT_RESET_STATE:
1789       {
1790          CELT_MEMSET((char*)&st->ENCODER_RESET_START, 0,
1791                celt_encoder_get_size_custom(st->mode, st->channels)-
1792                ((char*)&st->ENCODER_RESET_START - (char*)st));
1793          st->vbr_offset = 0;
1794          st->delayedIntra = 1;
1795          st->spread_decision = SPREAD_NORMAL;
1796          st->tonal_average = QCONST16(1.f,8);
1797       }
1798       break;
1799       case CELT_SET_INPUT_CLIPPING_REQUEST:
1800       {
1801          celt_int32 value = va_arg(ap, celt_int32);
1802          st->clip = value;
1803       }
1804       break;
1805       default:
1806          goto bad_request;
1807    }
1808    va_end(ap);
1809    return CELT_OK;
1810 bad_arg:
1811    va_end(ap);
1812    return CELT_BAD_ARG;
1813 bad_request:
1814    va_end(ap);
1815    return CELT_UNIMPLEMENTED;
1816 }
1817
1818 /**********************************************************************/
1819 /*                                                                    */
1820 /*                             DECODER                                */
1821 /*                                                                    */
1822 /**********************************************************************/
1823 #define DECODE_BUFFER_SIZE 2048
1824
1825 /** Decoder state 
1826  @brief Decoder state
1827  */
1828 struct CELTDecoder {
1829    const CELTMode *mode;
1830    int overlap;
1831    int channels;
1832    int stream_channels;
1833
1834    int downsample;
1835    int start, end;
1836    int signalling;
1837
1838    /* Everything beyond this point gets cleared on a reset */
1839 #define DECODER_RESET_START rng
1840
1841    celt_uint32 rng;
1842    int last_pitch_index;
1843    int loss_count;
1844    int postfilter_period;
1845    int postfilter_period_old;
1846    celt_word16 postfilter_gain;
1847    celt_word16 postfilter_gain_old;
1848    int postfilter_tapset;
1849    int postfilter_tapset_old;
1850
1851    celt_sig preemph_memD[2];
1852    
1853    celt_sig _decode_mem[1]; /* Size = channels*(DECODE_BUFFER_SIZE+mode->overlap) */
1854    /* celt_word16 lpc[],  Size = channels*LPC_ORDER */
1855    /* celt_word16 oldEBands[], Size = channels*mode->nbEBands */
1856    /* celt_word16 oldLogE[], Size = channels*mode->nbEBands */
1857    /* celt_word16 oldLogE2[], Size = channels*mode->nbEBands */
1858    /* celt_word16 backgroundLogE[], Size = channels*mode->nbEBands */
1859 };
1860
1861 int celt_decoder_get_size(int channels)
1862 {
1863    const CELTMode *mode = celt_mode_create(48000, 960, NULL);
1864    return celt_decoder_get_size_custom(mode, channels);
1865 }
1866
1867 int celt_decoder_get_size_custom(const CELTMode *mode, int channels)
1868 {
1869    int size = sizeof(struct CELTDecoder)
1870             + (channels*(DECODE_BUFFER_SIZE+mode->overlap)-1)*sizeof(celt_sig)
1871             + channels*LPC_ORDER*sizeof(celt_word16)
1872             + 4*channels*mode->nbEBands*sizeof(celt_word16);
1873    return size;
1874 }
1875
1876 CELTDecoder *celt_decoder_create(int sampling_rate, int channels, int *error)
1877 {
1878    CELTDecoder *st;
1879    st = (CELTDecoder *)celt_alloc(celt_decoder_get_size(channels));
1880    if (st!=NULL && celt_decoder_init(st, sampling_rate, channels, error)==NULL)
1881    {
1882       celt_decoder_destroy(st);
1883       st = NULL;
1884    }
1885    return st;
1886 }
1887
1888 CELTDecoder *celt_decoder_create_custom(const CELTMode *mode, int channels, int *error)
1889 {
1890    CELTDecoder *st = (CELTDecoder *)celt_alloc(celt_decoder_get_size_custom(mode, channels));
1891    if (st!=NULL && celt_decoder_init_custom(st, mode, channels, error)==NULL)
1892    {
1893       celt_decoder_destroy(st);
1894       st = NULL;
1895    }
1896    return st;
1897 }
1898
1899 CELTDecoder *celt_decoder_init(CELTDecoder *st, int sampling_rate, int channels, int *error)
1900 {
1901    celt_decoder_init_custom(st, celt_mode_create(48000, 960, NULL), channels, error);
1902    st->downsample = resampling_factor(sampling_rate);
1903    if (st->downsample==0)
1904    {
1905       if (error)
1906          *error = CELT_BAD_ARG;
1907       return NULL;
1908    }
1909    return st;
1910 }
1911
1912 CELTDecoder *celt_decoder_init_custom(CELTDecoder *st, const CELTMode *mode, int channels, int *error)
1913 {
1914    if (channels < 0 || channels > 2)
1915    {
1916       if (error)
1917          *error = CELT_BAD_ARG;
1918       return NULL;
1919    }
1920
1921    if (st==NULL)
1922    {
1923       if (error)
1924          *error = CELT_ALLOC_FAIL;
1925       return NULL;
1926    }
1927
1928    CELT_MEMSET((char*)st, 0, celt_decoder_get_size_custom(mode, channels));
1929
1930    st->mode = mode;
1931    st->overlap = mode->overlap;
1932    st->stream_channels = st->channels = channels;
1933
1934    st->downsample = 1;
1935    st->start = 0;
1936    st->end = st->mode->effEBands;
1937    st->signalling = 1;
1938
1939    st->loss_count = 0;
1940
1941    if (error)
1942       *error = CELT_OK;
1943    return st;
1944 }
1945
1946 void celt_decoder_destroy(CELTDecoder *st)
1947 {
1948    celt_free(st);
1949 }
1950
1951 static void celt_decode_lost(CELTDecoder * restrict st, celt_word16 * restrict pcm, int N, int LM)
1952 {
1953    int c;
1954    int pitch_index;
1955    int overlap = st->mode->overlap;
1956    celt_word16 fade = Q15ONE;
1957    int i, len;
1958    const int C = CHANNELS(st->channels);
1959    int offset;
1960    celt_sig *out_mem[2];
1961    celt_sig *decode_mem[2];
1962    celt_sig *overlap_mem[2];
1963    celt_word16 *lpc;
1964    celt_word32 *out_syn[2];
1965    celt_word16 *oldBandE, *oldLogE2, *backgroundLogE;
1966    int plc=1;
1967    SAVE_STACK;
1968    
1969    c=0; do {
1970       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
1971       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
1972       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
1973    } while (++c<C);
1974    lpc = (celt_word16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*C);
1975    oldBandE = lpc+C*LPC_ORDER;
1976    oldLogE2 = oldBandE + C*st->mode->nbEBands;
1977    backgroundLogE = oldLogE2  + C*st->mode->nbEBands;
1978
1979    out_syn[0] = out_mem[0]+MAX_PERIOD-N;
1980    if (C==2)
1981       out_syn[1] = out_mem[1]+MAX_PERIOD-N;
1982
1983    len = N+st->mode->overlap;
1984    
1985    if (st->loss_count >= 5)
1986    {
1987       VARDECL(celt_sig, freq);
1988       VARDECL(celt_norm, X);
1989       VARDECL(celt_ener, bandE);
1990       celt_uint32 seed;
1991
1992       ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
1993       ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
1994       ALLOC(bandE, st->mode->nbEBands*C, celt_ener);
1995
1996       log2Amp(st->mode, st->start, st->end, bandE, backgroundLogE, C);
1997
1998       seed = st->rng;
1999       for (c=0;c<C;c++)
2000       {
2001          for (i=0;i<st->mode->effEBands;i++)
2002          {
2003             int j;
2004             int boffs;
2005             int blen;
2006             boffs = N*c+(st->mode->eBands[i]<<LM);
2007             blen = (st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
2008             for (j=0;j<blen;j++)
2009             {
2010                seed = lcg_rand(seed);
2011                X[boffs+j] = (celt_int32)(seed)>>20;
2012             }
2013             renormalise_vector(X+boffs, blen, Q15ONE);
2014          }
2015       }
2016       st->rng = seed;
2017
2018       denormalise_bands(st->mode, X, freq, bandE, st->mode->effEBands, C, 1<<LM);
2019
2020       compute_inv_mdcts(st->mode, 0, freq, out_syn, overlap_mem, C, LM);
2021       plc = 0;
2022    } else if (st->loss_count == 0)
2023    {
2024       celt_word16 pitch_buf[MAX_PERIOD>>1];
2025       int len2 = len;
2026       /* FIXME: This is a kludge */
2027       if (len2>MAX_PERIOD>>1)
2028          len2 = MAX_PERIOD>>1;
2029       pitch_downsample(out_mem, pitch_buf, MAX_PERIOD, C);
2030       pitch_search(pitch_buf+((MAX_PERIOD-len2)>>1), pitch_buf, len2,
2031                    MAX_PERIOD-len2-100, &pitch_index);
2032       pitch_index = MAX_PERIOD-len2-pitch_index;
2033       st->last_pitch_index = pitch_index;
2034    } else {
2035       pitch_index = st->last_pitch_index;
2036       fade = QCONST16(.8f,15);
2037    }
2038
2039    if (plc)
2040    {
2041       c=0; do {
2042          /* FIXME: This is more memory than necessary */
2043          celt_word32 e[2*MAX_PERIOD];
2044          celt_word16 exc[2*MAX_PERIOD];
2045          celt_word32 ac[LPC_ORDER+1];
2046          celt_word16 decay = 1;
2047          celt_word32 S1=0;
2048          celt_word16 mem[LPC_ORDER]={0};
2049
2050          offset = MAX_PERIOD-pitch_index;
2051          for (i=0;i<MAX_PERIOD;i++)
2052             exc[i] = ROUND16(out_mem[c][i], SIG_SHIFT);
2053
2054          if (st->loss_count == 0)
2055          {
2056             _celt_autocorr(exc, ac, st->mode->window, st->mode->overlap,
2057                   LPC_ORDER, MAX_PERIOD);
2058
2059             /* Noise floor -40 dB */
2060 #ifdef FIXED_POINT
2061             ac[0] += SHR32(ac[0],13);
2062 #else
2063             ac[0] *= 1.0001f;
2064 #endif
2065             /* Lag windowing */
2066             for (i=1;i<=LPC_ORDER;i++)
2067             {
2068                /*ac[i] *= exp(-.5*(2*M_PI*.002*i)*(2*M_PI*.002*i));*/
2069 #ifdef FIXED_POINT
2070                ac[i] -= MULT16_32_Q15(2*i*i, ac[i]);
2071 #else
2072                ac[i] -= ac[i]*(.008f*i)*(.008f*i);
2073 #endif
2074             }
2075
2076             _celt_lpc(lpc+c*LPC_ORDER, ac, LPC_ORDER);
2077          }
2078          for (i=0;i<LPC_ORDER;i++)
2079             mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT);
2080          fir(exc, lpc+c*LPC_ORDER, exc, MAX_PERIOD, LPC_ORDER, mem);
2081          /*for (i=0;i<MAX_PERIOD;i++)printf("%d ", exc[i]); printf("\n");*/
2082          /* Check if the waveform is decaying (and if so how fast) */
2083          {
2084             celt_word32 E1=1, E2=1;
2085             int period;
2086             if (pitch_index <= MAX_PERIOD/2)
2087                period = pitch_index;
2088             else
2089                period = MAX_PERIOD/2;
2090             for (i=0;i<period;i++)
2091             {
2092                E1 += SHR32(MULT16_16(exc[MAX_PERIOD-period+i],exc[MAX_PERIOD-period+i]),8);
2093                E2 += SHR32(MULT16_16(exc[MAX_PERIOD-2*period+i],exc[MAX_PERIOD-2*period+i]),8);
2094             }
2095             if (E1 > E2)
2096                E1 = E2;
2097             decay = celt_sqrt(frac_div32(SHR(E1,1),E2));
2098          }
2099
2100          /* Copy excitation, taking decay into account */
2101          for (i=0;i<len+st->mode->overlap;i++)
2102          {
2103             celt_word16 tmp;
2104             if (offset+i >= MAX_PERIOD)
2105             {
2106                offset -= pitch_index;
2107                decay = MULT16_16_Q15(decay, decay);
2108             }
2109             e[i] = SHL32(EXTEND32(MULT16_16_Q15(decay, exc[offset+i])), SIG_SHIFT);
2110             tmp = ROUND16(out_mem[c][offset+i],SIG_SHIFT);
2111             S1 += SHR32(MULT16_16(tmp,tmp),8);
2112          }
2113          for (i=0;i<LPC_ORDER;i++)
2114             mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT);
2115          for (i=0;i<len+st->mode->overlap;i++)
2116             e[i] = MULT16_32_Q15(fade, e[i]);
2117          iir(e, lpc+c*LPC_ORDER, e, len+st->mode->overlap, LPC_ORDER, mem);
2118
2119          {
2120             celt_word32 S2=0;
2121             for (i=0;i<len+overlap;i++)
2122             {
2123                celt_word16 tmp = ROUND16(e[i],SIG_SHIFT);
2124                S2 += SHR32(MULT16_16(tmp,tmp),8);
2125             }
2126             /* This checks for an "explosion" in the synthesis */
2127 #ifdef FIXED_POINT
2128             if (!(S1 > SHR32(S2,2)))
2129 #else
2130                /* Float test is written this way to catch NaNs at the same time */
2131                if (!(S1 > 0.2f*S2))
2132 #endif
2133                {
2134                   for (i=0;i<len+overlap;i++)
2135                      e[i] = 0;
2136                } else if (S1 < S2)
2137                {
2138                   celt_word16 ratio = celt_sqrt(frac_div32(SHR32(S1,1)+1,S2+1));
2139                   for (i=0;i<len+overlap;i++)
2140                      e[i] = MULT16_32_Q15(ratio, e[i]);
2141                }
2142          }
2143
2144 #ifdef ENABLE_POSTFILTER
2145          /* Apply post-filter to the MDCT overlap of the previous frame */
2146          comb_filter(out_mem[c]+MAX_PERIOD, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap,
2147                st->postfilter_gain, st->postfilter_gain, st->postfilter_tapset, st->postfilter_tapset,
2148                NULL, 0);
2149 #endif /* ENABLE_POSTFILTER */
2150
2151          for (i=0;i<MAX_PERIOD+st->mode->overlap-N;i++)
2152             out_mem[c][i] = out_mem[c][N+i];
2153
2154          /* Apply TDAC to the concealed audio so that it blends with the
2155          previous and next frames */
2156          for (i=0;i<overlap/2;i++)
2157          {
2158             celt_word32 tmp;
2159             tmp = MULT16_32_Q15(st->mode->window[i],           e[N+overlap-1-i]) +
2160                   MULT16_32_Q15(st->mode->window[overlap-i-1], e[N+i          ]);
2161             out_mem[c][MAX_PERIOD+i] = MULT16_32_Q15(st->mode->window[overlap-i-1], tmp);
2162             out_mem[c][MAX_PERIOD+overlap-i-1] = MULT16_32_Q15(st->mode->window[i], tmp);
2163          }
2164          for (i=0;i<N;i++)
2165             out_mem[c][MAX_PERIOD-N+i] = e[i];
2166
2167 #ifdef ENABLE_POSTFILTER
2168          /* Apply pre-filter to the MDCT overlap for the next frame (post-filter will be applied then) */
2169          comb_filter(e, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap,
2170                -st->postfilter_gain, -st->postfilter_gain, st->postfilter_tapset, st->postfilter_tapset,
2171                NULL, 0);
2172 #endif /* ENABLE_POSTFILTER */
2173          for (i=0;i<overlap;i++)
2174             out_mem[c][MAX_PERIOD+i] = e[i];
2175       } while (++c<C);
2176    }
2177
2178    deemphasis(out_syn, pcm, N, C, st->downsample, st->mode->preemph, st->preemph_memD);
2179    
2180    st->loss_count++;
2181
2182    RESTORE_STACK;
2183 }
2184
2185 #ifdef FIXED_POINT
2186 CELT_STATIC
2187 int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size, ec_dec *dec)
2188 {
2189 #else
2190 CELT_STATIC
2191 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)
2192 {
2193 #endif
2194    int c, i, N;
2195    int spread_decision;
2196    celt_int32 bits;
2197    ec_dec _dec;
2198    VARDECL(celt_sig, freq);
2199    VARDECL(celt_norm, X);
2200    VARDECL(celt_ener, bandE);
2201    VARDECL(int, fine_quant);
2202    VARDECL(int, pulses);
2203    VARDECL(int, cap);
2204    VARDECL(int, offsets);
2205    VARDECL(int, fine_priority);
2206    VARDECL(int, tf_res);
2207    VARDECL(unsigned char, collapse_masks);
2208    celt_sig *out_mem[2];
2209    celt_sig *decode_mem[2];
2210    celt_sig *overlap_mem[2];
2211    celt_sig *out_syn[2];
2212    celt_word16 *lpc;
2213    celt_word16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE;
2214
2215    int shortBlocks;
2216    int isTransient;
2217    int intra_ener;
2218    const int CC = CHANNELS(st->channels);
2219    int LM, M;
2220    int effEnd;
2221    int codedBands;
2222    int alloc_trim;
2223    int postfilter_pitch;
2224    celt_word16 postfilter_gain;
2225    int intensity=0;
2226    int dual_stereo=0;
2227    celt_int32 total_bits;
2228    celt_int32 balance;
2229    celt_int32 tell;
2230    int dynalloc_logp;
2231    int postfilter_tapset;
2232    int anti_collapse_rsv;
2233    int anti_collapse_on=0;
2234    int silence;
2235    int C = CHANNELS(st->stream_channels);
2236    ALLOC_STACK;
2237    SAVE_STACK;
2238
2239    frame_size *= st->downsample;
2240
2241    c=0; do {
2242       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
2243       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
2244       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
2245    } while (++c<CC);
2246    lpc = (celt_word16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*CC);
2247    oldBandE = lpc+CC*LPC_ORDER;
2248    oldLogE = oldBandE + CC*st->mode->nbEBands;
2249    oldLogE2 = oldLogE + CC*st->mode->nbEBands;
2250    backgroundLogE = oldLogE2  + CC*st->mode->nbEBands;
2251
2252    if (st->signalling && data!=NULL)
2253    {
2254       st->end = IMAX(1, st->mode->effEBands-2*(data[0]>>5));
2255       LM = (data[0]>>3)&0x3;
2256       C = 1 + ((data[0]>>2)&0x1);
2257       data++;
2258       len--;
2259       if (LM>st->mode->maxLM)
2260          return CELT_CORRUPTED_DATA;
2261       if (frame_size < st->mode->shortMdctSize<<LM)
2262          return CELT_BAD_ARG;
2263       else
2264          frame_size = st->mode->shortMdctSize<<LM;
2265    } else {
2266       for (LM=0;LM<=st->mode->maxLM;LM++)
2267          if (st->mode->shortMdctSize<<LM==frame_size)
2268             break;
2269       if (LM>st->mode->maxLM)
2270          return CELT_BAD_ARG;
2271    }
2272    M=1<<LM;
2273
2274    if (len<0 || len>1275 || pcm==NULL)
2275       return CELT_BAD_ARG;
2276
2277    N = M*st->mode->shortMdctSize;
2278
2279    effEnd = st->end;
2280    if (effEnd > st->mode->effEBands)
2281       effEnd = st->mode->effEBands;
2282
2283    ALLOC(freq, CC*N, celt_sig); /**< Interleaved signal MDCTs */
2284    ALLOC(X, CC*N, celt_norm);   /**< Interleaved normalised MDCTs */
2285    ALLOC(bandE, st->mode->nbEBands*CC, celt_ener);
2286    c=0; do
2287       for (i=0;i<M*st->mode->eBands[st->start];i++)
2288          X[c*N+i] = 0;
2289    while (++c<CC);
2290    c=0; do   
2291       for (i=M*st->mode->eBands[effEnd];i<N;i++)
2292          X[c*N+i] = 0;
2293    while (++c<CC);
2294
2295    if (data == NULL || len<=1)
2296    {
2297       celt_decode_lost(st, pcm, N, LM);
2298       RESTORE_STACK;
2299       return CELT_OK;
2300    }
2301    if (len<0) {
2302      RESTORE_STACK;
2303      return CELT_BAD_ARG;
2304    }
2305
2306    if (dec == NULL)
2307    {
2308       ec_dec_init(&_dec,(unsigned char*)data,len);
2309       dec = &_dec;
2310    }
2311
2312    if (C>CC)
2313    {
2314       RESTORE_STACK;
2315       return CELT_CORRUPTED_DATA;
2316    } else if (C<CC)
2317    {
2318       for (i=0;i<st->mode->nbEBands;i++)
2319          oldBandE[i]=MAX16(oldBandE[i],oldBandE[st->mode->nbEBands+i]);
2320    }
2321
2322    total_bits = len*8;
2323    tell = ec_tell(dec);
2324
2325    if (tell==1)
2326       silence = ec_dec_bit_logp(dec, 15);
2327    else
2328       silence = 0;
2329    if (silence)
2330    {
2331       /* Pretend we've read all the remaining bits */
2332       tell = len*8;
2333       dec->nbits_total+=tell-ec_tell(dec);
2334    }
2335
2336    postfilter_gain = 0;
2337    postfilter_pitch = 0;
2338    postfilter_tapset = 0;
2339    if (st->start==0 && tell+16 <= total_bits)
2340    {
2341       if(ec_dec_bit_logp(dec, 1))
2342       {
2343 #ifdef ENABLE_POSTFILTER
2344          int qg, octave;
2345          octave = ec_dec_uint(dec, 6);
2346          postfilter_pitch = (16<<octave)+ec_dec_bits(dec, 4+octave)-1;
2347          qg = ec_dec_bits(dec, 3);
2348          if (ec_tell(dec)+2<=total_bits)
2349             postfilter_tapset = ec_dec_icdf(dec, tapset_icdf, 2);
2350          postfilter_gain = QCONST16(.09375f,15)*(qg+1);
2351 #else /* ENABLE_POSTFILTER */
2352          RESTORE_STACK;
2353          return CELT_CORRUPTED_DATA;
2354 #endif /* ENABLE_POSTFILTER */
2355       }
2356       tell = ec_tell(dec);
2357    }
2358
2359    if (LM > 0 && tell+3 <= total_bits)
2360    {
2361       isTransient = ec_dec_bit_logp(dec, 3);
2362       tell = ec_tell(dec);
2363    }
2364    else
2365       isTransient = 0;
2366
2367    if (isTransient)
2368       shortBlocks = M;
2369    else
2370       shortBlocks = 0;
2371
2372    /* Decode the global flags (first symbols in the stream) */
2373    intra_ener = tell+3<=total_bits ? ec_dec_bit_logp(dec, 3) : 0;
2374    /* Get band energies */
2375    unquant_coarse_energy(st->mode, st->start, st->end, oldBandE,
2376          intra_ener, dec, C, LM);
2377
2378    ALLOC(tf_res, st->mode->nbEBands, int);
2379    tf_decode(st->start, st->end, isTransient, tf_res, LM, dec);
2380
2381    tell = ec_tell(dec);
2382    spread_decision = SPREAD_NORMAL;
2383    if (tell+4 <= total_bits)
2384       spread_decision = ec_dec_icdf(dec, spread_icdf, 5);
2385
2386    ALLOC(pulses, st->mode->nbEBands, int);
2387    ALLOC(cap, st->mode->nbEBands, int);
2388    ALLOC(offsets, st->mode->nbEBands, int);
2389    ALLOC(fine_priority, st->mode->nbEBands, int);
2390
2391    init_caps(st->mode,cap,LM,C);
2392
2393    dynalloc_logp = 6;
2394    total_bits<<=BITRES;
2395    tell = ec_tell_frac(dec);
2396    for (i=st->start;i<st->end;i++)
2397    {
2398       int width, quanta;
2399       int dynalloc_loop_logp;
2400       int boost;
2401       width = C*(st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
2402       /* quanta is 6 bits, but no more than 1 bit/sample
2403          and no less than 1/8 bit/sample */
2404       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
2405       dynalloc_loop_logp = dynalloc_logp;
2406       boost = 0;
2407       while (tell+(dynalloc_loop_logp<<BITRES) < total_bits && boost < cap[i])
2408       {
2409          int flag;
2410          flag = ec_dec_bit_logp(dec, dynalloc_loop_logp);
2411          tell = ec_tell_frac(dec);
2412          if (!flag)
2413             break;
2414          boost += quanta;
2415          total_bits -= quanta;
2416          dynalloc_loop_logp = 1;
2417       }
2418       offsets[i] = boost;
2419       /* Making dynalloc more likely */
2420       if (boost>0)
2421          dynalloc_logp = IMAX(2, dynalloc_logp-1);
2422    }
2423
2424    ALLOC(fine_quant, st->mode->nbEBands, int);
2425    alloc_trim = tell+(6<<BITRES) <= total_bits ?
2426          ec_dec_icdf(dec, trim_icdf, 7) : 5;
2427
2428    bits = ((celt_int32)len*8<<BITRES) - ec_tell_frac(dec) - 1;
2429    anti_collapse_rsv = isTransient&&LM>=2&&bits>=(LM+2<<BITRES) ? (1<<BITRES) : 0;
2430    bits -= anti_collapse_rsv;
2431    codedBands = compute_allocation(st->mode, st->start, st->end, offsets, cap,
2432          alloc_trim, &intensity, &dual_stereo, bits, &balance, pulses,
2433          fine_quant, fine_priority, C, LM, dec, 0, 0);
2434    
2435    unquant_fine_energy(st->mode, st->start, st->end, oldBandE, fine_quant, dec, C);
2436
2437    /* Decode fixed codebook */
2438    ALLOC(collapse_masks, C*st->mode->nbEBands, unsigned char);
2439    quant_all_bands(0, st->mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
2440          NULL, pulses, shortBlocks, spread_decision, dual_stereo, intensity, tf_res, 1,
2441          len*(8<<BITRES)-anti_collapse_rsv, balance, dec, LM, codedBands, &st->rng);
2442
2443    if (anti_collapse_rsv > 0)
2444    {
2445       anti_collapse_on = ec_dec_bits(dec, 1);
2446    }
2447
2448    unquant_energy_finalise(st->mode, st->start, st->end, oldBandE,
2449          fine_quant, fine_priority, len*8-ec_tell(dec), dec, C);
2450
2451    if (anti_collapse_on)
2452       anti_collapse(st->mode, X, collapse_masks, LM, C, CC, N,
2453             st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
2454
2455    log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
2456
2457    if (silence)
2458    {
2459       for (i=0;i<C*st->mode->nbEBands;i++)
2460       {
2461          bandE[i] = 0;
2462          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
2463       }
2464    }
2465    /* Synthesis */
2466    denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
2467
2468    CELT_MOVE(decode_mem[0], decode_mem[0]+N, DECODE_BUFFER_SIZE-N);
2469    if (CC==2)
2470       CELT_MOVE(decode_mem[1], decode_mem[1]+N, DECODE_BUFFER_SIZE-N);
2471
2472    c=0; do
2473       for (i=0;i<M*st->mode->eBands[st->start];i++)
2474          freq[c*N+i] = 0;
2475    while (++c<C);
2476    c=0; do {
2477       int bound = M*st->mode->eBands[effEnd];
2478       if (st->downsample!=1)
2479          bound = IMIN(bound, N/st->downsample);
2480       for (i=bound;i<N;i++)
2481          freq[c*N+i] = 0;
2482    } while (++c<C);
2483
2484    out_syn[0] = out_mem[0]+MAX_PERIOD-N;
2485    if (CC==2)
2486       out_syn[1] = out_mem[1]+MAX_PERIOD-N;
2487
2488    if (CC==2&&C==1)
2489    {
2490       for (i=0;i<N;i++)
2491          freq[N+i] = freq[i];
2492    }
2493
2494    /* Compute inverse MDCTs */
2495    compute_inv_mdcts(st->mode, shortBlocks, freq, out_syn, overlap_mem, CC, LM);
2496
2497 #ifdef ENABLE_POSTFILTER
2498    c=0; do {
2499       st->postfilter_period=IMAX(st->postfilter_period, COMBFILTER_MINPERIOD);
2500       st->postfilter_period_old=IMAX(st->postfilter_period_old, COMBFILTER_MINPERIOD);
2501       comb_filter(out_syn[c], out_syn[c], st->postfilter_period_old, st->postfilter_period, st->mode->shortMdctSize,
2502             st->postfilter_gain_old, st->postfilter_gain, st->postfilter_tapset_old, st->postfilter_tapset,
2503             st->mode->window, st->overlap);
2504       if (LM!=0)
2505          comb_filter(out_syn[c]+st->mode->shortMdctSize, out_syn[c]+st->mode->shortMdctSize, st->postfilter_period, postfilter_pitch, N-st->mode->shortMdctSize,
2506                st->postfilter_gain, postfilter_gain, st->postfilter_tapset, postfilter_tapset,
2507                st->mode->window, st->mode->overlap);
2508
2509    } while (++c<CC);
2510    st->postfilter_period_old = st->postfilter_period;
2511    st->postfilter_gain_old = st->postfilter_gain;
2512    st->postfilter_tapset_old = st->postfilter_tapset;
2513    st->postfilter_period = postfilter_pitch;
2514    st->postfilter_gain = postfilter_gain;
2515    st->postfilter_tapset = postfilter_tapset;
2516    if (LM!=0)
2517    {
2518       st->postfilter_period_old = st->postfilter_period;
2519       st->postfilter_gain_old = st->postfilter_gain;
2520       st->postfilter_tapset_old = st->postfilter_tapset;
2521    }
2522 #endif /* ENABLE_POSTFILTER */
2523
2524    if (CC==2&&C==1) {
2525       for (i=0;i<st->mode->nbEBands;i++)
2526          oldBandE[st->mode->nbEBands+i]=oldBandE[i];
2527    }
2528
2529    /* In case start or end were to change */
2530    c=0; do
2531    {
2532       for (i=0;i<st->start;i++)
2533          oldBandE[c*st->mode->nbEBands+i]=0;
2534       for (i=st->end;i<st->mode->nbEBands;i++)
2535          oldBandE[c*st->mode->nbEBands+i]=0;
2536    } while (++c<CC);
2537    if (!isTransient)
2538    {
2539       for (i=0;i<CC*st->mode->nbEBands;i++)
2540          oldLogE2[i] = oldLogE[i];
2541       for (i=0;i<CC*st->mode->nbEBands;i++)
2542          oldLogE[i] = oldBandE[i];
2543       for (i=0;i<CC*st->mode->nbEBands;i++)
2544          backgroundLogE[i] = MIN16(backgroundLogE[i] + M*QCONST16(0.001f,DB_SHIFT), oldBandE[i]);
2545    } else {
2546       for (i=0;i<CC*st->mode->nbEBands;i++)
2547          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
2548    }
2549    st->rng = dec->rng;
2550
2551    deemphasis(out_syn, pcm, N, CC, st->downsample, st->mode->preemph, st->preemph_memD);
2552    st->loss_count = 0;
2553    RESTORE_STACK;
2554    if (ec_tell(dec) > 8*len || ec_get_error(dec))
2555       return CELT_CORRUPTED_DATA;
2556    else
2557       return frame_size/st->downsample;
2558 }
2559
2560 #ifdef FIXED_POINT
2561 #ifndef DISABLE_FLOAT_API
2562 CELT_STATIC
2563 int celt_decode_with_ec_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size, ec_dec *dec)
2564 {
2565    int j, ret, C, N;
2566    VARDECL(celt_int16, out);
2567    ALLOC_STACK;
2568    SAVE_STACK;
2569
2570    if (pcm==NULL)
2571       return CELT_BAD_ARG;
2572
2573    C = CHANNELS(st->channels);
2574    N = frame_size;
2575    
2576    ALLOC(out, C*N, celt_int16);
2577    ret=celt_decode_with_ec(st, data, len, out, frame_size, dec);
2578    if (ret>0)
2579       for (j=0;j<C*ret;j++)
2580          pcm[j]=out[j]*(1.f/32768.f);
2581      
2582    RESTORE_STACK;
2583    return ret;
2584 }
2585 #endif /*DISABLE_FLOAT_API*/
2586 #else
2587 CELT_STATIC
2588 int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size, ec_dec *dec)
2589 {
2590    int j, ret, C, N;
2591    VARDECL(celt_sig, out);
2592    ALLOC_STACK;
2593    SAVE_STACK;
2594
2595    if (pcm==NULL)
2596       return CELT_BAD_ARG;
2597
2598    C = CHANNELS(st->channels);
2599    N = frame_size;
2600    ALLOC(out, C*N, celt_sig);
2601
2602    ret=celt_decode_with_ec_float(st, data, len, out, frame_size, dec);
2603
2604    if (ret>0)
2605       for (j=0;j<C*ret;j++)
2606          pcm[j] = FLOAT2INT16 (out[j]);
2607    
2608    RESTORE_STACK;
2609    return ret;
2610 }
2611 #endif
2612
2613 int celt_decode(CELTDecoder * restrict st, const unsigned char *data, int len, celt_int16 * restrict pcm, int frame_size)
2614 {
2615    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
2616 }
2617
2618 #ifndef DISABLE_FLOAT_API
2619 int celt_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size)
2620 {
2621    return celt_decode_with_ec_float(st, data, len, pcm, frame_size, NULL);
2622 }
2623 #endif /* DISABLE_FLOAT_API */
2624
2625 int celt_decoder_ctl(CELTDecoder * restrict st, int request, ...)
2626 {
2627    va_list ap;
2628
2629    va_start(ap, request);
2630    switch (request)
2631    {
2632       case CELT_GET_MODE_REQUEST:
2633       {
2634          const CELTMode ** value = va_arg(ap, const CELTMode**);
2635          if (value==0)
2636             goto bad_arg;
2637          *value=st->mode;
2638       }
2639       break;
2640       case CELT_SET_START_BAND_REQUEST:
2641       {
2642          celt_int32 value = va_arg(ap, celt_int32);
2643          if (value<0 || value>=st->mode->nbEBands)
2644             goto bad_arg;
2645          st->start = value;
2646       }
2647       break;
2648       case CELT_SET_END_BAND_REQUEST:
2649       {
2650          celt_int32 value = va_arg(ap, celt_int32);
2651          if (value<1 || value>st->mode->nbEBands)
2652             goto bad_arg;
2653          st->end = value;
2654       }
2655       break;
2656       case CELT_SET_CHANNELS_REQUEST:
2657       {
2658          celt_int32 value = va_arg(ap, celt_int32);
2659          if (value<1 || value>2)
2660             goto bad_arg;
2661          st->stream_channels = value;
2662       }
2663       break;
2664       case CELT_SET_SIGNALLING_REQUEST:
2665       {
2666          celt_int32 value = va_arg(ap, celt_int32);
2667          st->signalling = value;
2668       }
2669       break;
2670       case CELT_RESET_STATE:
2671       {
2672          CELT_MEMSET((char*)&st->DECODER_RESET_START, 0,
2673                celt_decoder_get_size_custom(st->mode, st->channels)-
2674                ((char*)&st->DECODER_RESET_START - (char*)st));
2675       }
2676       break;
2677       default:
2678          goto bad_request;
2679    }
2680    va_end(ap);
2681    return CELT_OK;
2682 bad_arg:
2683    va_end(ap);
2684    return CELT_BAD_ARG;
2685 bad_request:
2686       va_end(ap);
2687   return CELT_UNIMPLEMENTED;
2688 }
2689
2690 const char *celt_strerror(int error)
2691 {
2692    static const char *error_strings[8] = {
2693       "success",
2694       "invalid argument",
2695       "invalid mode",
2696       "internal error",
2697       "corrupted stream",
2698       "request not implemented",
2699       "invalid state",
2700       "memory allocation failed"
2701    };
2702    if (error > 0 || error < -7)
2703       return "unknown error";
2704    else 
2705       return error_strings[-error];
2706 }
2707