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