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