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