Disables tf_analysis() for hybrid mode
[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)
1286       {
1287          if (st->complexity == 0)
1288             st->spread_decision = SPREAD_NONE;
1289       } else {
1290          if (st->analysis.valid)
1291          {
1292             static const opus_val16 spread_thresholds[3] = {-QCONST16(.6f, 15), -QCONST16(.2f, 15), -QCONST16(.07f, 15)};
1293             static const opus_val16 spread_histeresis[3] = {QCONST16(.15f, 15), QCONST16(.07f, 15), QCONST16(.02f, 15)};
1294             static const opus_val16 tapset_thresholds[2] = {QCONST16(.0f, 15), QCONST16(.15f, 15)};
1295             static const opus_val16 tapset_histeresis[2] = {QCONST16(.1f, 15), QCONST16(.05f, 15)};
1296             st->spread_decision = hysteresis_decision(-st->analysis.tonality, spread_thresholds, spread_histeresis, 3, st->spread_decision);
1297             st->tapset_decision = hysteresis_decision(st->analysis.tonality_slope, tapset_thresholds, tapset_histeresis, 2, st->tapset_decision);
1298          } else {
1299             st->spread_decision = spreading_decision(mode, X,
1300                   &st->tonal_average, st->spread_decision, &st->hf_average,
1301                   &st->tapset_decision, pf_on&&!shortBlocks, effEnd, C, M);
1302          }
1303          /*printf("%d %d\n", st->tapset_decision, st->spread_decision);*/
1304          /*printf("%f %d %f %d\n\n", st->analysis.tonality, st->spread_decision, st->analysis.tonality_slope, st->tapset_decision);*/
1305       }
1306       ec_enc_icdf(enc, st->spread_decision, spread_icdf, 5);
1307    }
1308
1309    ALLOC(cap, nbEBands, int);
1310    ALLOC(offsets, nbEBands, int);
1311
1312    init_caps(mode,cap,LM,C);
1313    for (i=0;i<nbEBands;i++)
1314       offsets[i] = 0;
1315    /* Dynamic allocation code */
1316    maxDepth=-QCONST16(32.f, DB_SHIFT);
1317    /* Make sure that dynamic allocation can't make us bust the budget */
1318    if (effectiveBytes > 50 && LM>=1)
1319    {
1320       int last=0;
1321       VARDECL(opus_val16, follower);
1322       ALLOC(follower, C*nbEBands, opus_val16);
1323       c=0;do
1324       {
1325          follower[c*nbEBands] = bandLogE2[c*nbEBands];
1326          for (i=1;i<st->end;i++)
1327          {
1328             /* The last band to be at least 3 dB higher than the previous one
1329                is the last we'll consider. Otherwise, we run into problems on
1330                bandlimited signals. */
1331             if (bandLogE2[c*nbEBands+i] > bandLogE2[c*nbEBands+i-1]+QCONST16(.5f,DB_SHIFT))
1332                last=i;
1333             follower[c*nbEBands+i] = MIN16(follower[c*nbEBands+i-1]+QCONST16(1.5f,DB_SHIFT), bandLogE2[c*nbEBands+i]);
1334          }
1335          for (i=last-1;i>=0;i--)
1336             follower[c*nbEBands+i] = MIN16(follower[c*nbEBands+i], MIN16(follower[c*nbEBands+i+1]+QCONST16(2.f,DB_SHIFT), bandLogE2[c*nbEBands+i]));
1337          for (i=0;i<st->end;i++)
1338          {
1339             opus_val16 noise_floor;
1340             /* Noise floor must take into account eMeans, the depth, the width of the bands
1341                and the preemphasis filter (approx. square of bark band ID) */
1342             noise_floor = MULT16_16(QCONST16(0.0625f, DB_SHIFT),mode->logN[i])
1343                   +QCONST16(.5f,DB_SHIFT)+SHL16(9-st->lsb_depth,DB_SHIFT)-SHL16(eMeans[i],6)
1344                   +MULT16_16(QCONST16(.0062,DB_SHIFT),(i+5)*(i+5));
1345             follower[c*nbEBands+i] = MAX16(follower[c*nbEBands+i], noise_floor);
1346             maxDepth = MAX16(maxDepth, bandLogE[c*nbEBands+i]-noise_floor);
1347          }
1348       } while (++c<C);
1349       if (C==2)
1350       {
1351          for (i=st->start;i<st->end;i++)
1352          {
1353             /* Consider 24 dB "cross-talk" */
1354             follower[nbEBands+i] = MAX16(follower[nbEBands+i], follower[                   i]-QCONST16(4.f,DB_SHIFT));
1355             follower[                   i] = MAX16(follower[                   i], follower[nbEBands+i]-QCONST16(4.f,DB_SHIFT));
1356             follower[i] = HALF16(MAX16(0, bandLogE[i]-follower[i]) + MAX16(0, bandLogE[nbEBands+i]-follower[nbEBands+i]));
1357          }
1358       } else {
1359          for (i=st->start;i<st->end;i++)
1360          {
1361             follower[i] = MAX16(0, bandLogE[i]-follower[i]);
1362          }
1363       }
1364       /* For non-transient CBR/CVBR frames, halve the dynalloc contribution */
1365       if ((!st->vbr || st->constrained_vbr)&&!isTransient)
1366       {
1367          for (i=st->start;i<st->end;i++)
1368             follower[i] = HALF16(follower[i]);
1369       }
1370       for (i=st->start;i<st->end;i++)
1371       {
1372          int width;
1373          int boost;
1374          int boost_bits;
1375
1376          if (i<8)
1377             follower[i] *= 2;
1378          if (i>=12)
1379             follower[i] = HALF16(follower[i]);
1380          follower[i] = MIN16(follower[i], QCONST16(4, DB_SHIFT));
1381
1382          width = C*(eBands[i+1]-eBands[i])<<LM;
1383          if (width<6)
1384          {
1385             boost = SHR32(EXTEND32(follower[i]),DB_SHIFT);
1386             boost_bits = boost*width<<BITRES;
1387          } else if (width > 48) {
1388             boost = SHR32(EXTEND32(follower[i])*8,DB_SHIFT);
1389             boost_bits = (boost*width<<BITRES)/8;
1390          } else {
1391             boost = SHR32(EXTEND32(follower[i])*width/6,DB_SHIFT);
1392             boost_bits = boost*6<<BITRES;
1393          }
1394          /* For CBR and non-transient CVBR frames, limit dynalloc to 1/4 of the bits */
1395          if ((!st->vbr || (st->constrained_vbr&&!isTransient))
1396                && (tot_boost+boost_bits)>>BITRES>>3 > effectiveBytes/4)
1397          {
1398             offsets[i] = 0;
1399             break;
1400          } else {
1401             offsets[i] = boost;
1402             tot_boost += boost_bits;
1403          }
1404       }
1405    }
1406    dynalloc_logp = 6;
1407    total_bits<<=BITRES;
1408    total_boost = 0;
1409    tell = ec_tell_frac(enc);
1410    for (i=st->start;i<st->end;i++)
1411    {
1412       int width, quanta;
1413       int dynalloc_loop_logp;
1414       int boost;
1415       int j;
1416       width = C*(eBands[i+1]-eBands[i])<<LM;
1417       /* quanta is 6 bits, but no more than 1 bit/sample
1418          and no less than 1/8 bit/sample */
1419       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
1420       dynalloc_loop_logp = dynalloc_logp;
1421       boost = 0;
1422       for (j = 0; tell+(dynalloc_loop_logp<<BITRES) < total_bits-total_boost
1423             && boost < cap[i]; j++)
1424       {
1425          int flag;
1426          flag = j<offsets[i];
1427          ec_enc_bit_logp(enc, flag, dynalloc_loop_logp);
1428          tell = ec_tell_frac(enc);
1429          if (!flag)
1430             break;
1431          boost += quanta;
1432          total_boost += quanta;
1433          dynalloc_loop_logp = 1;
1434       }
1435       /* Making dynalloc more likely */
1436       if (j)
1437          dynalloc_logp = IMAX(2, dynalloc_logp-1);
1438       offsets[i] = boost;
1439    }
1440
1441    if (C==2)
1442    {
1443       int effectiveRate;
1444
1445       static const opus_val16 intensity_thresholds[21]=
1446       /* 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19  20  off*/
1447         { 16,21,23,25,27,29,31,33,35,38,42,46,50,54,58,63,68,75,84,102,130};
1448       static const opus_val16 intensity_histeresis[21]=
1449         {  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 4, 5, 6,  8, 12};
1450
1451       /* Always use MS for 2.5 ms frames until we can do a better analysis */
1452       if (LM!=0)
1453          dual_stereo = stereo_analysis(mode, X, LM, N);
1454
1455       /* Account for coarse energy */
1456       effectiveRate = (8*effectiveBytes - 80)>>LM;
1457
1458       /* effectiveRate in kb/s */
1459       effectiveRate = 2*effectiveRate/5;
1460
1461       st->intensity = hysteresis_decision(effectiveRate, intensity_thresholds, intensity_histeresis, 21, st->intensity);
1462       st->intensity = IMIN(st->end,IMAX(st->start, st->intensity));
1463    }
1464
1465    alloc_trim = 5;
1466    if (tell+(6<<BITRES) <= total_bits - total_boost)
1467    {
1468       alloc_trim = alloc_trim_analysis(mode, X, bandLogE,
1469             st->end, LM, C, N, &st->analysis, &st->stereo_saving, tf_estimate, st->intensity);
1470       ec_enc_icdf(enc, alloc_trim, trim_icdf, 7);
1471       tell = ec_tell_frac(enc);
1472    }
1473
1474    /* Variable bitrate */
1475    if (vbr_rate>0)
1476    {
1477      opus_val16 alpha;
1478      opus_int32 delta;
1479      /* The target rate in 8th bits per frame */
1480      opus_int32 target, base_target;
1481      opus_int32 min_allowed;
1482      int coded_bins;
1483      int coded_bands;
1484      int lm_diff = mode->maxLM - LM;
1485      coded_bands = st->lastCodedBands ? st->lastCodedBands : nbEBands;
1486      coded_bins = eBands[coded_bands]<<LM;
1487      if (C==2)
1488         coded_bins += eBands[IMIN(st->intensity, coded_bands)]<<LM;
1489
1490      /* Don't attempt to use more than 510 kb/s, even for frames smaller than 20 ms.
1491         The CELT allocator will just not be able to use more than that anyway. */
1492      nbCompressedBytes = IMIN(nbCompressedBytes,1275>>(3-LM));
1493      target = vbr_rate - ((40*C+20)<<BITRES);
1494      base_target = target;
1495
1496      if (st->constrained_vbr)
1497         target += (st->vbr_offset>>lm_diff);
1498
1499      /*printf("%f %f %f %f %d %d ", st->analysis.activity, st->analysis.tonality, tf_estimate, st->stereo_saving, tot_boost, coded_bands);*/
1500 #ifndef FIXED_POINT
1501      if (st->analysis.valid && st->analysis.activity<.4)
1502         target -= (coded_bins<<BITRES)*1*(.4-st->analysis.activity);
1503 #endif
1504      /* Stereo savings */
1505      if (C==2)
1506      {
1507         int coded_stereo_bands;
1508         int coded_stereo_dof;
1509         coded_stereo_bands = IMIN(st->intensity, coded_bands);
1510         coded_stereo_dof = (eBands[coded_stereo_bands]<<LM)-coded_stereo_bands;
1511         /*printf("%d %d %d ", coded_stereo_dof, coded_bins, tot_boost);*/
1512         target -= MIN32(target/3, SHR16(MULT16_16(st->stereo_saving,(coded_stereo_dof<<BITRES)),8));
1513         target += MULT16_16_Q15(QCONST16(0.035,15),coded_stereo_dof<<BITRES);
1514      }
1515      /* Limits starving of other bands when using dynalloc */
1516      target += tot_boost;
1517      /* Compensates for the average transient boost */
1518      target = MULT16_32_Q15(QCONST16(0.96f,15),target);
1519      /* Apply transient boost */
1520      target = SHL32(MULT16_32_Q15(tf_estimate, target),1);
1521
1522 #ifndef FIXED_POINT
1523      /* Apply tonality boost */
1524      if (st->analysis.valid) {
1525         int tonal_target;
1526         float tonal;
1527
1528         /* Compensates for the average tonality boost */
1529         target -= MULT16_16_Q15(QCONST16(0.13f,15),coded_bins<<BITRES);
1530
1531         tonal = MAX16(0,st->analysis.tonality-.2);
1532         tonal_target = target + (coded_bins<<BITRES)*2.0f*tonal;
1533         if (pitch_change)
1534            tonal_target +=  (coded_bins<<BITRES)*.8;
1535         /*printf("%f %f ", st->analysis.tonality, tonal);*/
1536         target = IMAX(tonal_target,target);
1537      }
1538 #endif
1539
1540      {
1541         opus_int32 floor_depth;
1542         int bins;
1543         bins = eBands[nbEBands-2]<<LM;
1544         /*floor_depth = SHR32(MULT16_16((C*bins<<BITRES),celt_log2(SHL32(MAX16(1,sample_max),13))), DB_SHIFT);*/
1545         floor_depth = SHR32(MULT16_16((C*bins<<BITRES),maxDepth), DB_SHIFT);
1546         floor_depth = IMAX(floor_depth, target>>2);
1547         target = IMIN(target, floor_depth);
1548         /*printf("%f %d\n", maxDepth, floor_depth);*/
1549      }
1550
1551      if (st->constrained_vbr || st->bitrate<64000)
1552      {
1553         opus_val16 rate_factor;
1554 #ifdef FIXED_POINT
1555         rate_factor = MAX16(0,(st->bitrate-32000));
1556 #else
1557         rate_factor = MAX16(0,(1.f/32768)*(st->bitrate-32000));
1558 #endif
1559         if (st->constrained_vbr)
1560            rate_factor = MIN16(rate_factor, QCONST16(0.67f, 15));
1561         target = base_target + MULT16_32_Q15(rate_factor, target-base_target);
1562
1563      }
1564      /* Don't allow more than doubling the rate */
1565      target = IMIN(2*base_target, target);
1566
1567      /* The current offset is removed from the target and the space used
1568         so far is added*/
1569      target=target+tell;
1570      /* In VBR mode the frame size must not be reduced so much that it would
1571          result in the encoder running out of bits.
1572         The margin of 2 bytes ensures that none of the bust-prevention logic
1573          in the decoder will have triggered so far. */
1574      min_allowed = ((tell+total_boost+(1<<(BITRES+3))-1)>>(BITRES+3)) + 2 - nbFilledBytes;
1575
1576      nbAvailableBytes = (target+(1<<(BITRES+2)))>>(BITRES+3);
1577      nbAvailableBytes = IMAX(min_allowed,nbAvailableBytes);
1578      nbAvailableBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes) - nbFilledBytes;
1579
1580      /* By how much did we "miss" the target on that frame */
1581      delta = target - vbr_rate;
1582
1583      target=nbAvailableBytes<<(BITRES+3);
1584
1585      /*If the frame is silent we don't adjust our drift, otherwise
1586        the encoder will shoot to very high rates after hitting a
1587        span of silence, but we do allow the bitres to refill.
1588        This means that we'll undershoot our target in CVBR/VBR modes
1589        on files with lots of silence. */
1590      if(silence)
1591      {
1592        nbAvailableBytes = 2;
1593        target = 2*8<<BITRES;
1594        delta = 0;
1595      }
1596
1597      if (st->vbr_count < 970)
1598      {
1599         st->vbr_count++;
1600         alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+20),16));
1601      } else
1602         alpha = QCONST16(.001f,15);
1603      /* How many bits have we used in excess of what we're allowed */
1604      if (st->constrained_vbr)
1605         st->vbr_reservoir += target - vbr_rate;
1606      /*printf ("%d\n", st->vbr_reservoir);*/
1607
1608      /* Compute the offset we need to apply in order to reach the target */
1609      if (st->constrained_vbr)
1610      {
1611         st->vbr_drift += (opus_int32)MULT16_32_Q15(alpha,(delta*(1<<lm_diff))-st->vbr_offset-st->vbr_drift);
1612         st->vbr_offset = -st->vbr_drift;
1613      }
1614      /*printf ("%d\n", st->vbr_drift);*/
1615
1616      if (st->constrained_vbr && st->vbr_reservoir < 0)
1617      {
1618         /* We're under the min value -- increase rate */
1619         int adjust = (-st->vbr_reservoir)/(8<<BITRES);
1620         /* Unless we're just coding silence */
1621         nbAvailableBytes += silence?0:adjust;
1622         st->vbr_reservoir = 0;
1623         /*printf ("+%d\n", adjust);*/
1624      }
1625      nbCompressedBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes);
1626      /*printf("%d\n", nbCompressedBytes*50*8);*/
1627      /* This moves the raw bits to take into account the new compressed size */
1628      ec_enc_shrink(enc, nbCompressedBytes);
1629    }
1630
1631    /* Bit allocation */
1632    ALLOC(fine_quant, nbEBands, int);
1633    ALLOC(pulses, nbEBands, int);
1634    ALLOC(fine_priority, nbEBands, int);
1635
1636    /* bits =           packet size                    - where we are - safety*/
1637    bits = (((opus_int32)nbCompressedBytes*8)<<BITRES) - ec_tell_frac(enc) - 1;
1638    anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0;
1639    bits -= anti_collapse_rsv;
1640    codedBands = compute_allocation(mode, st->start, st->end, offsets, cap,
1641          alloc_trim, &st->intensity, &dual_stereo, bits, &balance, pulses,
1642          fine_quant, fine_priority, C, LM, enc, 1, st->lastCodedBands);
1643    st->lastCodedBands = codedBands;
1644
1645    quant_fine_energy(mode, st->start, st->end, oldBandE, error, fine_quant, enc, C);
1646
1647 #ifdef MEASURE_NORM_MSE
1648    float X0[3000];
1649    float bandE0[60];
1650    c=0; do
1651       for (i=0;i<N;i++)
1652          X0[i+c*N] = X[i+c*N];
1653    while (++c<C);
1654    for (i=0;i<C*nbEBands;i++)
1655       bandE0[i] = bandE[i];
1656 #endif
1657
1658    /* Residual quantisation */
1659    ALLOC(collapse_masks, C*nbEBands, unsigned char);
1660    quant_all_bands(1, mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
1661          bandE, pulses, shortBlocks, st->spread_decision, dual_stereo, st->intensity, tf_res,
1662          nbCompressedBytes*(8<<BITRES)-anti_collapse_rsv, balance, enc, LM, codedBands, &st->rng);
1663
1664    if (anti_collapse_rsv > 0)
1665    {
1666       anti_collapse_on = st->consec_transient<2;
1667 #ifdef FUZZING
1668       anti_collapse_on = rand()&0x1;
1669 #endif
1670       ec_enc_bits(enc, anti_collapse_on, 1);
1671    }
1672    quant_energy_finalise(mode, st->start, st->end, oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_tell(enc), enc, C);
1673
1674    if (silence)
1675    {
1676       for (i=0;i<C*nbEBands;i++)
1677          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
1678    }
1679
1680 #ifdef RESYNTH
1681    /* Re-synthesis of the coded audio if required */
1682    {
1683       celt_sig *out_mem[2];
1684
1685       log2Amp(mode, st->start, st->end, bandE, oldBandE, C);
1686       if (silence)
1687       {
1688          for (i=0;i<C*nbEBands;i++)
1689             bandE[i] = 0;
1690       }
1691
1692 #ifdef MEASURE_NORM_MSE
1693       measure_norm_mse(mode, X, X0, bandE, bandE0, M, N, C);
1694 #endif
1695       if (anti_collapse_on)
1696       {
1697          anti_collapse(mode, X, collapse_masks, LM, C, N,
1698                st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
1699       }
1700
1701       /* Synthesis */
1702       denormalise_bands(mode, X, freq, bandE, st->start, effEnd, C, M);
1703
1704       c=0; do {
1705          OPUS_MOVE(st->syn_mem[c], st->syn_mem[c]+N, 2*MAX_PERIOD-N+overlap);
1706       } while (++c<CC);
1707
1708       if (CC==2&&C==1)
1709       {
1710          for (i=0;i<N;i++)
1711             freq[N+i] = freq[i];
1712       }
1713
1714       c=0; do {
1715          out_mem[c] = st->syn_mem[c]+2*MAX_PERIOD-N;
1716       } while (++c<CC);
1717
1718       compute_inv_mdcts(mode, shortBlocks, freq, out_mem, CC, LM);
1719
1720       c=0; do {
1721          st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
1722          st->prefilter_period_old=IMAX(st->prefilter_period_old, COMBFILTER_MINPERIOD);
1723          comb_filter(out_mem[c], out_mem[c], st->prefilter_period_old, st->prefilter_period, mode->shortMdctSize,
1724                st->prefilter_gain_old, st->prefilter_gain, st->prefilter_tapset_old, st->prefilter_tapset,
1725                mode->window, st->overlap);
1726          if (LM!=0)
1727             comb_filter(out_mem[c]+mode->shortMdctSize, out_mem[c]+mode->shortMdctSize, st->prefilter_period, pitch_index, N-mode->shortMdctSize,
1728                   st->prefilter_gain, gain1, st->prefilter_tapset, prefilter_tapset,
1729                   mode->window, overlap);
1730       } while (++c<CC);
1731
1732       /* We reuse freq[] as scratch space for the de-emphasis */
1733       deemphasis(out_mem, (opus_val16*)pcm, N, CC, st->upsample, mode->preemph, st->preemph_memD, freq);
1734       st->prefilter_period_old = st->prefilter_period;
1735       st->prefilter_gain_old = st->prefilter_gain;
1736       st->prefilter_tapset_old = st->prefilter_tapset;
1737    }
1738 #endif
1739
1740    st->prefilter_period = pitch_index;
1741    st->prefilter_gain = gain1;
1742    st->prefilter_tapset = prefilter_tapset;
1743 #ifdef RESYNTH
1744    if (LM!=0)
1745    {
1746       st->prefilter_period_old = st->prefilter_period;
1747       st->prefilter_gain_old = st->prefilter_gain;
1748       st->prefilter_tapset_old = st->prefilter_tapset;
1749    }
1750 #endif
1751
1752    if (CC==2&&C==1) {
1753       for (i=0;i<nbEBands;i++)
1754          oldBandE[nbEBands+i]=oldBandE[i];
1755    }
1756
1757    if (!isTransient)
1758    {
1759       for (i=0;i<CC*nbEBands;i++)
1760          oldLogE2[i] = oldLogE[i];
1761       for (i=0;i<CC*nbEBands;i++)
1762          oldLogE[i] = oldBandE[i];
1763    } else {
1764       for (i=0;i<CC*nbEBands;i++)
1765          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
1766    }
1767    /* In case start or end were to change */
1768    c=0; do
1769    {
1770       for (i=0;i<st->start;i++)
1771       {
1772          oldBandE[c*nbEBands+i]=0;
1773          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
1774       }
1775       for (i=st->end;i<nbEBands;i++)
1776       {
1777          oldBandE[c*nbEBands+i]=0;
1778          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
1779       }
1780    } while (++c<CC);
1781
1782    if (isTransient)
1783       st->consec_transient++;
1784    else
1785       st->consec_transient=0;
1786    st->rng = enc->rng;
1787
1788    /* If there's any room left (can only happen for very high rates),
1789       it's already filled with zeros */
1790    ec_enc_done(enc);
1791
1792 #ifdef CUSTOM_MODES
1793    if (st->signalling)
1794       nbCompressedBytes++;
1795 #endif
1796
1797    RESTORE_STACK;
1798    if (ec_get_error(enc))
1799       return OPUS_INTERNAL_ERROR;
1800    else
1801       return nbCompressedBytes;
1802 }
1803
1804
1805 #ifdef CUSTOM_MODES
1806
1807 #ifdef FIXED_POINT
1808 int opus_custom_encode(CELTEncoder * OPUS_RESTRICT st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1809 {
1810    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1811 }
1812
1813 #ifndef DISABLE_FLOAT_API
1814 int opus_custom_encode_float(CELTEncoder * OPUS_RESTRICT st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1815 {
1816    int j, ret, C, N;
1817    VARDECL(opus_int16, in);
1818    ALLOC_STACK;
1819
1820    if (pcm==NULL)
1821       return OPUS_BAD_ARG;
1822
1823    C = st->channels;
1824    N = frame_size;
1825    ALLOC(in, C*N, opus_int16);
1826
1827    for (j=0;j<C*N;j++)
1828      in[j] = FLOAT2INT16(pcm[j]);
1829
1830    ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
1831 #ifdef RESYNTH
1832    for (j=0;j<C*N;j++)
1833       ((float*)pcm)[j]=in[j]*(1.f/32768.f);
1834 #endif
1835    RESTORE_STACK;
1836    return ret;
1837 }
1838 #endif /* DISABLE_FLOAT_API */
1839 #else
1840
1841 int opus_custom_encode(CELTEncoder * OPUS_RESTRICT st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1842 {
1843    int j, ret, C, N;
1844    VARDECL(celt_sig, in);
1845    ALLOC_STACK;
1846
1847    if (pcm==NULL)
1848       return OPUS_BAD_ARG;
1849
1850    C=st->channels;
1851    N=frame_size;
1852    ALLOC(in, C*N, celt_sig);
1853    for (j=0;j<C*N;j++) {
1854      in[j] = SCALEOUT(pcm[j]);
1855    }
1856
1857    ret = celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
1858 #ifdef RESYNTH
1859    for (j=0;j<C*N;j++)
1860       ((opus_int16*)pcm)[j] = FLOAT2INT16(in[j]);
1861 #endif
1862    RESTORE_STACK;
1863    return ret;
1864 }
1865
1866 int opus_custom_encode_float(CELTEncoder * OPUS_RESTRICT st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1867 {
1868    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1869 }
1870
1871 #endif
1872
1873 #endif /* CUSTOM_MODES */
1874
1875 int opus_custom_encoder_ctl(CELTEncoder * OPUS_RESTRICT st, int request, ...)
1876 {
1877    va_list ap;
1878
1879    va_start(ap, request);
1880    switch (request)
1881    {
1882       case OPUS_SET_COMPLEXITY_REQUEST:
1883       {
1884          int value = va_arg(ap, opus_int32);
1885          if (value<0 || value>10)
1886             goto bad_arg;
1887          st->complexity = value;
1888       }
1889       break;
1890       case CELT_SET_START_BAND_REQUEST:
1891       {
1892          opus_int32 value = va_arg(ap, opus_int32);
1893          if (value<0 || value>=st->mode->nbEBands)
1894             goto bad_arg;
1895          st->start = value;
1896       }
1897       break;
1898       case CELT_SET_END_BAND_REQUEST:
1899       {
1900          opus_int32 value = va_arg(ap, opus_int32);
1901          if (value<1 || value>st->mode->nbEBands)
1902             goto bad_arg;
1903          st->end = value;
1904       }
1905       break;
1906       case CELT_SET_PREDICTION_REQUEST:
1907       {
1908          int value = va_arg(ap, opus_int32);
1909          if (value<0 || value>2)
1910             goto bad_arg;
1911          st->disable_pf = value<=1;
1912          st->force_intra = value==0;
1913       }
1914       break;
1915       case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1916       {
1917          int value = va_arg(ap, opus_int32);
1918          if (value<0 || value>100)
1919             goto bad_arg;
1920          st->loss_rate = value;
1921       }
1922       break;
1923       case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1924       {
1925          opus_int32 value = va_arg(ap, opus_int32);
1926          st->constrained_vbr = value;
1927       }
1928       break;
1929       case OPUS_SET_VBR_REQUEST:
1930       {
1931          opus_int32 value = va_arg(ap, opus_int32);
1932          st->vbr = value;
1933       }
1934       break;
1935       case OPUS_SET_BITRATE_REQUEST:
1936       {
1937          opus_int32 value = va_arg(ap, opus_int32);
1938          if (value<=500 && value!=OPUS_BITRATE_MAX)
1939             goto bad_arg;
1940          value = IMIN(value, 260000*st->channels);
1941          st->bitrate = value;
1942       }
1943       break;
1944       case CELT_SET_CHANNELS_REQUEST:
1945       {
1946          opus_int32 value = va_arg(ap, opus_int32);
1947          if (value<1 || value>2)
1948             goto bad_arg;
1949          st->stream_channels = value;
1950       }
1951       break;
1952       case OPUS_SET_LSB_DEPTH_REQUEST:
1953       {
1954           opus_int32 value = va_arg(ap, opus_int32);
1955           if (value<8 || value>24)
1956              goto bad_arg;
1957           st->lsb_depth=value;
1958       }
1959       break;
1960       case OPUS_GET_LSB_DEPTH_REQUEST:
1961       {
1962           opus_int32 *value = va_arg(ap, opus_int32*);
1963           *value=st->lsb_depth;
1964       }
1965       break;
1966       case OPUS_RESET_STATE:
1967       {
1968          int i;
1969          opus_val16 *oldBandE, *oldLogE, *oldLogE2;
1970          oldBandE = (opus_val16*)(st->in_mem+st->channels*(st->overlap+COMBFILTER_MAXPERIOD));
1971          oldLogE = oldBandE + st->channels*st->mode->nbEBands;
1972          oldLogE2 = oldLogE + st->channels*st->mode->nbEBands;
1973          OPUS_CLEAR((char*)&st->ENCODER_RESET_START,
1974                opus_custom_encoder_get_size(st->mode, st->channels)-
1975                ((char*)&st->ENCODER_RESET_START - (char*)st));
1976          for (i=0;i<st->channels*st->mode->nbEBands;i++)
1977             oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT);
1978          st->vbr_offset = 0;
1979          st->delayedIntra = 1;
1980          st->spread_decision = SPREAD_NORMAL;
1981          st->tonal_average = 256;
1982          st->hf_average = 0;
1983          st->tapset_decision = 0;
1984       }
1985       break;
1986 #ifdef CUSTOM_MODES
1987       case CELT_SET_INPUT_CLIPPING_REQUEST:
1988       {
1989          opus_int32 value = va_arg(ap, opus_int32);
1990          st->clip = value;
1991       }
1992       break;
1993 #endif
1994       case CELT_SET_SIGNALLING_REQUEST:
1995       {
1996          opus_int32 value = va_arg(ap, opus_int32);
1997          st->signalling = value;
1998       }
1999       break;
2000       case CELT_SET_ANALYSIS_REQUEST:
2001       {
2002          AnalysisInfo *info = va_arg(ap, AnalysisInfo *);
2003          if (info)
2004             OPUS_COPY(&st->analysis, info, 1);
2005       }
2006       break;
2007       case CELT_GET_MODE_REQUEST:
2008       {
2009          const CELTMode ** value = va_arg(ap, const CELTMode**);
2010          if (value==0)
2011             goto bad_arg;
2012          *value=st->mode;
2013       }
2014       break;
2015       case OPUS_GET_FINAL_RANGE_REQUEST:
2016       {
2017          opus_uint32 * value = va_arg(ap, opus_uint32 *);
2018          if (value==0)
2019             goto bad_arg;
2020          *value=st->rng;
2021       }
2022       break;
2023       default:
2024          goto bad_request;
2025    }
2026    va_end(ap);
2027    return OPUS_OK;
2028 bad_arg:
2029    va_end(ap);
2030    return OPUS_BAD_ARG;
2031 bad_request:
2032    va_end(ap);
2033    return OPUS_UNIMPLEMENTED;
2034 }