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