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