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