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