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