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