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