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