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