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