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