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