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