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