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