Implements a better transient metric for VBR
[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, opus_val16 *tf_estimate)
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    opus_val16 maxbin;
304    opus_val32 L1, L2, tf_tmp;
305    VARDECL(opus_val16, bins);
306    SAVE_STACK;
307    ALLOC(tmp, len, opus_val16);
308
309    block = overlap/2;
310    N=len/block;
311    ALLOC(bins, N, opus_val16);
312    if (C==1)
313    {
314       for (i=0;i<len;i++)
315          tmp[i] = SHR32(in[i],SIG_SHIFT);
316    } else {
317       for (i=0;i<len;i++)
318          tmp[i] = SHR32(ADD32(in[i],in[i+len]), SIG_SHIFT+1);
319    }
320
321    /* High-pass filter: (1 - 2*z^-1 + z^-2) / (1 - z^-1 + .5*z^-2) */
322    for (i=0;i<len;i++)
323    {
324       opus_val32 x,y;
325       x = tmp[i];
326       y = ADD32(mem0, x);
327 #ifdef FIXED_POINT
328       mem0 = mem1 + y - SHL32(x,1);
329       mem1 = x - SHR32(y,1);
330 #else
331       mem0 = mem1 + y - 2*x;
332       mem1 = x - .5f*y;
333 #endif
334       tmp[i] = EXTRACT16(SHR32(y,2));
335    }
336    /* First few samples are bad because we don't propagate the memory */
337    for (i=0;i<12;i++)
338       tmp[i] = 0;
339
340    maxbin=0;
341    for (i=0;i<N;i++)
342    {
343       int j;
344       opus_val16 max_abs=0;
345       for (j=0;j<block;j++)
346          max_abs = MAX16(max_abs, ABS16(tmp[i*block+j]));
347       bins[i] = max_abs;
348       maxbin = MAX16(maxbin, bins[i]);
349    }
350    L1=0;
351    L2=0;
352    for (i=0;i<N;i++)
353    {
354       int j;
355       int conseq=0;
356       opus_val16 t1, t2, t3;
357       opus_val16 tmp_bin;
358
359       tmp_bin = bins[i]+MULT16_16_Q15(QCONST16(.05f,15),maxbin);
360       L1 += EXTEND32(tmp_bin);
361       L2 += SHR32(MULT16_16(tmp_bin, tmp_bin), 4);
362       t1 = MULT16_16_Q15(QCONST16(.15f, 15), bins[i]);
363       t2 = MULT16_16_Q15(QCONST16(.4f, 15), bins[i]);
364       t3 = MULT16_16_Q15(QCONST16(.15f, 15), bins[i]);
365       for (j=0;j<i;j++)
366       {
367          if (bins[j] < t1)
368             conseq++;
369          if (bins[j] < t2)
370             conseq++;
371          else
372             conseq = 0;
373       }
374       if (conseq>=3)
375          is_transient=1;
376       conseq = 0;
377       for (j=i+1;j<N;j++)
378       {
379          if (bins[j] < t3)
380             conseq++;
381          else
382             conseq = 0;
383       }
384       if (conseq>=7)
385          is_transient=1;
386    }
387    /* sqrt(L2*N)/L1 */
388    tf_tmp = SHL32(DIV32( SHL32(EXTEND32(celt_sqrt(SHR16(L2,4) * N)), 14), ADD32(EPSILON, L1)), 4);
389    *tf_estimate = MAX16(QCONST16(1.f, 14), EXTRACT16(MIN16(QCONST32(1.99, 14), tf_tmp)));
390    RESTORE_STACK;
391 #ifdef FUZZING
392    is_transient = rand()&0x1;
393 #endif
394    return is_transient;
395 }
396
397 /** Apply window and compute the MDCT for all sub-frames and
398     all channels in a frame */
399 static void compute_mdcts(const CELTMode *mode, int shortBlocks, celt_sig * restrict in, celt_sig * restrict out, int C, int LM)
400 {
401    if (C==1 && !shortBlocks)
402    {
403       const int overlap = OVERLAP(mode);
404       clt_mdct_forward(&mode->mdct, in, out, mode->window, overlap, mode->maxLM-LM, 1);
405    } else {
406       const int overlap = OVERLAP(mode);
407       int N = mode->shortMdctSize<<LM;
408       int B = 1;
409       int b, c;
410       if (shortBlocks)
411       {
412          N = mode->shortMdctSize;
413          B = shortBlocks;
414       }
415       c=0; do {
416          for (b=0;b<B;b++)
417          {
418             /* Interleaving the sub-frames while doing the MDCTs */
419             clt_mdct_forward(&mode->mdct, in+c*(B*N+overlap)+b*N, &out[b+c*N*B], mode->window, overlap, shortBlocks ? mode->maxLM : mode->maxLM-LM, B);
420          }
421       } while (++c<C);
422    }
423 }
424
425 /** Compute the IMDCT and apply window for all sub-frames and
426     all channels in a frame */
427 static void compute_inv_mdcts(const CELTMode *mode, int shortBlocks, celt_sig *X,
428       celt_sig * restrict out_mem[],
429       celt_sig * restrict overlap_mem[], int C, int LM)
430 {
431    int c;
432    const int N = mode->shortMdctSize<<LM;
433    const int overlap = OVERLAP(mode);
434    VARDECL(opus_val32, x);
435    SAVE_STACK;
436
437    ALLOC(x, N+overlap, opus_val32);
438    c=0; do {
439       int j;
440       int b;
441       int N2 = N;
442       int B = 1;
443
444       if (shortBlocks)
445       {
446          N2 = mode->shortMdctSize;
447          B = shortBlocks;
448       }
449       /* Prevents problems from the imdct doing the overlap-add */
450       OPUS_CLEAR(x, overlap);
451
452       for (b=0;b<B;b++)
453       {
454          /* IMDCT on the interleaved the sub-frames */
455          clt_mdct_backward(&mode->mdct, &X[b+c*N2*B], x+N2*b, mode->window, overlap, shortBlocks ? mode->maxLM : mode->maxLM-LM, B);
456       }
457
458       for (j=0;j<overlap;j++)
459          out_mem[c][j] = x[j] + overlap_mem[c][j];
460       for (;j<N;j++)
461          out_mem[c][j] = x[j];
462       for (j=0;j<overlap;j++)
463          overlap_mem[c][j] = x[N+j];
464    } while (++c<C);
465    RESTORE_STACK;
466 }
467
468 static void deemphasis(celt_sig *in[], opus_val16 *pcm, int N, int C, int downsample, const opus_val16 *coef, celt_sig *mem)
469 {
470    int c;
471    int count=0;
472    c=0; do {
473       int j;
474       celt_sig * restrict x;
475       opus_val16  * restrict y;
476       celt_sig m = mem[c];
477       x =in[c];
478       y = pcm+c;
479       for (j=0;j<N;j++)
480       {
481          celt_sig tmp = *x + m;
482          m = MULT16_32_Q15(coef[0], tmp)
483            - MULT16_32_Q15(coef[1], *x);
484          tmp = SHL32(MULT16_32_Q15(coef[3], tmp), 2);
485          x++;
486          /* Technically the store could be moved outside of the if because
487             the stores we don't want will just be overwritten */
488          if (count==0)
489             *y = SCALEOUT(SIG2WORD16(tmp));
490          if (++count==downsample)
491          {
492             y+=C;
493             count=0;
494          }
495       }
496       mem[c] = m;
497    } while (++c<C);
498 }
499
500 static void comb_filter(opus_val32 *y, opus_val32 *x, int T0, int T1, int N,
501       opus_val16 g0, opus_val16 g1, int tapset0, int tapset1,
502       const opus_val16 *window, int overlap)
503 {
504    int i;
505    /* printf ("%d %d %f %f\n", T0, T1, g0, g1); */
506    opus_val16 g00, g01, g02, g10, g11, g12;
507    static const opus_val16 gains[3][3] = {
508          {QCONST16(0.3066406250f, 15), QCONST16(0.2170410156f, 15), QCONST16(0.1296386719f, 15)},
509          {QCONST16(0.4638671875f, 15), QCONST16(0.2680664062f, 15), QCONST16(0.f, 15)},
510          {QCONST16(0.7998046875f, 15), QCONST16(0.1000976562f, 15), QCONST16(0.f, 15)}};
511    g00 = MULT16_16_Q15(g0, gains[tapset0][0]);
512    g01 = MULT16_16_Q15(g0, gains[tapset0][1]);
513    g02 = MULT16_16_Q15(g0, gains[tapset0][2]);
514    g10 = MULT16_16_Q15(g1, gains[tapset1][0]);
515    g11 = MULT16_16_Q15(g1, gains[tapset1][1]);
516    g12 = MULT16_16_Q15(g1, gains[tapset1][2]);
517    for (i=0;i<overlap;i++)
518    {
519       opus_val16 f;
520       f = MULT16_16_Q15(window[i],window[i]);
521       y[i] = x[i]
522                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g00),x[i-T0])
523                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g01),x[i-T0-1])
524                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g01),x[i-T0+1])
525                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g02),x[i-T0-2])
526                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g02),x[i-T0+2])
527                + MULT16_32_Q15(MULT16_16_Q15(f,g10),x[i-T1])
528                + MULT16_32_Q15(MULT16_16_Q15(f,g11),x[i-T1-1])
529                + MULT16_32_Q15(MULT16_16_Q15(f,g11),x[i-T1+1])
530                + MULT16_32_Q15(MULT16_16_Q15(f,g12),x[i-T1-2])
531                + MULT16_32_Q15(MULT16_16_Q15(f,g12),x[i-T1+2]);
532
533    }
534    for (i=overlap;i<N;i++)
535       y[i] = x[i]
536                + MULT16_32_Q15(g10,x[i-T1])
537                + MULT16_32_Q15(g11,x[i-T1-1])
538                + MULT16_32_Q15(g11,x[i-T1+1])
539                + MULT16_32_Q15(g12,x[i-T1-2])
540                + MULT16_32_Q15(g12,x[i-T1+2]);
541 }
542
543 static const signed char tf_select_table[4][8] = {
544       {0, -1, 0, -1,    0,-1, 0,-1},
545       {0, -1, 0, -2,    1, 0, 1,-1},
546       {0, -2, 0, -3,    2, 0, 1,-1},
547       {0, -2, 0, -3,    3, 0, 1,-1},
548 };
549
550 static opus_val32 l1_metric(const celt_norm *tmp, int N, int LM)
551 {
552    int i;
553    opus_val32 L1;
554    opus_val16 bias;
555    L1 = 0;
556    for (i=0;i<N;i++)
557       L1 += EXTEND32(ABS16(tmp[i]));
558    /* When in doubt, prefer goo freq resolution */
559    bias = QCONST16(.015f,15)*LM;
560    L1 = MAC16_32_Q15(L1, bias, L1);
561    return L1;
562
563 }
564
565 static int tf_analysis(const CELTMode *m, int len, int C, int isTransient,
566       int *tf_res, int nbCompressedBytes, celt_norm *X, int N0, int LM,
567       int *tf_sum)
568 {
569    int i;
570    VARDECL(int, metric);
571    int cost0;
572    int cost1;
573    VARDECL(int, path0);
574    VARDECL(int, path1);
575    VARDECL(celt_norm, tmp);
576    int lambda;
577    int tf_select=0;
578    SAVE_STACK;
579
580    if (nbCompressedBytes<15*C)
581    {
582       *tf_sum = 0;
583       for (i=0;i<len;i++)
584          tf_res[i] = isTransient;
585       return 0;
586    }
587    if (nbCompressedBytes<40)
588       lambda = 12;
589    else if (nbCompressedBytes<60)
590       lambda = 6;
591    else if (nbCompressedBytes<100)
592       lambda = 4;
593    else
594       lambda = 3;
595
596    ALLOC(metric, len, int);
597    ALLOC(tmp, (m->eBands[len]-m->eBands[len-1])<<LM, celt_norm);
598    ALLOC(path0, len, int);
599    ALLOC(path1, len, int);
600
601    *tf_sum = 0;
602    for (i=0;i<len;i++)
603    {
604       int j, k, N;
605       opus_val32 L1, best_L1;
606       int best_level=0;
607       N = (m->eBands[i+1]-m->eBands[i])<<LM;
608       for (j=0;j<N;j++)
609          tmp[j] = X[j+(m->eBands[i]<<LM)];
610       /* Just add the right channel if we're in stereo */
611       if (C==2)
612          for (j=0;j<N;j++)
613             tmp[j] = ADD16(SHR16(tmp[j], 1),SHR16(X[N0+j+(m->eBands[i]<<LM)], 1));
614       L1 = l1_metric(tmp, N, isTransient ? LM : 0);
615       best_L1 = L1;
616       /*printf ("%f ", L1);*/
617       for (k=0;k<LM;k++)
618       {
619          int B;
620
621          if (isTransient)
622             B = (LM-k-1);
623          else
624             B = k+1;
625
626          if (isTransient)
627             haar1(tmp, N>>(LM-k), 1<<(LM-k));
628          else
629             haar1(tmp, N>>k, 1<<k);
630
631          L1 = l1_metric(tmp, N, B);
632
633          if (L1 < best_L1)
634          {
635             best_L1 = L1;
636             best_level = k+1;
637          }
638       }
639       /*printf ("%d ", isTransient ? LM-best_level : best_level);*/
640       if (isTransient)
641          metric[i] = best_level;
642       else
643          metric[i] = -best_level;
644       *tf_sum += metric[i];
645    }
646    /*printf("\n");*/
647    /* NOTE: Future optimized implementations could detect extreme transients and set
648       tf_select = 1 but so far we have not found a reliable way of making this useful */
649    tf_select = 0;
650
651    cost0 = 0;
652    cost1 = isTransient ? 0 : lambda;
653    /* Viterbi forward pass */
654    for (i=1;i<len;i++)
655    {
656       int curr0, curr1;
657       int from0, from1;
658
659       from0 = cost0;
660       from1 = cost1 + lambda;
661       if (from0 < from1)
662       {
663          curr0 = from0;
664          path0[i]= 0;
665       } else {
666          curr0 = from1;
667          path0[i]= 1;
668       }
669
670       from0 = cost0 + lambda;
671       from1 = cost1;
672       if (from0 < from1)
673       {
674          curr1 = from0;
675          path1[i]= 0;
676       } else {
677          curr1 = from1;
678          path1[i]= 1;
679       }
680       cost0 = curr0 + abs(metric[i]-tf_select_table[LM][4*isTransient+2*tf_select+0]);
681       cost1 = curr1 + abs(metric[i]-tf_select_table[LM][4*isTransient+2*tf_select+1]);
682    }
683    tf_res[len-1] = cost0 < cost1 ? 0 : 1;
684    /* Viterbi backward pass to check the decisions */
685    for (i=len-2;i>=0;i--)
686    {
687       if (tf_res[i+1] == 1)
688          tf_res[i] = path1[i+1];
689       else
690          tf_res[i] = path0[i+1];
691    }
692    RESTORE_STACK;
693 #ifdef FUZZING
694    tf_select = rand()&0x1;
695    tf_res[0] = rand()&0x1;
696    for (i=1;i<len;i++)
697       tf_res[i] = tf_res[i-1] ^ ((rand()&0xF) == 0);
698 #endif
699    return tf_select;
700 }
701
702 static void tf_encode(int start, int end, int isTransient, int *tf_res, int LM, int tf_select, ec_enc *enc)
703 {
704    int curr, i;
705    int tf_select_rsv;
706    int tf_changed;
707    int logp;
708    opus_uint32 budget;
709    opus_uint32 tell;
710    budget = enc->storage*8;
711    tell = ec_tell(enc);
712    logp = isTransient ? 2 : 4;
713    /* Reserve space to code the tf_select decision. */
714    tf_select_rsv = LM>0 && tell+logp+1 <= budget;
715    budget -= tf_select_rsv;
716    curr = tf_changed = 0;
717    for (i=start;i<end;i++)
718    {
719       if (tell+logp<=budget)
720       {
721          ec_enc_bit_logp(enc, tf_res[i] ^ curr, logp);
722          tell = ec_tell(enc);
723          curr = tf_res[i];
724          tf_changed |= curr;
725       }
726       else
727          tf_res[i] = curr;
728       logp = isTransient ? 4 : 5;
729    }
730    /* Only code tf_select if it would actually make a difference. */
731    if (tf_select_rsv &&
732          tf_select_table[LM][4*isTransient+0+tf_changed]!=
733          tf_select_table[LM][4*isTransient+2+tf_changed])
734       ec_enc_bit_logp(enc, tf_select, 1);
735    else
736       tf_select = 0;
737    for (i=start;i<end;i++)
738       tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]];
739    /*printf("%d %d ", isTransient, tf_select); for(i=0;i<end;i++)printf("%d ", tf_res[i]);printf("\n");*/
740 }
741
742 static void tf_decode(int start, int end, int isTransient, int *tf_res, int LM, ec_dec *dec)
743 {
744    int i, curr, tf_select;
745    int tf_select_rsv;
746    int tf_changed;
747    int logp;
748    opus_uint32 budget;
749    opus_uint32 tell;
750
751    budget = dec->storage*8;
752    tell = ec_tell(dec);
753    logp = isTransient ? 2 : 4;
754    tf_select_rsv = LM>0 && tell+logp+1<=budget;
755    budget -= tf_select_rsv;
756    tf_changed = curr = 0;
757    for (i=start;i<end;i++)
758    {
759       if (tell+logp<=budget)
760       {
761          curr ^= ec_dec_bit_logp(dec, logp);
762          tell = ec_tell(dec);
763          tf_changed |= curr;
764       }
765       tf_res[i] = curr;
766       logp = isTransient ? 4 : 5;
767    }
768    tf_select = 0;
769    if (tf_select_rsv &&
770      tf_select_table[LM][4*isTransient+0+tf_changed] !=
771      tf_select_table[LM][4*isTransient+2+tf_changed])
772    {
773       tf_select = ec_dec_bit_logp(dec, 1);
774    }
775    for (i=start;i<end;i++)
776    {
777       tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]];
778    }
779 }
780
781 static void init_caps(const CELTMode *m,int *cap,int LM,int C)
782 {
783    int i;
784    for (i=0;i<m->nbEBands;i++)
785    {
786       int N;
787       N=(m->eBands[i+1]-m->eBands[i])<<LM;
788       cap[i] = (m->cache.caps[m->nbEBands*(2*LM+C-1)+i]+64)*C*N>>2;
789    }
790 }
791
792 static int alloc_trim_analysis(const CELTMode *m, const celt_norm *X,
793       const opus_val16 *bandLogE, int end, int LM, int C, int N0)
794 {
795    int i;
796    opus_val32 diff=0;
797    int c;
798    int trim_index = 5;
799    if (C==2)
800    {
801       opus_val16 sum = 0; /* Q10 */
802       /* Compute inter-channel correlation for low frequencies */
803       for (i=0;i<8;i++)
804       {
805          int j;
806          opus_val32 partial = 0;
807          for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++)
808             partial = MAC16_16(partial, X[j], X[N0+j]);
809          sum = ADD16(sum, EXTRACT16(SHR32(partial, 18)));
810       }
811       sum = MULT16_16_Q15(QCONST16(1.f/8, 15), sum);
812       /*printf ("%f\n", sum);*/
813       if (sum > QCONST16(.995f,10))
814          trim_index-=4;
815       else if (sum > QCONST16(.92f,10))
816          trim_index-=3;
817       else if (sum > QCONST16(.85f,10))
818          trim_index-=2;
819       else if (sum > QCONST16(.8f,10))
820          trim_index-=1;
821    }
822
823    /* Estimate spectral tilt */
824    c=0; do {
825       for (i=0;i<end-1;i++)
826       {
827          diff += bandLogE[i+c*m->nbEBands]*(opus_int32)(2+2*i-m->nbEBands);
828       }
829    } while (++c<C);
830    /* We divide by two here to avoid making the tilt larger for stereo as a
831       result of a bug in the loop above */
832    diff /= 2*C*(end-1);
833    /*printf("%f\n", diff);*/
834    if (diff > QCONST16(2.f, DB_SHIFT))
835       trim_index--;
836    if (diff > QCONST16(8.f, DB_SHIFT))
837       trim_index--;
838    if (diff < -QCONST16(4.f, DB_SHIFT))
839       trim_index++;
840    if (diff < -QCONST16(10.f, DB_SHIFT))
841       trim_index++;
842
843    if (trim_index<0)
844       trim_index = 0;
845    if (trim_index>10)
846       trim_index = 10;
847 #ifdef FUZZING
848    trim_index = rand()%11;
849 #endif
850    return trim_index;
851 }
852
853 static int stereo_analysis(const CELTMode *m, const celt_norm *X,
854       int LM, int N0)
855 {
856    int i;
857    int thetas;
858    opus_val32 sumLR = EPSILON, sumMS = EPSILON;
859
860    /* Use the L1 norm to model the entropy of the L/R signal vs the M/S signal */
861    for (i=0;i<13;i++)
862    {
863       int j;
864       for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++)
865       {
866          opus_val32 L, R, M, S;
867          /* We cast to 32-bit first because of the -32768 case */
868          L = EXTEND32(X[j]);
869          R = EXTEND32(X[N0+j]);
870          M = ADD32(L, R);
871          S = SUB32(L, R);
872          sumLR = ADD32(sumLR, ADD32(ABS32(L), ABS32(R)));
873          sumMS = ADD32(sumMS, ADD32(ABS32(M), ABS32(S)));
874       }
875    }
876    sumMS = MULT16_32_Q15(QCONST16(0.707107f, 15), sumMS);
877    thetas = 13;
878    /* We don't need thetas for lower bands with LM<=1 */
879    if (LM<=1)
880       thetas -= 8;
881    return MULT16_32_Q15((m->eBands[13]<<(LM+1))+thetas, sumMS)
882          > MULT16_32_Q15(m->eBands[13]<<(LM+1), sumLR);
883 }
884
885 int celt_encode_with_ec(CELTEncoder * restrict st, const opus_val16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
886 {
887    int i, c, N;
888    opus_int32 bits;
889    ec_enc _enc;
890    VARDECL(celt_sig, in);
891    VARDECL(celt_sig, freq);
892    VARDECL(celt_norm, X);
893    VARDECL(celt_ener, bandE);
894    VARDECL(opus_val16, bandLogE);
895    VARDECL(int, fine_quant);
896    VARDECL(opus_val16, error);
897    VARDECL(int, pulses);
898    VARDECL(int, cap);
899    VARDECL(int, offsets);
900    VARDECL(int, fine_priority);
901    VARDECL(int, tf_res);
902    VARDECL(unsigned char, collapse_masks);
903    celt_sig *prefilter_mem;
904    opus_val16 *oldBandE, *oldLogE, *oldLogE2;
905    int shortBlocks=0;
906    int isTransient=0;
907    const int CC = st->channels;
908    const int C = st->stream_channels;
909    int LM, M;
910    int tf_select;
911    int nbFilledBytes, nbAvailableBytes;
912    int effEnd;
913    int codedBands;
914    int tf_sum;
915    int alloc_trim;
916    int pitch_index=COMBFILTER_MINPERIOD;
917    opus_val16 gain1 = 0;
918    int intensity=0;
919    int dual_stereo=0;
920    int effectiveBytes;
921    opus_val16 pf_threshold;
922    int dynalloc_logp;
923    opus_int32 vbr_rate;
924    opus_int32 total_bits;
925    opus_int32 total_boost;
926    opus_int32 balance;
927    opus_int32 tell;
928    int prefilter_tapset=0;
929    int pf_on;
930    int anti_collapse_rsv;
931    int anti_collapse_on=0;
932    int silence=0;
933    opus_val16 tf_estimate;
934    ALLOC_STACK;
935
936    if (nbCompressedBytes<2 || pcm==NULL)
937      return OPUS_BAD_ARG;
938
939    frame_size *= st->upsample;
940    for (LM=0;LM<=st->mode->maxLM;LM++)
941       if (st->mode->shortMdctSize<<LM==frame_size)
942          break;
943    if (LM>st->mode->maxLM)
944       return OPUS_BAD_ARG;
945    M=1<<LM;
946    N = M*st->mode->shortMdctSize;
947
948    prefilter_mem = st->in_mem+CC*(st->overlap);
949    oldBandE = (opus_val16*)(st->in_mem+CC*(2*st->overlap+COMBFILTER_MAXPERIOD));
950    oldLogE = oldBandE + CC*st->mode->nbEBands;
951    oldLogE2 = oldLogE + CC*st->mode->nbEBands;
952
953    if (enc==NULL)
954    {
955       tell=1;
956       nbFilledBytes=0;
957    } else {
958       tell=ec_tell(enc);
959       nbFilledBytes=(tell+4)>>3;
960    }
961
962 #ifdef CUSTOM_MODES
963    if (st->signalling && enc==NULL)
964    {
965       int tmp = (st->mode->effEBands-st->end)>>1;
966       st->end = IMAX(1, st->mode->effEBands-tmp);
967       compressed[0] = tmp<<5;
968       compressed[0] |= LM<<3;
969       compressed[0] |= (C==2)<<2;
970       /* Convert "standard mode" to Opus header */
971       if (st->mode->Fs==48000 && st->mode->shortMdctSize==120)
972       {
973          int c0 = toOpus(compressed[0]);
974          if (c0<0)
975             return OPUS_BAD_ARG;
976          compressed[0] = c0;
977       }
978       compressed++;
979       nbCompressedBytes--;
980    }
981 #else
982    celt_assert(st->signalling==0);
983 #endif
984
985    /* Can't produce more than 1275 output bytes */
986    nbCompressedBytes = IMIN(nbCompressedBytes,1275);
987    nbAvailableBytes = nbCompressedBytes - nbFilledBytes;
988
989    if (st->vbr && st->bitrate!=OPUS_BITRATE_MAX)
990    {
991       opus_int32 den=st->mode->Fs>>BITRES;
992       vbr_rate=(st->bitrate*frame_size+(den>>1))/den;
993 #ifdef CUSTOM_MODES
994       if (st->signalling)
995          vbr_rate -= 8<<BITRES;
996 #endif
997       effectiveBytes = vbr_rate>>(3+BITRES);
998    } else {
999       opus_int32 tmp;
1000       vbr_rate = 0;
1001       tmp = st->bitrate*frame_size;
1002       if (tell>1)
1003          tmp += tell;
1004       if (st->bitrate!=OPUS_BITRATE_MAX)
1005          nbCompressedBytes = IMAX(2, IMIN(nbCompressedBytes,
1006                (tmp+4*st->mode->Fs)/(8*st->mode->Fs)-!!st->signalling));
1007       effectiveBytes = nbCompressedBytes;
1008    }
1009
1010    if (enc==NULL)
1011    {
1012       ec_enc_init(&_enc, compressed, nbCompressedBytes);
1013       enc = &_enc;
1014    }
1015
1016    if (vbr_rate>0)
1017    {
1018       /* Computes the max bit-rate allowed in VBR mode to avoid violating the
1019           target rate and buffering.
1020          We must do this up front so that bust-prevention logic triggers
1021           correctly if we don't have enough bits. */
1022       if (st->constrained_vbr)
1023       {
1024          opus_int32 vbr_bound;
1025          opus_int32 max_allowed;
1026          /* We could use any multiple of vbr_rate as bound (depending on the
1027              delay).
1028             This is clamped to ensure we use at least two bytes if the encoder
1029              was entirely empty, but to allow 0 in hybrid mode. */
1030          vbr_bound = vbr_rate;
1031          max_allowed = IMIN(IMAX(tell==1?2:0,
1032                (vbr_rate+vbr_bound-st->vbr_reservoir)>>(BITRES+3)),
1033                nbAvailableBytes);
1034          if(max_allowed < nbAvailableBytes)
1035          {
1036             nbCompressedBytes = nbFilledBytes+max_allowed;
1037             nbAvailableBytes = max_allowed;
1038             ec_enc_shrink(enc, nbCompressedBytes);
1039          }
1040       }
1041    }
1042    total_bits = nbCompressedBytes*8;
1043
1044    effEnd = st->end;
1045    if (effEnd > st->mode->effEBands)
1046       effEnd = st->mode->effEBands;
1047
1048    ALLOC(in, CC*(N+st->overlap), celt_sig);
1049
1050    /* Find pitch period and gain */
1051    {
1052       VARDECL(celt_sig, _pre);
1053       celt_sig *pre[2];
1054       SAVE_STACK;
1055       ALLOC(_pre, CC*(N+COMBFILTER_MAXPERIOD), celt_sig);
1056
1057       pre[0] = _pre;
1058       pre[1] = _pre + (N+COMBFILTER_MAXPERIOD);
1059
1060       silence = 1;
1061       c=0; do {
1062          int count = 0;
1063          const opus_val16 * restrict pcmp = pcm+c;
1064          celt_sig * restrict inp = in+c*(N+st->overlap)+st->overlap;
1065
1066          for (i=0;i<N;i++)
1067          {
1068             celt_sig x, tmp;
1069
1070             x = SCALEIN(*pcmp);
1071 #ifndef FIXED_POINT
1072             if (!(x==x))
1073                x = 0;
1074             if (st->clip)
1075                x = MAX32(-65536.f, MIN32(65536.f,x));
1076 #endif
1077             if (++count==st->upsample)
1078             {
1079                count=0;
1080                pcmp+=CC;
1081             } else {
1082                x = 0;
1083             }
1084             /* Apply pre-emphasis */
1085             tmp = MULT16_16(st->mode->preemph[2], x);
1086             *inp = tmp + st->preemph_memE[c];
1087             st->preemph_memE[c] = MULT16_32_Q15(st->mode->preemph[1], *inp)
1088                                    - MULT16_32_Q15(st->mode->preemph[0], tmp);
1089             silence = silence && *inp == 0;
1090             inp++;
1091          }
1092          OPUS_COPY(pre[c], prefilter_mem+c*COMBFILTER_MAXPERIOD, COMBFILTER_MAXPERIOD);
1093          OPUS_COPY(pre[c]+COMBFILTER_MAXPERIOD, in+c*(N+st->overlap)+st->overlap, N);
1094       } while (++c<CC);
1095
1096 #ifdef FUZZING
1097       if ((rand()&0x3F)==0)
1098          silence = 1;
1099 #endif
1100       if (tell==1)
1101          ec_enc_bit_logp(enc, silence, 15);
1102       else
1103          silence=0;
1104       if (silence)
1105       {
1106          /*In VBR mode there is no need to send more than the minimum. */
1107          if (vbr_rate>0)
1108          {
1109             effectiveBytes=nbCompressedBytes=IMIN(nbCompressedBytes, nbFilledBytes+2);
1110             total_bits=nbCompressedBytes*8;
1111             nbAvailableBytes=2;
1112             ec_enc_shrink(enc, nbCompressedBytes);
1113          }
1114          /* Pretend we've filled all the remaining bits with zeros
1115             (that's what the initialiser did anyway) */
1116          tell = nbCompressedBytes*8;
1117          enc->nbits_total+=tell-ec_tell(enc);
1118       }
1119       if (nbAvailableBytes>12*C && st->start==0 && !silence && !st->disable_pf && st->complexity >= 5)
1120       {
1121          VARDECL(opus_val16, pitch_buf);
1122          ALLOC(pitch_buf, (COMBFILTER_MAXPERIOD+N)>>1, opus_val16);
1123
1124          pitch_downsample(pre, pitch_buf, COMBFILTER_MAXPERIOD+N, CC);
1125          pitch_search(pitch_buf+(COMBFILTER_MAXPERIOD>>1), pitch_buf, N,
1126                COMBFILTER_MAXPERIOD-COMBFILTER_MINPERIOD, &pitch_index);
1127          pitch_index = COMBFILTER_MAXPERIOD-pitch_index;
1128
1129          gain1 = remove_doubling(pitch_buf, COMBFILTER_MAXPERIOD, COMBFILTER_MINPERIOD,
1130                N, &pitch_index, st->prefilter_period, st->prefilter_gain);
1131          if (pitch_index > COMBFILTER_MAXPERIOD-2)
1132             pitch_index = COMBFILTER_MAXPERIOD-2;
1133          gain1 = MULT16_16_Q15(QCONST16(.7f,15),gain1);
1134          if (st->loss_rate>2)
1135             gain1 = HALF32(gain1);
1136          if (st->loss_rate>4)
1137             gain1 = HALF32(gain1);
1138          if (st->loss_rate>8)
1139             gain1 = 0;
1140          prefilter_tapset = st->tapset_decision;
1141       } else {
1142          gain1 = 0;
1143       }
1144
1145       /* Gain threshold for enabling the prefilter/postfilter */
1146       pf_threshold = QCONST16(.2f,15);
1147
1148       /* Adjusting the threshold based on rate and continuity */
1149       if (abs(pitch_index-st->prefilter_period)*10>pitch_index)
1150          pf_threshold += QCONST16(.2f,15);
1151       if (nbAvailableBytes<25)
1152          pf_threshold += QCONST16(.1f,15);
1153       if (nbAvailableBytes<35)
1154          pf_threshold += QCONST16(.1f,15);
1155       if (st->prefilter_gain > QCONST16(.4f,15))
1156          pf_threshold -= QCONST16(.1f,15);
1157       if (st->prefilter_gain > QCONST16(.55f,15))
1158          pf_threshold -= QCONST16(.1f,15);
1159
1160       /* Hard threshold at 0.2 */
1161       pf_threshold = MAX16(pf_threshold, QCONST16(.2f,15));
1162       if (gain1<pf_threshold)
1163       {
1164          if(st->start==0 && tell+16<=total_bits)
1165             ec_enc_bit_logp(enc, 0, 1);
1166          gain1 = 0;
1167          pf_on = 0;
1168       } else {
1169          /*This block is not gated by a total bits check only because
1170            of the nbAvailableBytes check above.*/
1171          int qg;
1172          int octave;
1173
1174          if (ABS16(gain1-st->prefilter_gain)<QCONST16(.1f,15))
1175             gain1=st->prefilter_gain;
1176
1177 #ifdef FIXED_POINT
1178          qg = ((gain1+1536)>>10)/3-1;
1179 #else
1180          qg = (int)floor(.5f+gain1*32/3)-1;
1181 #endif
1182          qg = IMAX(0, IMIN(7, qg));
1183          ec_enc_bit_logp(enc, 1, 1);
1184          pitch_index += 1;
1185          octave = EC_ILOG(pitch_index)-5;
1186          ec_enc_uint(enc, octave, 6);
1187          ec_enc_bits(enc, pitch_index-(16<<octave), 4+octave);
1188          pitch_index -= 1;
1189          ec_enc_bits(enc, qg, 3);
1190          if (ec_tell(enc)+2<=total_bits)
1191             ec_enc_icdf(enc, prefilter_tapset, tapset_icdf, 2);
1192          else
1193            prefilter_tapset = 0;
1194          gain1 = QCONST16(0.09375f,15)*(qg+1);
1195          pf_on = 1;
1196       }
1197       /*printf("%d %f\n", pitch_index, gain1);*/
1198
1199       c=0; do {
1200          int offset = st->mode->shortMdctSize-st->mode->overlap;
1201          st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
1202          OPUS_COPY(in+c*(N+st->overlap), st->in_mem+c*(st->overlap), st->overlap);
1203          if (offset)
1204             comb_filter(in+c*(N+st->overlap)+st->overlap, pre[c]+COMBFILTER_MAXPERIOD,
1205                   st->prefilter_period, st->prefilter_period, offset, -st->prefilter_gain, -st->prefilter_gain,
1206                   st->prefilter_tapset, st->prefilter_tapset, NULL, 0);
1207
1208          comb_filter(in+c*(N+st->overlap)+st->overlap+offset, pre[c]+COMBFILTER_MAXPERIOD+offset,
1209                st->prefilter_period, pitch_index, N-offset, -st->prefilter_gain, -gain1,
1210                st->prefilter_tapset, prefilter_tapset, st->mode->window, st->mode->overlap);
1211          OPUS_COPY(st->in_mem+c*(st->overlap), in+c*(N+st->overlap)+N, st->overlap);
1212
1213          if (N>COMBFILTER_MAXPERIOD)
1214          {
1215             OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, pre[c]+N, COMBFILTER_MAXPERIOD);
1216          } else {
1217             OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, prefilter_mem+c*COMBFILTER_MAXPERIOD+N, COMBFILTER_MAXPERIOD-N);
1218             OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD+COMBFILTER_MAXPERIOD-N, pre[c]+COMBFILTER_MAXPERIOD, N);
1219          }
1220       } while (++c<CC);
1221
1222       RESTORE_STACK;
1223    }
1224
1225    isTransient = 0;
1226    shortBlocks = 0;
1227    if (LM>0 && ec_tell(enc)+3<=total_bits)
1228    {
1229       if (st->complexity > 1)
1230       {
1231          isTransient = transient_analysis(in, N+st->overlap, CC,
1232                   st->overlap, &tf_estimate);
1233          if (isTransient)
1234             shortBlocks = M;
1235       }
1236       ec_enc_bit_logp(enc, isTransient, 3);
1237    }
1238
1239    ALLOC(freq, CC*N, celt_sig); /**< Interleaved signal MDCTs */
1240    ALLOC(bandE,st->mode->nbEBands*CC, celt_ener);
1241    ALLOC(bandLogE,st->mode->nbEBands*CC, opus_val16);
1242    /* Compute MDCTs */
1243    compute_mdcts(st->mode, shortBlocks, in, freq, CC, LM);
1244
1245    if (CC==2&&C==1)
1246    {
1247       for (i=0;i<N;i++)
1248          freq[i] = ADD32(HALF32(freq[i]), HALF32(freq[N+i]));
1249    }
1250    if (st->upsample != 1)
1251    {
1252       c=0; do
1253       {
1254          int bound = N/st->upsample;
1255          for (i=0;i<bound;i++)
1256             freq[c*N+i] *= st->upsample;
1257          for (;i<N;i++)
1258             freq[c*N+i] = 0;
1259       } while (++c<C);
1260    }
1261    ALLOC(X, C*N, celt_norm);         /**< Interleaved normalised MDCTs */
1262
1263    compute_band_energies(st->mode, freq, bandE, effEnd, C, M);
1264
1265    amp2Log2(st->mode, effEnd, st->end, bandE, bandLogE, C);
1266
1267    /* Band normalisation */
1268    normalise_bands(st->mode, freq, X, bandE, effEnd, C, M);
1269
1270    ALLOC(tf_res, st->mode->nbEBands, int);
1271    tf_select = tf_analysis(st->mode, effEnd, C, isTransient, tf_res, effectiveBytes, X, N, LM, &tf_sum);
1272    for (i=effEnd;i<st->end;i++)
1273       tf_res[i] = tf_res[effEnd-1];
1274
1275    ALLOC(error, C*st->mode->nbEBands, opus_val16);
1276    quant_coarse_energy(st->mode, st->start, st->end, effEnd, bandLogE,
1277          oldBandE, total_bits, error, enc,
1278          C, LM, nbAvailableBytes, st->force_intra,
1279          &st->delayedIntra, st->complexity >= 4, st->loss_rate);
1280
1281    tf_encode(st->start, st->end, isTransient, tf_res, LM, tf_select, enc);
1282
1283    st->spread_decision = SPREAD_NORMAL;
1284    if (ec_tell(enc)+4<=total_bits)
1285    {
1286       if (shortBlocks || st->complexity < 3 || nbAvailableBytes < 10*C)
1287       {
1288          if (st->complexity == 0)
1289             st->spread_decision = SPREAD_NONE;
1290       } else {
1291          st->spread_decision = spreading_decision(st->mode, X,
1292                &st->tonal_average, st->spread_decision, &st->hf_average,
1293                &st->tapset_decision, pf_on&&!shortBlocks, effEnd, C, M);
1294       }
1295       ec_enc_icdf(enc, st->spread_decision, spread_icdf, 5);
1296    }
1297
1298    ALLOC(cap, st->mode->nbEBands, int);
1299    ALLOC(offsets, st->mode->nbEBands, int);
1300
1301    init_caps(st->mode,cap,LM,C);
1302    for (i=0;i<st->mode->nbEBands;i++)
1303       offsets[i] = 0;
1304    /* Dynamic allocation code */
1305    /* Make sure that dynamic allocation can't make us bust the budget */
1306    if (effectiveBytes > 50 && LM>=1)
1307    {
1308       int t1, t2;
1309       if (LM <= 1)
1310       {
1311          t1 = 3;
1312          t2 = 5;
1313       } else {
1314          t1 = 2;
1315          t2 = 4;
1316       }
1317       for (i=st->start+1;i<st->end-1;i++)
1318       {
1319          opus_val32 d2;
1320          d2 = 2*bandLogE[i]-bandLogE[i-1]-bandLogE[i+1];
1321          if (C==2)
1322             d2 = HALF32(d2 + 2*bandLogE[i+st->mode->nbEBands]-
1323                   bandLogE[i-1+st->mode->nbEBands]-bandLogE[i+1+st->mode->nbEBands]);
1324 #ifdef FUZZING
1325          if((rand()&0xF)==0)
1326          {
1327             offsets[i] += 1;
1328             if((rand()&0x3)==0)
1329                offsets[i] += 1+(rand()&0x3);
1330          }
1331 #else
1332          if (d2 > SHL16(t1,DB_SHIFT))
1333             offsets[i] += 1;
1334          if (d2 > SHL16(t2,DB_SHIFT))
1335             offsets[i] += 1;
1336 #endif
1337       }
1338    }
1339    dynalloc_logp = 6;
1340    total_bits<<=BITRES;
1341    total_boost = 0;
1342    tell = ec_tell_frac(enc);
1343    for (i=st->start;i<st->end;i++)
1344    {
1345       int width, quanta;
1346       int dynalloc_loop_logp;
1347       int boost;
1348       int j;
1349       width = C*(st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
1350       /* quanta is 6 bits, but no more than 1 bit/sample
1351          and no less than 1/8 bit/sample */
1352       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
1353       dynalloc_loop_logp = dynalloc_logp;
1354       boost = 0;
1355       for (j = 0; tell+(dynalloc_loop_logp<<BITRES) < total_bits-total_boost
1356             && boost < cap[i]; j++)
1357       {
1358          int flag;
1359          flag = j<offsets[i];
1360          ec_enc_bit_logp(enc, flag, dynalloc_loop_logp);
1361          tell = ec_tell_frac(enc);
1362          if (!flag)
1363             break;
1364          boost += quanta;
1365          total_boost += quanta;
1366          dynalloc_loop_logp = 1;
1367       }
1368       /* Making dynalloc more likely */
1369       if (j)
1370          dynalloc_logp = IMAX(2, dynalloc_logp-1);
1371       offsets[i] = boost;
1372    }
1373    alloc_trim = 5;
1374    if (tell+(6<<BITRES) <= total_bits - total_boost)
1375    {
1376       alloc_trim = alloc_trim_analysis(st->mode, X, bandLogE,
1377             st->end, LM, C, N);
1378       ec_enc_icdf(enc, alloc_trim, trim_icdf, 7);
1379       tell = ec_tell_frac(enc);
1380    }
1381
1382    /* Variable bitrate */
1383    if (vbr_rate>0)
1384    {
1385      opus_val16 alpha;
1386      opus_int32 delta;
1387      /* The target rate in 8th bits per frame */
1388      opus_int32 target;
1389      opus_int32 min_allowed;
1390      int lm_diff = st->mode->maxLM - LM;
1391
1392      /* Don't attempt to use more than 510 kb/s, even for frames smaller than 20 ms.
1393         The CELT allocator will just not be able to use more than that anyway. */
1394      nbCompressedBytes = IMIN(nbCompressedBytes,1275>>(3-LM));
1395      target = vbr_rate - ((40*C+20)<<BITRES);
1396      if (st->constrained_vbr)
1397         target += (st->vbr_offset>>lm_diff);
1398
1399 #ifdef FIXED_POINT
1400      target = SHL32(MULT16_32_Q15(target, SUB16(tf_estimate, QCONST16(0.05, 14))),1);
1401 #else
1402      target *= tf_estimate-.05;
1403 #endif
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 }