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