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