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