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