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