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