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