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