oops
[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    }
1114    *tot_boost_ = tot_boost;
1115    RESTORE_STACK;
1116    return maxDepth;
1117 }
1118
1119
1120 static int run_prefilter(CELTEncoder *st, celt_sig *in, celt_sig *prefilter_mem, int CC, int N,
1121       int prefilter_tapset, int *pitch, opus_val16 *gain, int *qgain, int enabled, int nbAvailableBytes, AnalysisInfo *analysis)
1122 {
1123    int c;
1124    VARDECL(celt_sig, _pre);
1125    celt_sig *pre[2];
1126    const CELTMode *mode;
1127    int pitch_index;
1128    opus_val16 gain1;
1129    opus_val16 pf_threshold;
1130    int pf_on;
1131    int qg;
1132    int overlap;
1133    SAVE_STACK;
1134
1135    mode = st->mode;
1136    overlap = mode->overlap;
1137    ALLOC(_pre, CC*(N+COMBFILTER_MAXPERIOD), celt_sig);
1138
1139    pre[0] = _pre;
1140    pre[1] = _pre + (N+COMBFILTER_MAXPERIOD);
1141
1142
1143    c=0; do {
1144       OPUS_COPY(pre[c], prefilter_mem+c*COMBFILTER_MAXPERIOD, COMBFILTER_MAXPERIOD);
1145       OPUS_COPY(pre[c]+COMBFILTER_MAXPERIOD, in+c*(N+overlap)+overlap, N);
1146    } while (++c<CC);
1147
1148    if (enabled)
1149    {
1150       VARDECL(opus_val16, pitch_buf);
1151       ALLOC(pitch_buf, (COMBFILTER_MAXPERIOD+N)>>1, opus_val16);
1152
1153       pitch_downsample(pre, pitch_buf, COMBFILTER_MAXPERIOD+N, CC, st->arch);
1154       /* Don't search for the fir last 1.5 octave of the range because
1155          there's too many false-positives due to short-term correlation */
1156       pitch_search(pitch_buf+(COMBFILTER_MAXPERIOD>>1), pitch_buf, N,
1157             COMBFILTER_MAXPERIOD-3*COMBFILTER_MINPERIOD, &pitch_index,
1158             st->arch);
1159       pitch_index = COMBFILTER_MAXPERIOD-pitch_index;
1160
1161       gain1 = remove_doubling(pitch_buf, COMBFILTER_MAXPERIOD, COMBFILTER_MINPERIOD,
1162             N, &pitch_index, st->prefilter_period, st->prefilter_gain, st->arch);
1163       if (pitch_index > COMBFILTER_MAXPERIOD-2)
1164          pitch_index = COMBFILTER_MAXPERIOD-2;
1165       gain1 = MULT16_16_Q15(QCONST16(.7f,15),gain1);
1166       /*printf("%d %d %f %f\n", pitch_change, pitch_index, gain1, st->analysis.tonality);*/
1167       if (st->loss_rate>2)
1168          gain1 = HALF32(gain1);
1169       if (st->loss_rate>4)
1170          gain1 = HALF32(gain1);
1171       if (st->loss_rate>8)
1172          gain1 = 0;
1173    } else {
1174       gain1 = 0;
1175       pitch_index = COMBFILTER_MINPERIOD;
1176    }
1177 #ifndef DISABLE_FLOAT_API
1178    if (analysis->valid)
1179       gain1 *= analysis->max_pitch_ratio;
1180 #endif
1181    /* Gain threshold for enabling the prefilter/postfilter */
1182    pf_threshold = QCONST16(.2f,15);
1183
1184    /* Adjusting the threshold based on rate and continuity */
1185    if (abs(pitch_index-st->prefilter_period)*10>pitch_index)
1186       pf_threshold += QCONST16(.2f,15);
1187    if (nbAvailableBytes<25)
1188       pf_threshold += QCONST16(.1f,15);
1189    if (nbAvailableBytes<35)
1190       pf_threshold += QCONST16(.1f,15);
1191    if (st->prefilter_gain > QCONST16(.4f,15))
1192       pf_threshold -= QCONST16(.1f,15);
1193    if (st->prefilter_gain > QCONST16(.55f,15))
1194       pf_threshold -= QCONST16(.1f,15);
1195
1196    /* Hard threshold at 0.2 */
1197    pf_threshold = MAX16(pf_threshold, QCONST16(.2f,15));
1198    if (gain1<pf_threshold)
1199    {
1200       gain1 = 0;
1201       pf_on = 0;
1202       qg = 0;
1203    } else {
1204       /*This block is not gated by a total bits check only because
1205         of the nbAvailableBytes check above.*/
1206       if (ABS16(gain1-st->prefilter_gain)<QCONST16(.1f,15))
1207          gain1=st->prefilter_gain;
1208
1209 #ifdef FIXED_POINT
1210       qg = ((gain1+1536)>>10)/3-1;
1211 #else
1212       qg = (int)floor(.5f+gain1*32/3)-1;
1213 #endif
1214       qg = IMAX(0, IMIN(7, qg));
1215       gain1 = QCONST16(0.09375f,15)*(qg+1);
1216       pf_on = 1;
1217    }
1218    /*printf("%d %f\n", pitch_index, gain1);*/
1219
1220    c=0; do {
1221       int offset = mode->shortMdctSize-overlap;
1222       st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
1223       OPUS_COPY(in+c*(N+overlap), st->in_mem+c*(overlap), overlap);
1224       if (offset)
1225          comb_filter(in+c*(N+overlap)+overlap, pre[c]+COMBFILTER_MAXPERIOD,
1226                st->prefilter_period, st->prefilter_period, offset, -st->prefilter_gain, -st->prefilter_gain,
1227                st->prefilter_tapset, st->prefilter_tapset, NULL, 0, st->arch);
1228
1229       comb_filter(in+c*(N+overlap)+overlap+offset, pre[c]+COMBFILTER_MAXPERIOD+offset,
1230             st->prefilter_period, pitch_index, N-offset, -st->prefilter_gain, -gain1,
1231             st->prefilter_tapset, prefilter_tapset, mode->window, overlap, st->arch);
1232       OPUS_COPY(st->in_mem+c*(overlap), in+c*(N+overlap)+N, overlap);
1233
1234       if (N>COMBFILTER_MAXPERIOD)
1235       {
1236          OPUS_COPY(prefilter_mem+c*COMBFILTER_MAXPERIOD, pre[c]+N, COMBFILTER_MAXPERIOD);
1237       } else {
1238          OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, prefilter_mem+c*COMBFILTER_MAXPERIOD+N, COMBFILTER_MAXPERIOD-N);
1239          OPUS_COPY(prefilter_mem+c*COMBFILTER_MAXPERIOD+COMBFILTER_MAXPERIOD-N, pre[c]+COMBFILTER_MAXPERIOD, N);
1240       }
1241    } while (++c<CC);
1242
1243    RESTORE_STACK;
1244    *gain = gain1;
1245    *pitch = pitch_index;
1246    *qgain = qg;
1247    return pf_on;
1248 }
1249
1250 static int compute_vbr(const CELTMode *mode, AnalysisInfo *analysis, opus_int32 base_target,
1251       int LM, opus_int32 bitrate, int lastCodedBands, int C, int intensity,
1252       int constrained_vbr, opus_val16 stereo_saving, int tot_boost,
1253       opus_val16 tf_estimate, int pitch_change, opus_val16 maxDepth,
1254       int lfe, int has_surround_mask, opus_val16 surround_masking,
1255       opus_val16 temporal_vbr)
1256 {
1257    /* The target rate in 8th bits per frame */
1258    opus_int32 target;
1259    int coded_bins;
1260    int coded_bands;
1261    opus_val16 tf_calibration;
1262    int nbEBands;
1263    const opus_int16 *eBands;
1264
1265    nbEBands = mode->nbEBands;
1266    eBands = mode->eBands;
1267
1268    coded_bands = lastCodedBands ? lastCodedBands : nbEBands;
1269    coded_bins = eBands[coded_bands]<<LM;
1270    if (C==2)
1271       coded_bins += eBands[IMIN(intensity, coded_bands)]<<LM;
1272
1273    target = base_target;
1274
1275    /*printf("%f %f %f %f %d %d ", st->analysis.activity, st->analysis.tonality, tf_estimate, st->stereo_saving, tot_boost, coded_bands);*/
1276 #ifndef DISABLE_FLOAT_API
1277    if (analysis->valid && analysis->activity<.4)
1278       target -= (opus_int32)((coded_bins<<BITRES)*(.4f-analysis->activity));
1279 #endif
1280    /* Stereo savings */
1281    if (C==2)
1282    {
1283       int coded_stereo_bands;
1284       int coded_stereo_dof;
1285       opus_val16 max_frac;
1286       coded_stereo_bands = IMIN(intensity, coded_bands);
1287       coded_stereo_dof = (eBands[coded_stereo_bands]<<LM)-coded_stereo_bands;
1288       /* Maximum fraction of the bits we can save if the signal is mono. */
1289       max_frac = DIV32_16(MULT16_16(QCONST16(0.8f, 15), coded_stereo_dof), coded_bins);
1290       stereo_saving = MIN16(stereo_saving, QCONST16(1.f, 8));
1291       /*printf("%d %d %d ", coded_stereo_dof, coded_bins, tot_boost);*/
1292       target -= (opus_int32)MIN32(MULT16_32_Q15(max_frac,target),
1293                       SHR32(MULT16_16(stereo_saving-QCONST16(0.1f,8),(coded_stereo_dof<<BITRES)),8));
1294    }
1295    /* Boost the rate according to dynalloc (minus the dynalloc average for calibration). */
1296    target += tot_boost-(19<<LM);
1297    /* Apply transient boost, compensating for average boost. */
1298    tf_calibration = QCONST16(0.044f,14);
1299    target += (opus_int32)SHL32(MULT16_32_Q15(tf_estimate-tf_calibration, target),1);
1300
1301 #ifndef DISABLE_FLOAT_API
1302    /* Apply tonality boost */
1303    if (analysis->valid && !lfe)
1304    {
1305       opus_int32 tonal_target;
1306       float tonal;
1307
1308       /* Tonality boost (compensating for the average). */
1309       tonal = MAX16(0.f,analysis->tonality-.15f)-0.12f;
1310       tonal_target = target + (opus_int32)((coded_bins<<BITRES)*1.2f*tonal);
1311       if (pitch_change)
1312          tonal_target +=  (opus_int32)((coded_bins<<BITRES)*.8f);
1313       /*printf("%f %f ", analysis->tonality, tonal);*/
1314       target = tonal_target;
1315    }
1316 #else
1317    (void)analysis;
1318    (void)pitch_change;
1319 #endif
1320
1321    if (has_surround_mask&&!lfe)
1322    {
1323       opus_int32 surround_target = target + (opus_int32)SHR32(MULT16_16(surround_masking,coded_bins<<BITRES), DB_SHIFT);
1324       /*printf("%f %d %d %d %d %d %d ", surround_masking, coded_bins, st->end, st->intensity, surround_target, target, st->bitrate);*/
1325       target = IMAX(target/4, surround_target);
1326    }
1327
1328    {
1329       opus_int32 floor_depth;
1330       int bins;
1331       bins = eBands[nbEBands-2]<<LM;
1332       /*floor_depth = SHR32(MULT16_16((C*bins<<BITRES),celt_log2(SHL32(MAX16(1,sample_max),13))), DB_SHIFT);*/
1333       floor_depth = (opus_int32)SHR32(MULT16_16((C*bins<<BITRES),maxDepth), DB_SHIFT);
1334       floor_depth = IMAX(floor_depth, target>>2);
1335       target = IMIN(target, floor_depth);
1336       /*printf("%f %d\n", maxDepth, floor_depth);*/
1337    }
1338
1339    /* Make VBR less aggressive for constrained VBR because we can't keep a higher bitrate
1340       for long. Needs tuning. */
1341    if ((!has_surround_mask||lfe) && constrained_vbr)
1342    {
1343       target = base_target + (opus_int32)MULT16_32_Q15(QCONST16(0.67f, 15), target-base_target);
1344    }
1345
1346    if (!has_surround_mask && tf_estimate < QCONST16(.2f, 14))
1347    {
1348       opus_val16 amount;
1349       opus_val16 tvbr_factor;
1350       amount = MULT16_16_Q15(QCONST16(.0000031f, 30), IMAX(0, IMIN(32000, 96000-bitrate)));
1351       tvbr_factor = SHR32(MULT16_16(temporal_vbr, amount), DB_SHIFT);
1352       target += (opus_int32)MULT16_32_Q15(tvbr_factor, target);
1353    }
1354
1355    /* Don't allow more than doubling the rate */
1356    target = IMIN(2*base_target, target);
1357
1358    return target;
1359 }
1360
1361 int celt_encode_with_ec(CELTEncoder * OPUS_RESTRICT st, const opus_val16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
1362 {
1363    int i, c, N;
1364    opus_int32 bits;
1365    ec_enc _enc;
1366    VARDECL(celt_sig, in);
1367    VARDECL(celt_sig, freq);
1368    VARDECL(celt_norm, X);
1369    VARDECL(celt_ener, bandE);
1370    VARDECL(opus_val16, bandLogE);
1371    VARDECL(opus_val16, bandLogE2);
1372    VARDECL(int, fine_quant);
1373    VARDECL(opus_val16, error);
1374    VARDECL(int, pulses);
1375    VARDECL(int, cap);
1376    VARDECL(int, offsets);
1377    VARDECL(int, importance);
1378    VARDECL(int, fine_priority);
1379    VARDECL(int, tf_res);
1380    VARDECL(unsigned char, collapse_masks);
1381    celt_sig *prefilter_mem;
1382    opus_val16 *oldBandE, *oldLogE, *oldLogE2, *energyError;
1383    int shortBlocks=0;
1384    int isTransient=0;
1385    const int CC = st->channels;
1386    const int C = st->stream_channels;
1387    int LM, M;
1388    int tf_select;
1389    int nbFilledBytes, nbAvailableBytes;
1390    int start;
1391    int end;
1392    int effEnd;
1393    int codedBands;
1394    int alloc_trim;
1395    int pitch_index=COMBFILTER_MINPERIOD;
1396    opus_val16 gain1 = 0;
1397    int dual_stereo=0;
1398    int effectiveBytes;
1399    int dynalloc_logp;
1400    opus_int32 vbr_rate;
1401    opus_int32 total_bits;
1402    opus_int32 total_boost;
1403    opus_int32 balance;
1404    opus_int32 tell;
1405    opus_int32 tell0_frac;
1406    int prefilter_tapset=0;
1407    int pf_on;
1408    int anti_collapse_rsv;
1409    int anti_collapse_on=0;
1410    int silence=0;
1411    int tf_chan = 0;
1412    opus_val16 tf_estimate;
1413    int pitch_change=0;
1414    opus_int32 tot_boost;
1415    opus_val32 sample_max;
1416    opus_val16 maxDepth;
1417    const OpusCustomMode *mode;
1418    int nbEBands;
1419    int overlap;
1420    const opus_int16 *eBands;
1421    int secondMdct;
1422    int signalBandwidth;
1423    int transient_got_disabled=0;
1424    opus_val16 surround_masking=0;
1425    opus_val16 temporal_vbr=0;
1426    opus_val16 surround_trim = 0;
1427    opus_int32 equiv_rate;
1428    int hybrid;
1429    int weak_transient = 0;
1430    int enable_tf_analysis;
1431    VARDECL(opus_val16, surround_dynalloc);
1432    ALLOC_STACK;
1433
1434    mode = st->mode;
1435    nbEBands = mode->nbEBands;
1436    overlap = mode->overlap;
1437    eBands = mode->eBands;
1438    start = st->start;
1439    end = st->end;
1440    hybrid = start != 0;
1441    tf_estimate = 0;
1442    if (nbCompressedBytes<2 || pcm==NULL)
1443    {
1444       RESTORE_STACK;
1445       return OPUS_BAD_ARG;
1446    }
1447
1448    frame_size *= st->upsample;
1449    for (LM=0;LM<=mode->maxLM;LM++)
1450       if (mode->shortMdctSize<<LM==frame_size)
1451          break;
1452    if (LM>mode->maxLM)
1453    {
1454       RESTORE_STACK;
1455       return OPUS_BAD_ARG;
1456    }
1457    M=1<<LM;
1458    N = M*mode->shortMdctSize;
1459
1460    prefilter_mem = st->in_mem+CC*(overlap);
1461    oldBandE = (opus_val16*)(st->in_mem+CC*(overlap+COMBFILTER_MAXPERIOD));
1462    oldLogE = oldBandE + CC*nbEBands;
1463    oldLogE2 = oldLogE + CC*nbEBands;
1464    energyError = oldLogE2 + CC*nbEBands;
1465
1466    if (enc==NULL)
1467    {
1468       tell0_frac=tell=1;
1469       nbFilledBytes=0;
1470    } else {
1471       tell0_frac=ec_tell_frac(enc);
1472       tell=ec_tell(enc);
1473       nbFilledBytes=(tell+4)>>3;
1474    }
1475
1476 #ifdef CUSTOM_MODES
1477    if (st->signalling && enc==NULL)
1478    {
1479       int tmp = (mode->effEBands-end)>>1;
1480       end = st->end = IMAX(1, mode->effEBands-tmp);
1481       compressed[0] = tmp<<5;
1482       compressed[0] |= LM<<3;
1483       compressed[0] |= (C==2)<<2;
1484       /* Convert "standard mode" to Opus header */
1485       if (mode->Fs==48000 && mode->shortMdctSize==120)
1486       {
1487          int c0 = toOpus(compressed[0]);
1488          if (c0<0)
1489          {
1490             RESTORE_STACK;
1491             return OPUS_BAD_ARG;
1492          }
1493          compressed[0] = c0;
1494       }
1495       compressed++;
1496       nbCompressedBytes--;
1497    }
1498 #else
1499    celt_assert(st->signalling==0);
1500 #endif
1501
1502    /* Can't produce more than 1275 output bytes */
1503    nbCompressedBytes = IMIN(nbCompressedBytes,1275);
1504    nbAvailableBytes = nbCompressedBytes - nbFilledBytes;
1505
1506    if (st->vbr && st->bitrate!=OPUS_BITRATE_MAX)
1507    {
1508       opus_int32 den=mode->Fs>>BITRES;
1509       vbr_rate=(st->bitrate*frame_size+(den>>1))/den;
1510 #ifdef CUSTOM_MODES
1511       if (st->signalling)
1512          vbr_rate -= 8<<BITRES;
1513 #endif
1514       effectiveBytes = vbr_rate>>(3+BITRES);
1515    } else {
1516       opus_int32 tmp;
1517       vbr_rate = 0;
1518       tmp = st->bitrate*frame_size;
1519       if (tell>1)
1520          tmp += tell;
1521       if (st->bitrate!=OPUS_BITRATE_MAX)
1522          nbCompressedBytes = IMAX(2, IMIN(nbCompressedBytes,
1523                (tmp+4*mode->Fs)/(8*mode->Fs)-!!st->signalling));
1524       effectiveBytes = nbCompressedBytes - nbFilledBytes;
1525    }
1526    equiv_rate = ((opus_int32)nbCompressedBytes*8*50 >> (3-LM)) - (40*C+20)*((400>>LM) - 50);
1527    if (st->bitrate != OPUS_BITRATE_MAX)
1528       equiv_rate = IMIN(equiv_rate, st->bitrate - (40*C+20)*((400>>LM) - 50));
1529
1530    if (enc==NULL)
1531    {
1532       ec_enc_init(&_enc, compressed, nbCompressedBytes);
1533       enc = &_enc;
1534    }
1535
1536    if (vbr_rate>0)
1537    {
1538       /* Computes the max bit-rate allowed in VBR mode to avoid violating the
1539           target rate and buffering.
1540          We must do this up front so that bust-prevention logic triggers
1541           correctly if we don't have enough bits. */
1542       if (st->constrained_vbr)
1543       {
1544          opus_int32 vbr_bound;
1545          opus_int32 max_allowed;
1546          /* We could use any multiple of vbr_rate as bound (depending on the
1547              delay).
1548             This is clamped to ensure we use at least two bytes if the encoder
1549              was entirely empty, but to allow 0 in hybrid mode. */
1550          vbr_bound = vbr_rate;
1551          max_allowed = IMIN(IMAX(tell==1?2:0,
1552                (vbr_rate+vbr_bound-st->vbr_reservoir)>>(BITRES+3)),
1553                nbAvailableBytes);
1554          if(max_allowed < nbAvailableBytes)
1555          {
1556             nbCompressedBytes = nbFilledBytes+max_allowed;
1557             nbAvailableBytes = max_allowed;
1558             ec_enc_shrink(enc, nbCompressedBytes);
1559          }
1560       }
1561    }
1562    total_bits = nbCompressedBytes*8;
1563
1564    effEnd = end;
1565    if (effEnd > mode->effEBands)
1566       effEnd = mode->effEBands;
1567
1568    ALLOC(in, CC*(N+overlap), celt_sig);
1569
1570    sample_max=MAX32(st->overlap_max, celt_maxabs16(pcm, C*(N-overlap)/st->upsample));
1571    st->overlap_max=celt_maxabs16(pcm+C*(N-overlap)/st->upsample, C*overlap/st->upsample);
1572    sample_max=MAX32(sample_max, st->overlap_max);
1573 #ifdef FIXED_POINT
1574    silence = (sample_max==0);
1575 #else
1576    silence = (sample_max <= (opus_val16)1/(1<<st->lsb_depth));
1577 #endif
1578 #ifdef FUZZING
1579    if ((rand()&0x3F)==0)
1580       silence = 1;
1581 #endif
1582    if (tell==1)
1583       ec_enc_bit_logp(enc, silence, 15);
1584    else
1585       silence=0;
1586    if (silence)
1587    {
1588       /*In VBR mode there is no need to send more than the minimum. */
1589       if (vbr_rate>0)
1590       {
1591          effectiveBytes=nbCompressedBytes=IMIN(nbCompressedBytes, nbFilledBytes+2);
1592          total_bits=nbCompressedBytes*8;
1593          nbAvailableBytes=2;
1594          ec_enc_shrink(enc, nbCompressedBytes);
1595       }
1596       /* Pretend we've filled all the remaining bits with zeros
1597             (that's what the initialiser did anyway) */
1598       tell = nbCompressedBytes*8;
1599       enc->nbits_total+=tell-ec_tell(enc);
1600    }
1601    c=0; do {
1602       int need_clip=0;
1603 #ifndef FIXED_POINT
1604       need_clip = st->clip && sample_max>65536.f;
1605 #endif
1606       celt_preemphasis(pcm+c, in+c*(N+overlap)+overlap, N, CC, st->upsample,
1607                   mode->preemph, st->preemph_memE+c, need_clip);
1608    } while (++c<CC);
1609
1610
1611
1612    /* Find pitch period and gain */
1613    {
1614       int enabled;
1615       int qg;
1616       enabled = ((st->lfe&&nbAvailableBytes>3) || nbAvailableBytes>12*C) && !hybrid && !silence && !st->disable_pf
1617             && st->complexity >= 5;
1618
1619       prefilter_tapset = st->tapset_decision;
1620       pf_on = run_prefilter(st, in, prefilter_mem, CC, N, prefilter_tapset, &pitch_index, &gain1, &qg, enabled, nbAvailableBytes, &st->analysis);
1621       if ((gain1 > QCONST16(.4f,15) || st->prefilter_gain > QCONST16(.4f,15)) && (!st->analysis.valid || st->analysis.tonality > .3)
1622             && (pitch_index > 1.26*st->prefilter_period || pitch_index < .79*st->prefilter_period))
1623          pitch_change = 1;
1624       if (pf_on==0)
1625       {
1626          if(!hybrid && tell+16<=total_bits)
1627             ec_enc_bit_logp(enc, 0, 1);
1628       } else {
1629          /*This block is not gated by a total bits check only because
1630            of the nbAvailableBytes check above.*/
1631          int octave;
1632          ec_enc_bit_logp(enc, 1, 1);
1633          pitch_index += 1;
1634          octave = EC_ILOG(pitch_index)-5;
1635          ec_enc_uint(enc, octave, 6);
1636          ec_enc_bits(enc, pitch_index-(16<<octave), 4+octave);
1637          pitch_index -= 1;
1638          ec_enc_bits(enc, qg, 3);
1639          ec_enc_icdf(enc, prefilter_tapset, tapset_icdf, 2);
1640       }
1641    }
1642
1643    isTransient = 0;
1644    shortBlocks = 0;
1645    if (st->complexity >= 1 && !st->lfe)
1646    {
1647       /* Reduces the likelihood of energy instability on fricatives at low bitrate
1648          in hybrid mode. It seems like we still want to have real transients on vowels
1649          though (small SILK quantization offset value). */
1650       int allow_weak_transients = hybrid && effectiveBytes<15 && st->silk_info.offset >= 100;
1651       isTransient = transient_analysis(in, N+overlap, CC,
1652             &tf_estimate, &tf_chan, allow_weak_transients, &weak_transient);
1653    }
1654    if (LM>0 && ec_tell(enc)+3<=total_bits)
1655    {
1656       if (isTransient)
1657          shortBlocks = M;
1658    } else {
1659       isTransient = 0;
1660       transient_got_disabled=1;
1661    }
1662
1663    ALLOC(freq, CC*N, celt_sig); /**< Interleaved signal MDCTs */
1664    ALLOC(bandE,nbEBands*CC, celt_ener);
1665    ALLOC(bandLogE,nbEBands*CC, opus_val16);
1666
1667    secondMdct = shortBlocks && st->complexity>=8;
1668    ALLOC(bandLogE2, C*nbEBands, opus_val16);
1669    if (secondMdct)
1670    {
1671       compute_mdcts(mode, 0, in, freq, C, CC, LM, st->upsample, st->arch);
1672       compute_band_energies(mode, freq, bandE, effEnd, C, LM, st->arch);
1673       amp2Log2(mode, effEnd, end, bandE, bandLogE2, C);
1674       for (i=0;i<C*nbEBands;i++)
1675          bandLogE2[i] += HALF16(SHL16(LM, DB_SHIFT));
1676    }
1677
1678    compute_mdcts(mode, shortBlocks, in, freq, C, CC, LM, st->upsample, st->arch);
1679    if (CC==2&&C==1)
1680       tf_chan = 0;
1681    compute_band_energies(mode, freq, bandE, effEnd, C, LM, st->arch);
1682
1683    if (st->lfe)
1684    {
1685       for (i=2;i<end;i++)
1686       {
1687          bandE[i] = IMIN(bandE[i], MULT16_32_Q15(QCONST16(1e-4f,15),bandE[0]));
1688          bandE[i] = MAX32(bandE[i], EPSILON);
1689       }
1690    }
1691    amp2Log2(mode, effEnd, end, bandE, bandLogE, C);
1692
1693    ALLOC(surround_dynalloc, C*nbEBands, opus_val16);
1694    OPUS_CLEAR(surround_dynalloc, end);
1695    /* This computes how much masking takes place between surround channels */
1696    if (!hybrid&&st->energy_mask&&!st->lfe)
1697    {
1698       int mask_end;
1699       int midband;
1700       int count_dynalloc;
1701       opus_val32 mask_avg=0;
1702       opus_val32 diff=0;
1703       int count=0;
1704       mask_end = IMAX(2,st->lastCodedBands);
1705       for (c=0;c<C;c++)
1706       {
1707          for(i=0;i<mask_end;i++)
1708          {
1709             opus_val16 mask;
1710             mask = MAX16(MIN16(st->energy_mask[nbEBands*c+i],
1711                    QCONST16(.25f, DB_SHIFT)), -QCONST16(2.0f, DB_SHIFT));
1712             if (mask > 0)
1713                mask = HALF16(mask);
1714             mask_avg += MULT16_16(mask, eBands[i+1]-eBands[i]);
1715             count += eBands[i+1]-eBands[i];
1716             diff += MULT16_16(mask, 1+2*i-mask_end);
1717          }
1718       }
1719       celt_assert(count>0);
1720       mask_avg = DIV32_16(mask_avg,count);
1721       mask_avg += QCONST16(.2f, DB_SHIFT);
1722       diff = diff*6/(C*(mask_end-1)*(mask_end+1)*mask_end);
1723       /* Again, being conservative */
1724       diff = HALF32(diff);
1725       diff = MAX32(MIN32(diff, QCONST32(.031f, DB_SHIFT)), -QCONST32(.031f, DB_SHIFT));
1726       /* Find the band that's in the middle of the coded spectrum */
1727       for (midband=0;eBands[midband+1] < eBands[mask_end]/2;midband++);
1728       count_dynalloc=0;
1729       for(i=0;i<mask_end;i++)
1730       {
1731          opus_val32 lin;
1732          opus_val16 unmask;
1733          lin = mask_avg + diff*(i-midband);
1734          if (C==2)
1735             unmask = MAX16(st->energy_mask[i], st->energy_mask[nbEBands+i]);
1736          else
1737             unmask = st->energy_mask[i];
1738          unmask = MIN16(unmask, QCONST16(.0f, DB_SHIFT));
1739          unmask -= lin;
1740          if (unmask > QCONST16(.25f, DB_SHIFT))
1741          {
1742             surround_dynalloc[i] = unmask - QCONST16(.25f, DB_SHIFT);
1743             count_dynalloc++;
1744          }
1745       }
1746       if (count_dynalloc>=3)
1747       {
1748          /* If we need dynalloc in many bands, it's probably because our
1749             initial masking rate was too low. */
1750          mask_avg += QCONST16(.25f, DB_SHIFT);
1751          if (mask_avg>0)
1752          {
1753             /* Something went really wrong in the original calculations,
1754                disabling masking. */
1755             mask_avg = 0;
1756             diff = 0;
1757             OPUS_CLEAR(surround_dynalloc, mask_end);
1758          } else {
1759             for(i=0;i<mask_end;i++)
1760                surround_dynalloc[i] = MAX16(0, surround_dynalloc[i]-QCONST16(.25f, DB_SHIFT));
1761          }
1762       }
1763       mask_avg += QCONST16(.2f, DB_SHIFT);
1764       /* Convert to 1/64th units used for the trim */
1765       surround_trim = 64*diff;
1766       /*printf("%d %d ", mask_avg, surround_trim);*/
1767       surround_masking = mask_avg;
1768    }
1769    /* Temporal VBR (but not for LFE) */
1770    if (!st->lfe)
1771    {
1772       opus_val16 follow=-QCONST16(10.0f,DB_SHIFT);
1773       opus_val32 frame_avg=0;
1774       opus_val16 offset = shortBlocks?HALF16(SHL16(LM, DB_SHIFT)):0;
1775       for(i=start;i<end;i++)
1776       {
1777          follow = MAX16(follow-QCONST16(1.f, DB_SHIFT), bandLogE[i]-offset);
1778          if (C==2)
1779             follow = MAX16(follow, bandLogE[i+nbEBands]-offset);
1780          frame_avg += follow;
1781       }
1782       frame_avg /= (end-start);
1783       temporal_vbr = SUB16(frame_avg,st->spec_avg);
1784       temporal_vbr = MIN16(QCONST16(3.f, DB_SHIFT), MAX16(-QCONST16(1.5f, DB_SHIFT), temporal_vbr));
1785       st->spec_avg += MULT16_16_Q15(QCONST16(.02f, 15), temporal_vbr);
1786    }
1787    /*for (i=0;i<21;i++)
1788       printf("%f ", bandLogE[i]);
1789    printf("\n");*/
1790
1791    if (!secondMdct)
1792    {
1793       OPUS_COPY(bandLogE2, bandLogE, C*nbEBands);
1794    }
1795
1796    /* Last chance to catch any transient we might have missed in the
1797       time-domain analysis */
1798    if (LM>0 && ec_tell(enc)+3<=total_bits && !isTransient && st->complexity>=5 && !st->lfe && !hybrid)
1799    {
1800       if (patch_transient_decision(bandLogE, oldBandE, nbEBands, start, end, C))
1801       {
1802          isTransient = 1;
1803          shortBlocks = M;
1804          compute_mdcts(mode, shortBlocks, in, freq, C, CC, LM, st->upsample, st->arch);
1805          compute_band_energies(mode, freq, bandE, effEnd, C, LM, st->arch);
1806          amp2Log2(mode, effEnd, end, bandE, bandLogE, C);
1807          /* Compensate for the scaling of short vs long mdcts */
1808          for (i=0;i<C*nbEBands;i++)
1809             bandLogE2[i] += HALF16(SHL16(LM, DB_SHIFT));
1810          tf_estimate = QCONST16(.2f,14);
1811       }
1812    }
1813
1814    if (LM>0 && ec_tell(enc)+3<=total_bits)
1815       ec_enc_bit_logp(enc, isTransient, 3);
1816
1817    ALLOC(X, C*N, celt_norm);         /**< Interleaved normalised MDCTs */
1818
1819    /* Band normalisation */
1820    normalise_bands(mode, freq, X, bandE, effEnd, C, M);
1821
1822    enable_tf_analysis = effectiveBytes>=15*C && !hybrid && st->complexity>=2 && !st->lfe;
1823
1824    ALLOC(offsets, nbEBands, int);
1825    ALLOC(importance, nbEBands, int);
1826
1827    maxDepth = dynalloc_analysis(bandLogE, bandLogE2, nbEBands, start, end, C, offsets,
1828          st->lsb_depth, mode->logN, isTransient, st->vbr, st->constrained_vbr,
1829          eBands, LM, effectiveBytes, &tot_boost, st->lfe, surround_dynalloc, &st->analysis, importance);
1830
1831    ALLOC(tf_res, nbEBands, int);
1832    /* Disable variable tf resolution for hybrid and at very low bitrate */
1833    if (enable_tf_analysis)
1834    {
1835       int lambda;
1836       lambda = IMAX(80, 20480/effectiveBytes + 2);
1837       tf_select = tf_analysis(mode, effEnd, isTransient, tf_res, lambda, X, N, LM, tf_estimate, tf_chan, importance);
1838       for (i=effEnd;i<end;i++)
1839          tf_res[i] = tf_res[effEnd-1];
1840    } else if (hybrid && weak_transient)
1841    {
1842       /* For weak transients, we rely on the fact that improving time resolution using
1843          TF on a long window is imperfect and will not result in an energy collapse at
1844          low bitrate. */
1845       for (i=0;i<end;i++)
1846          tf_res[i] = 1;
1847       tf_select=0;
1848    } else if (hybrid && effectiveBytes<15)
1849    {
1850       /* For low bitrate hybrid, we force temporal resolution to 5 ms rather than 2.5 ms. */
1851       for (i=0;i<end;i++)
1852          tf_res[i] = 0;
1853       tf_select=isTransient;
1854    } else {
1855       for (i=0;i<end;i++)
1856          tf_res[i] = isTransient;
1857       tf_select=0;
1858    }
1859
1860    ALLOC(error, C*nbEBands, opus_val16);
1861    c=0;
1862    do {
1863       for (i=start;i<end;i++)
1864       {
1865          /* When the energy is stable, slightly bias energy quantization towards
1866             the previous error to make the gain more stable (a constant offset is
1867             better than fluctuations). */
1868          if (ABS32(SUB32(bandLogE[i+c*nbEBands], oldBandE[i+c*nbEBands])) < QCONST16(2.f, DB_SHIFT))
1869          {
1870             bandLogE[i+c*nbEBands] -= MULT16_16_Q15(energyError[i+c*nbEBands], QCONST16(0.25f, 15));
1871          }
1872       }
1873    } while (++c < C);
1874    quant_coarse_energy(mode, start, end, effEnd, bandLogE,
1875          oldBandE, total_bits, error, enc,
1876          C, LM, nbAvailableBytes, st->force_intra,
1877          &st->delayedIntra, st->complexity >= 4, st->loss_rate, st->lfe);
1878
1879    tf_encode(start, end, isTransient, tf_res, LM, tf_select, enc);
1880
1881    if (ec_tell(enc)+4<=total_bits)
1882    {
1883       if (st->lfe)
1884       {
1885          st->tapset_decision = 0;
1886          st->spread_decision = SPREAD_NORMAL;
1887       } else if (hybrid)
1888       {
1889          if (st->complexity == 0)
1890             st->spread_decision = SPREAD_NONE;
1891          else if (isTransient)
1892             st->spread_decision = SPREAD_NORMAL;
1893          else
1894             st->spread_decision = SPREAD_AGGRESSIVE;
1895       } else if (shortBlocks || st->complexity < 3 || nbAvailableBytes < 10*C)
1896       {
1897          if (st->complexity == 0)
1898             st->spread_decision = SPREAD_NONE;
1899          else
1900             st->spread_decision = SPREAD_NORMAL;
1901       } else {
1902          /* Disable new spreading+tapset estimator until we can show it works
1903             better than the old one. So far it seems like spreading_decision()
1904             works best. */
1905 #if 0
1906          if (st->analysis.valid)
1907          {
1908             static const opus_val16 spread_thresholds[3] = {-QCONST16(.6f, 15), -QCONST16(.2f, 15), -QCONST16(.07f, 15)};
1909             static const opus_val16 spread_histeresis[3] = {QCONST16(.15f, 15), QCONST16(.07f, 15), QCONST16(.02f, 15)};
1910             static const opus_val16 tapset_thresholds[2] = {QCONST16(.0f, 15), QCONST16(.15f, 15)};
1911             static const opus_val16 tapset_histeresis[2] = {QCONST16(.1f, 15), QCONST16(.05f, 15)};
1912             st->spread_decision = hysteresis_decision(-st->analysis.tonality, spread_thresholds, spread_histeresis, 3, st->spread_decision);
1913             st->tapset_decision = hysteresis_decision(st->analysis.tonality_slope, tapset_thresholds, tapset_histeresis, 2, st->tapset_decision);
1914          } else
1915 #endif
1916          {
1917             st->spread_decision = spreading_decision(mode, X,
1918                   &st->tonal_average, st->spread_decision, &st->hf_average,
1919                   &st->tapset_decision, pf_on&&!shortBlocks, effEnd, C, M);
1920          }
1921          /*printf("%d %d\n", st->tapset_decision, st->spread_decision);*/
1922          /*printf("%f %d %f %d\n\n", st->analysis.tonality, st->spread_decision, st->analysis.tonality_slope, st->tapset_decision);*/
1923       }
1924       ec_enc_icdf(enc, st->spread_decision, spread_icdf, 5);
1925    }
1926
1927    /* For LFE, everything interesting is in the first band */
1928    if (st->lfe)
1929       offsets[0] = IMIN(8, effectiveBytes/3);
1930    ALLOC(cap, nbEBands, int);
1931    init_caps(mode,cap,LM,C);
1932
1933    dynalloc_logp = 6;
1934    total_bits<<=BITRES;
1935    total_boost = 0;
1936    tell = ec_tell_frac(enc);
1937    for (i=start;i<end;i++)
1938    {
1939       int width, quanta;
1940       int dynalloc_loop_logp;
1941       int boost;
1942       int j;
1943       width = C*(eBands[i+1]-eBands[i])<<LM;
1944       /* quanta is 6 bits, but no more than 1 bit/sample
1945          and no less than 1/8 bit/sample */
1946       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
1947       dynalloc_loop_logp = dynalloc_logp;
1948       boost = 0;
1949       for (j = 0; tell+(dynalloc_loop_logp<<BITRES) < total_bits-total_boost
1950             && boost < cap[i]; j++)
1951       {
1952          int flag;
1953          flag = j<offsets[i];
1954          ec_enc_bit_logp(enc, flag, dynalloc_loop_logp);
1955          tell = ec_tell_frac(enc);
1956          if (!flag)
1957             break;
1958          boost += quanta;
1959          total_boost += quanta;
1960          dynalloc_loop_logp = 1;
1961       }
1962       /* Making dynalloc more likely */
1963       if (j)
1964          dynalloc_logp = IMAX(2, dynalloc_logp-1);
1965       offsets[i] = boost;
1966    }
1967
1968    if (C==2)
1969    {
1970       static const opus_val16 intensity_thresholds[21]=
1971       /* 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19  20  off*/
1972         {  1, 2, 3, 4, 5, 6, 7, 8,16,24,36,44,50,56,62,67,72,79,88,106,134};
1973       static const opus_val16 intensity_histeresis[21]=
1974         {  1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 4, 5, 6,  8, 8};
1975
1976       /* Always use MS for 2.5 ms frames until we can do a better analysis */
1977       if (LM!=0)
1978          dual_stereo = stereo_analysis(mode, X, LM, N);
1979
1980       st->intensity = hysteresis_decision((opus_val16)(equiv_rate/1000),
1981             intensity_thresholds, intensity_histeresis, 21, st->intensity);
1982       st->intensity = IMIN(end,IMAX(start, st->intensity));
1983    }
1984
1985    alloc_trim = 5;
1986    if (tell+(6<<BITRES) <= total_bits - total_boost)
1987    {
1988       if (start > 0 || st->lfe)
1989       {
1990          st->stereo_saving = 0;
1991          alloc_trim = 5;
1992       } else {
1993          alloc_trim = alloc_trim_analysis(mode, X, bandLogE,
1994             end, LM, C, N, &st->analysis, &st->stereo_saving, tf_estimate,
1995             st->intensity, surround_trim, equiv_rate, st->arch);
1996       }
1997       ec_enc_icdf(enc, alloc_trim, trim_icdf, 7);
1998       tell = ec_tell_frac(enc);
1999    }
2000
2001    /* Variable bitrate */
2002    if (vbr_rate>0)
2003    {
2004      opus_val16 alpha;
2005      opus_int32 delta;
2006      /* The target rate in 8th bits per frame */
2007      opus_int32 target, base_target;
2008      opus_int32 min_allowed;
2009      int lm_diff = mode->maxLM - LM;
2010
2011      /* Don't attempt to use more than 510 kb/s, even for frames smaller than 20 ms.
2012         The CELT allocator will just not be able to use more than that anyway. */
2013      nbCompressedBytes = IMIN(nbCompressedBytes,1275>>(3-LM));
2014      if (!hybrid)
2015      {
2016         base_target = vbr_rate - ((40*C+20)<<BITRES);
2017      } else {
2018         base_target = IMAX(0, vbr_rate - ((9*C+4)<<BITRES));
2019      }
2020
2021      if (st->constrained_vbr)
2022         base_target += (st->vbr_offset>>lm_diff);
2023
2024      if (!hybrid)
2025      {
2026         target = compute_vbr(mode, &st->analysis, base_target, LM, equiv_rate,
2027            st->lastCodedBands, C, st->intensity, st->constrained_vbr,
2028            st->stereo_saving, tot_boost, tf_estimate, pitch_change, maxDepth,
2029            st->lfe, st->energy_mask!=NULL, surround_masking,
2030            temporal_vbr);
2031      } else {
2032         target = base_target;
2033         /* Tonal frames (offset<100) need more bits than noisy (offset>100) ones. */
2034         if (st->silk_info.offset < 100) target += 12 << BITRES >> (3-LM);
2035         if (st->silk_info.offset > 100) target -= 18 << BITRES >> (3-LM);
2036         /* Boosting bitrate on transients and vowels with significant temporal
2037            spikes. */
2038         target += (opus_int32)MULT16_16_Q14(tf_estimate-QCONST16(.25f,14), (50<<BITRES));
2039         /* If we have a strong transient, let's make sure it has enough bits to code
2040            the first two bands, so that it can use folding rather than noise. */
2041         if (tf_estimate > QCONST16(.7f,14))
2042            target = IMAX(target, 50<<BITRES);
2043      }
2044      /* The current offset is removed from the target and the space used
2045         so far is added*/
2046      target=target+tell;
2047      /* In VBR mode the frame size must not be reduced so much that it would
2048          result in the encoder running out of bits.
2049         The margin of 2 bytes ensures that none of the bust-prevention logic
2050          in the decoder will have triggered so far. */
2051      min_allowed = ((tell+total_boost+(1<<(BITRES+3))-1)>>(BITRES+3)) + 2;
2052      /* Take into account the 37 bits we need to have left in the packet to
2053         signal a redundant frame in hybrid mode. Creating a shorter packet would
2054         create an entropy coder desync. */
2055      if (hybrid)
2056         min_allowed = IMAX(min_allowed, (tell0_frac+(37<<BITRES)+total_boost+(1<<(BITRES+3))-1)>>(BITRES+3));
2057
2058      nbAvailableBytes = (target+(1<<(BITRES+2)))>>(BITRES+3);
2059      nbAvailableBytes = IMAX(min_allowed,nbAvailableBytes);
2060      nbAvailableBytes = IMIN(nbCompressedBytes,nbAvailableBytes);
2061
2062      /* By how much did we "miss" the target on that frame */
2063      delta = target - vbr_rate;
2064
2065      target=nbAvailableBytes<<(BITRES+3);
2066
2067      /*If the frame is silent we don't adjust our drift, otherwise
2068        the encoder will shoot to very high rates after hitting a
2069        span of silence, but we do allow the bitres to refill.
2070        This means that we'll undershoot our target in CVBR/VBR modes
2071        on files with lots of silence. */
2072      if(silence)
2073      {
2074        nbAvailableBytes = 2;
2075        target = 2*8<<BITRES;
2076        delta = 0;
2077      }
2078
2079      if (st->vbr_count < 970)
2080      {
2081         st->vbr_count++;
2082         alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+20),16));
2083      } else
2084         alpha = QCONST16(.001f,15);
2085      /* How many bits have we used in excess of what we're allowed */
2086      if (st->constrained_vbr)
2087         st->vbr_reservoir += target - vbr_rate;
2088      /*printf ("%d\n", st->vbr_reservoir);*/
2089
2090      /* Compute the offset we need to apply in order to reach the target */
2091      if (st->constrained_vbr)
2092      {
2093         st->vbr_drift += (opus_int32)MULT16_32_Q15(alpha,(delta*(1<<lm_diff))-st->vbr_offset-st->vbr_drift);
2094         st->vbr_offset = -st->vbr_drift;
2095      }
2096      /*printf ("%d\n", st->vbr_drift);*/
2097
2098      if (st->constrained_vbr && st->vbr_reservoir < 0)
2099      {
2100         /* We're under the min value -- increase rate */
2101         int adjust = (-st->vbr_reservoir)/(8<<BITRES);
2102         /* Unless we're just coding silence */
2103         nbAvailableBytes += silence?0:adjust;
2104         st->vbr_reservoir = 0;
2105         /*printf ("+%d\n", adjust);*/
2106      }
2107      nbCompressedBytes = IMIN(nbCompressedBytes,nbAvailableBytes);
2108      /*printf("%d\n", nbCompressedBytes*50*8);*/
2109      /* This moves the raw bits to take into account the new compressed size */
2110      ec_enc_shrink(enc, nbCompressedBytes);
2111    }
2112
2113    /* Bit allocation */
2114    ALLOC(fine_quant, nbEBands, int);
2115    ALLOC(pulses, nbEBands, int);
2116    ALLOC(fine_priority, nbEBands, int);
2117
2118    /* bits =           packet size                    - where we are - safety*/
2119    bits = (((opus_int32)nbCompressedBytes*8)<<BITRES) - ec_tell_frac(enc) - 1;
2120    anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0;
2121    bits -= anti_collapse_rsv;
2122    signalBandwidth = end-1;
2123 #ifndef DISABLE_FLOAT_API
2124    if (st->analysis.valid)
2125    {
2126       int min_bandwidth;
2127       if (equiv_rate < (opus_int32)32000*C)
2128          min_bandwidth = 13;
2129       else if (equiv_rate < (opus_int32)48000*C)
2130          min_bandwidth = 16;
2131       else if (equiv_rate < (opus_int32)60000*C)
2132          min_bandwidth = 18;
2133       else  if (equiv_rate < (opus_int32)80000*C)
2134          min_bandwidth = 19;
2135       else
2136          min_bandwidth = 20;
2137       signalBandwidth = IMAX(st->analysis.bandwidth, min_bandwidth);
2138    }
2139 #endif
2140    if (st->lfe)
2141       signalBandwidth = 1;
2142    codedBands = compute_allocation(mode, start, end, offsets, cap,
2143          alloc_trim, &st->intensity, &dual_stereo, bits, &balance, pulses,
2144          fine_quant, fine_priority, C, LM, enc, 1, st->lastCodedBands, signalBandwidth);
2145    if (st->lastCodedBands)
2146       st->lastCodedBands = IMIN(st->lastCodedBands+1,IMAX(st->lastCodedBands-1,codedBands));
2147    else
2148       st->lastCodedBands = codedBands;
2149
2150    quant_fine_energy(mode, start, end, oldBandE, error, fine_quant, enc, C);
2151
2152    /* Residual quantisation */
2153    ALLOC(collapse_masks, C*nbEBands, unsigned char);
2154    quant_all_bands(1, mode, start, end, X, C==2 ? X+N : NULL, collapse_masks,
2155          bandE, pulses, shortBlocks, st->spread_decision,
2156          dual_stereo, st->intensity, tf_res, nbCompressedBytes*(8<<BITRES)-anti_collapse_rsv,
2157          balance, enc, LM, codedBands, &st->rng, st->complexity, st->arch, st->disable_inv);
2158
2159    if (anti_collapse_rsv > 0)
2160    {
2161       anti_collapse_on = st->consec_transient<2;
2162 #ifdef FUZZING
2163       anti_collapse_on = rand()&0x1;
2164 #endif
2165       ec_enc_bits(enc, anti_collapse_on, 1);
2166    }
2167    quant_energy_finalise(mode, start, end, oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_tell(enc), enc, C);
2168    OPUS_CLEAR(energyError, nbEBands*CC);
2169    c=0;
2170    do {
2171       for (i=start;i<end;i++)
2172       {
2173          energyError[i+c*nbEBands] = MAX16(-QCONST16(0.5f, 15), MIN16(QCONST16(0.5f, 15), error[i+c*nbEBands]));
2174       }
2175    } while (++c < C);
2176
2177    if (silence)
2178    {
2179       for (i=0;i<C*nbEBands;i++)
2180          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
2181    }
2182
2183 #ifdef RESYNTH
2184    /* Re-synthesis of the coded audio if required */
2185    {
2186       celt_sig *out_mem[2];
2187
2188       if (anti_collapse_on)
2189       {
2190          anti_collapse(mode, X, collapse_masks, LM, C, N,
2191                start, end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
2192       }
2193
2194       c=0; do {
2195          OPUS_MOVE(st->syn_mem[c], st->syn_mem[c]+N, 2*MAX_PERIOD-N+overlap/2);
2196       } while (++c<CC);
2197
2198       c=0; do {
2199          out_mem[c] = st->syn_mem[c]+2*MAX_PERIOD-N;
2200       } while (++c<CC);
2201
2202       celt_synthesis(mode, X, out_mem, oldBandE, start, effEnd,
2203                      C, CC, isTransient, LM, st->upsample, silence, st->arch);
2204
2205       c=0; do {
2206          st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
2207          st->prefilter_period_old=IMAX(st->prefilter_period_old, COMBFILTER_MINPERIOD);
2208          comb_filter(out_mem[c], out_mem[c], st->prefilter_period_old, st->prefilter_period, mode->shortMdctSize,
2209                st->prefilter_gain_old, st->prefilter_gain, st->prefilter_tapset_old, st->prefilter_tapset,
2210                mode->window, overlap);
2211          if (LM!=0)
2212             comb_filter(out_mem[c]+mode->shortMdctSize, out_mem[c]+mode->shortMdctSize, st->prefilter_period, pitch_index, N-mode->shortMdctSize,
2213                   st->prefilter_gain, gain1, st->prefilter_tapset, prefilter_tapset,
2214                   mode->window, overlap);
2215       } while (++c<CC);
2216
2217       /* We reuse freq[] as scratch space for the de-emphasis */
2218       deemphasis(out_mem, (opus_val16*)pcm, N, CC, st->upsample, mode->preemph, st->preemph_memD);
2219       st->prefilter_period_old = st->prefilter_period;
2220       st->prefilter_gain_old = st->prefilter_gain;
2221       st->prefilter_tapset_old = st->prefilter_tapset;
2222    }
2223 #endif
2224
2225    st->prefilter_period = pitch_index;
2226    st->prefilter_gain = gain1;
2227    st->prefilter_tapset = prefilter_tapset;
2228 #ifdef RESYNTH
2229    if (LM!=0)
2230    {
2231       st->prefilter_period_old = st->prefilter_period;
2232       st->prefilter_gain_old = st->prefilter_gain;
2233       st->prefilter_tapset_old = st->prefilter_tapset;
2234    }
2235 #endif
2236
2237    if (CC==2&&C==1) {
2238       OPUS_COPY(&oldBandE[nbEBands], oldBandE, nbEBands);
2239    }
2240
2241    if (!isTransient)
2242    {
2243       OPUS_COPY(oldLogE2, oldLogE, CC*nbEBands);
2244       OPUS_COPY(oldLogE, oldBandE, CC*nbEBands);
2245    } else {
2246       for (i=0;i<CC*nbEBands;i++)
2247          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
2248    }
2249    /* In case start or end were to change */
2250    c=0; do
2251    {
2252       for (i=0;i<start;i++)
2253       {
2254          oldBandE[c*nbEBands+i]=0;
2255          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
2256       }
2257       for (i=end;i<nbEBands;i++)
2258       {
2259          oldBandE[c*nbEBands+i]=0;
2260          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
2261       }
2262    } while (++c<CC);
2263
2264    if (isTransient || transient_got_disabled)
2265       st->consec_transient++;
2266    else
2267       st->consec_transient=0;
2268    st->rng = enc->rng;
2269
2270    /* If there's any room left (can only happen for very high rates),
2271       it's already filled with zeros */
2272    ec_enc_done(enc);
2273
2274 #ifdef CUSTOM_MODES
2275    if (st->signalling)
2276       nbCompressedBytes++;
2277 #endif
2278
2279    RESTORE_STACK;
2280    if (ec_get_error(enc))
2281       return OPUS_INTERNAL_ERROR;
2282    else
2283       return nbCompressedBytes;
2284 }
2285
2286
2287 #ifdef CUSTOM_MODES
2288
2289 #ifdef FIXED_POINT
2290 int opus_custom_encode(CELTEncoder * OPUS_RESTRICT st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2291 {
2292    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
2293 }
2294
2295 #ifndef DISABLE_FLOAT_API
2296 int opus_custom_encode_float(CELTEncoder * OPUS_RESTRICT st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2297 {
2298    int j, ret, C, N;
2299    VARDECL(opus_int16, in);
2300    ALLOC_STACK;
2301
2302    if (pcm==NULL)
2303       return OPUS_BAD_ARG;
2304
2305    C = st->channels;
2306    N = frame_size;
2307    ALLOC(in, C*N, opus_int16);
2308
2309    for (j=0;j<C*N;j++)
2310      in[j] = FLOAT2INT16(pcm[j]);
2311
2312    ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
2313 #ifdef RESYNTH
2314    for (j=0;j<C*N;j++)
2315       ((float*)pcm)[j]=in[j]*(1.f/32768.f);
2316 #endif
2317    RESTORE_STACK;
2318    return ret;
2319 }
2320 #endif /* DISABLE_FLOAT_API */
2321 #else
2322
2323 int opus_custom_encode(CELTEncoder * OPUS_RESTRICT st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2324 {
2325    int j, ret, C, N;
2326    VARDECL(celt_sig, in);
2327    ALLOC_STACK;
2328
2329    if (pcm==NULL)
2330       return OPUS_BAD_ARG;
2331
2332    C=st->channels;
2333    N=frame_size;
2334    ALLOC(in, C*N, celt_sig);
2335    for (j=0;j<C*N;j++) {
2336      in[j] = SCALEOUT(pcm[j]);
2337    }
2338
2339    ret = celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
2340 #ifdef RESYNTH
2341    for (j=0;j<C*N;j++)
2342       ((opus_int16*)pcm)[j] = FLOAT2INT16(in[j]);
2343 #endif
2344    RESTORE_STACK;
2345    return ret;
2346 }
2347
2348 int opus_custom_encode_float(CELTEncoder * OPUS_RESTRICT st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2349 {
2350    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
2351 }
2352
2353 #endif
2354
2355 #endif /* CUSTOM_MODES */
2356
2357 int opus_custom_encoder_ctl(CELTEncoder * OPUS_RESTRICT st, int request, ...)
2358 {
2359    va_list ap;
2360
2361    va_start(ap, request);
2362    switch (request)
2363    {
2364       case OPUS_SET_COMPLEXITY_REQUEST:
2365       {
2366          int value = va_arg(ap, opus_int32);
2367          if (value<0 || value>10)
2368             goto bad_arg;
2369          st->complexity = value;
2370       }
2371       break;
2372       case CELT_SET_START_BAND_REQUEST:
2373       {
2374          opus_int32 value = va_arg(ap, opus_int32);
2375          if (value<0 || value>=st->mode->nbEBands)
2376             goto bad_arg;
2377          st->start = value;
2378       }
2379       break;
2380       case CELT_SET_END_BAND_REQUEST:
2381       {
2382          opus_int32 value = va_arg(ap, opus_int32);
2383          if (value<1 || value>st->mode->nbEBands)
2384             goto bad_arg;
2385          st->end = value;
2386       }
2387       break;
2388       case CELT_SET_PREDICTION_REQUEST:
2389       {
2390          int value = va_arg(ap, opus_int32);
2391          if (value<0 || value>2)
2392             goto bad_arg;
2393          st->disable_pf = value<=1;
2394          st->force_intra = value==0;
2395       }
2396       break;
2397       case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2398       {
2399          int value = va_arg(ap, opus_int32);
2400          if (value<0 || value>100)
2401             goto bad_arg;
2402          st->loss_rate = value;
2403       }
2404       break;
2405       case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2406       {
2407          opus_int32 value = va_arg(ap, opus_int32);
2408          st->constrained_vbr = value;
2409       }
2410       break;
2411       case OPUS_SET_VBR_REQUEST:
2412       {
2413          opus_int32 value = va_arg(ap, opus_int32);
2414          st->vbr = value;
2415       }
2416       break;
2417       case OPUS_SET_BITRATE_REQUEST:
2418       {
2419          opus_int32 value = va_arg(ap, opus_int32);
2420          if (value<=500 && value!=OPUS_BITRATE_MAX)
2421             goto bad_arg;
2422          value = IMIN(value, 260000*st->channels);
2423          st->bitrate = value;
2424       }
2425       break;
2426       case CELT_SET_CHANNELS_REQUEST:
2427       {
2428          opus_int32 value = va_arg(ap, opus_int32);
2429          if (value<1 || value>2)
2430             goto bad_arg;
2431          st->stream_channels = value;
2432       }
2433       break;
2434       case OPUS_SET_LSB_DEPTH_REQUEST:
2435       {
2436           opus_int32 value = va_arg(ap, opus_int32);
2437           if (value<8 || value>24)
2438              goto bad_arg;
2439           st->lsb_depth=value;
2440       }
2441       break;
2442       case OPUS_GET_LSB_DEPTH_REQUEST:
2443       {
2444           opus_int32 *value = va_arg(ap, opus_int32*);
2445           *value=st->lsb_depth;
2446       }
2447       break;
2448       case OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST:
2449       {
2450           opus_int32 value = va_arg(ap, opus_int32);
2451           if(value<0 || value>1)
2452           {
2453              goto bad_arg;
2454           }
2455           st->disable_inv = value;
2456       }
2457       break;
2458       case OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST:
2459       {
2460           opus_int32 *value = va_arg(ap, opus_int32*);
2461           if (!value)
2462           {
2463              goto bad_arg;
2464           }
2465           *value = st->disable_inv;
2466       }
2467       break;
2468       case OPUS_RESET_STATE:
2469       {
2470          int i;
2471          opus_val16 *oldBandE, *oldLogE, *oldLogE2;
2472          oldBandE = (opus_val16*)(st->in_mem+st->channels*(st->mode->overlap+COMBFILTER_MAXPERIOD));
2473          oldLogE = oldBandE + st->channels*st->mode->nbEBands;
2474          oldLogE2 = oldLogE + st->channels*st->mode->nbEBands;
2475          OPUS_CLEAR((char*)&st->ENCODER_RESET_START,
2476                opus_custom_encoder_get_size(st->mode, st->channels)-
2477                ((char*)&st->ENCODER_RESET_START - (char*)st));
2478          for (i=0;i<st->channels*st->mode->nbEBands;i++)
2479             oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT);
2480          st->vbr_offset = 0;
2481          st->delayedIntra = 1;
2482          st->spread_decision = SPREAD_NORMAL;
2483          st->tonal_average = 256;
2484          st->hf_average = 0;
2485          st->tapset_decision = 0;
2486       }
2487       break;
2488 #ifdef CUSTOM_MODES
2489       case CELT_SET_INPUT_CLIPPING_REQUEST:
2490       {
2491          opus_int32 value = va_arg(ap, opus_int32);
2492          st->clip = value;
2493       }
2494       break;
2495 #endif
2496       case CELT_SET_SIGNALLING_REQUEST:
2497       {
2498          opus_int32 value = va_arg(ap, opus_int32);
2499          st->signalling = value;
2500       }
2501       break;
2502       case CELT_SET_ANALYSIS_REQUEST:
2503       {
2504          AnalysisInfo *info = va_arg(ap, AnalysisInfo *);
2505          if (info)
2506             OPUS_COPY(&st->analysis, info, 1);
2507       }
2508       break;
2509       case CELT_SET_SILK_INFO_REQUEST:
2510       {
2511          SILKInfo *info = va_arg(ap, SILKInfo *);
2512          if (info)
2513             OPUS_COPY(&st->silk_info, info, 1);
2514       }
2515       break;
2516       case CELT_GET_MODE_REQUEST:
2517       {
2518          const CELTMode ** value = va_arg(ap, const CELTMode**);
2519          if (value==0)
2520             goto bad_arg;
2521          *value=st->mode;
2522       }
2523       break;
2524       case OPUS_GET_FINAL_RANGE_REQUEST:
2525       {
2526          opus_uint32 * value = va_arg(ap, opus_uint32 *);
2527          if (value==0)
2528             goto bad_arg;
2529          *value=st->rng;
2530       }
2531       break;
2532       case OPUS_SET_LFE_REQUEST:
2533       {
2534           opus_int32 value = va_arg(ap, opus_int32);
2535           st->lfe = value;
2536       }
2537       break;
2538       case OPUS_SET_ENERGY_MASK_REQUEST:
2539       {
2540           opus_val16 *value = va_arg(ap, opus_val16*);
2541           st->energy_mask = value;
2542       }
2543       break;
2544       default:
2545          goto bad_request;
2546    }
2547    va_end(ap);
2548    return OPUS_OK;
2549 bad_arg:
2550    va_end(ap);
2551    return OPUS_BAD_ARG;
2552 bad_request:
2553    va_end(ap);
2554    return OPUS_UNIMPLEMENTED;
2555 }