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