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