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