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