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