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