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