Tonality and pitch tuning
[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    }
1340    if (st->upsample != 1)
1341    {
1342       c=0; do
1343       {
1344          int bound = N/st->upsample;
1345          for (i=0;i<bound;i++)
1346             freq[c*N+i] *= st->upsample;
1347          for (;i<N;i++)
1348             freq[c*N+i] = 0;
1349       } while (++c<C);
1350    }
1351    compute_band_energies(st->mode, freq, bandE, effEnd, C, M);
1352
1353    amp2Log2(st->mode, effEnd, st->end, bandE, bandLogE, C);
1354    /*for (i=0;i<21;i++)
1355       printf("%f ", bandLogE[i]);
1356    printf("\n");*/
1357
1358    ALLOC(bandLogE2, C*st->mode->nbEBands, opus_val16);
1359    if (shortBlocks)
1360    {
1361       VARDECL(celt_sig, freq2);
1362       ALLOC(freq2, C*N, celt_sig);
1363       compute_mdcts(st->mode, 0, in, freq2, CC, LM);
1364       if (CC==2&&C==1)
1365       {
1366          for (i=0;i<N;i++)
1367             freq2[i] = ADD32(HALF32(freq2[i]), HALF32(freq2[N+i]));
1368       }
1369       if (st->upsample != 1)
1370       {
1371          c=0; do
1372          {
1373             int bound = N/st->upsample;
1374             for (i=0;i<bound;i++)
1375                freq2[c*N+i] *= st->upsample;
1376             for (;i<N;i++)
1377                freq2[c*N+i] = 0;
1378          } while (++c<C);
1379       }
1380       ALLOC(bandE2, C*st->mode->nbEBands, opus_val32);
1381       compute_band_energies(st->mode, freq2, bandE2, effEnd, C, M);
1382       amp2Log2(st->mode, effEnd, st->end, bandE2, bandLogE2, C);
1383       for (i=0;i<C*st->mode->nbEBands;i++)
1384          bandLogE2[i] += HALF16(SHL(LM, DB_SHIFT));
1385    } else {
1386       for (i=0;i<C*st->mode->nbEBands;i++)
1387          bandLogE2[i] = bandLogE[i];
1388    }
1389
1390    ALLOC(X, C*N, celt_norm);         /**< Interleaved normalised MDCTs */
1391
1392    /* Band normalisation */
1393    normalise_bands(st->mode, freq, X, bandE, effEnd, C, M);
1394
1395    ALLOC(tf_res, st->mode->nbEBands, int);
1396    tf_select = tf_analysis(st->mode, effEnd, C, isTransient, tf_res, effectiveBytes, X, N, LM, &tf_sum, tf_estimate, tf_chan);
1397    for (i=effEnd;i<st->end;i++)
1398       tf_res[i] = tf_res[effEnd-1];
1399
1400    ALLOC(error, C*st->mode->nbEBands, opus_val16);
1401    quant_coarse_energy(st->mode, st->start, st->end, effEnd, bandLogE,
1402          oldBandE, total_bits, error, enc,
1403          C, LM, nbAvailableBytes, st->force_intra,
1404          &st->delayedIntra, st->complexity >= 4, st->loss_rate);
1405
1406    tf_encode(st->start, st->end, isTransient, tf_res, LM, tf_select, enc);
1407
1408    if (ec_tell(enc)+4<=total_bits)
1409    {
1410       if (shortBlocks || st->complexity < 3 || nbAvailableBytes < 10*C)
1411       {
1412          if (st->complexity == 0)
1413             st->spread_decision = SPREAD_NONE;
1414       } else {
1415          if (st->analysis.valid)
1416          {
1417             static const opus_val16 spread_thresholds[3] = {-QCONST16(.6f, 15), -QCONST16(.2f, 15), -QCONST16(.07f, 15)};
1418             static const opus_val16 spread_histeresis[3] = {QCONST16(.15f, 15), QCONST16(.07f, 15), QCONST16(.02f, 15)};
1419             static const opus_val16 tapset_thresholds[2] = {QCONST16(.0f, 15), QCONST16(.15f, 15)};
1420             static const opus_val16 tapset_histeresis[2] = {QCONST16(.1f, 15), QCONST16(.05f, 15)};
1421             st->spread_decision = hysteresis_decision(-st->analysis.tonality, spread_thresholds, spread_histeresis, 3, st->spread_decision);
1422             st->tapset_decision = hysteresis_decision(st->analysis.tonality_slope, tapset_thresholds, tapset_histeresis, 2, st->tapset_decision);
1423          } else {
1424             st->spread_decision = spreading_decision(st->mode, X,
1425                   &st->tonal_average, st->spread_decision, &st->hf_average,
1426                   &st->tapset_decision, pf_on&&!shortBlocks, effEnd, C, M);
1427          }
1428          /*printf("%d %d\n", st->tapset_decision, st->spread_decision);*/
1429          /*printf("%f %d %f %d\n\n", st->analysis.tonality, st->spread_decision, st->analysis.tonality_slope, st->tapset_decision);*/
1430       }
1431       ec_enc_icdf(enc, st->spread_decision, spread_icdf, 5);
1432    }
1433
1434    ALLOC(cap, st->mode->nbEBands, int);
1435    ALLOC(offsets, st->mode->nbEBands, int);
1436
1437    init_caps(st->mode,cap,LM,C);
1438    for (i=0;i<st->mode->nbEBands;i++)
1439       offsets[i] = 0;
1440    /* Dynamic allocation code */
1441    /* Make sure that dynamic allocation can't make us bust the budget */
1442    if (effectiveBytes > 50 && LM>=1)
1443    {
1444       opus_val16 follower[42]={0};
1445       c=0;do
1446       {
1447          follower[c*st->mode->nbEBands] = bandLogE2[c*st->mode->nbEBands];
1448          for (i=1;i<st->mode->nbEBands;i++)
1449             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]);
1450          for (i=st->end-2;i>=0;i--)
1451             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]));
1452       } while (++c<2);
1453       if (C==2)
1454       {
1455          for (i=st->start;i<st->end;i++)
1456          {
1457             /* Consider 24 dB "cross-talk" */
1458             follower[st->mode->nbEBands+i] = MAX16(follower[st->mode->nbEBands+i], follower[                   i]-QCONST16(4.f,DB_SHIFT));
1459             follower[                   i] = MAX16(follower[                   i], follower[st->mode->nbEBands+i]-QCONST16(4.f,DB_SHIFT));
1460             follower[i] = HALF16(MAX16(0, bandLogE[i]-follower[i]) + MAX16(0, bandLogE[st->mode->nbEBands+i]-follower[st->mode->nbEBands+i]));
1461          }
1462       } else {
1463          for (i=st->start;i<st->end;i++)
1464          {
1465             follower[i] = MAX16(0, bandLogE[i]-follower[i]);
1466          }
1467       }
1468       for (i=st->start;i<st->end;i++)
1469       {
1470          int width;
1471          int boost;
1472
1473          if (i<8)
1474             follower[i] *= 2;
1475          if (i>=12)
1476             follower[i] *= .5;
1477          follower[i] = MIN16(follower[i], QCONST16(4, DB_SHIFT));
1478          width = C*(st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
1479          if (width<6)
1480          {
1481             boost = SHR32(EXTEND32(follower[i]),DB_SHIFT);
1482             tot_boost += boost*width<<BITRES;
1483          } else if (width > 48) {
1484             boost = SHR32(EXTEND32(follower[i])*8,DB_SHIFT);
1485             tot_boost += (boost*width<<BITRES)/8;
1486          } else {
1487             boost = SHR32(EXTEND32(follower[i])*width/6,DB_SHIFT);
1488             tot_boost += boost*6<<BITRES;
1489          }
1490          offsets[i] = boost;
1491       }
1492    }
1493 #ifndef FIXED_POINT
1494    if (0 && st->analysis.valid)
1495    {
1496       if (st->analysis.boost_amount[0]>.2)
1497          offsets[st->analysis.boost_band[0]]+=2;
1498       if (st->analysis.boost_amount[0]>.4)
1499          offsets[st->analysis.boost_band[0]]+=2;
1500       if (st->analysis.boost_amount[1]>.2)
1501          offsets[st->analysis.boost_band[1]]+=2;
1502       if (st->analysis.boost_amount[1]>.4)
1503          offsets[st->analysis.boost_band[1]]+=2;
1504    }
1505 #endif
1506    dynalloc_logp = 6;
1507    total_bits<<=BITRES;
1508    total_boost = 0;
1509    tell = ec_tell_frac(enc);
1510    for (i=st->start;i<st->end;i++)
1511    {
1512       int width, quanta;
1513       int dynalloc_loop_logp;
1514       int boost;
1515       int j;
1516       width = C*(st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
1517       /* quanta is 6 bits, but no more than 1 bit/sample
1518          and no less than 1/8 bit/sample */
1519       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
1520       dynalloc_loop_logp = dynalloc_logp;
1521       boost = 0;
1522       for (j = 0; tell+(dynalloc_loop_logp<<BITRES) < total_bits-total_boost
1523             && boost < cap[i]; j++)
1524       {
1525          int flag;
1526          flag = j<offsets[i];
1527          ec_enc_bit_logp(enc, flag, dynalloc_loop_logp);
1528          tell = ec_tell_frac(enc);
1529          if (!flag)
1530             break;
1531          boost += quanta;
1532          total_boost += quanta;
1533          dynalloc_loop_logp = 1;
1534       }
1535       /* Making dynalloc more likely */
1536       if (j)
1537          dynalloc_logp = IMAX(2, dynalloc_logp-1);
1538       offsets[i] = boost;
1539    }
1540    alloc_trim = 5;
1541    if (tell+(6<<BITRES) <= total_bits - total_boost)
1542    {
1543       alloc_trim = alloc_trim_analysis(st->mode, X, bandLogE,
1544             st->end, LM, C, N, &st->analysis, &stereo_saving, tf_estimate);
1545       ec_enc_icdf(enc, alloc_trim, trim_icdf, 7);
1546       tell = ec_tell_frac(enc);
1547    }
1548
1549    if (C==2)
1550    {
1551       int effectiveRate;
1552
1553       /* Always use MS for 2.5 ms frames until we can do a better analysis */
1554       if (LM!=0)
1555          dual_stereo = stereo_analysis(st->mode, X, LM, N);
1556
1557       /* Account for coarse energy */
1558       effectiveRate = (8*effectiveBytes - 80)>>LM;
1559
1560       /* effectiveRate in kb/s */
1561       effectiveRate = 2*effectiveRate/5;
1562       if (effectiveRate<35)
1563          intensity = 8;
1564       else if (effectiveRate<50)
1565          intensity = 12;
1566       else if (effectiveRate<68)
1567          intensity = 16;
1568       else if (effectiveRate<84)
1569          intensity = 18;
1570       else if (effectiveRate<102)
1571          intensity = 19;
1572       else if (effectiveRate<130)
1573          intensity = 20;
1574       else
1575          intensity = 100;
1576       intensity = IMIN(st->end,IMAX(st->start, intensity));
1577    }
1578
1579    /* Variable bitrate */
1580    if (vbr_rate>0)
1581    {
1582      opus_val16 alpha;
1583      opus_int32 delta;
1584      /* The target rate in 8th bits per frame */
1585      opus_int32 target, new_target;
1586      opus_int32 min_allowed;
1587      int coded_bins;
1588      int coded_bands;
1589      int lm_diff = st->mode->maxLM - LM;
1590      coded_bands = st->lastCodedBands ? st->lastCodedBands : st->mode->nbEBands;
1591      coded_bins = st->mode->eBands[coded_bands]<<LM;
1592      if (C==2)
1593         coded_bins += st->mode->eBands[IMIN(intensity, coded_bands)]<<LM;
1594
1595      /* Don't attempt to use more than 510 kb/s, even for frames smaller than 20 ms.
1596         The CELT allocator will just not be able to use more than that anyway. */
1597      nbCompressedBytes = IMIN(nbCompressedBytes,1275>>(3-LM));
1598      target = vbr_rate - ((40*C+20)<<BITRES);
1599      if (st->constrained_vbr)
1600         target += (st->vbr_offset>>lm_diff);
1601
1602      /*printf("%f %f %f\n", st->analysis.activity, st->analysis.tonality, tf_estimate);*/
1603 #ifndef FIXED_POINT
1604      if (st->analysis.valid && st->analysis.activity<.4)
1605         target -= (coded_bins<<BITRES)*1*(.4-st->analysis.activity);
1606 #endif
1607      if (C==2)
1608         target -= MIN32(target/3, SHR16(MULT16_16(stereo_saving,(st->mode->eBands[intensity]<<LM<<BITRES)),8));
1609      target += (coded_bins<<BITRES)*.05;
1610      target -= (coded_bins<<BITRES)*.13;
1611      target += IMAX(0,tot_boost-100)/2;
1612      target *= .96;
1613
1614 #ifdef FIXED_POINT
1615      new_target = SHL32(MULT16_32_Q15(target, tf_estimate),1);
1616 #else
1617      new_target = target*tf_estimate;
1618 #endif
1619
1620 #ifndef FIXED_POINT
1621      if (st->analysis.valid) {
1622         int tonal_target;
1623         float tonal;
1624         tonal = MAX16(0,st->analysis.tonality-.2);
1625         tonal_target = new_target + (coded_bins<<BITRES)*2.0f*tonal;
1626         if (pitch_change)
1627            tonal_target +=  (coded_bins<<BITRES)*.8;
1628         /*printf("%f %f ", st->analysis.tonality, tonal);*/
1629         new_target = IMAX(tonal_target,new_target);
1630      }
1631 #endif
1632
1633      /* The current offset is removed from the target and the space used
1634         so far is added*/
1635      target=new_target+tell;
1636      /* In VBR mode the frame size must not be reduced so much that it would
1637          result in the encoder running out of bits.
1638         The margin of 2 bytes ensures that none of the bust-prevention logic
1639          in the decoder will have triggered so far. */
1640      min_allowed = ((tell+total_boost+(1<<(BITRES+3))-1)>>(BITRES+3)) + 2 - nbFilledBytes;
1641
1642      nbAvailableBytes = (target+(1<<(BITRES+2)))>>(BITRES+3);
1643      nbAvailableBytes = IMAX(min_allowed,nbAvailableBytes);
1644      nbAvailableBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes) - nbFilledBytes;
1645
1646      /* By how much did we "miss" the target on that frame */
1647      delta = target - vbr_rate;
1648
1649      target=nbAvailableBytes<<(BITRES+3);
1650
1651      /*If the frame is silent we don't adjust our drift, otherwise
1652        the encoder will shoot to very high rates after hitting a
1653        span of silence, but we do allow the bitres to refill.
1654        This means that we'll undershoot our target in CVBR/VBR modes
1655        on files with lots of silence. */
1656      if(silence)
1657      {
1658        nbAvailableBytes = 2;
1659        target = 2*8<<BITRES;
1660        delta = 0;
1661      }
1662
1663      if (st->vbr_count < 970)
1664      {
1665         st->vbr_count++;
1666         alpha = celt_rcp(SHL32(EXTEND32(st->vbr_count+20),16));
1667      } else
1668         alpha = QCONST16(.001f,15);
1669      /* How many bits have we used in excess of what we're allowed */
1670      if (st->constrained_vbr)
1671         st->vbr_reservoir += target - vbr_rate;
1672      /*printf ("%d\n", st->vbr_reservoir);*/
1673
1674      /* Compute the offset we need to apply in order to reach the target */
1675      if (st->constrained_vbr)
1676      {
1677         st->vbr_drift += (opus_int32)MULT16_32_Q15(alpha,(delta*(1<<lm_diff))-st->vbr_offset-st->vbr_drift);
1678         st->vbr_offset = -st->vbr_drift;
1679      }
1680      /*printf ("%d\n", st->vbr_drift);*/
1681
1682      if (st->constrained_vbr && st->vbr_reservoir < 0)
1683      {
1684         /* We're under the min value -- increase rate */
1685         int adjust = (-st->vbr_reservoir)/(8<<BITRES);
1686         /* Unless we're just coding silence */
1687         nbAvailableBytes += silence?0:adjust;
1688         st->vbr_reservoir = 0;
1689         /*printf ("+%d\n", adjust);*/
1690      }
1691      nbCompressedBytes = IMIN(nbCompressedBytes,nbAvailableBytes+nbFilledBytes);
1692      /*printf("%d\n", nbCompressedBytes*50*8);*/
1693      /* This moves the raw bits to take into account the new compressed size */
1694      ec_enc_shrink(enc, nbCompressedBytes);
1695    }
1696
1697    /* Bit allocation */
1698    ALLOC(fine_quant, st->mode->nbEBands, int);
1699    ALLOC(pulses, st->mode->nbEBands, int);
1700    ALLOC(fine_priority, st->mode->nbEBands, int);
1701
1702    /* bits =           packet size                    - where we are - safety*/
1703    bits = (((opus_int32)nbCompressedBytes*8)<<BITRES) - ec_tell_frac(enc) - 1;
1704    anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0;
1705    bits -= anti_collapse_rsv;
1706    codedBands = compute_allocation(st->mode, st->start, st->end, offsets, cap,
1707          alloc_trim, &intensity, &dual_stereo, bits, &balance, pulses,
1708          fine_quant, fine_priority, C, LM, enc, 1, st->lastCodedBands);
1709    st->lastCodedBands = codedBands;
1710
1711    quant_fine_energy(st->mode, st->start, st->end, oldBandE, error, fine_quant, enc, C);
1712
1713 #ifdef MEASURE_NORM_MSE
1714    float X0[3000];
1715    float bandE0[60];
1716    c=0; do
1717       for (i=0;i<N;i++)
1718          X0[i+c*N] = X[i+c*N];
1719    while (++c<C);
1720    for (i=0;i<C*st->mode->nbEBands;i++)
1721       bandE0[i] = bandE[i];
1722 #endif
1723
1724    /* Residual quantisation */
1725    ALLOC(collapse_masks, C*st->mode->nbEBands, unsigned char);
1726    quant_all_bands(1, st->mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
1727          bandE, pulses, shortBlocks, st->spread_decision, dual_stereo, intensity, tf_res,
1728          nbCompressedBytes*(8<<BITRES)-anti_collapse_rsv, balance, enc, LM, codedBands, &st->rng);
1729
1730    if (anti_collapse_rsv > 0)
1731    {
1732       anti_collapse_on = st->consec_transient<2;
1733 #ifdef FUZZING
1734       anti_collapse_on = rand()&0x1;
1735 #endif
1736       ec_enc_bits(enc, anti_collapse_on, 1);
1737    }
1738    quant_energy_finalise(st->mode, st->start, st->end, oldBandE, error, fine_quant, fine_priority, nbCompressedBytes*8-ec_tell(enc), enc, C);
1739
1740    if (silence)
1741    {
1742       for (i=0;i<C*st->mode->nbEBands;i++)
1743          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
1744    }
1745
1746 #ifdef RESYNTH
1747    /* Re-synthesis of the coded audio if required */
1748    {
1749       celt_sig *out_mem[2];
1750       celt_sig *overlap_mem[2];
1751
1752       log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
1753       if (silence)
1754       {
1755          for (i=0;i<C*st->mode->nbEBands;i++)
1756             bandE[i] = 0;
1757       }
1758
1759 #ifdef MEASURE_NORM_MSE
1760       measure_norm_mse(st->mode, X, X0, bandE, bandE0, M, N, C);
1761 #endif
1762       if (anti_collapse_on)
1763       {
1764          anti_collapse(st->mode, X, collapse_masks, LM, C, N,
1765                st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
1766       }
1767
1768       /* Synthesis */
1769       denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
1770
1771       OPUS_MOVE(st->syn_mem[0], st->syn_mem[0]+N, MAX_PERIOD);
1772       if (CC==2)
1773          OPUS_MOVE(st->syn_mem[1], st->syn_mem[1]+N, MAX_PERIOD);
1774
1775       c=0; do
1776          for (i=0;i<M*st->mode->eBands[st->start];i++)
1777             freq[c*N+i] = 0;
1778       while (++c<C);
1779       c=0; do
1780          for (i=M*st->mode->eBands[st->end];i<N;i++)
1781             freq[c*N+i] = 0;
1782       while (++c<C);
1783
1784       if (CC==2&&C==1)
1785       {
1786          for (i=0;i<N;i++)
1787             freq[N+i] = freq[i];
1788       }
1789
1790       out_mem[0] = st->syn_mem[0]+MAX_PERIOD;
1791       if (CC==2)
1792          out_mem[1] = st->syn_mem[1]+MAX_PERIOD;
1793
1794       overlap_mem[0] = prefilter_mem+CC*COMBFILTER_MAXPERIOD;
1795       if (CC==2)
1796          overlap_mem[1] = overlap_mem[0] + st->overlap;
1797
1798       compute_inv_mdcts(st->mode, shortBlocks, freq, out_mem, overlap_mem, CC, LM);
1799
1800       c=0; do {
1801          st->prefilter_period=IMAX(st->prefilter_period, COMBFILTER_MINPERIOD);
1802          st->prefilter_period_old=IMAX(st->prefilter_period_old, COMBFILTER_MINPERIOD);
1803          comb_filter(out_mem[c], out_mem[c], st->prefilter_period_old, st->prefilter_period, st->mode->shortMdctSize,
1804                st->prefilter_gain_old, st->prefilter_gain, st->prefilter_tapset_old, st->prefilter_tapset,
1805                st->mode->window, st->overlap);
1806          if (LM!=0)
1807             comb_filter(out_mem[c]+st->mode->shortMdctSize, out_mem[c]+st->mode->shortMdctSize, st->prefilter_period, pitch_index, N-st->mode->shortMdctSize,
1808                   st->prefilter_gain, gain1, st->prefilter_tapset, prefilter_tapset,
1809                   st->mode->window, st->mode->overlap);
1810       } while (++c<CC);
1811
1812       deemphasis(out_mem, (opus_val16*)pcm, N, CC, st->upsample, st->mode->preemph, st->preemph_memD);
1813       st->prefilter_period_old = st->prefilter_period;
1814       st->prefilter_gain_old = st->prefilter_gain;
1815       st->prefilter_tapset_old = st->prefilter_tapset;
1816    }
1817 #endif
1818
1819    st->prefilter_period = pitch_index;
1820    st->prefilter_gain = gain1;
1821    st->prefilter_tapset = prefilter_tapset;
1822 #ifdef RESYNTH
1823    if (LM!=0)
1824    {
1825       st->prefilter_period_old = st->prefilter_period;
1826       st->prefilter_gain_old = st->prefilter_gain;
1827       st->prefilter_tapset_old = st->prefilter_tapset;
1828    }
1829 #endif
1830
1831    if (CC==2&&C==1) {
1832       for (i=0;i<st->mode->nbEBands;i++)
1833          oldBandE[st->mode->nbEBands+i]=oldBandE[i];
1834    }
1835
1836    if (!isTransient)
1837    {
1838       for (i=0;i<CC*st->mode->nbEBands;i++)
1839          oldLogE2[i] = oldLogE[i];
1840       for (i=0;i<CC*st->mode->nbEBands;i++)
1841          oldLogE[i] = oldBandE[i];
1842    } else {
1843       for (i=0;i<CC*st->mode->nbEBands;i++)
1844          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
1845    }
1846    /* In case start or end were to change */
1847    c=0; do
1848    {
1849       for (i=0;i<st->start;i++)
1850       {
1851          oldBandE[c*st->mode->nbEBands+i]=0;
1852          oldLogE[c*st->mode->nbEBands+i]=oldLogE2[c*st->mode->nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
1853       }
1854       for (i=st->end;i<st->mode->nbEBands;i++)
1855       {
1856          oldBandE[c*st->mode->nbEBands+i]=0;
1857          oldLogE[c*st->mode->nbEBands+i]=oldLogE2[c*st->mode->nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
1858       }
1859    } while (++c<CC);
1860
1861    if (isTransient)
1862       st->consec_transient++;
1863    else
1864       st->consec_transient=0;
1865    st->rng = enc->rng;
1866
1867    /* If there's any room left (can only happen for very high rates),
1868       it's already filled with zeros */
1869    ec_enc_done(enc);
1870
1871 #ifdef CUSTOM_MODES
1872    if (st->signalling)
1873       nbCompressedBytes++;
1874 #endif
1875
1876    RESTORE_STACK;
1877    if (ec_get_error(enc))
1878       return OPUS_INTERNAL_ERROR;
1879    else
1880       return nbCompressedBytes;
1881 }
1882
1883
1884 #ifdef CUSTOM_MODES
1885
1886 #ifdef FIXED_POINT
1887 int opus_custom_encode(CELTEncoder * restrict st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1888 {
1889    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1890 }
1891
1892 #ifndef DISABLE_FLOAT_API
1893 int opus_custom_encode_float(CELTEncoder * restrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1894 {
1895    int j, ret, C, N;
1896    VARDECL(opus_int16, in);
1897    ALLOC_STACK;
1898
1899    if (pcm==NULL)
1900       return OPUS_BAD_ARG;
1901
1902    C = st->channels;
1903    N = frame_size;
1904    ALLOC(in, C*N, opus_int16);
1905
1906    for (j=0;j<C*N;j++)
1907      in[j] = FLOAT2INT16(pcm[j]);
1908
1909    ret=celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
1910 #ifdef RESYNTH
1911    for (j=0;j<C*N;j++)
1912       ((float*)pcm)[j]=in[j]*(1.f/32768.f);
1913 #endif
1914    RESTORE_STACK;
1915    return ret;
1916 }
1917 #endif /* DISABLE_FLOAT_API */
1918 #else
1919
1920 int opus_custom_encode(CELTEncoder * restrict st, const opus_int16 * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1921 {
1922    int j, ret, C, N;
1923    VARDECL(celt_sig, in);
1924    ALLOC_STACK;
1925
1926    if (pcm==NULL)
1927       return OPUS_BAD_ARG;
1928
1929    C=st->channels;
1930    N=frame_size;
1931    ALLOC(in, C*N, celt_sig);
1932    for (j=0;j<C*N;j++) {
1933      in[j] = SCALEOUT(pcm[j]);
1934    }
1935
1936    ret = celt_encode_with_ec(st,in,frame_size,compressed,nbCompressedBytes, NULL);
1937 #ifdef RESYNTH
1938    for (j=0;j<C*N;j++)
1939       ((opus_int16*)pcm)[j] = FLOAT2INT16(in[j]);
1940 #endif
1941    RESTORE_STACK;
1942    return ret;
1943 }
1944
1945 int opus_custom_encode_float(CELTEncoder * restrict st, const float * pcm, int frame_size, unsigned char *compressed, int nbCompressedBytes)
1946 {
1947    return celt_encode_with_ec(st, pcm, frame_size, compressed, nbCompressedBytes, NULL);
1948 }
1949
1950 #endif
1951
1952 #endif /* CUSTOM_MODES */
1953
1954 int opus_custom_encoder_ctl(CELTEncoder * restrict st, int request, ...)
1955 {
1956    va_list ap;
1957
1958    va_start(ap, request);
1959    switch (request)
1960    {
1961       case OPUS_SET_COMPLEXITY_REQUEST:
1962       {
1963          int value = va_arg(ap, opus_int32);
1964          if (value<0 || value>10)
1965             goto bad_arg;
1966          st->complexity = value;
1967       }
1968       break;
1969       case CELT_SET_START_BAND_REQUEST:
1970       {
1971          opus_int32 value = va_arg(ap, opus_int32);
1972          if (value<0 || value>=st->mode->nbEBands)
1973             goto bad_arg;
1974          st->start = value;
1975       }
1976       break;
1977       case CELT_SET_END_BAND_REQUEST:
1978       {
1979          opus_int32 value = va_arg(ap, opus_int32);
1980          if (value<1 || value>st->mode->nbEBands)
1981             goto bad_arg;
1982          st->end = value;
1983       }
1984       break;
1985       case CELT_SET_PREDICTION_REQUEST:
1986       {
1987          int value = va_arg(ap, opus_int32);
1988          if (value<0 || value>2)
1989             goto bad_arg;
1990          st->disable_pf = value<=1;
1991          st->force_intra = value==0;
1992       }
1993       break;
1994       case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1995       {
1996          int value = va_arg(ap, opus_int32);
1997          if (value<0 || value>100)
1998             goto bad_arg;
1999          st->loss_rate = value;
2000       }
2001       break;
2002       case OPUS_SET_VBR_CONSTRAINT_REQUEST:
2003       {
2004          opus_int32 value = va_arg(ap, opus_int32);
2005          st->constrained_vbr = value;
2006       }
2007       break;
2008       case OPUS_SET_VBR_REQUEST:
2009       {
2010          opus_int32 value = va_arg(ap, opus_int32);
2011          st->vbr = value;
2012       }
2013       break;
2014       case OPUS_SET_BITRATE_REQUEST:
2015       {
2016          opus_int32 value = va_arg(ap, opus_int32);
2017          if (value<=500 && value!=OPUS_BITRATE_MAX)
2018             goto bad_arg;
2019          value = IMIN(value, 260000*st->channels);
2020          st->bitrate = value;
2021       }
2022       break;
2023       case CELT_SET_CHANNELS_REQUEST:
2024       {
2025          opus_int32 value = va_arg(ap, opus_int32);
2026          if (value<1 || value>2)
2027             goto bad_arg;
2028          st->stream_channels = value;
2029       }
2030       break;
2031       case OPUS_RESET_STATE:
2032       {
2033          int i;
2034          opus_val16 *oldBandE, *oldLogE, *oldLogE2;
2035          oldBandE = (opus_val16*)(st->in_mem+st->channels*(2*st->overlap+COMBFILTER_MAXPERIOD));
2036          oldLogE = oldBandE + st->channels*st->mode->nbEBands;
2037          oldLogE2 = oldLogE + st->channels*st->mode->nbEBands;
2038          OPUS_CLEAR((char*)&st->ENCODER_RESET_START,
2039                opus_custom_encoder_get_size(st->mode, st->channels)-
2040                ((char*)&st->ENCODER_RESET_START - (char*)st));
2041          for (i=0;i<st->channels*st->mode->nbEBands;i++)
2042             oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT);
2043          st->vbr_offset = 0;
2044          st->delayedIntra = 1;
2045          st->spread_decision = SPREAD_NORMAL;
2046          st->tonal_average = 256;
2047          st->hf_average = 0;
2048          st->tapset_decision = 0;
2049       }
2050       break;
2051 #ifdef CUSTOM_MODES
2052       case CELT_SET_INPUT_CLIPPING_REQUEST:
2053       {
2054          opus_int32 value = va_arg(ap, opus_int32);
2055          st->clip = value;
2056       }
2057       break;
2058 #endif
2059       case CELT_SET_SIGNALLING_REQUEST:
2060       {
2061          opus_int32 value = va_arg(ap, opus_int32);
2062          st->signalling = value;
2063       }
2064       break;
2065       case CELT_SET_ANALYSIS_REQUEST:
2066       {
2067          AnalysisInfo *info = va_arg(ap, AnalysisInfo *);
2068          if (info)
2069             OPUS_COPY(&st->analysis, info, 1);
2070       }
2071       break;
2072       case CELT_GET_MODE_REQUEST:
2073       {
2074          const CELTMode ** value = va_arg(ap, const CELTMode**);
2075          if (value==0)
2076             goto bad_arg;
2077          *value=st->mode;
2078       }
2079       break;
2080       case OPUS_GET_FINAL_RANGE_REQUEST:
2081       {
2082          opus_uint32 * value = va_arg(ap, opus_uint32 *);
2083          if (value==0)
2084             goto bad_arg;
2085          *value=st->rng;
2086       }
2087       break;
2088       default:
2089          goto bad_request;
2090    }
2091    va_end(ap);
2092    return OPUS_OK;
2093 bad_arg:
2094    va_end(ap);
2095    return OPUS_BAD_ARG;
2096 bad_request:
2097    va_end(ap);
2098    return OPUS_UNIMPLEMENTED;
2099 }
2100
2101 /**********************************************************************/
2102 /*                                                                    */
2103 /*                             DECODER                                */
2104 /*                                                                    */
2105 /**********************************************************************/
2106 #define DECODE_BUFFER_SIZE 2048
2107
2108 /** Decoder state
2109  @brief Decoder state
2110  */
2111 struct OpusCustomDecoder {
2112    const OpusCustomMode *mode;
2113    int overlap;
2114    int channels;
2115    int stream_channels;
2116
2117    int downsample;
2118    int start, end;
2119    int signalling;
2120
2121    /* Everything beyond this point gets cleared on a reset */
2122 #define DECODER_RESET_START rng
2123
2124    opus_uint32 rng;
2125    int error;
2126    int last_pitch_index;
2127    int loss_count;
2128    int postfilter_period;
2129    int postfilter_period_old;
2130    opus_val16 postfilter_gain;
2131    opus_val16 postfilter_gain_old;
2132    int postfilter_tapset;
2133    int postfilter_tapset_old;
2134
2135    celt_sig preemph_memD[2];
2136
2137    celt_sig _decode_mem[1]; /* Size = channels*(DECODE_BUFFER_SIZE+mode->overlap) */
2138    /* opus_val16 lpc[],  Size = channels*LPC_ORDER */
2139    /* opus_val16 oldEBands[], Size = 2*mode->nbEBands */
2140    /* opus_val16 oldLogE[], Size = 2*mode->nbEBands */
2141    /* opus_val16 oldLogE2[], Size = 2*mode->nbEBands */
2142    /* opus_val16 backgroundLogE[], Size = 2*mode->nbEBands */
2143 };
2144
2145 int celt_decoder_get_size(int channels)
2146 {
2147    const CELTMode *mode = opus_custom_mode_create(48000, 960, NULL);
2148    return opus_custom_decoder_get_size(mode, channels);
2149 }
2150
2151 OPUS_CUSTOM_NOSTATIC int opus_custom_decoder_get_size(const CELTMode *mode, int channels)
2152 {
2153    int size = sizeof(struct CELTDecoder)
2154             + (channels*(DECODE_BUFFER_SIZE+mode->overlap)-1)*sizeof(celt_sig)
2155             + channels*LPC_ORDER*sizeof(opus_val16)
2156             + 4*2*mode->nbEBands*sizeof(opus_val16);
2157    return size;
2158 }
2159
2160 #ifdef CUSTOM_MODES
2161 CELTDecoder *opus_custom_decoder_create(const CELTMode *mode, int channels, int *error)
2162 {
2163    int ret;
2164    CELTDecoder *st = (CELTDecoder *)opus_alloc(opus_custom_decoder_get_size(mode, channels));
2165    ret = opus_custom_decoder_init(st, mode, channels);
2166    if (ret != OPUS_OK)
2167    {
2168       opus_custom_decoder_destroy(st);
2169       st = NULL;
2170    }
2171    if (error)
2172       *error = ret;
2173    return st;
2174 }
2175 #endif /* CUSTOM_MODES */
2176
2177 int celt_decoder_init(CELTDecoder *st, opus_int32 sampling_rate, int channels)
2178 {
2179    int ret;
2180    ret = opus_custom_decoder_init(st, opus_custom_mode_create(48000, 960, NULL), channels);
2181    if (ret != OPUS_OK)
2182       return ret;
2183    st->downsample = resampling_factor(sampling_rate);
2184    if (st->downsample==0)
2185       return OPUS_BAD_ARG;
2186    else
2187       return OPUS_OK;
2188 }
2189
2190 OPUS_CUSTOM_NOSTATIC int opus_custom_decoder_init(CELTDecoder *st, const CELTMode *mode, int channels)
2191 {
2192    if (channels < 0 || channels > 2)
2193       return OPUS_BAD_ARG;
2194
2195    if (st==NULL)
2196       return OPUS_ALLOC_FAIL;
2197
2198    OPUS_CLEAR((char*)st, opus_custom_decoder_get_size(mode, channels));
2199
2200    st->mode = mode;
2201    st->overlap = mode->overlap;
2202    st->stream_channels = st->channels = channels;
2203
2204    st->downsample = 1;
2205    st->start = 0;
2206    st->end = st->mode->effEBands;
2207    st->signalling = 1;
2208
2209    st->loss_count = 0;
2210
2211    opus_custom_decoder_ctl(st, OPUS_RESET_STATE);
2212
2213    return OPUS_OK;
2214 }
2215
2216 #ifdef CUSTOM_MODES
2217 void opus_custom_decoder_destroy(CELTDecoder *st)
2218 {
2219    opus_free(st);
2220 }
2221 #endif /* CUSTOM_MODES */
2222
2223 static void celt_decode_lost(CELTDecoder * restrict st, opus_val16 * restrict pcm, int N, int LM)
2224 {
2225    int c;
2226    int pitch_index;
2227    int overlap = st->mode->overlap;
2228    opus_val16 fade = Q15ONE;
2229    int i, len;
2230    const int C = st->channels;
2231    int offset;
2232    celt_sig *out_mem[2];
2233    celt_sig *decode_mem[2];
2234    celt_sig *overlap_mem[2];
2235    opus_val16 *lpc;
2236    opus_val32 *out_syn[2];
2237    opus_val16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE;
2238    SAVE_STACK;
2239
2240    c=0; do {
2241       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
2242       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
2243       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
2244    } while (++c<C);
2245    lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*C);
2246    oldBandE = lpc+C*LPC_ORDER;
2247    oldLogE = oldBandE + 2*st->mode->nbEBands;
2248    oldLogE2 = oldLogE + 2*st->mode->nbEBands;
2249    backgroundLogE = oldLogE2  + 2*st->mode->nbEBands;
2250
2251    out_syn[0] = out_mem[0]+MAX_PERIOD-N;
2252    if (C==2)
2253       out_syn[1] = out_mem[1]+MAX_PERIOD-N;
2254
2255    len = N+st->mode->overlap;
2256
2257    if (st->loss_count >= 5 || st->start!=0)
2258    {
2259       /* Noise-based PLC/CNG */
2260       VARDECL(celt_sig, freq);
2261       VARDECL(celt_norm, X);
2262       VARDECL(celt_ener, bandE);
2263       opus_uint32 seed;
2264       int effEnd;
2265
2266       effEnd = st->end;
2267       if (effEnd > st->mode->effEBands)
2268          effEnd = st->mode->effEBands;
2269
2270       ALLOC(freq, C*N, celt_sig); /**< Interleaved signal MDCTs */
2271       ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
2272       ALLOC(bandE, st->mode->nbEBands*C, celt_ener);
2273
2274       if (st->loss_count >= 5)
2275          log2Amp(st->mode, st->start, st->end, bandE, backgroundLogE, C);
2276       else {
2277          /* Energy decay */
2278          opus_val16 decay = st->loss_count==0 ? QCONST16(1.5f, DB_SHIFT) : QCONST16(.5f, DB_SHIFT);
2279          c=0; do
2280          {
2281             for (i=st->start;i<st->end;i++)
2282                oldBandE[c*st->mode->nbEBands+i] -= decay;
2283          } while (++c<C);
2284          log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
2285       }
2286       seed = st->rng;
2287       for (c=0;c<C;c++)
2288       {
2289          for (i=0;i<(st->mode->eBands[st->start]<<LM);i++)
2290             X[c*N+i] = 0;
2291          for (i=st->start;i<st->mode->effEBands;i++)
2292          {
2293             int j;
2294             int boffs;
2295             int blen;
2296             boffs = N*c+(st->mode->eBands[i]<<LM);
2297             blen = (st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
2298             for (j=0;j<blen;j++)
2299             {
2300                seed = celt_lcg_rand(seed);
2301                X[boffs+j] = (celt_norm)((opus_int32)seed>>20);
2302             }
2303             renormalise_vector(X+boffs, blen, Q15ONE);
2304          }
2305          for (i=(st->mode->eBands[st->end]<<LM);i<N;i++)
2306             X[c*N+i] = 0;
2307       }
2308       st->rng = seed;
2309
2310       denormalise_bands(st->mode, X, freq, bandE, st->mode->effEBands, C, 1<<LM);
2311
2312       c=0; do
2313          for (i=0;i<st->mode->eBands[st->start]<<LM;i++)
2314             freq[c*N+i] = 0;
2315       while (++c<C);
2316       c=0; do {
2317          int bound = st->mode->eBands[effEnd]<<LM;
2318          if (st->downsample!=1)
2319             bound = IMIN(bound, N/st->downsample);
2320          for (i=bound;i<N;i++)
2321             freq[c*N+i] = 0;
2322       } while (++c<C);
2323       compute_inv_mdcts(st->mode, 0, freq, out_syn, overlap_mem, C, LM);
2324    } else {
2325       /* Pitch-based PLC */
2326       if (st->loss_count == 0)
2327       {
2328          opus_val16 pitch_buf[DECODE_BUFFER_SIZE>>1];
2329          /* Corresponds to a min pitch of 67 Hz. It's possible to save CPU in this
2330          search by using only part of the decode buffer */
2331          int poffset = 720;
2332          pitch_downsample(decode_mem, pitch_buf, DECODE_BUFFER_SIZE, C);
2333          /* Max pitch is 100 samples (480 Hz) */
2334          pitch_search(pitch_buf+((poffset)>>1), pitch_buf, DECODE_BUFFER_SIZE-poffset,
2335                poffset-100, &pitch_index);
2336          pitch_index = poffset-pitch_index;
2337          st->last_pitch_index = pitch_index;
2338       } else {
2339          pitch_index = st->last_pitch_index;
2340          fade = QCONST16(.8f,15);
2341       }
2342
2343       c=0; do {
2344          VARDECL(opus_val32, e);
2345          opus_val16 exc[MAX_PERIOD];
2346          opus_val32 ac[LPC_ORDER+1];
2347          opus_val16 decay = 1;
2348          opus_val32 S1=0;
2349          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};
2350
2351          ALLOC(e, MAX_PERIOD+2*st->mode->overlap, opus_val32);
2352
2353          offset = MAX_PERIOD-pitch_index;
2354          for (i=0;i<MAX_PERIOD;i++)
2355             exc[i] = ROUND16(out_mem[c][i], SIG_SHIFT);
2356
2357          if (st->loss_count == 0)
2358          {
2359             _celt_autocorr(exc, ac, st->mode->window, st->mode->overlap,
2360                   LPC_ORDER, MAX_PERIOD);
2361
2362             /* Noise floor -40 dB */
2363 #ifdef FIXED_POINT
2364             ac[0] += SHR32(ac[0],13);
2365 #else
2366             ac[0] *= 1.0001f;
2367 #endif
2368             /* Lag windowing */
2369             for (i=1;i<=LPC_ORDER;i++)
2370             {
2371                /*ac[i] *= exp(-.5*(2*M_PI*.002*i)*(2*M_PI*.002*i));*/
2372 #ifdef FIXED_POINT
2373                ac[i] -= MULT16_32_Q15(2*i*i, ac[i]);
2374 #else
2375                ac[i] -= ac[i]*(.008f*i)*(.008f*i);
2376 #endif
2377             }
2378
2379             _celt_lpc(lpc+c*LPC_ORDER, ac, LPC_ORDER);
2380          }
2381          for (i=0;i<LPC_ORDER;i++)
2382             mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT);
2383          celt_fir(exc, lpc+c*LPC_ORDER, exc, MAX_PERIOD, LPC_ORDER, mem);
2384          /*for (i=0;i<MAX_PERIOD;i++)printf("%d ", exc[i]); printf("\n");*/
2385          /* Check if the waveform is decaying (and if so how fast) */
2386          {
2387             opus_val32 E1=1, E2=1;
2388             int period;
2389             if (pitch_index <= MAX_PERIOD/2)
2390                period = pitch_index;
2391             else
2392                period = MAX_PERIOD/2;
2393             for (i=0;i<period;i++)
2394             {
2395                E1 += SHR32(MULT16_16(exc[MAX_PERIOD-period+i],exc[MAX_PERIOD-period+i]),8);
2396                E2 += SHR32(MULT16_16(exc[MAX_PERIOD-2*period+i],exc[MAX_PERIOD-2*period+i]),8);
2397             }
2398             if (E1 > E2)
2399                E1 = E2;
2400             decay = celt_sqrt(frac_div32(SHR32(E1,1),E2));
2401          }
2402
2403          /* Copy excitation, taking decay into account */
2404          for (i=0;i<len+st->mode->overlap;i++)
2405          {
2406             opus_val16 tmp;
2407             if (offset+i >= MAX_PERIOD)
2408             {
2409                offset -= pitch_index;
2410                decay = MULT16_16_Q15(decay, decay);
2411             }
2412             e[i] = SHL32(EXTEND32(MULT16_16_Q15(decay, exc[offset+i])), SIG_SHIFT);
2413             tmp = ROUND16(out_mem[c][offset+i],SIG_SHIFT);
2414             S1 += SHR32(MULT16_16(tmp,tmp),8);
2415          }
2416          for (i=0;i<LPC_ORDER;i++)
2417             mem[i] = ROUND16(out_mem[c][MAX_PERIOD-1-i], SIG_SHIFT);
2418          for (i=0;i<len+st->mode->overlap;i++)
2419             e[i] = MULT16_32_Q15(fade, e[i]);
2420          celt_iir(e, lpc+c*LPC_ORDER, e, len+st->mode->overlap, LPC_ORDER, mem);
2421
2422          {
2423             opus_val32 S2=0;
2424             for (i=0;i<len+overlap;i++)
2425             {
2426                opus_val16 tmp = ROUND16(e[i],SIG_SHIFT);
2427                S2 += SHR32(MULT16_16(tmp,tmp),8);
2428             }
2429             /* This checks for an "explosion" in the synthesis */
2430 #ifdef FIXED_POINT
2431             if (!(S1 > SHR32(S2,2)))
2432 #else
2433                /* Float test is written this way to catch NaNs at the same time */
2434                if (!(S1 > 0.2f*S2))
2435 #endif
2436                {
2437                   for (i=0;i<len+overlap;i++)
2438                      e[i] = 0;
2439                } else if (S1 < S2)
2440                {
2441                   opus_val16 ratio = celt_sqrt(frac_div32(SHR32(S1,1)+1,S2+1));
2442                   for (i=0;i<len+overlap;i++)
2443                      e[i] = MULT16_32_Q15(ratio, e[i]);
2444                }
2445          }
2446
2447          /* Apply post-filter to the MDCT overlap of the previous frame */
2448          comb_filter(out_mem[c]+MAX_PERIOD, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap,
2449                st->postfilter_gain, st->postfilter_gain, st->postfilter_tapset, st->postfilter_tapset,
2450                NULL, 0);
2451
2452          for (i=0;i<MAX_PERIOD+st->mode->overlap-N;i++)
2453             out_mem[c][i] = out_mem[c][N+i];
2454
2455          /* Apply TDAC to the concealed audio so that it blends with the
2456          previous and next frames */
2457          for (i=0;i<overlap/2;i++)
2458          {
2459             opus_val32 tmp;
2460             tmp = MULT16_32_Q15(st->mode->window[i],           e[N+overlap-1-i]) +
2461                   MULT16_32_Q15(st->mode->window[overlap-i-1], e[N+i          ]);
2462             out_mem[c][MAX_PERIOD+i] = MULT16_32_Q15(st->mode->window[overlap-i-1], tmp);
2463             out_mem[c][MAX_PERIOD+overlap-i-1] = MULT16_32_Q15(st->mode->window[i], tmp);
2464          }
2465          for (i=0;i<N;i++)
2466             out_mem[c][MAX_PERIOD-N+i] = e[i];
2467
2468          /* Apply pre-filter to the MDCT overlap for the next frame (post-filter will be applied then) */
2469          comb_filter(e, out_mem[c]+MAX_PERIOD, st->postfilter_period, st->postfilter_period, st->overlap,
2470                -st->postfilter_gain, -st->postfilter_gain, st->postfilter_tapset, st->postfilter_tapset,
2471                NULL, 0);
2472          for (i=0;i<overlap;i++)
2473             out_mem[c][MAX_PERIOD+i] = e[i];
2474       } while (++c<C);
2475    }
2476
2477    deemphasis(out_syn, pcm, N, C, st->downsample, st->mode->preemph, st->preemph_memD);
2478
2479    st->loss_count++;
2480
2481    RESTORE_STACK;
2482 }
2483
2484 int celt_decode_with_ec(CELTDecoder * restrict st, const unsigned char *data, int len, opus_val16 * restrict pcm, int frame_size, ec_dec *dec)
2485 {
2486    int c, i, N;
2487    int spread_decision;
2488    opus_int32 bits;
2489    ec_dec _dec;
2490    VARDECL(celt_sig, freq);
2491    VARDECL(celt_norm, X);
2492    VARDECL(celt_ener, bandE);
2493    VARDECL(int, fine_quant);
2494    VARDECL(int, pulses);
2495    VARDECL(int, cap);
2496    VARDECL(int, offsets);
2497    VARDECL(int, fine_priority);
2498    VARDECL(int, tf_res);
2499    VARDECL(unsigned char, collapse_masks);
2500    celt_sig *out_mem[2];
2501    celt_sig *decode_mem[2];
2502    celt_sig *overlap_mem[2];
2503    celt_sig *out_syn[2];
2504    opus_val16 *lpc;
2505    opus_val16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE;
2506
2507    int shortBlocks;
2508    int isTransient;
2509    int intra_ener;
2510    const int CC = st->channels;
2511    int LM, M;
2512    int effEnd;
2513    int codedBands;
2514    int alloc_trim;
2515    int postfilter_pitch;
2516    opus_val16 postfilter_gain;
2517    int intensity=0;
2518    int dual_stereo=0;
2519    opus_int32 total_bits;
2520    opus_int32 balance;
2521    opus_int32 tell;
2522    int dynalloc_logp;
2523    int postfilter_tapset;
2524    int anti_collapse_rsv;
2525    int anti_collapse_on=0;
2526    int silence;
2527    int C = st->stream_channels;
2528    ALLOC_STACK;
2529
2530    frame_size *= st->downsample;
2531
2532    c=0; do {
2533       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+st->overlap);
2534       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
2535       overlap_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE;
2536    } while (++c<CC);
2537    lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*CC);
2538    oldBandE = lpc+CC*LPC_ORDER;
2539    oldLogE = oldBandE + 2*st->mode->nbEBands;
2540    oldLogE2 = oldLogE + 2*st->mode->nbEBands;
2541    backgroundLogE = oldLogE2  + 2*st->mode->nbEBands;
2542
2543 #ifdef CUSTOM_MODES
2544    if (st->signalling && data!=NULL)
2545    {
2546       int data0=data[0];
2547       /* Convert "standard mode" to Opus header */
2548       if (st->mode->Fs==48000 && st->mode->shortMdctSize==120)
2549       {
2550          data0 = fromOpus(data0);
2551          if (data0<0)
2552             return OPUS_INVALID_PACKET;
2553       }
2554       st->end = IMAX(1, st->mode->effEBands-2*(data0>>5));
2555       LM = (data0>>3)&0x3;
2556       C = 1 + ((data0>>2)&0x1);
2557       data++;
2558       len--;
2559       if (LM>st->mode->maxLM)
2560          return OPUS_INVALID_PACKET;
2561       if (frame_size < st->mode->shortMdctSize<<LM)
2562          return OPUS_BUFFER_TOO_SMALL;
2563       else
2564          frame_size = st->mode->shortMdctSize<<LM;
2565    } else {
2566 #else
2567    {
2568 #endif
2569       for (LM=0;LM<=st->mode->maxLM;LM++)
2570          if (st->mode->shortMdctSize<<LM==frame_size)
2571             break;
2572       if (LM>st->mode->maxLM)
2573          return OPUS_BAD_ARG;
2574    }
2575    M=1<<LM;
2576
2577    if (len<0 || len>1275 || pcm==NULL)
2578       return OPUS_BAD_ARG;
2579
2580    N = M*st->mode->shortMdctSize;
2581
2582    effEnd = st->end;
2583    if (effEnd > st->mode->effEBands)
2584       effEnd = st->mode->effEBands;
2585
2586    ALLOC(freq, IMAX(CC,C)*N, celt_sig); /**< Interleaved signal MDCTs */
2587    ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
2588    ALLOC(bandE, st->mode->nbEBands*C, celt_ener);
2589    c=0; do
2590       for (i=0;i<M*st->mode->eBands[st->start];i++)
2591          X[c*N+i] = 0;
2592    while (++c<C);
2593    c=0; do
2594       for (i=M*st->mode->eBands[effEnd];i<N;i++)
2595          X[c*N+i] = 0;
2596    while (++c<C);
2597
2598    if (data == NULL || len<=1)
2599    {
2600       celt_decode_lost(st, pcm, N, LM);
2601       RESTORE_STACK;
2602       return frame_size/st->downsample;
2603    }
2604
2605    if (dec == NULL)
2606    {
2607       ec_dec_init(&_dec,(unsigned char*)data,len);
2608       dec = &_dec;
2609    }
2610
2611    if (C==1)
2612    {
2613       for (i=0;i<st->mode->nbEBands;i++)
2614          oldBandE[i]=MAX16(oldBandE[i],oldBandE[st->mode->nbEBands+i]);
2615    }
2616
2617    total_bits = len*8;
2618    tell = ec_tell(dec);
2619
2620    if (tell >= total_bits)
2621       silence = 1;
2622    else if (tell==1)
2623       silence = ec_dec_bit_logp(dec, 15);
2624    else
2625       silence = 0;
2626    if (silence)
2627    {
2628       /* Pretend we've read all the remaining bits */
2629       tell = len*8;
2630       dec->nbits_total+=tell-ec_tell(dec);
2631    }
2632
2633    postfilter_gain = 0;
2634    postfilter_pitch = 0;
2635    postfilter_tapset = 0;
2636    if (st->start==0 && tell+16 <= total_bits)
2637    {
2638       if(ec_dec_bit_logp(dec, 1))
2639       {
2640          int qg, octave;
2641          octave = ec_dec_uint(dec, 6);
2642          postfilter_pitch = (16<<octave)+ec_dec_bits(dec, 4+octave)-1;
2643          qg = ec_dec_bits(dec, 3);
2644          if (ec_tell(dec)+2<=total_bits)
2645             postfilter_tapset = ec_dec_icdf(dec, tapset_icdf, 2);
2646          postfilter_gain = QCONST16(.09375f,15)*(qg+1);
2647       }
2648       tell = ec_tell(dec);
2649    }
2650
2651    if (LM > 0 && tell+3 <= total_bits)
2652    {
2653       isTransient = ec_dec_bit_logp(dec, 3);
2654       tell = ec_tell(dec);
2655    }
2656    else
2657       isTransient = 0;
2658
2659    if (isTransient)
2660       shortBlocks = M;
2661    else
2662       shortBlocks = 0;
2663
2664    /* Decode the global flags (first symbols in the stream) */
2665    intra_ener = tell+3<=total_bits ? ec_dec_bit_logp(dec, 3) : 0;
2666    /* Get band energies */
2667    unquant_coarse_energy(st->mode, st->start, st->end, oldBandE,
2668          intra_ener, dec, C, LM);
2669
2670    ALLOC(tf_res, st->mode->nbEBands, int);
2671    tf_decode(st->start, st->end, isTransient, tf_res, LM, dec);
2672
2673    tell = ec_tell(dec);
2674    spread_decision = SPREAD_NORMAL;
2675    if (tell+4 <= total_bits)
2676       spread_decision = ec_dec_icdf(dec, spread_icdf, 5);
2677
2678    ALLOC(pulses, st->mode->nbEBands, int);
2679    ALLOC(cap, st->mode->nbEBands, int);
2680    ALLOC(offsets, st->mode->nbEBands, int);
2681    ALLOC(fine_priority, st->mode->nbEBands, int);
2682
2683    init_caps(st->mode,cap,LM,C);
2684
2685    dynalloc_logp = 6;
2686    total_bits<<=BITRES;
2687    tell = ec_tell_frac(dec);
2688    for (i=st->start;i<st->end;i++)
2689    {
2690       int width, quanta;
2691       int dynalloc_loop_logp;
2692       int boost;
2693       width = C*(st->mode->eBands[i+1]-st->mode->eBands[i])<<LM;
2694       /* quanta is 6 bits, but no more than 1 bit/sample
2695          and no less than 1/8 bit/sample */
2696       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
2697       dynalloc_loop_logp = dynalloc_logp;
2698       boost = 0;
2699       while (tell+(dynalloc_loop_logp<<BITRES) < total_bits && boost < cap[i])
2700       {
2701          int flag;
2702          flag = ec_dec_bit_logp(dec, dynalloc_loop_logp);
2703          tell = ec_tell_frac(dec);
2704          if (!flag)
2705             break;
2706          boost += quanta;
2707          total_bits -= quanta;
2708          dynalloc_loop_logp = 1;
2709       }
2710       offsets[i] = boost;
2711       /* Making dynalloc more likely */
2712       if (boost>0)
2713          dynalloc_logp = IMAX(2, dynalloc_logp-1);
2714    }
2715
2716    ALLOC(fine_quant, st->mode->nbEBands, int);
2717    alloc_trim = tell+(6<<BITRES) <= total_bits ?
2718          ec_dec_icdf(dec, trim_icdf, 7) : 5;
2719
2720    bits = (((opus_int32)len*8)<<BITRES) - ec_tell_frac(dec) - 1;
2721    anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0;
2722    bits -= anti_collapse_rsv;
2723    codedBands = compute_allocation(st->mode, st->start, st->end, offsets, cap,
2724          alloc_trim, &intensity, &dual_stereo, bits, &balance, pulses,
2725          fine_quant, fine_priority, C, LM, dec, 0, 0);
2726
2727    unquant_fine_energy(st->mode, st->start, st->end, oldBandE, fine_quant, dec, C);
2728
2729    /* Decode fixed codebook */
2730    ALLOC(collapse_masks, C*st->mode->nbEBands, unsigned char);
2731    quant_all_bands(0, st->mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
2732          NULL, pulses, shortBlocks, spread_decision, dual_stereo, intensity, tf_res,
2733          len*(8<<BITRES)-anti_collapse_rsv, balance, dec, LM, codedBands, &st->rng);
2734
2735    if (anti_collapse_rsv > 0)
2736    {
2737       anti_collapse_on = ec_dec_bits(dec, 1);
2738    }
2739
2740    unquant_energy_finalise(st->mode, st->start, st->end, oldBandE,
2741          fine_quant, fine_priority, len*8-ec_tell(dec), dec, C);
2742
2743    if (anti_collapse_on)
2744       anti_collapse(st->mode, X, collapse_masks, LM, C, N,
2745             st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
2746
2747    log2Amp(st->mode, st->start, st->end, bandE, oldBandE, C);
2748
2749    if (silence)
2750    {
2751       for (i=0;i<C*st->mode->nbEBands;i++)
2752       {
2753          bandE[i] = 0;
2754          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
2755       }
2756    }
2757    /* Synthesis */
2758    denormalise_bands(st->mode, X, freq, bandE, effEnd, C, M);
2759
2760    OPUS_MOVE(decode_mem[0], decode_mem[0]+N, DECODE_BUFFER_SIZE-N);
2761    if (CC==2)
2762       OPUS_MOVE(decode_mem[1], decode_mem[1]+N, DECODE_BUFFER_SIZE-N);
2763
2764    c=0; do
2765       for (i=0;i<M*st->mode->eBands[st->start];i++)
2766          freq[c*N+i] = 0;
2767    while (++c<C);
2768    c=0; do {
2769       int bound = M*st->mode->eBands[effEnd];
2770       if (st->downsample!=1)
2771          bound = IMIN(bound, N/st->downsample);
2772       for (i=bound;i<N;i++)
2773          freq[c*N+i] = 0;
2774    } while (++c<C);
2775
2776    out_syn[0] = out_mem[0]+MAX_PERIOD-N;
2777    if (CC==2)
2778       out_syn[1] = out_mem[1]+MAX_PERIOD-N;
2779
2780    if (CC==2&&C==1)
2781    {
2782       for (i=0;i<N;i++)
2783          freq[N+i] = freq[i];
2784    }
2785    if (CC==1&&C==2)
2786    {
2787       for (i=0;i<N;i++)
2788          freq[i] = HALF32(ADD32(freq[i],freq[N+i]));
2789    }
2790
2791    /* Compute inverse MDCTs */
2792    compute_inv_mdcts(st->mode, shortBlocks, freq, out_syn, overlap_mem, CC, LM);
2793
2794    c=0; do {
2795       st->postfilter_period=IMAX(st->postfilter_period, COMBFILTER_MINPERIOD);
2796       st->postfilter_period_old=IMAX(st->postfilter_period_old, COMBFILTER_MINPERIOD);
2797       comb_filter(out_syn[c], out_syn[c], st->postfilter_period_old, st->postfilter_period, st->mode->shortMdctSize,
2798             st->postfilter_gain_old, st->postfilter_gain, st->postfilter_tapset_old, st->postfilter_tapset,
2799             st->mode->window, st->overlap);
2800       if (LM!=0)
2801          comb_filter(out_syn[c]+st->mode->shortMdctSize, out_syn[c]+st->mode->shortMdctSize, st->postfilter_period, postfilter_pitch, N-st->mode->shortMdctSize,
2802                st->postfilter_gain, postfilter_gain, st->postfilter_tapset, postfilter_tapset,
2803                st->mode->window, st->mode->overlap);
2804
2805    } while (++c<CC);
2806    st->postfilter_period_old = st->postfilter_period;
2807    st->postfilter_gain_old = st->postfilter_gain;
2808    st->postfilter_tapset_old = st->postfilter_tapset;
2809    st->postfilter_period = postfilter_pitch;
2810    st->postfilter_gain = postfilter_gain;
2811    st->postfilter_tapset = postfilter_tapset;
2812    if (LM!=0)
2813    {
2814       st->postfilter_period_old = st->postfilter_period;
2815       st->postfilter_gain_old = st->postfilter_gain;
2816       st->postfilter_tapset_old = st->postfilter_tapset;
2817    }
2818
2819    if (C==1) {
2820       for (i=0;i<st->mode->nbEBands;i++)
2821          oldBandE[st->mode->nbEBands+i]=oldBandE[i];
2822    }
2823
2824    /* In case start or end were to change */
2825    if (!isTransient)
2826    {
2827       for (i=0;i<2*st->mode->nbEBands;i++)
2828          oldLogE2[i] = oldLogE[i];
2829       for (i=0;i<2*st->mode->nbEBands;i++)
2830          oldLogE[i] = oldBandE[i];
2831       for (i=0;i<2*st->mode->nbEBands;i++)
2832          backgroundLogE[i] = MIN16(backgroundLogE[i] + M*QCONST16(0.001f,DB_SHIFT), oldBandE[i]);
2833    } else {
2834       for (i=0;i<2*st->mode->nbEBands;i++)
2835          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
2836    }
2837    c=0; do
2838    {
2839       for (i=0;i<st->start;i++)
2840       {
2841          oldBandE[c*st->mode->nbEBands+i]=0;
2842          oldLogE[c*st->mode->nbEBands+i]=oldLogE2[c*st->mode->nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
2843       }
2844       for (i=st->end;i<st->mode->nbEBands;i++)
2845       {
2846          oldBandE[c*st->mode->nbEBands+i]=0;
2847          oldLogE[c*st->mode->nbEBands+i]=oldLogE2[c*st->mode->nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
2848       }
2849    } while (++c<2);
2850    st->rng = dec->rng;
2851
2852    deemphasis(out_syn, pcm, N, CC, st->downsample, st->mode->preemph, st->preemph_memD);
2853    st->loss_count = 0;
2854    RESTORE_STACK;
2855    if (ec_tell(dec) > 8*len)
2856       return OPUS_INTERNAL_ERROR;
2857    if(ec_get_error(dec))
2858       st->error = 1;
2859    return frame_size/st->downsample;
2860 }
2861
2862
2863 #ifdef CUSTOM_MODES
2864
2865 #ifdef FIXED_POINT
2866 int opus_custom_decode(CELTDecoder * restrict st, const unsigned char *data, int len, opus_int16 * restrict pcm, int frame_size)
2867 {
2868    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
2869 }
2870
2871 #ifndef DISABLE_FLOAT_API
2872 int opus_custom_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size)
2873 {
2874    int j, ret, C, N;
2875    VARDECL(opus_int16, out);
2876    ALLOC_STACK;
2877
2878    if (pcm==NULL)
2879       return OPUS_BAD_ARG;
2880
2881    C = st->channels;
2882    N = frame_size;
2883
2884    ALLOC(out, C*N, opus_int16);
2885    ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL);
2886    if (ret>0)
2887       for (j=0;j<C*ret;j++)
2888          pcm[j]=out[j]*(1.f/32768.f);
2889
2890    RESTORE_STACK;
2891    return ret;
2892 }
2893 #endif /* DISABLE_FLOAT_API */
2894
2895 #else
2896
2897 int opus_custom_decode_float(CELTDecoder * restrict st, const unsigned char *data, int len, float * restrict pcm, int frame_size)
2898 {
2899    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
2900 }
2901
2902 int opus_custom_decode(CELTDecoder * restrict st, const unsigned char *data, int len, opus_int16 * restrict pcm, int frame_size)
2903 {
2904    int j, ret, C, N;
2905    VARDECL(celt_sig, out);
2906    ALLOC_STACK;
2907
2908    if (pcm==NULL)
2909       return OPUS_BAD_ARG;
2910
2911    C = st->channels;
2912    N = frame_size;
2913    ALLOC(out, C*N, celt_sig);
2914
2915    ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL);
2916
2917    if (ret>0)
2918       for (j=0;j<C*ret;j++)
2919          pcm[j] = FLOAT2INT16 (out[j]);
2920
2921    RESTORE_STACK;
2922    return ret;
2923 }
2924
2925 #endif
2926 #endif /* CUSTOM_MODES */
2927
2928 int opus_custom_decoder_ctl(CELTDecoder * restrict st, int request, ...)
2929 {
2930    va_list ap;
2931
2932    va_start(ap, request);
2933    switch (request)
2934    {
2935       case CELT_SET_START_BAND_REQUEST:
2936       {
2937          opus_int32 value = va_arg(ap, opus_int32);
2938          if (value<0 || value>=st->mode->nbEBands)
2939             goto bad_arg;
2940          st->start = value;
2941       }
2942       break;
2943       case CELT_SET_END_BAND_REQUEST:
2944       {
2945          opus_int32 value = va_arg(ap, opus_int32);
2946          if (value<1 || value>st->mode->nbEBands)
2947             goto bad_arg;
2948          st->end = value;
2949       }
2950       break;
2951       case CELT_SET_CHANNELS_REQUEST:
2952       {
2953          opus_int32 value = va_arg(ap, opus_int32);
2954          if (value<1 || value>2)
2955             goto bad_arg;
2956          st->stream_channels = value;
2957       }
2958       break;
2959       case CELT_GET_AND_CLEAR_ERROR_REQUEST:
2960       {
2961          opus_int32 *value = va_arg(ap, opus_int32*);
2962          if (value==NULL)
2963             goto bad_arg;
2964          *value=st->error;
2965          st->error = 0;
2966       }
2967       break;
2968       case OPUS_GET_LOOKAHEAD_REQUEST:
2969       {
2970          opus_int32 *value = va_arg(ap, opus_int32*);
2971          if (value==NULL)
2972             goto bad_arg;
2973          *value = st->overlap/st->downsample;
2974       }
2975       break;
2976       case OPUS_RESET_STATE:
2977       {
2978          int i;
2979          opus_val16 *lpc, *oldBandE, *oldLogE, *oldLogE2;
2980          lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*st->channels);
2981          oldBandE = lpc+st->channels*LPC_ORDER;
2982          oldLogE = oldBandE + 2*st->mode->nbEBands;
2983          oldLogE2 = oldLogE + 2*st->mode->nbEBands;
2984          OPUS_CLEAR((char*)&st->DECODER_RESET_START,
2985                opus_custom_decoder_get_size(st->mode, st->channels)-
2986                ((char*)&st->DECODER_RESET_START - (char*)st));
2987          for (i=0;i<2*st->mode->nbEBands;i++)
2988             oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT);
2989       }
2990       break;
2991       case OPUS_GET_PITCH_REQUEST:
2992       {
2993          opus_int32 *value = va_arg(ap, opus_int32*);
2994          if (value==NULL)
2995             goto bad_arg;
2996          *value = st->postfilter_period;
2997       }
2998       break;
2999 #ifdef OPUS_BUILD
3000       case CELT_GET_MODE_REQUEST:
3001       {
3002          const CELTMode ** value = va_arg(ap, const CELTMode**);
3003          if (value==0)
3004             goto bad_arg;
3005          *value=st->mode;
3006       }
3007       break;
3008       case CELT_SET_SIGNALLING_REQUEST:
3009       {
3010          opus_int32 value = va_arg(ap, opus_int32);
3011          st->signalling = value;
3012       }
3013       break;
3014       case OPUS_GET_FINAL_RANGE_REQUEST:
3015       {
3016          opus_uint32 * value = va_arg(ap, opus_uint32 *);
3017          if (value==0)
3018             goto bad_arg;
3019          *value=st->rng;
3020       }
3021       break;
3022 #endif
3023       default:
3024          goto bad_request;
3025    }
3026    va_end(ap);
3027    return OPUS_OK;
3028 bad_arg:
3029    va_end(ap);
3030    return OPUS_BAD_ARG;
3031 bad_request:
3032       va_end(ap);
3033   return OPUS_UNIMPLEMENTED;
3034 }
3035
3036
3037
3038 const char *opus_strerror(int error)
3039 {
3040    static const char *error_strings[8] = {
3041       "success",
3042       "invalid argument",
3043       "buffer too small",
3044       "internal error",
3045       "corrupted stream",
3046       "request not implemented",
3047       "invalid state",
3048       "memory allocation failed"
3049    };
3050    if (error > 0 || error < -7)
3051       return "unknown error";
3052    else
3053       return error_strings[-error];
3054 }
3055
3056 const char *opus_get_version_string(void)
3057 {
3058     return "libopus " OPUS_VERSION
3059 #ifdef FIXED_POINT
3060           "-fixed"
3061 #endif
3062 #ifdef FUZZING
3063           "-fuzzing"
3064 #endif
3065           ;
3066 }