Aborting on NaN in CELT
[opus.git] / celt / celt_encoder.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_ENCODER_C
35
36 #include "cpu_support.h"
37 #include "os_support.h"
38 #include "mdct.h"
39 #include <math.h>
40 #include "celt.h"
41 #include "pitch.h"
42 #include "bands.h"
43 #include "modes.h"
44 #include "entcode.h"
45 #include "quant_bands.h"
46 #include "rate.h"
47 #include "stack_alloc.h"
48 #include "mathops.h"
49 #include "float_cast.h"
50 #include <stdarg.h>
51 #include "celt_lpc.h"
52 #include "vq.h"
53
54
55 /** Encoder state
56  @brief Encoder state
57  */
58 struct OpusCustomEncoder {
59    const OpusCustomMode *mode;     /**< Mode used by the encoder */
60    int channels;
61    int stream_channels;
62
63    int force_intra;
64    int clip;
65    int disable_pf;
66    int complexity;
67    int upsample;
68    int start, end;
69
70    opus_int32 bitrate;
71    int vbr;
72    int signalling;
73    int constrained_vbr;      /* If zero, VBR can do whatever it likes with the rate */
74    int loss_rate;
75    int lsb_depth;
76    int lfe;
77    int disable_inv;
78    int arch;
79
80    /* Everything beyond this point gets cleared on a reset */
81 #define ENCODER_RESET_START rng
82
83    opus_uint32 rng;
84    int spread_decision;
85    opus_val32 delayedIntra;
86    int tonal_average;
87    int lastCodedBands;
88    int hf_average;
89    int tapset_decision;
90
91    int prefilter_period;
92    opus_val16 prefilter_gain;
93    int prefilter_tapset;
94 #ifdef RESYNTH
95    int prefilter_period_old;
96    opus_val16 prefilter_gain_old;
97    int prefilter_tapset_old;
98 #endif
99    int consec_transient;
100    AnalysisInfo analysis;
101    SILKInfo silk_info;
102
103    opus_val32 preemph_memE[2];
104    opus_val32 preemph_memD[2];
105
106    /* VBR-related parameters */
107    opus_int32 vbr_reservoir;
108    opus_int32 vbr_drift;
109    opus_int32 vbr_offset;
110    opus_int32 vbr_count;
111    opus_val32 overlap_max;
112    opus_val16 stereo_saving;
113    int intensity;
114    opus_val16 *energy_mask;
115    opus_val16 spec_avg;
116
117 #ifdef RESYNTH
118    /* +MAX_PERIOD/2 to make space for overlap */
119    celt_sig syn_mem[2][2*MAX_PERIOD+MAX_PERIOD/2];
120 #endif
121
122    celt_sig in_mem[1]; /* Size = channels*mode->overlap */
123    /* celt_sig prefilter_mem[],  Size = channels*COMBFILTER_MAXPERIOD */
124    /* opus_val16 oldBandE[],     Size = channels*mode->nbEBands */
125    /* opus_val16 oldLogE[],      Size = channels*mode->nbEBands */
126    /* opus_val16 oldLogE2[],     Size = channels*mode->nbEBands */
127    /* opus_val16 energyError[],  Size = channels*mode->nbEBands */
128 };
129
130 int celt_encoder_get_size(int channels)
131 {
132    CELTMode *mode = opus_custom_mode_create(48000, 960, NULL);
133    return opus_custom_encoder_get_size(mode, channels);
134 }
135
136 OPUS_CUSTOM_NOSTATIC int opus_custom_encoder_get_size(const CELTMode *mode, int channels)
137 {
138    int size = sizeof(struct CELTEncoder)
139          + (channels*mode->overlap-1)*sizeof(celt_sig)    /* celt_sig in_mem[channels*mode->overlap]; */
140          + channels*COMBFILTER_MAXPERIOD*sizeof(celt_sig) /* celt_sig prefilter_mem[channels*COMBFILTER_MAXPERIOD]; */
141          + 4*channels*mode->nbEBands*sizeof(opus_val16);  /* opus_val16 oldBandE[channels*mode->nbEBands]; */
142                                                           /* opus_val16 oldLogE[channels*mode->nbEBands]; */
143                                                           /* opus_val16 oldLogE2[channels*mode->nbEBands]; */
144                                                           /* opus_val16 energyError[channels*mode->nbEBands]; */
145    return size;
146 }
147
148 #ifdef CUSTOM_MODES
149 CELTEncoder *opus_custom_encoder_create(const CELTMode *mode, int channels, int *error)
150 {
151    int ret;
152    CELTEncoder *st = (CELTEncoder *)opus_alloc(opus_custom_encoder_get_size(mode, channels));
153    /* init will handle the NULL case */
154    ret = opus_custom_encoder_init(st, mode, channels);
155    if (ret != OPUS_OK)
156    {
157       opus_custom_encoder_destroy(st);
158       st = NULL;
159    }
160    if (error)
161       *error = ret;
162    return st;
163 }
164 #endif /* CUSTOM_MODES */
165
166 static int opus_custom_encoder_init_arch(CELTEncoder *st, const CELTMode *mode,
167                                          int channels, int arch)
168 {
169    if (channels < 0 || channels > 2)
170       return OPUS_BAD_ARG;
171
172    if (st==NULL || mode==NULL)
173       return OPUS_ALLOC_FAIL;
174
175    OPUS_CLEAR((char*)st, opus_custom_encoder_get_size(mode, channels));
176
177    st->mode = mode;
178    st->stream_channels = st->channels = channels;
179
180    st->upsample = 1;
181    st->start = 0;
182    st->end = st->mode->effEBands;
183    st->signalling = 1;
184    st->arch = arch;
185
186    st->constrained_vbr = 1;
187    st->clip = 1;
188
189    st->bitrate = OPUS_BITRATE_MAX;
190    st->vbr = 0;
191    st->force_intra  = 0;
192    st->complexity = 5;
193    st->lsb_depth=24;
194
195    opus_custom_encoder_ctl(st, OPUS_RESET_STATE);
196
197    return OPUS_OK;
198 }
199
200 #ifdef CUSTOM_MODES
201 int opus_custom_encoder_init(CELTEncoder *st, const CELTMode *mode, int channels)
202 {
203    return opus_custom_encoder_init_arch(st, mode, channels, opus_select_arch());
204 }
205 #endif
206
207 int celt_encoder_init(CELTEncoder *st, opus_int32 sampling_rate, int channels,
208                       int arch)
209 {
210    int ret;
211    ret = opus_custom_encoder_init_arch(st,
212            opus_custom_mode_create(48000, 960, NULL), channels, arch);
213    if (ret != OPUS_OK)
214       return ret;
215    st->upsample = resampling_factor(sampling_rate);
216    return OPUS_OK;
217 }
218
219 #ifdef CUSTOM_MODES
220 void opus_custom_encoder_destroy(CELTEncoder *st)
221 {
222    opus_free(st);
223 }
224 #endif /* CUSTOM_MODES */
225
226
227 static int transient_analysis(const opus_val32 * OPUS_RESTRICT in, int len, int C,
228                               opus_val16 *tf_estimate, int *tf_chan, int allow_weak_transients,
229                               int *weak_transient)
230 {
231    int i;
232    VARDECL(opus_val16, tmp);
233    opus_val32 mem0,mem1;
234    int is_transient = 0;
235    opus_int32 mask_metric = 0;
236    int c;
237    opus_val16 tf_max;
238    int len2;
239    /* Forward masking: 6.7 dB/ms. */
240 #ifdef FIXED_POINT
241    int forward_shift = 4;
242 #else
243    opus_val16 forward_decay = QCONST16(.0625f,15);
244 #endif
245    /* Table of 6*64/x, trained on real data to minimize the average error */
246    static const unsigned char inv_table[128] = {
247          255,255,156,110, 86, 70, 59, 51, 45, 40, 37, 33, 31, 28, 26, 25,
248           23, 22, 21, 20, 19, 18, 17, 16, 16, 15, 15, 14, 13, 13, 12, 12,
249           12, 12, 11, 11, 11, 10, 10, 10,  9,  9,  9,  9,  9,  9,  8,  8,
250            8,  8,  8,  7,  7,  7,  7,  7,  7,  6,  6,  6,  6,  6,  6,  6,
251            6,  6,  6,  6,  6,  6,  6,  6,  6,  5,  5,  5,  5,  5,  5,  5,
252            5,  5,  5,  5,  5,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
253            4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  3,  3,
254            3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  2,
255    };
256    SAVE_STACK;
257    ALLOC(tmp, len, opus_val16);
258
259    *weak_transient = 0;
260    /* For lower bitrates, let's be more conservative and have a forward masking
261       decay of 3.3 dB/ms. This avoids having to code transients at very low
262       bitrate (mostly for hybrid), which can result in unstable energy and/or
263       partial collapse. */
264    if (allow_weak_transients)
265    {
266 #ifdef FIXED_POINT
267       forward_shift = 5;
268 #else
269       forward_decay = QCONST16(.03125f,15);
270 #endif
271    }
272    len2=len/2;
273    for (c=0;c<C;c++)
274    {
275       opus_val32 mean;
276       opus_int32 unmask=0;
277       opus_val32 norm;
278       opus_val16 maxE;
279       mem0=0;
280       mem1=0;
281       /* High-pass filter: (1 - 2*z^-1 + z^-2) / (1 - z^-1 + .5*z^-2) */
282       for (i=0;i<len;i++)
283       {
284          opus_val32 x,y;
285          x = SHR32(in[i+c*len],SIG_SHIFT);
286          y = ADD32(mem0, x);
287 #ifdef FIXED_POINT
288          mem0 = mem1 + y - SHL32(x,1);
289          mem1 = x - SHR32(y,1);
290 #else
291          mem0 = mem1 + y - 2*x;
292          mem1 = x - .5f*y;
293 #endif
294          tmp[i] = SROUND16(y, 2);
295          /*printf("%f ", tmp[i]);*/
296       }
297       /*printf("\n");*/
298       /* First few samples are bad because we don't propagate the memory */
299       OPUS_CLEAR(tmp, 12);
300
301 #ifdef FIXED_POINT
302       /* Normalize tmp to max range */
303       {
304          int shift=0;
305          shift = 14-celt_ilog2(MAX16(1, celt_maxabs16(tmp, len)));
306          if (shift!=0)
307          {
308             for (i=0;i<len;i++)
309                tmp[i] = SHL16(tmp[i], shift);
310          }
311       }
312 #endif
313
314       mean=0;
315       mem0=0;
316       /* Grouping by two to reduce complexity */
317       /* Forward pass to compute the post-echo threshold*/
318       for (i=0;i<len2;i++)
319       {
320          opus_val16 x2 = PSHR32(MULT16_16(tmp[2*i],tmp[2*i]) + MULT16_16(tmp[2*i+1],tmp[2*i+1]),16);
321          mean += x2;
322 #ifdef FIXED_POINT
323          /* FIXME: Use PSHR16() instead */
324          tmp[i] = mem0 + PSHR32(x2-mem0,forward_shift);
325 #else
326          tmp[i] = mem0 + MULT16_16_P15(forward_decay,x2-mem0);
327 #endif
328          mem0 = tmp[i];
329       }
330
331       mem0=0;
332       maxE=0;
333       /* Backward pass to compute the pre-echo threshold */
334       for (i=len2-1;i>=0;i--)
335       {
336          /* Backward masking: 13.9 dB/ms. */
337 #ifdef FIXED_POINT
338          /* FIXME: Use PSHR16() instead */
339          tmp[i] = mem0 + PSHR32(tmp[i]-mem0,3);
340 #else
341          tmp[i] = mem0 + MULT16_16_P15(QCONST16(0.125f,15),tmp[i]-mem0);
342 #endif
343          mem0 = tmp[i];
344          maxE = MAX16(maxE, mem0);
345       }
346       /*for (i=0;i<len2;i++)printf("%f ", tmp[i]/mean);printf("\n");*/
347
348       /* Compute the ratio of the "frame energy" over the harmonic mean of the energy.
349          This essentially corresponds to a bitrate-normalized temporal noise-to-mask
350          ratio */
351
352       /* As a compromise with the old transient detector, frame energy is the
353          geometric mean of the energy and half the max */
354 #ifdef FIXED_POINT
355       /* Costs two sqrt() to avoid overflows */
356       mean = MULT16_16(celt_sqrt(mean), celt_sqrt(MULT16_16(maxE,len2>>1)));
357 #else
358       mean = celt_sqrt(mean * maxE*.5*len2);
359 #endif
360       /* Inverse of the mean energy in Q15+6 */
361       norm = SHL32(EXTEND32(len2),6+14)/ADD32(EPSILON,SHR32(mean,1));
362       /* Compute harmonic mean discarding the unreliable boundaries
363          The data is smooth, so we only take 1/4th of the samples */
364       unmask=0;
365       /* We should never see NaNs here. If we find any, then something really bad happened and we better abort
366          before it does any damage later on. If these asserts are disabled (no hardening), then the table
367          lookup a few lines below (id = ...) is likely to crash dur to an out-of-bounds read. DO NOT FIX
368          that crash on NaN since it could result in a worse issue later on. */
369       celt_assert(!celt_isnan(tmp[0]));
370       celt_assert(!celt_isnan(norm));
371       for (i=12;i<len2-5;i+=4)
372       {
373          int id;
374 #ifdef FIXED_POINT
375          id = MAX32(0,MIN32(127,MULT16_32_Q15(tmp[i]+EPSILON,norm))); /* Do not round to nearest */
376 #else
377          id = (int)MAX32(0,MIN32(127,floor(64*norm*(tmp[i]+EPSILON)))); /* Do not round to nearest */
378 #endif
379          unmask += inv_table[id];
380       }
381       /*printf("%d\n", unmask);*/
382       /* Normalize, compensate for the 1/4th of the sample and the factor of 6 in the inverse table */
383       unmask = 64*unmask*4/(6*(len2-17));
384       if (unmask>mask_metric)
385       {
386          *tf_chan = c;
387          mask_metric = unmask;
388       }
389    }
390    is_transient = mask_metric>200;
391    /* For low bitrates, define "weak transients" that need to be
392       handled differently to avoid partial collapse. */
393    if (allow_weak_transients && is_transient && mask_metric<600) {
394       is_transient = 0;
395       *weak_transient = 1;
396    }
397    /* Arbitrary metric for VBR boost */
398    tf_max = MAX16(0,celt_sqrt(27*mask_metric)-42);
399    /* *tf_estimate = 1 + MIN16(1, sqrt(MAX16(0, tf_max-30))/20); */
400    *tf_estimate = celt_sqrt(MAX32(0, SHL32(MULT16_16(QCONST16(0.0069,14),MIN16(163,tf_max)),14)-QCONST32(0.139,28)));
401    /*printf("%d %f\n", tf_max, mask_metric);*/
402    RESTORE_STACK;
403 #ifdef FUZZING
404    is_transient = rand()&0x1;
405 #endif
406    /*printf("%d %f %d\n", is_transient, (float)*tf_estimate, tf_max);*/
407    return is_transient;
408 }
409
410 /* Looks for sudden increases of energy to decide whether we need to patch
411    the transient decision */
412 static int patch_transient_decision(opus_val16 *newE, opus_val16 *oldE, int nbEBands,
413       int start, int end, int C)
414 {
415    int i, c;
416    opus_val32 mean_diff=0;
417    opus_val16 spread_old[26];
418    /* Apply an aggressive (-6 dB/Bark) spreading function to the old frame to
419       avoid false detection caused by irrelevant bands */
420    if (C==1)
421    {
422       spread_old[start] = oldE[start];
423       for (i=start+1;i<end;i++)
424          spread_old[i] = MAX16(spread_old[i-1]-QCONST16(1.0f, DB_SHIFT), oldE[i]);
425    } else {
426       spread_old[start] = MAX16(oldE[start],oldE[start+nbEBands]);
427       for (i=start+1;i<end;i++)
428          spread_old[i] = MAX16(spread_old[i-1]-QCONST16(1.0f, DB_SHIFT),
429                                MAX16(oldE[i],oldE[i+nbEBands]));
430    }
431    for (i=end-2;i>=start;i--)
432       spread_old[i] = MAX16(spread_old[i], spread_old[i+1]-QCONST16(1.0f, DB_SHIFT));
433    /* Compute mean increase */
434    c=0; do {
435       for (i=IMAX(2,start);i<end-1;i++)
436       {
437          opus_val16 x1, x2;
438          x1 = MAX16(0, newE[i + c*nbEBands]);
439          x2 = MAX16(0, spread_old[i]);
440          mean_diff = ADD32(mean_diff, EXTEND32(MAX16(0, SUB16(x1, x2))));
441       }
442    } while (++c<C);
443    mean_diff = DIV32(mean_diff, C*(end-1-IMAX(2,start)));
444    /*printf("%f %f %d\n", mean_diff, max_diff, count);*/
445    return mean_diff > QCONST16(1.f, DB_SHIFT);
446 }
447
448 /** Apply window and compute the MDCT for all sub-frames and
449     all channels in a frame */
450 static void compute_mdcts(const CELTMode *mode, int shortBlocks, celt_sig * OPUS_RESTRICT in,
451                           celt_sig * OPUS_RESTRICT out, int C, int CC, int LM, int upsample,
452                           int arch)
453 {
454    const int overlap = mode->overlap;
455    int N;
456    int B;
457    int shift;
458    int i, b, c;
459    if (shortBlocks)
460    {
461       B = shortBlocks;
462       N = mode->shortMdctSize;
463       shift = mode->maxLM;
464    } else {
465       B = 1;
466       N = mode->shortMdctSize<<LM;
467       shift = mode->maxLM-LM;
468    }
469    c=0; do {
470       for (b=0;b<B;b++)
471       {
472          /* Interleaving the sub-frames while doing the MDCTs */
473          clt_mdct_forward(&mode->mdct, in+c*(B*N+overlap)+b*N,
474                           &out[b+c*N*B], mode->window, overlap, shift, B,
475                           arch);
476       }
477    } while (++c<CC);
478    if (CC==2&&C==1)
479    {
480       for (i=0;i<B*N;i++)
481          out[i] = ADD32(HALF32(out[i]), HALF32(out[B*N+i]));
482    }
483    if (upsample != 1)
484    {
485       c=0; do
486       {
487          int bound = B*N/upsample;
488          for (i=0;i<bound;i++)
489             out[c*B*N+i] *= upsample;
490          OPUS_CLEAR(&out[c*B*N+bound], B*N-bound);
491       } while (++c<C);
492    }
493 }
494
495
496 void celt_preemphasis(const opus_val16 * OPUS_RESTRICT pcmp, celt_sig * OPUS_RESTRICT inp,
497                         int N, int CC, int upsample, const opus_val16 *coef, celt_sig *mem, int clip)
498 {
499    int i;
500    opus_val16 coef0;
501    celt_sig m;
502    int Nu;
503
504    coef0 = coef[0];
505    m = *mem;
506
507    /* Fast path for the normal 48kHz case and no clipping */
508    if (coef[1] == 0 && upsample == 1 && !clip)
509    {
510       for (i=0;i<N;i++)
511       {
512          opus_val16 x;
513          x = SCALEIN(pcmp[CC*i]);
514          /* Apply pre-emphasis */
515          inp[i] = SHL32(x, SIG_SHIFT) - m;
516          m = SHR32(MULT16_16(coef0, x), 15-SIG_SHIFT);
517       }
518       *mem = m;
519       return;
520    }
521
522    Nu = N/upsample;
523    if (upsample!=1)
524    {
525       OPUS_CLEAR(inp, N);
526    }
527    for (i=0;i<Nu;i++)
528       inp[i*upsample] = SCALEIN(pcmp[CC*i]);
529
530 #ifndef FIXED_POINT
531    if (clip)
532    {
533       /* Clip input to avoid encoding non-portable files */
534       for (i=0;i<Nu;i++)
535          inp[i*upsample] = MAX32(-65536.f, MIN32(65536.f,inp[i*upsample]));
536    }
537 #else
538    (void)clip; /* Avoids a warning about clip being unused. */
539 #endif
540 #ifdef CUSTOM_MODES
541    if (coef[1] != 0)
542    {
543       opus_val16 coef1 = coef[1];
544       opus_val16 coef2 = coef[2];
545       for (i=0;i<N;i++)
546       {
547          celt_sig x, tmp;
548          x = inp[i];
549          /* Apply pre-emphasis */
550          tmp = MULT16_16(coef2, x);
551          inp[i] = tmp + m;
552          m = MULT16_32_Q15(coef1, inp[i]) - MULT16_32_Q15(coef0, tmp);
553       }
554    } else
555 #endif
556    {
557       for (i=0;i<N;i++)
558       {
559          opus_val16 x;
560          x = inp[i];
561          /* Apply pre-emphasis */
562          inp[i] = SHL32(x, SIG_SHIFT) - m;
563          m = SHR32(MULT16_16(coef0, x), 15-SIG_SHIFT);
564       }
565    }
566    *mem = m;
567 }
568
569
570
571 static opus_val32 l1_metric(const celt_norm *tmp, int N, int LM, opus_val16 bias)
572 {
573    int i;
574    opus_val32 L1;
575    L1 = 0;
576    for (i=0;i<N;i++)
577       L1 += EXTEND32(ABS16(tmp[i]));
578    /* When in doubt, prefer good freq resolution */
579    L1 = MAC16_32_Q15(L1, LM*bias, L1);
580    return L1;
581
582 }
583
584 static int tf_analysis(const CELTMode *m, int len, int isTransient,
585       int *tf_res, int lambda, celt_norm *X, int N0, int LM,
586       opus_val16 tf_estimate, int tf_chan, int *importance)
587 {
588    int i;
589    VARDECL(int, metric);
590    int cost0;
591    int cost1;
592    VARDECL(int, path0);
593    VARDECL(int, path1);
594    VARDECL(celt_norm, tmp);
595    VARDECL(celt_norm, tmp_1);
596    int sel;
597    int selcost[2];
598    int tf_select=0;
599    opus_val16 bias;
600
601    SAVE_STACK;
602    bias = MULT16_16_Q14(QCONST16(.04f,15), MAX16(-QCONST16(.25f,14), QCONST16(.5f,14)-tf_estimate));
603    /*printf("%f ", bias);*/
604
605    ALLOC(metric, len, int);
606    ALLOC(tmp, (m->eBands[len]-m->eBands[len-1])<<LM, celt_norm);
607    ALLOC(tmp_1, (m->eBands[len]-m->eBands[len-1])<<LM, celt_norm);
608    ALLOC(path0, len, int);
609    ALLOC(path1, len, int);
610
611    for (i=0;i<len;i++)
612    {
613       int k, N;
614       int narrow;
615       opus_val32 L1, best_L1;
616       int best_level=0;
617       N = (m->eBands[i+1]-m->eBands[i])<<LM;
618       /* band is too narrow to be split down to LM=-1 */
619       narrow = (m->eBands[i+1]-m->eBands[i])==1;
620       OPUS_COPY(tmp, &X[tf_chan*N0 + (m->eBands[i]<<LM)], N);
621       /* Just add the right channel if we're in stereo */
622       /*if (C==2)
623          for (j=0;j<N;j++)
624             tmp[j] = ADD16(SHR16(tmp[j], 1),SHR16(X[N0+j+(m->eBands[i]<<LM)], 1));*/
625       L1 = l1_metric(tmp, N, isTransient ? LM : 0, bias);
626       best_L1 = L1;
627       /* Check the -1 case for transients */
628       if (isTransient && !narrow)
629       {
630          OPUS_COPY(tmp_1, tmp, N);
631          haar1(tmp_1, N>>LM, 1<<LM);
632          L1 = l1_metric(tmp_1, N, LM+1, bias);
633          if (L1<best_L1)
634          {
635             best_L1 = L1;
636             best_level = -1;
637          }
638       }
639       /*printf ("%f ", L1);*/
640       for (k=0;k<LM+!(isTransient||narrow);k++)
641       {
642          int B;
643
644          if (isTransient)
645             B = (LM-k-1);
646          else
647             B = k+1;
648
649          haar1(tmp, N>>k, 1<<k);
650
651          L1 = l1_metric(tmp, N, B, bias);
652
653          if (L1 < best_L1)
654          {
655             best_L1 = L1;
656             best_level = k+1;
657          }
658       }
659       /*printf ("%d ", isTransient ? LM-best_level : best_level);*/
660       /* metric is in Q1 to be able to select the mid-point (-0.5) for narrower bands */
661       if (isTransient)
662          metric[i] = 2*best_level;
663       else
664          metric[i] = -2*best_level;
665       /* For bands that can't be split to -1, set the metric to the half-way point to avoid
666          biasing the decision */
667       if (narrow && (metric[i]==0 || metric[i]==-2*LM))
668          metric[i]-=1;
669       /*printf("%d ", metric[i]/2 + (!isTransient)*LM);*/
670    }
671    /*printf("\n");*/
672    /* Search for the optimal tf resolution, including tf_select */
673    tf_select = 0;
674    for (sel=0;sel<2;sel++)
675    {
676       cost0 = importance[0]*abs(metric[0]-2*tf_select_table[LM][4*isTransient+2*sel+0]);
677       cost1 = importance[0]*abs(metric[0]-2*tf_select_table[LM][4*isTransient+2*sel+1]) + (isTransient ? 0 : lambda);
678       for (i=1;i<len;i++)
679       {
680          int curr0, curr1;
681          curr0 = IMIN(cost0, cost1 + lambda);
682          curr1 = IMIN(cost0 + lambda, cost1);
683          cost0 = curr0 + importance[i]*abs(metric[i]-2*tf_select_table[LM][4*isTransient+2*sel+0]);
684          cost1 = curr1 + importance[i]*abs(metric[i]-2*tf_select_table[LM][4*isTransient+2*sel+1]);
685       }
686       cost0 = IMIN(cost0, cost1);
687       selcost[sel]=cost0;
688    }
689    /* For now, we're conservative and only allow tf_select=1 for transients.
690     * If tests confirm it's useful for non-transients, we could allow it. */
691    if (selcost[1]<selcost[0] && isTransient)
692       tf_select=1;
693    cost0 = importance[0]*abs(metric[0]-2*tf_select_table[LM][4*isTransient+2*tf_select+0]);
694    cost1 = importance[0]*abs(metric[0]-2*tf_select_table[LM][4*isTransient+2*tf_select+1]) + (isTransient ? 0 : lambda);
695    /* Viterbi forward pass */
696    for (i=1;i<len;i++)
697    {
698       int curr0, curr1;
699       int from0, from1;
700
701       from0 = cost0;
702       from1 = cost1 + lambda;
703       if (from0 < from1)
704       {
705          curr0 = from0;
706          path0[i]= 0;
707       } else {
708          curr0 = from1;
709          path0[i]= 1;
710       }
711
712       from0 = cost0 + lambda;
713       from1 = cost1;
714       if (from0 < from1)
715       {
716          curr1 = from0;
717          path1[i]= 0;
718       } else {
719          curr1 = from1;
720          path1[i]= 1;
721       }
722       cost0 = curr0 + importance[i]*abs(metric[i]-2*tf_select_table[LM][4*isTransient+2*tf_select+0]);
723       cost1 = curr1 + importance[i]*abs(metric[i]-2*tf_select_table[LM][4*isTransient+2*tf_select+1]);
724    }
725    tf_res[len-1] = cost0 < cost1 ? 0 : 1;
726    /* Viterbi backward pass to check the decisions */
727    for (i=len-2;i>=0;i--)
728    {
729       if (tf_res[i+1] == 1)
730          tf_res[i] = path1[i+1];
731       else
732          tf_res[i] = path0[i+1];
733    }
734    /*printf("%d %f\n", *tf_sum, tf_estimate);*/
735    RESTORE_STACK;
736 #ifdef FUZZING
737    tf_select = rand()&0x1;
738    tf_res[0] = rand()&0x1;
739    for (i=1;i<len;i++)
740       tf_res[i] = tf_res[i-1] ^ ((rand()&0xF) == 0);
741 #endif
742    return tf_select;
743 }
744
745 static void tf_encode(int start, int end, int isTransient, int *tf_res, int LM, int tf_select, ec_enc *enc)
746 {
747    int curr, i;
748    int tf_select_rsv;
749    int tf_changed;
750    int logp;
751    opus_uint32 budget;
752    opus_uint32 tell;
753    budget = enc->storage*8;
754    tell = ec_tell(enc);
755    logp = isTransient ? 2 : 4;
756    /* Reserve space to code the tf_select decision. */
757    tf_select_rsv = LM>0 && tell+logp+1 <= budget;
758    budget -= tf_select_rsv;
759    curr = tf_changed = 0;
760    for (i=start;i<end;i++)
761    {
762       if (tell+logp<=budget)
763       {
764          ec_enc_bit_logp(enc, tf_res[i] ^ curr, logp);
765          tell = ec_tell(enc);
766          curr = tf_res[i];
767          tf_changed |= curr;
768       }
769       else
770          tf_res[i] = curr;
771       logp = isTransient ? 4 : 5;
772    }
773    /* Only code tf_select if it would actually make a difference. */
774    if (tf_select_rsv &&
775          tf_select_table[LM][4*isTransient+0+tf_changed]!=
776          tf_select_table[LM][4*isTransient+2+tf_changed])
777       ec_enc_bit_logp(enc, tf_select, 1);
778    else
779       tf_select = 0;
780    for (i=start;i<end;i++)
781       tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]];
782    /*for(i=0;i<end;i++)printf("%d ", isTransient ? tf_res[i] : LM+tf_res[i]);printf("\n");*/
783 }
784
785
786 static int alloc_trim_analysis(const CELTMode *m, const celt_norm *X,
787       const opus_val16 *bandLogE, int end, int LM, int C, int N0,
788       AnalysisInfo *analysis, opus_val16 *stereo_saving, opus_val16 tf_estimate,
789       int intensity, opus_val16 surround_trim, opus_int32 equiv_rate, int arch)
790 {
791    int i;
792    opus_val32 diff=0;
793    int c;
794    int trim_index;
795    opus_val16 trim = QCONST16(5.f, 8);
796    opus_val16 logXC, logXC2;
797    /* At low bitrate, reducing the trim seems to help. At higher bitrates, it's less
798       clear what's best, so we're keeping it as it was before, at least for now. */
799    if (equiv_rate < 64000) {
800       trim = QCONST16(4.f, 8);
801    } else if (equiv_rate < 80000) {
802       opus_int32 frac = (equiv_rate-64000) >> 10;
803       trim = QCONST16(4.f, 8) + QCONST16(1.f/16.f, 8)*frac;
804    }
805    if (C==2)
806    {
807       opus_val16 sum = 0; /* Q10 */
808       opus_val16 minXC; /* Q10 */
809       /* Compute inter-channel correlation for low frequencies */
810       for (i=0;i<8;i++)
811       {
812          opus_val32 partial;
813          partial = celt_inner_prod(&X[m->eBands[i]<<LM], &X[N0+(m->eBands[i]<<LM)],
814                (m->eBands[i+1]-m->eBands[i])<<LM, arch);
815          sum = ADD16(sum, EXTRACT16(SHR32(partial, 18)));
816       }
817       sum = MULT16_16_Q15(QCONST16(1.f/8, 15), sum);
818       sum = MIN16(QCONST16(1.f, 10), ABS16(sum));
819       minXC = sum;
820       for (i=8;i<intensity;i++)
821       {
822          opus_val32 partial;
823          partial = celt_inner_prod(&X[m->eBands[i]<<LM], &X[N0+(m->eBands[i]<<LM)],
824                (m->eBands[i+1]-m->eBands[i])<<LM, arch);
825          minXC = MIN16(minXC, ABS16(EXTRACT16(SHR32(partial, 18))));
826       }
827       minXC = MIN16(QCONST16(1.f, 10), ABS16(minXC));
828       /*printf ("%f\n", sum);*/
829       /* mid-side savings estimations based on the LF average*/
830       logXC = celt_log2(QCONST32(1.001f, 20)-MULT16_16(sum, sum));
831       /* mid-side savings estimations based on min correlation */
832       logXC2 = MAX16(HALF16(logXC), celt_log2(QCONST32(1.001f, 20)-MULT16_16(minXC, minXC)));
833 #ifdef FIXED_POINT
834       /* Compensate for Q20 vs Q14 input and convert output to Q8 */
835       logXC = PSHR32(logXC-QCONST16(6.f, DB_SHIFT),DB_SHIFT-8);
836       logXC2 = PSHR32(logXC2-QCONST16(6.f, DB_SHIFT),DB_SHIFT-8);
837 #endif
838
839       trim += MAX16(-QCONST16(4.f, 8), MULT16_16_Q15(QCONST16(.75f,15),logXC));
840       *stereo_saving = MIN16(*stereo_saving + QCONST16(0.25f, 8), -HALF16(logXC2));
841    }
842
843    /* Estimate spectral tilt */
844    c=0; do {
845       for (i=0;i<end-1;i++)
846       {
847          diff += bandLogE[i+c*m->nbEBands]*(opus_int32)(2+2*i-end);
848       }
849    } while (++c<C);
850    diff /= C*(end-1);
851    /*printf("%f\n", diff);*/
852    trim -= MAX32(-QCONST16(2.f, 8), MIN32(QCONST16(2.f, 8), SHR32(diff+QCONST16(1.f, DB_SHIFT),DB_SHIFT-8)/6 ));
853    trim -= SHR16(surround_trim, DB_SHIFT-8);
854    trim -= 2*SHR16(tf_estimate, 14-8);
855 #ifndef DISABLE_FLOAT_API
856    if (analysis->valid)
857    {
858       trim -= MAX16(-QCONST16(2.f, 8), MIN16(QCONST16(2.f, 8),
859             (opus_val16)(QCONST16(2.f, 8)*(analysis->tonality_slope+.05f))));
860    }
861 #else
862    (void)analysis;
863 #endif
864
865 #ifdef FIXED_POINT
866    trim_index = PSHR32(trim, 8);
867 #else
868    trim_index = (int)floor(.5f+trim);
869 #endif
870    trim_index = IMAX(0, IMIN(10, trim_index));
871    /*printf("%d\n", trim_index);*/
872 #ifdef FUZZING
873    trim_index = rand()%11;
874 #endif
875    return trim_index;
876 }
877
878 static int stereo_analysis(const CELTMode *m, const celt_norm *X,
879       int LM, int N0)
880 {
881    int i;
882    int thetas;
883    opus_val32 sumLR = EPSILON, sumMS = EPSILON;
884
885    /* Use the L1 norm to model the entropy of the L/R signal vs the M/S signal */
886    for (i=0;i<13;i++)
887    {
888       int j;
889       for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++)
890       {
891          opus_val32 L, R, M, S;
892          /* We cast to 32-bit first because of the -32768 case */
893          L = EXTEND32(X[j]);
894          R = EXTEND32(X[N0+j]);
895          M = ADD32(L, R);
896          S = SUB32(L, R);
897          sumLR = ADD32(sumLR, ADD32(ABS32(L), ABS32(R)));
898          sumMS = ADD32(sumMS, ADD32(ABS32(M), ABS32(S)));
899       }
900    }
901    sumMS = MULT16_32_Q15(QCONST16(0.707107f, 15), sumMS);
902    thetas = 13;
903    /* We don't need thetas for lower bands with LM<=1 */
904    if (LM<=1)
905       thetas -= 8;
906    return MULT16_32_Q15((m->eBands[13]<<(LM+1))+thetas, sumMS)
907          > MULT16_32_Q15(m->eBands[13]<<(LM+1), sumLR);
908 }
909
910 #define MSWAP(a,b) do {opus_val16 tmp = a;a=b;b=tmp;} while(0)
911 static opus_val16 median_of_5(const opus_val16 *x)
912 {
913    opus_val16 t0, t1, t2, t3, t4;
914    t2 = x[2];
915    if (x[0] > x[1])
916    {
917       t0 = x[1];
918       t1 = x[0];
919    } else {
920       t0 = x[0];
921       t1 = x[1];
922    }
923    if (x[3] > x[4])
924    {
925       t3 = x[4];
926       t4 = x[3];
927    } else {
928       t3 = x[3];
929       t4 = x[4];
930    }
931    if (t0 > t3)
932    {
933       MSWAP(t0, t3);
934       MSWAP(t1, t4);
935    }
936    if (t2 > t1)
937    {
938       if (t1 < t3)
939          return MIN16(t2, t3);
940       else
941          return MIN16(t4, t1);
942    } else {
943       if (t2 < t3)
944          return MIN16(t1, t3);
945       else
946          return MIN16(t2, t4);
947    }
948 }
949
950 static opus_val16 median_of_3(const opus_val16 *x)
951 {
952    opus_val16 t0, t1, t2;
953    if (x[0] > x[1])
954    {
955       t0 = x[1];
956       t1 = x[0];
957    } else {
958       t0 = x[0];
959       t1 = x[1];
960    }
961    t2 = x[2];
962    if (t1 < t2)
963       return t1;
964    else if (t0 < t2)
965       return t2;
966    else
967       return t0;
968 }
969
970 static opus_val16 dynalloc_analysis(const opus_val16 *bandLogE, const opus_val16 *bandLogE2,
971       int nbEBands, int start, int end, int C, int *offsets, int lsb_depth, const opus_int16 *logN,
972       int isTransient, int vbr, int constrained_vbr, const opus_int16 *eBands, int LM,
973       int effectiveBytes, opus_int32 *tot_boost_, int lfe, opus_val16 *surround_dynalloc,
974       AnalysisInfo *analysis, int *importance, int *spread_weight)
975 {
976    int i, c;
977    opus_int32 tot_boost=0;
978    opus_val16 maxDepth;
979    VARDECL(opus_val16, follower);
980    VARDECL(opus_val16, noise_floor);
981    SAVE_STACK;
982    ALLOC(follower, C*nbEBands, opus_val16);
983    ALLOC(noise_floor, C*nbEBands, opus_val16);
984    OPUS_CLEAR(offsets, nbEBands);
985    /* Dynamic allocation code */
986    maxDepth=-QCONST16(31.9f, DB_SHIFT);
987    for (i=0;i<end;i++)
988    {
989       /* Noise floor must take into account eMeans, the depth, the width of the bands
990          and the preemphasis filter (approx. square of bark band ID) */
991       noise_floor[i] = MULT16_16(QCONST16(0.0625f, DB_SHIFT),logN[i])
992             +QCONST16(.5f,DB_SHIFT)+SHL16(9-lsb_depth,DB_SHIFT)-SHL16(eMeans[i],6)
993             +MULT16_16(QCONST16(.0062,DB_SHIFT),(i+5)*(i+5));
994    }
995    c=0;do
996    {
997       for (i=0;i<end;i++)
998          maxDepth = MAX16(maxDepth, bandLogE[c*nbEBands+i]-noise_floor[i]);
999    } while (++c<C);
1000    {
1001       /* Compute a really simple masking model to avoid taking into account completely masked
1002          bands when computing the spreading decision. */
1003       VARDECL(opus_val16, mask);
1004       VARDECL(opus_val16, sig);
1005       ALLOC(mask, nbEBands, opus_val16);
1006       ALLOC(sig, nbEBands, opus_val16);
1007       for (i=0;i<end;i++)
1008          mask[i] = bandLogE[i]-noise_floor[i];
1009       if (C==2)
1010       {
1011          for (i=0;i<end;i++)
1012             mask[i] = MAX16(mask[i], bandLogE[nbEBands+i]-noise_floor[i]);
1013       }
1014       OPUS_COPY(sig, mask, end);
1015       for (i=1;i<end;i++)
1016          mask[i] = MAX16(mask[i], mask[i-1] - QCONST16(2.f, DB_SHIFT));
1017       for (i=end-2;i>=0;i--)
1018          mask[i] = MAX16(mask[i], mask[i+1] - QCONST16(3.f, DB_SHIFT));
1019       for (i=0;i<end;i++)
1020       {
1021          /* Compute SMR: Mask is never more than 72 dB below the peak and never below the noise floor.*/
1022          opus_val16 smr = sig[i]-MAX16(MAX16(0, maxDepth-QCONST16(12.f, DB_SHIFT)), mask[i]);
1023          /* Clamp SMR to make sure we're not shifting by something negative or too large. */
1024          smr = MAX16(-QCONST16(5.f, DB_SHIFT), MIN16(0, smr));
1025 #ifdef FIXED_POINT
1026          /* FIXME: Use PSHR16() instead */
1027          spread_weight[i] = IMAX(1, 32 >> -PSHR32(smr, DB_SHIFT));
1028 #else
1029          spread_weight[i] = IMAX(1, 32 >> -(int)floor(.5f + smr));
1030 #endif
1031       }
1032       /*for (i=0;i<end;i++)
1033          printf("%d ", spread_weight[i]);
1034       printf("\n");*/
1035    }
1036    /* Make sure that dynamic allocation can't make us bust the budget */
1037    if (effectiveBytes > 50 && LM>=1 && !lfe)
1038    {
1039       int last=0;
1040       c=0;do
1041       {
1042          opus_val16 offset;
1043          opus_val16 tmp;
1044          opus_val16 *f;
1045          f = &follower[c*nbEBands];
1046          f[0] = bandLogE2[c*nbEBands];
1047          for (i=1;i<end;i++)
1048          {
1049             /* The last band to be at least 3 dB higher than the previous one
1050                is the last we'll consider. Otherwise, we run into problems on
1051                bandlimited signals. */
1052             if (bandLogE2[c*nbEBands+i] > bandLogE2[c*nbEBands+i-1]+QCONST16(.5f,DB_SHIFT))
1053                last=i;
1054             f[i] = MIN16(f[i-1]+QCONST16(1.5f,DB_SHIFT), bandLogE2[c*nbEBands+i]);
1055          }
1056          for (i=last-1;i>=0;i--)
1057             f[i] = MIN16(f[i], MIN16(f[i+1]+QCONST16(2.f,DB_SHIFT), bandLogE2[c*nbEBands+i]));
1058
1059          /* Combine with a median filter to avoid dynalloc triggering unnecessarily.
1060             The "offset" value controls how conservative we are -- a higher offset
1061             reduces the impact of the median filter and makes dynalloc use more bits. */
1062          offset = QCONST16(1.f, DB_SHIFT);
1063          for (i=2;i<end-2;i++)
1064             f[i] = MAX16(f[i], median_of_5(&bandLogE2[c*nbEBands+i-2])-offset);
1065          tmp = median_of_3(&bandLogE2[c*nbEBands])-offset;
1066          f[0] = MAX16(f[0], tmp);
1067          f[1] = MAX16(f[1], tmp);
1068          tmp = median_of_3(&bandLogE2[c*nbEBands+end-3])-offset;
1069          f[end-2] = MAX16(f[end-2], tmp);
1070          f[end-1] = MAX16(f[end-1], tmp);
1071
1072          for (i=0;i<end;i++)
1073             f[i] = MAX16(f[i], noise_floor[i]);
1074       } while (++c<C);
1075       if (C==2)
1076       {
1077          for (i=start;i<end;i++)
1078          {
1079             /* Consider 24 dB "cross-talk" */
1080             follower[nbEBands+i] = MAX16(follower[nbEBands+i], follower[         i]-QCONST16(4.f,DB_SHIFT));
1081             follower[         i] = MAX16(follower[         i], follower[nbEBands+i]-QCONST16(4.f,DB_SHIFT));
1082             follower[i] = HALF16(MAX16(0, bandLogE[i]-follower[i]) + MAX16(0, bandLogE[nbEBands+i]-follower[nbEBands+i]));
1083          }
1084       } else {
1085          for (i=start;i<end;i++)
1086          {
1087             follower[i] = MAX16(0, bandLogE[i]-follower[i]);
1088          }
1089       }
1090       for (i=start;i<end;i++)
1091          follower[i] = MAX16(follower[i], surround_dynalloc[i]);
1092       for (i=start;i<end;i++)
1093       {
1094 #ifdef FIXED_POINT
1095          importance[i] = PSHR32(13*celt_exp2(MIN16(follower[i], QCONST16(4.f, DB_SHIFT))), 16);
1096 #else
1097          importance[i] = (int)floor(.5f+13*celt_exp2(MIN16(follower[i], QCONST16(4.f, DB_SHIFT))));
1098 #endif
1099       }
1100       /* For non-transient CBR/CVBR frames, halve the dynalloc contribution */
1101       if ((!vbr || constrained_vbr)&&!isTransient)
1102       {
1103          for (i=start;i<end;i++)
1104             follower[i] = HALF16(follower[i]);
1105       }
1106       for (i=start;i<end;i++)
1107       {
1108          if (i<8)
1109             follower[i] *= 2;
1110          if (i>=12)
1111             follower[i] = HALF16(follower[i]);
1112       }
1113 #ifdef DISABLE_FLOAT_API
1114       (void)analysis;
1115 #else
1116       if (analysis->valid)
1117       {
1118          for (i=start;i<IMIN(LEAK_BANDS, end);i++)
1119             follower[i] = follower[i] +  QCONST16(1.f/64.f, DB_SHIFT)*analysis->leak_boost[i];
1120       }
1121 #endif
1122       for (i=start;i<end;i++)
1123       {
1124          int width;
1125          int boost;
1126          int boost_bits;
1127
1128          follower[i] = MIN16(follower[i], QCONST16(4, DB_SHIFT));
1129
1130          width = C*(eBands[i+1]-eBands[i])<<LM;
1131          if (width<6)
1132          {
1133             boost = (int)SHR32(EXTEND32(follower[i]),DB_SHIFT);
1134             boost_bits = boost*width<<BITRES;
1135          } else if (width > 48) {
1136             boost = (int)SHR32(EXTEND32(follower[i])*8,DB_SHIFT);
1137             boost_bits = (boost*width<<BITRES)/8;
1138          } else {
1139             boost = (int)SHR32(EXTEND32(follower[i])*width/6,DB_SHIFT);
1140             boost_bits = boost*6<<BITRES;
1141          }
1142          /* For CBR and non-transient CVBR frames, limit dynalloc to 2/3 of the bits */
1143          if ((!vbr || (constrained_vbr&&!isTransient))
1144                && (tot_boost+boost_bits)>>BITRES>>3 > 2*effectiveBytes/3)
1145          {
1146             opus_int32 cap = ((2*effectiveBytes/3)<<BITRES<<3);
1147             offsets[i] = cap-tot_boost;
1148             tot_boost = cap;
1149             break;
1150          } else {
1151             offsets[i] = boost;
1152             tot_boost += boost_bits;
1153          }
1154       }
1155    } else {
1156       for (i=start;i<end;i++)
1157          importance[i] = 13;
1158    }
1159    *tot_boost_ = tot_boost;
1160    RESTORE_STACK;
1161    return maxDepth;
1162 }
1163
1164
1165 static int run_prefilter(CELTEncoder *st, celt_sig *in, celt_sig *prefilter_mem, int CC, int N,
1166       int prefilter_tapset, int *pitch, opus_val16 *gain, int *qgain, int enabled, int nbAvailableBytes, AnalysisInfo *analysis)
1167 {
1168    int c;
1169    VARDECL(celt_sig, _pre);
1170    celt_sig *pre[2];
1171    const CELTMode *mode;
1172    int pitch_index;
1173    opus_val16 gain1;
1174    opus_val16 pf_threshold;
1175    int pf_on;
1176    int qg;
1177    int overlap;
1178    SAVE_STACK;
1179
1180    mode = st->mode;
1181    overlap = mode->overlap;
1182    ALLOC(_pre, CC*(N+COMBFILTER_MAXPERIOD), celt_sig);
1183
1184    pre[0] = _pre;
1185    pre[1] = _pre + (N+COMBFILTER_MAXPERIOD);
1186
1187
1188    c=0; do {
1189       OPUS_COPY(pre[c], prefilter_mem+c*COMBFILTER_MAXPERIOD, COMBFILTER_MAXPERIOD);
1190       OPUS_COPY(pre[c]+COMBFILTER_MAXPERIOD, in+c*(N+overlap)+overlap, N);
1191    } while (++c<CC);
1192
1193    if (enabled)
1194    {
1195       VARDECL(opus_val16, pitch_buf);
1196       ALLOC(pitch_buf, (COMBFILTER_MAXPERIOD+N)>>1, opus_val16);
1197
1198       pitch_downsample(pre, pitch_buf, COMBFILTER_MAXPERIOD+N, CC, st->arch);
1199       /* Don't search for the fir last 1.5 octave of the range because
1200          there's too many false-positives due to short-term correlation */
1201       pitch_search(pitch_buf+(COMBFILTER_MAXPERIOD>>1), pitch_buf, N,
1202             COMBFILTER_MAXPERIOD-3*COMBFILTER_MINPERIOD, &pitch_index,
1203             st->arch);
1204       pitch_index = COMBFILTER_MAXPERIOD-pitch_index;
1205
1206       gain1 = remove_doubling(pitch_buf, COMBFILTER_MAXPERIOD, COMBFILTER_MINPERIOD,
1207             N, &pitch_index, st->prefilter_period, st->prefilter_gain, st->arch);
1208       if (pitch_index > COMBFILTER_MAXPERIOD-2)
1209          pitch_index = COMBFILTER_MAXPERIOD-2;
1210       gain1 = MULT16_16_Q15(QCONST16(.7f,15),gain1);
1211       /*printf("%d %d %f %f\n", pitch_change, pitch_index, gain1, st->analysis.tonality);*/
1212       if (st->loss_rate>2)
1213          gain1 = HALF32(gain1);
1214       if (st->loss_rate>4)
1215          gain1 = HALF32(gain1);
1216       if (st->loss_rate>8)
1217          gain1 = 0;
1218    } else {
1219       gain1 = 0;
1220       pitch_index = COMBFILTER_MINPERIOD;
1221    }
1222 #ifndef DISABLE_FLOAT_API
1223    if (analysis->valid)
1224       gain1 *= analysis->max_pitch_ratio;
1225 #endif
1226    /* Gain threshold for enabling the prefilter/postfilter */
1227    pf_threshold = QCONST16(.2f,15);
1228
1229    /* Adjusting the threshold based on rate and continuity */
1230    if (abs(pitch_index-st->prefilter_period)*10>pitch_index)
1231       pf_threshold += QCONST16(.2f,15);
1232    if (nbAvailableBytes<25)
1233       pf_threshold += QCONST16(.1f,15);
1234    if (nbAvailableBytes<35)
1235       pf_threshold += QCONST16(.1f,15);
1236    if (st->prefilter_gain > QCONST16(.4f,15))
1237       pf_threshold -= QCONST16(.1f,15);
1238    if (st->prefilter_gain > QCONST16(.55f,15))
1239       pf_threshold -= QCONST16(.1f,15);
1240
1241    /* Hard threshold at 0.2 */
1242    pf_threshold = MAX16(pf_threshold, QCONST16(.2f,15));
1243    if (gain1<pf_threshold)
1244    {
1245       gain1 = 0;
1246       pf_on = 0;
1247       qg = 0;
1248    } else {
1249       /*This block is not gated by a total bits check only because
1250         of the nbAvailableBytes check above.*/
1251       if (ABS16(gain1-st->prefilter_gain)<QCONST16(.1f,15))
1252          gain1=st->prefilter_gain;
1253
1254 #ifdef FIXED_POINT
1255       qg = ((gain1+1536)>>10)/3-1;
1256 #else
1257       qg = (int)floor(.5f+gain1*32/3)-1;
1258 #endif
1259       qg = IMAX(0, IMIN(7, qg));
1260       gain1 = QCONST16(0.09375f,15)*(qg+1);
1261       pf_on = 1;
1262    }
1263    /*printf("%d %f\n", pitch_index, gain1);*/
1264
1265    c=0; do {
1266       int offset = mode->shortMdctSize-overlap;
1267       st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
1268       OPUS_COPY(in+c*(N+overlap), st->in_mem+c*(overlap), overlap);
1269       if (offset)
1270          comb_filter(in+c*(N+overlap)+overlap, pre[c]+COMBFILTER_MAXPERIOD,
1271                st->prefilter_period, st->prefilter_period, offset, -st->prefilter_gain, -st->prefilter_gain,
1272                st->prefilter_tapset, st->prefilter_tapset, NULL, 0, st->arch);
1273
1274       comb_filter(in+c*(N+overlap)+overlap+offset, pre[c]+COMBFILTER_MAXPERIOD+offset,
1275             st->prefilter_period, pitch_index, N-offset, -st->prefilter_gain, -gain1,
1276             st->prefilter_tapset, prefilter_tapset, mode->window, overlap, st->arch);
1277       OPUS_COPY(st->in_mem+c*(overlap), in+c*(N+overlap)+N, overlap);
1278
1279       if (N>COMBFILTER_MAXPERIOD)
1280       {
1281          OPUS_COPY(prefilter_mem+c*COMBFILTER_MAXPERIOD, pre[c]+N, COMBFILTER_MAXPERIOD);
1282       } else {
1283          OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, prefilter_mem+c*COMBFILTER_MAXPERIOD+N, COMBFILTER_MAXPERIOD-N);
1284          OPUS_COPY(prefilter_mem+c*COMBFILTER_MAXPERIOD+COMBFILTER_MAXPERIOD-N, pre[c]+COMBFILTER_MAXPERIOD, N);
1285       }
1286    } while (++c<CC);
1287
1288    RESTORE_STACK;
1289    *gain = gain1;
1290    *pitch = pitch_index;
1291    *qgain = qg;
1292    return pf_on;
1293 }
1294
1295 static int compute_vbr(const CELTMode *mode, AnalysisInfo *analysis, opus_int32 base_target,
1296       int LM, opus_int32 bitrate, int lastCodedBands, int C, int intensity,
1297       int constrained_vbr, opus_val16 stereo_saving, int tot_boost,
1298       opus_val16 tf_estimate, int pitch_change, opus_val16 maxDepth,
1299       int lfe, int has_surround_mask, opus_val16 surround_masking,
1300       opus_val16 temporal_vbr)
1301 {
1302    /* The target rate in 8th bits per frame */
1303    opus_int32 target;
1304    int coded_bins;
1305    int coded_bands;
1306    opus_val16 tf_calibration;
1307    int nbEBands;
1308    const opus_int16 *eBands;
1309
1310    nbEBands = mode->nbEBands;
1311    eBands = mode->eBands;
1312
1313    coded_bands = lastCodedBands ? lastCodedBands : nbEBands;
1314    coded_bins = eBands[coded_bands]<<LM;
1315    if (C==2)
1316       coded_bins += eBands[IMIN(intensity, coded_bands)]<<LM;
1317
1318    target = base_target;
1319
1320    /*printf("%f %f %f %f %d %d ", st->analysis.activity, st->analysis.tonality, tf_estimate, st->stereo_saving, tot_boost, coded_bands);*/
1321 #ifndef DISABLE_FLOAT_API
1322    if (analysis->valid && analysis->activity<.4)
1323       target -= (opus_int32)((coded_bins<<BITRES)*(.4f-analysis->activity));
1324 #endif
1325    /* Stereo savings */
1326    if (C==2)
1327    {
1328       int coded_stereo_bands;
1329       int coded_stereo_dof;
1330       opus_val16 max_frac;
1331       coded_stereo_bands = IMIN(intensity, coded_bands);
1332       coded_stereo_dof = (eBands[coded_stereo_bands]<<LM)-coded_stereo_bands;
1333       /* Maximum fraction of the bits we can save if the signal is mono. */
1334       max_frac = DIV32_16(MULT16_16(QCONST16(0.8f, 15), coded_stereo_dof), coded_bins);
1335       stereo_saving = MIN16(stereo_saving, QCONST16(1.f, 8));
1336       /*printf("%d %d %d ", coded_stereo_dof, coded_bins, tot_boost);*/
1337       target -= (opus_int32)MIN32(MULT16_32_Q15(max_frac,target),
1338                       SHR32(MULT16_16(stereo_saving-QCONST16(0.1f,8),(coded_stereo_dof<<BITRES)),8));
1339    }
1340    /* Boost the rate according to dynalloc (minus the dynalloc average for calibration). */
1341    target += tot_boost-(19<<LM);
1342    /* Apply transient boost, compensating for average boost. */
1343    tf_calibration = QCONST16(0.044f,14);
1344    target += (opus_int32)SHL32(MULT16_32_Q15(tf_estimate-tf_calibration, target),1);
1345
1346 #ifndef DISABLE_FLOAT_API
1347    /* Apply tonality boost */
1348    if (analysis->valid && !lfe)
1349    {
1350       opus_int32 tonal_target;
1351       float tonal;
1352
1353       /* Tonality boost (compensating for the average). */
1354       tonal = MAX16(0.f,analysis->tonality-.15f)-0.12f;
1355       tonal_target = target + (opus_int32)((coded_bins<<BITRES)*1.2f*tonal);
1356       if (pitch_change)
1357          tonal_target +=  (opus_int32)((coded_bins<<BITRES)*.8f);
1358       /*printf("%f %f ", analysis->tonality, tonal);*/
1359       target = tonal_target;
1360    }
1361 #else
1362    (void)analysis;
1363    (void)pitch_change;
1364 #endif
1365
1366    if (has_surround_mask&&!lfe)
1367    {
1368       opus_int32 surround_target = target + (opus_int32)SHR32(MULT16_16(surround_masking,coded_bins<<BITRES), DB_SHIFT);
1369       /*printf("%f %d %d %d %d %d %d ", surround_masking, coded_bins, st->end, st->intensity, surround_target, target, st->bitrate);*/
1370       target = IMAX(target/4, surround_target);
1371    }
1372
1373    {
1374       opus_int32 floor_depth;
1375       int bins;
1376       bins = eBands[nbEBands-2]<<LM;
1377       /*floor_depth = SHR32(MULT16_16((C*bins<<BITRES),celt_log2(SHL32(MAX16(1,sample_max),13))), DB_SHIFT);*/
1378       floor_depth = (opus_int32)SHR32(MULT16_16((C*bins<<BITRES),maxDepth), DB_SHIFT);
1379       floor_depth = IMAX(floor_depth, target>>2);
1380       target = IMIN(target, floor_depth);
1381       /*printf("%f %d\n", maxDepth, floor_depth);*/
1382    }
1383
1384    /* Make VBR less aggressive for constrained VBR because we can't keep a higher bitrate
1385       for long. Needs tuning. */
1386    if ((!has_surround_mask||lfe) && constrained_vbr)
1387    {
1388       target = base_target + (opus_int32)MULT16_32_Q15(QCONST16(0.67f, 15), target-base_target);
1389    }
1390
1391    if (!has_surround_mask && tf_estimate < QCONST16(.2f, 14))
1392    {
1393       opus_val16 amount;
1394       opus_val16 tvbr_factor;
1395       amount = MULT16_16_Q15(QCONST16(.0000031f, 30), IMAX(0, IMIN(32000, 96000-bitrate)));
1396       tvbr_factor = SHR32(MULT16_16(temporal_vbr, amount), DB_SHIFT);
1397       target += (opus_int32)MULT16_32_Q15(tvbr_factor, target);
1398    }
1399
1400    /* Don't allow more than doubling the rate */
1401    target = IMIN(2*base_target, target);
1402
1403    return target;
1404 }
1405
1406 int celt_encode_with_ec(CELTEncoder * OPUS_RESTRICT st, const opus_val16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
1407 {
1408    int i, c, N;
1409    opus_int32 bits;
1410    ec_enc _enc;
1411    VARDECL(celt_sig, in);
1412    VARDECL(celt_sig, freq);
1413    VARDECL(celt_norm, X);
1414    VARDECL(celt_ener, bandE);
1415    VARDECL(opus_val16, bandLogE);
1416    VARDECL(opus_val16, bandLogE2);
1417    VARDECL(int, fine_quant);
1418    VARDECL(opus_val16, error);
1419    VARDECL(int, pulses);
1420    VARDECL(int, cap);
1421    VARDECL(int, offsets);
1422    VARDECL(int, importance);
1423    VARDECL(int, spread_weight);
1424    VARDECL(int, fine_priority);
1425    VARDECL(int, tf_res);
1426    VARDECL(unsigned char, collapse_masks);
1427    celt_sig *prefilter_mem;
1428    opus_val16 *oldBandE, *oldLogE, *oldLogE2, *energyError;
1429    int shortBlocks=0;
1430    int isTransient=0;
1431    const int CC = st->channels;
1432    const int C = st->stream_channels;
1433    int LM, M;
1434    int tf_select;
1435    int nbFilledBytes, nbAvailableBytes;
1436    int start;
1437    int end;
1438    int effEnd;
1439    int codedBands;
1440    int alloc_trim;
1441    int pitch_index=COMBFILTER_MINPERIOD;
1442    opus_val16 gain1 = 0;
1443    int dual_stereo=0;
1444    int effectiveBytes;
1445    int dynalloc_logp;
1446    opus_int32 vbr_rate;
1447    opus_int32 total_bits;
1448    opus_int32 total_boost;
1449    opus_int32 balance;
1450    opus_int32 tell;
1451    opus_int32 tell0_frac;
1452    int prefilter_tapset=0;
1453    int pf_on;
1454    int anti_collapse_rsv;
1455    int anti_collapse_on=0;
1456    int silence=0;
1457    int tf_chan = 0;
1458    opus_val16 tf_estimate;
1459    int pitch_change=0;
1460    opus_int32 tot_boost;
1461    opus_val32 sample_max;
1462    opus_val16 maxDepth;
1463    const OpusCustomMode *mode;
1464    int nbEBands;
1465    int overlap;
1466    const opus_int16 *eBands;
1467    int secondMdct;
1468    int signalBandwidth;
1469    int transient_got_disabled=0;
1470    opus_val16 surround_masking=0;
1471    opus_val16 temporal_vbr=0;
1472    opus_val16 surround_trim = 0;
1473    opus_int32 equiv_rate;
1474    int hybrid;
1475    int weak_transient = 0;
1476    int enable_tf_analysis;
1477    VARDECL(opus_val16, surround_dynalloc);
1478    ALLOC_STACK;
1479
1480    mode = st->mode;
1481    nbEBands = mode->nbEBands;
1482    overlap = mode->overlap;
1483    eBands = mode->eBands;
1484    start = st->start;
1485    end = st->end;
1486    hybrid = start != 0;
1487    tf_estimate = 0;
1488    if (nbCompressedBytes<2 || pcm==NULL)
1489    {
1490       RESTORE_STACK;
1491       return OPUS_BAD_ARG;
1492    }
1493
1494    frame_size *= st->upsample;
1495    for (LM=0;LM<=mode->maxLM;LM++)
1496       if (mode->shortMdctSize<<LM==frame_size)
1497          break;
1498    if (LM>mode->maxLM)
1499    {
1500       RESTORE_STACK;
1501       return OPUS_BAD_ARG;
1502    }
1503    M=1<<LM;
1504    N = M*mode->shortMdctSize;
1505
1506    prefilter_mem = st->in_mem+CC*(overlap);
1507    oldBandE = (opus_val16*)(st->in_mem+CC*(overlap+COMBFILTER_MAXPERIOD));
1508    oldLogE = oldBandE + CC*nbEBands;
1509    oldLogE2 = oldLogE + CC*nbEBands;
1510    energyError = oldLogE2 + CC*nbEBands;
1511
1512    if (enc==NULL)
1513    {
1514       tell0_frac=tell=1;
1515       nbFilledBytes=0;
1516    } else {
1517       tell0_frac=ec_tell_frac(enc);
1518       tell=ec_tell(enc);
1519       nbFilledBytes=(tell+4)>>3;
1520    }
1521
1522 #ifdef CUSTOM_MODES
1523    if (st->signalling && enc==NULL)
1524    {
1525       int tmp = (mode->effEBands-end)>>1;
1526       end = st->end = IMAX(1, mode->effEBands-tmp);
1527       compressed[0] = tmp<<5;
1528       compressed[0] |= LM<<3;
1529       compressed[0] |= (C==2)<<2;
1530       /* Convert "standard mode" to Opus header */
1531       if (mode->Fs==48000 && mode->shortMdctSize==120)
1532       {
1533          int c0 = toOpus(compressed[0]);
1534          if (c0<0)
1535          {
1536             RESTORE_STACK;
1537             return OPUS_BAD_ARG;
1538          }
1539          compressed[0] = c0;
1540       }
1541       compressed++;
1542       nbCompressedBytes--;
1543    }
1544 #else
1545    celt_assert(st->signalling==0);
1546 #endif
1547
1548    /* Can't produce more than 1275 output bytes */
1549    nbCompressedBytes = IMIN(nbCompressedBytes,1275);
1550    nbAvailableBytes = nbCompressedBytes - nbFilledBytes;
1551
1552    if (st->vbr && st->bitrate!=OPUS_BITRATE_MAX)
1553    {
1554       opus_int32 den=mode->Fs>>BITRES;
1555       vbr_rate=(st->bitrate*frame_size+(den>>1))/den;
1556 #ifdef CUSTOM_MODES
1557       if (st->signalling)
1558          vbr_rate -= 8<<BITRES;
1559 #endif
1560       effectiveBytes = vbr_rate>>(3+BITRES);
1561    } else {
1562       opus_int32 tmp;
1563       vbr_rate = 0;
1564       tmp = st->bitrate*frame_size;
1565       if (tell>1)
1566          tmp += tell;
1567       if (st->bitrate!=OPUS_BITRATE_MAX)
1568          nbCompressedBytes = IMAX(2, IMIN(nbCompressedBytes,
1569                (tmp+4*mode->Fs)/(8*mode->Fs)-!!st->signalling));
1570       effectiveBytes = nbCompressedBytes - nbFilledBytes;
1571    }
1572    equiv_rate = ((opus_int32)nbCompressedBytes*8*50 >> (3-LM)) - (40*C+20)*((400>>LM) - 50);
1573    if (st->bitrate != OPUS_BITRATE_MAX)
1574       equiv_rate = IMIN(equiv_rate, st->bitrate - (40*C+20)*((400>>LM) - 50));
1575
1576    if (enc==NULL)
1577    {
1578       ec_enc_init(&_enc, compressed, nbCompressedBytes);
1579       enc = &_enc;
1580    }
1581
1582    if (vbr_rate>0)
1583    {
1584       /* Computes the max bit-rate allowed in VBR mode to avoid violating the
1585           target rate and buffering.
1586          We must do this up front so that bust-prevention logic triggers
1587           correctly if we don't have enough bits. */
1588       if (st->constrained_vbr)
1589       {
1590          opus_int32 vbr_bound;
1591          opus_int32 max_allowed;
1592          /* We could use any multiple of vbr_rate as bound (depending on the
1593              delay).
1594             This is clamped to ensure we use at least two bytes if the encoder
1595              was entirely empty, but to allow 0 in hybrid mode. */
1596          vbr_bound = vbr_rate;
1597          max_allowed = IMIN(IMAX(tell==1?2:0,
1598                (vbr_rate+vbr_bound-st->vbr_reservoir)>>(BITRES+3)),
1599                nbAvailableBytes);
1600          if(max_allowed < nbAvailableBytes)
1601          {
1602             nbCompressedBytes = nbFilledBytes+max_allowed;
1603             nbAvailableBytes = max_allowed;
1604             ec_enc_shrink(enc, nbCompressedBytes);
1605          }
1606       }
1607    }
1608    total_bits = nbCompressedBytes*8;
1609
1610    effEnd = end;
1611    if (effEnd > mode->effEBands)
1612       effEnd = mode->effEBands;
1613
1614    ALLOC(in, CC*(N+overlap), celt_sig);
1615
1616    sample_max=MAX32(st->overlap_max, celt_maxabs16(pcm, C*(N-overlap)/st->upsample));
1617    st->overlap_max=celt_maxabs16(pcm+C*(N-overlap)/st->upsample, C*overlap/st->upsample);
1618    sample_max=MAX32(sample_max, st->overlap_max);
1619 #ifdef FIXED_POINT
1620    silence = (sample_max==0);
1621 #else
1622    silence = (sample_max <= (opus_val16)1/(1<<st->lsb_depth));
1623 #endif
1624 #ifdef FUZZING
1625    if ((rand()&0x3F)==0)
1626       silence = 1;
1627 #endif
1628    if (tell==1)
1629       ec_enc_bit_logp(enc, silence, 15);
1630    else
1631       silence=0;
1632    if (silence)
1633    {
1634       /*In VBR mode there is no need to send more than the minimum. */
1635       if (vbr_rate>0)
1636       {
1637          effectiveBytes=nbCompressedBytes=IMIN(nbCompressedBytes, nbFilledBytes+2);
1638          total_bits=nbCompressedBytes*8;
1639          nbAvailableBytes=2;
1640          ec_enc_shrink(enc, nbCompressedBytes);
1641       }
1642       /* Pretend we've filled all the remaining bits with zeros
1643             (that's what the initialiser did anyway) */
1644       tell = nbCompressedBytes*8;
1645       enc->nbits_total+=tell-ec_tell(enc);
1646    }
1647    c=0; do {
1648       int need_clip=0;
1649 #ifndef FIXED_POINT
1650       need_clip = st->clip && sample_max>65536.f;
1651 #endif
1652       celt_preemphasis(pcm+c, in+c*(N+overlap)+overlap, N, CC, st->upsample,
1653                   mode->preemph, st->preemph_memE+c, need_clip);
1654    } while (++c<CC);
1655
1656
1657
1658    /* Find pitch period and gain */
1659    {
1660       int enabled;
1661       int qg;
1662       enabled = ((st->lfe&&nbAvailableBytes>3) || nbAvailableBytes>12*C) && !hybrid && !silence && !st->disable_pf
1663             && st->complexity >= 5;
1664
1665       prefilter_tapset = st->tapset_decision;
1666       pf_on = run_prefilter(st, in, prefilter_mem, CC, N, prefilter_tapset, &pitch_index, &gain1, &qg, enabled, nbAvailableBytes, &st->analysis);
1667       if ((gain1 > QCONST16(.4f,15) || st->prefilter_gain > QCONST16(.4f,15)) && (!st->analysis.valid || st->analysis.tonality > .3)
1668             && (pitch_index > 1.26*st->prefilter_period || pitch_index < .79*st->prefilter_period))
1669          pitch_change = 1;
1670       if (pf_on==0)
1671       {
1672          if(!hybrid && tell+16<=total_bits)
1673             ec_enc_bit_logp(enc, 0, 1);
1674       } else {
1675          /*This block is not gated by a total bits check only because
1676            of the nbAvailableBytes check above.*/
1677          int octave;
1678          ec_enc_bit_logp(enc, 1, 1);
1679          pitch_index += 1;
1680          octave = EC_ILOG(pitch_index)-5;
1681          ec_enc_uint(enc, octave, 6);
1682          ec_enc_bits(enc, pitch_index-(16<<octave), 4+octave);
1683          pitch_index -= 1;
1684          ec_enc_bits(enc, qg, 3);
1685          ec_enc_icdf(enc, prefilter_tapset, tapset_icdf, 2);
1686       }
1687    }
1688
1689    isTransient = 0;
1690    shortBlocks = 0;
1691    if (st->complexity >= 1 && !st->lfe)
1692    {
1693       /* Reduces the likelihood of energy instability on fricatives at low bitrate
1694          in hybrid mode. It seems like we still want to have real transients on vowels
1695          though (small SILK quantization offset value). */
1696       int allow_weak_transients = hybrid && effectiveBytes<15 && st->silk_info.signalType != 2;
1697       isTransient = transient_analysis(in, N+overlap, CC,
1698             &tf_estimate, &tf_chan, allow_weak_transients, &weak_transient);
1699    }
1700    if (LM>0 && ec_tell(enc)+3<=total_bits)
1701    {
1702       if (isTransient)
1703          shortBlocks = M;
1704    } else {
1705       isTransient = 0;
1706       transient_got_disabled=1;
1707    }
1708
1709    ALLOC(freq, CC*N, celt_sig); /**< Interleaved signal MDCTs */
1710    ALLOC(bandE,nbEBands*CC, celt_ener);
1711    ALLOC(bandLogE,nbEBands*CC, opus_val16);
1712
1713    secondMdct = shortBlocks && st->complexity>=8;
1714    ALLOC(bandLogE2, C*nbEBands, opus_val16);
1715    if (secondMdct)
1716    {
1717       compute_mdcts(mode, 0, in, freq, C, CC, LM, st->upsample, st->arch);
1718       compute_band_energies(mode, freq, bandE, effEnd, C, LM, st->arch);
1719       amp2Log2(mode, effEnd, end, bandE, bandLogE2, C);
1720       for (i=0;i<C*nbEBands;i++)
1721          bandLogE2[i] += HALF16(SHL16(LM, DB_SHIFT));
1722    }
1723
1724    compute_mdcts(mode, shortBlocks, in, freq, C, CC, LM, st->upsample, st->arch);
1725    /* This should catch any NaN in the CELT input. Since we're not supposed to see any (they're filtered
1726       at the Opus layer), just abort. */
1727    celt_assert(!celt_isnan(freq[0]) && (C==1 || !celt_isnan(freq[C*N])));
1728    if (CC==2&&C==1)
1729       tf_chan = 0;
1730    compute_band_energies(mode, freq, bandE, effEnd, C, LM, st->arch);
1731
1732    if (st->lfe)
1733    {
1734       for (i=2;i<end;i++)
1735       {
1736          bandE[i] = IMIN(bandE[i], MULT16_32_Q15(QCONST16(1e-4f,15),bandE[0]));
1737          bandE[i] = MAX32(bandE[i], EPSILON);
1738       }
1739    }
1740    amp2Log2(mode, effEnd, end, bandE, bandLogE, C);
1741
1742    ALLOC(surround_dynalloc, C*nbEBands, opus_val16);
1743    OPUS_CLEAR(surround_dynalloc, end);
1744    /* This computes how much masking takes place between surround channels */
1745    if (!hybrid&&st->energy_mask&&!st->lfe)
1746    {
1747       int mask_end;
1748       int midband;
1749       int count_dynalloc;
1750       opus_val32 mask_avg=0;
1751       opus_val32 diff=0;
1752       int count=0;
1753       mask_end = IMAX(2,st->lastCodedBands);
1754       for (c=0;c<C;c++)
1755       {
1756          for(i=0;i<mask_end;i++)
1757          {
1758             opus_val16 mask;
1759             mask = MAX16(MIN16(st->energy_mask[nbEBands*c+i],
1760                    QCONST16(.25f, DB_SHIFT)), -QCONST16(2.0f, DB_SHIFT));
1761             if (mask > 0)
1762                mask = HALF16(mask);
1763             mask_avg += MULT16_16(mask, eBands[i+1]-eBands[i]);
1764             count += eBands[i+1]-eBands[i];
1765             diff += MULT16_16(mask, 1+2*i-mask_end);
1766          }
1767       }
1768       celt_assert(count>0);
1769       mask_avg = DIV32_16(mask_avg,count);
1770       mask_avg += QCONST16(.2f, DB_SHIFT);
1771       diff = diff*6/(C*(mask_end-1)*(mask_end+1)*mask_end);
1772       /* Again, being conservative */
1773       diff = HALF32(diff);
1774       diff = MAX32(MIN32(diff, QCONST32(.031f, DB_SHIFT)), -QCONST32(.031f, DB_SHIFT));
1775       /* Find the band that's in the middle of the coded spectrum */
1776       for (midband=0;eBands[midband+1] < eBands[mask_end]/2;midband++);
1777       count_dynalloc=0;
1778       for(i=0;i<mask_end;i++)
1779       {
1780          opus_val32 lin;
1781          opus_val16 unmask;
1782          lin = mask_avg + diff*(i-midband);
1783          if (C==2)
1784             unmask = MAX16(st->energy_mask[i], st->energy_mask[nbEBands+i]);
1785          else
1786             unmask = st->energy_mask[i];
1787          unmask = MIN16(unmask, QCONST16(.0f, DB_SHIFT));
1788          unmask -= lin;
1789          if (unmask > QCONST16(.25f, DB_SHIFT))
1790          {
1791             surround_dynalloc[i] = unmask - QCONST16(.25f, DB_SHIFT);
1792             count_dynalloc++;
1793          }
1794       }
1795       if (count_dynalloc>=3)
1796       {
1797          /* If we need dynalloc in many bands, it's probably because our
1798             initial masking rate was too low. */
1799          mask_avg += QCONST16(.25f, DB_SHIFT);
1800          if (mask_avg>0)
1801          {
1802             /* Something went really wrong in the original calculations,
1803                disabling masking. */
1804             mask_avg = 0;
1805             diff = 0;
1806             OPUS_CLEAR(surround_dynalloc, mask_end);
1807          } else {
1808             for(i=0;i<mask_end;i++)
1809                surround_dynalloc[i] = MAX16(0, surround_dynalloc[i]-QCONST16(.25f, DB_SHIFT));
1810          }
1811       }
1812       mask_avg += QCONST16(.2f, DB_SHIFT);
1813       /* Convert to 1/64th units used for the trim */
1814       surround_trim = 64*diff;
1815       /*printf("%d %d ", mask_avg, surround_trim);*/
1816       surround_masking = mask_avg;
1817    }
1818    /* Temporal VBR (but not for LFE) */
1819    if (!st->lfe)
1820    {
1821       opus_val16 follow=-QCONST16(10.0f,DB_SHIFT);
1822       opus_val32 frame_avg=0;
1823       opus_val16 offset = shortBlocks?HALF16(SHL16(LM, DB_SHIFT)):0;
1824       for(i=start;i<end;i++)
1825       {
1826          follow = MAX16(follow-QCONST16(1.f, DB_SHIFT), bandLogE[i]-offset);
1827          if (C==2)
1828             follow = MAX16(follow, bandLogE[i+nbEBands]-offset);
1829          frame_avg += follow;
1830       }
1831       frame_avg /= (end-start);
1832       temporal_vbr = SUB16(frame_avg,st->spec_avg);
1833       temporal_vbr = MIN16(QCONST16(3.f, DB_SHIFT), MAX16(-QCONST16(1.5f, DB_SHIFT), temporal_vbr));
1834       st->spec_avg += MULT16_16_Q15(QCONST16(.02f, 15), temporal_vbr);
1835    }
1836    /*for (i=0;i<21;i++)
1837       printf("%f ", bandLogE[i]);
1838    printf("\n");*/
1839
1840    if (!secondMdct)
1841    {
1842       OPUS_COPY(bandLogE2, bandLogE, C*nbEBands);
1843    }
1844
1845    /* Last chance to catch any transient we might have missed in the
1846       time-domain analysis */
1847    if (LM>0 && ec_tell(enc)+3<=total_bits && !isTransient && st->complexity>=5 && !st->lfe && !hybrid)
1848    {
1849       if (patch_transient_decision(bandLogE, oldBandE, nbEBands, start, end, C))
1850       {
1851          isTransient = 1;
1852          shortBlocks = M;
1853          compute_mdcts(mode, shortBlocks, in, freq, C, CC, LM, st->upsample, st->arch);
1854          compute_band_energies(mode, freq, bandE, effEnd, C, LM, st->arch);
1855          amp2Log2(mode, effEnd, end, bandE, bandLogE, C);
1856          /* Compensate for the scaling of short vs long mdcts */
1857          for (i=0;i<C*nbEBands;i++)
1858             bandLogE2[i] += HALF16(SHL16(LM, DB_SHIFT));
1859          tf_estimate = QCONST16(.2f,14);
1860       }
1861    }
1862
1863    if (LM>0 && ec_tell(enc)+3<=total_bits)
1864       ec_enc_bit_logp(enc, isTransient, 3);
1865
1866    ALLOC(X, C*N, celt_norm);         /**< Interleaved normalised MDCTs */
1867
1868    /* Band normalisation */
1869    normalise_bands(mode, freq, X, bandE, effEnd, C, M);
1870
1871    enable_tf_analysis = effectiveBytes>=15*C && !hybrid && st->complexity>=2 && !st->lfe;
1872
1873    ALLOC(offsets, nbEBands, int);
1874    ALLOC(importance, nbEBands, int);
1875    ALLOC(spread_weight, nbEBands, int);
1876
1877    maxDepth = dynalloc_analysis(bandLogE, bandLogE2, nbEBands, start, end, C, offsets,
1878          st->lsb_depth, mode->logN, isTransient, st->vbr, st->constrained_vbr,
1879          eBands, LM, effectiveBytes, &tot_boost, st->lfe, surround_dynalloc, &st->analysis, importance, spread_weight);
1880
1881    ALLOC(tf_res, nbEBands, int);
1882    /* Disable variable tf resolution for hybrid and at very low bitrate */
1883    if (enable_tf_analysis)
1884    {
1885       int lambda;
1886       lambda = IMAX(80, 20480/effectiveBytes + 2);
1887       tf_select = tf_analysis(mode, effEnd, isTransient, tf_res, lambda, X, N, LM, tf_estimate, tf_chan, importance);
1888       for (i=effEnd;i<end;i++)
1889          tf_res[i] = tf_res[effEnd-1];
1890    } else if (hybrid && weak_transient)
1891    {
1892       /* For weak transients, we rely on the fact that improving time resolution using
1893          TF on a long window is imperfect and will not result in an energy collapse at
1894          low bitrate. */
1895       for (i=0;i<end;i++)
1896          tf_res[i] = 1;
1897       tf_select=0;
1898    } else if (hybrid && effectiveBytes<15 && st->silk_info.signalType != 2)
1899    {
1900       /* For low bitrate hybrid, we force temporal resolution to 5 ms rather than 2.5 ms. */
1901       for (i=0;i<end;i++)
1902          tf_res[i] = 0;
1903       tf_select=isTransient;
1904    } else {
1905       for (i=0;i<end;i++)
1906          tf_res[i] = isTransient;
1907       tf_select=0;
1908    }
1909
1910    ALLOC(error, C*nbEBands, opus_val16);
1911    c=0;
1912    do {
1913       for (i=start;i<end;i++)
1914       {
1915          /* When the energy is stable, slightly bias energy quantization towards
1916             the previous error to make the gain more stable (a constant offset is
1917             better than fluctuations). */
1918          if (ABS32(SUB32(bandLogE[i+c*nbEBands], oldBandE[i+c*nbEBands])) < QCONST16(2.f, DB_SHIFT))
1919          {
1920             bandLogE[i+c*nbEBands] -= MULT16_16_Q15(energyError[i+c*nbEBands], QCONST16(0.25f, 15));
1921          }
1922       }
1923    } while (++c < C);
1924    quant_coarse_energy(mode, start, end, effEnd, bandLogE,
1925          oldBandE, total_bits, error, enc,
1926          C, LM, nbAvailableBytes, st->force_intra,
1927          &st->delayedIntra, st->complexity >= 4, st->loss_rate, st->lfe);
1928
1929    tf_encode(start, end, isTransient, tf_res, LM, tf_select, enc);
1930
1931    if (ec_tell(enc)+4<=total_bits)
1932    {
1933       if (st->lfe)
1934       {
1935          st->tapset_decision = 0;
1936          st->spread_decision = SPREAD_NORMAL;
1937       } else if (hybrid)
1938       {
1939          if (st->complexity == 0)
1940             st->spread_decision = SPREAD_NONE;
1941          else if (isTransient)
1942             st->spread_decision = SPREAD_NORMAL;
1943          else
1944             st->spread_decision = SPREAD_AGGRESSIVE;
1945       } else if (shortBlocks || st->complexity < 3 || nbAvailableBytes < 10*C)
1946       {
1947          if (st->complexity == 0)
1948             st->spread_decision = SPREAD_NONE;
1949          else
1950             st->spread_decision = SPREAD_NORMAL;
1951       } else {
1952          /* Disable new spreading+tapset estimator until we can show it works
1953             better than the old one. So far it seems like spreading_decision()
1954             works best. */
1955 #if 0
1956          if (st->analysis.valid)
1957          {
1958             static const opus_val16 spread_thresholds[3] = {-QCONST16(.6f, 15), -QCONST16(.2f, 15), -QCONST16(.07f, 15)};
1959             static const opus_val16 spread_histeresis[3] = {QCONST16(.15f, 15), QCONST16(.07f, 15), QCONST16(.02f, 15)};
1960             static const opus_val16 tapset_thresholds[2] = {QCONST16(.0f, 15), QCONST16(.15f, 15)};
1961             static const opus_val16 tapset_histeresis[2] = {QCONST16(.1f, 15), QCONST16(.05f, 15)};
1962             st->spread_decision = hysteresis_decision(-st->analysis.tonality, spread_thresholds, spread_histeresis, 3, st->spread_decision);
1963             st->tapset_decision = hysteresis_decision(st->analysis.tonality_slope, tapset_thresholds, tapset_histeresis, 2, st->tapset_decision);
1964          } else
1965 #endif
1966          {
1967             st->spread_decision = spreading_decision(mode, X,
1968                   &st->tonal_average, st->spread_decision, &st->hf_average,
1969                   &st->tapset_decision, pf_on&&!shortBlocks, effEnd, C, M, spread_weight);
1970          }
1971          /*printf("%d %d\n", st->tapset_decision, st->spread_decision);*/
1972          /*printf("%f %d %f %d\n\n", st->analysis.tonality, st->spread_decision, st->analysis.tonality_slope, st->tapset_decision);*/
1973       }
1974       ec_enc_icdf(enc, st->spread_decision, spread_icdf, 5);
1975    }
1976
1977    /* For LFE, everything interesting is in the first band */
1978    if (st->lfe)
1979       offsets[0] = IMIN(8, effectiveBytes/3);
1980    ALLOC(cap, nbEBands, int);
1981    init_caps(mode,cap,LM,C);
1982
1983    dynalloc_logp = 6;
1984    total_bits<<=BITRES;
1985    total_boost = 0;
1986    tell = ec_tell_frac(enc);
1987    for (i=start;i<end;i++)
1988    {
1989       int width, quanta;
1990       int dynalloc_loop_logp;
1991       int boost;
1992       int j;
1993       width = C*(eBands[i+1]-eBands[i])<<LM;
1994       /* quanta is 6 bits, but no more than 1 bit/sample
1995          and no less than 1/8 bit/sample */
1996       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
1997       dynalloc_loop_logp = dynalloc_logp;
1998       boost = 0;
1999       for (j = 0; tell+(dynalloc_loop_logp<<BITRES) < total_bits-total_boost
2000             && boost < cap[i]; j++)
2001       {
2002          int flag;
2003          flag = j<offsets[i];
2004          ec_enc_bit_logp(enc, flag, dynalloc_loop_logp);
2005          tell = ec_tell_frac(enc);
2006          if (!flag)
2007             break;
2008          boost += quanta;
2009          total_boost += quanta;
2010          dynalloc_loop_logp = 1;
2011       }
2012       /* Making dynalloc more likely */
2013       if (j)
2014          dynalloc_logp = IMAX(2, dynalloc_logp-1);
2015       offsets[i] = boost;
2016    }
2017
2018    if (C==2)
2019    {
2020       static const opus_val16 intensity_thresholds[21]=
2021       /* 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19  20  off*/
2022         {  1, 2, 3, 4, 5, 6, 7, 8,16,24,36,44,50,56,62,67,72,79,88,106,134};
2023       static const opus_val16 intensity_histeresis[21]=
2024         {  1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 4, 5, 6,  8, 8};
2025
2026       /* Always use MS for 2.5 ms frames until we can do a better analysis */
2027       if (LM!=0)
2028          dual_stereo = stereo_analysis(mode, X, LM, N);
2029
2030       st->intensity = hysteresis_decision((opus_val16)(equiv_rate/1000),
2031             intensity_thresholds, intensity_histeresis, 21, st->intensity);
2032       st->intensity = IMIN(end,IMAX(start, st->intensity));
2033    }
2034
2035    alloc_trim = 5;
2036    if (tell+(6<<BITRES) <= total_bits - total_boost)
2037    {
2038       if (start > 0 || st->lfe)
2039       {
2040          st->stereo_saving = 0;
2041          alloc_trim = 5;
2042       } else {
2043          alloc_trim = alloc_trim_analysis(mode, X, bandLogE,
2044             end, LM, C, N, &st->analysis, &st->stereo_saving, tf_estimate,
2045             st->intensity, surround_trim, equiv_rate, st->arch);
2046       }
2047       ec_enc_icdf(enc, alloc_trim, trim_icdf, 7);
2048       tell = ec_tell_frac(enc);
2049    }
2050
2051    /* Variable bitrate */
2052    if (vbr_rate>0)
2053    {
2054      opus_val16 alpha;
2055      opus_int32 delta;
2056      /* The target rate in 8th bits per frame */
2057      opus_int32 target, base_target;
2058      opus_int32 min_allowed;
2059      int lm_diff = mode->maxLM - LM;
2060
2061      /* Don't attempt to use more than 510 kb/s, even for frames smaller than 20 ms.
2062         The CELT allocator will just not be able to use more than that anyway. */
2063      nbCompressedBytes = IMIN(nbCompressedBytes,1275>>(3-LM));
2064      if (!hybrid)
2065      {
2066         base_target = vbr_rate - ((40*C+20)<<BITRES);
2067      } else {
2068         base_target = IMAX(0, vbr_rate - ((9*C+4)<<BITRES));
2069      }
2070
2071      if (st->constrained_vbr)
2072         base_target += (st->vbr_offset>>lm_diff);
2073
2074      if (!hybrid)
2075      {
2076         target = compute_vbr(mode, &st->analysis, base_target, LM, equiv_rate,
2077            st->lastCodedBands, C, st->intensity, st->constrained_vbr,
2078            st->stereo_saving, tot_boost, tf_estimate, pitch_change, maxDepth,
2079            st->lfe, st->energy_mask!=NULL, surround_masking,
2080            temporal_vbr);
2081      } else {
2082         target = base_target;
2083         /* Tonal frames (offset<100) need more bits than noisy (offset>100) ones. */
2084         if (st->silk_info.offset < 100) target += 12 << BITRES >> (3-LM);
2085         if (st->silk_info.offset > 100) target -= 18 << BITRES >> (3-LM);
2086         /* Boosting bitrate on transients and vowels with significant temporal
2087            spikes. */
2088         target += (opus_int32)MULT16_16_Q14(tf_estimate-QCONST16(.25f,14), (50<<BITRES));
2089         /* If we have a strong transient, let's make sure it has enough bits to code
2090            the first two bands, so that it can use folding rather than noise. */
2091         if (tf_estimate > QCONST16(.7f,14))
2092            target = IMAX(target, 50<<BITRES);
2093      }
2094      /* The current offset is removed from the target and the space used
2095         so far is added*/
2096      target=target+tell;
2097      /* In VBR mode the frame size must not be reduced so much that it would
2098          result in the encoder running out of bits.
2099         The margin of 2 bytes ensures that none of the bust-prevention logic
2100          in the decoder will have triggered so far. */
2101      min_allowed = ((tell+total_boost+(1<<(BITRES+3))-1)>>(BITRES+3)) + 2;
2102      /* Take into account the 37 bits we need to have left in the packet to
2103         signal a redundant frame in hybrid mode. Creating a shorter packet would
2104         create an entropy coder desync. */
2105      if (hybrid)
2106         min_allowed = IMAX(min_allowed, (tell0_frac+(37<<BITRES)+total_boost+(1<<(BITRES+3))-1)>>(BITRES+3));
2107
2108      nbAvailableBytes = (target+(1<<(BITRES+2)))>>(BITRES+3);
2109      nbAvailableBytes = IMAX(min_allowed,nbAvailableBytes);
2110      nbAvailableBytes = IMIN(nbCompressedBytes,nbAvailableBytes);
2111
2112      /* By how much did we "miss" the target on that frame */
2113      delta = target - vbr_rate;
2114
2115      target=nbAvailableBytes<<(BITRES+3);
2116
2117      /*If the frame is silent we don't adjust our drift, otherwise
2118        the encoder will shoot to very high rates after hitting a
2119        span of silence, but we do allow the bitres to refill.
2120        This means that we'll undershoot our target in CVBR/VBR modes
2121        on files with lots of silence. */
2122      if(silence)
2123      {
2124        nbAvailableBytes = 2;
2125        target = 2*8<<BITRES;
2126        delta = 0;
2127      }
2128
2129      if (st->vbr_count < 970)
2130      {
2131         st->vbr_count++;
2132         alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+20),16));
2133      } else
2134         alpha = QCONST16(.001f,15);
2135      /* How many bits have we used in excess of what we're allowed */
2136      if (st->constrained_vbr)
2137         st->vbr_reservoir += target - vbr_rate;
2138      /*printf ("%d\n", st->vbr_reservoir);*/
2139
2140      /* Compute the offset we need to apply in order to reach the target */
2141      if (st->constrained_vbr)
2142      {
2143         st->vbr_drift += (opus_int32)MULT16_32_Q15(alpha,(delta*(1<<lm_diff))-st->vbr_offset-st->vbr_drift);
2144         st->vbr_offset = -st->vbr_drift;
2145      }
2146      /*printf ("%d\n", st->vbr_drift);*/
2147
2148      if (st->constrained_vbr && st->vbr_reservoir < 0)
2149      {
2150         /* We're under the min value -- increase rate */
2151         int adjust = (-st->vbr_reservoir)/(8<<BITRES);
2152         /* Unless we're just coding silence */
2153         nbAvailableBytes += silence?0:adjust;
2154         st->vbr_reservoir = 0;
2155         /*printf ("+%d\n", adjust);*/
2156      }
2157      nbCompressedBytes = IMIN(nbCompressedBytes,nbAvailableBytes);
2158      /*printf("%d\n", nbCompressedBytes*50*8);*/
2159      /* This moves the raw bits to take into account the new compressed size */
2160      ec_enc_shrink(enc, nbCompressedBytes);
2161    }
2162
2163    /* Bit allocation */
2164    ALLOC(fine_quant, nbEBands, int);
2165    ALLOC(pulses, nbEBands, int);
2166    ALLOC(fine_priority, nbEBands, int);
2167
2168    /* bits =           packet size                    - where we are - safety*/
2169    bits = (((opus_int32)nbCompressedBytes*8)<<BITRES) - ec_tell_frac(enc) - 1;
2170    anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0;
2171    bits -= anti_collapse_rsv;
2172    signalBandwidth = end-1;
2173 #ifndef DISABLE_FLOAT_API
2174    if (st->analysis.valid)
2175    {
2176       int min_bandwidth;
2177       if (equiv_rate < (opus_int32)32000*C)
2178          min_bandwidth = 13;
2179       else if (equiv_rate < (opus_int32)48000*C)
2180          min_bandwidth = 16;
2181       else if (equiv_rate < (opus_int32)60000*C)
2182          min_bandwidth = 18;
2183       else  if (equiv_rate < (opus_int32)80000*C)
2184          min_bandwidth = 19;
2185       else
2186          min_bandwidth = 20;
2187       signalBandwidth = IMAX(st->analysis.bandwidth, min_bandwidth);
2188    }
2189 #endif
2190    if (st->lfe)
2191       signalBandwidth = 1;
2192    codedBands = compute_allocation(mode, start, end, offsets, cap,
2193          alloc_trim, &st->intensity, &dual_stereo, bits, &balance, pulses,
2194          fine_quant, fine_priority, C, LM, enc, 1, st->lastCodedBands, signalBandwidth);
2195    if (st->lastCodedBands)
2196       st->lastCodedBands = IMIN(st->lastCodedBands+1,IMAX(st->lastCodedBands-1,codedBands));
2197    else
2198       st->lastCodedBands = codedBands;
2199
2200    quant_fine_energy(mode, start, end, oldBandE, error, fine_quant, enc, C);
2201
2202    /* Residual quantisation */
2203    ALLOC(collapse_masks, C*nbEBands, unsigned char);
2204    quant_all_bands(1, mode, start, end, X, C==2 ? X+N : NULL, collapse_masks,
2205          bandE, pulses, shortBlocks, st->spread_decision,
2206          dual_stereo, st->intensity, tf_res, nbCompressedBytes*(8<<BITRES)-anti_collapse_rsv,
2207          balance, enc, LM, codedBands, &st->rng, st->complexity, st->arch, st->disable_inv);
2208
2209    if (anti_collapse_rsv > 0)
2210    {
2211       anti_collapse_on = st->consec_transient<2;
2212 #ifdef FUZZING
2213       anti_collapse_on = rand()&0x1;
2214 #endif
2215       ec_enc_bits(enc, anti_collapse_on, 1);
2216    }
2217    quant_energy_finalise(mode, start, end, oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_tell(enc), enc, C);
2218    OPUS_CLEAR(energyError, nbEBands*CC);
2219    c=0;
2220    do {
2221       for (i=start;i<end;i++)
2222       {
2223          energyError[i+c*nbEBands] = MAX16(-QCONST16(0.5f, 15), MIN16(QCONST16(0.5f, 15), error[i+c*nbEBands]));
2224       }
2225    } while (++c < C);
2226
2227    if (silence)
2228    {
2229       for (i=0;i<C*nbEBands;i++)
2230          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
2231    }
2232
2233 #ifdef RESYNTH
2234    /* Re-synthesis of the coded audio if required */
2235    {
2236       celt_sig *out_mem[2];
2237
2238       if (anti_collapse_on)
2239       {
2240          anti_collapse(mode, X, collapse_masks, LM, C, N,
2241                start, end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
2242       }
2243
2244       c=0; do {
2245          OPUS_MOVE(st->syn_mem[c], st->syn_mem[c]+N, 2*MAX_PERIOD-N+overlap/2);
2246       } while (++c<CC);
2247
2248       c=0; do {
2249          out_mem[c] = st->syn_mem[c]+2*MAX_PERIOD-N;
2250       } while (++c<CC);
2251
2252       celt_synthesis(mode, X, out_mem, oldBandE, start, effEnd,
2253                      C, CC, isTransient, LM, st->upsample, silence, st->arch);
2254
2255       c=0; do {
2256          st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
2257          st->prefilter_period_old=IMAX(st->prefilter_period_old, COMBFILTER_MINPERIOD);
2258          comb_filter(out_mem[c], out_mem[c], st->prefilter_period_old, st->prefilter_period, mode->shortMdctSize,
2259                st->prefilter_gain_old, st->prefilter_gain, st->prefilter_tapset_old, st->prefilter_tapset,
2260                mode->window, overlap);
2261          if (LM!=0)
2262             comb_filter(out_mem[c]+mode->shortMdctSize, out_mem[c]+mode->shortMdctSize, st->prefilter_period, pitch_index, N-mode->shortMdctSize,
2263                   st->prefilter_gain, gain1, st->prefilter_tapset, prefilter_tapset,
2264                   mode->window, overlap);
2265       } while (++c<CC);
2266
2267       /* We reuse freq[] as scratch space for the de-emphasis */
2268       deemphasis(out_mem, (opus_val16*)pcm, N, CC, st->upsample, mode->preemph, st->preemph_memD);
2269       st->prefilter_period_old = st->prefilter_period;
2270       st->prefilter_gain_old = st->prefilter_gain;
2271       st->prefilter_tapset_old = st->prefilter_tapset;
2272    }
2273 #endif
2274
2275    st->prefilter_period = pitch_index;
2276    st->prefilter_gain = gain1;
2277    st->prefilter_tapset = prefilter_tapset;
2278 #ifdef RESYNTH
2279    if (LM!=0)
2280    {
2281       st->prefilter_period_old = st->prefilter_period;
2282       st->prefilter_gain_old = st->prefilter_gain;
2283       st->prefilter_tapset_old = st->prefilter_tapset;
2284    }
2285 #endif
2286
2287    if (CC==2&&C==1) {
2288       OPUS_COPY(&oldBandE[nbEBands], oldBandE, nbEBands);
2289    }
2290
2291    if (!isTransient)
2292    {
2293       OPUS_COPY(oldLogE2, oldLogE, CC*nbEBands);
2294       OPUS_COPY(oldLogE, oldBandE, CC*nbEBands);
2295    } else {
2296       for (i=0;i<CC*nbEBands;i++)
2297          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
2298    }
2299    /* In case start or end were to change */
2300    c=0; do
2301    {
2302       for (i=0;i<start;i++)
2303       {
2304          oldBandE[c*nbEBands+i]=0;
2305          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
2306       }
2307       for (i=end;i<nbEBands;i++)
2308       {
2309          oldBandE[c*nbEBands+i]=0;
2310          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
2311       }
2312    } while (++c<CC);
2313
2314    if (isTransient || transient_got_disabled)
2315       st->consec_transient++;
2316    else
2317       st->consec_transient=0;
2318    st->rng = enc->rng;
2319
2320    /* If there's any room left (can only happen for very high rates),
2321       it's already filled with zeros */
2322    ec_enc_done(enc);
2323
2324 #ifdef CUSTOM_MODES
2325    if (st->signalling)
2326       nbCompressedBytes++;
2327 #endif
2328
2329    RESTORE_STACK;
2330    if (ec_get_error(enc))
2331       return OPUS_INTERNAL_ERROR;
2332    else
2333       return nbCompressedBytes;
2334 }
2335
2336
2337 #ifdef CUSTOM_MODES
2338
2339 #ifdef FIXED_POINT
2340 int opus_custom_encode(CELTEncoder * OPUS_RESTRICT st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2341 {
2342    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
2343 }
2344
2345 #ifndef DISABLE_FLOAT_API
2346 int opus_custom_encode_float(CELTEncoder * OPUS_RESTRICT st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2347 {
2348    int j, ret, C, N;
2349    VARDECL(opus_int16, in);
2350    ALLOC_STACK;
2351
2352    if (pcm==NULL)
2353       return OPUS_BAD_ARG;
2354
2355    C = st->channels;
2356    N = frame_size;
2357    ALLOC(in, C*N, opus_int16);
2358
2359    for (j=0;j<C*N;j++)
2360      in[j] = FLOAT2INT16(pcm[j]);
2361
2362    ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
2363 #ifdef RESYNTH
2364    for (j=0;j<C*N;j++)
2365       ((float*)pcm)[j]=in[j]*(1.f/32768.f);
2366 #endif
2367    RESTORE_STACK;
2368    return ret;
2369 }
2370 #endif /* DISABLE_FLOAT_API */
2371 #else
2372
2373 int opus_custom_encode(CELTEncoder * OPUS_RESTRICT st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2374 {
2375    int j, ret, C, N;
2376    VARDECL(celt_sig, in);
2377    ALLOC_STACK;
2378
2379    if (pcm==NULL)
2380       return OPUS_BAD_ARG;
2381
2382    C=st->channels;
2383    N=frame_size;
2384    ALLOC(in, C*N, celt_sig);
2385    for (j=0;j<C*N;j++) {
2386      in[j] = SCALEOUT(pcm[j]);
2387    }
2388
2389    ret = celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
2390 #ifdef RESYNTH
2391    for (j=0;j<C*N;j++)
2392       ((opus_int16*)pcm)[j] = FLOAT2INT16(in[j]);
2393 #endif
2394    RESTORE_STACK;
2395    return ret;
2396 }
2397
2398 int opus_custom_encode_float(CELTEncoder * OPUS_RESTRICT st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2399 {
2400    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
2401 }
2402
2403 #endif
2404
2405 #endif /* CUSTOM_MODES */
2406
2407 int opus_custom_encoder_ctl(CELTEncoder * OPUS_RESTRICT st, int request, ...)
2408 {
2409    va_list ap;
2410
2411    va_start(ap, request);
2412    switch (request)
2413    {
2414       case OPUS_SET_COMPLEXITY_REQUEST:
2415       {
2416          int value = va_arg(ap, opus_int32);
2417          if (value<0 || value>10)
2418             goto bad_arg;
2419          st->complexity = value;
2420       }
2421       break;
2422       case CELT_SET_START_BAND_REQUEST:
2423       {
2424          opus_int32 value = va_arg(ap, opus_int32);
2425          if (value<0 || value>=st->mode->nbEBands)
2426             goto bad_arg;
2427          st->start = value;
2428       }
2429       break;
2430       case CELT_SET_END_BAND_REQUEST:
2431       {
2432          opus_int32 value = va_arg(ap, opus_int32);
2433          if (value<1 || value>st->mode->nbEBands)
2434             goto bad_arg;
2435          st->end = value;
2436       }
2437       break;
2438       case CELT_SET_PREDICTION_REQUEST:
2439       {
2440          int value = va_arg(ap, opus_int32);
2441          if (value<0 || value>2)
2442             goto bad_arg;
2443          st->disable_pf = value<=1;
2444          st->force_intra = value==0;
2445       }
2446       break;
2447       case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2448       {
2449          int value = va_arg(ap, opus_int32);
2450          if (value<0 || value>100)
2451             goto bad_arg;
2452          st->loss_rate = value;
2453       }
2454       break;
2455       case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2456       {
2457          opus_int32 value = va_arg(ap, opus_int32);
2458          st->constrained_vbr = value;
2459       }
2460       break;
2461       case OPUS_SET_VBR_REQUEST:
2462       {
2463          opus_int32 value = va_arg(ap, opus_int32);
2464          st->vbr = value;
2465       }
2466       break;
2467       case OPUS_SET_BITRATE_REQUEST:
2468       {
2469          opus_int32 value = va_arg(ap, opus_int32);
2470          if (value<=500 && value!=OPUS_BITRATE_MAX)
2471             goto bad_arg;
2472          value = IMIN(value, 260000*st->channels);
2473          st->bitrate = value;
2474       }
2475       break;
2476       case CELT_SET_CHANNELS_REQUEST:
2477       {
2478          opus_int32 value = va_arg(ap, opus_int32);
2479          if (value<1 || value>2)
2480             goto bad_arg;
2481          st->stream_channels = value;
2482       }
2483       break;
2484       case OPUS_SET_LSB_DEPTH_REQUEST:
2485       {
2486           opus_int32 value = va_arg(ap, opus_int32);
2487           if (value<8 || value>24)
2488              goto bad_arg;
2489           st->lsb_depth=value;
2490       }
2491       break;
2492       case OPUS_GET_LSB_DEPTH_REQUEST:
2493       {
2494           opus_int32 *value = va_arg(ap, opus_int32*);
2495           *value=st->lsb_depth;
2496       }
2497       break;
2498       case OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST:
2499       {
2500           opus_int32 value = va_arg(ap, opus_int32);
2501           if(value<0 || value>1)
2502           {
2503              goto bad_arg;
2504           }
2505           st->disable_inv = value;
2506       }
2507       break;
2508       case OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST:
2509       {
2510           opus_int32 *value = va_arg(ap, opus_int32*);
2511           if (!value)
2512           {
2513              goto bad_arg;
2514           }
2515           *value = st->disable_inv;
2516       }
2517       break;
2518       case OPUS_RESET_STATE:
2519       {
2520          int i;
2521          opus_val16 *oldBandE, *oldLogE, *oldLogE2;
2522          oldBandE = (opus_val16*)(st->in_mem+st->channels*(st->mode->overlap+COMBFILTER_MAXPERIOD));
2523          oldLogE = oldBandE + st->channels*st->mode->nbEBands;
2524          oldLogE2 = oldLogE + st->channels*st->mode->nbEBands;
2525          OPUS_CLEAR((char*)&st->ENCODER_RESET_START,
2526                opus_custom_encoder_get_size(st->mode, st->channels)-
2527                ((char*)&st->ENCODER_RESET_START - (char*)st));
2528          for (i=0;i<st->channels*st->mode->nbEBands;i++)
2529             oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT);
2530          st->vbr_offset = 0;
2531          st->delayedIntra = 1;
2532          st->spread_decision = SPREAD_NORMAL;
2533          st->tonal_average = 256;
2534          st->hf_average = 0;
2535          st->tapset_decision = 0;
2536       }
2537       break;
2538 #ifdef CUSTOM_MODES
2539       case CELT_SET_INPUT_CLIPPING_REQUEST:
2540       {
2541          opus_int32 value = va_arg(ap, opus_int32);
2542          st->clip = value;
2543       }
2544       break;
2545 #endif
2546       case CELT_SET_SIGNALLING_REQUEST:
2547       {
2548          opus_int32 value = va_arg(ap, opus_int32);
2549          st->signalling = value;
2550       }
2551       break;
2552       case CELT_SET_ANALYSIS_REQUEST:
2553       {
2554          AnalysisInfo *info = va_arg(ap, AnalysisInfo *);
2555          if (info)
2556             OPUS_COPY(&st->analysis, info, 1);
2557       }
2558       break;
2559       case CELT_SET_SILK_INFO_REQUEST:
2560       {
2561          SILKInfo *info = va_arg(ap, SILKInfo *);
2562          if (info)
2563             OPUS_COPY(&st->silk_info, info, 1);
2564       }
2565       break;
2566       case CELT_GET_MODE_REQUEST:
2567       {
2568          const CELTMode ** value = va_arg(ap, const CELTMode**);
2569          if (value==0)
2570             goto bad_arg;
2571          *value=st->mode;
2572       }
2573       break;
2574       case OPUS_GET_FINAL_RANGE_REQUEST:
2575       {
2576          opus_uint32 * value = va_arg(ap, opus_uint32 *);
2577          if (value==0)
2578             goto bad_arg;
2579          *value=st->rng;
2580       }
2581       break;
2582       case OPUS_SET_LFE_REQUEST:
2583       {
2584           opus_int32 value = va_arg(ap, opus_int32);
2585           st->lfe = value;
2586       }
2587       break;
2588       case OPUS_SET_ENERGY_MASK_REQUEST:
2589       {
2590           opus_val16 *value = va_arg(ap, opus_val16*);
2591           st->energy_mask = value;
2592       }
2593       break;
2594       default:
2595          goto bad_request;
2596    }
2597    va_end(ap);
2598    return OPUS_OK;
2599 bad_arg:
2600    va_end(ap);
2601    return OPUS_BAD_ARG;
2602 bad_request:
2603    va_end(ap);
2604    return OPUS_UNIMPLEMENTED;
2605 }