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