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