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