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