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