Replaces inline copies and initialization with OPUS_*() macros.
[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(MAX16(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 j, 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          int j;
772          opus_val32 partial = 0;
773          for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++)
774             partial = MAC16_16(partial, X[j], X[N0+j]);
775          sum = ADD16(sum, EXTRACT16(SHR32(partial, 18)));
776       }
777       sum = MULT16_16_Q15(QCONST16(1.f/8, 15), sum);
778       sum = MIN16(QCONST16(1.f, 10), ABS16(sum));
779       minXC = sum;
780       for (i=8;i<intensity;i++)
781       {
782          int j;
783          opus_val32 partial = 0;
784          for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++)
785             partial = MAC16_16(partial, X[j], X[N0+j]);
786          minXC = MIN16(minXC, ABS16(EXTRACT16(SHR32(partial, 18))));
787       }
788       minXC = MIN16(QCONST16(1.f, 10), ABS16(minXC));
789       /*printf ("%f\n", sum);*/
790       if (sum > QCONST16(.995f,10))
791          trim_index-=4;
792       else if (sum > QCONST16(.92f,10))
793          trim_index-=3;
794       else if (sum > QCONST16(.85f,10))
795          trim_index-=2;
796       else if (sum > QCONST16(.8f,10))
797          trim_index-=1;
798       /* mid-side savings estimations based on the LF average*/
799       logXC = celt_log2(QCONST32(1.001f, 20)-MULT16_16(sum, sum));
800       /* mid-side savings estimations based on min correlation */
801       logXC2 = MAX16(HALF16(logXC), celt_log2(QCONST32(1.001f, 20)-MULT16_16(minXC, minXC)));
802 #ifdef FIXED_POINT
803       /* Compensate for Q20 vs Q14 input and convert output to Q8 */
804       logXC = PSHR32(logXC-QCONST16(6.f, DB_SHIFT),DB_SHIFT-8);
805       logXC2 = PSHR32(logXC2-QCONST16(6.f, DB_SHIFT),DB_SHIFT-8);
806 #endif
807
808       trim += MAX16(-QCONST16(4.f, 8), MULT16_16_Q15(QCONST16(.75f,15),logXC));
809       *stereo_saving = MIN16(*stereo_saving + QCONST16(0.25f, 8), -HALF16(logXC2));
810    }
811
812    /* Estimate spectral tilt */
813    c=0; do {
814       for (i=0;i<end-1;i++)
815       {
816          diff += bandLogE[i+c*m->nbEBands]*(opus_int32)(2+2*i-end);
817       }
818    } while (++c<C);
819    diff /= C*(end-1);
820    /*printf("%f\n", diff);*/
821    if (diff > QCONST16(2.f, DB_SHIFT))
822       trim_index--;
823    if (diff > QCONST16(8.f, DB_SHIFT))
824       trim_index--;
825    if (diff < -QCONST16(4.f, DB_SHIFT))
826       trim_index++;
827    if (diff < -QCONST16(10.f, DB_SHIFT))
828       trim_index++;
829    trim -= MAX16(-QCONST16(2.f, 8), MIN16(QCONST16(2.f, 8), SHR16(diff+QCONST16(1.f, DB_SHIFT),DB_SHIFT-8)/6 ));
830    trim -= SHR16(surround_trim, DB_SHIFT-8);
831    trim -= 2*SHR16(tf_estimate, 14-8);
832 #ifndef DISABLE_FLOAT_API
833    if (analysis->valid)
834    {
835       trim -= MAX16(-QCONST16(2.f, 8), MIN16(QCONST16(2.f, 8),
836             (opus_val16)(QCONST16(2.f, 8)*(analysis->tonality_slope+.05f))));
837    }
838 #endif
839
840 #ifdef FIXED_POINT
841    trim_index = PSHR32(trim, 8);
842 #else
843    trim_index = (int)floor(.5f+trim);
844 #endif
845    if (trim_index<0)
846       trim_index = 0;
847    if (trim_index>10)
848       trim_index = 10;
849    /*printf("%d\n", trim_index);*/
850 #ifdef FUZZING
851    trim_index = rand()%11;
852 #endif
853    return trim_index;
854 }
855
856 static int stereo_analysis(const CELTMode *m, const celt_norm *X,
857       int LM, int N0)
858 {
859    int i;
860    int thetas;
861    opus_val32 sumLR = EPSILON, sumMS = EPSILON;
862
863    /* Use the L1 norm to model the entropy of the L/R signal vs the M/S signal */
864    for (i=0;i<13;i++)
865    {
866       int j;
867       for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++)
868       {
869          opus_val32 L, R, M, S;
870          /* We cast to 32-bit first because of the -32768 case */
871          L = EXTEND32(X[j]);
872          R = EXTEND32(X[N0+j]);
873          M = ADD32(L, R);
874          S = SUB32(L, R);
875          sumLR = ADD32(sumLR, ADD32(ABS32(L), ABS32(R)));
876          sumMS = ADD32(sumMS, ADD32(ABS32(M), ABS32(S)));
877       }
878    }
879    sumMS = MULT16_32_Q15(QCONST16(0.707107f, 15), sumMS);
880    thetas = 13;
881    /* We don't need thetas for lower bands with LM<=1 */
882    if (LM<=1)
883       thetas -= 8;
884    return MULT16_32_Q15((m->eBands[13]<<(LM+1))+thetas, sumMS)
885          > MULT16_32_Q15(m->eBands[13]<<(LM+1), sumLR);
886 }
887
888 static opus_val16 dynalloc_analysis(const opus_val16 *bandLogE, const opus_val16 *bandLogE2,
889       int nbEBands, int start, int end, int C, int *offsets, int lsb_depth, const opus_int16 *logN,
890       int isTransient, int vbr, int constrained_vbr, const opus_int16 *eBands, int LM,
891       int effectiveBytes, opus_int32 *tot_boost_, int lfe, opus_val16 *surround_dynalloc)
892 {
893    int i, c;
894    opus_int32 tot_boost=0;
895    opus_val16 maxDepth;
896    VARDECL(opus_val16, follower);
897    VARDECL(opus_val16, noise_floor);
898    SAVE_STACK;
899    ALLOC(follower, C*nbEBands, opus_val16);
900    ALLOC(noise_floor, C*nbEBands, opus_val16);
901    OPUS_CLEAR(offsets, nbEBands);
902    /* Dynamic allocation code */
903    maxDepth=-QCONST16(31.9f, DB_SHIFT);
904    for (i=0;i<end;i++)
905    {
906       /* Noise floor must take into account eMeans, the depth, the width of the bands
907          and the preemphasis filter (approx. square of bark band ID) */
908       noise_floor[i] = MULT16_16(QCONST16(0.0625f, DB_SHIFT),logN[i])
909             +QCONST16(.5f,DB_SHIFT)+SHL16(9-lsb_depth,DB_SHIFT)-SHL16(eMeans[i],6)
910             +MULT16_16(QCONST16(.0062,DB_SHIFT),(i+5)*(i+5));
911    }
912    c=0;do
913    {
914       for (i=0;i<end;i++)
915          maxDepth = MAX16(maxDepth, bandLogE[c*nbEBands+i]-noise_floor[i]);
916    } while (++c<C);
917    /* Make sure that dynamic allocation can't make us bust the budget */
918    if (effectiveBytes > 50 && LM>=1 && !lfe)
919    {
920       int last=0;
921       c=0;do
922       {
923          follower[c*nbEBands] = bandLogE2[c*nbEBands];
924          for (i=1;i<end;i++)
925          {
926             /* The last band to be at least 3 dB higher than the previous one
927                is the last we'll consider. Otherwise, we run into problems on
928                bandlimited signals. */
929             if (bandLogE2[c*nbEBands+i] > bandLogE2[c*nbEBands+i-1]+QCONST16(.5f,DB_SHIFT))
930                last=i;
931             follower[c*nbEBands+i] = MIN16(follower[c*nbEBands+i-1]+QCONST16(1.5f,DB_SHIFT), bandLogE2[c*nbEBands+i]);
932          }
933          for (i=last-1;i>=0;i--)
934             follower[c*nbEBands+i] = MIN16(follower[c*nbEBands+i], MIN16(follower[c*nbEBands+i+1]+QCONST16(2.f,DB_SHIFT), bandLogE2[c*nbEBands+i]));
935          for (i=0;i<end;i++)
936             follower[c*nbEBands+i] = MAX16(follower[c*nbEBands+i], noise_floor[i]);
937       } while (++c<C);
938       if (C==2)
939       {
940          for (i=start;i<end;i++)
941          {
942             /* Consider 24 dB "cross-talk" */
943             follower[nbEBands+i] = MAX16(follower[nbEBands+i], follower[         i]-QCONST16(4.f,DB_SHIFT));
944             follower[         i] = MAX16(follower[         i], follower[nbEBands+i]-QCONST16(4.f,DB_SHIFT));
945             follower[i] = HALF16(MAX16(0, bandLogE[i]-follower[i]) + MAX16(0, bandLogE[nbEBands+i]-follower[nbEBands+i]));
946          }
947       } else {
948          for (i=start;i<end;i++)
949          {
950             follower[i] = MAX16(0, bandLogE[i]-follower[i]);
951          }
952       }
953       for (i=start;i<end;i++)
954          follower[i] = MAX16(follower[i], surround_dynalloc[i]);
955       /* For non-transient CBR/CVBR frames, halve the dynalloc contribution */
956       if ((!vbr || constrained_vbr)&&!isTransient)
957       {
958          for (i=start;i<end;i++)
959             follower[i] = HALF16(follower[i]);
960       }
961       for (i=start;i<end;i++)
962       {
963          int width;
964          int boost;
965          int boost_bits;
966
967          if (i<8)
968             follower[i] *= 2;
969          if (i>=12)
970             follower[i] = HALF16(follower[i]);
971          follower[i] = MIN16(follower[i], QCONST16(4, DB_SHIFT));
972
973          width = C*(eBands[i+1]-eBands[i])<<LM;
974          if (width<6)
975          {
976             boost = (int)SHR32(EXTEND32(follower[i]),DB_SHIFT);
977             boost_bits = boost*width<<BITRES;
978          } else if (width > 48) {
979             boost = (int)SHR32(EXTEND32(follower[i])*8,DB_SHIFT);
980             boost_bits = (boost*width<<BITRES)/8;
981          } else {
982             boost = (int)SHR32(EXTEND32(follower[i])*width/6,DB_SHIFT);
983             boost_bits = boost*6<<BITRES;
984          }
985          /* For CBR and non-transient CVBR frames, limit dynalloc to 1/4 of the bits */
986          if ((!vbr || (constrained_vbr&&!isTransient))
987                && (tot_boost+boost_bits)>>BITRES>>3 > effectiveBytes/4)
988          {
989             opus_int32 cap = ((effectiveBytes/4)<<BITRES<<3);
990             offsets[i] = cap-tot_boost;
991             tot_boost = cap;
992             break;
993          } else {
994             offsets[i] = boost;
995             tot_boost += boost_bits;
996          }
997       }
998    }
999    *tot_boost_ = tot_boost;
1000    RESTORE_STACK;
1001    return maxDepth;
1002 }
1003
1004
1005 static int run_prefilter(CELTEncoder *st, celt_sig *in, celt_sig *prefilter_mem, int CC, int N,
1006       int prefilter_tapset, int *pitch, opus_val16 *gain, int *qgain, int enabled, int nbAvailableBytes)
1007 {
1008    int c;
1009    VARDECL(celt_sig, _pre);
1010    celt_sig *pre[2];
1011    const CELTMode *mode;
1012    int pitch_index;
1013    opus_val16 gain1;
1014    opus_val16 pf_threshold;
1015    int pf_on;
1016    int qg;
1017    SAVE_STACK;
1018
1019    mode = st->mode;
1020    ALLOC(_pre, CC*(N+COMBFILTER_MAXPERIOD), celt_sig);
1021
1022    pre[0] = _pre;
1023    pre[1] = _pre + (N+COMBFILTER_MAXPERIOD);
1024
1025
1026    c=0; do {
1027       OPUS_COPY(pre[c], prefilter_mem+c*COMBFILTER_MAXPERIOD, COMBFILTER_MAXPERIOD);
1028       OPUS_COPY(pre[c]+COMBFILTER_MAXPERIOD, in+c*(N+st->overlap)+st->overlap, N);
1029    } while (++c<CC);
1030
1031    if (enabled)
1032    {
1033       VARDECL(opus_val16, pitch_buf);
1034       ALLOC(pitch_buf, (COMBFILTER_MAXPERIOD+N)>>1, opus_val16);
1035
1036       pitch_downsample(pre, pitch_buf, COMBFILTER_MAXPERIOD+N, CC, st->arch);
1037       /* Don't search for the fir last 1.5 octave of the range because
1038          there's too many false-positives due to short-term correlation */
1039       pitch_search(pitch_buf+(COMBFILTER_MAXPERIOD>>1), pitch_buf, N,
1040             COMBFILTER_MAXPERIOD-3*COMBFILTER_MINPERIOD, &pitch_index,
1041             st->arch);
1042       pitch_index = COMBFILTER_MAXPERIOD-pitch_index;
1043
1044       gain1 = remove_doubling(pitch_buf, COMBFILTER_MAXPERIOD, COMBFILTER_MINPERIOD,
1045             N, &pitch_index, st->prefilter_period, st->prefilter_gain);
1046       if (pitch_index > COMBFILTER_MAXPERIOD-2)
1047          pitch_index = COMBFILTER_MAXPERIOD-2;
1048       gain1 = MULT16_16_Q15(QCONST16(.7f,15),gain1);
1049       /*printf("%d %d %f %f\n", pitch_change, pitch_index, gain1, st->analysis.tonality);*/
1050       if (st->loss_rate>2)
1051          gain1 = HALF32(gain1);
1052       if (st->loss_rate>4)
1053          gain1 = HALF32(gain1);
1054       if (st->loss_rate>8)
1055          gain1 = 0;
1056    } else {
1057       gain1 = 0;
1058       pitch_index = COMBFILTER_MINPERIOD;
1059    }
1060
1061    /* Gain threshold for enabling the prefilter/postfilter */
1062    pf_threshold = QCONST16(.2f,15);
1063
1064    /* Adjusting the threshold based on rate and continuity */
1065    if (abs(pitch_index-st->prefilter_period)*10>pitch_index)
1066       pf_threshold += QCONST16(.2f,15);
1067    if (nbAvailableBytes<25)
1068       pf_threshold += QCONST16(.1f,15);
1069    if (nbAvailableBytes<35)
1070       pf_threshold += QCONST16(.1f,15);
1071    if (st->prefilter_gain > QCONST16(.4f,15))
1072       pf_threshold -= QCONST16(.1f,15);
1073    if (st->prefilter_gain > QCONST16(.55f,15))
1074       pf_threshold -= QCONST16(.1f,15);
1075
1076    /* Hard threshold at 0.2 */
1077    pf_threshold = MAX16(pf_threshold, QCONST16(.2f,15));
1078    if (gain1<pf_threshold)
1079    {
1080       gain1 = 0;
1081       pf_on = 0;
1082       qg = 0;
1083    } else {
1084       /*This block is not gated by a total bits check only because
1085         of the nbAvailableBytes check above.*/
1086       if (ABS16(gain1-st->prefilter_gain)<QCONST16(.1f,15))
1087          gain1=st->prefilter_gain;
1088
1089 #ifdef FIXED_POINT
1090       qg = ((gain1+1536)>>10)/3-1;
1091 #else
1092       qg = (int)floor(.5f+gain1*32/3)-1;
1093 #endif
1094       qg = IMAX(0, IMIN(7, qg));
1095       gain1 = QCONST16(0.09375f,15)*(qg+1);
1096       pf_on = 1;
1097    }
1098    /*printf("%d %f\n", pitch_index, gain1);*/
1099
1100    c=0; do {
1101       int offset = mode->shortMdctSize-st->overlap;
1102       st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
1103       OPUS_COPY(in+c*(N+st->overlap), st->in_mem+c*(st->overlap), st->overlap);
1104       if (offset)
1105          comb_filter(in+c*(N+st->overlap)+st->overlap, pre[c]+COMBFILTER_MAXPERIOD,
1106                st->prefilter_period, st->prefilter_period, offset, -st->prefilter_gain, -st->prefilter_gain,
1107                st->prefilter_tapset, st->prefilter_tapset, NULL, 0);
1108
1109       comb_filter(in+c*(N+st->overlap)+st->overlap+offset, pre[c]+COMBFILTER_MAXPERIOD+offset,
1110             st->prefilter_period, pitch_index, N-offset, -st->prefilter_gain, -gain1,
1111             st->prefilter_tapset, prefilter_tapset, mode->window, st->overlap);
1112       OPUS_COPY(st->in_mem+c*(st->overlap), in+c*(N+st->overlap)+N, st->overlap);
1113
1114       if (N>COMBFILTER_MAXPERIOD)
1115       {
1116          OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, pre[c]+N, COMBFILTER_MAXPERIOD);
1117       } else {
1118          OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, prefilter_mem+c*COMBFILTER_MAXPERIOD+N, COMBFILTER_MAXPERIOD-N);
1119          OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD+COMBFILTER_MAXPERIOD-N, pre[c]+COMBFILTER_MAXPERIOD, N);
1120       }
1121    } while (++c<CC);
1122
1123    RESTORE_STACK;
1124    *gain = gain1;
1125    *pitch = pitch_index;
1126    *qgain = qg;
1127    return pf_on;
1128 }
1129
1130 static int compute_vbr(const CELTMode *mode, AnalysisInfo *analysis, opus_int32 base_target,
1131       int LM, opus_int32 bitrate, int lastCodedBands, int C, int intensity,
1132       int constrained_vbr, opus_val16 stereo_saving, int tot_boost,
1133       opus_val16 tf_estimate, int pitch_change, opus_val16 maxDepth,
1134       int variable_duration, int lfe, int has_surround_mask, opus_val16 surround_masking,
1135       opus_val16 temporal_vbr)
1136 {
1137    /* The target rate in 8th bits per frame */
1138    opus_int32 target;
1139    int coded_bins;
1140    int coded_bands;
1141    opus_val16 tf_calibration;
1142    int nbEBands;
1143    const opus_int16 *eBands;
1144
1145    nbEBands = mode->nbEBands;
1146    eBands = mode->eBands;
1147
1148    coded_bands = lastCodedBands ? lastCodedBands : nbEBands;
1149    coded_bins = eBands[coded_bands]<<LM;
1150    if (C==2)
1151       coded_bins += eBands[IMIN(intensity, coded_bands)]<<LM;
1152
1153    target = base_target;
1154
1155    /*printf("%f %f %f %f %d %d ", st->analysis.activity, st->analysis.tonality, tf_estimate, st->stereo_saving, tot_boost, coded_bands);*/
1156 #ifndef DISABLE_FLOAT_API
1157    if (analysis->valid && analysis->activity<.4)
1158       target -= (opus_int32)((coded_bins<<BITRES)*(.4f-analysis->activity));
1159 #endif
1160    /* Stereo savings */
1161    if (C==2)
1162    {
1163       int coded_stereo_bands;
1164       int coded_stereo_dof;
1165       opus_val16 max_frac;
1166       coded_stereo_bands = IMIN(intensity, coded_bands);
1167       coded_stereo_dof = (eBands[coded_stereo_bands]<<LM)-coded_stereo_bands;
1168       /* Maximum fraction of the bits we can save if the signal is mono. */
1169       max_frac = DIV32_16(MULT16_16(QCONST16(0.8f, 15), coded_stereo_dof), coded_bins);
1170       stereo_saving = MIN16(stereo_saving, QCONST16(1.f, 8));
1171       /*printf("%d %d %d ", coded_stereo_dof, coded_bins, tot_boost);*/
1172       target -= (opus_int32)MIN32(MULT16_32_Q15(max_frac,target),
1173                       SHR32(MULT16_16(stereo_saving-QCONST16(0.1f,8),(coded_stereo_dof<<BITRES)),8));
1174    }
1175    /* Boost the rate according to dynalloc (minus the dynalloc average for calibration). */
1176    target += tot_boost-(16<<LM);
1177    /* Apply transient boost, compensating for average boost. */
1178    tf_calibration = variable_duration==OPUS_FRAMESIZE_VARIABLE ?
1179                     QCONST16(0.02f,14) : QCONST16(0.04f,14);
1180    target += (opus_int32)SHL32(MULT16_32_Q15(tf_estimate-tf_calibration, target),1);
1181
1182 #ifndef DISABLE_FLOAT_API
1183    /* Apply tonality boost */
1184    if (analysis->valid && !lfe)
1185    {
1186       opus_int32 tonal_target;
1187       float tonal;
1188
1189       /* Tonality boost (compensating for the average). */
1190       tonal = MAX16(0.f,analysis->tonality-.15f)-0.09f;
1191       tonal_target = target + (opus_int32)((coded_bins<<BITRES)*1.2f*tonal);
1192       if (pitch_change)
1193          tonal_target +=  (opus_int32)((coded_bins<<BITRES)*.8f);
1194       /*printf("%f %f ", analysis->tonality, tonal);*/
1195       target = tonal_target;
1196    }
1197 #endif
1198
1199    if (has_surround_mask&&!lfe)
1200    {
1201       opus_int32 surround_target = target + (opus_int32)SHR32(MULT16_16(surround_masking,coded_bins<<BITRES), DB_SHIFT);
1202       /*printf("%f %d %d %d %d %d %d ", surround_masking, coded_bins, st->end, st->intensity, surround_target, target, st->bitrate);*/
1203       target = IMAX(target/4, surround_target);
1204    }
1205
1206    {
1207       opus_int32 floor_depth;
1208       int bins;
1209       bins = eBands[nbEBands-2]<<LM;
1210       /*floor_depth = SHR32(MULT16_16((C*bins<<BITRES),celt_log2(SHL32(MAX16(1,sample_max),13))), DB_SHIFT);*/
1211       floor_depth = (opus_int32)SHR32(MULT16_16((C*bins<<BITRES),maxDepth), DB_SHIFT);
1212       floor_depth = IMAX(floor_depth, target>>2);
1213       target = IMIN(target, floor_depth);
1214       /*printf("%f %d\n", maxDepth, floor_depth);*/
1215    }
1216
1217    if ((!has_surround_mask||lfe) && (constrained_vbr || bitrate<64000))
1218    {
1219       opus_val16 rate_factor;
1220 #ifdef FIXED_POINT
1221       rate_factor = MAX16(0,(bitrate-32000));
1222 #else
1223       rate_factor = MAX16(0,(1.f/32768)*(bitrate-32000));
1224 #endif
1225       if (constrained_vbr)
1226          rate_factor = MIN16(rate_factor, QCONST16(0.67f, 15));
1227       target = base_target + (opus_int32)MULT16_32_Q15(rate_factor, target-base_target);
1228
1229    }
1230
1231    if (!has_surround_mask && tf_estimate < QCONST16(.2f, 14))
1232    {
1233       opus_val16 amount;
1234       opus_val16 tvbr_factor;
1235       amount = MULT16_16_Q15(QCONST16(.0000031f, 30), IMAX(0, IMIN(32000, 96000-bitrate)));
1236       tvbr_factor = SHR32(MULT16_16(temporal_vbr, amount), DB_SHIFT);
1237       target += (opus_int32)MULT16_32_Q15(tvbr_factor, target);
1238    }
1239
1240    /* Don't allow more than doubling the rate */
1241    target = IMIN(2*base_target, target);
1242
1243    return target;
1244 }
1245
1246 int celt_encode_with_ec(CELTEncoder * OPUS_RESTRICT st, const opus_val16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
1247 {
1248    int i, c, N;
1249    opus_int32 bits;
1250    ec_enc _enc;
1251    VARDECL(celt_sig, in);
1252    VARDECL(celt_sig, freq);
1253    VARDECL(celt_norm, X);
1254    VARDECL(celt_ener, bandE);
1255    VARDECL(opus_val16, bandLogE);
1256    VARDECL(opus_val16, bandLogE2);
1257    VARDECL(int, fine_quant);
1258    VARDECL(opus_val16, error);
1259    VARDECL(int, pulses);
1260    VARDECL(int, cap);
1261    VARDECL(int, offsets);
1262    VARDECL(int, fine_priority);
1263    VARDECL(int, tf_res);
1264    VARDECL(unsigned char, collapse_masks);
1265    celt_sig *prefilter_mem;
1266    opus_val16 *oldBandE, *oldLogE, *oldLogE2;
1267    int shortBlocks=0;
1268    int isTransient=0;
1269    const int CC = st->channels;
1270    const int C = st->stream_channels;
1271    int LM, M;
1272    int tf_select;
1273    int nbFilledBytes, nbAvailableBytes;
1274    int effEnd;
1275    int codedBands;
1276    int tf_sum;
1277    int alloc_trim;
1278    int pitch_index=COMBFILTER_MINPERIOD;
1279    opus_val16 gain1 = 0;
1280    int dual_stereo=0;
1281    int effectiveBytes;
1282    int dynalloc_logp;
1283    opus_int32 vbr_rate;
1284    opus_int32 total_bits;
1285    opus_int32 total_boost;
1286    opus_int32 balance;
1287    opus_int32 tell;
1288    int prefilter_tapset=0;
1289    int pf_on;
1290    int anti_collapse_rsv;
1291    int anti_collapse_on=0;
1292    int silence=0;
1293    int tf_chan = 0;
1294    opus_val16 tf_estimate;
1295    int pitch_change=0;
1296    opus_int32 tot_boost;
1297    opus_val32 sample_max;
1298    opus_val16 maxDepth;
1299    const OpusCustomMode *mode;
1300    int nbEBands;
1301    int overlap;
1302    const opus_int16 *eBands;
1303    int secondMdct;
1304    int signalBandwidth;
1305    int transient_got_disabled=0;
1306    opus_val16 surround_masking=0;
1307    opus_val16 temporal_vbr=0;
1308    opus_val16 surround_trim = 0;
1309    opus_int32 equiv_rate = 510000;
1310    VARDECL(opus_val16, surround_dynalloc);
1311    ALLOC_STACK;
1312
1313    mode = st->mode;
1314    nbEBands = mode->nbEBands;
1315    overlap = mode->overlap;
1316    eBands = mode->eBands;
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*(st->overlap);
1337    oldBandE = (opus_val16*)(st->in_mem+CC*(st->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-st->end)>>1;
1354       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 = st->end;
1438    if (effEnd > mode->effEBands)
1439       effEnd = mode->effEBands;
1440
1441    ALLOC(in, CC*(N+st->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+st->overlap)+st->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) && st->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(st->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+st->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, st->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<st->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, st->end, bandE, bandLogE, C);
1561
1562    ALLOC(surround_dynalloc, C*nbEBands, opus_val16);
1563    OPUS_CLEAR(surround_dynalloc, st->end);
1564    /* This computes how much masking takes place between surround channels */
1565    if (st->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=st->start;i<st->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 /= (st->end-st->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, st->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, st->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 && st->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<st->end;i++)
1706          tf_res[i] = tf_res[effEnd-1];
1707    } else {
1708       tf_sum = 0;
1709       for (i=0;i<st->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, st->start, st->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(st->start, st->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 || st->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, st->start, st->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=st->start;i<st->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(st->end,IMAX(st->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             st->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 = st->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, st->start, st->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, st->start, st->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, st->start, st->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, st->start, st->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                st->start, st->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, st->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, st->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<st->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=st->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->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 }