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