Fixes some fixed-point 16-bit int overflows
[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 *new, opus_val16 *old, 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] = old[0];
384       for (i=1;i<end;i++)
385          spread_old[i] = MAX16(spread_old[i-1]-QCONST16(1.0f, DB_SHIFT), old[i]);
386    } else {
387       spread_old[0] = MAX16(old[0],old[nbEBands]);
388       for (i=1;i<end;i++)
389          spread_old[i] = MAX16(spread_old[i-1]-QCONST16(1.0f, DB_SHIFT),
390                                MAX16(old[i],old[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, new[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(32.f, 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             offsets[i] = 0;
978             break;
979          } else {
980             offsets[i] = boost;
981             tot_boost += boost_bits;
982          }
983       }
984    }
985    *tot_boost_ = tot_boost;
986    RESTORE_STACK;
987    return maxDepth;
988 }
989
990
991 static int run_prefilter(CELTEncoder *st, celt_sig *in, celt_sig *prefilter_mem, int CC, int N,
992       int prefilter_tapset, int *pitch, opus_val16 *gain, int *qgain, int enabled, int nbAvailableBytes)
993 {
994    int c;
995    VARDECL(celt_sig, _pre);
996    celt_sig *pre[2];
997    const CELTMode *mode;
998    int pitch_index;
999    opus_val16 gain1;
1000    opus_val16 pf_threshold;
1001    int pf_on;
1002    int qg;
1003    SAVE_STACK;
1004
1005    mode = st->mode;
1006    ALLOC(_pre, CC*(N+COMBFILTER_MAXPERIOD), celt_sig);
1007
1008    pre[0] = _pre;
1009    pre[1] = _pre + (N+COMBFILTER_MAXPERIOD);
1010
1011
1012    c=0; do {
1013       OPUS_COPY(pre[c], prefilter_mem+c*COMBFILTER_MAXPERIOD, COMBFILTER_MAXPERIOD);
1014       OPUS_COPY(pre[c]+COMBFILTER_MAXPERIOD, in+c*(N+st->overlap)+st->overlap, N);
1015    } while (++c<CC);
1016
1017    if (enabled)
1018    {
1019       VARDECL(opus_val16, pitch_buf);
1020       ALLOC(pitch_buf, (COMBFILTER_MAXPERIOD+N)>>1, opus_val16);
1021
1022       pitch_downsample(pre, pitch_buf, COMBFILTER_MAXPERIOD+N, CC);
1023       /* Don't search for the fir last 1.5 octave of the range because
1024          there's too many false-positives due to short-term correlation */
1025       pitch_search(pitch_buf+(COMBFILTER_MAXPERIOD>>1), pitch_buf, N,
1026             COMBFILTER_MAXPERIOD-3*COMBFILTER_MINPERIOD, &pitch_index);
1027       pitch_index = COMBFILTER_MAXPERIOD-pitch_index;
1028
1029       gain1 = remove_doubling(pitch_buf, COMBFILTER_MAXPERIOD, COMBFILTER_MINPERIOD,
1030             N, &pitch_index, st->prefilter_period, st->prefilter_gain);
1031       if (pitch_index > COMBFILTER_MAXPERIOD-2)
1032          pitch_index = COMBFILTER_MAXPERIOD-2;
1033       gain1 = MULT16_16_Q15(QCONST16(.7f,15),gain1);
1034       /*printf("%d %d %f %f\n", pitch_change, pitch_index, gain1, st->analysis.tonality);*/
1035       if (st->loss_rate>2)
1036          gain1 = HALF32(gain1);
1037       if (st->loss_rate>4)
1038          gain1 = HALF32(gain1);
1039       if (st->loss_rate>8)
1040          gain1 = 0;
1041    } else {
1042       gain1 = 0;
1043       pitch_index = COMBFILTER_MINPERIOD;
1044    }
1045
1046    /* Gain threshold for enabling the prefilter/postfilter */
1047    pf_threshold = QCONST16(.2f,15);
1048
1049    /* Adjusting the threshold based on rate and continuity */
1050    if (abs(pitch_index-st->prefilter_period)*10>pitch_index)
1051       pf_threshold += QCONST16(.2f,15);
1052    if (nbAvailableBytes<25)
1053       pf_threshold += QCONST16(.1f,15);
1054    if (nbAvailableBytes<35)
1055       pf_threshold += QCONST16(.1f,15);
1056    if (st->prefilter_gain > QCONST16(.4f,15))
1057       pf_threshold -= QCONST16(.1f,15);
1058    if (st->prefilter_gain > QCONST16(.55f,15))
1059       pf_threshold -= QCONST16(.1f,15);
1060
1061    /* Hard threshold at 0.2 */
1062    pf_threshold = MAX16(pf_threshold, QCONST16(.2f,15));
1063    if (gain1<pf_threshold)
1064    {
1065       gain1 = 0;
1066       pf_on = 0;
1067       qg = 0;
1068    } else {
1069       /*This block is not gated by a total bits check only because
1070         of the nbAvailableBytes check above.*/
1071       if (ABS16(gain1-st->prefilter_gain)<QCONST16(.1f,15))
1072          gain1=st->prefilter_gain;
1073
1074 #ifdef FIXED_POINT
1075       qg = ((gain1+1536)>>10)/3-1;
1076 #else
1077       qg = (int)floor(.5f+gain1*32/3)-1;
1078 #endif
1079       qg = IMAX(0, IMIN(7, qg));
1080       gain1 = QCONST16(0.09375f,15)*(qg+1);
1081       pf_on = 1;
1082    }
1083    /*printf("%d %f\n", pitch_index, gain1);*/
1084
1085    c=0; do {
1086       int offset = mode->shortMdctSize-st->overlap;
1087       st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
1088       OPUS_COPY(in+c*(N+st->overlap), st->in_mem+c*(st->overlap), st->overlap);
1089       if (offset)
1090          comb_filter(in+c*(N+st->overlap)+st->overlap, pre[c]+COMBFILTER_MAXPERIOD,
1091                st->prefilter_period, st->prefilter_period, offset, -st->prefilter_gain, -st->prefilter_gain,
1092                st->prefilter_tapset, st->prefilter_tapset, NULL, 0);
1093
1094       comb_filter(in+c*(N+st->overlap)+st->overlap+offset, pre[c]+COMBFILTER_MAXPERIOD+offset,
1095             st->prefilter_period, pitch_index, N-offset, -st->prefilter_gain, -gain1,
1096             st->prefilter_tapset, prefilter_tapset, mode->window, st->overlap);
1097       OPUS_COPY(st->in_mem+c*(st->overlap), in+c*(N+st->overlap)+N, st->overlap);
1098
1099       if (N>COMBFILTER_MAXPERIOD)
1100       {
1101          OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, pre[c]+N, COMBFILTER_MAXPERIOD);
1102       } else {
1103          OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, prefilter_mem+c*COMBFILTER_MAXPERIOD+N, COMBFILTER_MAXPERIOD-N);
1104          OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD+COMBFILTER_MAXPERIOD-N, pre[c]+COMBFILTER_MAXPERIOD, N);
1105       }
1106    } while (++c<CC);
1107
1108    RESTORE_STACK;
1109    *gain = gain1;
1110    *pitch = pitch_index;
1111    *qgain = qg;
1112    return pf_on;
1113 }
1114
1115 static int compute_vbr(const CELTMode *mode, AnalysisInfo *analysis, opus_int32 base_target,
1116       int LM, opus_int32 bitrate, int lastCodedBands, int C, int intensity,
1117       int constrained_vbr, opus_val16 stereo_saving, int tot_boost,
1118       opus_val16 tf_estimate, int pitch_change, opus_val16 maxDepth,
1119       int variable_duration, int lfe, int has_surround_mask, opus_val16 surround_masking,
1120       opus_val16 temporal_vbr)
1121 {
1122    /* The target rate in 8th bits per frame */
1123    opus_int32 target;
1124    int coded_bins;
1125    int coded_bands;
1126    opus_val16 tf_calibration;
1127    int nbEBands;
1128    const opus_int16 *eBands;
1129
1130    nbEBands = mode->nbEBands;
1131    eBands = mode->eBands;
1132
1133    coded_bands = lastCodedBands ? lastCodedBands : nbEBands;
1134    coded_bins = eBands[coded_bands]<<LM;
1135    if (C==2)
1136       coded_bins += eBands[IMIN(intensity, coded_bands)]<<LM;
1137
1138    target = base_target;
1139
1140    /*printf("%f %f %f %f %d %d ", st->analysis.activity, st->analysis.tonality, tf_estimate, st->stereo_saving, tot_boost, coded_bands);*/
1141 #ifndef FIXED_POINT
1142    if (analysis->valid && analysis->activity<.4)
1143       target -= (opus_int32)((coded_bins<<BITRES)*(.4f-analysis->activity));
1144 #endif
1145    /* Stereo savings */
1146    if (C==2)
1147    {
1148       int coded_stereo_bands;
1149       int coded_stereo_dof;
1150       opus_val16 max_frac;
1151       coded_stereo_bands = IMIN(intensity, coded_bands);
1152       coded_stereo_dof = (eBands[coded_stereo_bands]<<LM)-coded_stereo_bands;
1153       /* Maximum fraction of the bits we can save if the signal is mono. */
1154       max_frac = DIV32_16(MULT16_16(QCONST16(0.8f, 15), coded_stereo_dof), coded_bins);
1155       /*printf("%d %d %d ", coded_stereo_dof, coded_bins, tot_boost);*/
1156       target -= (opus_int32)MIN32(MULT16_32_Q15(max_frac,target),
1157                       SHR32(MULT16_16(stereo_saving-QCONST16(0.1f,8),(coded_stereo_dof<<BITRES)),8));
1158    }
1159    /* Boost the rate according to dynalloc (minus the dynalloc average for calibration). */
1160    target += tot_boost-(16<<LM);
1161    /* Apply transient boost, compensating for average boost. */
1162    tf_calibration = variable_duration==OPUS_FRAMESIZE_VARIABLE ?
1163                     QCONST16(0.02f,14) : QCONST16(0.04f,14);
1164    target += (opus_int32)SHL32(MULT16_32_Q15(tf_estimate-tf_calibration, target),1);
1165
1166 #ifndef FIXED_POINT
1167    /* Apply tonality boost */
1168    if (analysis->valid && !lfe)
1169    {
1170       opus_int32 tonal_target;
1171       float tonal;
1172
1173       /* Tonality boost (compensating for the average). */
1174       tonal = MAX16(0.f,analysis->tonality-.15f)-0.09f;
1175       tonal_target = target + (opus_int32)((coded_bins<<BITRES)*1.2f*tonal);
1176       if (pitch_change)
1177          tonal_target +=  (opus_int32)((coded_bins<<BITRES)*.8f);
1178       /*printf("%f %f ", st->analysis.tonality, tonal);*/
1179       target = tonal_target;
1180    }
1181 #endif
1182
1183    if (has_surround_mask&&!lfe)
1184    {
1185       opus_int32 surround_target = target + (opus_int32)SHR32(MULT16_16(surround_masking,coded_bins<<BITRES), DB_SHIFT);
1186       /*printf("%f %d %d %d %d %d %d ", surround_masking, coded_bins, st->end, st->intensity, surround_target, target, st->bitrate);*/
1187       target = IMAX(target/4, surround_target);
1188    }
1189
1190    {
1191       opus_int32 floor_depth;
1192       int bins;
1193       bins = eBands[nbEBands-2]<<LM;
1194       /*floor_depth = SHR32(MULT16_16((C*bins<<BITRES),celt_log2(SHL32(MAX16(1,sample_max),13))), DB_SHIFT);*/
1195       floor_depth = (opus_int32)SHR32(MULT16_16((C*bins<<BITRES),maxDepth), DB_SHIFT);
1196       floor_depth = IMAX(floor_depth, target>>2);
1197       target = IMIN(target, floor_depth);
1198       /*printf("%f %d\n", maxDepth, floor_depth);*/
1199    }
1200
1201    if ((!has_surround_mask||lfe) && (constrained_vbr || bitrate<64000))
1202    {
1203       opus_val16 rate_factor;
1204 #ifdef FIXED_POINT
1205       rate_factor = MAX16(0,(bitrate-32000));
1206 #else
1207       rate_factor = MAX16(0,(1.f/32768)*(bitrate-32000));
1208 #endif
1209       if (constrained_vbr)
1210          rate_factor = MIN16(rate_factor, QCONST16(0.67f, 15));
1211       target = base_target + (opus_int32)MULT16_32_Q15(rate_factor, target-base_target);
1212
1213    }
1214
1215    if (!has_surround_mask && tf_estimate < QCONST16(.2f, 14))
1216    {
1217       opus_val16 amount;
1218       opus_val16 tvbr_factor;
1219       amount = MULT16_16_Q15(QCONST16(.0000031f, 30), IMAX(0, IMIN(32000, 96000-bitrate)));
1220       tvbr_factor = SHR32(MULT16_16(temporal_vbr, amount), DB_SHIFT);
1221       target += (opus_int32)MULT16_32_Q15(tvbr_factor, target);
1222    }
1223
1224    /* Don't allow more than doubling the rate */
1225    target = IMIN(2*base_target, target);
1226
1227    return target;
1228 }
1229
1230 int celt_encode_with_ec(CELTEncoder * OPUS_RESTRICT st, const opus_val16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
1231 {
1232    int i, c, N;
1233    opus_int32 bits;
1234    ec_enc _enc;
1235    VARDECL(celt_sig, in);
1236    VARDECL(celt_sig, freq);
1237    VARDECL(celt_norm, X);
1238    VARDECL(celt_ener, bandE);
1239    VARDECL(opus_val16, bandLogE);
1240    VARDECL(opus_val16, bandLogE2);
1241    VARDECL(int, fine_quant);
1242    VARDECL(opus_val16, error);
1243    VARDECL(int, pulses);
1244    VARDECL(int, cap);
1245    VARDECL(int, offsets);
1246    VARDECL(int, fine_priority);
1247    VARDECL(int, tf_res);
1248    VARDECL(unsigned char, collapse_masks);
1249    celt_sig *prefilter_mem;
1250    opus_val16 *oldBandE, *oldLogE, *oldLogE2;
1251    int shortBlocks=0;
1252    int isTransient=0;
1253    const int CC = st->channels;
1254    const int C = st->stream_channels;
1255    int LM, M;
1256    int tf_select;
1257    int nbFilledBytes, nbAvailableBytes;
1258    int effEnd;
1259    int codedBands;
1260    int tf_sum;
1261    int alloc_trim;
1262    int pitch_index=COMBFILTER_MINPERIOD;
1263    opus_val16 gain1 = 0;
1264    int dual_stereo=0;
1265    int effectiveBytes;
1266    int dynalloc_logp;
1267    opus_int32 vbr_rate;
1268    opus_int32 total_bits;
1269    opus_int32 total_boost;
1270    opus_int32 balance;
1271    opus_int32 tell;
1272    int prefilter_tapset=0;
1273    int pf_on;
1274    int anti_collapse_rsv;
1275    int anti_collapse_on=0;
1276    int silence=0;
1277    int tf_chan = 0;
1278    opus_val16 tf_estimate;
1279    int pitch_change=0;
1280    opus_int32 tot_boost;
1281    opus_val32 sample_max;
1282    opus_val16 maxDepth;
1283    const OpusCustomMode *mode;
1284    int nbEBands;
1285    int overlap;
1286    const opus_int16 *eBands;
1287    int secondMdct;
1288    int signalBandwidth;
1289    int transient_got_disabled=0;
1290    opus_val16 surround_masking=0;
1291    opus_val16 temporal_vbr=0;
1292    ALLOC_STACK;
1293
1294    mode = st->mode;
1295    nbEBands = mode->nbEBands;
1296    overlap = mode->overlap;
1297    eBands = mode->eBands;
1298    tf_estimate = 0;
1299    if (nbCompressedBytes<2 || pcm==NULL)
1300      return OPUS_BAD_ARG;
1301
1302    frame_size *= st->upsample;
1303    for (LM=0;LM<=mode->maxLM;LM++)
1304       if (mode->shortMdctSize<<LM==frame_size)
1305          break;
1306    if (LM>mode->maxLM)
1307       return OPUS_BAD_ARG;
1308    M=1<<LM;
1309    N = M*mode->shortMdctSize;
1310
1311    prefilter_mem = st->in_mem+CC*(st->overlap);
1312    oldBandE = (opus_val16*)(st->in_mem+CC*(st->overlap+COMBFILTER_MAXPERIOD));
1313    oldLogE = oldBandE + CC*nbEBands;
1314    oldLogE2 = oldLogE + CC*nbEBands;
1315
1316    if (enc==NULL)
1317    {
1318       tell=1;
1319       nbFilledBytes=0;
1320    } else {
1321       tell=ec_tell(enc);
1322       nbFilledBytes=(tell+4)>>3;
1323    }
1324
1325 #ifdef CUSTOM_MODES
1326    if (st->signalling && enc==NULL)
1327    {
1328       int tmp = (mode->effEBands-st->end)>>1;
1329       st->end = IMAX(1, mode->effEBands-tmp);
1330       compressed[0] = tmp<<5;
1331       compressed[0] |= LM<<3;
1332       compressed[0] |= (C==2)<<2;
1333       /* Convert "standard mode" to Opus header */
1334       if (mode->Fs==48000 && mode->shortMdctSize==120)
1335       {
1336          int c0 = toOpus(compressed[0]);
1337          if (c0<0)
1338             return OPUS_BAD_ARG;
1339          compressed[0] = c0;
1340       }
1341       compressed++;
1342       nbCompressedBytes--;
1343    }
1344 #else
1345    celt_assert(st->signalling==0);
1346 #endif
1347
1348    /* Can't produce more than 1275 output bytes */
1349    nbCompressedBytes = IMIN(nbCompressedBytes,1275);
1350    nbAvailableBytes = nbCompressedBytes - nbFilledBytes;
1351
1352    if (st->vbr && st->bitrate!=OPUS_BITRATE_MAX)
1353    {
1354       opus_int32 den=mode->Fs>>BITRES;
1355       vbr_rate=(st->bitrate*frame_size+(den>>1))/den;
1356 #ifdef CUSTOM_MODES
1357       if (st->signalling)
1358          vbr_rate -= 8<<BITRES;
1359 #endif
1360       effectiveBytes = vbr_rate>>(3+BITRES);
1361    } else {
1362       opus_int32 tmp;
1363       vbr_rate = 0;
1364       tmp = st->bitrate*frame_size;
1365       if (tell>1)
1366          tmp += tell;
1367       if (st->bitrate!=OPUS_BITRATE_MAX)
1368          nbCompressedBytes = IMAX(2, IMIN(nbCompressedBytes,
1369                (tmp+4*mode->Fs)/(8*mode->Fs)-!!st->signalling));
1370       effectiveBytes = nbCompressedBytes;
1371    }
1372
1373    if (enc==NULL)
1374    {
1375       ec_enc_init(&_enc, compressed, nbCompressedBytes);
1376       enc = &_enc;
1377    }
1378
1379    if (vbr_rate>0)
1380    {
1381       /* Computes the max bit-rate allowed in VBR mode to avoid violating the
1382           target rate and buffering.
1383          We must do this up front so that bust-prevention logic triggers
1384           correctly if we don't have enough bits. */
1385       if (st->constrained_vbr)
1386       {
1387          opus_int32 vbr_bound;
1388          opus_int32 max_allowed;
1389          /* We could use any multiple of vbr_rate as bound (depending on the
1390              delay).
1391             This is clamped to ensure we use at least two bytes if the encoder
1392              was entirely empty, but to allow 0 in hybrid mode. */
1393          vbr_bound = vbr_rate;
1394          max_allowed = IMIN(IMAX(tell==1?2:0,
1395                (vbr_rate+vbr_bound-st->vbr_reservoir)>>(BITRES+3)),
1396                nbAvailableBytes);
1397          if(max_allowed < nbAvailableBytes)
1398          {
1399             nbCompressedBytes = nbFilledBytes+max_allowed;
1400             nbAvailableBytes = max_allowed;
1401             ec_enc_shrink(enc, nbCompressedBytes);
1402          }
1403       }
1404    }
1405    total_bits = nbCompressedBytes*8;
1406
1407    effEnd = st->end;
1408    if (effEnd > mode->effEBands)
1409       effEnd = mode->effEBands;
1410
1411    ALLOC(in, CC*(N+st->overlap), celt_sig);
1412
1413    sample_max=MAX32(st->overlap_max, celt_maxabs16(pcm, C*(N-overlap)/st->upsample));
1414    st->overlap_max=celt_maxabs16(pcm+C*(N-overlap)/st->upsample, C*overlap/st->upsample);
1415    sample_max=MAX32(sample_max, st->overlap_max);
1416 #ifdef FIXED_POINT
1417    silence = (sample_max==0);
1418 #else
1419    silence = (sample_max <= (opus_val16)1/(1<<st->lsb_depth));
1420 #endif
1421 #ifdef FUZZING
1422    if ((rand()&0x3F)==0)
1423       silence = 1;
1424 #endif
1425    if (tell==1)
1426       ec_enc_bit_logp(enc, silence, 15);
1427    else
1428       silence=0;
1429    if (silence)
1430    {
1431       /*In VBR mode there is no need to send more than the minimum. */
1432       if (vbr_rate>0)
1433       {
1434          effectiveBytes=nbCompressedBytes=IMIN(nbCompressedBytes, nbFilledBytes+2);
1435          total_bits=nbCompressedBytes*8;
1436          nbAvailableBytes=2;
1437          ec_enc_shrink(enc, nbCompressedBytes);
1438       }
1439       /* Pretend we've filled all the remaining bits with zeros
1440             (that's what the initialiser did anyway) */
1441       tell = nbCompressedBytes*8;
1442       enc->nbits_total+=tell-ec_tell(enc);
1443    }
1444    c=0; do {
1445       preemphasis(pcm+c, in+c*(N+st->overlap)+st->overlap, N, CC, st->upsample,
1446                   mode->preemph, st->preemph_memE+c, st->clip);
1447    } while (++c<CC);
1448
1449
1450
1451    /* Find pitch period and gain */
1452    {
1453       int enabled;
1454       int qg;
1455       enabled = (st->lfe || nbAvailableBytes>12*C) && st->start==0 && !silence && !st->disable_pf
1456             && st->complexity >= 5 && !(st->consec_transient && LM!=3 && st->variable_duration==OPUS_FRAMESIZE_VARIABLE);
1457
1458       prefilter_tapset = st->tapset_decision;
1459       pf_on = run_prefilter(st, in, prefilter_mem, CC, N, prefilter_tapset, &pitch_index, &gain1, &qg, enabled, nbAvailableBytes);
1460       if ((gain1 > QCONST16(.4f,15) || st->prefilter_gain > QCONST16(.4f,15)) && (!st->analysis.valid || st->analysis.tonality > .3)
1461             && (pitch_index > 1.26*st->prefilter_period || pitch_index < .79*st->prefilter_period))
1462          pitch_change = 1;
1463       if (pf_on==0)
1464       {
1465          if(st->start==0 && tell+16<=total_bits)
1466             ec_enc_bit_logp(enc, 0, 1);
1467       } else {
1468          /*This block is not gated by a total bits check only because
1469            of the nbAvailableBytes check above.*/
1470          int octave;
1471          ec_enc_bit_logp(enc, 1, 1);
1472          pitch_index += 1;
1473          octave = EC_ILOG(pitch_index)-5;
1474          ec_enc_uint(enc, octave, 6);
1475          ec_enc_bits(enc, pitch_index-(16<<octave), 4+octave);
1476          pitch_index -= 1;
1477          ec_enc_bits(enc, qg, 3);
1478          ec_enc_icdf(enc, prefilter_tapset, tapset_icdf, 2);
1479       }
1480    }
1481
1482    isTransient = 0;
1483    shortBlocks = 0;
1484    if (st->complexity >= 1 && !st->lfe)
1485    {
1486       isTransient = transient_analysis(in, N+st->overlap, CC,
1487             &tf_estimate, &tf_chan);
1488    }
1489    if (LM>0 && ec_tell(enc)+3<=total_bits)
1490    {
1491       if (isTransient)
1492          shortBlocks = M;
1493    } else {
1494       isTransient = 0;
1495       transient_got_disabled=1;
1496    }
1497
1498    ALLOC(freq, CC*N, celt_sig); /**< Interleaved signal MDCTs */
1499    ALLOC(bandE,nbEBands*CC, celt_ener);
1500    ALLOC(bandLogE,nbEBands*CC, opus_val16);
1501
1502    secondMdct = shortBlocks && st->complexity>=8;
1503    ALLOC(bandLogE2, C*nbEBands, opus_val16);
1504    if (secondMdct)
1505    {
1506       compute_mdcts(mode, 0, in, freq, C, CC, LM, st->upsample);
1507       compute_band_energies(mode, freq, bandE, effEnd, C, M);
1508       amp2Log2(mode, effEnd, st->end, bandE, bandLogE2, C);
1509       for (i=0;i<C*nbEBands;i++)
1510          bandLogE2[i] += HALF16(SHL16(LM, DB_SHIFT));
1511    }
1512
1513    compute_mdcts(mode, shortBlocks, in, freq, C, CC, LM, st->upsample);
1514    if (CC==2&&C==1)
1515       tf_chan = 0;
1516    compute_band_energies(mode, freq, bandE, effEnd, C, M);
1517
1518    if (st->lfe)
1519    {
1520       for (i=2;i<st->end;i++)
1521       {
1522          bandE[i] = IMIN(bandE[i], MULT16_32_Q15(QCONST16(1e-4f,15),bandE[0]));
1523          bandE[i] = MAX32(bandE[i], EPSILON);
1524       }
1525    }
1526    amp2Log2(mode, effEnd, st->end, bandE, bandLogE, C);
1527    if (st->energy_save)
1528    {
1529       opus_val16 offset = shortBlocks?HALF16(SHL16(LM, DB_SHIFT)):0;
1530 #ifdef FIXED_POINT
1531       /* Compensate for the 1/8 gain we apply in the fixed-point downshift to avoid overflows. */
1532       offset -= QCONST16(3.0f, DB_SHIFT);
1533 #endif
1534       for(i=0;i<C*nbEBands;i++)
1535          st->energy_save[i]=bandLogE[i]-offset;
1536       st->energy_save=NULL;
1537    }
1538    /* This computes how much masking takes place between surround channels */
1539    if (st->energy_mask&&!st->lfe)
1540    {
1541       opus_val32 mask_avg=0;
1542       opus_val16 offset = shortBlocks?HALF16(SHL16(LM, DB_SHIFT)):0;
1543       for (c=0;c<C;c++)
1544       {
1545          opus_val16 followE, followMask;
1546          followE = followMask = -QCONST16(14.f, DB_SHIFT);
1547          for(i=0;i<st->end;i++)
1548          {
1549             /* We use a simple follower to approximate the masking spreading function. */
1550             followE = MAX16(followE-QCONST16(1.f, DB_SHIFT), bandLogE[nbEBands*c+i]-offset);
1551             followMask = MAX16(followMask-QCONST16(1.f, DB_SHIFT), st->energy_mask[nbEBands*c+i]);
1552             mask_avg += followE-followMask;
1553          }
1554       }
1555       surround_masking = DIV32_16(mask_avg,C*st->end) + QCONST16(.7f, DB_SHIFT);
1556       surround_masking = MIN16(MAX16(surround_masking, -QCONST16(2.f, DB_SHIFT)), QCONST16(.2f, DB_SHIFT));
1557       surround_masking -= HALF16(HALF16(surround_masking));
1558    }
1559    /* Temporal VBR (but not for LFE) */
1560    if (!st->lfe)
1561    {
1562       opus_val16 follow=-QCONST16(10.0f,DB_SHIFT);
1563       float frame_avg=0;
1564       opus_val16 offset = shortBlocks?HALF16(SHL16(LM, DB_SHIFT)):0;
1565       for(i=st->start;i<st->end;i++)
1566       {
1567          follow = MAX16(follow-QCONST16(1.f, DB_SHIFT), bandLogE[i]-offset);
1568          if (C==2)
1569             follow = MAX16(follow, bandLogE[i+nbEBands]-offset);
1570          frame_avg += follow;
1571       }
1572       frame_avg /= (st->end-st->start);
1573       temporal_vbr = SUB16(frame_avg,st->spec_avg);
1574       temporal_vbr = MIN16(QCONST16(3.f, DB_SHIFT), MAX16(-QCONST16(1.5f, DB_SHIFT), temporal_vbr));
1575       st->spec_avg += MULT16_16_Q15(QCONST16(.02f, 15), temporal_vbr);
1576    }
1577    /*for (i=0;i<21;i++)
1578       printf("%f ", bandLogE[i]);
1579    printf("\n");*/
1580
1581    if (!secondMdct)
1582    {
1583       for (i=0;i<C*nbEBands;i++)
1584          bandLogE2[i] = bandLogE[i];
1585    }
1586
1587    /* Last chance to catch any transient we might have missed in the
1588       time-domain analysis */
1589    if (LM>0 && ec_tell(enc)+3<=total_bits && !isTransient && st->complexity>=5 && !st->lfe)
1590    {
1591       if (patch_transient_decision(bandLogE, oldBandE, nbEBands, st->end, C))
1592       {
1593          isTransient = 1;
1594          shortBlocks = M;
1595          compute_mdcts(mode, shortBlocks, in, freq, C, CC, LM, st->upsample);
1596          compute_band_energies(mode, freq, bandE, effEnd, C, M);
1597          amp2Log2(mode, effEnd, st->end, bandE, bandLogE, C);
1598          /* Compensate for the scaling of short vs long mdcts */
1599          for (i=0;i<C*nbEBands;i++)
1600             bandLogE2[i] += HALF16(SHL16(LM, DB_SHIFT));
1601          tf_estimate = QCONST16(.2f,14);
1602       }
1603    }
1604
1605    if (LM>0 && ec_tell(enc)+3<=total_bits)
1606       ec_enc_bit_logp(enc, isTransient, 3);
1607
1608    ALLOC(X, C*N, celt_norm);         /**< Interleaved normalised MDCTs */
1609
1610    /* Band normalisation */
1611    normalise_bands(mode, freq, X, bandE, effEnd, C, M);
1612
1613    ALLOC(tf_res, nbEBands, int);
1614    /* Disable variable tf resolution for hybrid and at very low bitrate */
1615    if (effectiveBytes>=15*C && st->start==0 && st->complexity>=2 && !st->lfe)
1616    {
1617       int lambda;
1618       if (effectiveBytes<40)
1619          lambda = 12;
1620       else if (effectiveBytes<60)
1621          lambda = 6;
1622       else if (effectiveBytes<100)
1623          lambda = 4;
1624       else
1625          lambda = 3;
1626       lambda*=2;
1627       tf_select = tf_analysis(mode, effEnd, isTransient, tf_res, lambda, X, N, LM, &tf_sum, tf_estimate, tf_chan);
1628       for (i=effEnd;i<st->end;i++)
1629          tf_res[i] = tf_res[effEnd-1];
1630    } else {
1631       tf_sum = 0;
1632       for (i=0;i<st->end;i++)
1633          tf_res[i] = isTransient;
1634       tf_select=0;
1635    }
1636
1637    ALLOC(error, C*nbEBands, opus_val16);
1638    quant_coarse_energy(mode, st->start, st->end, effEnd, bandLogE,
1639          oldBandE, total_bits, error, enc,
1640          C, LM, nbAvailableBytes, st->force_intra,
1641          &st->delayedIntra, st->complexity >= 4, st->loss_rate, st->lfe);
1642
1643    tf_encode(st->start, st->end, isTransient, tf_res, LM, tf_select, enc);
1644
1645    if (ec_tell(enc)+4<=total_bits)
1646    {
1647       if (st->lfe)
1648       {
1649          st->tapset_decision = 0;
1650          st->spread_decision = SPREAD_NORMAL;
1651       } else if (shortBlocks || st->complexity < 3 || nbAvailableBytes < 10*C || st->start != 0)
1652       {
1653          if (st->complexity == 0)
1654             st->spread_decision = SPREAD_NONE;
1655          else
1656             st->spread_decision = SPREAD_NORMAL;
1657       } else {
1658          /* Disable new spreading+tapset estimator until we can show it works
1659             better than the old one. So far it seems like spreading_decision()
1660             works best. */
1661          if (0&&st->analysis.valid)
1662          {
1663             static const opus_val16 spread_thresholds[3] = {-QCONST16(.6f, 15), -QCONST16(.2f, 15), -QCONST16(.07f, 15)};
1664             static const opus_val16 spread_histeresis[3] = {QCONST16(.15f, 15), QCONST16(.07f, 15), QCONST16(.02f, 15)};
1665             static const opus_val16 tapset_thresholds[2] = {QCONST16(.0f, 15), QCONST16(.15f, 15)};
1666             static const opus_val16 tapset_histeresis[2] = {QCONST16(.1f, 15), QCONST16(.05f, 15)};
1667             st->spread_decision = hysteresis_decision(-st->analysis.tonality, spread_thresholds, spread_histeresis, 3, st->spread_decision);
1668             st->tapset_decision = hysteresis_decision(st->analysis.tonality_slope, tapset_thresholds, tapset_histeresis, 2, st->tapset_decision);
1669          } else {
1670             st->spread_decision = spreading_decision(mode, X,
1671                   &st->tonal_average, st->spread_decision, &st->hf_average,
1672                   &st->tapset_decision, pf_on&&!shortBlocks, effEnd, C, M);
1673          }
1674          /*printf("%d %d\n", st->tapset_decision, st->spread_decision);*/
1675          /*printf("%f %d %f %d\n\n", st->analysis.tonality, st->spread_decision, st->analysis.tonality_slope, st->tapset_decision);*/
1676       }
1677       ec_enc_icdf(enc, st->spread_decision, spread_icdf, 5);
1678    }
1679
1680    ALLOC(offsets, nbEBands, int);
1681
1682    maxDepth = dynalloc_analysis(bandLogE, bandLogE2, nbEBands, st->start, st->end, C, offsets,
1683          st->lsb_depth, mode->logN, isTransient, st->vbr, st->constrained_vbr,
1684          eBands, LM, effectiveBytes, &tot_boost, st->lfe);
1685    /* For LFE, everything interesting is in the first band */
1686    if (st->lfe)
1687       offsets[0] = IMIN(8, effectiveBytes/3);
1688    ALLOC(cap, nbEBands, int);
1689    init_caps(mode,cap,LM,C);
1690
1691    dynalloc_logp = 6;
1692    total_bits<<=BITRES;
1693    total_boost = 0;
1694    tell = ec_tell_frac(enc);
1695    for (i=st->start;i<st->end;i++)
1696    {
1697       int width, quanta;
1698       int dynalloc_loop_logp;
1699       int boost;
1700       int j;
1701       width = C*(eBands[i+1]-eBands[i])<<LM;
1702       /* quanta is 6 bits, but no more than 1 bit/sample
1703          and no less than 1/8 bit/sample */
1704       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
1705       dynalloc_loop_logp = dynalloc_logp;
1706       boost = 0;
1707       for (j = 0; tell+(dynalloc_loop_logp<<BITRES) < total_bits-total_boost
1708             && boost < cap[i]; j++)
1709       {
1710          int flag;
1711          flag = j<offsets[i];
1712          ec_enc_bit_logp(enc, flag, dynalloc_loop_logp);
1713          tell = ec_tell_frac(enc);
1714          if (!flag)
1715             break;
1716          boost += quanta;
1717          total_boost += quanta;
1718          dynalloc_loop_logp = 1;
1719       }
1720       /* Making dynalloc more likely */
1721       if (j)
1722          dynalloc_logp = IMAX(2, dynalloc_logp-1);
1723       offsets[i] = boost;
1724    }
1725
1726    if (C==2)
1727    {
1728       int effectiveRate;
1729
1730       static const opus_val16 intensity_thresholds[21]=
1731       /* 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19  20  off*/
1732         { 16,21,23,25,27,29,31,33,35,38,42,46,50,54,58,63,68,75,84,102,130};
1733       static const opus_val16 intensity_histeresis[21]=
1734         {  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 4, 5, 6,  8, 12};
1735
1736       /* Always use MS for 2.5 ms frames until we can do a better analysis */
1737       if (LM!=0)
1738          dual_stereo = stereo_analysis(mode, X, LM, N);
1739
1740       /* Account for coarse energy */
1741       effectiveRate = (8*effectiveBytes - 80)>>LM;
1742
1743       /* effectiveRate in kb/s */
1744       effectiveRate = 2*effectiveRate/5;
1745
1746       st->intensity = hysteresis_decision((opus_val16)effectiveRate, intensity_thresholds, intensity_histeresis, 21, st->intensity);
1747       st->intensity = IMIN(st->end,IMAX(st->start, st->intensity));
1748    }
1749
1750    alloc_trim = 5;
1751    if (tell+(6<<BITRES) <= total_bits - total_boost)
1752    {
1753       if (st->lfe)
1754          alloc_trim = 5;
1755       else
1756          alloc_trim = alloc_trim_analysis(mode, X, bandLogE,
1757             st->end, LM, C, N, &st->analysis, &st->stereo_saving, tf_estimate, st->intensity);
1758       ec_enc_icdf(enc, alloc_trim, trim_icdf, 7);
1759       tell = ec_tell_frac(enc);
1760    }
1761
1762    /* Variable bitrate */
1763    if (vbr_rate>0)
1764    {
1765      opus_val16 alpha;
1766      opus_int32 delta;
1767      /* The target rate in 8th bits per frame */
1768      opus_int32 target, base_target;
1769      opus_int32 min_allowed;
1770      int lm_diff = mode->maxLM - LM;
1771
1772      /* Don't attempt to use more than 510 kb/s, even for frames smaller than 20 ms.
1773         The CELT allocator will just not be able to use more than that anyway. */
1774      nbCompressedBytes = IMIN(nbCompressedBytes,1275>>(3-LM));
1775      base_target = vbr_rate - ((40*C+20)<<BITRES);
1776
1777      if (st->constrained_vbr)
1778         base_target += (st->vbr_offset>>lm_diff);
1779
1780      target = compute_vbr(mode, &st->analysis, base_target, LM, st->bitrate,
1781            st->lastCodedBands, C, st->intensity, st->constrained_vbr,
1782            st->stereo_saving, tot_boost, tf_estimate, pitch_change, maxDepth,
1783            st->variable_duration, st->lfe, st->energy_mask!=NULL, surround_masking,
1784            temporal_vbr);
1785
1786      /* The current offset is removed from the target and the space used
1787         so far is added*/
1788      target=target+tell;
1789      /* In VBR mode the frame size must not be reduced so much that it would
1790          result in the encoder running out of bits.
1791         The margin of 2 bytes ensures that none of the bust-prevention logic
1792          in the decoder will have triggered so far. */
1793      min_allowed = ((tell+total_boost+(1<<(BITRES+3))-1)>>(BITRES+3)) + 2 - nbFilledBytes;
1794
1795      nbAvailableBytes = (target+(1<<(BITRES+2)))>>(BITRES+3);
1796      nbAvailableBytes = IMAX(min_allowed,nbAvailableBytes);
1797      nbAvailableBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes) - nbFilledBytes;
1798
1799      /* By how much did we "miss" the target on that frame */
1800      delta = target - vbr_rate;
1801
1802      target=nbAvailableBytes<<(BITRES+3);
1803
1804      /*If the frame is silent we don't adjust our drift, otherwise
1805        the encoder will shoot to very high rates after hitting a
1806        span of silence, but we do allow the bitres to refill.
1807        This means that we'll undershoot our target in CVBR/VBR modes
1808        on files with lots of silence. */
1809      if(silence)
1810      {
1811        nbAvailableBytes = 2;
1812        target = 2*8<<BITRES;
1813        delta = 0;
1814      }
1815
1816      if (st->vbr_count < 970)
1817      {
1818         st->vbr_count++;
1819         alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+20),16));
1820      } else
1821         alpha = QCONST16(.001f,15);
1822      /* How many bits have we used in excess of what we're allowed */
1823      if (st->constrained_vbr)
1824         st->vbr_reservoir += target - vbr_rate;
1825      /*printf ("%d\n", st->vbr_reservoir);*/
1826
1827      /* Compute the offset we need to apply in order to reach the target */
1828      if (st->constrained_vbr)
1829      {
1830         st->vbr_drift += (opus_int32)MULT16_32_Q15(alpha,(delta*(1<<lm_diff))-st->vbr_offset-st->vbr_drift);
1831         st->vbr_offset = -st->vbr_drift;
1832      }
1833      /*printf ("%d\n", st->vbr_drift);*/
1834
1835      if (st->constrained_vbr && st->vbr_reservoir < 0)
1836      {
1837         /* We're under the min value -- increase rate */
1838         int adjust = (-st->vbr_reservoir)/(8<<BITRES);
1839         /* Unless we're just coding silence */
1840         nbAvailableBytes += silence?0:adjust;
1841         st->vbr_reservoir = 0;
1842         /*printf ("+%d\n", adjust);*/
1843      }
1844      nbCompressedBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes);
1845      /*printf("%d\n", nbCompressedBytes*50*8);*/
1846      /* This moves the raw bits to take into account the new compressed size */
1847      ec_enc_shrink(enc, nbCompressedBytes);
1848    }
1849
1850    /* Bit allocation */
1851    ALLOC(fine_quant, nbEBands, int);
1852    ALLOC(pulses, nbEBands, int);
1853    ALLOC(fine_priority, nbEBands, int);
1854
1855    /* bits =           packet size                    - where we are - safety*/
1856    bits = (((opus_int32)nbCompressedBytes*8)<<BITRES) - ec_tell_frac(enc) - 1;
1857    anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0;
1858    bits -= anti_collapse_rsv;
1859    signalBandwidth = st->end-1;
1860 #ifndef FIXED_POINT
1861    if (st->analysis.valid)
1862    {
1863       int min_bandwidth;
1864       if (st->bitrate < (opus_int32)32000*C)
1865          min_bandwidth = 13;
1866       else if (st->bitrate < (opus_int32)48000*C)
1867          min_bandwidth = 16;
1868       else if (st->bitrate < (opus_int32)60000*C)
1869          min_bandwidth = 18;
1870       else  if (st->bitrate < (opus_int32)80000*C)
1871          min_bandwidth = 19;
1872       else
1873          min_bandwidth = 20;
1874       signalBandwidth = IMAX(st->analysis.bandwidth, min_bandwidth);
1875    }
1876 #endif
1877    if (st->lfe)
1878       signalBandwidth = 1;
1879    codedBands = compute_allocation(mode, st->start, st->end, offsets, cap,
1880          alloc_trim, &st->intensity, &dual_stereo, bits, &balance, pulses,
1881          fine_quant, fine_priority, C, LM, enc, 1, st->lastCodedBands, signalBandwidth);
1882    if (st->lastCodedBands)
1883       st->lastCodedBands = IMIN(st->lastCodedBands+1,IMAX(st->lastCodedBands-1,codedBands));
1884    else
1885       st->lastCodedBands = codedBands;
1886
1887    quant_fine_energy(mode, st->start, st->end, oldBandE, error, fine_quant, enc, C);
1888
1889    /* Residual quantisation */
1890    ALLOC(collapse_masks, C*nbEBands, unsigned char);
1891    quant_all_bands(1, mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
1892          bandE, pulses, shortBlocks, st->spread_decision, dual_stereo, st->intensity, tf_res,
1893          nbCompressedBytes*(8<<BITRES)-anti_collapse_rsv, balance, enc, LM, codedBands, &st->rng);
1894
1895    if (anti_collapse_rsv > 0)
1896    {
1897       anti_collapse_on = st->consec_transient<2;
1898 #ifdef FUZZING
1899       anti_collapse_on = rand()&0x1;
1900 #endif
1901       ec_enc_bits(enc, anti_collapse_on, 1);
1902    }
1903    quant_energy_finalise(mode, st->start, st->end, oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_tell(enc), enc, C);
1904
1905    if (silence)
1906    {
1907       for (i=0;i<C*nbEBands;i++)
1908          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
1909    }
1910
1911 #ifdef RESYNTH
1912    /* Re-synthesis of the coded audio if required */
1913    {
1914       celt_sig *out_mem[2];
1915
1916       if (anti_collapse_on)
1917       {
1918          anti_collapse(mode, X, collapse_masks, LM, C, N,
1919                st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
1920       }
1921
1922       if (silence)
1923       {
1924          for (i=0;i<C*N;i++)
1925             freq[i] = 0;
1926       } else {
1927          /* Synthesis */
1928          denormalise_bands(mode, X, freq, oldBandE, st->start, effEnd, C, M);
1929       }
1930
1931       c=0; do {
1932          OPUS_MOVE(st->syn_mem[c], st->syn_mem[c]+N, 2*MAX_PERIOD-N+overlap/2);
1933       } while (++c<CC);
1934
1935       if (CC==2&&C==1)
1936       {
1937          for (i=0;i<N;i++)
1938             freq[N+i] = freq[i];
1939       }
1940
1941       c=0; do {
1942          out_mem[c] = st->syn_mem[c]+2*MAX_PERIOD-N;
1943       } while (++c<CC);
1944
1945       compute_inv_mdcts(mode, shortBlocks, freq, out_mem, CC, LM);
1946
1947       c=0; do {
1948          st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
1949          st->prefilter_period_old=IMAX(st->prefilter_period_old, COMBFILTER_MINPERIOD);
1950          comb_filter(out_mem[c], out_mem[c], st->prefilter_period_old, st->prefilter_period, mode->shortMdctSize,
1951                st->prefilter_gain_old, st->prefilter_gain, st->prefilter_tapset_old, st->prefilter_tapset,
1952                mode->window, st->overlap);
1953          if (LM!=0)
1954             comb_filter(out_mem[c]+mode->shortMdctSize, out_mem[c]+mode->shortMdctSize, st->prefilter_period, pitch_index, N-mode->shortMdctSize,
1955                   st->prefilter_gain, gain1, st->prefilter_tapset, prefilter_tapset,
1956                   mode->window, overlap);
1957       } while (++c<CC);
1958
1959       /* We reuse freq[] as scratch space for the de-emphasis */
1960       deemphasis(out_mem, (opus_val16*)pcm, N, CC, st->upsample, mode->preemph, st->preemph_memD, freq);
1961       st->prefilter_period_old = st->prefilter_period;
1962       st->prefilter_gain_old = st->prefilter_gain;
1963       st->prefilter_tapset_old = st->prefilter_tapset;
1964    }
1965 #endif
1966
1967    st->prefilter_period = pitch_index;
1968    st->prefilter_gain = gain1;
1969    st->prefilter_tapset = prefilter_tapset;
1970 #ifdef RESYNTH
1971    if (LM!=0)
1972    {
1973       st->prefilter_period_old = st->prefilter_period;
1974       st->prefilter_gain_old = st->prefilter_gain;
1975       st->prefilter_tapset_old = st->prefilter_tapset;
1976    }
1977 #endif
1978
1979    if (CC==2&&C==1) {
1980       for (i=0;i<nbEBands;i++)
1981          oldBandE[nbEBands+i]=oldBandE[i];
1982    }
1983
1984    if (!isTransient)
1985    {
1986       for (i=0;i<CC*nbEBands;i++)
1987          oldLogE2[i] = oldLogE[i];
1988       for (i=0;i<CC*nbEBands;i++)
1989          oldLogE[i] = oldBandE[i];
1990    } else {
1991       for (i=0;i<CC*nbEBands;i++)
1992          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
1993    }
1994    /* In case start or end were to change */
1995    c=0; do
1996    {
1997       for (i=0;i<st->start;i++)
1998       {
1999          oldBandE[c*nbEBands+i]=0;
2000          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
2001       }
2002       for (i=st->end;i<nbEBands;i++)
2003       {
2004          oldBandE[c*nbEBands+i]=0;
2005          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
2006       }
2007    } while (++c<CC);
2008
2009    if (isTransient || transient_got_disabled)
2010       st->consec_transient++;
2011    else
2012       st->consec_transient=0;
2013    st->rng = enc->rng;
2014
2015    /* If there's any room left (can only happen for very high rates),
2016       it's already filled with zeros */
2017    ec_enc_done(enc);
2018
2019 #ifdef CUSTOM_MODES
2020    if (st->signalling)
2021       nbCompressedBytes++;
2022 #endif
2023
2024    RESTORE_STACK;
2025    if (ec_get_error(enc))
2026       return OPUS_INTERNAL_ERROR;
2027    else
2028       return nbCompressedBytes;
2029 }
2030
2031
2032 #ifdef CUSTOM_MODES
2033
2034 #ifdef FIXED_POINT
2035 int opus_custom_encode(CELTEncoder * OPUS_RESTRICT st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2036 {
2037    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
2038 }
2039
2040 #ifndef DISABLE_FLOAT_API
2041 int opus_custom_encode_float(CELTEncoder * OPUS_RESTRICT st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2042 {
2043    int j, ret, C, N;
2044    VARDECL(opus_int16, in);
2045    ALLOC_STACK;
2046
2047    if (pcm==NULL)
2048       return OPUS_BAD_ARG;
2049
2050    C = st->channels;
2051    N = frame_size;
2052    ALLOC(in, C*N, opus_int16);
2053
2054    for (j=0;j<C*N;j++)
2055      in[j] = FLOAT2INT16(pcm[j]);
2056
2057    ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
2058 #ifdef RESYNTH
2059    for (j=0;j<C*N;j++)
2060       ((float*)pcm)[j]=in[j]*(1.f/32768.f);
2061 #endif
2062    RESTORE_STACK;
2063    return ret;
2064 }
2065 #endif /* DISABLE_FLOAT_API */
2066 #else
2067
2068 int opus_custom_encode(CELTEncoder * OPUS_RESTRICT st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2069 {
2070    int j, ret, C, N;
2071    VARDECL(celt_sig, in);
2072    ALLOC_STACK;
2073
2074    if (pcm==NULL)
2075       return OPUS_BAD_ARG;
2076
2077    C=st->channels;
2078    N=frame_size;
2079    ALLOC(in, C*N, celt_sig);
2080    for (j=0;j<C*N;j++) {
2081      in[j] = SCALEOUT(pcm[j]);
2082    }
2083
2084    ret = celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
2085 #ifdef RESYNTH
2086    for (j=0;j<C*N;j++)
2087       ((opus_int16*)pcm)[j] = FLOAT2INT16(in[j]);
2088 #endif
2089    RESTORE_STACK;
2090    return ret;
2091 }
2092
2093 int opus_custom_encode_float(CELTEncoder * OPUS_RESTRICT st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2094 {
2095    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
2096 }
2097
2098 #endif
2099
2100 #endif /* CUSTOM_MODES */
2101
2102 int opus_custom_encoder_ctl(CELTEncoder * OPUS_RESTRICT st, int request, ...)
2103 {
2104    va_list ap;
2105
2106    va_start(ap, request);
2107    switch (request)
2108    {
2109       case OPUS_SET_COMPLEXITY_REQUEST:
2110       {
2111          int value = va_arg(ap, opus_int32);
2112          if (value<0 || value>10)
2113             goto bad_arg;
2114          st->complexity = value;
2115       }
2116       break;
2117       case CELT_SET_START_BAND_REQUEST:
2118       {
2119          opus_int32 value = va_arg(ap, opus_int32);
2120          if (value<0 || value>=st->mode->nbEBands)
2121             goto bad_arg;
2122          st->start = value;
2123       }
2124       break;
2125       case CELT_SET_END_BAND_REQUEST:
2126       {
2127          opus_int32 value = va_arg(ap, opus_int32);
2128          if (value<1 || value>st->mode->nbEBands)
2129             goto bad_arg;
2130          st->end = value;
2131       }
2132       break;
2133       case CELT_SET_PREDICTION_REQUEST:
2134       {
2135          int value = va_arg(ap, opus_int32);
2136          if (value<0 || value>2)
2137             goto bad_arg;
2138          st->disable_pf = value<=1;
2139          st->force_intra = value==0;
2140       }
2141       break;
2142       case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2143       {
2144          int value = va_arg(ap, opus_int32);
2145          if (value<0 || value>100)
2146             goto bad_arg;
2147          st->loss_rate = value;
2148       }
2149       break;
2150       case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2151       {
2152          opus_int32 value = va_arg(ap, opus_int32);
2153          st->constrained_vbr = value;
2154       }
2155       break;
2156       case OPUS_SET_VBR_REQUEST:
2157       {
2158          opus_int32 value = va_arg(ap, opus_int32);
2159          st->vbr = value;
2160       }
2161       break;
2162       case OPUS_SET_BITRATE_REQUEST:
2163       {
2164          opus_int32 value = va_arg(ap, opus_int32);
2165          if (value<=500 && value!=OPUS_BITRATE_MAX)
2166             goto bad_arg;
2167          value = IMIN(value, 260000*st->channels);
2168          st->bitrate = value;
2169       }
2170       break;
2171       case CELT_SET_CHANNELS_REQUEST:
2172       {
2173          opus_int32 value = va_arg(ap, opus_int32);
2174          if (value<1 || value>2)
2175             goto bad_arg;
2176          st->stream_channels = value;
2177       }
2178       break;
2179       case OPUS_SET_LSB_DEPTH_REQUEST:
2180       {
2181           opus_int32 value = va_arg(ap, opus_int32);
2182           if (value<8 || value>24)
2183              goto bad_arg;
2184           st->lsb_depth=value;
2185       }
2186       break;
2187       case OPUS_GET_LSB_DEPTH_REQUEST:
2188       {
2189           opus_int32 *value = va_arg(ap, opus_int32*);
2190           *value=st->lsb_depth;
2191       }
2192       break;
2193       case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
2194       {
2195           opus_int32 value = va_arg(ap, opus_int32);
2196           st->variable_duration = value;
2197       }
2198       break;
2199       case OPUS_RESET_STATE:
2200       {
2201          int i;
2202          opus_val16 *oldBandE, *oldLogE, *oldLogE2;
2203          oldBandE = (opus_val16*)(st->in_mem+st->channels*(st->overlap+COMBFILTER_MAXPERIOD));
2204          oldLogE = oldBandE + st->channels*st->mode->nbEBands;
2205          oldLogE2 = oldLogE + st->channels*st->mode->nbEBands;
2206          OPUS_CLEAR((char*)&st->ENCODER_RESET_START,
2207                opus_custom_encoder_get_size(st->mode, st->channels)-
2208                ((char*)&st->ENCODER_RESET_START - (char*)st));
2209          for (i=0;i<st->channels*st->mode->nbEBands;i++)
2210             oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT);
2211          st->vbr_offset = 0;
2212          st->delayedIntra = 1;
2213          st->spread_decision = SPREAD_NORMAL;
2214          st->tonal_average = 256;
2215          st->hf_average = 0;
2216          st->tapset_decision = 0;
2217       }
2218       break;
2219 #ifdef CUSTOM_MODES
2220       case CELT_SET_INPUT_CLIPPING_REQUEST:
2221       {
2222          opus_int32 value = va_arg(ap, opus_int32);
2223          st->clip = value;
2224       }
2225       break;
2226 #endif
2227       case CELT_SET_SIGNALLING_REQUEST:
2228       {
2229          opus_int32 value = va_arg(ap, opus_int32);
2230          st->signalling = value;
2231       }
2232       break;
2233       case CELT_SET_ANALYSIS_REQUEST:
2234       {
2235          AnalysisInfo *info = va_arg(ap, AnalysisInfo *);
2236          if (info)
2237             OPUS_COPY(&st->analysis, info, 1);
2238       }
2239       break;
2240       case CELT_GET_MODE_REQUEST:
2241       {
2242          const CELTMode ** value = va_arg(ap, const CELTMode**);
2243          if (value==0)
2244             goto bad_arg;
2245          *value=st->mode;
2246       }
2247       break;
2248       case OPUS_GET_FINAL_RANGE_REQUEST:
2249       {
2250          opus_uint32 * value = va_arg(ap, opus_uint32 *);
2251          if (value==0)
2252             goto bad_arg;
2253          *value=st->rng;
2254       }
2255       break;
2256       case OPUS_SET_LFE_REQUEST:
2257       {
2258           opus_int32 value = va_arg(ap, opus_int32);
2259           st->lfe = value;
2260       }
2261       break;
2262       case OPUS_SET_ENERGY_SAVE_REQUEST:
2263       {
2264           opus_val16 *value = va_arg(ap, opus_val16*);
2265           st->energy_save=value;
2266       }
2267       break;
2268       case OPUS_SET_ENERGY_MASK_REQUEST:
2269       {
2270           opus_val16 *value = va_arg(ap, opus_val16*);
2271           st->energy_mask = value;
2272       }
2273       break;
2274       default:
2275          goto bad_request;
2276    }
2277    va_end(ap);
2278    return OPUS_OK;
2279 bad_arg:
2280    va_end(ap);
2281    return OPUS_BAD_ARG;
2282 bad_request:
2283    va_end(ap);
2284    return OPUS_UNIMPLEMENTED;
2285 }