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