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