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