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