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