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