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