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