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