fb33cb6252ccccff1f0b8e46e794b5ebf6770855
[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    compute_band_energies(mode, freq, bandE, effEnd, C, M);
1384
1385    amp2Log2(mode, effEnd, st->end, bandE, bandLogE, C);
1386    /*for (i=0;i<21;i++)
1387       printf("%f ", bandLogE[i]);
1388    printf("\n");*/
1389
1390    if (!secondMdct)
1391    {
1392       for (i=0;i<C*nbEBands;i++)
1393          bandLogE2[i] = bandLogE[i];
1394    }
1395
1396    /* Last chance to catch any transient we might have missed in the
1397       time-domain analysis */
1398    if (LM>0 && ec_tell(enc)+3<=total_bits && !isTransient && st->complexity>=5)
1399    {
1400       if (patch_transient_decision(bandLogE, oldBandE, nbEBands, st->end, C))
1401       {
1402          isTransient = 1;
1403          shortBlocks = M;
1404          compute_mdcts(mode, shortBlocks, in, freq, C, CC, LM, st->upsample);
1405          compute_band_energies(mode, freq, bandE, effEnd, C, M);
1406          amp2Log2(mode, effEnd, st->end, bandE, bandLogE, C);
1407          /* Compensate for the scaling of short vs long mdcts */
1408          for (i=0;i<C*nbEBands;i++)
1409             bandLogE2[i] += HALF16(SHL16(LM, DB_SHIFT));
1410          tf_estimate = QCONST16(.2,14);
1411       }
1412    }
1413
1414    if (LM>0 && ec_tell(enc)+3<=total_bits)
1415       ec_enc_bit_logp(enc, isTransient, 3);
1416
1417    ALLOC(X, C*N, celt_norm);         /**< Interleaved normalised MDCTs */
1418
1419    /* Band normalisation */
1420    normalise_bands(mode, freq, X, bandE, effEnd, C, M);
1421
1422    ALLOC(tf_res, nbEBands, int);
1423    /* Disable variable tf resolution for hybrid and at very low bitrate */
1424    if (effectiveBytes>=15*C && st->start==0 && st->complexity>=2)
1425    {
1426       int lambda;
1427       if (effectiveBytes<40)
1428          lambda = 12;
1429       else if (effectiveBytes<60)
1430          lambda = 6;
1431       else if (effectiveBytes<100)
1432          lambda = 4;
1433       else
1434          lambda = 3;
1435       lambda*=2;
1436       tf_select = tf_analysis(mode, effEnd, isTransient, tf_res, lambda, X, N, LM, &tf_sum, tf_estimate, tf_chan);
1437       for (i=effEnd;i<st->end;i++)
1438          tf_res[i] = tf_res[effEnd-1];
1439    } else {
1440       tf_sum = 0;
1441       for (i=0;i<st->end;i++)
1442          tf_res[i] = isTransient;
1443       tf_select=0;
1444    }
1445
1446    ALLOC(error, C*nbEBands, opus_val16);
1447    quant_coarse_energy(mode, st->start, st->end, effEnd, bandLogE,
1448          oldBandE, total_bits, error, enc,
1449          C, LM, nbAvailableBytes, st->force_intra,
1450          &st->delayedIntra, st->complexity >= 4, st->loss_rate);
1451
1452    tf_encode(st->start, st->end, isTransient, tf_res, LM, tf_select, enc);
1453
1454    if (ec_tell(enc)+4<=total_bits)
1455    {
1456       if (shortBlocks || st->complexity < 3 || nbAvailableBytes < 10*C || st->start != 0)
1457       {
1458          if (st->complexity == 0)
1459             st->spread_decision = SPREAD_NONE;
1460          else
1461             st->spread_decision = SPREAD_NORMAL;
1462       } else {
1463          /* Disable new spreading+tapset estimator until we can show it works
1464             better than the old one. So far it seems like spreading_decision()
1465             works best. */
1466          if (0&&st->analysis.valid)
1467          {
1468             static const opus_val16 spread_thresholds[3] = {-QCONST16(.6f, 15), -QCONST16(.2f, 15), -QCONST16(.07f, 15)};
1469             static const opus_val16 spread_histeresis[3] = {QCONST16(.15f, 15), QCONST16(.07f, 15), QCONST16(.02f, 15)};
1470             static const opus_val16 tapset_thresholds[2] = {QCONST16(.0f, 15), QCONST16(.15f, 15)};
1471             static const opus_val16 tapset_histeresis[2] = {QCONST16(.1f, 15), QCONST16(.05f, 15)};
1472             st->spread_decision = hysteresis_decision(-st->analysis.tonality, spread_thresholds, spread_histeresis, 3, st->spread_decision);
1473             st->tapset_decision = hysteresis_decision(st->analysis.tonality_slope, tapset_thresholds, tapset_histeresis, 2, st->tapset_decision);
1474          } else {
1475             st->spread_decision = spreading_decision(mode, X,
1476                   &st->tonal_average, st->spread_decision, &st->hf_average,
1477                   &st->tapset_decision, pf_on&&!shortBlocks, effEnd, C, M);
1478          }
1479          /*printf("%d %d\n", st->tapset_decision, st->spread_decision);*/
1480          /*printf("%f %d %f %d\n\n", st->analysis.tonality, st->spread_decision, st->analysis.tonality_slope, st->tapset_decision);*/
1481       }
1482       ec_enc_icdf(enc, st->spread_decision, spread_icdf, 5);
1483    }
1484
1485    ALLOC(offsets, nbEBands, int);
1486
1487    maxDepth = dynalloc_analysis(bandLogE, bandLogE2, nbEBands, st->start, st->end, C, offsets,
1488          st->lsb_depth, mode->logN, isTransient, st->vbr, st->constrained_vbr,
1489          eBands, LM, effectiveBytes, &tot_boost);
1490    ALLOC(cap, nbEBands, int);
1491    init_caps(mode,cap,LM,C);
1492
1493    dynalloc_logp = 6;
1494    total_bits<<=BITRES;
1495    total_boost = 0;
1496    tell = ec_tell_frac(enc);
1497    for (i=st->start;i<st->end;i++)
1498    {
1499       int width, quanta;
1500       int dynalloc_loop_logp;
1501       int boost;
1502       int j;
1503       width = C*(eBands[i+1]-eBands[i])<<LM;
1504       /* quanta is 6 bits, but no more than 1 bit/sample
1505          and no less than 1/8 bit/sample */
1506       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
1507       dynalloc_loop_logp = dynalloc_logp;
1508       boost = 0;
1509       for (j = 0; tell+(dynalloc_loop_logp<<BITRES) < total_bits-total_boost
1510             && boost < cap[i]; j++)
1511       {
1512          int flag;
1513          flag = j<offsets[i];
1514          ec_enc_bit_logp(enc, flag, dynalloc_loop_logp);
1515          tell = ec_tell_frac(enc);
1516          if (!flag)
1517             break;
1518          boost += quanta;
1519          total_boost += quanta;
1520          dynalloc_loop_logp = 1;
1521       }
1522       /* Making dynalloc more likely */
1523       if (j)
1524          dynalloc_logp = IMAX(2, dynalloc_logp-1);
1525       offsets[i] = boost;
1526    }
1527
1528    if (C==2)
1529    {
1530       int effectiveRate;
1531
1532       static const opus_val16 intensity_thresholds[21]=
1533       /* 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19  20  off*/
1534         { 16,21,23,25,27,29,31,33,35,38,42,46,50,54,58,63,68,75,84,102,130};
1535       static const opus_val16 intensity_histeresis[21]=
1536         {  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 4, 5, 6,  8, 12};
1537
1538       /* Always use MS for 2.5 ms frames until we can do a better analysis */
1539       if (LM!=0)
1540          dual_stereo = stereo_analysis(mode, X, LM, N);
1541
1542       /* Account for coarse energy */
1543       effectiveRate = (8*effectiveBytes - 80)>>LM;
1544
1545       /* effectiveRate in kb/s */
1546       effectiveRate = 2*effectiveRate/5;
1547
1548       st->intensity = hysteresis_decision((opus_val16)effectiveRate, intensity_thresholds, intensity_histeresis, 21, st->intensity);
1549       st->intensity = IMIN(st->end,IMAX(st->start, st->intensity));
1550    }
1551
1552    alloc_trim = 5;
1553    if (tell+(6<<BITRES) <= total_bits - total_boost)
1554    {
1555       alloc_trim = alloc_trim_analysis(mode, X, bandLogE,
1556             st->end, LM, C, N, &st->analysis, &st->stereo_saving, tf_estimate, st->intensity);
1557       ec_enc_icdf(enc, alloc_trim, trim_icdf, 7);
1558       tell = ec_tell_frac(enc);
1559    }
1560
1561    /* Variable bitrate */
1562    if (vbr_rate>0)
1563    {
1564      opus_val16 alpha;
1565      opus_int32 delta;
1566      /* The target rate in 8th bits per frame */
1567      opus_int32 target, base_target;
1568      opus_int32 min_allowed;
1569      int coded_bins;
1570      int coded_bands;
1571      int lm_diff = mode->maxLM - LM;
1572      coded_bands = st->lastCodedBands ? st->lastCodedBands : nbEBands;
1573      coded_bins = eBands[coded_bands]<<LM;
1574      if (C==2)
1575         coded_bins += eBands[IMIN(st->intensity, coded_bands)]<<LM;
1576
1577      /* Don't attempt to use more than 510 kb/s, even for frames smaller than 20 ms.
1578         The CELT allocator will just not be able to use more than that anyway. */
1579      nbCompressedBytes = IMIN(nbCompressedBytes,1275>>(3-LM));
1580      target = vbr_rate - ((40*C+20)<<BITRES);
1581      base_target = target;
1582
1583      if (st->constrained_vbr)
1584         target += (st->vbr_offset>>lm_diff);
1585
1586      /*printf("%f %f %f %f %d %d ", st->analysis.activity, st->analysis.tonality, tf_estimate, st->stereo_saving, tot_boost, coded_bands);*/
1587 #ifndef FIXED_POINT
1588      if (st->analysis.valid && st->analysis.activity<.4)
1589         target -= (opus_int32)((coded_bins<<BITRES)*(.4f-st->analysis.activity));
1590 #endif
1591      /* Stereo savings */
1592      if (C==2)
1593      {
1594         int coded_stereo_bands;
1595         int coded_stereo_dof;
1596         opus_val16 max_frac;
1597         coded_stereo_bands = IMIN(st->intensity, coded_bands);
1598         coded_stereo_dof = (eBands[coded_stereo_bands]<<LM)-coded_stereo_bands;
1599         /* Maximum fraction of the bits we can save if the signal is mono. */
1600         max_frac = DIV32_16(MULT16_16(QCONST16(0.8f, 15), coded_stereo_dof), coded_bins);
1601         /*printf("%d %d %d ", coded_stereo_dof, coded_bins, tot_boost);*/
1602         target -= (opus_int32)MIN32(MULT16_32_Q15(max_frac,target),
1603                         SHR16(MULT16_16(st->stereo_saving-QCONST16(0.1f,8),(coded_stereo_dof<<BITRES)),8));
1604      }
1605      /* Boost the rate according to dynalloc (minus the dynalloc average for calibration). */
1606      target += tot_boost-(16<<LM);
1607      /* Apply transient boost, compensating for average boost. */
1608      target += (opus_int32)SHL32(MULT16_32_Q15(tf_estimate-QCONST16(0.04f,14), target),1);
1609
1610 #ifndef FIXED_POINT
1611      /* Apply tonality boost */
1612      if (st->analysis.valid) {
1613         opus_int32 tonal_target;
1614         float tonal;
1615
1616         /* Tonality boost (compensating for the average). */
1617         tonal = MAX16(0.f,st->analysis.tonality-.15f)-0.09f;
1618         tonal_target = target + (opus_int32)((coded_bins<<BITRES)*1.2f*tonal);
1619         if (pitch_change)
1620            tonal_target +=  (opus_int32)((coded_bins<<BITRES)*.8f);
1621         /*printf("%f %f ", st->analysis.tonality, tonal);*/
1622         target = tonal_target;
1623      }
1624 #endif
1625
1626      {
1627         opus_int32 floor_depth;
1628         int bins;
1629         bins = eBands[nbEBands-2]<<LM;
1630         /*floor_depth = SHR32(MULT16_16((C*bins<<BITRES),celt_log2(SHL32(MAX16(1,sample_max),13))), DB_SHIFT);*/
1631         floor_depth = (opus_int32)SHR32(MULT16_16((C*bins<<BITRES),maxDepth), DB_SHIFT);
1632         floor_depth = IMAX(floor_depth, target>>2);
1633         target = IMIN(target, floor_depth);
1634         /*printf("%f %d\n", maxDepth, floor_depth);*/
1635      }
1636
1637      if (st->constrained_vbr || st->bitrate<64000)
1638      {
1639         opus_val16 rate_factor;
1640 #ifdef FIXED_POINT
1641         rate_factor = MAX16(0,(st->bitrate-32000));
1642 #else
1643         rate_factor = MAX16(0,(1.f/32768)*(st->bitrate-32000));
1644 #endif
1645         if (st->constrained_vbr)
1646            rate_factor = MIN16(rate_factor, QCONST16(0.67f, 15));
1647         target = base_target + (opus_int32)MULT16_32_Q15(rate_factor, target-base_target);
1648
1649      }
1650      /* Don't allow more than doubling the rate */
1651      target = IMIN(2*base_target, target);
1652
1653      /* The current offset is removed from the target and the space used
1654         so far is added*/
1655      target=target+tell;
1656      /* In VBR mode the frame size must not be reduced so much that it would
1657          result in the encoder running out of bits.
1658         The margin of 2 bytes ensures that none of the bust-prevention logic
1659          in the decoder will have triggered so far. */
1660      min_allowed = ((tell+total_boost+(1<<(BITRES+3))-1)>>(BITRES+3)) + 2 - nbFilledBytes;
1661
1662      nbAvailableBytes = (target+(1<<(BITRES+2)))>>(BITRES+3);
1663      nbAvailableBytes = IMAX(min_allowed,nbAvailableBytes);
1664      nbAvailableBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes) - nbFilledBytes;
1665
1666      /* By how much did we "miss" the target on that frame */
1667      delta = target - vbr_rate;
1668
1669      target=nbAvailableBytes<<(BITRES+3);
1670
1671      /*If the frame is silent we don't adjust our drift, otherwise
1672        the encoder will shoot to very high rates after hitting a
1673        span of silence, but we do allow the bitres to refill.
1674        This means that we'll undershoot our target in CVBR/VBR modes
1675        on files with lots of silence. */
1676      if(silence)
1677      {
1678        nbAvailableBytes = 2;
1679        target = 2*8<<BITRES;
1680        delta = 0;
1681      }
1682
1683      if (st->vbr_count < 970)
1684      {
1685         st->vbr_count++;
1686         alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+20),16));
1687      } else
1688         alpha = QCONST16(.001f,15);
1689      /* How many bits have we used in excess of what we're allowed */
1690      if (st->constrained_vbr)
1691         st->vbr_reservoir += target - vbr_rate;
1692      /*printf ("%d\n", st->vbr_reservoir);*/
1693
1694      /* Compute the offset we need to apply in order to reach the target */
1695      if (st->constrained_vbr)
1696      {
1697         st->vbr_drift += (opus_int32)MULT16_32_Q15(alpha,(delta*(1<<lm_diff))-st->vbr_offset-st->vbr_drift);
1698         st->vbr_offset = -st->vbr_drift;
1699      }
1700      /*printf ("%d\n", st->vbr_drift);*/
1701
1702      if (st->constrained_vbr && st->vbr_reservoir < 0)
1703      {
1704         /* We're under the min value -- increase rate */
1705         int adjust = (-st->vbr_reservoir)/(8<<BITRES);
1706         /* Unless we're just coding silence */
1707         nbAvailableBytes += silence?0:adjust;
1708         st->vbr_reservoir = 0;
1709         /*printf ("+%d\n", adjust);*/
1710      }
1711      nbCompressedBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes);
1712      /*printf("%d\n", nbCompressedBytes*50*8);*/
1713      /* This moves the raw bits to take into account the new compressed size */
1714      ec_enc_shrink(enc, nbCompressedBytes);
1715    }
1716
1717    /* Bit allocation */
1718    ALLOC(fine_quant, nbEBands, int);
1719    ALLOC(pulses, nbEBands, int);
1720    ALLOC(fine_priority, nbEBands, int);
1721
1722    /* bits =           packet size                    - where we are - safety*/
1723    bits = (((opus_int32)nbCompressedBytes*8)<<BITRES) - ec_tell_frac(enc) - 1;
1724    anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0;
1725    bits -= anti_collapse_rsv;
1726    signalBandwidth = st->end-1;
1727 #ifndef FIXED_POINT
1728    if (st->analysis.valid)
1729       signalBandwidth = st->analysis.bandwidth;
1730 #endif
1731    codedBands = compute_allocation(mode, st->start, st->end, offsets, cap,
1732          alloc_trim, &st->intensity, &dual_stereo, bits, &balance, pulses,
1733          fine_quant, fine_priority, C, LM, enc, 1, st->lastCodedBands, signalBandwidth);
1734    st->lastCodedBands = codedBands;
1735
1736    quant_fine_energy(mode, st->start, st->end, oldBandE, error, fine_quant, enc, C);
1737
1738 #ifdef MEASURE_NORM_MSE
1739    float X0[3000];
1740    float bandE0[60];
1741    c=0; do
1742       for (i=0;i<N;i++)
1743          X0[i+c*N] = X[i+c*N];
1744    while (++c<C);
1745    for (i=0;i<C*nbEBands;i++)
1746       bandE0[i] = bandE[i];
1747 #endif
1748
1749    /* Residual quantisation */
1750    ALLOC(collapse_masks, C*nbEBands, unsigned char);
1751    quant_all_bands(1, mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
1752          bandE, pulses, shortBlocks, st->spread_decision, dual_stereo, st->intensity, tf_res,
1753          nbCompressedBytes*(8<<BITRES)-anti_collapse_rsv, balance, enc, LM, codedBands, &st->rng);
1754
1755    if (anti_collapse_rsv > 0)
1756    {
1757       anti_collapse_on = st->consec_transient<2;
1758 #ifdef FUZZING
1759       anti_collapse_on = rand()&0x1;
1760 #endif
1761       ec_enc_bits(enc, anti_collapse_on, 1);
1762    }
1763    quant_energy_finalise(mode, st->start, st->end, oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_tell(enc), enc, C);
1764
1765    if (silence)
1766    {
1767       for (i=0;i<C*nbEBands;i++)
1768          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
1769    }
1770
1771 #ifdef RESYNTH
1772    /* Re-synthesis of the coded audio if required */
1773    {
1774       celt_sig *out_mem[2];
1775
1776       log2Amp(mode, st->start, st->end, bandE, oldBandE, C);
1777       if (silence)
1778       {
1779          for (i=0;i<C*nbEBands;i++)
1780             bandE[i] = 0;
1781       }
1782
1783 #ifdef MEASURE_NORM_MSE
1784       measure_norm_mse(mode, X, X0, bandE, bandE0, M, N, C);
1785 #endif
1786       if (anti_collapse_on)
1787       {
1788          anti_collapse(mode, X, collapse_masks, LM, C, N,
1789                st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
1790       }
1791
1792       /* Synthesis */
1793       denormalise_bands(mode, X, freq, bandE, st->start, effEnd, C, M);
1794
1795       c=0; do {
1796          OPUS_MOVE(st->syn_mem[c], st->syn_mem[c]+N, 2*MAX_PERIOD-N+overlap/2);
1797       } while (++c<CC);
1798
1799       if (CC==2&&C==1)
1800       {
1801          for (i=0;i<N;i++)
1802             freq[N+i] = freq[i];
1803       }
1804
1805       c=0; do {
1806          out_mem[c] = st->syn_mem[c]+2*MAX_PERIOD-N;
1807       } while (++c<CC);
1808
1809       compute_inv_mdcts(mode, shortBlocks, freq, out_mem, CC, LM);
1810
1811       c=0; do {
1812          st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
1813          st->prefilter_period_old=IMAX(st->prefilter_period_old, COMBFILTER_MINPERIOD);
1814          comb_filter(out_mem[c], out_mem[c], st->prefilter_period_old, st->prefilter_period, mode->shortMdctSize,
1815                st->prefilter_gain_old, st->prefilter_gain, st->prefilter_tapset_old, st->prefilter_tapset,
1816                mode->window, st->overlap);
1817          if (LM!=0)
1818             comb_filter(out_mem[c]+mode->shortMdctSize, out_mem[c]+mode->shortMdctSize, st->prefilter_period, pitch_index, N-mode->shortMdctSize,
1819                   st->prefilter_gain, gain1, st->prefilter_tapset, prefilter_tapset,
1820                   mode->window, overlap);
1821       } while (++c<CC);
1822
1823       /* We reuse freq[] as scratch space for the de-emphasis */
1824       deemphasis(out_mem, (opus_val16*)pcm, N, CC, st->upsample, mode->preemph, st->preemph_memD, freq);
1825       st->prefilter_period_old = st->prefilter_period;
1826       st->prefilter_gain_old = st->prefilter_gain;
1827       st->prefilter_tapset_old = st->prefilter_tapset;
1828    }
1829 #endif
1830
1831    st->prefilter_period = pitch_index;
1832    st->prefilter_gain = gain1;
1833    st->prefilter_tapset = prefilter_tapset;
1834 #ifdef RESYNTH
1835    if (LM!=0)
1836    {
1837       st->prefilter_period_old = st->prefilter_period;
1838       st->prefilter_gain_old = st->prefilter_gain;
1839       st->prefilter_tapset_old = st->prefilter_tapset;
1840    }
1841 #endif
1842
1843    if (CC==2&&C==1) {
1844       for (i=0;i<nbEBands;i++)
1845          oldBandE[nbEBands+i]=oldBandE[i];
1846    }
1847
1848    if (!isTransient)
1849    {
1850       for (i=0;i<CC*nbEBands;i++)
1851          oldLogE2[i] = oldLogE[i];
1852       for (i=0;i<CC*nbEBands;i++)
1853          oldLogE[i] = oldBandE[i];
1854    } else {
1855       for (i=0;i<CC*nbEBands;i++)
1856          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
1857    }
1858    /* In case start or end were to change */
1859    c=0; do
1860    {
1861       for (i=0;i<st->start;i++)
1862       {
1863          oldBandE[c*nbEBands+i]=0;
1864          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
1865       }
1866       for (i=st->end;i<nbEBands;i++)
1867       {
1868          oldBandE[c*nbEBands+i]=0;
1869          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
1870       }
1871    } while (++c<CC);
1872
1873    if (isTransient)
1874       st->consec_transient++;
1875    else
1876       st->consec_transient=0;
1877    st->rng = enc->rng;
1878
1879    /* If there's any room left (can only happen for very high rates),
1880       it's already filled with zeros */
1881    ec_enc_done(enc);
1882
1883 #ifdef CUSTOM_MODES
1884    if (st->signalling)
1885       nbCompressedBytes++;
1886 #endif
1887
1888    RESTORE_STACK;
1889    if (ec_get_error(enc))
1890       return OPUS_INTERNAL_ERROR;
1891    else
1892       return nbCompressedBytes;
1893 }
1894
1895
1896 #ifdef CUSTOM_MODES
1897
1898 #ifdef FIXED_POINT
1899 int opus_custom_encode(CELTEncoder * OPUS_RESTRICT st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1900 {
1901    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1902 }
1903
1904 #ifndef DISABLE_FLOAT_API
1905 int opus_custom_encode_float(CELTEncoder * OPUS_RESTRICT st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1906 {
1907    int j, ret, C, N;
1908    VARDECL(opus_int16, in);
1909    ALLOC_STACK;
1910
1911    if (pcm==NULL)
1912       return OPUS_BAD_ARG;
1913
1914    C = st->channels;
1915    N = frame_size;
1916    ALLOC(in, C*N, opus_int16);
1917
1918    for (j=0;j<C*N;j++)
1919      in[j] = FLOAT2INT16(pcm[j]);
1920
1921    ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
1922 #ifdef RESYNTH
1923    for (j=0;j<C*N;j++)
1924       ((float*)pcm)[j]=in[j]*(1.f/32768.f);
1925 #endif
1926    RESTORE_STACK;
1927    return ret;
1928 }
1929 #endif /* DISABLE_FLOAT_API */
1930 #else
1931
1932 int opus_custom_encode(CELTEncoder * OPUS_RESTRICT st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1933 {
1934    int j, ret, C, N;
1935    VARDECL(celt_sig, in);
1936    ALLOC_STACK;
1937
1938    if (pcm==NULL)
1939       return OPUS_BAD_ARG;
1940
1941    C=st->channels;
1942    N=frame_size;
1943    ALLOC(in, C*N, celt_sig);
1944    for (j=0;j<C*N;j++) {
1945      in[j] = SCALEOUT(pcm[j]);
1946    }
1947
1948    ret = celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
1949 #ifdef RESYNTH
1950    for (j=0;j<C*N;j++)
1951       ((opus_int16*)pcm)[j] = FLOAT2INT16(in[j]);
1952 #endif
1953    RESTORE_STACK;
1954    return ret;
1955 }
1956
1957 int opus_custom_encode_float(CELTEncoder * OPUS_RESTRICT st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1958 {
1959    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1960 }
1961
1962 #endif
1963
1964 #endif /* CUSTOM_MODES */
1965
1966 int opus_custom_encoder_ctl(CELTEncoder * OPUS_RESTRICT st, int request, ...)
1967 {
1968    va_list ap;
1969
1970    va_start(ap, request);
1971    switch (request)
1972    {
1973       case OPUS_SET_COMPLEXITY_REQUEST:
1974       {
1975          int value = va_arg(ap, opus_int32);
1976          if (value<0 || value>10)
1977             goto bad_arg;
1978          st->complexity = value;
1979       }
1980       break;
1981       case CELT_SET_START_BAND_REQUEST:
1982       {
1983          opus_int32 value = va_arg(ap, opus_int32);
1984          if (value<0 || value>=st->mode->nbEBands)
1985             goto bad_arg;
1986          st->start = value;
1987       }
1988       break;
1989       case CELT_SET_END_BAND_REQUEST:
1990       {
1991          opus_int32 value = va_arg(ap, opus_int32);
1992          if (value<1 || value>st->mode->nbEBands)
1993             goto bad_arg;
1994          st->end = value;
1995       }
1996       break;
1997       case CELT_SET_PREDICTION_REQUEST:
1998       {
1999          int value = va_arg(ap, opus_int32);
2000          if (value<0 || value>2)
2001             goto bad_arg;
2002          st->disable_pf = value<=1;
2003          st->force_intra = value==0;
2004       }
2005       break;
2006       case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2007       {
2008          int value = va_arg(ap, opus_int32);
2009          if (value<0 || value>100)
2010             goto bad_arg;
2011          st->loss_rate = value;
2012       }
2013       break;
2014       case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2015       {
2016          opus_int32 value = va_arg(ap, opus_int32);
2017          st->constrained_vbr = value;
2018       }
2019       break;
2020       case OPUS_SET_VBR_REQUEST:
2021       {
2022          opus_int32 value = va_arg(ap, opus_int32);
2023          st->vbr = value;
2024       }
2025       break;
2026       case OPUS_SET_BITRATE_REQUEST:
2027       {
2028          opus_int32 value = va_arg(ap, opus_int32);
2029          if (value<=500 && value!=OPUS_BITRATE_MAX)
2030             goto bad_arg;
2031          value = IMIN(value, 260000*st->channels);
2032          st->bitrate = value;
2033       }
2034       break;
2035       case CELT_SET_CHANNELS_REQUEST:
2036       {
2037          opus_int32 value = va_arg(ap, opus_int32);
2038          if (value<1 || value>2)
2039             goto bad_arg;
2040          st->stream_channels = value;
2041       }
2042       break;
2043       case OPUS_SET_LSB_DEPTH_REQUEST:
2044       {
2045           opus_int32 value = va_arg(ap, opus_int32);
2046           if (value<8 || value>24)
2047              goto bad_arg;
2048           st->lsb_depth=value;
2049       }
2050       break;
2051       case OPUS_GET_LSB_DEPTH_REQUEST:
2052       {
2053           opus_int32 *value = va_arg(ap, opus_int32*);
2054           *value=st->lsb_depth;
2055       }
2056       break;
2057       case OPUS_RESET_STATE:
2058       {
2059          int i;
2060          opus_val16 *oldBandE, *oldLogE, *oldLogE2;
2061          oldBandE = (opus_val16*)(st->in_mem+st->channels*(st->overlap+COMBFILTER_MAXPERIOD));
2062          oldLogE = oldBandE + st->channels*st->mode->nbEBands;
2063          oldLogE2 = oldLogE + st->channels*st->mode->nbEBands;
2064          OPUS_CLEAR((char*)&st->ENCODER_RESET_START,
2065                opus_custom_encoder_get_size(st->mode, st->channels)-
2066                ((char*)&st->ENCODER_RESET_START - (char*)st));
2067          for (i=0;i<st->channels*st->mode->nbEBands;i++)
2068             oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT);
2069          st->vbr_offset = 0;
2070          st->delayedIntra = 1;
2071          st->spread_decision = SPREAD_NORMAL;
2072          st->tonal_average = 256;
2073          st->hf_average = 0;
2074          st->tapset_decision = 0;
2075       }
2076       break;
2077 #ifdef CUSTOM_MODES
2078       case CELT_SET_INPUT_CLIPPING_REQUEST:
2079       {
2080          opus_int32 value = va_arg(ap, opus_int32);
2081          st->clip = value;
2082       }
2083       break;
2084 #endif
2085       case CELT_SET_SIGNALLING_REQUEST:
2086       {
2087          opus_int32 value = va_arg(ap, opus_int32);
2088          st->signalling = value;
2089       }
2090       break;
2091       case CELT_SET_ANALYSIS_REQUEST:
2092       {
2093          AnalysisInfo *info = va_arg(ap, AnalysisInfo *);
2094          if (info)
2095             OPUS_COPY(&st->analysis, info, 1);
2096       }
2097       break;
2098       case CELT_GET_MODE_REQUEST:
2099       {
2100          const CELTMode ** value = va_arg(ap, const CELTMode**);
2101          if (value==0)
2102             goto bad_arg;
2103          *value=st->mode;
2104       }
2105       break;
2106       case OPUS_GET_FINAL_RANGE_REQUEST:
2107       {
2108          opus_uint32 * value = va_arg(ap, opus_uint32 *);
2109          if (value==0)
2110             goto bad_arg;
2111          *value=st->rng;
2112       }
2113       break;
2114       default:
2115          goto bad_request;
2116    }
2117    va_end(ap);
2118    return OPUS_OK;
2119 bad_arg:
2120    va_end(ap);
2121    return OPUS_BAD_ARG;
2122 bad_request:
2123    va_end(ap);
2124    return OPUS_UNIMPLEMENTED;
2125 }