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