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