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