comb_filter() bypass for the case where the gain is zero.
[opus.git] / celt / celt.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_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 #ifndef OPUS_VERSION
54 #define OPUS_VERSION "unknown"
55 #endif
56
57 #ifdef CUSTOM_MODES
58 #define OPUS_CUSTOM_NOSTATIC
59 #else
60 #define OPUS_CUSTOM_NOSTATIC static inline
61 #endif
62
63 static const unsigned char trim_icdf[11] = {126, 124, 119, 109, 87, 41, 19, 9, 4, 2, 0};
64 /* Probs: NONE: 21.875%, LIGHT: 6.25%, NORMAL: 65.625%, AGGRESSIVE: 6.25% */
65 static const unsigned char spread_icdf[4] = {25, 23, 2, 0};
66
67 static const unsigned char tapset_icdf[3]={2,1,0};
68
69 #ifdef CUSTOM_MODES
70 static const unsigned char toOpusTable[20] = {
71       0xE0, 0xE8, 0xF0, 0xF8,
72       0xC0, 0xC8, 0xD0, 0xD8,
73       0xA0, 0xA8, 0xB0, 0xB8,
74       0x00, 0x00, 0x00, 0x00,
75       0x80, 0x88, 0x90, 0x98,
76 };
77
78 static const unsigned char fromOpusTable[16] = {
79       0x80, 0x88, 0x90, 0x98,
80       0x40, 0x48, 0x50, 0x58,
81       0x20, 0x28, 0x30, 0x38,
82       0x00, 0x08, 0x10, 0x18
83 };
84
85 static inline int toOpus(unsigned char c)
86 {
87    int ret=0;
88    if (c<0xA0)
89       ret = toOpusTable[c>>3];
90    if (ret == 0)
91       return -1;
92    else
93       return ret|(c&0x7);
94 }
95
96 static inline int fromOpus(unsigned char c)
97 {
98    if (c<0x80)
99       return -1;
100    else
101       return fromOpusTable[(c>>3)-16] | (c&0x7);
102 }
103 #endif /* CUSTOM_MODES */
104
105 #define COMBFILTER_MAXPERIOD 1024
106 #define COMBFILTER_MINPERIOD 15
107
108 static int resampling_factor(opus_int32 rate)
109 {
110    int ret;
111    switch (rate)
112    {
113    case 48000:
114       ret = 1;
115       break;
116    case 24000:
117       ret = 2;
118       break;
119    case 16000:
120       ret = 3;
121       break;
122    case 12000:
123       ret = 4;
124       break;
125    case 8000:
126       ret = 6;
127       break;
128    default:
129 #ifndef CUSTOM_MODES
130       celt_assert(0);
131 #endif
132       ret = 0;
133       break;
134    }
135    return ret;
136 }
137
138 /** Encoder state
139  @brief Encoder state
140  */
141 struct OpusCustomEncoder {
142    const OpusCustomMode *mode;     /**< Mode used by the encoder */
143    int overlap;
144    int channels;
145    int stream_channels;
146
147    int force_intra;
148    int clip;
149    int disable_pf;
150    int complexity;
151    int upsample;
152    int start, end;
153
154    opus_int32 bitrate;
155    int vbr;
156    int signalling;
157    int constrained_vbr;      /* If zero, VBR can do whatever it likes with the rate */
158    int loss_rate;
159    int lsb_depth;
160
161    /* Everything beyond this point gets cleared on a reset */
162 #define ENCODER_RESET_START rng
163
164    opus_uint32 rng;
165    int spread_decision;
166    opus_val32 delayedIntra;
167    int tonal_average;
168    int lastCodedBands;
169    int hf_average;
170    int tapset_decision;
171
172    int prefilter_period;
173    opus_val16 prefilter_gain;
174    int prefilter_tapset;
175 #ifdef RESYNTH
176    int prefilter_period_old;
177    opus_val16 prefilter_gain_old;
178    int prefilter_tapset_old;
179 #endif
180    int consec_transient;
181    AnalysisInfo analysis;
182
183    opus_val32 preemph_memE[2];
184    opus_val32 preemph_memD[2];
185
186    /* VBR-related parameters */
187    opus_int32 vbr_reservoir;
188    opus_int32 vbr_drift;
189    opus_int32 vbr_offset;
190    opus_int32 vbr_count;
191    opus_val16 overlap_max;
192    opus_val16 stereo_saving;
193    int intensity;
194
195 #ifdef RESYNTH
196    celt_sig syn_mem[2][2*MAX_PERIOD];
197 #endif
198
199    celt_sig in_mem[1]; /* Size = channels*mode->overlap */
200    /* celt_sig prefilter_mem[],  Size = channels*COMBFILTER_MAXPERIOD */
201    /* opus_val16 oldBandE[],     Size = channels*mode->nbEBands */
202    /* opus_val16 oldLogE[],      Size = channels*mode->nbEBands */
203    /* opus_val16 oldLogE2[],     Size = channels*mode->nbEBands */
204 #ifdef RESYNTH
205    /* opus_val16 overlap_mem[],  Size = channels*overlap */
206 #endif
207 };
208
209 int celt_encoder_get_size(int channels)
210 {
211    CELTMode *mode = opus_custom_mode_create(48000, 960, NULL);
212    return opus_custom_encoder_get_size(mode, channels);
213 }
214
215 OPUS_CUSTOM_NOSTATIC int opus_custom_encoder_get_size(const CELTMode *mode, int channels)
216 {
217    int size = sizeof(struct CELTEncoder)
218          + (channels*mode->overlap-1)*sizeof(celt_sig)    /* celt_sig in_mem[channels*mode->overlap]; */
219          + channels*COMBFILTER_MAXPERIOD*sizeof(celt_sig) /* celt_sig prefilter_mem[channels*COMBFILTER_MAXPERIOD]; */
220          + 3*channels*mode->nbEBands*sizeof(opus_val16);  /* opus_val16 oldBandE[channels*mode->nbEBands]; */
221                                                           /* opus_val16 oldLogE[channels*mode->nbEBands]; */
222                                                           /* opus_val16 oldLogE2[channels*mode->nbEBands]; */
223 #ifdef RESYNTH
224    size += channels*mode->overlap*sizeof(celt_sig);       /* celt_sig overlap_mem[channels*mode->nbEBands]; */
225 #endif
226    return size;
227 }
228
229 #ifdef CUSTOM_MODES
230 CELTEncoder *opus_custom_encoder_create(const CELTMode *mode, int channels, int *error)
231 {
232    int ret;
233    CELTEncoder *st = (CELTEncoder *)opus_alloc(opus_custom_encoder_get_size(mode, channels));
234    /* init will handle the NULL case */
235    ret = opus_custom_encoder_init(st, mode, channels);
236    if (ret != OPUS_OK)
237    {
238       opus_custom_encoder_destroy(st);
239       st = NULL;
240    }
241    if (error)
242       *error = ret;
243    return st;
244 }
245 #endif /* CUSTOM_MODES */
246
247 int celt_encoder_init(CELTEncoder *st, opus_int32 sampling_rate, int channels)
248 {
249    int ret;
250    ret = opus_custom_encoder_init(st, opus_custom_mode_create(48000, 960, NULL), channels);
251    if (ret != OPUS_OK)
252       return ret;
253    st->upsample = resampling_factor(sampling_rate);
254    return OPUS_OK;
255 }
256
257 OPUS_CUSTOM_NOSTATIC int opus_custom_encoder_init(CELTEncoder *st, const CELTMode *mode, int channels)
258 {
259    if (channels < 0 || channels > 2)
260       return OPUS_BAD_ARG;
261
262    if (st==NULL || mode==NULL)
263       return OPUS_ALLOC_FAIL;
264
265    OPUS_CLEAR((char*)st, opus_custom_encoder_get_size(mode, channels));
266
267    st->mode = mode;
268    st->overlap = mode->overlap;
269    st->stream_channels = st->channels = channels;
270
271    st->upsample = 1;
272    st->start = 0;
273    st->end = st->mode->effEBands;
274    st->signalling = 1;
275
276    st->constrained_vbr = 1;
277    st->clip = 1;
278
279    st->bitrate = OPUS_BITRATE_MAX;
280    st->vbr = 0;
281    st->force_intra  = 0;
282    st->complexity = 5;
283    st->lsb_depth=24;
284
285    opus_custom_encoder_ctl(st, OPUS_RESET_STATE);
286
287    return OPUS_OK;
288 }
289
290 #ifdef CUSTOM_MODES
291 void opus_custom_encoder_destroy(CELTEncoder *st)
292 {
293    opus_free(st);
294 }
295 #endif /* CUSTOM_MODES */
296
297 static inline opus_val16 SIG2WORD16(celt_sig x)
298 {
299 #ifdef FIXED_POINT
300    x = PSHR32(x, SIG_SHIFT);
301    x = MAX32(x, -32768);
302    x = MIN32(x, 32767);
303    return EXTRACT16(x);
304 #else
305    return (opus_val16)x;
306 #endif
307 }
308
309 static int transient_analysis(const opus_val32 * OPUS_RESTRICT in, int len, int C,
310                               opus_val16 *tf_estimate, int *tf_chan)
311 {
312    int i;
313    VARDECL(opus_val16, tmp);
314    opus_val32 mem0,mem1;
315    int is_transient = 0;
316    opus_int32 mask_metric = 0;
317    int c;
318    int tf_max;
319    /* Table of 6*64/x, trained on real data to minimize the average error */
320    static const unsigned char inv_table[128] = {
321          255,255,156,110, 86, 70, 59, 51, 45, 40, 37, 33, 31, 28, 26, 25,
322           23, 22, 21, 20, 19, 18, 17, 16, 16, 15, 15, 14, 13, 13, 12, 12,
323           12, 12, 11, 11, 11, 10, 10, 10,  9,  9,  9,  9,  9,  9,  8,  8,
324            8,  8,  8,  7,  7,  7,  7,  7,  7,  6,  6,  6,  6,  6,  6,  6,
325            6,  6,  6,  6,  6,  6,  6,  6,  6,  5,  5,  5,  5,  5,  5,  5,
326            5,  5,  5,  5,  5,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
327            4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  3,  3,
328            3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  2,
329    };
330    SAVE_STACK;
331    ALLOC(tmp, len, opus_val16);
332
333    tf_max = 0;
334    for (c=0;c<C;c++)
335    {
336       opus_val32 mean;
337       opus_int32 unmask=0;
338       opus_val32 norm;
339       mem0=0;
340       mem1=0;
341       /* High-pass filter: (1 - 2*z^-1 + z^-2) / (1 - z^-1 + .5*z^-2) */
342       for (i=0;i<len;i++)
343       {
344          opus_val32 x,y;
345          x = SHR32(in[i+c*len],SIG_SHIFT);
346          y = ADD32(mem0, x);
347 #ifdef FIXED_POINT
348          mem0 = mem1 + y - SHL32(x,1);
349          mem1 = x - SHR32(y,1);
350 #else
351          mem0 = mem1 + y - 2*x;
352          mem1 = x - .5f*y;
353 #endif
354          tmp[i] = EXTRACT16(SHR32(y,2));
355          /*printf("%f ", tmp[i]);*/
356       }
357       /*printf("\n");*/
358       /* First few samples are bad because we don't propagate the memory */
359       for (i=0;i<12;i++)
360          tmp[i] = 0;
361
362 #ifdef FIXED_POINT
363       /* Normalize tmp to max range */
364       {
365          int shift=0;
366          shift = 14-celt_ilog2(1+celt_maxabs16(tmp, len));
367          if (shift!=0)
368          {
369             for (i=0;i<len;i++)
370                tmp[i] = SHL16(tmp[i], shift);
371          }
372       }
373 #endif
374
375       mean=0;
376       mem0=0;
377       /*  Grouping by two to reduce complexity */
378       len/=2;
379       /* Forward pass to compute the post-echo threshold*/
380       for (i=0;i<len;i++)
381       {
382          opus_val16 x2 = PSHR32(MULT16_16(tmp[2*i],tmp[2*i]) + MULT16_16(tmp[2*i+1],tmp[2*i+1]),16);
383          mean += x2;
384 #ifdef FIXED_POINT
385          /* FIXME: Use PSHR16() instead */
386          tmp[i] = mem0 + PSHR32(x2-mem0,4);
387 #else
388          tmp[i] = mem0 + MULT16_16_P15(QCONST16(.0625f,15),x2-mem0);
389 #endif
390          mem0 = tmp[i];
391       }
392
393       mem0=0;
394       /* Backward pass to compute the pre-echo threshold */
395       for (i=len-1;i>=0;i--)
396       {
397 #ifdef FIXED_POINT
398          /* FIXME: Use PSHR16() instead */
399          tmp[i] = mem0 + PSHR32(tmp[i]-mem0,3);
400 #else
401          tmp[i] = mem0 + MULT16_16_P15(QCONST16(0.125f,15),tmp[i]-mem0);
402 #endif
403          mem0 = tmp[i];
404       }
405       /*for (i=0;i<len;i++)printf("%f ", tmp[i]/mean);printf("\n");*/
406
407       /* Compute the ratio of the mean energy over the harmonic mean of the energy.
408          This essentially corresponds to a bitrate-normalized temporal noise-to-mask
409          ratio */
410
411       /* Inverse of the mean energy in Q15+6 */
412       norm = SHL32(EXTEND32(len),6+14)/ADD32(EPSILON,SHR32(mean,1));
413       /* Compute harmonic mean discarding the unreliable boundaries
414          The data is smooth, so we only take 1/4th of the samples */
415       unmask=0;
416       for (i=12;i<len-5;i+=4)
417       {
418          int id;
419 #ifdef FIXED_POINT
420          id = IMAX(0,IMIN(127,MULT16_32_Q15(tmp[i],norm))); /* Do not round to nearest */
421 #else
422          id = IMAX(0,IMIN(127,floor(64*norm*tmp[i]))); /* Do not round to nearest */
423 #endif
424          unmask += inv_table[id];
425       }
426       /*printf("%d\n", unmask);*/
427       /* Normalize, compensate for the 1/4th of the sample and the factor of 6 in the inverse table */
428       unmask = 64*unmask*4/(6*(len-17));
429       if (unmask>mask_metric)
430       {
431          *tf_chan = c;
432          mask_metric = unmask;
433       }
434    }
435    is_transient = mask_metric>141;
436
437    /* Arbitrary metric for VBR boost */
438    tf_max = MAX16(0,celt_sqrt(64*mask_metric)-64);
439    /* *tf_estimate = 1 + MIN16(1, sqrt(MAX16(0, tf_max-30))/20); */
440    *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)));
441    /*printf("%d %f\n", tf_max, mask_metric);*/
442    RESTORE_STACK;
443 #ifdef FUZZING
444    is_transient = rand()&0x1;
445 #endif
446    /*printf("%d %f %d\n", is_transient, (float)*tf_estimate, tf_max);*/
447    return is_transient;
448 }
449
450 /** Apply window and compute the MDCT for all sub-frames and
451     all channels in a frame */
452 static void compute_mdcts(const CELTMode *mode, int shortBlocks, celt_sig * OPUS_RESTRICT in, celt_sig * OPUS_RESTRICT out, int C, int LM)
453 {
454    if (C==1 && !shortBlocks)
455    {
456       const int overlap = OVERLAP(mode);
457       clt_mdct_forward(&mode->mdct, in, out, mode->window, overlap, mode->maxLM-LM, 1);
458    } else {
459       const int overlap = OVERLAP(mode);
460       int N = mode->shortMdctSize<<LM;
461       int B = 1;
462       int b, c;
463       if (shortBlocks)
464       {
465          N = mode->shortMdctSize;
466          B = shortBlocks;
467       }
468       c=0; do {
469          for (b=0;b<B;b++)
470          {
471             /* Interleaving the sub-frames while doing the MDCTs */
472             clt_mdct_forward(&mode->mdct, in+c*(B*N+overlap)+b*N, &out[b+c*N*B], mode->window, overlap, shortBlocks ? mode->maxLM : mode->maxLM-LM, B);
473          }
474       } while (++c<C);
475    }
476 }
477
478 /** Compute the IMDCT and apply window for all sub-frames and
479     all channels in a frame */
480 static void compute_inv_mdcts(const CELTMode *mode, int shortBlocks, celt_sig *X,
481       celt_sig * OPUS_RESTRICT out_mem[],
482       celt_sig * OPUS_RESTRICT overlap_mem[], int C, int LM)
483 {
484    int c;
485    const int N = mode->shortMdctSize<<LM;
486    const int overlap = OVERLAP(mode);
487    VARDECL(opus_val32, x);
488    SAVE_STACK;
489
490    ALLOC(x, N+overlap, opus_val32);
491    c=0; do {
492       int j;
493       int b;
494       int N2 = N;
495       int B = 1;
496
497       if (shortBlocks)
498       {
499          N2 = mode->shortMdctSize;
500          B = shortBlocks;
501       }
502       /* Prevents problems from the imdct doing the overlap-add */
503       OPUS_CLEAR(x, overlap);
504
505       for (b=0;b<B;b++)
506       {
507          /* IMDCT on the interleaved the sub-frames */
508          clt_mdct_backward(&mode->mdct, &X[b+c*N2*B], x+N2*b, mode->window, overlap, shortBlocks ? mode->maxLM : mode->maxLM-LM, B);
509       }
510
511       for (j=0;j<overlap;j++)
512          out_mem[c][j] = x[j] + overlap_mem[c][j];
513       for (;j<N;j++)
514          out_mem[c][j] = x[j];
515       for (j=0;j<overlap;j++)
516          overlap_mem[c][j] = x[N+j];
517    } while (++c<C);
518    RESTORE_STACK;
519 }
520
521 static void preemphasis(const opus_val16 * OPUS_RESTRICT pcmp, celt_sig * OPUS_RESTRICT inp,
522                         int N, int CC, int upsample, const opus_val16 *coef, celt_sig *mem, int clip)
523 {
524    int i;
525    opus_val16 coef0, coef1;
526    celt_sig m;
527    int Nu;
528
529    coef0 = coef[0];
530    coef1 = coef[1];
531
532
533    Nu = N/upsample;
534    if (upsample!=1)
535    {
536       for (i=0;i<N;i++)
537          inp[i] = 0;
538    }
539    for (i=0;i<Nu;i++)
540    {
541       celt_sig x;
542
543       x = SCALEIN(pcmp[CC*i]);
544 #ifndef FIXED_POINT
545       /* Replace NaNs with zeros */
546       if (!(x==x))
547          x = 0;
548 #endif
549       inp[i*upsample] = x;
550    }
551
552 #ifndef FIXED_POINT
553    if (clip)
554    {
555       /* Clip input to avoid encoding non-portable files */
556       for (i=0;i<Nu;i++)
557          inp[i*upsample] = MAX32(-65536.f, MIN32(65536.f,inp[i*upsample]));
558    }
559 #endif
560    m = *mem;
561    if (coef1 == 0)
562    {
563       for (i=0;i<N;i++)
564       {
565          celt_sig x;
566          x = SHL32(inp[i], SIG_SHIFT);
567          /* Apply pre-emphasis */
568          inp[i] = x + m;
569          m = - MULT16_32_Q15(coef0, x);
570       }
571    } else {
572       opus_val16 coef2 = coef[2];
573       for (i=0;i<N;i++)
574       {
575          opus_val16 x, tmp;
576          x = inp[i];
577          /* Apply pre-emphasis */
578          tmp = MULT16_16(coef2, x);
579          inp[i] = tmp + m;
580          m = MULT16_32_Q15(coef1, inp[i]) - MULT16_32_Q15(coef0, tmp);
581       }
582    }
583    *mem = m;
584 }
585
586 static void deemphasis(celt_sig *in[], opus_val16 *pcm, int N, int C, int downsample, const opus_val16 *coef, celt_sig *mem, celt_sig * OPUS_RESTRICT scratch)
587 {
588    int c;
589    int Nd;
590    opus_val16 coef0, coef1;
591
592    coef0 = coef[0];
593    coef1 = coef[1];
594    Nd = N/downsample;
595    c=0; do {
596       int j;
597       celt_sig * OPUS_RESTRICT x;
598       opus_val16  * OPUS_RESTRICT y;
599       celt_sig m = mem[c];
600       x =in[c];
601       y = pcm+c;
602       /* Shortcut for the standard (non-custom modes) case */
603       if (coef1 == 0)
604       {
605          for (j=0;j<N;j++)
606          {
607             celt_sig tmp = x[j] + m;
608             m = MULT16_32_Q15(coef0, tmp);
609             scratch[j] = tmp;
610          }
611       } else {
612          opus_val16 coef3 = coef[3];
613          for (j=0;j<N;j++)
614          {
615             celt_sig tmp = x[j] + m;
616             m = MULT16_32_Q15(coef0, tmp)
617               - MULT16_32_Q15(coef1, x[j]);
618             tmp = SHL32(MULT16_32_Q15(coef3, tmp), 2);
619             scratch[j] = tmp;
620          }
621       }
622       mem[c] = m;
623
624       /* Perform down-sampling */
625       for (j=0;j<Nd;j++)
626          y[j*C] = SCALEOUT(SIG2WORD16(scratch[j*downsample]));
627    } while (++c<C);
628 }
629
630 static void comb_filter(opus_val32 *y, opus_val32 *x, int T0, int T1, int N,
631       opus_val16 g0, opus_val16 g1, int tapset0, int tapset1,
632       const opus_val16 *window, int overlap)
633 {
634    int i;
635    /* printf ("%d %d %f %f\n", T0, T1, g0, g1); */
636    opus_val16 g00, g01, g02, g10, g11, g12;
637    opus_val32 x0, x1, x2, x3, x4;
638    static const opus_val16 gains[3][3] = {
639          {QCONST16(0.3066406250f, 15), QCONST16(0.2170410156f, 15), QCONST16(0.1296386719f, 15)},
640          {QCONST16(0.4638671875f, 15), QCONST16(0.2680664062f, 15), QCONST16(0.f, 15)},
641          {QCONST16(0.7998046875f, 15), QCONST16(0.1000976562f, 15), QCONST16(0.f, 15)}};
642
643    if (g0==0 && g1==0)
644    {
645       /* OPT: Happens to work without the OPUS_MOVE(), but only because the current encoder already copies x to y */
646       if (x!=y)
647          OPUS_MOVE(y, x, N);
648       return;
649    }
650    g00 = MULT16_16_Q15(g0, gains[tapset0][0]);
651    g01 = MULT16_16_Q15(g0, gains[tapset0][1]);
652    g02 = MULT16_16_Q15(g0, gains[tapset0][2]);
653    g10 = MULT16_16_Q15(g1, gains[tapset1][0]);
654    g11 = MULT16_16_Q15(g1, gains[tapset1][1]);
655    g12 = MULT16_16_Q15(g1, gains[tapset1][2]);
656    x1 = x[-T1+1];
657    x2 = x[-T1  ];
658    x3 = x[-T1-1];
659    x4 = x[-T1-2];
660    for (i=0;i<overlap;i++)
661    {
662       opus_val16 f;
663       x0=x[i-T1+2];
664       f = MULT16_16_Q15(window[i],window[i]);
665       y[i] = x[i]
666                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g00),x[i-T0])
667                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g01),ADD32(x[i-T0+1],x[i-T0-1]))
668                + MULT16_32_Q15(MULT16_16_Q15((Q15ONE-f),g02),ADD32(x[i-T0+2],x[i-T0-2]))
669                + MULT16_32_Q15(MULT16_16_Q15(f,g10),x2)
670                + MULT16_32_Q15(MULT16_16_Q15(f,g11),ADD32(x1,x3))
671                + MULT16_32_Q15(MULT16_16_Q15(f,g12),ADD32(x0,x4));
672       x4=x3;
673       x3=x2;
674       x2=x1;
675       x1=x0;
676
677    }
678    if (g1==0)
679    {
680       /* OPT: Happens to work without the OPUS_MOVE(), but only because the current encoder already copies x to y */
681       if (x!=y)
682          OPUS_MOVE(y+overlap, x+overlap, N-overlap);
683       return;
684    }
685    /* OPT: For machines where the movs are costly, unroll by 5 */
686    for (;i<N;i++)
687    {
688       x0=x[i-T1+2];
689       y[i] = x[i]
690                + MULT16_32_Q15(g10,x2)
691                + MULT16_32_Q15(g11,ADD32(x1,x3))
692                + MULT16_32_Q15(g12,ADD32(x0,x4));
693       x4=x3;
694       x3=x2;
695       x2=x1;
696       x1=x0;
697    }
698 }
699
700 static const signed char tf_select_table[4][8] = {
701       {0, -1, 0, -1,    0,-1, 0,-1},
702       {0, -1, 0, -2,    1, 0, 1,-1},
703       {0, -2, 0, -3,    2, 0, 1,-1},
704       {0, -2, 0, -3,    3, 0, 1,-1},
705 };
706
707 static opus_val32 l1_metric(const celt_norm *tmp, int N, int LM, opus_val16 bias)
708 {
709    int i;
710    opus_val32 L1;
711    L1 = 0;
712    for (i=0;i<N;i++)
713       L1 += EXTEND32(ABS16(tmp[i]));
714    /* When in doubt, prefer good freq resolution */
715    L1 = MAC16_32_Q15(L1, LM*bias, L1);
716    return L1;
717
718 }
719
720 static int tf_analysis(const CELTMode *m, int len, int C, int isTransient,
721       int *tf_res, int nbCompressedBytes, celt_norm *X, int N0, int LM,
722       int *tf_sum, opus_val16 tf_estimate, int tf_chan)
723 {
724    int i;
725    VARDECL(int, metric);
726    int cost0;
727    int cost1;
728    VARDECL(int, path0);
729    VARDECL(int, path1);
730    VARDECL(celt_norm, tmp);
731    VARDECL(celt_norm, tmp_1);
732    int lambda;
733    int sel;
734    int selcost[2];
735    int tf_select=0;
736    opus_val16 bias;
737
738    SAVE_STACK;
739    bias = MULT16_16_Q14(QCONST16(.04f,15), MAX16(-QCONST16(.25f,14), QCONST16(1.5f,14)-tf_estimate));
740    /*printf("%f ", bias);*/
741
742    if (nbCompressedBytes<15*C)
743    {
744       *tf_sum = 0;
745       for (i=0;i<len;i++)
746          tf_res[i] = isTransient;
747       return 0;
748    }
749    if (nbCompressedBytes<40)
750       lambda = 12;
751    else if (nbCompressedBytes<60)
752       lambda = 6;
753    else if (nbCompressedBytes<100)
754       lambda = 4;
755    else
756       lambda = 3;
757    lambda*=2;
758    ALLOC(metric, len, int);
759    ALLOC(tmp, (m->eBands[len]-m->eBands[len-1])<<LM, celt_norm);
760    ALLOC(tmp_1, (m->eBands[len]-m->eBands[len-1])<<LM, celt_norm);
761    ALLOC(path0, len, int);
762    ALLOC(path1, len, int);
763
764    *tf_sum = 0;
765    for (i=0;i<len;i++)
766    {
767       int j, k, N;
768       int narrow;
769       opus_val32 L1, best_L1;
770       int best_level=0;
771       N = (m->eBands[i+1]-m->eBands[i])<<LM;
772       /* band is too narrow to be split down to LM=-1 */
773       narrow = (m->eBands[i+1]-m->eBands[i])==1;
774       for (j=0;j<N;j++)
775          tmp[j] = X[tf_chan*N0 + j+(m->eBands[i]<<LM)];
776       /* Just add the right channel if we're in stereo */
777       /*if (C==2)
778          for (j=0;j<N;j++)
779             tmp[j] = ADD16(SHR16(tmp[j], 1),SHR16(X[N0+j+(m->eBands[i]<<LM)], 1));*/
780       L1 = l1_metric(tmp, N, isTransient ? LM : 0, bias);
781       best_L1 = L1;
782       /* Check the -1 case for transients */
783       if (isTransient && !narrow)
784       {
785          for (j=0;j<N;j++)
786             tmp_1[j] = tmp[j];
787          haar1(tmp_1, N>>LM, 1<<LM);
788          L1 = l1_metric(tmp_1, N, LM+1, bias);
789          if (L1<best_L1)
790          {
791             best_L1 = L1;
792             best_level = -1;
793          }
794       }
795       /*printf ("%f ", L1);*/
796       for (k=0;k<LM+!(isTransient||narrow);k++)
797       {
798          int B;
799
800          if (isTransient)
801             B = (LM-k-1);
802          else
803             B = k+1;
804
805          haar1(tmp, N>>k, 1<<k);
806
807          L1 = l1_metric(tmp, N, B, bias);
808
809          if (L1 < best_L1)
810          {
811             best_L1 = L1;
812             best_level = k+1;
813          }
814       }
815       /*printf ("%d ", isTransient ? LM-best_level : best_level);*/
816       /* metric is in Q1 to be able to select the mid-point (-0.5) for narrower bands */
817       if (isTransient)
818          metric[i] = 2*best_level;
819       else
820          metric[i] = -2*best_level;
821       *tf_sum += (isTransient ? LM : 0) - metric[i]/2;
822       /* For bands that can't be split to -1, set the metric to the half-way point to avoid
823          biasing the decision */
824       if (narrow && (metric[i]==0 || metric[i]==-2*LM))
825          metric[i]-=1;
826       /*printf("%d ", metric[i]);*/
827    }
828    /*printf("\n");*/
829    /* Search for the optimal tf resolution, including tf_select */
830    tf_select = 0;
831    for (sel=0;sel<2;sel++)
832    {
833       cost0 = 0;
834       cost1 = isTransient ? 0 : lambda;
835       for (i=1;i<len;i++)
836       {
837          int curr0, curr1;
838          curr0 = IMIN(cost0, cost1 + lambda);
839          curr1 = IMIN(cost0 + lambda, cost1);
840          cost0 = curr0 + abs(metric[i]-2*tf_select_table[LM][4*isTransient+2*sel+0]);
841          cost1 = curr1 + abs(metric[i]-2*tf_select_table[LM][4*isTransient+2*sel+1]);
842       }
843       cost0 = IMIN(cost0, cost1);
844       selcost[sel]=cost0;
845    }
846    /* For now, we're conservative and only allow tf_select=1 for transients.
847     * If tests confirm it's useful for non-transients, we could allow it. */
848    if (selcost[1]<selcost[0] && isTransient)
849       tf_select=1;
850    cost0 = 0;
851    cost1 = isTransient ? 0 : lambda;
852    /* Viterbi forward pass */
853    for (i=1;i<len;i++)
854    {
855       int curr0, curr1;
856       int from0, from1;
857
858       from0 = cost0;
859       from1 = cost1 + lambda;
860       if (from0 < from1)
861       {
862          curr0 = from0;
863          path0[i]= 0;
864       } else {
865          curr0 = from1;
866          path0[i]= 1;
867       }
868
869       from0 = cost0 + lambda;
870       from1 = cost1;
871       if (from0 < from1)
872       {
873          curr1 = from0;
874          path1[i]= 0;
875       } else {
876          curr1 = from1;
877          path1[i]= 1;
878       }
879       cost0 = curr0 + abs(metric[i]-2*tf_select_table[LM][4*isTransient+2*tf_select+0]);
880       cost1 = curr1 + abs(metric[i]-2*tf_select_table[LM][4*isTransient+2*tf_select+1]);
881    }
882    tf_res[len-1] = cost0 < cost1 ? 0 : 1;
883    /* Viterbi backward pass to check the decisions */
884    for (i=len-2;i>=0;i--)
885    {
886       if (tf_res[i+1] == 1)
887          tf_res[i] = path1[i+1];
888       else
889          tf_res[i] = path0[i+1];
890    }
891    /*printf("%d %f\n", *tf_sum, tf_estimate);*/
892    RESTORE_STACK;
893 #ifdef FUZZING
894    tf_select = rand()&0x1;
895    tf_res[0] = rand()&0x1;
896    for (i=1;i<len;i++)
897       tf_res[i] = tf_res[i-1] ^ ((rand()&0xF) == 0);
898 #endif
899    return tf_select;
900 }
901
902 static void tf_encode(int start, int end, int isTransient, int *tf_res, int LM, int tf_select, ec_enc *enc)
903 {
904    int curr, i;
905    int tf_select_rsv;
906    int tf_changed;
907    int logp;
908    opus_uint32 budget;
909    opus_uint32 tell;
910    budget = enc->storage*8;
911    tell = ec_tell(enc);
912    logp = isTransient ? 2 : 4;
913    /* Reserve space to code the tf_select decision. */
914    tf_select_rsv = LM>0 && tell+logp+1 <= budget;
915    budget -= tf_select_rsv;
916    curr = tf_changed = 0;
917    for (i=start;i<end;i++)
918    {
919       if (tell+logp<=budget)
920       {
921          ec_enc_bit_logp(enc, tf_res[i] ^ curr, logp);
922          tell = ec_tell(enc);
923          curr = tf_res[i];
924          tf_changed |= curr;
925       }
926       else
927          tf_res[i] = curr;
928       logp = isTransient ? 4 : 5;
929    }
930    /* Only code tf_select if it would actually make a difference. */
931    if (tf_select_rsv &&
932          tf_select_table[LM][4*isTransient+0+tf_changed]!=
933          tf_select_table[LM][4*isTransient+2+tf_changed])
934       ec_enc_bit_logp(enc, tf_select, 1);
935    else
936       tf_select = 0;
937    for (i=start;i<end;i++)
938       tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]];
939    /*for(i=0;i<end;i++)printf("%d ", isTransient ? tf_res[i] : LM+tf_res[i]);printf("\n");*/
940 }
941
942 static void tf_decode(int start, int end, int isTransient, int *tf_res, int LM, ec_dec *dec)
943 {
944    int i, curr, tf_select;
945    int tf_select_rsv;
946    int tf_changed;
947    int logp;
948    opus_uint32 budget;
949    opus_uint32 tell;
950
951    budget = dec->storage*8;
952    tell = ec_tell(dec);
953    logp = isTransient ? 2 : 4;
954    tf_select_rsv = LM>0 && tell+logp+1<=budget;
955    budget -= tf_select_rsv;
956    tf_changed = curr = 0;
957    for (i=start;i<end;i++)
958    {
959       if (tell+logp<=budget)
960       {
961          curr ^= ec_dec_bit_logp(dec, logp);
962          tell = ec_tell(dec);
963          tf_changed |= curr;
964       }
965       tf_res[i] = curr;
966       logp = isTransient ? 4 : 5;
967    }
968    tf_select = 0;
969    if (tf_select_rsv &&
970      tf_select_table[LM][4*isTransient+0+tf_changed] !=
971      tf_select_table[LM][4*isTransient+2+tf_changed])
972    {
973       tf_select = ec_dec_bit_logp(dec, 1);
974    }
975    for (i=start;i<end;i++)
976    {
977       tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]];
978    }
979 }
980
981 static void init_caps(const CELTMode *m,int *cap,int LM,int C)
982 {
983    int i;
984    for (i=0;i<m->nbEBands;i++)
985    {
986       int N;
987       N=(m->eBands[i+1]-m->eBands[i])<<LM;
988       cap[i] = (m->cache.caps[m->nbEBands*(2*LM+C-1)+i]+64)*C*N>>2;
989    }
990 }
991
992 static int alloc_trim_analysis(const CELTMode *m, const celt_norm *X,
993       const opus_val16 *bandLogE, int end, int LM, int C, int N0,
994       AnalysisInfo *analysis, opus_val16 *stereo_saving, opus_val16 tf_estimate,
995       int intensity)
996 {
997    int i;
998    opus_val32 diff=0;
999    int c;
1000    int trim_index = 5;
1001    opus_val16 trim = QCONST16(5.f, 8);
1002    opus_val16 logXC, logXC2;
1003    if (C==2)
1004    {
1005       opus_val16 sum = 0; /* Q10 */
1006       opus_val16 minXC; /* Q10 */
1007       /* Compute inter-channel correlation for low frequencies */
1008       for (i=0;i<8;i++)
1009       {
1010          int j;
1011          opus_val32 partial = 0;
1012          for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++)
1013             partial = MAC16_16(partial, X[j], X[N0+j]);
1014          sum = ADD16(sum, EXTRACT16(SHR32(partial, 18)));
1015       }
1016       sum = MULT16_16_Q15(QCONST16(1.f/8, 15), sum);
1017       sum = MIN16(QCONST16(1.f, 10), ABS16(sum));
1018       minXC = sum;
1019       for (i=8;i<intensity;i++)
1020       {
1021          int j;
1022          opus_val32 partial = 0;
1023          for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++)
1024             partial = MAC16_16(partial, X[j], X[N0+j]);
1025          minXC = MIN16(minXC, ABS16(EXTRACT16(SHR32(partial, 18))));
1026       }
1027       minXC = MIN16(QCONST16(1.f, 10), ABS16(minXC));
1028       /*printf ("%f\n", sum);*/
1029       if (sum > QCONST16(.995f,10))
1030          trim_index-=4;
1031       else if (sum > QCONST16(.92f,10))
1032          trim_index-=3;
1033       else if (sum > QCONST16(.85f,10))
1034          trim_index-=2;
1035       else if (sum > QCONST16(.8f,10))
1036          trim_index-=1;
1037       /* mid-side savings estimations based on the LF average*/
1038       logXC = celt_log2(QCONST32(1.001f, 20)-MULT16_16(sum, sum));
1039       /* mid-side savings estimations based on min correlation */
1040       logXC2 = MAX16(HALF16(logXC), celt_log2(QCONST32(1.001f, 20)-MULT16_16(minXC, minXC)));
1041 #ifdef FIXED_POINT
1042       /* Compensate for Q20 vs Q14 input and convert output to Q8 */
1043       logXC = PSHR32(logXC-QCONST16(6.f, DB_SHIFT),DB_SHIFT-8);
1044       logXC2 = PSHR32(logXC2-QCONST16(6.f, DB_SHIFT),DB_SHIFT-8);
1045 #endif
1046
1047       trim += MAX16(-QCONST16(4.f, 8), MULT16_16_Q15(QCONST16(.75f,15),logXC));
1048       *stereo_saving = MIN16(*stereo_saving + QCONST16(0.25f, 8), -HALF16(logXC2));
1049    }
1050
1051    /* Estimate spectral tilt */
1052    c=0; do {
1053       for (i=0;i<end-1;i++)
1054       {
1055          diff += bandLogE[i+c*m->nbEBands]*(opus_int32)(2+2*i-end);
1056       }
1057    } while (++c<C);
1058    diff /= C*(end-1);
1059    /*printf("%f\n", diff);*/
1060    if (diff > QCONST16(2.f, DB_SHIFT))
1061       trim_index--;
1062    if (diff > QCONST16(8.f, DB_SHIFT))
1063       trim_index--;
1064    if (diff < -QCONST16(4.f, DB_SHIFT))
1065       trim_index++;
1066    if (diff < -QCONST16(10.f, DB_SHIFT))
1067       trim_index++;
1068    trim -= MAX16(-QCONST16(2.f, 8), MIN16(QCONST16(2.f, 8), SHR16(diff+QCONST16(1.f, DB_SHIFT),DB_SHIFT-8)/6 ));
1069    trim -= 2*SHR16(tf_estimate-QCONST16(1.f,14), 14-8);
1070 #ifndef FIXED_POINT
1071    if (analysis->valid)
1072    {
1073       trim -= MAX16(-QCONST16(2.f, 8), MIN16(QCONST16(2.f, 8), 2*(analysis->tonality_slope+.05)));
1074    }
1075 #endif
1076
1077 #ifdef FIXED_POINT
1078    trim_index = PSHR32(trim, 8);
1079 #else
1080    trim_index = floor(.5+trim);
1081 #endif
1082    if (trim_index<0)
1083       trim_index = 0;
1084    if (trim_index>10)
1085       trim_index = 10;
1086    /*printf("%d\n", trim_index);*/
1087 #ifdef FUZZING
1088    trim_index = rand()%11;
1089 #endif
1090    return trim_index;
1091 }
1092
1093 static int stereo_analysis(const CELTMode *m, const celt_norm *X,
1094       int LM, int N0)
1095 {
1096    int i;
1097    int thetas;
1098    opus_val32 sumLR = EPSILON, sumMS = EPSILON;
1099
1100    /* Use the L1 norm to model the entropy of the L/R signal vs the M/S signal */
1101    for (i=0;i<13;i++)
1102    {
1103       int j;
1104       for (j=m->eBands[i]<<LM;j<m->eBands[i+1]<<LM;j++)
1105       {
1106          opus_val32 L, R, M, S;
1107          /* We cast to 32-bit first because of the -32768 case */
1108          L = EXTEND32(X[j]);
1109          R = EXTEND32(X[N0+j]);
1110          M = ADD32(L, R);
1111          S = SUB32(L, R);
1112          sumLR = ADD32(sumLR, ADD32(ABS32(L), ABS32(R)));
1113          sumMS = ADD32(sumMS, ADD32(ABS32(M), ABS32(S)));
1114       }
1115    }
1116    sumMS = MULT16_32_Q15(QCONST16(0.707107f, 15), sumMS);
1117    thetas = 13;
1118    /* We don't need thetas for lower bands with LM<=1 */
1119    if (LM<=1)
1120       thetas -= 8;
1121    return MULT16_32_Q15((m->eBands[13]<<(LM+1))+thetas, sumMS)
1122          > MULT16_32_Q15(m->eBands[13]<<(LM+1), sumLR);
1123 }
1124
1125 static int run_prefilter(CELTEncoder *st, celt_sig *in, celt_sig *prefilter_mem, int CC, int N,
1126       int prefilter_tapset, int *pitch, opus_val16 *gain, int *qgain, int enabled, int nbAvailableBytes)
1127 {
1128    int c;
1129    VARDECL(celt_sig, _pre);
1130    celt_sig *pre[2];
1131    const CELTMode *mode;
1132    int pitch_index;
1133    opus_val16 gain1;
1134    opus_val16 pf_threshold;
1135    int pf_on;
1136    int qg;
1137    SAVE_STACK;
1138
1139    mode = st->mode;
1140    ALLOC(_pre, CC*(N+COMBFILTER_MAXPERIOD), celt_sig);
1141
1142    pre[0] = _pre;
1143    pre[1] = _pre + (N+COMBFILTER_MAXPERIOD);
1144
1145
1146    c=0; do {
1147       OPUS_COPY(pre[c], prefilter_mem+c*COMBFILTER_MAXPERIOD, COMBFILTER_MAXPERIOD);
1148       OPUS_COPY(pre[c]+COMBFILTER_MAXPERIOD, in+c*(N+st->overlap)+st->overlap, N);
1149    } while (++c<CC);
1150
1151    if (enabled)
1152    {
1153       VARDECL(opus_val16, pitch_buf);
1154       ALLOC(pitch_buf, (COMBFILTER_MAXPERIOD+N)>>1, opus_val16);
1155
1156       pitch_downsample(pre, pitch_buf, COMBFILTER_MAXPERIOD+N, CC);
1157       /* Don't search for the fir last 1.5 octave of the range because
1158          there's too many false-positives due to short-term correlation */
1159       pitch_search(pitch_buf+(COMBFILTER_MAXPERIOD>>1), pitch_buf, N,
1160             COMBFILTER_MAXPERIOD-3*COMBFILTER_MINPERIOD, &pitch_index);
1161       pitch_index = COMBFILTER_MAXPERIOD-pitch_index;
1162
1163       gain1 = remove_doubling(pitch_buf, COMBFILTER_MAXPERIOD, COMBFILTER_MINPERIOD,
1164             N, &pitch_index, st->prefilter_period, st->prefilter_gain);
1165       if (pitch_index > COMBFILTER_MAXPERIOD-2)
1166          pitch_index = COMBFILTER_MAXPERIOD-2;
1167       gain1 = MULT16_16_Q15(QCONST16(.7f,15),gain1);
1168       /*printf("%d %d %f %f\n", pitch_change, pitch_index, gain1, st->analysis.tonality);*/
1169       if (st->loss_rate>2)
1170          gain1 = HALF32(gain1);
1171       if (st->loss_rate>4)
1172          gain1 = HALF32(gain1);
1173       if (st->loss_rate>8)
1174          gain1 = 0;
1175    } else {
1176       gain1 = 0;
1177       pitch_index = COMBFILTER_MINPERIOD;
1178    }
1179
1180    /* Gain threshold for enabling the prefilter/postfilter */
1181    pf_threshold = QCONST16(.2f,15);
1182
1183    /* Adjusting the threshold based on rate and continuity */
1184    if (abs(pitch_index-st->prefilter_period)*10>pitch_index)
1185       pf_threshold += QCONST16(.2f,15);
1186    if (nbAvailableBytes<25)
1187       pf_threshold += QCONST16(.1f,15);
1188    if (nbAvailableBytes<35)
1189       pf_threshold += QCONST16(.1f,15);
1190    if (st->prefilter_gain > QCONST16(.4f,15))
1191       pf_threshold -= QCONST16(.1f,15);
1192    if (st->prefilter_gain > QCONST16(.55f,15))
1193       pf_threshold -= QCONST16(.1f,15);
1194
1195    /* Hard threshold at 0.2 */
1196    pf_threshold = MAX16(pf_threshold, QCONST16(.2f,15));
1197    if (gain1<pf_threshold)
1198    {
1199       gain1 = 0;
1200       pf_on = 0;
1201       qg = 0;
1202    } else {
1203       /*This block is not gated by a total bits check only because
1204         of the nbAvailableBytes check above.*/
1205       if (ABS16(gain1-st->prefilter_gain)<QCONST16(.1f,15))
1206          gain1=st->prefilter_gain;
1207
1208 #ifdef FIXED_POINT
1209       qg = ((gain1+1536)>>10)/3-1;
1210 #else
1211       qg = (int)floor(.5f+gain1*32/3)-1;
1212 #endif
1213       qg = IMAX(0, IMIN(7, qg));
1214       gain1 = QCONST16(0.09375f,15)*(qg+1);
1215       pf_on = 1;
1216    }
1217    /*printf("%d %f\n", pitch_index, gain1);*/
1218
1219    c=0; do {
1220       int offset = mode->shortMdctSize-st->overlap;
1221       st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
1222       OPUS_COPY(in+c*(N+st->overlap), st->in_mem+c*(st->overlap), st->overlap);
1223       if (offset)
1224          comb_filter(in+c*(N+st->overlap)+st->overlap, pre[c]+COMBFILTER_MAXPERIOD,
1225                st->prefilter_period, st->prefilter_period, offset, -st->prefilter_gain, -st->prefilter_gain,
1226                st->prefilter_tapset, st->prefilter_tapset, NULL, 0);
1227
1228       comb_filter(in+c*(N+st->overlap)+st->overlap+offset, pre[c]+COMBFILTER_MAXPERIOD+offset,
1229             st->prefilter_period, pitch_index, N-offset, -st->prefilter_gain, -gain1,
1230             st->prefilter_tapset, prefilter_tapset, mode->window, st->overlap);
1231       OPUS_COPY(st->in_mem+c*(st->overlap), in+c*(N+st->overlap)+N, st->overlap);
1232
1233       if (N>COMBFILTER_MAXPERIOD)
1234       {
1235          OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, pre[c]+N, COMBFILTER_MAXPERIOD);
1236       } else {
1237          OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD, prefilter_mem+c*COMBFILTER_MAXPERIOD+N, COMBFILTER_MAXPERIOD-N);
1238          OPUS_MOVE(prefilter_mem+c*COMBFILTER_MAXPERIOD+COMBFILTER_MAXPERIOD-N, pre[c]+COMBFILTER_MAXPERIOD, N);
1239       }
1240    } while (++c<CC);
1241
1242    RESTORE_STACK;
1243    *gain = gain1;
1244    *pitch = pitch_index;
1245    *qgain = qg;
1246    return pf_on;
1247 }
1248
1249 int celt_encode_with_ec(CELTEncoder * OPUS_RESTRICT st, const opus_val16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes, ec_enc *enc)
1250 {
1251    int i, c, N;
1252    opus_int32 bits;
1253    ec_enc _enc;
1254    VARDECL(celt_sig, in);
1255    VARDECL(celt_sig, freq);
1256    VARDECL(celt_norm, X);
1257    VARDECL(celt_ener, bandE);
1258    VARDECL(opus_val16, bandLogE);
1259    VARDECL(opus_val16, bandLogE2);
1260    VARDECL(int, fine_quant);
1261    VARDECL(opus_val16, error);
1262    VARDECL(int, pulses);
1263    VARDECL(int, cap);
1264    VARDECL(int, offsets);
1265    VARDECL(int, fine_priority);
1266    VARDECL(int, tf_res);
1267    VARDECL(unsigned char, collapse_masks);
1268    celt_sig *prefilter_mem;
1269    opus_val16 *oldBandE, *oldLogE, *oldLogE2;
1270    int shortBlocks=0;
1271    int isTransient=0;
1272    const int CC = st->channels;
1273    const int C = st->stream_channels;
1274    int LM, M;
1275    int tf_select;
1276    int nbFilledBytes, nbAvailableBytes;
1277    int effEnd;
1278    int codedBands;
1279    int tf_sum;
1280    int alloc_trim;
1281    int pitch_index=COMBFILTER_MINPERIOD;
1282    opus_val16 gain1 = 0;
1283    int dual_stereo=0;
1284    int effectiveBytes;
1285    int dynalloc_logp;
1286    opus_int32 vbr_rate;
1287    opus_int32 total_bits;
1288    opus_int32 total_boost;
1289    opus_int32 balance;
1290    opus_int32 tell;
1291    int prefilter_tapset=0;
1292    int pf_on;
1293    int anti_collapse_rsv;
1294    int anti_collapse_on=0;
1295    int silence=0;
1296    int tf_chan = 0;
1297    opus_val16 tf_estimate;
1298    int pitch_change=0;
1299    opus_int32 tot_boost=0;
1300    opus_val16 sample_max;
1301    opus_val16 maxDepth;
1302    const OpusCustomMode *mode;
1303    int nbEBands;
1304    int overlap;
1305    const opus_int16 *eBands;
1306    ALLOC_STACK;
1307
1308    mode = st->mode;
1309    nbEBands = mode->nbEBands;
1310    overlap = mode->overlap;
1311    eBands = mode->eBands;
1312    tf_estimate = QCONST16(1.0f,14);
1313    if (nbCompressedBytes<2 || pcm==NULL)
1314      return OPUS_BAD_ARG;
1315
1316    frame_size *= st->upsample;
1317    for (LM=0;LM<=mode->maxLM;LM++)
1318       if (mode->shortMdctSize<<LM==frame_size)
1319          break;
1320    if (LM>mode->maxLM)
1321       return OPUS_BAD_ARG;
1322    M=1<<LM;
1323    N = M*mode->shortMdctSize;
1324
1325    prefilter_mem = st->in_mem+CC*(st->overlap);
1326    oldBandE = (opus_val16*)(st->in_mem+CC*(st->overlap+COMBFILTER_MAXPERIOD));
1327    oldLogE = oldBandE + CC*nbEBands;
1328    oldLogE2 = oldLogE + CC*nbEBands;
1329
1330    if (enc==NULL)
1331    {
1332       tell=1;
1333       nbFilledBytes=0;
1334    } else {
1335       tell=ec_tell(enc);
1336       nbFilledBytes=(tell+4)>>3;
1337    }
1338
1339 #ifdef CUSTOM_MODES
1340    if (st->signalling && enc==NULL)
1341    {
1342       int tmp = (mode->effEBands-st->end)>>1;
1343       st->end = IMAX(1, mode->effEBands-tmp);
1344       compressed[0] = tmp<<5;
1345       compressed[0] |= LM<<3;
1346       compressed[0] |= (C==2)<<2;
1347       /* Convert "standard mode" to Opus header */
1348       if (mode->Fs==48000 && mode->shortMdctSize==120)
1349       {
1350          int c0 = toOpus(compressed[0]);
1351          if (c0<0)
1352             return OPUS_BAD_ARG;
1353          compressed[0] = c0;
1354       }
1355       compressed++;
1356       nbCompressedBytes--;
1357    }
1358 #else
1359    celt_assert(st->signalling==0);
1360 #endif
1361
1362    /* Can't produce more than 1275 output bytes */
1363    nbCompressedBytes = IMIN(nbCompressedBytes,1275);
1364    nbAvailableBytes = nbCompressedBytes - nbFilledBytes;
1365
1366    if (st->vbr && st->bitrate!=OPUS_BITRATE_MAX)
1367    {
1368       opus_int32 den=mode->Fs>>BITRES;
1369       vbr_rate=(st->bitrate*frame_size+(den>>1))/den;
1370 #ifdef CUSTOM_MODES
1371       if (st->signalling)
1372          vbr_rate -= 8<<BITRES;
1373 #endif
1374       effectiveBytes = vbr_rate>>(3+BITRES);
1375    } else {
1376       opus_int32 tmp;
1377       vbr_rate = 0;
1378       tmp = st->bitrate*frame_size;
1379       if (tell>1)
1380          tmp += tell;
1381       if (st->bitrate!=OPUS_BITRATE_MAX)
1382          nbCompressedBytes = IMAX(2, IMIN(nbCompressedBytes,
1383                (tmp+4*mode->Fs)/(8*mode->Fs)-!!st->signalling));
1384       effectiveBytes = nbCompressedBytes;
1385    }
1386
1387    if (enc==NULL)
1388    {
1389       ec_enc_init(&_enc, compressed, nbCompressedBytes);
1390       enc = &_enc;
1391    }
1392
1393    if (vbr_rate>0)
1394    {
1395       /* Computes the max bit-rate allowed in VBR mode to avoid violating the
1396           target rate and buffering.
1397          We must do this up front so that bust-prevention logic triggers
1398           correctly if we don't have enough bits. */
1399       if (st->constrained_vbr)
1400       {
1401          opus_int32 vbr_bound;
1402          opus_int32 max_allowed;
1403          /* We could use any multiple of vbr_rate as bound (depending on the
1404              delay).
1405             This is clamped to ensure we use at least two bytes if the encoder
1406              was entirely empty, but to allow 0 in hybrid mode. */
1407          vbr_bound = vbr_rate;
1408          max_allowed = IMIN(IMAX(tell==1?2:0,
1409                (vbr_rate+vbr_bound-st->vbr_reservoir)>>(BITRES+3)),
1410                nbAvailableBytes);
1411          if(max_allowed < nbAvailableBytes)
1412          {
1413             nbCompressedBytes = nbFilledBytes+max_allowed;
1414             nbAvailableBytes = max_allowed;
1415             ec_enc_shrink(enc, nbCompressedBytes);
1416          }
1417       }
1418    }
1419    total_bits = nbCompressedBytes*8;
1420
1421    effEnd = st->end;
1422    if (effEnd > mode->effEBands)
1423       effEnd = mode->effEBands;
1424
1425    ALLOC(in, CC*(N+st->overlap), celt_sig);
1426
1427    sample_max=MAX16(st->overlap_max, celt_maxabs16(pcm, C*(N-overlap)/st->upsample));
1428    st->overlap_max=celt_maxabs16(pcm+C*(N-overlap)/st->upsample, C*overlap/st->upsample);
1429    sample_max=MAX16(sample_max, st->overlap_max);
1430 #ifdef FIXED_POINT
1431    silence = (sample_max==0);
1432 #else
1433    silence = (sample_max <= (opus_val16)1/(1<<st->lsb_depth));
1434 #endif
1435 #ifdef FUZZING
1436    if ((rand()&0x3F)==0)
1437       silence = 1;
1438 #endif
1439    if (tell==1)
1440       ec_enc_bit_logp(enc, silence, 15);
1441    else
1442       silence=0;
1443    if (silence)
1444    {
1445       /*In VBR mode there is no need to send more than the minimum. */
1446       if (vbr_rate>0)
1447       {
1448          effectiveBytes=nbCompressedBytes=IMIN(nbCompressedBytes, nbFilledBytes+2);
1449          total_bits=nbCompressedBytes*8;
1450          nbAvailableBytes=2;
1451          ec_enc_shrink(enc, nbCompressedBytes);
1452       }
1453       /* Pretend we've filled all the remaining bits with zeros
1454             (that's what the initialiser did anyway) */
1455       tell = nbCompressedBytes*8;
1456       enc->nbits_total+=tell-ec_tell(enc);
1457    }
1458    c=0; do {
1459       preemphasis(pcm+c, in+c*(N+st->overlap)+st->overlap, N, CC, st->upsample,
1460                   mode->preemph, st->preemph_memE+c, st->clip);
1461    } while (++c<CC);
1462
1463
1464
1465    /* Find pitch period and gain */
1466    {
1467       int enabled;
1468       int qg;
1469       enabled = nbAvailableBytes>12*C && st->start==0 && !silence && !st->disable_pf && st->complexity >= 5;
1470
1471       prefilter_tapset = st->tapset_decision;
1472       pf_on = run_prefilter(st, in, prefilter_mem, CC, N, prefilter_tapset, &pitch_index, &gain1, &qg, enabled, nbAvailableBytes);
1473       if ((gain1 > QCONST16(.4f,15) || st->prefilter_gain > QCONST16(.4f,15)) && st->analysis.tonality > .3
1474             && (pitch_index > 1.26*st->prefilter_period || pitch_index < .79*st->prefilter_period))
1475          pitch_change = 1;
1476       if (pf_on==0)
1477       {
1478          if(st->start==0 && tell+16<=total_bits)
1479             ec_enc_bit_logp(enc, 0, 1);
1480       } else {
1481          /*This block is not gated by a total bits check only because
1482            of the nbAvailableBytes check above.*/
1483          int octave;
1484          ec_enc_bit_logp(enc, 1, 1);
1485          pitch_index += 1;
1486          octave = EC_ILOG(pitch_index)-5;
1487          ec_enc_uint(enc, octave, 6);
1488          ec_enc_bits(enc, pitch_index-(16<<octave), 4+octave);
1489          pitch_index -= 1;
1490          ec_enc_bits(enc, qg, 3);
1491          ec_enc_icdf(enc, prefilter_tapset, tapset_icdf, 2);
1492       }
1493    }
1494
1495    isTransient = 0;
1496    shortBlocks = 0;
1497    if (LM>0 && ec_tell(enc)+3<=total_bits)
1498    {
1499       if (st->complexity > 1)
1500       {
1501          isTransient = transient_analysis(in, N+st->overlap, CC,
1502                   &tf_estimate, &tf_chan);
1503          if (isTransient)
1504             shortBlocks = M;
1505       }
1506       ec_enc_bit_logp(enc, isTransient, 3);
1507    }
1508
1509    ALLOC(freq, CC*N, celt_sig); /**< Interleaved signal MDCTs */
1510    ALLOC(bandE,nbEBands*CC, celt_ener);
1511    ALLOC(bandLogE,nbEBands*CC, opus_val16);
1512    /* Compute MDCTs */
1513    compute_mdcts(mode, shortBlocks, in, freq, CC, LM);
1514
1515    if (CC==2&&C==1)
1516    {
1517       for (i=0;i<N;i++)
1518          freq[i] = ADD32(HALF32(freq[i]), HALF32(freq[N+i]));
1519       tf_chan = 0;
1520    }
1521    if (st->upsample != 1)
1522    {
1523       c=0; do
1524       {
1525          int bound = N/st->upsample;
1526          for (i=0;i<bound;i++)
1527             freq[c*N+i] *= st->upsample;
1528          for (;i<N;i++)
1529             freq[c*N+i] = 0;
1530       } while (++c<C);
1531    }
1532    compute_band_energies(mode, freq, bandE, effEnd, C, M);
1533
1534    amp2Log2(mode, effEnd, st->end, bandE, bandLogE, C);
1535    /*for (i=0;i<21;i++)
1536       printf("%f ", bandLogE[i]);
1537    printf("\n");*/
1538
1539    ALLOC(bandLogE2, C*nbEBands, opus_val16);
1540    if (shortBlocks && st->complexity>=8)
1541    {
1542       VARDECL(celt_sig, freq2);
1543       VARDECL(opus_val32, bandE2);
1544       ALLOC(freq2, CC*N, celt_sig);
1545       compute_mdcts(mode, 0, in, freq2, CC, LM);
1546       if (CC==2&&C==1)
1547       {
1548          for (i=0;i<N;i++)
1549             freq2[i] = ADD32(HALF32(freq2[i]), HALF32(freq2[N+i]));
1550       }
1551       if (st->upsample != 1)
1552       {
1553          c=0; do
1554          {
1555             int bound = N/st->upsample;
1556             for (i=0;i<bound;i++)
1557                freq2[c*N+i] *= st->upsample;
1558             for (;i<N;i++)
1559                freq2[c*N+i] = 0;
1560          } while (++c<C);
1561       }
1562       ALLOC(bandE2, C*nbEBands, opus_val32);
1563       compute_band_energies(mode, freq2, bandE2, effEnd, C, M);
1564       amp2Log2(mode, effEnd, st->end, bandE2, bandLogE2, C);
1565       for (i=0;i<C*nbEBands;i++)
1566          bandLogE2[i] += HALF16(SHL16(LM, DB_SHIFT));
1567    } else {
1568       for (i=0;i<C*nbEBands;i++)
1569          bandLogE2[i] = bandLogE[i];
1570    }
1571
1572    ALLOC(X, C*N, celt_norm);         /**< Interleaved normalised MDCTs */
1573
1574    /* Band normalisation */
1575    normalise_bands(mode, freq, X, bandE, effEnd, C, M);
1576
1577    ALLOC(tf_res, nbEBands, int);
1578    tf_select = tf_analysis(mode, effEnd, C, isTransient, tf_res, effectiveBytes, X, N, LM, &tf_sum, tf_estimate, tf_chan);
1579    for (i=effEnd;i<st->end;i++)
1580       tf_res[i] = tf_res[effEnd-1];
1581
1582    ALLOC(error, C*nbEBands, opus_val16);
1583    quant_coarse_energy(mode, st->start, st->end, effEnd, bandLogE,
1584          oldBandE, total_bits, error, enc,
1585          C, LM, nbAvailableBytes, st->force_intra,
1586          &st->delayedIntra, st->complexity >= 4, st->loss_rate);
1587
1588    tf_encode(st->start, st->end, isTransient, tf_res, LM, tf_select, enc);
1589
1590    if (ec_tell(enc)+4<=total_bits)
1591    {
1592       if (shortBlocks || st->complexity < 3 || nbAvailableBytes < 10*C)
1593       {
1594          if (st->complexity == 0)
1595             st->spread_decision = SPREAD_NONE;
1596       } else {
1597          if (st->analysis.valid)
1598          {
1599             static const opus_val16 spread_thresholds[3] = {-QCONST16(.6f, 15), -QCONST16(.2f, 15), -QCONST16(.07f, 15)};
1600             static const opus_val16 spread_histeresis[3] = {QCONST16(.15f, 15), QCONST16(.07f, 15), QCONST16(.02f, 15)};
1601             static const opus_val16 tapset_thresholds[2] = {QCONST16(.0f, 15), QCONST16(.15f, 15)};
1602             static const opus_val16 tapset_histeresis[2] = {QCONST16(.1f, 15), QCONST16(.05f, 15)};
1603             st->spread_decision = hysteresis_decision(-st->analysis.tonality, spread_thresholds, spread_histeresis, 3, st->spread_decision);
1604             st->tapset_decision = hysteresis_decision(st->analysis.tonality_slope, tapset_thresholds, tapset_histeresis, 2, st->tapset_decision);
1605          } else {
1606             st->spread_decision = spreading_decision(mode, X,
1607                   &st->tonal_average, st->spread_decision, &st->hf_average,
1608                   &st->tapset_decision, pf_on&&!shortBlocks, effEnd, C, M);
1609          }
1610          /*printf("%d %d\n", st->tapset_decision, st->spread_decision);*/
1611          /*printf("%f %d %f %d\n\n", st->analysis.tonality, st->spread_decision, st->analysis.tonality_slope, st->tapset_decision);*/
1612       }
1613       ec_enc_icdf(enc, st->spread_decision, spread_icdf, 5);
1614    }
1615
1616    ALLOC(cap, nbEBands, int);
1617    ALLOC(offsets, nbEBands, int);
1618
1619    init_caps(mode,cap,LM,C);
1620    for (i=0;i<nbEBands;i++)
1621       offsets[i] = 0;
1622    /* Dynamic allocation code */
1623    maxDepth=-QCONST16(32.f, DB_SHIFT);
1624    /* Make sure that dynamic allocation can't make us bust the budget */
1625    if (effectiveBytes > 50 && LM>=1)
1626    {
1627       int last=0;
1628       VARDECL(opus_val16, follower);
1629       ALLOC(follower, C*nbEBands, opus_val16);
1630       c=0;do
1631       {
1632          follower[c*nbEBands] = bandLogE2[c*nbEBands];
1633          for (i=1;i<st->end;i++)
1634          {
1635             /* The last band to be at least 3 dB higher than the previous one
1636                is the last we'll consider. Otherwise, we run into problems on
1637                bandlimited signals. */
1638             if (bandLogE2[c*nbEBands+i] > bandLogE2[c*nbEBands+i-1]+QCONST16(.5f,DB_SHIFT))
1639                last=i;
1640             follower[c*nbEBands+i] = MIN16(follower[c*nbEBands+i-1]+QCONST16(1.5f,DB_SHIFT), bandLogE2[c*nbEBands+i]);
1641          }
1642          for (i=last-1;i>=0;i--)
1643             follower[c*nbEBands+i] = MIN16(follower[c*nbEBands+i], MIN16(follower[c*nbEBands+i+1]+QCONST16(2.f,DB_SHIFT), bandLogE2[c*nbEBands+i]));
1644          for (i=0;i<st->end;i++)
1645          {
1646             opus_val16 noise_floor;
1647             /* Noise floor must take into account eMeans, the depth, the width of the bands
1648                and the preemphasis filter (approx. square of bark band ID) */
1649             noise_floor = MULT16_16(QCONST16(0.0625f, DB_SHIFT),mode->logN[i])
1650                   +QCONST16(.5f,DB_SHIFT)+SHL16(9-st->lsb_depth,DB_SHIFT)-SHL16(eMeans[i],6)
1651                   +MULT16_16(QCONST16(.0062,DB_SHIFT),(i+5)*(i+5));
1652             follower[c*nbEBands+i] = MAX16(follower[c*nbEBands+i], noise_floor);
1653             maxDepth = MAX16(maxDepth, bandLogE[c*nbEBands+i]-noise_floor);
1654          }
1655       } while (++c<C);
1656       if (C==2)
1657       {
1658          for (i=st->start;i<st->end;i++)
1659          {
1660             /* Consider 24 dB "cross-talk" */
1661             follower[nbEBands+i] = MAX16(follower[nbEBands+i], follower[                   i]-QCONST16(4.f,DB_SHIFT));
1662             follower[                   i] = MAX16(follower[                   i], follower[nbEBands+i]-QCONST16(4.f,DB_SHIFT));
1663             follower[i] = HALF16(MAX16(0, bandLogE[i]-follower[i]) + MAX16(0, bandLogE[nbEBands+i]-follower[nbEBands+i]));
1664          }
1665       } else {
1666          for (i=st->start;i<st->end;i++)
1667          {
1668             follower[i] = MAX16(0, bandLogE[i]-follower[i]);
1669          }
1670       }
1671       /* For non-transient CBR/CVBR frames, halve the dynalloc contribution */
1672       if ((!st->vbr || st->constrained_vbr)&&!isTransient)
1673       {
1674          for (i=st->start;i<st->end;i++)
1675             follower[i] = HALF16(follower[i]);
1676       }
1677       for (i=st->start;i<st->end;i++)
1678       {
1679          int width;
1680          int boost;
1681          int boost_bits;
1682
1683          if (i<8)
1684             follower[i] *= 2;
1685          if (i>=12)
1686             follower[i] = HALF16(follower[i]);
1687          follower[i] = MIN16(follower[i], QCONST16(4, DB_SHIFT));
1688
1689          width = C*(eBands[i+1]-eBands[i])<<LM;
1690          if (width<6)
1691          {
1692             boost = SHR32(EXTEND32(follower[i]),DB_SHIFT);
1693             boost_bits = boost*width<<BITRES;
1694          } else if (width > 48) {
1695             boost = SHR32(EXTEND32(follower[i])*8,DB_SHIFT);
1696             boost_bits = (boost*width<<BITRES)/8;
1697          } else {
1698             boost = SHR32(EXTEND32(follower[i])*width/6,DB_SHIFT);
1699             boost_bits = boost*6<<BITRES;
1700          }
1701          /* For CBR and non-transient CVBR frames, limit dynalloc to 1/4 of the bits */
1702          if ((!st->vbr || (st->constrained_vbr&&!isTransient))
1703                && (tot_boost+boost_bits)>>BITRES>>3 > effectiveBytes/4)
1704          {
1705             offsets[i] = 0;
1706             break;
1707          } else {
1708             offsets[i] = boost;
1709             tot_boost += boost_bits;
1710          }
1711       }
1712    }
1713    dynalloc_logp = 6;
1714    total_bits<<=BITRES;
1715    total_boost = 0;
1716    tell = ec_tell_frac(enc);
1717    for (i=st->start;i<st->end;i++)
1718    {
1719       int width, quanta;
1720       int dynalloc_loop_logp;
1721       int boost;
1722       int j;
1723       width = C*(eBands[i+1]-eBands[i])<<LM;
1724       /* quanta is 6 bits, but no more than 1 bit/sample
1725          and no less than 1/8 bit/sample */
1726       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
1727       dynalloc_loop_logp = dynalloc_logp;
1728       boost = 0;
1729       for (j = 0; tell+(dynalloc_loop_logp<<BITRES) < total_bits-total_boost
1730             && boost < cap[i]; j++)
1731       {
1732          int flag;
1733          flag = j<offsets[i];
1734          ec_enc_bit_logp(enc, flag, dynalloc_loop_logp);
1735          tell = ec_tell_frac(enc);
1736          if (!flag)
1737             break;
1738          boost += quanta;
1739          total_boost += quanta;
1740          dynalloc_loop_logp = 1;
1741       }
1742       /* Making dynalloc more likely */
1743       if (j)
1744          dynalloc_logp = IMAX(2, dynalloc_logp-1);
1745       offsets[i] = boost;
1746    }
1747
1748    if (C==2)
1749    {
1750       int effectiveRate;
1751
1752       static const opus_val16 intensity_thresholds[21]=
1753       /* 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19  20  off*/
1754         { 16,21,23,25,27,29,31,33,35,38,42,46,50,54,58,63,68,75,84,102,130};
1755       static const opus_val16 intensity_histeresis[21]=
1756         {  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 4, 5, 6,  8, 12};
1757
1758       /* Always use MS for 2.5 ms frames until we can do a better analysis */
1759       if (LM!=0)
1760          dual_stereo = stereo_analysis(mode, X, LM, N);
1761
1762       /* Account for coarse energy */
1763       effectiveRate = (8*effectiveBytes - 80)>>LM;
1764
1765       /* effectiveRate in kb/s */
1766       effectiveRate = 2*effectiveRate/5;
1767
1768       st->intensity = hysteresis_decision(effectiveRate, intensity_thresholds, intensity_histeresis, 21, st->intensity);
1769       st->intensity = IMIN(st->end,IMAX(st->start, st->intensity));
1770    }
1771
1772    alloc_trim = 5;
1773    if (tell+(6<<BITRES) <= total_bits - total_boost)
1774    {
1775       alloc_trim = alloc_trim_analysis(mode, X, bandLogE,
1776             st->end, LM, C, N, &st->analysis, &st->stereo_saving, tf_estimate, st->intensity);
1777       ec_enc_icdf(enc, alloc_trim, trim_icdf, 7);
1778       tell = ec_tell_frac(enc);
1779    }
1780
1781    /* Variable bitrate */
1782    if (vbr_rate>0)
1783    {
1784      opus_val16 alpha;
1785      opus_int32 delta;
1786      /* The target rate in 8th bits per frame */
1787      opus_int32 target, base_target;
1788      opus_int32 min_allowed;
1789      int coded_bins;
1790      int coded_bands;
1791      int lm_diff = mode->maxLM - LM;
1792      coded_bands = st->lastCodedBands ? st->lastCodedBands : nbEBands;
1793      coded_bins = eBands[coded_bands]<<LM;
1794      if (C==2)
1795         coded_bins += eBands[IMIN(st->intensity, coded_bands)]<<LM;
1796
1797      /* Don't attempt to use more than 510 kb/s, even for frames smaller than 20 ms.
1798         The CELT allocator will just not be able to use more than that anyway. */
1799      nbCompressedBytes = IMIN(nbCompressedBytes,1275>>(3-LM));
1800      target = vbr_rate - ((40*C+20)<<BITRES);
1801      base_target = target;
1802
1803      if (st->constrained_vbr)
1804         target += (st->vbr_offset>>lm_diff);
1805
1806      /*printf("%f %f %f %f %d %d ", st->analysis.activity, st->analysis.tonality, tf_estimate, st->stereo_saving, tot_boost, coded_bands);*/
1807 #ifndef FIXED_POINT
1808      if (st->analysis.valid && st->analysis.activity<.4)
1809         target -= (coded_bins<<BITRES)*1*(.4-st->analysis.activity);
1810 #endif
1811      /* Stereo savings */
1812      if (C==2)
1813      {
1814         int coded_stereo_bands;
1815         int coded_stereo_dof;
1816         coded_stereo_bands = IMIN(st->intensity, coded_bands);
1817         coded_stereo_dof = (eBands[coded_stereo_bands]<<LM)-coded_stereo_bands;
1818         /*printf("%d %d %d ", coded_stereo_dof, coded_bins, tot_boost);*/
1819         target -= MIN32(target/3, SHR16(MULT16_16(st->stereo_saving,(coded_stereo_dof<<BITRES)),8));
1820         target += MULT16_16_Q15(QCONST16(0.035,15),coded_stereo_dof<<BITRES);
1821      }
1822      /* Limits starving of other bands when using dynalloc */
1823      target += tot_boost;
1824      /* Compensates for the average transient boost */
1825      target = MULT16_32_Q15(QCONST16(0.96f,15),target);
1826      /* Apply transient boost */
1827      target = SHL32(MULT16_32_Q15(tf_estimate, target),1);
1828
1829 #ifndef FIXED_POINT
1830      /* Apply tonality boost */
1831      if (st->analysis.valid) {
1832         int tonal_target;
1833         float tonal;
1834
1835         /* Compensates for the average tonality boost */
1836         target -= MULT16_16_Q15(QCONST16(0.13f,15),coded_bins<<BITRES);
1837
1838         tonal = MAX16(0,st->analysis.tonality-.2);
1839         tonal_target = target + (coded_bins<<BITRES)*2.0f*tonal;
1840         if (pitch_change)
1841            tonal_target +=  (coded_bins<<BITRES)*.8;
1842         /*printf("%f %f ", st->analysis.tonality, tonal);*/
1843         target = IMAX(tonal_target,target);
1844      }
1845 #endif
1846
1847      {
1848         opus_int32 floor_depth;
1849         int bins;
1850         bins = eBands[nbEBands-2]<<LM;
1851         /*floor_depth = SHR32(MULT16_16((C*bins<<BITRES),celt_log2(SHL32(MAX16(1,sample_max),13))), DB_SHIFT);*/
1852         floor_depth = SHR32(MULT16_16((C*bins<<BITRES),maxDepth), DB_SHIFT);
1853         floor_depth = IMAX(floor_depth, target>>2);
1854         target = IMIN(target, floor_depth);
1855         /*printf("%f %d\n", maxDepth, floor_depth);*/
1856      }
1857
1858      if (st->constrained_vbr || st->bitrate<64000)
1859      {
1860         opus_val16 rate_factor;
1861 #ifdef FIXED_POINT
1862         rate_factor = MAX16(0,(st->bitrate-32000));
1863 #else
1864         rate_factor = MAX16(0,(1.f/32768)*(st->bitrate-32000));
1865 #endif
1866         if (st->constrained_vbr)
1867            rate_factor = MIN16(rate_factor, QCONST16(0.67f, 15));
1868         target = base_target + MULT16_32_Q15(rate_factor, target-base_target);
1869
1870      }
1871      /* Don't allow more than doubling the rate */
1872      target = IMIN(2*base_target, target);
1873
1874      /* The current offset is removed from the target and the space used
1875         so far is added*/
1876      target=target+tell;
1877      /* In VBR mode the frame size must not be reduced so much that it would
1878          result in the encoder running out of bits.
1879         The margin of 2 bytes ensures that none of the bust-prevention logic
1880          in the decoder will have triggered so far. */
1881      min_allowed = ((tell+total_boost+(1<<(BITRES+3))-1)>>(BITRES+3)) + 2 - nbFilledBytes;
1882
1883      nbAvailableBytes = (target+(1<<(BITRES+2)))>>(BITRES+3);
1884      nbAvailableBytes = IMAX(min_allowed,nbAvailableBytes);
1885      nbAvailableBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes) - nbFilledBytes;
1886
1887      /* By how much did we "miss" the target on that frame */
1888      delta = target - vbr_rate;
1889
1890      target=nbAvailableBytes<<(BITRES+3);
1891
1892      /*If the frame is silent we don't adjust our drift, otherwise
1893        the encoder will shoot to very high rates after hitting a
1894        span of silence, but we do allow the bitres to refill.
1895        This means that we'll undershoot our target in CVBR/VBR modes
1896        on files with lots of silence. */
1897      if(silence)
1898      {
1899        nbAvailableBytes = 2;
1900        target = 2*8<<BITRES;
1901        delta = 0;
1902      }
1903
1904      if (st->vbr_count < 970)
1905      {
1906         st->vbr_count++;
1907         alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+20),16));
1908      } else
1909         alpha = QCONST16(.001f,15);
1910      /* How many bits have we used in excess of what we're allowed */
1911      if (st->constrained_vbr)
1912         st->vbr_reservoir += target - vbr_rate;
1913      /*printf ("%d\n", st->vbr_reservoir);*/
1914
1915      /* Compute the offset we need to apply in order to reach the target */
1916      if (st->constrained_vbr)
1917      {
1918         st->vbr_drift += (opus_int32)MULT16_32_Q15(alpha,(delta*(1<<lm_diff))-st->vbr_offset-st->vbr_drift);
1919         st->vbr_offset = -st->vbr_drift;
1920      }
1921      /*printf ("%d\n", st->vbr_drift);*/
1922
1923      if (st->constrained_vbr && st->vbr_reservoir < 0)
1924      {
1925         /* We're under the min value -- increase rate */
1926         int adjust = (-st->vbr_reservoir)/(8<<BITRES);
1927         /* Unless we're just coding silence */
1928         nbAvailableBytes += silence?0:adjust;
1929         st->vbr_reservoir = 0;
1930         /*printf ("+%d\n", adjust);*/
1931      }
1932      nbCompressedBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes);
1933      /*printf("%d\n", nbCompressedBytes*50*8);*/
1934      /* This moves the raw bits to take into account the new compressed size */
1935      ec_enc_shrink(enc, nbCompressedBytes);
1936    }
1937
1938    /* Bit allocation */
1939    ALLOC(fine_quant, nbEBands, int);
1940    ALLOC(pulses, nbEBands, int);
1941    ALLOC(fine_priority, nbEBands, int);
1942
1943    /* bits =           packet size                    - where we are - safety*/
1944    bits = (((opus_int32)nbCompressedBytes*8)<<BITRES) - ec_tell_frac(enc) - 1;
1945    anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0;
1946    bits -= anti_collapse_rsv;
1947    codedBands = compute_allocation(mode, st->start, st->end, offsets, cap,
1948          alloc_trim, &st->intensity, &dual_stereo, bits, &balance, pulses,
1949          fine_quant, fine_priority, C, LM, enc, 1, st->lastCodedBands);
1950    st->lastCodedBands = codedBands;
1951
1952    quant_fine_energy(mode, st->start, st->end, oldBandE, error, fine_quant, enc, C);
1953
1954 #ifdef MEASURE_NORM_MSE
1955    float X0[3000];
1956    float bandE0[60];
1957    c=0; do
1958       for (i=0;i<N;i++)
1959          X0[i+c*N] = X[i+c*N];
1960    while (++c<C);
1961    for (i=0;i<C*nbEBands;i++)
1962       bandE0[i] = bandE[i];
1963 #endif
1964
1965    /* Residual quantisation */
1966    ALLOC(collapse_masks, C*nbEBands, unsigned char);
1967    quant_all_bands(1, mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
1968          bandE, pulses, shortBlocks, st->spread_decision, dual_stereo, st->intensity, tf_res,
1969          nbCompressedBytes*(8<<BITRES)-anti_collapse_rsv, balance, enc, LM, codedBands, &st->rng);
1970
1971    if (anti_collapse_rsv > 0)
1972    {
1973       anti_collapse_on = st->consec_transient<2;
1974 #ifdef FUZZING
1975       anti_collapse_on = rand()&0x1;
1976 #endif
1977       ec_enc_bits(enc, anti_collapse_on, 1);
1978    }
1979    quant_energy_finalise(mode, st->start, st->end, oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_tell(enc), enc, C);
1980
1981    if (silence)
1982    {
1983       for (i=0;i<C*nbEBands;i++)
1984          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
1985    }
1986
1987 #ifdef RESYNTH
1988    /* Re-synthesis of the coded audio if required */
1989    {
1990       celt_sig *out_mem[2];
1991       celt_sig *overlap_mem[2];
1992
1993       log2Amp(mode, st->start, st->end, bandE, oldBandE, C);
1994       if (silence)
1995       {
1996          for (i=0;i<C*nbEBands;i++)
1997             bandE[i] = 0;
1998       }
1999
2000 #ifdef MEASURE_NORM_MSE
2001       measure_norm_mse(mode, X, X0, bandE, bandE0, M, N, C);
2002 #endif
2003       if (anti_collapse_on)
2004       {
2005          anti_collapse(mode, X, collapse_masks, LM, C, N,
2006                st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
2007       }
2008
2009       /* Synthesis */
2010       denormalise_bands(mode, X, freq, bandE, effEnd, C, M);
2011
2012       OPUS_MOVE(st->syn_mem[0], st->syn_mem[0]+N, MAX_PERIOD);
2013       if (CC==2)
2014          OPUS_MOVE(st->syn_mem[1], st->syn_mem[1]+N, MAX_PERIOD);
2015
2016       c=0; do
2017          for (i=0;i<M*eBands[st->start];i++)
2018             freq[c*N+i] = 0;
2019       while (++c<C);
2020       c=0; do
2021          for (i=M*eBands[st->end];i<N;i++)
2022             freq[c*N+i] = 0;
2023       while (++c<C);
2024
2025       if (CC==2&&C==1)
2026       {
2027          for (i=0;i<N;i++)
2028             freq[N+i] = freq[i];
2029       }
2030
2031       out_mem[0] = st->syn_mem[0]+MAX_PERIOD;
2032       if (CC==2)
2033          out_mem[1] = st->syn_mem[1]+MAX_PERIOD;
2034
2035       overlap_mem[0] = (celt_sig*)(oldLogE2 + CC*nbEBands);
2036       if (CC==2)
2037          overlap_mem[1] = overlap_mem[0] + st->overlap;
2038
2039       compute_inv_mdcts(mode, shortBlocks, freq, out_mem, overlap_mem, CC, LM);
2040
2041       c=0; do {
2042          st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
2043          st->prefilter_period_old=IMAX(st->prefilter_period_old, COMBFILTER_MINPERIOD);
2044          comb_filter(out_mem[c], out_mem[c], st->prefilter_period_old, st->prefilter_period, mode->shortMdctSize,
2045                st->prefilter_gain_old, st->prefilter_gain, st->prefilter_tapset_old, st->prefilter_tapset,
2046                mode->window, st->overlap);
2047          if (LM!=0)
2048             comb_filter(out_mem[c]+mode->shortMdctSize, out_mem[c]+mode->shortMdctSize, st->prefilter_period, pitch_index, N-mode->shortMdctSize,
2049                   st->prefilter_gain, gain1, st->prefilter_tapset, prefilter_tapset,
2050                   mode->window, overlap);
2051       } while (++c<CC);
2052
2053       /* We reuse freq[] as scratch space for the de-emphasis */
2054       deemphasis(out_mem, (opus_val16*)pcm, N, CC, st->upsample, mode->preemph, st->preemph_memD, freq);
2055       st->prefilter_period_old = st->prefilter_period;
2056       st->prefilter_gain_old = st->prefilter_gain;
2057       st->prefilter_tapset_old = st->prefilter_tapset;
2058    }
2059 #endif
2060
2061    st->prefilter_period = pitch_index;
2062    st->prefilter_gain = gain1;
2063    st->prefilter_tapset = prefilter_tapset;
2064 #ifdef RESYNTH
2065    if (LM!=0)
2066    {
2067       st->prefilter_period_old = st->prefilter_period;
2068       st->prefilter_gain_old = st->prefilter_gain;
2069       st->prefilter_tapset_old = st->prefilter_tapset;
2070    }
2071 #endif
2072
2073    if (CC==2&&C==1) {
2074       for (i=0;i<nbEBands;i++)
2075          oldBandE[nbEBands+i]=oldBandE[i];
2076    }
2077
2078    if (!isTransient)
2079    {
2080       for (i=0;i<CC*nbEBands;i++)
2081          oldLogE2[i] = oldLogE[i];
2082       for (i=0;i<CC*nbEBands;i++)
2083          oldLogE[i] = oldBandE[i];
2084    } else {
2085       for (i=0;i<CC*nbEBands;i++)
2086          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
2087    }
2088    /* In case start or end were to change */
2089    c=0; do
2090    {
2091       for (i=0;i<st->start;i++)
2092       {
2093          oldBandE[c*nbEBands+i]=0;
2094          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
2095       }
2096       for (i=st->end;i<nbEBands;i++)
2097       {
2098          oldBandE[c*nbEBands+i]=0;
2099          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
2100       }
2101    } while (++c<CC);
2102
2103    if (isTransient)
2104       st->consec_transient++;
2105    else
2106       st->consec_transient=0;
2107    st->rng = enc->rng;
2108
2109    /* If there's any room left (can only happen for very high rates),
2110       it's already filled with zeros */
2111    ec_enc_done(enc);
2112
2113 #ifdef CUSTOM_MODES
2114    if (st->signalling)
2115       nbCompressedBytes++;
2116 #endif
2117
2118    RESTORE_STACK;
2119    if (ec_get_error(enc))
2120       return OPUS_INTERNAL_ERROR;
2121    else
2122       return nbCompressedBytes;
2123 }
2124
2125
2126 #ifdef CUSTOM_MODES
2127
2128 #ifdef FIXED_POINT
2129 int opus_custom_encode(CELTEncoder * OPUS_RESTRICT st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2130 {
2131    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
2132 }
2133
2134 #ifndef DISABLE_FLOAT_API
2135 int opus_custom_encode_float(CELTEncoder * OPUS_RESTRICT st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2136 {
2137    int j, ret, C, N;
2138    VARDECL(opus_int16, in);
2139    ALLOC_STACK;
2140
2141    if (pcm==NULL)
2142       return OPUS_BAD_ARG;
2143
2144    C = st->channels;
2145    N = frame_size;
2146    ALLOC(in, C*N, opus_int16);
2147
2148    for (j=0;j<C*N;j++)
2149      in[j] = FLOAT2INT16(pcm[j]);
2150
2151    ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
2152 #ifdef RESYNTH
2153    for (j=0;j<C*N;j++)
2154       ((float*)pcm)[j]=in[j]*(1.f/32768.f);
2155 #endif
2156    RESTORE_STACK;
2157    return ret;
2158 }
2159 #endif /* DISABLE_FLOAT_API */
2160 #else
2161
2162 int opus_custom_encode(CELTEncoder * OPUS_RESTRICT st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2163 {
2164    int j, ret, C, N;
2165    VARDECL(celt_sig, in);
2166    ALLOC_STACK;
2167
2168    if (pcm==NULL)
2169       return OPUS_BAD_ARG;
2170
2171    C=st->channels;
2172    N=frame_size;
2173    ALLOC(in, C*N, celt_sig);
2174    for (j=0;j<C*N;j++) {
2175      in[j] = SCALEOUT(pcm[j]);
2176    }
2177
2178    ret = celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
2179 #ifdef RESYNTH
2180    for (j=0;j<C*N;j++)
2181       ((opus_int16*)pcm)[j] = FLOAT2INT16(in[j]);
2182 #endif
2183    RESTORE_STACK;
2184    return ret;
2185 }
2186
2187 int opus_custom_encode_float(CELTEncoder * OPUS_RESTRICT st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
2188 {
2189    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
2190 }
2191
2192 #endif
2193
2194 #endif /* CUSTOM_MODES */
2195
2196 int opus_custom_encoder_ctl(CELTEncoder * OPUS_RESTRICT st, int request, ...)
2197 {
2198    va_list ap;
2199
2200    va_start(ap, request);
2201    switch (request)
2202    {
2203       case OPUS_SET_COMPLEXITY_REQUEST:
2204       {
2205          int value = va_arg(ap, opus_int32);
2206          if (value<0 || value>10)
2207             goto bad_arg;
2208          st->complexity = value;
2209       }
2210       break;
2211       case CELT_SET_START_BAND_REQUEST:
2212       {
2213          opus_int32 value = va_arg(ap, opus_int32);
2214          if (value<0 || value>=st->mode->nbEBands)
2215             goto bad_arg;
2216          st->start = value;
2217       }
2218       break;
2219       case CELT_SET_END_BAND_REQUEST:
2220       {
2221          opus_int32 value = va_arg(ap, opus_int32);
2222          if (value<1 || value>st->mode->nbEBands)
2223             goto bad_arg;
2224          st->end = value;
2225       }
2226       break;
2227       case CELT_SET_PREDICTION_REQUEST:
2228       {
2229          int value = va_arg(ap, opus_int32);
2230          if (value<0 || value>2)
2231             goto bad_arg;
2232          st->disable_pf = value<=1;
2233          st->force_intra = value==0;
2234       }
2235       break;
2236       case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
2237       {
2238          int value = va_arg(ap, opus_int32);
2239          if (value<0 || value>100)
2240             goto bad_arg;
2241          st->loss_rate = value;
2242       }
2243       break;
2244       case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2245       {
2246          opus_int32 value = va_arg(ap, opus_int32);
2247          st->constrained_vbr = value;
2248       }
2249       break;
2250       case OPUS_SET_VBR_REQUEST:
2251       {
2252          opus_int32 value = va_arg(ap, opus_int32);
2253          st->vbr = value;
2254       }
2255       break;
2256       case OPUS_SET_BITRATE_REQUEST:
2257       {
2258          opus_int32 value = va_arg(ap, opus_int32);
2259          if (value<=500 && value!=OPUS_BITRATE_MAX)
2260             goto bad_arg;
2261          value = IMIN(value, 260000*st->channels);
2262          st->bitrate = value;
2263       }
2264       break;
2265       case CELT_SET_CHANNELS_REQUEST:
2266       {
2267          opus_int32 value = va_arg(ap, opus_int32);
2268          if (value<1 || value>2)
2269             goto bad_arg;
2270          st->stream_channels = value;
2271       }
2272       break;
2273       case OPUS_SET_LSB_DEPTH_REQUEST:
2274       {
2275           opus_int32 value = va_arg(ap, opus_int32);
2276           if (value<8 || value>24)
2277              goto bad_arg;
2278           st->lsb_depth=value;
2279       }
2280       break;
2281       case OPUS_GET_LSB_DEPTH_REQUEST:
2282       {
2283           opus_int32 *value = va_arg(ap, opus_int32*);
2284           *value=st->lsb_depth;
2285       }
2286       break;
2287       case OPUS_RESET_STATE:
2288       {
2289          int i;
2290          opus_val16 *oldBandE, *oldLogE, *oldLogE2;
2291          oldBandE = (opus_val16*)(st->in_mem+st->channels*(st->overlap+COMBFILTER_MAXPERIOD));
2292          oldLogE = oldBandE + st->channels*st->mode->nbEBands;
2293          oldLogE2 = oldLogE + st->channels*st->mode->nbEBands;
2294          OPUS_CLEAR((char*)&st->ENCODER_RESET_START,
2295                opus_custom_encoder_get_size(st->mode, st->channels)-
2296                ((char*)&st->ENCODER_RESET_START - (char*)st));
2297          for (i=0;i<st->channels*st->mode->nbEBands;i++)
2298             oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT);
2299          st->vbr_offset = 0;
2300          st->delayedIntra = 1;
2301          st->spread_decision = SPREAD_NORMAL;
2302          st->tonal_average = 256;
2303          st->hf_average = 0;
2304          st->tapset_decision = 0;
2305       }
2306       break;
2307 #ifdef CUSTOM_MODES
2308       case CELT_SET_INPUT_CLIPPING_REQUEST:
2309       {
2310          opus_int32 value = va_arg(ap, opus_int32);
2311          st->clip = value;
2312       }
2313       break;
2314 #endif
2315       case CELT_SET_SIGNALLING_REQUEST:
2316       {
2317          opus_int32 value = va_arg(ap, opus_int32);
2318          st->signalling = value;
2319       }
2320       break;
2321       case CELT_SET_ANALYSIS_REQUEST:
2322       {
2323          AnalysisInfo *info = va_arg(ap, AnalysisInfo *);
2324          if (info)
2325             OPUS_COPY(&st->analysis, info, 1);
2326       }
2327       break;
2328       case CELT_GET_MODE_REQUEST:
2329       {
2330          const CELTMode ** value = va_arg(ap, const CELTMode**);
2331          if (value==0)
2332             goto bad_arg;
2333          *value=st->mode;
2334       }
2335       break;
2336       case OPUS_GET_FINAL_RANGE_REQUEST:
2337       {
2338          opus_uint32 * value = va_arg(ap, opus_uint32 *);
2339          if (value==0)
2340             goto bad_arg;
2341          *value=st->rng;
2342       }
2343       break;
2344       default:
2345          goto bad_request;
2346    }
2347    va_end(ap);
2348    return OPUS_OK;
2349 bad_arg:
2350    va_end(ap);
2351    return OPUS_BAD_ARG;
2352 bad_request:
2353    va_end(ap);
2354    return OPUS_UNIMPLEMENTED;
2355 }
2356
2357 /**********************************************************************/
2358 /*                                                                    */
2359 /*                             DECODER                                */
2360 /*                                                                    */
2361 /**********************************************************************/
2362 #define DECODE_BUFFER_SIZE 2048
2363
2364 /** Decoder state
2365  @brief Decoder state
2366  */
2367 struct OpusCustomDecoder {
2368    const OpusCustomMode *mode;
2369    int overlap;
2370    int channels;
2371    int stream_channels;
2372
2373    int downsample;
2374    int start, end;
2375    int signalling;
2376
2377    /* Everything beyond this point gets cleared on a reset */
2378 #define DECODER_RESET_START rng
2379
2380    opus_uint32 rng;
2381    int error;
2382    int last_pitch_index;
2383    int loss_count;
2384    int postfilter_period;
2385    int postfilter_period_old;
2386    opus_val16 postfilter_gain;
2387    opus_val16 postfilter_gain_old;
2388    int postfilter_tapset;
2389    int postfilter_tapset_old;
2390
2391    celt_sig preemph_memD[2];
2392
2393    celt_sig _decode_mem[1]; /* Size = channels*(DECODE_BUFFER_SIZE+mode->overlap) */
2394    /* opus_val16 lpc[],  Size = channels*LPC_ORDER */
2395    /* opus_val16 oldEBands[], Size = 2*mode->nbEBands */
2396    /* opus_val16 oldLogE[], Size = 2*mode->nbEBands */
2397    /* opus_val16 oldLogE2[], Size = 2*mode->nbEBands */
2398    /* opus_val16 backgroundLogE[], Size = 2*mode->nbEBands */
2399 };
2400
2401 int celt_decoder_get_size(int channels)
2402 {
2403    const CELTMode *mode = opus_custom_mode_create(48000, 960, NULL);
2404    return opus_custom_decoder_get_size(mode, channels);
2405 }
2406
2407 OPUS_CUSTOM_NOSTATIC int opus_custom_decoder_get_size(const CELTMode *mode, int channels)
2408 {
2409    int size = sizeof(struct CELTDecoder)
2410             + (channels*(DECODE_BUFFER_SIZE+mode->overlap)-1)*sizeof(celt_sig)
2411             + channels*LPC_ORDER*sizeof(opus_val16)
2412             + 4*2*mode->nbEBands*sizeof(opus_val16);
2413    return size;
2414 }
2415
2416 #ifdef CUSTOM_MODES
2417 CELTDecoder *opus_custom_decoder_create(const CELTMode *mode, int channels, int *error)
2418 {
2419    int ret;
2420    CELTDecoder *st = (CELTDecoder *)opus_alloc(opus_custom_decoder_get_size(mode, channels));
2421    ret = opus_custom_decoder_init(st, mode, channels);
2422    if (ret != OPUS_OK)
2423    {
2424       opus_custom_decoder_destroy(st);
2425       st = NULL;
2426    }
2427    if (error)
2428       *error = ret;
2429    return st;
2430 }
2431 #endif /* CUSTOM_MODES */
2432
2433 int celt_decoder_init(CELTDecoder *st, opus_int32 sampling_rate, int channels)
2434 {
2435    int ret;
2436    ret = opus_custom_decoder_init(st, opus_custom_mode_create(48000, 960, NULL), channels);
2437    if (ret != OPUS_OK)
2438       return ret;
2439    st->downsample = resampling_factor(sampling_rate);
2440    if (st->downsample==0)
2441       return OPUS_BAD_ARG;
2442    else
2443       return OPUS_OK;
2444 }
2445
2446 OPUS_CUSTOM_NOSTATIC int opus_custom_decoder_init(CELTDecoder *st, const CELTMode *mode, int channels)
2447 {
2448    if (channels < 0 || channels > 2)
2449       return OPUS_BAD_ARG;
2450
2451    if (st==NULL)
2452       return OPUS_ALLOC_FAIL;
2453
2454    OPUS_CLEAR((char*)st, opus_custom_decoder_get_size(mode, channels));
2455
2456    st->mode = mode;
2457    st->overlap = mode->overlap;
2458    st->stream_channels = st->channels = channels;
2459
2460    st->downsample = 1;
2461    st->start = 0;
2462    st->end = st->mode->effEBands;
2463    st->signalling = 1;
2464
2465    st->loss_count = 0;
2466
2467    opus_custom_decoder_ctl(st, OPUS_RESET_STATE);
2468
2469    return OPUS_OK;
2470 }
2471
2472 #ifdef CUSTOM_MODES
2473 void opus_custom_decoder_destroy(CELTDecoder *st)
2474 {
2475    opus_free(st);
2476 }
2477 #endif /* CUSTOM_MODES */
2478
2479 static void celt_decode_lost(CELTDecoder * OPUS_RESTRICT st, opus_val16 * OPUS_RESTRICT pcm, int N, int LM)
2480 {
2481    int c;
2482    int pitch_index;
2483    opus_val16 fade = Q15ONE;
2484    int i, len;
2485    const int C = st->channels;
2486    int offset;
2487    celt_sig *out_mem[2];
2488    celt_sig *decode_mem[2];
2489    celt_sig *overlap_mem[2];
2490    opus_val16 *lpc;
2491    opus_val32 *out_syn[2];
2492    opus_val16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE;
2493    const OpusCustomMode *mode;
2494    int nbEBands;
2495    int overlap;
2496    const opus_int16 *eBands;
2497    VARDECL(celt_sig, scratch);
2498    SAVE_STACK;
2499
2500    mode = st->mode;
2501    nbEBands = mode->nbEBands;
2502    overlap = mode->overlap;
2503    eBands = mode->eBands;
2504
2505    c=0; do {
2506       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
2507       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
2508       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
2509    } while (++c<C);
2510    lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*C);
2511    oldBandE = lpc+C*LPC_ORDER;
2512    oldLogE = oldBandE + 2*nbEBands;
2513    oldLogE2 = oldLogE + 2*nbEBands;
2514    backgroundLogE = oldLogE2  + 2*nbEBands;
2515
2516    out_syn[0] = out_mem[0]+MAX_PERIOD-N;
2517    if (C==2)
2518       out_syn[1] = out_mem[1]+MAX_PERIOD-N;
2519
2520    len = N+overlap;
2521
2522    if (st->loss_count >= 5 || st->start!=0)
2523    {
2524       /* Noise-based PLC/CNG */
2525       VARDECL(celt_sig, freq);
2526       VARDECL(celt_norm, X);
2527       VARDECL(celt_ener, bandE);
2528       opus_uint32 seed;
2529       int effEnd;
2530
2531       effEnd = st->end;
2532       if (effEnd > mode->effEBands)
2533          effEnd = mode->effEBands;
2534
2535       ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
2536       ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
2537       ALLOC(bandE, nbEBands*C, celt_ener);
2538
2539       if (st->loss_count >= 5)
2540          log2Amp(mode, st->start, st->end, bandE, backgroundLogE, C);
2541       else {
2542          /* Energy decay */
2543          opus_val16 decay = st->loss_count==0 ? QCONST16(1.5f, DB_SHIFT) : QCONST16(.5f, DB_SHIFT);
2544          c=0; do
2545          {
2546             for (i=st->start;i<st->end;i++)
2547                oldBandE[c*nbEBands+i] -= decay;
2548          } while (++c<C);
2549          log2Amp(mode, st->start, st->end, bandE, oldBandE, C);
2550       }
2551       seed = st->rng;
2552       for (c=0;c<C;c++)
2553       {
2554          for (i=0;i<(eBands[st->start]<<LM);i++)
2555             X[c*N+i] = 0;
2556          for (i=st->start;i<mode->effEBands;i++)
2557          {
2558             int j;
2559             int boffs;
2560             int blen;
2561             boffs = N*c+(eBands[i]<<LM);
2562             blen = (eBands[i+1]-eBands[i])<<LM;
2563             for (j=0;j<blen;j++)
2564             {
2565                seed = celt_lcg_rand(seed);
2566                X[boffs+j] = (celt_norm)((opus_int32)seed>>20);
2567             }
2568             renormalise_vector(X+boffs, blen, Q15ONE);
2569          }
2570          for (i=(eBands[st->end]<<LM);i<N;i++)
2571             X[c*N+i] = 0;
2572       }
2573       st->rng = seed;
2574
2575       denormalise_bands(mode, X, freq, bandE, mode->effEBands, C, 1<<LM);
2576
2577       c=0; do
2578          for (i=0;i<eBands[st->start]<<LM;i++)
2579             freq[c*N+i] = 0;
2580       while (++c<C);
2581       c=0; do {
2582          int bound = eBands[effEnd]<<LM;
2583          if (st->downsample!=1)
2584             bound = IMIN(bound, N/st->downsample);
2585          for (i=bound;i<N;i++)
2586             freq[c*N+i] = 0;
2587       } while (++c<C);
2588       compute_inv_mdcts(mode, 0, freq, out_syn, overlap_mem, C, LM);
2589    } else {
2590       /* Pitch-based PLC */
2591       VARDECL(opus_val32, e);
2592
2593       if (st->loss_count == 0)
2594       {
2595          opus_val16 pitch_buf[DECODE_BUFFER_SIZE>>1];
2596          /* Corresponds to a min pitch of 67 Hz. It's possible to save CPU in this
2597          search by using only part of the decode buffer */
2598          int poffset = 720;
2599          pitch_downsample(decode_mem, pitch_buf, DECODE_BUFFER_SIZE, C);
2600          /* Max pitch is 100 samples (480 Hz) */
2601          pitch_search(pitch_buf+((poffset)>>1), pitch_buf, DECODE_BUFFER_SIZE-poffset,
2602                poffset-100, &pitch_index);
2603          pitch_index = poffset-pitch_index;
2604          st->last_pitch_index = pitch_index;
2605       } else {
2606          pitch_index = st->last_pitch_index;
2607          fade = QCONST16(.8f,15);
2608       }
2609
2610       ALLOC(e, MAX_PERIOD+2*overlap, opus_val32);
2611       c=0; do {
2612          opus_val16 exc[MAX_PERIOD];
2613          opus_val32 ac[LPC_ORDER+1];
2614          opus_val16 decay = 1;
2615          opus_val32 S1=0;
2616          opus_val16 mem[LPC_ORDER]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
2617
2618          offset = MAX_PERIOD-pitch_index;
2619          for (i=0;i<MAX_PERIOD;i++)
2620             exc[i] = ROUND16(out_mem[c][i], SIG_SHIFT);
2621
2622          if (st->loss_count == 0)
2623          {
2624             _celt_autocorr(exc, ac, mode->window, overlap,
2625                   LPC_ORDER, MAX_PERIOD);
2626
2627             /* Noise floor -40 dB */
2628 #ifdef FIXED_POINT
2629             ac[0] += SHR32(ac[0],13);
2630 #else
2631             ac[0] *= 1.0001f;
2632 #endif
2633             /* Lag windowing */
2634             for (i=1;i<=LPC_ORDER;i++)
2635             {
2636                /*ac[i] *= exp(-.5*(2*M_PI*.002*i)*(2*M_PI*.002*i));*/
2637 #ifdef FIXED_POINT
2638                ac[i] -= MULT16_32_Q15(2*i*i, ac[i]);
2639 #else
2640                ac[i] -= ac[i]*(.008f*i)*(.008f*i);
2641 #endif
2642             }
2643
2644             _celt_lpc(lpc+c*LPC_ORDER, ac, LPC_ORDER);
2645          }
2646          for (i=0;i<LPC_ORDER;i++)
2647             mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT);
2648          celt_fir(exc, lpc+c*LPC_ORDER, exc, MAX_PERIOD, LPC_ORDER, mem);
2649          /*for (i=0;i<MAX_PERIOD;i++)printf("%d ", exc[i]); printf("\n");*/
2650          /* Check if the waveform is decaying (and if so how fast) */
2651          {
2652             opus_val32 E1=1, E2=1;
2653             int period;
2654             if (pitch_index <= MAX_PERIOD/2)
2655                period = pitch_index;
2656             else
2657                period = MAX_PERIOD/2;
2658             for (i=0;i<period;i++)
2659             {
2660                E1 += SHR32(MULT16_16(exc[MAX_PERIOD-period+i],exc[MAX_PERIOD-period+i]),8);
2661                E2 += SHR32(MULT16_16(exc[MAX_PERIOD-2*period+i],exc[MAX_PERIOD-2*period+i]),8);
2662             }
2663             if (E1 > E2)
2664                E1 = E2;
2665             decay = celt_sqrt(frac_div32(SHR32(E1,1),E2));
2666          }
2667
2668          /* Copy excitation, taking decay into account */
2669          for (i=0;i<len+overlap;i++)
2670          {
2671             opus_val16 tmp;
2672             if (offset+i >= MAX_PERIOD)
2673             {
2674                offset -= pitch_index;
2675                decay = MULT16_16_Q15(decay, decay);
2676             }
2677             e[i] = SHL32(EXTEND32(MULT16_16_Q15(decay, exc[offset+i])), SIG_SHIFT);
2678             tmp = ROUND16(out_mem[c][offset+i],SIG_SHIFT);
2679             S1 += SHR32(MULT16_16(tmp,tmp),8);
2680          }
2681          for (i=0;i<LPC_ORDER;i++)
2682             mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT);
2683          for (i=0;i<len+overlap;i++)
2684             e[i] = MULT16_32_Q15(fade, e[i]);
2685          celt_iir(e, lpc+c*LPC_ORDER, e, len+overlap, LPC_ORDER, mem);
2686
2687          {
2688             opus_val32 S2=0;
2689             for (i=0;i<len+overlap;i++)
2690             {
2691                opus_val16 tmp = ROUND16(e[i],SIG_SHIFT);
2692                S2 += SHR32(MULT16_16(tmp,tmp),8);
2693             }
2694             /* This checks for an "explosion" in the synthesis */
2695 #ifdef FIXED_POINT
2696             if (!(S1 > SHR32(S2,2)))
2697 #else
2698                /* Float test is written this way to catch NaNs at the same time */
2699                if (!(S1 > 0.2f*S2))
2700 #endif
2701                {
2702                   for (i=0;i<len+overlap;i++)
2703                      e[i] = 0;
2704                } else if (S1 < S2)
2705                {
2706                   opus_val16 ratio = celt_sqrt(frac_div32(SHR32(S1,1)+1,S2+1));
2707                   for (i=0;i<len+overlap;i++)
2708                      e[i] = MULT16_32_Q15(ratio, e[i]);
2709                }
2710          }
2711
2712          /* Apply post-filter to the MDCT overlap of the previous frame */
2713          comb_filter(out_mem[c]+MAX_PERIOD, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap,
2714                st->postfilter_gain, st->postfilter_gain, st->postfilter_tapset, st->postfilter_tapset,
2715                NULL, 0);
2716
2717          for (i=0;i<MAX_PERIOD+overlap-N;i++)
2718             out_mem[c][i] = out_mem[c][N+i];
2719
2720          /* Apply TDAC to the concealed audio so that it blends with the
2721          previous and next frames */
2722          for (i=0;i<overlap/2;i++)
2723          {
2724             opus_val32 tmp;
2725             tmp = MULT16_32_Q15(mode->window[i],           e[N+overlap-1-i]) +
2726                   MULT16_32_Q15(mode->window[overlap-i-1], e[N+i          ]);
2727             out_mem[c][MAX_PERIOD+i] = MULT16_32_Q15(mode->window[overlap-i-1], tmp);
2728             out_mem[c][MAX_PERIOD+overlap-i-1] = MULT16_32_Q15(mode->window[i], tmp);
2729          }
2730          for (i=0;i<N;i++)
2731             out_mem[c][MAX_PERIOD-N+i] = e[i];
2732
2733          /* Apply pre-filter to the MDCT overlap for the next frame (post-filter will be applied then) */
2734          comb_filter(e, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap,
2735                -st->postfilter_gain, -st->postfilter_gain, st->postfilter_tapset, st->postfilter_tapset,
2736                NULL, 0);
2737          for (i=0;i<overlap;i++)
2738             out_mem[c][MAX_PERIOD+i] = e[i];
2739       } while (++c<C);
2740    }
2741
2742    ALLOC(scratch, N, celt_sig);
2743    deemphasis(out_syn, pcm, N, C, st->downsample, mode->preemph, st->preemph_memD, scratch);
2744
2745    st->loss_count++;
2746
2747    RESTORE_STACK;
2748 }
2749
2750 int celt_decode_with_ec(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, opus_val16 * OPUS_RESTRICT pcm, int frame_size, ec_dec *dec)
2751 {
2752    int c, i, N;
2753    int spread_decision;
2754    opus_int32 bits;
2755    ec_dec _dec;
2756    VARDECL(celt_sig, freq);
2757    VARDECL(celt_norm, X);
2758    VARDECL(celt_ener, bandE);
2759    VARDECL(int, fine_quant);
2760    VARDECL(int, pulses);
2761    VARDECL(int, cap);
2762    VARDECL(int, offsets);
2763    VARDECL(int, fine_priority);
2764    VARDECL(int, tf_res);
2765    VARDECL(unsigned char, collapse_masks);
2766    celt_sig *out_mem[2];
2767    celt_sig *decode_mem[2];
2768    celt_sig *overlap_mem[2];
2769    celt_sig *out_syn[2];
2770    opus_val16 *lpc;
2771    opus_val16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE;
2772
2773    int shortBlocks;
2774    int isTransient;
2775    int intra_ener;
2776    const int CC = st->channels;
2777    int LM, M;
2778    int effEnd;
2779    int codedBands;
2780    int alloc_trim;
2781    int postfilter_pitch;
2782    opus_val16 postfilter_gain;
2783    int intensity=0;
2784    int dual_stereo=0;
2785    opus_int32 total_bits;
2786    opus_int32 balance;
2787    opus_int32 tell;
2788    int dynalloc_logp;
2789    int postfilter_tapset;
2790    int anti_collapse_rsv;
2791    int anti_collapse_on=0;
2792    int silence;
2793    int C = st->stream_channels;
2794    const OpusCustomMode *mode;
2795    int nbEBands;
2796    int overlap;
2797    const opus_int16 *eBands;
2798    ALLOC_STACK;
2799
2800    mode = st->mode;
2801    nbEBands = mode->nbEBands;
2802    overlap = mode->overlap;
2803    eBands = mode->eBands;
2804    frame_size *= st->downsample;
2805
2806    c=0; do {
2807       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+overlap);
2808       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
2809       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
2810    } while (++c<CC);
2811    lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+overlap)*CC);
2812    oldBandE = lpc+CC*LPC_ORDER;
2813    oldLogE = oldBandE + 2*nbEBands;
2814    oldLogE2 = oldLogE + 2*nbEBands;
2815    backgroundLogE = oldLogE2  + 2*nbEBands;
2816
2817 #ifdef CUSTOM_MODES
2818    if (st->signalling && data!=NULL)
2819    {
2820       int data0=data[0];
2821       /* Convert "standard mode" to Opus header */
2822       if (mode->Fs==48000 && mode->shortMdctSize==120)
2823       {
2824          data0 = fromOpus(data0);
2825          if (data0<0)
2826             return OPUS_INVALID_PACKET;
2827       }
2828       st->end = IMAX(1, mode->effEBands-2*(data0>>5));
2829       LM = (data0>>3)&0x3;
2830       C = 1 + ((data0>>2)&0x1);
2831       data++;
2832       len--;
2833       if (LM>mode->maxLM)
2834          return OPUS_INVALID_PACKET;
2835       if (frame_size < mode->shortMdctSize<<LM)
2836          return OPUS_BUFFER_TOO_SMALL;
2837       else
2838          frame_size = mode->shortMdctSize<<LM;
2839    } else {
2840 #else
2841    {
2842 #endif
2843       for (LM=0;LM<=mode->maxLM;LM++)
2844          if (mode->shortMdctSize<<LM==frame_size)
2845             break;
2846       if (LM>mode->maxLM)
2847          return OPUS_BAD_ARG;
2848    }
2849    M=1<<LM;
2850
2851    if (len<0 || len>1275 || pcm==NULL)
2852       return OPUS_BAD_ARG;
2853
2854    N = M*mode->shortMdctSize;
2855
2856    effEnd = st->end;
2857    if (effEnd > mode->effEBands)
2858       effEnd = mode->effEBands;
2859
2860    if (data == NULL || len<=1)
2861    {
2862       celt_decode_lost(st, pcm, N, LM);
2863       RESTORE_STACK;
2864       return frame_size/st->downsample;
2865    }
2866
2867    ALLOC(freq, IMAX(CC,C)*N, celt_sig); /**< Interleaved signal MDCTs */
2868    ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
2869    ALLOC(bandE, nbEBands*C, celt_ener);
2870    c=0; do
2871       for (i=0;i<M*eBands[st->start];i++)
2872          X[c*N+i] = 0;
2873    while (++c<C);
2874    c=0; do
2875       for (i=M*eBands[effEnd];i<N;i++)
2876          X[c*N+i] = 0;
2877    while (++c<C);
2878
2879    if (dec == NULL)
2880    {
2881       ec_dec_init(&_dec,(unsigned char*)data,len);
2882       dec = &_dec;
2883    }
2884
2885    if (C==1)
2886    {
2887       for (i=0;i<nbEBands;i++)
2888          oldBandE[i]=MAX16(oldBandE[i],oldBandE[nbEBands+i]);
2889    }
2890
2891    total_bits = len*8;
2892    tell = ec_tell(dec);
2893
2894    if (tell >= total_bits)
2895       silence = 1;
2896    else if (tell==1)
2897       silence = ec_dec_bit_logp(dec, 15);
2898    else
2899       silence = 0;
2900    if (silence)
2901    {
2902       /* Pretend we've read all the remaining bits */
2903       tell = len*8;
2904       dec->nbits_total+=tell-ec_tell(dec);
2905    }
2906
2907    postfilter_gain = 0;
2908    postfilter_pitch = 0;
2909    postfilter_tapset = 0;
2910    if (st->start==0 && tell+16 <= total_bits)
2911    {
2912       if(ec_dec_bit_logp(dec, 1))
2913       {
2914          int qg, octave;
2915          octave = ec_dec_uint(dec, 6);
2916          postfilter_pitch = (16<<octave)+ec_dec_bits(dec, 4+octave)-1;
2917          qg = ec_dec_bits(dec, 3);
2918          if (ec_tell(dec)+2<=total_bits)
2919             postfilter_tapset = ec_dec_icdf(dec, tapset_icdf, 2);
2920          postfilter_gain = QCONST16(.09375f,15)*(qg+1);
2921       }
2922       tell = ec_tell(dec);
2923    }
2924
2925    if (LM > 0 && tell+3 <= total_bits)
2926    {
2927       isTransient = ec_dec_bit_logp(dec, 3);
2928       tell = ec_tell(dec);
2929    }
2930    else
2931       isTransient = 0;
2932
2933    if (isTransient)
2934       shortBlocks = M;
2935    else
2936       shortBlocks = 0;
2937
2938    /* Decode the global flags (first symbols in the stream) */
2939    intra_ener = tell+3<=total_bits ? ec_dec_bit_logp(dec, 3) : 0;
2940    /* Get band energies */
2941    unquant_coarse_energy(mode, st->start, st->end, oldBandE,
2942          intra_ener, dec, C, LM);
2943
2944    ALLOC(tf_res, nbEBands, int);
2945    tf_decode(st->start, st->end, isTransient, tf_res, LM, dec);
2946
2947    tell = ec_tell(dec);
2948    spread_decision = SPREAD_NORMAL;
2949    if (tell+4 <= total_bits)
2950       spread_decision = ec_dec_icdf(dec, spread_icdf, 5);
2951
2952    ALLOC(pulses, nbEBands, int);
2953    ALLOC(cap, nbEBands, int);
2954    ALLOC(offsets, nbEBands, int);
2955    ALLOC(fine_priority, nbEBands, int);
2956
2957    init_caps(mode,cap,LM,C);
2958
2959    dynalloc_logp = 6;
2960    total_bits<<=BITRES;
2961    tell = ec_tell_frac(dec);
2962    for (i=st->start;i<st->end;i++)
2963    {
2964       int width, quanta;
2965       int dynalloc_loop_logp;
2966       int boost;
2967       width = C*(eBands[i+1]-eBands[i])<<LM;
2968       /* quanta is 6 bits, but no more than 1 bit/sample
2969          and no less than 1/8 bit/sample */
2970       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
2971       dynalloc_loop_logp = dynalloc_logp;
2972       boost = 0;
2973       while (tell+(dynalloc_loop_logp<<BITRES) < total_bits && boost < cap[i])
2974       {
2975          int flag;
2976          flag = ec_dec_bit_logp(dec, dynalloc_loop_logp);
2977          tell = ec_tell_frac(dec);
2978          if (!flag)
2979             break;
2980          boost += quanta;
2981          total_bits -= quanta;
2982          dynalloc_loop_logp = 1;
2983       }
2984       offsets[i] = boost;
2985       /* Making dynalloc more likely */
2986       if (boost>0)
2987          dynalloc_logp = IMAX(2, dynalloc_logp-1);
2988    }
2989
2990    ALLOC(fine_quant, nbEBands, int);
2991    alloc_trim = tell+(6<<BITRES) <= total_bits ?
2992          ec_dec_icdf(dec, trim_icdf, 7) : 5;
2993
2994    bits = (((opus_int32)len*8)<<BITRES) - ec_tell_frac(dec) - 1;
2995    anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0;
2996    bits -= anti_collapse_rsv;
2997    codedBands = compute_allocation(mode, st->start, st->end, offsets, cap,
2998          alloc_trim, &intensity, &dual_stereo, bits, &balance, pulses,
2999          fine_quant, fine_priority, C, LM, dec, 0, 0);
3000
3001    unquant_fine_energy(mode, st->start, st->end, oldBandE, fine_quant, dec, C);
3002
3003    /* Decode fixed codebook */
3004    ALLOC(collapse_masks, C*nbEBands, unsigned char);
3005    quant_all_bands(0, mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
3006          NULL, pulses, shortBlocks, spread_decision, dual_stereo, intensity, tf_res,
3007          len*(8<<BITRES)-anti_collapse_rsv, balance, dec, LM, codedBands, &st->rng);
3008
3009    if (anti_collapse_rsv > 0)
3010    {
3011       anti_collapse_on = ec_dec_bits(dec, 1);
3012    }
3013
3014    unquant_energy_finalise(mode, st->start, st->end, oldBandE,
3015          fine_quant, fine_priority, len*8-ec_tell(dec), dec, C);
3016
3017    if (anti_collapse_on)
3018       anti_collapse(mode, X, collapse_masks, LM, C, N,
3019             st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
3020
3021    log2Amp(mode, st->start, st->end, bandE, oldBandE, C);
3022
3023    if (silence)
3024    {
3025       for (i=0;i<C*nbEBands;i++)
3026       {
3027          bandE[i] = 0;
3028          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
3029       }
3030    }
3031    /* Synthesis */
3032    denormalise_bands(mode, X, freq, bandE, effEnd, C, M);
3033
3034    OPUS_MOVE(decode_mem[0], decode_mem[0]+N, DECODE_BUFFER_SIZE-N);
3035    if (CC==2)
3036       OPUS_MOVE(decode_mem[1], decode_mem[1]+N, DECODE_BUFFER_SIZE-N);
3037
3038    c=0; do
3039       for (i=0;i<M*eBands[st->start];i++)
3040          freq[c*N+i] = 0;
3041    while (++c<C);
3042    c=0; do {
3043       int bound = M*eBands[effEnd];
3044       if (st->downsample!=1)
3045          bound = IMIN(bound, N/st->downsample);
3046       for (i=bound;i<N;i++)
3047          freq[c*N+i] = 0;
3048    } while (++c<C);
3049
3050    out_syn[0] = out_mem[0]+MAX_PERIOD-N;
3051    if (CC==2)
3052       out_syn[1] = out_mem[1]+MAX_PERIOD-N;
3053
3054    if (CC==2&&C==1)
3055    {
3056       for (i=0;i<N;i++)
3057          freq[N+i] = freq[i];
3058    }
3059    if (CC==1&&C==2)
3060    {
3061       for (i=0;i<N;i++)
3062          freq[i] = HALF32(ADD32(freq[i],freq[N+i]));
3063    }
3064
3065    /* Compute inverse MDCTs */
3066    compute_inv_mdcts(mode, shortBlocks, freq, out_syn, overlap_mem, CC, LM);
3067
3068    c=0; do {
3069       st->postfilter_period=IMAX(st->postfilter_period, COMBFILTER_MINPERIOD);
3070       st->postfilter_period_old=IMAX(st->postfilter_period_old, COMBFILTER_MINPERIOD);
3071       comb_filter(out_syn[c], out_syn[c], st->postfilter_period_old, st->postfilter_period, mode->shortMdctSize,
3072             st->postfilter_gain_old, st->postfilter_gain, st->postfilter_tapset_old, st->postfilter_tapset,
3073             mode->window, overlap);
3074       if (LM!=0)
3075          comb_filter(out_syn[c]+mode->shortMdctSize, out_syn[c]+mode->shortMdctSize, st->postfilter_period, postfilter_pitch, N-mode->shortMdctSize,
3076                st->postfilter_gain, postfilter_gain, st->postfilter_tapset, postfilter_tapset,
3077                mode->window, overlap);
3078
3079    } while (++c<CC);
3080    st->postfilter_period_old = st->postfilter_period;
3081    st->postfilter_gain_old = st->postfilter_gain;
3082    st->postfilter_tapset_old = st->postfilter_tapset;
3083    st->postfilter_period = postfilter_pitch;
3084    st->postfilter_gain = postfilter_gain;
3085    st->postfilter_tapset = postfilter_tapset;
3086    if (LM!=0)
3087    {
3088       st->postfilter_period_old = st->postfilter_period;
3089       st->postfilter_gain_old = st->postfilter_gain;
3090       st->postfilter_tapset_old = st->postfilter_tapset;
3091    }
3092
3093    if (C==1) {
3094       for (i=0;i<nbEBands;i++)
3095          oldBandE[nbEBands+i]=oldBandE[i];
3096    }
3097
3098    /* In case start or end were to change */
3099    if (!isTransient)
3100    {
3101       for (i=0;i<2*nbEBands;i++)
3102          oldLogE2[i] = oldLogE[i];
3103       for (i=0;i<2*nbEBands;i++)
3104          oldLogE[i] = oldBandE[i];
3105       for (i=0;i<2*nbEBands;i++)
3106          backgroundLogE[i] = MIN16(backgroundLogE[i] + M*QCONST16(0.001f,DB_SHIFT), oldBandE[i]);
3107    } else {
3108       for (i=0;i<2*nbEBands;i++)
3109          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
3110    }
3111    c=0; do
3112    {
3113       for (i=0;i<st->start;i++)
3114       {
3115          oldBandE[c*nbEBands+i]=0;
3116          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
3117       }
3118       for (i=st->end;i<nbEBands;i++)
3119       {
3120          oldBandE[c*nbEBands+i]=0;
3121          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
3122       }
3123    } while (++c<2);
3124    st->rng = dec->rng;
3125
3126    /* We reuse freq[] as scratch space for the de-emphasis */
3127    deemphasis(out_syn, pcm, N, CC, st->downsample, mode->preemph, st->preemph_memD, freq);
3128    st->loss_count = 0;
3129    RESTORE_STACK;
3130    if (ec_tell(dec) > 8*len)
3131       return OPUS_INTERNAL_ERROR;
3132    if(ec_get_error(dec))
3133       st->error = 1;
3134    return frame_size/st->downsample;
3135 }
3136
3137
3138 #ifdef CUSTOM_MODES
3139
3140 #ifdef FIXED_POINT
3141 int opus_custom_decode(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, opus_int16 * OPUS_RESTRICT pcm, int frame_size)
3142 {
3143    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
3144 }
3145
3146 #ifndef DISABLE_FLOAT_API
3147 int opus_custom_decode_float(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, float * OPUS_RESTRICT pcm, int frame_size)
3148 {
3149    int j, ret, C, N;
3150    VARDECL(opus_int16, out);
3151    ALLOC_STACK;
3152
3153    if (pcm==NULL)
3154       return OPUS_BAD_ARG;
3155
3156    C = st->channels;
3157    N = frame_size;
3158
3159    ALLOC(out, C*N, opus_int16);
3160    ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL);
3161    if (ret>0)
3162       for (j=0;j<C*ret;j++)
3163          pcm[j]=out[j]*(1.f/32768.f);
3164
3165    RESTORE_STACK;
3166    return ret;
3167 }
3168 #endif /* DISABLE_FLOAT_API */
3169
3170 #else
3171
3172 int opus_custom_decode_float(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, float * OPUS_RESTRICT pcm, int frame_size)
3173 {
3174    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
3175 }
3176
3177 int opus_custom_decode(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, opus_int16 * OPUS_RESTRICT pcm, int frame_size)
3178 {
3179    int j, ret, C, N;
3180    VARDECL(celt_sig, out);
3181    ALLOC_STACK;
3182
3183    if (pcm==NULL)
3184       return OPUS_BAD_ARG;
3185
3186    C = st->channels;
3187    N = frame_size;
3188    ALLOC(out, C*N, celt_sig);
3189
3190    ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL);
3191
3192    if (ret>0)
3193       for (j=0;j<C*ret;j++)
3194          pcm[j] = FLOAT2INT16 (out[j]);
3195
3196    RESTORE_STACK;
3197    return ret;
3198 }
3199
3200 #endif
3201 #endif /* CUSTOM_MODES */
3202
3203 int opus_custom_decoder_ctl(CELTDecoder * OPUS_RESTRICT st, int request, ...)
3204 {
3205    va_list ap;
3206
3207    va_start(ap, request);
3208    switch (request)
3209    {
3210       case CELT_SET_START_BAND_REQUEST:
3211       {
3212          opus_int32 value = va_arg(ap, opus_int32);
3213          if (value<0 || value>=st->mode->nbEBands)
3214             goto bad_arg;
3215          st->start = value;
3216       }
3217       break;
3218       case CELT_SET_END_BAND_REQUEST:
3219       {
3220          opus_int32 value = va_arg(ap, opus_int32);
3221          if (value<1 || value>st->mode->nbEBands)
3222             goto bad_arg;
3223          st->end = value;
3224       }
3225       break;
3226       case CELT_SET_CHANNELS_REQUEST:
3227       {
3228          opus_int32 value = va_arg(ap, opus_int32);
3229          if (value<1 || value>2)
3230             goto bad_arg;
3231          st->stream_channels = value;
3232       }
3233       break;
3234       case CELT_GET_AND_CLEAR_ERROR_REQUEST:
3235       {
3236          opus_int32 *value = va_arg(ap, opus_int32*);
3237          if (value==NULL)
3238             goto bad_arg;
3239          *value=st->error;
3240          st->error = 0;
3241       }
3242       break;
3243       case OPUS_GET_LOOKAHEAD_REQUEST:
3244       {
3245          opus_int32 *value = va_arg(ap, opus_int32*);
3246          if (value==NULL)
3247             goto bad_arg;
3248          *value = st->overlap/st->downsample;
3249       }
3250       break;
3251       case OPUS_RESET_STATE:
3252       {
3253          int i;
3254          opus_val16 *lpc, *oldBandE, *oldLogE, *oldLogE2;
3255          lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*st->channels);
3256          oldBandE = lpc+st->channels*LPC_ORDER;
3257          oldLogE = oldBandE + 2*st->mode->nbEBands;
3258          oldLogE2 = oldLogE + 2*st->mode->nbEBands;
3259          OPUS_CLEAR((char*)&st->DECODER_RESET_START,
3260                opus_custom_decoder_get_size(st->mode, st->channels)-
3261                ((char*)&st->DECODER_RESET_START - (char*)st));
3262          for (i=0;i<2*st->mode->nbEBands;i++)
3263             oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT);
3264       }
3265       break;
3266       case OPUS_GET_PITCH_REQUEST:
3267       {
3268          opus_int32 *value = va_arg(ap, opus_int32*);
3269          if (value==NULL)
3270             goto bad_arg;
3271          *value = st->postfilter_period;
3272       }
3273       break;
3274 #ifdef OPUS_BUILD
3275       case CELT_GET_MODE_REQUEST:
3276       {
3277          const CELTMode ** value = va_arg(ap, const CELTMode**);
3278          if (value==0)
3279             goto bad_arg;
3280          *value=st->mode;
3281       }
3282       break;
3283       case CELT_SET_SIGNALLING_REQUEST:
3284       {
3285          opus_int32 value = va_arg(ap, opus_int32);
3286          st->signalling = value;
3287       }
3288       break;
3289       case OPUS_GET_FINAL_RANGE_REQUEST:
3290       {
3291          opus_uint32 * value = va_arg(ap, opus_uint32 *);
3292          if (value==0)
3293             goto bad_arg;
3294          *value=st->rng;
3295       }
3296       break;
3297 #endif
3298       default:
3299          goto bad_request;
3300    }
3301    va_end(ap);
3302    return OPUS_OK;
3303 bad_arg:
3304    va_end(ap);
3305    return OPUS_BAD_ARG;
3306 bad_request:
3307       va_end(ap);
3308   return OPUS_UNIMPLEMENTED;
3309 }
3310
3311
3312
3313 const char *opus_strerror(int error)
3314 {
3315    static const char * const error_strings[8] = {
3316       "success",
3317       "invalid argument",
3318       "buffer too small",
3319       "internal error",
3320       "corrupted stream",
3321       "request not implemented",
3322       "invalid state",
3323       "memory allocation failed"
3324    };
3325    if (error > 0 || error < -7)
3326       return "unknown error";
3327    else
3328       return error_strings[-error];
3329 }
3330
3331 const char *opus_get_version_string(void)
3332 {
3333     return "libopus " OPUS_VERSION
3334 #ifdef FIXED_POINT
3335           "-fixed"
3336 #endif
3337 #ifdef FUZZING
3338           "-fuzzing"
3339 #endif
3340           ;
3341 }