Speeding up extract_collapse_mask() slightly
[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          opus_val16 *f;
961          f = &follower[c*nbEBands];
962          f[0] = bandLogE2[c*nbEBands];
963          for (i=1;i<end;i++)
964          {
965             /* The last band to be at least 3 dB higher than the previous one
966                is the last we'll consider. Otherwise, we run into problems on
967                bandlimited signals. */
968             if (bandLogE2[c*nbEBands+i] > bandLogE2[c*nbEBands+i-1]+QCONST16(.5f,DB_SHIFT))
969                last=i;
970             f[i] = MIN16(f[i-1]+QCONST16(1.5f,DB_SHIFT), bandLogE2[c*nbEBands+i]);
971          }
972          for (i=last-1;i>=0;i--)
973             f[i] = MIN16(f[i], MIN16(f[i+1]+QCONST16(2.f,DB_SHIFT), bandLogE2[c*nbEBands+i]));
974
975          /* Combine with a median filter to avoid dynalloc triggering unnecessarily.
976             The "offset" value controls how conservative we are -- a higher offset
977             reduces the impact of the median filter and makes dynalloc use more bits. */
978          offset = QCONST16(1.f, DB_SHIFT);
979          for (i=2;i<end-2;i++)
980             f[i] = MAX16(f[i], median_of_5(&bandLogE2[c*nbEBands+i-2])-offset);
981          tmp = median_of_3(&bandLogE2[c*nbEBands])-offset;
982          f[0] = MAX16(f[0], tmp);
983          f[1] = MAX16(f[1], tmp);
984          tmp = median_of_3(&bandLogE2[c*nbEBands+end-3])-offset;
985          f[end-2] = MAX16(f[end-2], tmp);
986          f[end-1] = MAX16(f[end-1], tmp);
987
988          for (i=0;i<end;i++)
989             f[i] = MAX16(f[i], noise_floor[i]);
990       } while (++c<C);
991       if (C==2)
992       {
993          for (i=start;i<end;i++)
994          {
995             /* Consider 24 dB "cross-talk" */
996             follower[nbEBands+i] = MAX16(follower[nbEBands+i], follower[         i]-QCONST16(4.f,DB_SHIFT));
997             follower[         i] = MAX16(follower[         i], follower[nbEBands+i]-QCONST16(4.f,DB_SHIFT));
998             follower[i] = HALF16(MAX16(0, bandLogE[i]-follower[i]) + MAX16(0, bandLogE[nbEBands+i]-follower[nbEBands+i]));
999          }
1000       } else {
1001          for (i=start;i<end;i++)
1002          {
1003             follower[i] = MAX16(0, bandLogE[i]-follower[i]);
1004          }
1005       }
1006       for (i=start;i<end;i++)
1007          follower[i] = MAX16(follower[i], surround_dynalloc[i]);
1008       /* For non-transient CBR/CVBR frames, halve the dynalloc contribution */
1009       if ((!vbr || constrained_vbr)&&!isTransient)
1010       {
1011          for (i=start;i<end;i++)
1012             follower[i] = HALF16(follower[i]);
1013       }
1014       for (i=start;i<end;i++)
1015       {
1016          int width;
1017          int boost;
1018          int boost_bits;
1019
1020          if (i<8)
1021             follower[i] *= 2;
1022          if (i>=12)
1023             follower[i] = HALF16(follower[i]);
1024          follower[i] = MIN16(follower[i], QCONST16(4, DB_SHIFT));
1025
1026          width = C*(eBands[i+1]-eBands[i])<<LM;
1027          if (width<6)
1028          {
1029             boost = (int)SHR32(EXTEND32(follower[i]),DB_SHIFT);
1030             boost_bits = boost*width<<BITRES;
1031          } else if (width > 48) {
1032             boost = (int)SHR32(EXTEND32(follower[i])*8,DB_SHIFT);
1033             boost_bits = (boost*width<<BITRES)/8;
1034          } else {
1035             boost = (int)SHR32(EXTEND32(follower[i])*width/6,DB_SHIFT);
1036             boost_bits = boost*6<<BITRES;
1037          }
1038          /* For CBR and non-transient CVBR frames, limit dynalloc to 1/4 of the bits */
1039          if ((!vbr || (constrained_vbr&&!isTransient))
1040                && (tot_boost+boost_bits)>>BITRES>>3 > effectiveBytes/4)
1041          {
1042             opus_int32 cap = ((effectiveBytes/4)<<BITRES<<3);
1043             offsets[i] = cap-tot_boost;
1044             tot_boost = cap;
1045             break;
1046          } else {
1047             offsets[i] = boost;
1048             tot_boost += boost_bits;
1049          }
1050       }
1051    }
1052    *tot_boost_ = tot_boost;
1053    RESTORE_STACK;
1054    return maxDepth;
1055 }
1056
1057
1058 static int run_prefilter(CELTEncoder *st, celt_sig *in, celt_sig *prefilter_mem, int CC, int N,
1059       int prefilter_tapset, int *pitch, opus_val16 *gain, int *qgain, int enabled, int nbAvailableBytes)
1060 {
1061    int c;
1062    VARDECL(celt_sig, _pre);
1063    celt_sig *pre[2];
1064    const CELTMode *mode;
1065    int pitch_index;
1066    opus_val16 gain1;
1067    opus_val16 pf_threshold;
1068    int pf_on;
1069    int qg;
1070    int overlap;
1071    SAVE_STACK;
1072
1073    mode = st->mode;
1074    overlap = mode->overlap;
1075    ALLOC(_pre, CC*(N+COMBFILTER_MAXPERIOD), celt_sig);
1076
1077    pre[0] = _pre;
1078    pre[1] = _pre + (N+COMBFILTER_MAXPERIOD);
1079
1080
1081    c=0; do {
1082       OPUS_COPY(pre[c], prefilter_mem+c*COMBFILTER_MAXPERIOD, COMBFILTER_MAXPERIOD);
1083       OPUS_COPY(pre[c]+COMBFILTER_MAXPERIOD, in+c*(N+overlap)+overlap, N);
1084    } while (++c<CC);
1085
1086    if (enabled)
1087    {
1088       VARDECL(opus_val16, pitch_buf);
1089       ALLOC(pitch_buf, (COMBFILTER_MAXPERIOD+N)>>1, opus_val16);
1090
1091       pitch_downsample(pre, pitch_buf, COMBFILTER_MAXPERIOD+N, CC, st->arch);
1092       /* Don't search for the fir last 1.5 octave of the range because
1093          there's too many false-positives due to short-term correlation */
1094       pitch_search(pitch_buf+(COMBFILTER_MAXPERIOD>>1), pitch_buf, N,
1095             COMBFILTER_MAXPERIOD-3*COMBFILTER_MINPERIOD, &pitch_index,
1096             st->arch);
1097       pitch_index = COMBFILTER_MAXPERIOD-pitch_index;
1098
1099       gain1 = remove_doubling(pitch_buf, COMBFILTER_MAXPERIOD, COMBFILTER_MINPERIOD,
1100             N, &pitch_index, st->prefilter_period, st->prefilter_gain);
1101       if (pitch_index > COMBFILTER_MAXPERIOD-2)
1102          pitch_index = COMBFILTER_MAXPERIOD-2;
1103       gain1 = MULT16_16_Q15(QCONST16(.7f,15),gain1);
1104       /*printf("%d %d %f %f\n", pitch_change, pitch_index, gain1, st->analysis.tonality);*/
1105       if (st->loss_rate>2)
1106          gain1 = HALF32(gain1);
1107       if (st->loss_rate>4)
1108          gain1 = HALF32(gain1);
1109       if (st->loss_rate>8)
1110          gain1 = 0;
1111    } else {
1112       gain1 = 0;
1113       pitch_index = COMBFILTER_MINPERIOD;
1114    }
1115
1116    /* Gain threshold for enabling the prefilter/postfilter */
1117    pf_threshold = QCONST16(.2f,15);
1118
1119    /* Adjusting the threshold based on rate and continuity */
1120    if (abs(pitch_index-st->prefilter_period)*10>pitch_index)
1121       pf_threshold += QCONST16(.2f,15);
1122    if (nbAvailableBytes<25)
1123       pf_threshold += QCONST16(.1f,15);
1124    if (nbAvailableBytes<35)
1125       pf_threshold += QCONST16(.1f,15);
1126    if (st->prefilter_gain > QCONST16(.4f,15))
1127       pf_threshold -= QCONST16(.1f,15);
1128    if (st->prefilter_gain > QCONST16(.55f,15))
1129       pf_threshold -= QCONST16(.1f,15);
1130
1131    /* Hard threshold at 0.2 */
1132    pf_threshold = MAX16(pf_threshold, QCONST16(.2f,15));
1133    if (gain1<pf_threshold)
1134    {
1135       gain1 = 0;
1136       pf_on = 0;
1137       qg = 0;
1138    } else {
1139       /*This block is not gated by a total bits check only because
1140         of the nbAvailableBytes check above.*/
1141       if (ABS16(gain1-st->prefilter_gain)<QCONST16(.1f,15))
1142          gain1=st->prefilter_gain;
1143
1144 #ifdef FIXED_POINT
1145       qg = ((gain1+1536)>>10)/3-1;
1146 #else
1147       qg = (int)floor(.5f+gain1*32/3)-1;
1148 #endif
1149       qg = IMAX(0, IMIN(7, qg));
1150       gain1 = QCONST16(0.09375f,15)*(qg+1);
1151       pf_on = 1;
1152    }
1153    /*printf("%d %f\n", pitch_index, gain1);*/
1154
1155    c=0; do {
1156       int offset = mode->shortMdctSize-overlap;
1157       st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
1158       OPUS_COPY(in+c*(N+overlap), st->in_mem+c*(overlap), overlap);
1159       if (offset)
1160          comb_filter(in+c*(N+overlap)+overlap, pre[c]+COMBFILTER_MAXPERIOD,
1161                st->prefilter_period, st->prefilter_period, offset, -st->prefilter_gain, -st->prefilter_gain,
1162                st->prefilter_tapset, st->prefilter_tapset, NULL, 0);
1163
1164       comb_filter(in+c*(N+overlap)+overlap+offset, pre[c]+COMBFILTER_MAXPERIOD+offset,
1165             st->prefilter_period, pitch_index, N-offset, -st->prefilter_gain, -gain1,
1166             st->prefilter_tapset, prefilter_tapset, mode->window, overlap);
1167       OPUS_COPY(st->in_mem+c*(overlap), in+c*(N+overlap)+N, overlap);
1168
1169       if (N>COMBFILTER_MAXPERIOD)
1170       {
1171          OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, pre[c]+N, COMBFILTER_MAXPERIOD);
1172       } else {
1173          OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, prefilter_mem+c*COMBFILTER_MAXPERIOD+N, COMBFILTER_MAXPERIOD-N);
1174          OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD+COMBFILTER_MAXPERIOD-N, pre[c]+COMBFILTER_MAXPERIOD, N);
1175       }
1176    } while (++c<CC);
1177
1178    RESTORE_STACK;
1179    *gain = gain1;
1180    *pitch = pitch_index;
1181    *qgain = qg;
1182    return pf_on;
1183 }
1184
1185 static int compute_vbr(const CELTMode *mode, AnalysisInfo *analysis, opus_int32 base_target,
1186       int LM, opus_int32 bitrate, int lastCodedBands, int C, int intensity,
1187       int constrained_vbr, opus_val16 stereo_saving, int tot_boost,
1188       opus_val16 tf_estimate, int pitch_change, opus_val16 maxDepth,
1189       int variable_duration, int lfe, int has_surround_mask, opus_val16 surround_masking,
1190       opus_val16 temporal_vbr)
1191 {
1192    /* The target rate in 8th bits per frame */
1193    opus_int32 target;
1194    int coded_bins;
1195    int coded_bands;
1196    opus_val16 tf_calibration;
1197    int nbEBands;
1198    const opus_int16 *eBands;
1199
1200    nbEBands = mode->nbEBands;
1201    eBands = mode->eBands;
1202
1203    coded_bands = lastCodedBands ? lastCodedBands : nbEBands;
1204    coded_bins = eBands[coded_bands]<<LM;
1205    if (C==2)
1206       coded_bins += eBands[IMIN(intensity, coded_bands)]<<LM;
1207
1208    target = base_target;
1209
1210    /*printf("%f %f %f %f %d %d ", st->analysis.activity, st->analysis.tonality, tf_estimate, st->stereo_saving, tot_boost, coded_bands);*/
1211 #ifndef DISABLE_FLOAT_API
1212    if (analysis->valid && analysis->activity<.4)
1213       target -= (opus_int32)((coded_bins<<BITRES)*(.4f-analysis->activity));
1214 #endif
1215    /* Stereo savings */
1216    if (C==2)
1217    {
1218       int coded_stereo_bands;
1219       int coded_stereo_dof;
1220       opus_val16 max_frac;
1221       coded_stereo_bands = IMIN(intensity, coded_bands);
1222       coded_stereo_dof = (eBands[coded_stereo_bands]<<LM)-coded_stereo_bands;
1223       /* Maximum fraction of the bits we can save if the signal is mono. */
1224       max_frac = DIV32_16(MULT16_16(QCONST16(0.8f, 15), coded_stereo_dof), coded_bins);
1225       stereo_saving = MIN16(stereo_saving, QCONST16(1.f, 8));
1226       /*printf("%d %d %d ", coded_stereo_dof, coded_bins, tot_boost);*/
1227       target -= (opus_int32)MIN32(MULT16_32_Q15(max_frac,target),
1228                       SHR32(MULT16_16(stereo_saving-QCONST16(0.1f,8),(coded_stereo_dof<<BITRES)),8));
1229    }
1230    /* Boost the rate according to dynalloc (minus the dynalloc average for calibration). */
1231    target += tot_boost-(16<<LM);
1232    /* Apply transient boost, compensating for average boost. */
1233    tf_calibration = variable_duration==OPUS_FRAMESIZE_VARIABLE ?
1234                     QCONST16(0.02f,14) : QCONST16(0.04f,14);
1235    target += (opus_int32)SHL32(MULT16_32_Q15(tf_estimate-tf_calibration, target),1);
1236
1237 #ifndef DISABLE_FLOAT_API
1238    /* Apply tonality boost */
1239    if (analysis->valid && !lfe)
1240    {
1241       opus_int32 tonal_target;
1242       float tonal;
1243
1244       /* Tonality boost (compensating for the average). */
1245       tonal = MAX16(0.f,analysis->tonality-.15f)-0.09f;
1246       tonal_target = target + (opus_int32)((coded_bins<<BITRES)*1.2f*tonal);
1247       if (pitch_change)
1248          tonal_target +=  (opus_int32)((coded_bins<<BITRES)*.8f);
1249       /*printf("%f %f ", analysis->tonality, tonal);*/
1250       target = tonal_target;
1251    }
1252 #endif
1253
1254    if (has_surround_mask&&!lfe)
1255    {
1256       opus_int32 surround_target = target + (opus_int32)SHR32(MULT16_16(surround_masking,coded_bins<<BITRES), DB_SHIFT);
1257       /*printf("%f %d %d %d %d %d %d ", surround_masking, coded_bins, st->end, st->intensity, surround_target, target, st->bitrate);*/
1258       target = IMAX(target/4, surround_target);
1259    }
1260
1261    {
1262       opus_int32 floor_depth;
1263       int bins;
1264       bins = eBands[nbEBands-2]<<LM;
1265       /*floor_depth = SHR32(MULT16_16((C*bins<<BITRES),celt_log2(SHL32(MAX16(1,sample_max),13))), DB_SHIFT);*/
1266       floor_depth = (opus_int32)SHR32(MULT16_16((C*bins<<BITRES),maxDepth), DB_SHIFT);
1267       floor_depth = IMAX(floor_depth, target>>2);
1268       target = IMIN(target, floor_depth);
1269       /*printf("%f %d\n", maxDepth, floor_depth);*/
1270    }
1271
1272    if ((!has_surround_mask||lfe) && (constrained_vbr || bitrate<64000))
1273    {
1274       opus_val16 rate_factor;
1275 #ifdef FIXED_POINT
1276       rate_factor = MAX16(0,(bitrate-32000));
1277 #else
1278       rate_factor = MAX16(0,(1.f/32768)*(bitrate-32000));
1279 #endif
1280       if (constrained_vbr)
1281          rate_factor = MIN16(rate_factor, QCONST16(0.67f, 15));
1282       target = base_target + (opus_int32)MULT16_32_Q15(rate_factor, target-base_target);
1283
1284    }
1285
1286    if (!has_surround_mask && tf_estimate < QCONST16(.2f, 14))
1287    {
1288       opus_val16 amount;
1289       opus_val16 tvbr_factor;
1290       amount = MULT16_16_Q15(QCONST16(.0000031f, 30), IMAX(0, IMIN(32000, 96000-bitrate)));
1291       tvbr_factor = SHR32(MULT16_16(temporal_vbr, amount), DB_SHIFT);
1292       target += (opus_int32)MULT16_32_Q15(tvbr_factor, target);
1293    }
1294
1295    /* Don't allow more than doubling the rate */
1296    target = IMIN(2*base_target, target);
1297
1298    return target;
1299 }
1300
1301 int celt_encode_with_ec(CELTEncoder * OPUS_RESTRICT st, const opus_val16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
1302 {
1303    int i, c, N;
1304    opus_int32 bits;
1305    ec_enc _enc;
1306    VARDECL(celt_sig, in);
1307    VARDECL(celt_sig, freq);
1308    VARDECL(celt_norm, X);
1309    VARDECL(celt_ener, bandE);
1310    VARDECL(opus_val16, bandLogE);
1311    VARDECL(opus_val16, bandLogE2);
1312    VARDECL(int, fine_quant);
1313    VARDECL(opus_val16, error);
1314    VARDECL(int, pulses);
1315    VARDECL(int, cap);
1316    VARDECL(int, offsets);
1317    VARDECL(int, fine_priority);
1318    VARDECL(int, tf_res);
1319    VARDECL(unsigned char, collapse_masks);
1320    celt_sig *prefilter_mem;
1321    opus_val16 *oldBandE, *oldLogE, *oldLogE2;
1322    int shortBlocks=0;
1323    int isTransient=0;
1324    const int CC = st->channels;
1325    const int C = st->stream_channels;
1326    int LM, M;
1327    int tf_select;
1328    int nbFilledBytes, nbAvailableBytes;
1329    int start;
1330    int end;
1331    int effEnd;
1332    int codedBands;
1333    int tf_sum;
1334    int alloc_trim;
1335    int pitch_index=COMBFILTER_MINPERIOD;
1336    opus_val16 gain1 = 0;
1337    int dual_stereo=0;
1338    int effectiveBytes;
1339    int dynalloc_logp;
1340    opus_int32 vbr_rate;
1341    opus_int32 total_bits;
1342    opus_int32 total_boost;
1343    opus_int32 balance;
1344    opus_int32 tell;
1345    int prefilter_tapset=0;
1346    int pf_on;
1347    int anti_collapse_rsv;
1348    int anti_collapse_on=0;
1349    int silence=0;
1350    int tf_chan = 0;
1351    opus_val16 tf_estimate;
1352    int pitch_change=0;
1353    opus_int32 tot_boost;
1354    opus_val32 sample_max;
1355    opus_val16 maxDepth;
1356    const OpusCustomMode *mode;
1357    int nbEBands;
1358    int overlap;
1359    const opus_int16 *eBands;
1360    int secondMdct;
1361    int signalBandwidth;
1362    int transient_got_disabled=0;
1363    opus_val16 surround_masking=0;
1364    opus_val16 temporal_vbr=0;
1365    opus_val16 surround_trim = 0;
1366    opus_int32 equiv_rate = 510000;
1367    VARDECL(opus_val16, surround_dynalloc);
1368    ALLOC_STACK;
1369
1370    mode = st->mode;
1371    nbEBands = mode->nbEBands;
1372    overlap = mode->overlap;
1373    eBands = mode->eBands;
1374    start = st->start;
1375    end = st->end;
1376    tf_estimate = 0;
1377    if (nbCompressedBytes<2 || pcm==NULL)
1378    {
1379       RESTORE_STACK;
1380       return OPUS_BAD_ARG;
1381    }
1382
1383    frame_size *= st->upsample;
1384    for (LM=0;LM<=mode->maxLM;LM++)
1385       if (mode->shortMdctSize<<LM==frame_size)
1386          break;
1387    if (LM>mode->maxLM)
1388    {
1389       RESTORE_STACK;
1390       return OPUS_BAD_ARG;
1391    }
1392    M=1<<LM;
1393    N = M*mode->shortMdctSize;
1394
1395    prefilter_mem = st->in_mem+CC*(overlap);
1396    oldBandE = (opus_val16*)(st->in_mem+CC*(overlap+COMBFILTER_MAXPERIOD));
1397    oldLogE = oldBandE + CC*nbEBands;
1398    oldLogE2 = oldLogE + CC*nbEBands;
1399
1400    if (enc==NULL)
1401    {
1402       tell=1;
1403       nbFilledBytes=0;
1404    } else {
1405       tell=ec_tell(enc);
1406       nbFilledBytes=(tell+4)>>3;
1407    }
1408
1409 #ifdef CUSTOM_MODES
1410    if (st->signalling && enc==NULL)
1411    {
1412       int tmp = (mode->effEBands-end)>>1;
1413       end = st->end = IMAX(1, mode->effEBands-tmp);
1414       compressed[0] = tmp<<5;
1415       compressed[0] |= LM<<3;
1416       compressed[0] |= (C==2)<<2;
1417       /* Convert "standard mode" to Opus header */
1418       if (mode->Fs==48000 && mode->shortMdctSize==120)
1419       {
1420          int c0 = toOpus(compressed[0]);
1421          if (c0<0)
1422          {
1423             RESTORE_STACK;
1424             return OPUS_BAD_ARG;
1425          }
1426          compressed[0] = c0;
1427       }
1428       compressed++;
1429       nbCompressedBytes--;
1430    }
1431 #else
1432    celt_assert(st->signalling==0);
1433 #endif
1434
1435    /* Can't produce more than 1275 output bytes */
1436    nbCompressedBytes = IMIN(nbCompressedBytes,1275);
1437    nbAvailableBytes = nbCompressedBytes - nbFilledBytes;
1438
1439    if (st->vbr && st->bitrate!=OPUS_BITRATE_MAX)
1440    {
1441       opus_int32 den=mode->Fs>>BITRES;
1442       vbr_rate=(st->bitrate*frame_size+(den>>1))/den;
1443 #ifdef CUSTOM_MODES
1444       if (st->signalling)
1445          vbr_rate -= 8<<BITRES;
1446 #endif
1447       effectiveBytes = vbr_rate>>(3+BITRES);
1448    } else {
1449       opus_int32 tmp;
1450       vbr_rate = 0;
1451       tmp = st->bitrate*frame_size;
1452       if (tell>1)
1453          tmp += tell;
1454       if (st->bitrate!=OPUS_BITRATE_MAX)
1455          nbCompressedBytes = IMAX(2, IMIN(nbCompressedBytes,
1456                (tmp+4*mode->Fs)/(8*mode->Fs)-!!st->signalling));
1457       effectiveBytes = nbCompressedBytes;
1458    }
1459    if (st->bitrate != OPUS_BITRATE_MAX)
1460       equiv_rate = st->bitrate - (40*C+20)*((400>>LM) - 50);
1461
1462    if (enc==NULL)
1463    {
1464       ec_enc_init(&_enc, compressed, nbCompressedBytes);
1465       enc = &_enc;
1466    }
1467
1468    if (vbr_rate>0)
1469    {
1470       /* Computes the max bit-rate allowed in VBR mode to avoid violating the
1471           target rate and buffering.
1472          We must do this up front so that bust-prevention logic triggers
1473           correctly if we don't have enough bits. */
1474       if (st->constrained_vbr)
1475       {
1476          opus_int32 vbr_bound;
1477          opus_int32 max_allowed;
1478          /* We could use any multiple of vbr_rate as bound (depending on the
1479              delay).
1480             This is clamped to ensure we use at least two bytes if the encoder
1481              was entirely empty, but to allow 0 in hybrid mode. */
1482          vbr_bound = vbr_rate;
1483          max_allowed = IMIN(IMAX(tell==1?2:0,
1484                (vbr_rate+vbr_bound-st->vbr_reservoir)>>(BITRES+3)),
1485                nbAvailableBytes);
1486          if(max_allowed < nbAvailableBytes)
1487          {
1488             nbCompressedBytes = nbFilledBytes+max_allowed;
1489             nbAvailableBytes = max_allowed;
1490             ec_enc_shrink(enc, nbCompressedBytes);
1491          }
1492       }
1493    }
1494    total_bits = nbCompressedBytes*8;
1495
1496    effEnd = end;
1497    if (effEnd > mode->effEBands)
1498       effEnd = mode->effEBands;
1499
1500    ALLOC(in, CC*(N+overlap), celt_sig);
1501
1502    sample_max=MAX32(st->overlap_max, celt_maxabs16(pcm, C*(N-overlap)/st->upsample));
1503    st->overlap_max=celt_maxabs16(pcm+C*(N-overlap)/st->upsample, C*overlap/st->upsample);
1504    sample_max=MAX32(sample_max, st->overlap_max);
1505 #ifdef FIXED_POINT
1506    silence = (sample_max==0);
1507 #else
1508    silence = (sample_max <= (opus_val16)1/(1<<st->lsb_depth));
1509 #endif
1510 #ifdef FUZZING
1511    if ((rand()&0x3F)==0)
1512       silence = 1;
1513 #endif
1514    if (tell==1)
1515       ec_enc_bit_logp(enc, silence, 15);
1516    else
1517       silence=0;
1518    if (silence)
1519    {
1520       /*In VBR mode there is no need to send more than the minimum. */
1521       if (vbr_rate>0)
1522       {
1523          effectiveBytes=nbCompressedBytes=IMIN(nbCompressedBytes, nbFilledBytes+2);
1524          total_bits=nbCompressedBytes*8;
1525          nbAvailableBytes=2;
1526          ec_enc_shrink(enc, nbCompressedBytes);
1527       }
1528       /* Pretend we've filled all the remaining bits with zeros
1529             (that's what the initialiser did anyway) */
1530       tell = nbCompressedBytes*8;
1531       enc->nbits_total+=tell-ec_tell(enc);
1532    }
1533    c=0; do {
1534       int need_clip=0;
1535 #ifndef FIXED_POINT
1536       need_clip = st->clip && sample_max>65536.f;
1537 #endif
1538       celt_preemphasis(pcm+c, in+c*(N+overlap)+overlap, N, CC, st->upsample,
1539                   mode->preemph, st->preemph_memE+c, need_clip);
1540    } while (++c<CC);
1541
1542
1543
1544    /* Find pitch period and gain */
1545    {
1546       int enabled;
1547       int qg;
1548       enabled = ((st->lfe&&nbAvailableBytes>3) || nbAvailableBytes>12*C) && start==0 && !silence && !st->disable_pf
1549             && st->complexity >= 5 && !(st->consec_transient && LM!=3 && st->variable_duration==OPUS_FRAMESIZE_VARIABLE);
1550
1551       prefilter_tapset = st->tapset_decision;
1552       pf_on = run_prefilter(st, in, prefilter_mem, CC, N, prefilter_tapset, &pitch_index, &gain1, &qg, enabled, nbAvailableBytes);
1553       if ((gain1 > QCONST16(.4f,15) || st->prefilter_gain > QCONST16(.4f,15)) && (!st->analysis.valid || st->analysis.tonality > .3)
1554             && (pitch_index > 1.26*st->prefilter_period || pitch_index < .79*st->prefilter_period))
1555          pitch_change = 1;
1556       if (pf_on==0)
1557       {
1558          if(start==0 && tell+16<=total_bits)
1559             ec_enc_bit_logp(enc, 0, 1);
1560       } else {
1561          /*This block is not gated by a total bits check only because
1562            of the nbAvailableBytes check above.*/
1563          int octave;
1564          ec_enc_bit_logp(enc, 1, 1);
1565          pitch_index += 1;
1566          octave = EC_ILOG(pitch_index)-5;
1567          ec_enc_uint(enc, octave, 6);
1568          ec_enc_bits(enc, pitch_index-(16<<octave), 4+octave);
1569          pitch_index -= 1;
1570          ec_enc_bits(enc, qg, 3);
1571          ec_enc_icdf(enc, prefilter_tapset, tapset_icdf, 2);
1572       }
1573    }
1574
1575    isTransient = 0;
1576    shortBlocks = 0;
1577    if (st->complexity >= 1 && !st->lfe)
1578    {
1579       isTransient = transient_analysis(in, N+overlap, CC,
1580             &tf_estimate, &tf_chan);
1581    }
1582    if (LM>0 && ec_tell(enc)+3<=total_bits)
1583    {
1584       if (isTransient)
1585          shortBlocks = M;
1586    } else {
1587       isTransient = 0;
1588       transient_got_disabled=1;
1589    }
1590
1591    ALLOC(freq, CC*N, celt_sig); /**< Interleaved signal MDCTs */
1592    ALLOC(bandE,nbEBands*CC, celt_ener);
1593    ALLOC(bandLogE,nbEBands*CC, opus_val16);
1594
1595    secondMdct = shortBlocks && st->complexity>=8;
1596    ALLOC(bandLogE2, C*nbEBands, opus_val16);
1597    if (secondMdct)
1598    {
1599       compute_mdcts(mode, 0, in, freq, C, CC, LM, st->upsample);
1600       compute_band_energies(mode, freq, bandE, effEnd, C, LM);
1601       amp2Log2(mode, effEnd, end, bandE, bandLogE2, C);
1602       for (i=0;i<C*nbEBands;i++)
1603          bandLogE2[i] += HALF16(SHL16(LM, DB_SHIFT));
1604    }
1605
1606    compute_mdcts(mode, shortBlocks, in, freq, C, CC, LM, st->upsample);
1607    if (CC==2&&C==1)
1608       tf_chan = 0;
1609    compute_band_energies(mode, freq, bandE, effEnd, C, LM);
1610
1611    if (st->lfe)
1612    {
1613       for (i=2;i<end;i++)
1614       {
1615          bandE[i] = IMIN(bandE[i], MULT16_32_Q15(QCONST16(1e-4f,15),bandE[0]));
1616          bandE[i] = MAX32(bandE[i], EPSILON);
1617       }
1618    }
1619    amp2Log2(mode, effEnd, end, bandE, bandLogE, C);
1620
1621    ALLOC(surround_dynalloc, C*nbEBands, opus_val16);
1622    OPUS_CLEAR(surround_dynalloc, end);
1623    /* This computes how much masking takes place between surround channels */
1624    if (start==0&&st->energy_mask&&!st->lfe)
1625    {
1626       int mask_end;
1627       int midband;
1628       int count_dynalloc;
1629       opus_val32 mask_avg=0;
1630       opus_val32 diff=0;
1631       int count=0;
1632       mask_end = IMAX(2,st->lastCodedBands);
1633       for (c=0;c<C;c++)
1634       {
1635          for(i=0;i<mask_end;i++)
1636          {
1637             opus_val16 mask;
1638             mask = MAX16(MIN16(st->energy_mask[nbEBands*c+i],
1639                    QCONST16(.25f, DB_SHIFT)), -QCONST16(2.0f, DB_SHIFT));
1640             if (mask > 0)
1641                mask = HALF16(mask);
1642             mask_avg += MULT16_16(mask, eBands[i+1]-eBands[i]);
1643             count += eBands[i+1]-eBands[i];
1644             diff += MULT16_16(mask, 1+2*i-mask_end);
1645          }
1646       }
1647       mask_avg = DIV32_16(mask_avg,count);
1648       mask_avg += QCONST16(.2f, DB_SHIFT);
1649       diff = diff*6/(C*(mask_end-1)*(mask_end+1)*mask_end);
1650       /* Again, being conservative */
1651       diff = HALF32(diff);
1652       diff = MAX32(MIN32(diff, QCONST32(.031f, DB_SHIFT)), -QCONST32(.031f, DB_SHIFT));
1653       /* Find the band that's in the middle of the coded spectrum */
1654       for (midband=0;eBands[midband+1] < eBands[mask_end]/2;midband++);
1655       count_dynalloc=0;
1656       for(i=0;i<mask_end;i++)
1657       {
1658          opus_val32 lin;
1659          opus_val16 unmask;
1660          lin = mask_avg + diff*(i-midband);
1661          if (C==2)
1662             unmask = MAX16(st->energy_mask[i], st->energy_mask[nbEBands+i]);
1663          else
1664             unmask = st->energy_mask[i];
1665          unmask = MIN16(unmask, QCONST16(.0f, DB_SHIFT));
1666          unmask -= lin;
1667          if (unmask > QCONST16(.25f, DB_SHIFT))
1668          {
1669             surround_dynalloc[i] = unmask - QCONST16(.25f, DB_SHIFT);
1670             count_dynalloc++;
1671          }
1672       }
1673       if (count_dynalloc>=3)
1674       {
1675          /* If we need dynalloc in many bands, it's probably because our
1676             initial masking rate was too low. */
1677          mask_avg += QCONST16(.25f, DB_SHIFT);
1678          if (mask_avg>0)
1679          {
1680             /* Something went really wrong in the original calculations,
1681                disabling masking. */
1682             mask_avg = 0;
1683             diff = 0;
1684             OPUS_CLEAR(surround_dynalloc, mask_end);
1685          } else {
1686             for(i=0;i<mask_end;i++)
1687                surround_dynalloc[i] = MAX16(0, surround_dynalloc[i]-QCONST16(.25f, DB_SHIFT));
1688          }
1689       }
1690       mask_avg += QCONST16(.2f, DB_SHIFT);
1691       /* Convert to 1/64th units used for the trim */
1692       surround_trim = 64*diff;
1693       /*printf("%d %d ", mask_avg, surround_trim);*/
1694       surround_masking = mask_avg;
1695    }
1696    /* Temporal VBR (but not for LFE) */
1697    if (!st->lfe)
1698    {
1699       opus_val16 follow=-QCONST16(10.0f,DB_SHIFT);
1700       opus_val32 frame_avg=0;
1701       opus_val16 offset = shortBlocks?HALF16(SHL16(LM, DB_SHIFT)):0;
1702       for(i=start;i<end;i++)
1703       {
1704          follow = MAX16(follow-QCONST16(1.f, DB_SHIFT), bandLogE[i]-offset);
1705          if (C==2)
1706             follow = MAX16(follow, bandLogE[i+nbEBands]-offset);
1707          frame_avg += follow;
1708       }
1709       frame_avg /= (end-start);
1710       temporal_vbr = SUB16(frame_avg,st->spec_avg);
1711       temporal_vbr = MIN16(QCONST16(3.f, DB_SHIFT), MAX16(-QCONST16(1.5f, DB_SHIFT), temporal_vbr));
1712       st->spec_avg += MULT16_16_Q15(QCONST16(.02f, 15), temporal_vbr);
1713    }
1714    /*for (i=0;i<21;i++)
1715       printf("%f ", bandLogE[i]);
1716    printf("\n");*/
1717
1718    if (!secondMdct)
1719    {
1720       OPUS_COPY(bandLogE2, bandLogE, C*nbEBands);
1721    }
1722
1723    /* Last chance to catch any transient we might have missed in the
1724       time-domain analysis */
1725    if (LM>0 && ec_tell(enc)+3<=total_bits && !isTransient && st->complexity>=5 && !st->lfe)
1726    {
1727       if (patch_transient_decision(bandLogE, oldBandE, nbEBands, end, C))
1728       {
1729          isTransient = 1;
1730          shortBlocks = M;
1731          compute_mdcts(mode, shortBlocks, in, freq, C, CC, LM, st->upsample);
1732          compute_band_energies(mode, freq, bandE, effEnd, C, LM);
1733          amp2Log2(mode, effEnd, end, bandE, bandLogE, C);
1734          /* Compensate for the scaling of short vs long mdcts */
1735          for (i=0;i<C*nbEBands;i++)
1736             bandLogE2[i] += HALF16(SHL16(LM, DB_SHIFT));
1737          tf_estimate = QCONST16(.2f,14);
1738       }
1739    }
1740
1741    if (LM>0 && ec_tell(enc)+3<=total_bits)
1742       ec_enc_bit_logp(enc, isTransient, 3);
1743
1744    ALLOC(X, C*N, celt_norm);         /**< Interleaved normalised MDCTs */
1745
1746    /* Band normalisation */
1747    normalise_bands(mode, freq, X, bandE, effEnd, C, M);
1748
1749    ALLOC(tf_res, nbEBands, int);
1750    /* Disable variable tf resolution for hybrid and at very low bitrate */
1751    if (effectiveBytes>=15*C && start==0 && st->complexity>=2 && !st->lfe)
1752    {
1753       int lambda;
1754       if (effectiveBytes<40)
1755          lambda = 12;
1756       else if (effectiveBytes<60)
1757          lambda = 6;
1758       else if (effectiveBytes<100)
1759          lambda = 4;
1760       else
1761          lambda = 3;
1762       lambda*=2;
1763       tf_select = tf_analysis(mode, effEnd, isTransient, tf_res, lambda, X, N, LM, &tf_sum, tf_estimate, tf_chan);
1764       for (i=effEnd;i<end;i++)
1765          tf_res[i] = tf_res[effEnd-1];
1766    } else {
1767       tf_sum = 0;
1768       for (i=0;i<end;i++)
1769          tf_res[i] = isTransient;
1770       tf_select=0;
1771    }
1772
1773    ALLOC(error, C*nbEBands, opus_val16);
1774    quant_coarse_energy(mode, start, end, effEnd, bandLogE,
1775          oldBandE, total_bits, error, enc,
1776          C, LM, nbAvailableBytes, st->force_intra,
1777          &st->delayedIntra, st->complexity >= 4, st->loss_rate, st->lfe);
1778
1779    tf_encode(start, end, isTransient, tf_res, LM, tf_select, enc);
1780
1781    if (ec_tell(enc)+4<=total_bits)
1782    {
1783       if (st->lfe)
1784       {
1785          st->tapset_decision = 0;
1786          st->spread_decision = SPREAD_NORMAL;
1787       } else if (shortBlocks || st->complexity < 3 || nbAvailableBytes < 10*C || start != 0)
1788       {
1789          if (st->complexity == 0)
1790             st->spread_decision = SPREAD_NONE;
1791          else
1792             st->spread_decision = SPREAD_NORMAL;
1793       } else {
1794          /* Disable new spreading+tapset estimator until we can show it works
1795             better than the old one. So far it seems like spreading_decision()
1796             works best. */
1797 #if 0
1798          if (st->analysis.valid)
1799          {
1800             static const opus_val16 spread_thresholds[3] = {-QCONST16(.6f, 15), -QCONST16(.2f, 15), -QCONST16(.07f, 15)};
1801             static const opus_val16 spread_histeresis[3] = {QCONST16(.15f, 15), QCONST16(.07f, 15), QCONST16(.02f, 15)};
1802             static const opus_val16 tapset_thresholds[2] = {QCONST16(.0f, 15), QCONST16(.15f, 15)};
1803             static const opus_val16 tapset_histeresis[2] = {QCONST16(.1f, 15), QCONST16(.05f, 15)};
1804             st->spread_decision = hysteresis_decision(-st->analysis.tonality, spread_thresholds, spread_histeresis, 3, st->spread_decision);
1805             st->tapset_decision = hysteresis_decision(st->analysis.tonality_slope, tapset_thresholds, tapset_histeresis, 2, st->tapset_decision);
1806          } else
1807 #endif
1808          {
1809             st->spread_decision = spreading_decision(mode, X,
1810                   &st->tonal_average, st->spread_decision, &st->hf_average,
1811                   &st->tapset_decision, pf_on&&!shortBlocks, effEnd, C, M);
1812          }
1813          /*printf("%d %d\n", st->tapset_decision, st->spread_decision);*/
1814          /*printf("%f %d %f %d\n\n", st->analysis.tonality, st->spread_decision, st->analysis.tonality_slope, st->tapset_decision);*/
1815       }
1816       ec_enc_icdf(enc, st->spread_decision, spread_icdf, 5);
1817    }
1818
1819    ALLOC(offsets, nbEBands, int);
1820
1821    maxDepth = dynalloc_analysis(bandLogE, bandLogE2, nbEBands, start, end, C, offsets,
1822          st->lsb_depth, mode->logN, isTransient, st->vbr, st->constrained_vbr,
1823          eBands, LM, effectiveBytes, &tot_boost, st->lfe, surround_dynalloc);
1824    /* For LFE, everything interesting is in the first band */
1825    if (st->lfe)
1826       offsets[0] = IMIN(8, effectiveBytes/3);
1827    ALLOC(cap, nbEBands, int);
1828    init_caps(mode,cap,LM,C);
1829
1830    dynalloc_logp = 6;
1831    total_bits<<=BITRES;
1832    total_boost = 0;
1833    tell = ec_tell_frac(enc);
1834    for (i=start;i<end;i++)
1835    {
1836       int width, quanta;
1837       int dynalloc_loop_logp;
1838       int boost;
1839       int j;
1840       width = C*(eBands[i+1]-eBands[i])<<LM;
1841       /* quanta is 6 bits, but no more than 1 bit/sample
1842          and no less than 1/8 bit/sample */
1843       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
1844       dynalloc_loop_logp = dynalloc_logp;
1845       boost = 0;
1846       for (j = 0; tell+(dynalloc_loop_logp<<BITRES) < total_bits-total_boost
1847             && boost < cap[i]; j++)
1848       {
1849          int flag;
1850          flag = j<offsets[i];
1851          ec_enc_bit_logp(enc, flag, dynalloc_loop_logp);
1852          tell = ec_tell_frac(enc);
1853          if (!flag)
1854             break;
1855          boost += quanta;
1856          total_boost += quanta;
1857          dynalloc_loop_logp = 1;
1858       }
1859       /* Making dynalloc more likely */
1860       if (j)
1861          dynalloc_logp = IMAX(2, dynalloc_logp-1);
1862       offsets[i] = boost;
1863    }
1864
1865    if (C==2)
1866    {
1867       static const opus_val16 intensity_thresholds[21]=
1868       /* 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19  20  off*/
1869         {  1, 2, 3, 4, 5, 6, 7, 8,16,24,36,44,50,56,62,67,72,79,88,106,134};
1870       static const opus_val16 intensity_histeresis[21]=
1871         {  1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 4, 5, 6,  8, 8};
1872
1873       /* Always use MS for 2.5 ms frames until we can do a better analysis */
1874       if (LM!=0)
1875          dual_stereo = stereo_analysis(mode, X, LM, N);
1876
1877       st->intensity = hysteresis_decision((opus_val16)(equiv_rate/1000),
1878             intensity_thresholds, intensity_histeresis, 21, st->intensity);
1879       st->intensity = IMIN(end,IMAX(start, st->intensity));
1880    }
1881
1882    alloc_trim = 5;
1883    if (tell+(6<<BITRES) <= total_bits - total_boost)
1884    {
1885       if (st->lfe)
1886          alloc_trim = 5;
1887       else
1888          alloc_trim = alloc_trim_analysis(mode, X, bandLogE,
1889             end, LM, C, N, &st->analysis, &st->stereo_saving, tf_estimate, st->intensity, surround_trim);
1890       ec_enc_icdf(enc, alloc_trim, trim_icdf, 7);
1891       tell = ec_tell_frac(enc);
1892    }
1893
1894    /* Variable bitrate */
1895    if (vbr_rate>0)
1896    {
1897      opus_val16 alpha;
1898      opus_int32 delta;
1899      /* The target rate in 8th bits per frame */
1900      opus_int32 target, base_target;
1901      opus_int32 min_allowed;
1902      int lm_diff = mode->maxLM - LM;
1903
1904      /* Don't attempt to use more than 510 kb/s, even for frames smaller than 20 ms.
1905         The CELT allocator will just not be able to use more than that anyway. */
1906      nbCompressedBytes = IMIN(nbCompressedBytes,1275>>(3-LM));
1907      base_target = vbr_rate - ((40*C+20)<<BITRES);
1908
1909      if (st->constrained_vbr)
1910         base_target += (st->vbr_offset>>lm_diff);
1911
1912      target = compute_vbr(mode, &st->analysis, base_target, LM, equiv_rate,
1913            st->lastCodedBands, C, st->intensity, st->constrained_vbr,
1914            st->stereo_saving, tot_boost, tf_estimate, pitch_change, maxDepth,
1915            st->variable_duration, st->lfe, st->energy_mask!=NULL, surround_masking,
1916            temporal_vbr);
1917
1918      /* The current offset is removed from the target and the space used
1919         so far is added*/
1920      target=target+tell;
1921      /* In VBR mode the frame size must not be reduced so much that it would
1922          result in the encoder running out of bits.
1923         The margin of 2 bytes ensures that none of the bust-prevention logic
1924          in the decoder will have triggered so far. */
1925      min_allowed = ((tell+total_boost+(1<<(BITRES+3))-1)>>(BITRES+3)) + 2 - nbFilledBytes;
1926
1927      nbAvailableBytes = (target+(1<<(BITRES+2)))>>(BITRES+3);
1928      nbAvailableBytes = IMAX(min_allowed,nbAvailableBytes);
1929      nbAvailableBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes) - nbFilledBytes;
1930
1931      /* By how much did we "miss" the target on that frame */
1932      delta = target - vbr_rate;
1933
1934      target=nbAvailableBytes<<(BITRES+3);
1935
1936      /*If the frame is silent we don't adjust our drift, otherwise
1937        the encoder will shoot to very high rates after hitting a
1938        span of silence, but we do allow the bitres to refill.
1939        This means that we'll undershoot our target in CVBR/VBR modes
1940        on files with lots of silence. */
1941      if(silence)
1942      {
1943        nbAvailableBytes = 2;
1944        target = 2*8<<BITRES;
1945        delta = 0;
1946      }
1947
1948      if (st->vbr_count < 970)
1949      {
1950         st->vbr_count++;
1951         alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+20),16));
1952      } else
1953         alpha = QCONST16(.001f,15);
1954      /* How many bits have we used in excess of what we're allowed */
1955      if (st->constrained_vbr)
1956         st->vbr_reservoir += target - vbr_rate;
1957      /*printf ("%d\n", st->vbr_reservoir);*/
1958
1959      /* Compute the offset we need to apply in order to reach the target */
1960      if (st->constrained_vbr)
1961      {
1962         st->vbr_drift += (opus_int32)MULT16_32_Q15(alpha,(delta*(1<<lm_diff))-st->vbr_offset-st->vbr_drift);
1963         st->vbr_offset = -st->vbr_drift;
1964      }
1965      /*printf ("%d\n", st->vbr_drift);*/
1966
1967      if (st->constrained_vbr && st->vbr_reservoir < 0)
1968      {
1969         /* We're under the min value -- increase rate */
1970         int adjust = (-st->vbr_reservoir)/(8<<BITRES);
1971         /* Unless we're just coding silence */
1972         nbAvailableBytes += silence?0:adjust;
1973         st->vbr_reservoir = 0;
1974         /*printf ("+%d\n", adjust);*/
1975      }
1976      nbCompressedBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes);
1977      /*printf("%d\n", nbCompressedBytes*50*8);*/
1978      /* This moves the raw bits to take into account the new compressed size */
1979      ec_enc_shrink(enc, nbCompressedBytes);
1980    }
1981
1982    /* Bit allocation */
1983    ALLOC(fine_quant, nbEBands, int);
1984    ALLOC(pulses, nbEBands, int);
1985    ALLOC(fine_priority, nbEBands, int);
1986
1987    /* bits =           packet size                    - where we are - safety*/
1988    bits = (((opus_int32)nbCompressedBytes*8)<<BITRES) - ec_tell_frac(enc) - 1;
1989    anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0;
1990    bits -= anti_collapse_rsv;
1991    signalBandwidth = end-1;
1992 #ifndef DISABLE_FLOAT_API
1993    if (st->analysis.valid)
1994    {
1995       int min_bandwidth;
1996       if (equiv_rate < (opus_int32)32000*C)
1997          min_bandwidth = 13;
1998       else if (equiv_rate < (opus_int32)48000*C)
1999          min_bandwidth = 16;
2000       else if (equiv_rate < (opus_int32)60000*C)
2001          min_bandwidth = 18;
2002       else  if (equiv_rate < (opus_int32)80000*C)
2003          min_bandwidth = 19;
2004       else
2005          min_bandwidth = 20;
2006       signalBandwidth = IMAX(st->analysis.bandwidth, min_bandwidth);
2007    }
2008 #endif
2009    if (st->lfe)
2010       signalBandwidth = 1;
2011    codedBands = compute_allocation(mode, start, end, offsets, cap,
2012          alloc_trim, &st->intensity, &dual_stereo, bits, &balance, pulses,
2013          fine_quant, fine_priority, C, LM, enc, 1, st->lastCodedBands, signalBandwidth);
2014    if (st->lastCodedBands)
2015       st->lastCodedBands = IMIN(st->lastCodedBands+1,IMAX(st->lastCodedBands-1,codedBands));
2016    else
2017       st->lastCodedBands = codedBands;
2018
2019    quant_fine_energy(mode, start, end, oldBandE, error, fine_quant, enc, C);
2020
2021    /* Residual quantisation */
2022    ALLOC(collapse_masks, C*nbEBands, unsigned char);
2023    quant_all_bands(1, mode, start, end, X, C==2 ? X+N : NULL, collapse_masks,
2024          bandE, pulses, shortBlocks, st->spread_decision, dual_stereo, st->intensity, tf_res,
2025          nbCompressedBytes*(8<<BITRES)-anti_collapse_rsv, balance, enc, LM, codedBands, &st->rng);
2026
2027    if (anti_collapse_rsv > 0)
2028    {
2029       anti_collapse_on = st->consec_transient<2;
2030 #ifdef FUZZING
2031       anti_collapse_on = rand()&0x1;
2032 #endif
2033       ec_enc_bits(enc, anti_collapse_on, 1);
2034    }
2035    quant_energy_finalise(mode, start, end, oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_tell(enc), enc, C);
2036
2037    if (silence)
2038    {
2039       for (i=0;i<C*nbEBands;i++)
2040          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
2041    }
2042
2043 #ifdef RESYNTH
2044    /* Re-synthesis of the coded audio if required */
2045    {
2046       celt_sig *out_mem[2];
2047
2048       if (anti_collapse_on)
2049       {
2050          anti_collapse(mode, X, collapse_masks, LM, C, N,
2051                start, end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
2052       }
2053
2054       c=0; do {
2055          OPUS_MOVE(st->syn_mem[c], st->syn_mem[c]+N, 2*MAX_PERIOD-N+overlap/2);
2056       } while (++c<CC);
2057
2058       c=0; do {
2059          out_mem[c] = st->syn_mem[c]+2*MAX_PERIOD-N;
2060       } while (++c<CC);
2061
2062       celt_synthesis(mode, X, out_mem, oldBandE, start, effEnd, C, CC, isTransient, LM, st->upsample, silence);
2063
2064       c=0; do {
2065          st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
2066          st->prefilter_period_old=IMAX(st->prefilter_period_old, COMBFILTER_MINPERIOD);
2067          comb_filter(out_mem[c], out_mem[c], st->prefilter_period_old, st->prefilter_period, mode->shortMdctSize,
2068                st->prefilter_gain_old, st->prefilter_gain, st->prefilter_tapset_old, st->prefilter_tapset,
2069                mode->window, overlap);
2070          if (LM!=0)
2071             comb_filter(out_mem[c]+mode->shortMdctSize, out_mem[c]+mode->shortMdctSize, st->prefilter_period, pitch_index, N-mode->shortMdctSize,
2072                   st->prefilter_gain, gain1, st->prefilter_tapset, prefilter_tapset,
2073                   mode->window, overlap);
2074       } while (++c<CC);
2075
2076       /* We reuse freq[] as scratch space for the de-emphasis */
2077       deemphasis(out_mem, (opus_val16*)pcm, N, CC, st->upsample, mode->preemph, st->preemph_memD);
2078       st->prefilter_period_old = st->prefilter_period;
2079       st->prefilter_gain_old = st->prefilter_gain;
2080       st->prefilter_tapset_old = st->prefilter_tapset;
2081    }
2082 #endif
2083
2084    st->prefilter_period = pitch_index;
2085    st->prefilter_gain = gain1;
2086    st->prefilter_tapset = prefilter_tapset;
2087 #ifdef RESYNTH
2088    if (LM!=0)
2089    {
2090       st->prefilter_period_old = st->prefilter_period;
2091       st->prefilter_gain_old = st->prefilter_gain;
2092       st->prefilter_tapset_old = st->prefilter_tapset;
2093    }
2094 #endif
2095
2096    if (CC==2&&C==1) {
2097       OPUS_COPY(&oldBandE[nbEBands], oldBandE, nbEBands);
2098    }
2099
2100    if (!isTransient)
2101    {
2102       OPUS_COPY(oldLogE2, oldLogE, CC*nbEBands);
2103       OPUS_COPY(oldLogE, oldBandE, CC*nbEBands);
2104    } else {
2105       for (i=0;i<CC*nbEBands;i++)
2106          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
2107    }
2108    /* In case start or end were to change */
2109    c=0; do
2110    {
2111       for (i=0;i<start;i++)
2112       {
2113          oldBandE[c*nbEBands+i]=0;
2114          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
2115       }
2116       for (i=end;i<nbEBands;i++)
2117       {
2118          oldBandE[c*nbEBands+i]=0;
2119          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
2120       }
2121    } while (++c<CC);
2122
2123    if (isTransient || transient_got_disabled)
2124       st->consec_transient++;
2125    else
2126       st->consec_transient=0;
2127    st->rng = enc->rng;
2128
2129    /* If there's any room left (can only happen for very high rates),
2130       it's already filled with zeros */
2131    ec_enc_done(enc);
2132
2133 #ifdef CUSTOM_MODES
2134    if (st->signalling)
2135       nbCompressedBytes++;
2136 #endif
2137
2138    RESTORE_STACK;
2139    if (ec_get_error(enc))
2140       return OPUS_INTERNAL_ERROR;
2141    else
2142       return nbCompressedBytes;
2143 }
2144
2145
2146 #ifdef CUSTOM_MODES
2147
2148 #ifdef FIXED_POINT
2149 int opus_custom_encode(CELTEncoder * OPUS_RESTRICT st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2150 {
2151    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
2152 }
2153
2154 #ifndef DISABLE_FLOAT_API
2155 int opus_custom_encode_float(CELTEncoder * OPUS_RESTRICT st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2156 {
2157    int j, ret, C, N;
2158    VARDECL(opus_int16, in);
2159    ALLOC_STACK;
2160
2161    if (pcm==NULL)
2162       return OPUS_BAD_ARG;
2163
2164    C = st->channels;
2165    N = frame_size;
2166    ALLOC(in, C*N, opus_int16);
2167
2168    for (j=0;j<C*N;j++)
2169      in[j] = FLOAT2INT16(pcm[j]);
2170
2171    ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
2172 #ifdef RESYNTH
2173    for (j=0;j<C*N;j++)
2174       ((float*)pcm)[j]=in[j]*(1.f/32768.f);
2175 #endif
2176    RESTORE_STACK;
2177    return ret;
2178 }
2179 #endif /* DISABLE_FLOAT_API */
2180 #else
2181
2182 int opus_custom_encode(CELTEncoder * OPUS_RESTRICT st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2183 {
2184    int j, ret, C, N;
2185    VARDECL(celt_sig, in);
2186    ALLOC_STACK;
2187
2188    if (pcm==NULL)
2189       return OPUS_BAD_ARG;
2190
2191    C=st->channels;
2192    N=frame_size;
2193    ALLOC(in, C*N, celt_sig);
2194    for (j=0;j<C*N;j++) {
2195      in[j] = SCALEOUT(pcm[j]);
2196    }
2197
2198    ret = celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
2199 #ifdef RESYNTH
2200    for (j=0;j<C*N;j++)
2201       ((opus_int16*)pcm)[j] = FLOAT2INT16(in[j]);
2202 #endif
2203    RESTORE_STACK;
2204    return ret;
2205 }
2206
2207 int opus_custom_encode_float(CELTEncoder * OPUS_RESTRICT st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2208 {
2209    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
2210 }
2211
2212 #endif
2213
2214 #endif /* CUSTOM_MODES */
2215
2216 int opus_custom_encoder_ctl(CELTEncoder * OPUS_RESTRICT st, int request, ...)
2217 {
2218    va_list ap;
2219
2220    va_start(ap, request);
2221    switch (request)
2222    {
2223       case OPUS_SET_COMPLEXITY_REQUEST:
2224       {
2225          int value = va_arg(ap, opus_int32);
2226          if (value<0 || value>10)
2227             goto bad_arg;
2228          st->complexity = value;
2229       }
2230       break;
2231       case CELT_SET_START_BAND_REQUEST:
2232       {
2233          opus_int32 value = va_arg(ap, opus_int32);
2234          if (value<0 || value>=st->mode->nbEBands)
2235             goto bad_arg;
2236          st->start = value;
2237       }
2238       break;
2239       case CELT_SET_END_BAND_REQUEST:
2240       {
2241          opus_int32 value = va_arg(ap, opus_int32);
2242          if (value<1 || value>st->mode->nbEBands)
2243             goto bad_arg;
2244          st->end = value;
2245       }
2246       break;
2247       case CELT_SET_PREDICTION_REQUEST:
2248       {
2249          int value = va_arg(ap, opus_int32);
2250          if (value<0 || value>2)
2251             goto bad_arg;
2252          st->disable_pf = value<=1;
2253          st->force_intra = value==0;
2254       }
2255       break;
2256       case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2257       {
2258          int value = va_arg(ap, opus_int32);
2259          if (value<0 || value>100)
2260             goto bad_arg;
2261          st->loss_rate = value;
2262       }
2263       break;
2264       case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2265       {
2266          opus_int32 value = va_arg(ap, opus_int32);
2267          st->constrained_vbr = value;
2268       }
2269       break;
2270       case OPUS_SET_VBR_REQUEST:
2271       {
2272          opus_int32 value = va_arg(ap, opus_int32);
2273          st->vbr = value;
2274       }
2275       break;
2276       case OPUS_SET_BITRATE_REQUEST:
2277       {
2278          opus_int32 value = va_arg(ap, opus_int32);
2279          if (value<=500 && value!=OPUS_BITRATE_MAX)
2280             goto bad_arg;
2281          value = IMIN(value, 260000*st->channels);
2282          st->bitrate = value;
2283       }
2284       break;
2285       case CELT_SET_CHANNELS_REQUEST:
2286       {
2287          opus_int32 value = va_arg(ap, opus_int32);
2288          if (value<1 || value>2)
2289             goto bad_arg;
2290          st->stream_channels = value;
2291       }
2292       break;
2293       case OPUS_SET_LSB_DEPTH_REQUEST:
2294       {
2295           opus_int32 value = va_arg(ap, opus_int32);
2296           if (value<8 || value>24)
2297              goto bad_arg;
2298           st->lsb_depth=value;
2299       }
2300       break;
2301       case OPUS_GET_LSB_DEPTH_REQUEST:
2302       {
2303           opus_int32 *value = va_arg(ap, opus_int32*);
2304           *value=st->lsb_depth;
2305       }
2306       break;
2307       case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
2308       {
2309           opus_int32 value = va_arg(ap, opus_int32);
2310           st->variable_duration = value;
2311       }
2312       break;
2313       case OPUS_RESET_STATE:
2314       {
2315          int i;
2316          opus_val16 *oldBandE, *oldLogE, *oldLogE2;
2317          oldBandE = (opus_val16*)(st->in_mem+st->channels*(st->mode->overlap+COMBFILTER_MAXPERIOD));
2318          oldLogE = oldBandE + st->channels*st->mode->nbEBands;
2319          oldLogE2 = oldLogE + st->channels*st->mode->nbEBands;
2320          OPUS_CLEAR((char*)&st->ENCODER_RESET_START,
2321                opus_custom_encoder_get_size(st->mode, st->channels)-
2322                ((char*)&st->ENCODER_RESET_START - (char*)st));
2323          for (i=0;i<st->channels*st->mode->nbEBands;i++)
2324             oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT);
2325          st->vbr_offset = 0;
2326          st->delayedIntra = 1;
2327          st->spread_decision = SPREAD_NORMAL;
2328          st->tonal_average = 256;
2329          st->hf_average = 0;
2330          st->tapset_decision = 0;
2331       }
2332       break;
2333 #ifdef CUSTOM_MODES
2334       case CELT_SET_INPUT_CLIPPING_REQUEST:
2335       {
2336          opus_int32 value = va_arg(ap, opus_int32);
2337          st->clip = value;
2338       }
2339       break;
2340 #endif
2341       case CELT_SET_SIGNALLING_REQUEST:
2342       {
2343          opus_int32 value = va_arg(ap, opus_int32);
2344          st->signalling = value;
2345       }
2346       break;
2347       case CELT_SET_ANALYSIS_REQUEST:
2348       {
2349          AnalysisInfo *info = va_arg(ap, AnalysisInfo *);
2350          if (info)
2351             OPUS_COPY(&st->analysis, info, 1);
2352       }
2353       break;
2354       case CELT_GET_MODE_REQUEST:
2355       {
2356          const CELTMode ** value = va_arg(ap, const CELTMode**);
2357          if (value==0)
2358             goto bad_arg;
2359          *value=st->mode;
2360       }
2361       break;
2362       case OPUS_GET_FINAL_RANGE_REQUEST:
2363       {
2364          opus_uint32 * value = va_arg(ap, opus_uint32 *);
2365          if (value==0)
2366             goto bad_arg;
2367          *value=st->rng;
2368       }
2369       break;
2370       case OPUS_SET_LFE_REQUEST:
2371       {
2372           opus_int32 value = va_arg(ap, opus_int32);
2373           st->lfe = value;
2374       }
2375       break;
2376       case OPUS_SET_ENERGY_MASK_REQUEST:
2377       {
2378           opus_val16 *value = va_arg(ap, opus_val16*);
2379           st->energy_mask = value;
2380       }
2381       break;
2382       default:
2383          goto bad_request;
2384    }
2385    va_end(ap);
2386    return OPUS_OK;
2387 bad_arg:
2388    va_end(ap);
2389    return OPUS_BAD_ARG;
2390 bad_request:
2391    va_end(ap);
2392    return OPUS_UNIMPLEMENTED;
2393 }