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