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