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