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