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