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