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