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