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