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