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