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