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