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