Retuning the tf_analysis() lambda
[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;
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    equiv_rate = ((opus_int32)nbCompressedBytes*8*50 >> (3-LM)) - (40*C+20)*((400>>LM) - 50);
1465    if (st->bitrate != OPUS_BITRATE_MAX)
1466       equiv_rate = IMIN(equiv_rate, st->bitrate - (40*C+20)*((400>>LM) - 50));
1467
1468    if (enc==NULL)
1469    {
1470       ec_enc_init(&_enc, compressed, nbCompressedBytes);
1471       enc = &_enc;
1472    }
1473
1474    if (vbr_rate>0)
1475    {
1476       /* Computes the max bit-rate allowed in VBR mode to avoid violating the
1477           target rate and buffering.
1478          We must do this up front so that bust-prevention logic triggers
1479           correctly if we don't have enough bits. */
1480       if (st->constrained_vbr)
1481       {
1482          opus_int32 vbr_bound;
1483          opus_int32 max_allowed;
1484          /* We could use any multiple of vbr_rate as bound (depending on the
1485              delay).
1486             This is clamped to ensure we use at least two bytes if the encoder
1487              was entirely empty, but to allow 0 in hybrid mode. */
1488          vbr_bound = vbr_rate;
1489          max_allowed = IMIN(IMAX(tell==1?2:0,
1490                (vbr_rate+vbr_bound-st->vbr_reservoir)>>(BITRES+3)),
1491                nbAvailableBytes);
1492          if(max_allowed < nbAvailableBytes)
1493          {
1494             nbCompressedBytes = nbFilledBytes+max_allowed;
1495             nbAvailableBytes = max_allowed;
1496             ec_enc_shrink(enc, nbCompressedBytes);
1497          }
1498       }
1499    }
1500    total_bits = nbCompressedBytes*8;
1501
1502    effEnd = end;
1503    if (effEnd > mode->effEBands)
1504       effEnd = mode->effEBands;
1505
1506    ALLOC(in, CC*(N+overlap), celt_sig);
1507
1508    sample_max=MAX32(st->overlap_max, celt_maxabs16(pcm, C*(N-overlap)/st->upsample));
1509    st->overlap_max=celt_maxabs16(pcm+C*(N-overlap)/st->upsample, C*overlap/st->upsample);
1510    sample_max=MAX32(sample_max, st->overlap_max);
1511 #ifdef FIXED_POINT
1512    silence = (sample_max==0);
1513 #else
1514    silence = (sample_max <= (opus_val16)1/(1<<st->lsb_depth));
1515 #endif
1516 #ifdef FUZZING
1517    if ((rand()&0x3F)==0)
1518       silence = 1;
1519 #endif
1520    if (tell==1)
1521       ec_enc_bit_logp(enc, silence, 15);
1522    else
1523       silence=0;
1524    if (silence)
1525    {
1526       /*In VBR mode there is no need to send more than the minimum. */
1527       if (vbr_rate>0)
1528       {
1529          effectiveBytes=nbCompressedBytes=IMIN(nbCompressedBytes, nbFilledBytes+2);
1530          total_bits=nbCompressedBytes*8;
1531          nbAvailableBytes=2;
1532          ec_enc_shrink(enc, nbCompressedBytes);
1533       }
1534       /* Pretend we've filled all the remaining bits with zeros
1535             (that's what the initialiser did anyway) */
1536       tell = nbCompressedBytes*8;
1537       enc->nbits_total+=tell-ec_tell(enc);
1538    }
1539    c=0; do {
1540       int need_clip=0;
1541 #ifndef FIXED_POINT
1542       need_clip = st->clip && sample_max>65536.f;
1543 #endif
1544       celt_preemphasis(pcm+c, in+c*(N+overlap)+overlap, N, CC, st->upsample,
1545                   mode->preemph, st->preemph_memE+c, need_clip);
1546    } while (++c<CC);
1547
1548
1549
1550    /* Find pitch period and gain */
1551    {
1552       int enabled;
1553       int qg;
1554       enabled = ((st->lfe&&nbAvailableBytes>3) || nbAvailableBytes>12*C) && !hybrid && !silence && !st->disable_pf
1555             && st->complexity >= 5 && !(st->consec_transient && LM!=3 && st->variable_duration==OPUS_FRAMESIZE_VARIABLE);
1556
1557       prefilter_tapset = st->tapset_decision;
1558       pf_on = run_prefilter(st, in, prefilter_mem, CC, N, prefilter_tapset, &pitch_index, &gain1, &qg, enabled, nbAvailableBytes);
1559       if ((gain1 > QCONST16(.4f,15) || st->prefilter_gain > QCONST16(.4f,15)) && (!st->analysis.valid || st->analysis.tonality > .3)
1560             && (pitch_index > 1.26*st->prefilter_period || pitch_index < .79*st->prefilter_period))
1561          pitch_change = 1;
1562       if (pf_on==0)
1563       {
1564          if(!hybrid && tell+16<=total_bits)
1565             ec_enc_bit_logp(enc, 0, 1);
1566       } else {
1567          /*This block is not gated by a total bits check only because
1568            of the nbAvailableBytes check above.*/
1569          int octave;
1570          ec_enc_bit_logp(enc, 1, 1);
1571          pitch_index += 1;
1572          octave = EC_ILOG(pitch_index)-5;
1573          ec_enc_uint(enc, octave, 6);
1574          ec_enc_bits(enc, pitch_index-(16<<octave), 4+octave);
1575          pitch_index -= 1;
1576          ec_enc_bits(enc, qg, 3);
1577          ec_enc_icdf(enc, prefilter_tapset, tapset_icdf, 2);
1578       }
1579    }
1580
1581    isTransient = 0;
1582    shortBlocks = 0;
1583    if (st->complexity >= 1 && !st->lfe)
1584    {
1585       isTransient = transient_analysis(in, N+overlap, CC,
1586             &tf_estimate, &tf_chan);
1587    }
1588    if (LM>0 && ec_tell(enc)+3<=total_bits)
1589    {
1590       if (isTransient)
1591          shortBlocks = M;
1592    } else {
1593       isTransient = 0;
1594       transient_got_disabled=1;
1595    }
1596
1597    ALLOC(freq, CC*N, celt_sig); /**< Interleaved signal MDCTs */
1598    ALLOC(bandE,nbEBands*CC, celt_ener);
1599    ALLOC(bandLogE,nbEBands*CC, opus_val16);
1600
1601    secondMdct = shortBlocks && st->complexity>=8;
1602    ALLOC(bandLogE2, C*nbEBands, opus_val16);
1603    if (secondMdct)
1604    {
1605       compute_mdcts(mode, 0, in, freq, C, CC, LM, st->upsample, st->arch);
1606       compute_band_energies(mode, freq, bandE, effEnd, C, LM);
1607       amp2Log2(mode, effEnd, end, bandE, bandLogE2, C);
1608       for (i=0;i<C*nbEBands;i++)
1609          bandLogE2[i] += HALF16(SHL16(LM, DB_SHIFT));
1610    }
1611
1612    compute_mdcts(mode, shortBlocks, in, freq, C, CC, LM, st->upsample, st->arch);
1613    if (CC==2&&C==1)
1614       tf_chan = 0;
1615    compute_band_energies(mode, freq, bandE, effEnd, C, LM);
1616
1617    if (st->lfe)
1618    {
1619       for (i=2;i<end;i++)
1620       {
1621          bandE[i] = IMIN(bandE[i], MULT16_32_Q15(QCONST16(1e-4f,15),bandE[0]));
1622          bandE[i] = MAX32(bandE[i], EPSILON);
1623       }
1624    }
1625    amp2Log2(mode, effEnd, end, bandE, bandLogE, C);
1626
1627    ALLOC(surround_dynalloc, C*nbEBands, opus_val16);
1628    OPUS_CLEAR(surround_dynalloc, end);
1629    /* This computes how much masking takes place between surround channels */
1630    if (!hybrid&&st->energy_mask&&!st->lfe)
1631    {
1632       int mask_end;
1633       int midband;
1634       int count_dynalloc;
1635       opus_val32 mask_avg=0;
1636       opus_val32 diff=0;
1637       int count=0;
1638       mask_end = IMAX(2,st->lastCodedBands);
1639       for (c=0;c<C;c++)
1640       {
1641          for(i=0;i<mask_end;i++)
1642          {
1643             opus_val16 mask;
1644             mask = MAX16(MIN16(st->energy_mask[nbEBands*c+i],
1645                    QCONST16(.25f, DB_SHIFT)), -QCONST16(2.0f, DB_SHIFT));
1646             if (mask > 0)
1647                mask = HALF16(mask);
1648             mask_avg += MULT16_16(mask, eBands[i+1]-eBands[i]);
1649             count += eBands[i+1]-eBands[i];
1650             diff += MULT16_16(mask, 1+2*i-mask_end);
1651          }
1652       }
1653       celt_assert(count>0);
1654       mask_avg = DIV32_16(mask_avg,count);
1655       mask_avg += QCONST16(.2f, DB_SHIFT);
1656       diff = diff*6/(C*(mask_end-1)*(mask_end+1)*mask_end);
1657       /* Again, being conservative */
1658       diff = HALF32(diff);
1659       diff = MAX32(MIN32(diff, QCONST32(.031f, DB_SHIFT)), -QCONST32(.031f, DB_SHIFT));
1660       /* Find the band that's in the middle of the coded spectrum */
1661       for (midband=0;eBands[midband+1] < eBands[mask_end]/2;midband++);
1662       count_dynalloc=0;
1663       for(i=0;i<mask_end;i++)
1664       {
1665          opus_val32 lin;
1666          opus_val16 unmask;
1667          lin = mask_avg + diff*(i-midband);
1668          if (C==2)
1669             unmask = MAX16(st->energy_mask[i], st->energy_mask[nbEBands+i]);
1670          else
1671             unmask = st->energy_mask[i];
1672          unmask = MIN16(unmask, QCONST16(.0f, DB_SHIFT));
1673          unmask -= lin;
1674          if (unmask > QCONST16(.25f, DB_SHIFT))
1675          {
1676             surround_dynalloc[i] = unmask - QCONST16(.25f, DB_SHIFT);
1677             count_dynalloc++;
1678          }
1679       }
1680       if (count_dynalloc>=3)
1681       {
1682          /* If we need dynalloc in many bands, it's probably because our
1683             initial masking rate was too low. */
1684          mask_avg += QCONST16(.25f, DB_SHIFT);
1685          if (mask_avg>0)
1686          {
1687             /* Something went really wrong in the original calculations,
1688                disabling masking. */
1689             mask_avg = 0;
1690             diff = 0;
1691             OPUS_CLEAR(surround_dynalloc, mask_end);
1692          } else {
1693             for(i=0;i<mask_end;i++)
1694                surround_dynalloc[i] = MAX16(0, surround_dynalloc[i]-QCONST16(.25f, DB_SHIFT));
1695          }
1696       }
1697       mask_avg += QCONST16(.2f, DB_SHIFT);
1698       /* Convert to 1/64th units used for the trim */
1699       surround_trim = 64*diff;
1700       /*printf("%d %d ", mask_avg, surround_trim);*/
1701       surround_masking = mask_avg;
1702    }
1703    /* Temporal VBR (but not for LFE) */
1704    if (!st->lfe)
1705    {
1706       opus_val16 follow=-QCONST16(10.0f,DB_SHIFT);
1707       opus_val32 frame_avg=0;
1708       opus_val16 offset = shortBlocks?HALF16(SHL16(LM, DB_SHIFT)):0;
1709       for(i=start;i<end;i++)
1710       {
1711          follow = MAX16(follow-QCONST16(1.f, DB_SHIFT), bandLogE[i]-offset);
1712          if (C==2)
1713             follow = MAX16(follow, bandLogE[i+nbEBands]-offset);
1714          frame_avg += follow;
1715       }
1716       frame_avg /= (end-start);
1717       temporal_vbr = SUB16(frame_avg,st->spec_avg);
1718       temporal_vbr = MIN16(QCONST16(3.f, DB_SHIFT), MAX16(-QCONST16(1.5f, DB_SHIFT), temporal_vbr));
1719       st->spec_avg += MULT16_16_Q15(QCONST16(.02f, 15), temporal_vbr);
1720    }
1721    /*for (i=0;i<21;i++)
1722       printf("%f ", bandLogE[i]);
1723    printf("\n");*/
1724
1725    if (!secondMdct)
1726    {
1727       OPUS_COPY(bandLogE2, bandLogE, C*nbEBands);
1728    }
1729
1730    /* Last chance to catch any transient we might have missed in the
1731       time-domain analysis */
1732    if (LM>0 && ec_tell(enc)+3<=total_bits && !isTransient && st->complexity>=5 && !st->lfe && !hybrid)
1733    {
1734       if (patch_transient_decision(bandLogE, oldBandE, nbEBands, start, end, C))
1735       {
1736          isTransient = 1;
1737          shortBlocks = M;
1738          compute_mdcts(mode, shortBlocks, in, freq, C, CC, LM, st->upsample, st->arch);
1739          compute_band_energies(mode, freq, bandE, effEnd, C, LM);
1740          amp2Log2(mode, effEnd, end, bandE, bandLogE, C);
1741          /* Compensate for the scaling of short vs long mdcts */
1742          for (i=0;i<C*nbEBands;i++)
1743             bandLogE2[i] += HALF16(SHL16(LM, DB_SHIFT));
1744          tf_estimate = QCONST16(.2f,14);
1745       }
1746    }
1747
1748    if (LM>0 && ec_tell(enc)+3<=total_bits)
1749       ec_enc_bit_logp(enc, isTransient, 3);
1750
1751    ALLOC(X, C*N, celt_norm);         /**< Interleaved normalised MDCTs */
1752
1753    /* Band normalisation */
1754    normalise_bands(mode, freq, X, bandE, effEnd, C, M);
1755
1756    ALLOC(tf_res, nbEBands, int);
1757    /* Disable variable tf resolution for hybrid and at very low bitrate */
1758    if (effectiveBytes>=15*C && !hybrid && st->complexity>=2 && !st->lfe)
1759    {
1760       int lambda;
1761       lambda = IMAX(5, 1280/effectiveBytes + 2);
1762       tf_select = tf_analysis(mode, effEnd, isTransient, tf_res, lambda, X, N, LM, tf_estimate, tf_chan);
1763       for (i=effEnd;i<end;i++)
1764          tf_res[i] = tf_res[effEnd-1];
1765    } else if (hybrid && effectiveBytes<15)
1766    {
1767       /* For low bitrate hybrid, we force temporal resolution to 5 ms rather than 2.5 ms. */
1768       for (i=0;i<end;i++)
1769          tf_res[i] = 0;
1770       tf_select=isTransient;
1771    } else {
1772       for (i=0;i<end;i++)
1773          tf_res[i] = isTransient;
1774       tf_select=0;
1775    }
1776
1777    ALLOC(error, C*nbEBands, opus_val16);
1778    quant_coarse_energy(mode, start, end, effEnd, bandLogE,
1779          oldBandE, total_bits, error, enc,
1780          C, LM, nbAvailableBytes, st->force_intra,
1781          &st->delayedIntra, st->complexity >= 4, st->loss_rate, st->lfe);
1782
1783    tf_encode(start, end, isTransient, tf_res, LM, tf_select, enc);
1784
1785    if (ec_tell(enc)+4<=total_bits)
1786    {
1787       if (st->lfe)
1788       {
1789          st->tapset_decision = 0;
1790          st->spread_decision = SPREAD_NORMAL;
1791       } else if (hybrid)
1792       {
1793          if (st->complexity == 0)
1794             st->spread_decision = SPREAD_NONE;
1795          else if (isTransient)
1796             st->spread_decision = SPREAD_NORMAL;
1797          else
1798             st->spread_decision = SPREAD_AGGRESSIVE;
1799       } else if (shortBlocks || st->complexity < 3 || nbAvailableBytes < 10*C)
1800       {
1801          if (st->complexity == 0)
1802             st->spread_decision = SPREAD_NONE;
1803          else
1804             st->spread_decision = SPREAD_NORMAL;
1805       } else {
1806          /* Disable new spreading+tapset estimator until we can show it works
1807             better than the old one. So far it seems like spreading_decision()
1808             works best. */
1809 #if 0
1810          if (st->analysis.valid)
1811          {
1812             static const opus_val16 spread_thresholds[3] = {-QCONST16(.6f, 15), -QCONST16(.2f, 15), -QCONST16(.07f, 15)};
1813             static const opus_val16 spread_histeresis[3] = {QCONST16(.15f, 15), QCONST16(.07f, 15), QCONST16(.02f, 15)};
1814             static const opus_val16 tapset_thresholds[2] = {QCONST16(.0f, 15), QCONST16(.15f, 15)};
1815             static const opus_val16 tapset_histeresis[2] = {QCONST16(.1f, 15), QCONST16(.05f, 15)};
1816             st->spread_decision = hysteresis_decision(-st->analysis.tonality, spread_thresholds, spread_histeresis, 3, st->spread_decision);
1817             st->tapset_decision = hysteresis_decision(st->analysis.tonality_slope, tapset_thresholds, tapset_histeresis, 2, st->tapset_decision);
1818          } else
1819 #endif
1820          {
1821             st->spread_decision = spreading_decision(mode, X,
1822                   &st->tonal_average, st->spread_decision, &st->hf_average,
1823                   &st->tapset_decision, pf_on&&!shortBlocks, effEnd, C, M);
1824          }
1825          /*printf("%d %d\n", st->tapset_decision, st->spread_decision);*/
1826          /*printf("%f %d %f %d\n\n", st->analysis.tonality, st->spread_decision, st->analysis.tonality_slope, st->tapset_decision);*/
1827       }
1828       ec_enc_icdf(enc, st->spread_decision, spread_icdf, 5);
1829    }
1830
1831    ALLOC(offsets, nbEBands, int);
1832
1833    maxDepth = dynalloc_analysis(bandLogE, bandLogE2, nbEBands, start, end, C, offsets,
1834          st->lsb_depth, mode->logN, isTransient, st->vbr, st->constrained_vbr,
1835          eBands, LM, effectiveBytes, &tot_boost, st->lfe, surround_dynalloc);
1836    /* For LFE, everything interesting is in the first band */
1837    if (st->lfe)
1838       offsets[0] = IMIN(8, effectiveBytes/3);
1839    ALLOC(cap, nbEBands, int);
1840    init_caps(mode,cap,LM,C);
1841
1842    dynalloc_logp = 6;
1843    total_bits<<=BITRES;
1844    total_boost = 0;
1845    tell = ec_tell_frac(enc);
1846    for (i=start;i<end;i++)
1847    {
1848       int width, quanta;
1849       int dynalloc_loop_logp;
1850       int boost;
1851       int j;
1852       width = C*(eBands[i+1]-eBands[i])<<LM;
1853       /* quanta is 6 bits, but no more than 1 bit/sample
1854          and no less than 1/8 bit/sample */
1855       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
1856       dynalloc_loop_logp = dynalloc_logp;
1857       boost = 0;
1858       for (j = 0; tell+(dynalloc_loop_logp<<BITRES) < total_bits-total_boost
1859             && boost < cap[i]; j++)
1860       {
1861          int flag;
1862          flag = j<offsets[i];
1863          ec_enc_bit_logp(enc, flag, dynalloc_loop_logp);
1864          tell = ec_tell_frac(enc);
1865          if (!flag)
1866             break;
1867          boost += quanta;
1868          total_boost += quanta;
1869          dynalloc_loop_logp = 1;
1870       }
1871       /* Making dynalloc more likely */
1872       if (j)
1873          dynalloc_logp = IMAX(2, dynalloc_logp-1);
1874       offsets[i] = boost;
1875    }
1876
1877    if (C==2)
1878    {
1879       static const opus_val16 intensity_thresholds[21]=
1880       /* 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19  20  off*/
1881         {  1, 2, 3, 4, 5, 6, 7, 8,16,24,36,44,50,56,62,67,72,79,88,106,134};
1882       static const opus_val16 intensity_histeresis[21]=
1883         {  1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 4, 5, 6,  8, 8};
1884
1885       /* Always use MS for 2.5 ms frames until we can do a better analysis */
1886       if (LM!=0)
1887          dual_stereo = stereo_analysis(mode, X, LM, N);
1888
1889       st->intensity = hysteresis_decision((opus_val16)(equiv_rate/1000),
1890             intensity_thresholds, intensity_histeresis, 21, st->intensity);
1891       st->intensity = IMIN(end,IMAX(start, st->intensity));
1892    }
1893
1894    alloc_trim = 5;
1895    if (tell+(6<<BITRES) <= total_bits - total_boost)
1896    {
1897       if (start > 0 || st->lfe)
1898       {
1899          st->stereo_saving = 0;
1900          alloc_trim = 5;
1901       } else {
1902          alloc_trim = alloc_trim_analysis(mode, X, bandLogE,
1903             end, LM, C, N, &st->analysis, &st->stereo_saving, tf_estimate,
1904             st->intensity, surround_trim, st->arch);
1905       }
1906       ec_enc_icdf(enc, alloc_trim, trim_icdf, 7);
1907       tell = ec_tell_frac(enc);
1908    }
1909
1910    /* Variable bitrate */
1911    if (vbr_rate>0)
1912    {
1913      opus_val16 alpha;
1914      opus_int32 delta;
1915      /* The target rate in 8th bits per frame */
1916      opus_int32 target, base_target;
1917      opus_int32 min_allowed;
1918      int lm_diff = mode->maxLM - LM;
1919
1920      /* Don't attempt to use more than 510 kb/s, even for frames smaller than 20 ms.
1921         The CELT allocator will just not be able to use more than that anyway. */
1922      nbCompressedBytes = IMIN(nbCompressedBytes,1275>>(3-LM));
1923      if (!hybrid)
1924      {
1925         base_target = vbr_rate - ((40*C+20)<<BITRES);
1926      } else {
1927         base_target = IMAX(0, vbr_rate - ((9*C+4)<<BITRES));
1928      }
1929
1930      if (st->constrained_vbr)
1931         base_target += (st->vbr_offset>>lm_diff);
1932
1933      if (!hybrid)
1934      {
1935         target = compute_vbr(mode, &st->analysis, base_target, LM, equiv_rate,
1936            st->lastCodedBands, C, st->intensity, st->constrained_vbr,
1937            st->stereo_saving, tot_boost, tf_estimate, pitch_change, maxDepth,
1938            st->variable_duration, st->lfe, st->energy_mask!=NULL, surround_masking,
1939            temporal_vbr);
1940      } else {
1941         target = base_target;
1942         /* Tonal frames (offset<100) need more bits than noisy (offset>100) ones. */
1943         if (st->silk_info.offset < 100) target += 12 << BITRES >> (3-LM);
1944         if (st->silk_info.offset > 100) target -= 18 << BITRES >> (3-LM);
1945         /* Boosting bitrate on transients and vowels with significant temporal
1946            spikes. */
1947         target += MULT16_16_Q14(tf_estimate-QCONST16(.25f,14), (50<<BITRES));
1948         /* If we have a strong transient, let's make sure it has enough bits to code
1949            the first two bands, so that it can use folding rather than noise. */
1950         if (tf_estimate > QCONST16(.7f,14))
1951            target = IMAX(target, 50<<BITRES);
1952      }
1953      /* The current offset is removed from the target and the space used
1954         so far is added*/
1955      target=target+tell;
1956      /* In VBR mode the frame size must not be reduced so much that it would
1957          result in the encoder running out of bits.
1958         The margin of 2 bytes ensures that none of the bust-prevention logic
1959          in the decoder will have triggered so far. */
1960      min_allowed = ((tell+total_boost+(1<<(BITRES+3))-1)>>(BITRES+3)) + 2;
1961      /* Take into account the 37 bits we need to have left in the packet to
1962         signal a redundant frame in hybrid mode. Creating a shorter packet would
1963         create an entropy coder desync. */
1964      if (hybrid)
1965         min_allowed = IMAX(min_allowed, (tell0_frac+(37<<BITRES)+total_boost+(1<<(BITRES+3))-1)>>(BITRES+3));
1966
1967      nbAvailableBytes = (target+(1<<(BITRES+2)))>>(BITRES+3);
1968      nbAvailableBytes = IMAX(min_allowed,nbAvailableBytes);
1969      nbAvailableBytes = IMIN(nbCompressedBytes,nbAvailableBytes);
1970
1971      /* By how much did we "miss" the target on that frame */
1972      delta = target - vbr_rate;
1973
1974      target=nbAvailableBytes<<(BITRES+3);
1975
1976      /*If the frame is silent we don't adjust our drift, otherwise
1977        the encoder will shoot to very high rates after hitting a
1978        span of silence, but we do allow the bitres to refill.
1979        This means that we'll undershoot our target in CVBR/VBR modes
1980        on files with lots of silence. */
1981      if(silence)
1982      {
1983        nbAvailableBytes = 2;
1984        target = 2*8<<BITRES;
1985        delta = 0;
1986      }
1987
1988      if (st->vbr_count < 970)
1989      {
1990         st->vbr_count++;
1991         alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+20),16));
1992      } else
1993         alpha = QCONST16(.001f,15);
1994      /* How many bits have we used in excess of what we're allowed */
1995      if (st->constrained_vbr)
1996         st->vbr_reservoir += target - vbr_rate;
1997      /*printf ("%d\n", st->vbr_reservoir);*/
1998
1999      /* Compute the offset we need to apply in order to reach the target */
2000      if (st->constrained_vbr)
2001      {
2002         st->vbr_drift += (opus_int32)MULT16_32_Q15(alpha,(delta*(1<<lm_diff))-st->vbr_offset-st->vbr_drift);
2003         st->vbr_offset = -st->vbr_drift;
2004      }
2005      /*printf ("%d\n", st->vbr_drift);*/
2006
2007      if (st->constrained_vbr && st->vbr_reservoir < 0)
2008      {
2009         /* We're under the min value -- increase rate */
2010         int adjust = (-st->vbr_reservoir)/(8<<BITRES);
2011         /* Unless we're just coding silence */
2012         nbAvailableBytes += silence?0:adjust;
2013         st->vbr_reservoir = 0;
2014         /*printf ("+%d\n", adjust);*/
2015      }
2016      nbCompressedBytes = IMIN(nbCompressedBytes,nbAvailableBytes);
2017      /*printf("%d\n", nbCompressedBytes*50*8);*/
2018      /* This moves the raw bits to take into account the new compressed size */
2019      ec_enc_shrink(enc, nbCompressedBytes);
2020    }
2021
2022    /* Bit allocation */
2023    ALLOC(fine_quant, nbEBands, int);
2024    ALLOC(pulses, nbEBands, int);
2025    ALLOC(fine_priority, nbEBands, int);
2026
2027    /* bits =           packet size                    - where we are - safety*/
2028    bits = (((opus_int32)nbCompressedBytes*8)<<BITRES) - ec_tell_frac(enc) - 1;
2029    anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0;
2030    bits -= anti_collapse_rsv;
2031    signalBandwidth = end-1;
2032 #ifndef DISABLE_FLOAT_API
2033    if (st->analysis.valid)
2034    {
2035       int min_bandwidth;
2036       if (equiv_rate < (opus_int32)32000*C)
2037          min_bandwidth = 13;
2038       else if (equiv_rate < (opus_int32)48000*C)
2039          min_bandwidth = 16;
2040       else if (equiv_rate < (opus_int32)60000*C)
2041          min_bandwidth = 18;
2042       else  if (equiv_rate < (opus_int32)80000*C)
2043          min_bandwidth = 19;
2044       else
2045          min_bandwidth = 20;
2046       signalBandwidth = IMAX(st->analysis.bandwidth, min_bandwidth);
2047    }
2048 #endif
2049    if (st->lfe)
2050       signalBandwidth = 1;
2051    codedBands = compute_allocation(mode, start, end, offsets, cap,
2052          alloc_trim, &st->intensity, &dual_stereo, bits, &balance, pulses,
2053          fine_quant, fine_priority, C, LM, enc, 1, st->lastCodedBands, signalBandwidth);
2054    if (st->lastCodedBands)
2055       st->lastCodedBands = IMIN(st->lastCodedBands+1,IMAX(st->lastCodedBands-1,codedBands));
2056    else
2057       st->lastCodedBands = codedBands;
2058
2059    quant_fine_energy(mode, start, end, oldBandE, error, fine_quant, enc, C);
2060
2061    /* Residual quantisation */
2062    ALLOC(collapse_masks, C*nbEBands, unsigned char);
2063    quant_all_bands(1, mode, start, end, X, C==2 ? X+N : NULL, collapse_masks,
2064          bandE, pulses, shortBlocks, st->spread_decision,
2065          dual_stereo, st->intensity, tf_res, nbCompressedBytes*(8<<BITRES)-anti_collapse_rsv,
2066          balance, enc, LM, codedBands, &st->rng, st->arch);
2067
2068    if (anti_collapse_rsv > 0)
2069    {
2070       anti_collapse_on = st->consec_transient<2;
2071 #ifdef FUZZING
2072       anti_collapse_on = rand()&0x1;
2073 #endif
2074       ec_enc_bits(enc, anti_collapse_on, 1);
2075    }
2076    quant_energy_finalise(mode, start, end, oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_tell(enc), enc, C);
2077
2078    if (silence)
2079    {
2080       for (i=0;i<C*nbEBands;i++)
2081          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
2082    }
2083
2084 #ifdef RESYNTH
2085    /* Re-synthesis of the coded audio if required */
2086    {
2087       celt_sig *out_mem[2];
2088
2089       if (anti_collapse_on)
2090       {
2091          anti_collapse(mode, X, collapse_masks, LM, C, N,
2092                start, end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
2093       }
2094
2095       c=0; do {
2096          OPUS_MOVE(st->syn_mem[c], st->syn_mem[c]+N, 2*MAX_PERIOD-N+overlap/2);
2097       } while (++c<CC);
2098
2099       c=0; do {
2100          out_mem[c] = st->syn_mem[c]+2*MAX_PERIOD-N;
2101       } while (++c<CC);
2102
2103       celt_synthesis(mode, X, out_mem, oldBandE, start, effEnd,
2104                      C, CC, isTransient, LM, st->upsample, silence, st->arch);
2105
2106       c=0; do {
2107          st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
2108          st->prefilter_period_old=IMAX(st->prefilter_period_old, COMBFILTER_MINPERIOD);
2109          comb_filter(out_mem[c], out_mem[c], st->prefilter_period_old, st->prefilter_period, mode->shortMdctSize,
2110                st->prefilter_gain_old, st->prefilter_gain, st->prefilter_tapset_old, st->prefilter_tapset,
2111                mode->window, overlap);
2112          if (LM!=0)
2113             comb_filter(out_mem[c]+mode->shortMdctSize, out_mem[c]+mode->shortMdctSize, st->prefilter_period, pitch_index, N-mode->shortMdctSize,
2114                   st->prefilter_gain, gain1, st->prefilter_tapset, prefilter_tapset,
2115                   mode->window, overlap);
2116       } while (++c<CC);
2117
2118       /* We reuse freq[] as scratch space for the de-emphasis */
2119       deemphasis(out_mem, (opus_val16*)pcm, N, CC, st->upsample, mode->preemph, st->preemph_memD);
2120       st->prefilter_period_old = st->prefilter_period;
2121       st->prefilter_gain_old = st->prefilter_gain;
2122       st->prefilter_tapset_old = st->prefilter_tapset;
2123    }
2124 #endif
2125
2126    st->prefilter_period = pitch_index;
2127    st->prefilter_gain = gain1;
2128    st->prefilter_tapset = prefilter_tapset;
2129 #ifdef RESYNTH
2130    if (LM!=0)
2131    {
2132       st->prefilter_period_old = st->prefilter_period;
2133       st->prefilter_gain_old = st->prefilter_gain;
2134       st->prefilter_tapset_old = st->prefilter_tapset;
2135    }
2136 #endif
2137
2138    if (CC==2&&C==1) {
2139       OPUS_COPY(&oldBandE[nbEBands], oldBandE, nbEBands);
2140    }
2141
2142    if (!isTransient)
2143    {
2144       OPUS_COPY(oldLogE2, oldLogE, CC*nbEBands);
2145       OPUS_COPY(oldLogE, oldBandE, CC*nbEBands);
2146    } else {
2147       for (i=0;i<CC*nbEBands;i++)
2148          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
2149    }
2150    /* In case start or end were to change */
2151    c=0; do
2152    {
2153       for (i=0;i<start;i++)
2154       {
2155          oldBandE[c*nbEBands+i]=0;
2156          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
2157       }
2158       for (i=end;i<nbEBands;i++)
2159       {
2160          oldBandE[c*nbEBands+i]=0;
2161          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
2162       }
2163    } while (++c<CC);
2164
2165    if (isTransient || transient_got_disabled)
2166       st->consec_transient++;
2167    else
2168       st->consec_transient=0;
2169    st->rng = enc->rng;
2170
2171    /* If there's any room left (can only happen for very high rates),
2172       it's already filled with zeros */
2173    ec_enc_done(enc);
2174
2175 #ifdef CUSTOM_MODES
2176    if (st->signalling)
2177       nbCompressedBytes++;
2178 #endif
2179
2180    RESTORE_STACK;
2181    if (ec_get_error(enc))
2182       return OPUS_INTERNAL_ERROR;
2183    else
2184       return nbCompressedBytes;
2185 }
2186
2187
2188 #ifdef CUSTOM_MODES
2189
2190 #ifdef FIXED_POINT
2191 int opus_custom_encode(CELTEncoder * OPUS_RESTRICT st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2192 {
2193    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
2194 }
2195
2196 #ifndef DISABLE_FLOAT_API
2197 int opus_custom_encode_float(CELTEncoder * OPUS_RESTRICT st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2198 {
2199    int j, ret, C, N;
2200    VARDECL(opus_int16, in);
2201    ALLOC_STACK;
2202
2203    if (pcm==NULL)
2204       return OPUS_BAD_ARG;
2205
2206    C = st->channels;
2207    N = frame_size;
2208    ALLOC(in, C*N, opus_int16);
2209
2210    for (j=0;j<C*N;j++)
2211      in[j] = FLOAT2INT16(pcm[j]);
2212
2213    ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
2214 #ifdef RESYNTH
2215    for (j=0;j<C*N;j++)
2216       ((float*)pcm)[j]=in[j]*(1.f/32768.f);
2217 #endif
2218    RESTORE_STACK;
2219    return ret;
2220 }
2221 #endif /* DISABLE_FLOAT_API */
2222 #else
2223
2224 int opus_custom_encode(CELTEncoder * OPUS_RESTRICT st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2225 {
2226    int j, ret, C, N;
2227    VARDECL(celt_sig, in);
2228    ALLOC_STACK;
2229
2230    if (pcm==NULL)
2231       return OPUS_BAD_ARG;
2232
2233    C=st->channels;
2234    N=frame_size;
2235    ALLOC(in, C*N, celt_sig);
2236    for (j=0;j<C*N;j++) {
2237      in[j] = SCALEOUT(pcm[j]);
2238    }
2239
2240    ret = celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
2241 #ifdef RESYNTH
2242    for (j=0;j<C*N;j++)
2243       ((opus_int16*)pcm)[j] = FLOAT2INT16(in[j]);
2244 #endif
2245    RESTORE_STACK;
2246    return ret;
2247 }
2248
2249 int opus_custom_encode_float(CELTEncoder * OPUS_RESTRICT st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2250 {
2251    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
2252 }
2253
2254 #endif
2255
2256 #endif /* CUSTOM_MODES */
2257
2258 int opus_custom_encoder_ctl(CELTEncoder * OPUS_RESTRICT st, int request, ...)
2259 {
2260    va_list ap;
2261
2262    va_start(ap, request);
2263    switch (request)
2264    {
2265       case OPUS_SET_COMPLEXITY_REQUEST:
2266       {
2267          int value = va_arg(ap, opus_int32);
2268          if (value<0 || value>10)
2269             goto bad_arg;
2270          st->complexity = value;
2271       }
2272       break;
2273       case CELT_SET_START_BAND_REQUEST:
2274       {
2275          opus_int32 value = va_arg(ap, opus_int32);
2276          if (value<0 || value>=st->mode->nbEBands)
2277             goto bad_arg;
2278          st->start = value;
2279       }
2280       break;
2281       case CELT_SET_END_BAND_REQUEST:
2282       {
2283          opus_int32 value = va_arg(ap, opus_int32);
2284          if (value<1 || value>st->mode->nbEBands)
2285             goto bad_arg;
2286          st->end = value;
2287       }
2288       break;
2289       case CELT_SET_PREDICTION_REQUEST:
2290       {
2291          int value = va_arg(ap, opus_int32);
2292          if (value<0 || value>2)
2293             goto bad_arg;
2294          st->disable_pf = value<=1;
2295          st->force_intra = value==0;
2296       }
2297       break;
2298       case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2299       {
2300          int value = va_arg(ap, opus_int32);
2301          if (value<0 || value>100)
2302             goto bad_arg;
2303          st->loss_rate = value;
2304       }
2305       break;
2306       case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2307       {
2308          opus_int32 value = va_arg(ap, opus_int32);
2309          st->constrained_vbr = value;
2310       }
2311       break;
2312       case OPUS_SET_VBR_REQUEST:
2313       {
2314          opus_int32 value = va_arg(ap, opus_int32);
2315          st->vbr = value;
2316       }
2317       break;
2318       case OPUS_SET_BITRATE_REQUEST:
2319       {
2320          opus_int32 value = va_arg(ap, opus_int32);
2321          if (value<=500 && value!=OPUS_BITRATE_MAX)
2322             goto bad_arg;
2323          value = IMIN(value, 260000*st->channels);
2324          st->bitrate = value;
2325       }
2326       break;
2327       case CELT_SET_CHANNELS_REQUEST:
2328       {
2329          opus_int32 value = va_arg(ap, opus_int32);
2330          if (value<1 || value>2)
2331             goto bad_arg;
2332          st->stream_channels = value;
2333       }
2334       break;
2335       case OPUS_SET_LSB_DEPTH_REQUEST:
2336       {
2337           opus_int32 value = va_arg(ap, opus_int32);
2338           if (value<8 || value>24)
2339              goto bad_arg;
2340           st->lsb_depth=value;
2341       }
2342       break;
2343       case OPUS_GET_LSB_DEPTH_REQUEST:
2344       {
2345           opus_int32 *value = va_arg(ap, opus_int32*);
2346           *value=st->lsb_depth;
2347       }
2348       break;
2349       case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
2350       {
2351           opus_int32 value = va_arg(ap, opus_int32);
2352           st->variable_duration = value;
2353       }
2354       break;
2355       case OPUS_RESET_STATE:
2356       {
2357          int i;
2358          opus_val16 *oldBandE, *oldLogE, *oldLogE2;
2359          oldBandE = (opus_val16*)(st->in_mem+st->channels*(st->mode->overlap+COMBFILTER_MAXPERIOD));
2360          oldLogE = oldBandE + st->channels*st->mode->nbEBands;
2361          oldLogE2 = oldLogE + st->channels*st->mode->nbEBands;
2362          OPUS_CLEAR((char*)&st->ENCODER_RESET_START,
2363                opus_custom_encoder_get_size(st->mode, st->channels)-
2364                ((char*)&st->ENCODER_RESET_START - (char*)st));
2365          for (i=0;i<st->channels*st->mode->nbEBands;i++)
2366             oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT);
2367          st->vbr_offset = 0;
2368          st->delayedIntra = 1;
2369          st->spread_decision = SPREAD_NORMAL;
2370          st->tonal_average = 256;
2371          st->hf_average = 0;
2372          st->tapset_decision = 0;
2373       }
2374       break;
2375 #ifdef CUSTOM_MODES
2376       case CELT_SET_INPUT_CLIPPING_REQUEST:
2377       {
2378          opus_int32 value = va_arg(ap, opus_int32);
2379          st->clip = value;
2380       }
2381       break;
2382 #endif
2383       case CELT_SET_SIGNALLING_REQUEST:
2384       {
2385          opus_int32 value = va_arg(ap, opus_int32);
2386          st->signalling = value;
2387       }
2388       break;
2389       case CELT_SET_ANALYSIS_REQUEST:
2390       {
2391          AnalysisInfo *info = va_arg(ap, AnalysisInfo *);
2392          if (info)
2393             OPUS_COPY(&st->analysis, info, 1);
2394       }
2395       break;
2396       case CELT_SET_SILK_INFO_REQUEST:
2397       {
2398          SILKInfo *info = va_arg(ap, SILKInfo *);
2399          if (info)
2400             OPUS_COPY(&st->silk_info, info, 1);
2401       }
2402       break;
2403       case CELT_GET_MODE_REQUEST:
2404       {
2405          const CELTMode ** value = va_arg(ap, const CELTMode**);
2406          if (value==0)
2407             goto bad_arg;
2408          *value=st->mode;
2409       }
2410       break;
2411       case OPUS_GET_FINAL_RANGE_REQUEST:
2412       {
2413          opus_uint32 * value = va_arg(ap, opus_uint32 *);
2414          if (value==0)
2415             goto bad_arg;
2416          *value=st->rng;
2417       }
2418       break;
2419       case OPUS_SET_LFE_REQUEST:
2420       {
2421           opus_int32 value = va_arg(ap, opus_int32);
2422           st->lfe = value;
2423       }
2424       break;
2425       case OPUS_SET_ENERGY_MASK_REQUEST:
2426       {
2427           opus_val16 *value = va_arg(ap, opus_val16*);
2428           st->energy_mask = value;
2429       }
2430       break;
2431       default:
2432          goto bad_request;
2433    }
2434    va_end(ap);
2435    return OPUS_OK;
2436 bad_arg:
2437    va_end(ap);
2438    return OPUS_BAD_ARG;
2439 bad_request:
2440    va_end(ap);
2441    return OPUS_UNIMPLEMENTED;
2442 }