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