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