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