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