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