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