Fix NEON optimizations buffer read overrun
[opus.git] / celt / celt_decoder.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_DECODER_C
35
36 #include "cpu_support.h"
37 #include "os_support.h"
38 #include "mdct.h"
39 #include <math.h>
40 #include "celt.h"
41 #include "pitch.h"
42 #include "bands.h"
43 #include "modes.h"
44 #include "entcode.h"
45 #include "quant_bands.h"
46 #include "rate.h"
47 #include "stack_alloc.h"
48 #include "mathops.h"
49 #include "float_cast.h"
50 #include <stdarg.h>
51 #include "celt_lpc.h"
52 #include "vq.h"
53
54 /* The maximum pitch lag to allow in the pitch-based PLC. It's possible to save
55    CPU time in the PLC pitch search by making this smaller than MAX_PERIOD. The
56    current value corresponds to a pitch of 66.67 Hz. */
57 #define PLC_PITCH_LAG_MAX (720)
58 /* The minimum pitch lag to allow in the pitch-based PLC. This corresponds to a
59    pitch of 480 Hz. */
60 #define PLC_PITCH_LAG_MIN (100)
61
62 #if defined(SMALL_FOOTPRINT) && defined(FIXED_POINT)
63 #define NORM_ALIASING_HACK
64 #endif
65 /**********************************************************************/
66 /*                                                                    */
67 /*                             DECODER                                */
68 /*                                                                    */
69 /**********************************************************************/
70 #define DECODE_BUFFER_SIZE 2048
71
72 /** Decoder state
73  @brief Decoder state
74  */
75 struct OpusCustomDecoder {
76    const OpusCustomMode *mode;
77    int overlap;
78    int channels;
79    int stream_channels;
80
81    int downsample;
82    int start, end;
83    int signalling;
84    int disable_inv;
85    int arch;
86
87    /* Everything beyond this point gets cleared on a reset */
88 #define DECODER_RESET_START rng
89
90    opus_uint32 rng;
91    int error;
92    int last_pitch_index;
93    int loss_count;
94    int skip_plc;
95    int postfilter_period;
96    int postfilter_period_old;
97    opus_val16 postfilter_gain;
98    opus_val16 postfilter_gain_old;
99    int postfilter_tapset;
100    int postfilter_tapset_old;
101
102    celt_sig preemph_memD[2];
103
104    celt_sig _decode_mem[1]; /* Size = channels*(DECODE_BUFFER_SIZE+mode->overlap) */
105    /* opus_val16 lpc[],  Size = channels*LPC_ORDER */
106    /* opus_val16 oldEBands[], Size = 2*mode->nbEBands */
107    /* opus_val16 oldLogE[], Size = 2*mode->nbEBands */
108    /* opus_val16 oldLogE2[], Size = 2*mode->nbEBands */
109    /* opus_val16 backgroundLogE[], Size = 2*mode->nbEBands */
110 };
111
112 #if defined(ENABLE_HARDENING) || defined(ENABLE_ASSERTIONS)
113 /* Make basic checks on the CELT state to ensure we don't end
114    up writing all over memory. */
115 void validate_celt_decoder(CELTDecoder *st)
116 {
117 #ifndef CUSTOM_MODES
118    celt_assert(st->mode == opus_custom_mode_create(48000, 960, NULL));
119    celt_assert(st->overlap == 120);
120 #endif
121    celt_assert(st->channels == 1 || st->channels == 2);
122    celt_assert(st->stream_channels == 1 || st->stream_channels == 2);
123    celt_assert(st->downsample > 0);
124    celt_assert(st->start == 0 || st->start == 17);
125    celt_assert(st->start < st->end);
126    celt_assert(st->end <= 21);
127 #ifdef OPUS_ARCHMASK
128    celt_assert(st->arch >= 0);
129    celt_assert(st->arch <= OPUS_ARCHMASK);
130 #endif
131    celt_assert(st->last_pitch_index <= PLC_PITCH_LAG_MAX);
132    celt_assert(st->last_pitch_index >= PLC_PITCH_LAG_MIN || st->last_pitch_index == 0);
133    celt_assert(st->postfilter_period < MAX_PERIOD);
134    celt_assert(st->postfilter_period >= COMBFILTER_MINPERIOD || st->postfilter_period == 0);
135    celt_assert(st->postfilter_period_old < MAX_PERIOD);
136    celt_assert(st->postfilter_period_old >= COMBFILTER_MINPERIOD || st->postfilter_period_old == 0);
137    celt_assert(st->postfilter_tapset <= 2);
138    celt_assert(st->postfilter_tapset >= 0);
139    celt_assert(st->postfilter_tapset_old <= 2);
140    celt_assert(st->postfilter_tapset_old >= 0);
141 }
142 #endif
143
144 int celt_decoder_get_size(int channels)
145 {
146    const CELTMode *mode = opus_custom_mode_create(48000, 960, NULL);
147    return opus_custom_decoder_get_size(mode, channels);
148 }
149
150 OPUS_CUSTOM_NOSTATIC int opus_custom_decoder_get_size(const CELTMode *mode, int channels)
151 {
152    int size = sizeof(struct CELTDecoder)
153             + (channels*(DECODE_BUFFER_SIZE+mode->overlap)-1)*sizeof(celt_sig)
154             + channels*LPC_ORDER*sizeof(opus_val16)
155             + 4*2*mode->nbEBands*sizeof(opus_val16);
156    return size;
157 }
158
159 #ifdef CUSTOM_MODES
160 CELTDecoder *opus_custom_decoder_create(const CELTMode *mode, int channels, int *error)
161 {
162    int ret;
163    CELTDecoder *st = (CELTDecoder *)opus_alloc(opus_custom_decoder_get_size(mode, channels));
164    ret = opus_custom_decoder_init(st, mode, channels);
165    if (ret != OPUS_OK)
166    {
167       opus_custom_decoder_destroy(st);
168       st = NULL;
169    }
170    if (error)
171       *error = ret;
172    return st;
173 }
174 #endif /* CUSTOM_MODES */
175
176 int celt_decoder_init(CELTDecoder *st, opus_int32 sampling_rate, int channels)
177 {
178    int ret;
179    ret = opus_custom_decoder_init(st, opus_custom_mode_create(48000, 960, NULL), channels);
180    if (ret != OPUS_OK)
181       return ret;
182    st->downsample = resampling_factor(sampling_rate);
183    if (st->downsample==0)
184       return OPUS_BAD_ARG;
185    else
186       return OPUS_OK;
187 }
188
189 OPUS_CUSTOM_NOSTATIC int opus_custom_decoder_init(CELTDecoder *st, const CELTMode *mode, int channels)
190 {
191    if (channels < 0 || channels > 2)
192       return OPUS_BAD_ARG;
193
194    if (st==NULL)
195       return OPUS_ALLOC_FAIL;
196
197    OPUS_CLEAR((char*)st, opus_custom_decoder_get_size(mode, channels));
198
199    st->mode = mode;
200    st->overlap = mode->overlap;
201    st->stream_channels = st->channels = channels;
202
203    st->downsample = 1;
204    st->start = 0;
205    st->end = st->mode->effEBands;
206    st->signalling = 1;
207 #ifndef DISABLE_UPDATE_DRAFT
208    st->disable_inv = channels == 1;
209 #else
210    st->disable_inv = 0;
211 #endif
212    st->arch = opus_select_arch();
213
214    opus_custom_decoder_ctl(st, OPUS_RESET_STATE);
215
216    return OPUS_OK;
217 }
218
219 #ifdef CUSTOM_MODES
220 void opus_custom_decoder_destroy(CELTDecoder *st)
221 {
222    opus_free(st);
223 }
224 #endif /* CUSTOM_MODES */
225
226 #ifndef CUSTOM_MODES
227 /* Special case for stereo with no downsampling and no accumulation. This is
228    quite common and we can make it faster by processing both channels in the
229    same loop, reducing overhead due to the dependency loop in the IIR filter. */
230 static void deemphasis_stereo_simple(celt_sig *in[], opus_val16 *pcm, int N, const opus_val16 coef0,
231       celt_sig *mem)
232 {
233    celt_sig * OPUS_RESTRICT x0;
234    celt_sig * OPUS_RESTRICT x1;
235    celt_sig m0, m1;
236    int j;
237    x0=in[0];
238    x1=in[1];
239    m0 = mem[0];
240    m1 = mem[1];
241    for (j=0;j<N;j++)
242    {
243       celt_sig tmp0, tmp1;
244       /* Add VERY_SMALL to x[] first to reduce dependency chain. */
245       tmp0 = x0[j] + VERY_SMALL + m0;
246       tmp1 = x1[j] + VERY_SMALL + m1;
247       m0 = MULT16_32_Q15(coef0, tmp0);
248       m1 = MULT16_32_Q15(coef0, tmp1);
249       pcm[2*j  ] = SCALEOUT(SIG2WORD16(tmp0));
250       pcm[2*j+1] = SCALEOUT(SIG2WORD16(tmp1));
251    }
252    mem[0] = m0;
253    mem[1] = m1;
254 }
255 #endif
256
257 #ifndef RESYNTH
258 static
259 #endif
260 void deemphasis(celt_sig *in[], opus_val16 *pcm, int N, int C, int downsample, const opus_val16 *coef,
261       celt_sig *mem, int accum)
262 {
263    int c;
264    int Nd;
265    int apply_downsampling=0;
266    opus_val16 coef0;
267    VARDECL(celt_sig, scratch);
268    SAVE_STACK;
269 #ifndef CUSTOM_MODES
270    /* Short version for common case. */
271    if (downsample == 1 && C == 2 && !accum)
272    {
273       deemphasis_stereo_simple(in, pcm, N, coef[0], mem);
274       return;
275    }
276 #endif
277 #ifndef FIXED_POINT
278    (void)accum;
279    celt_assert(accum==0);
280 #endif
281    ALLOC(scratch, N, celt_sig);
282    coef0 = coef[0];
283    Nd = N/downsample;
284    c=0; do {
285       int j;
286       celt_sig * OPUS_RESTRICT x;
287       opus_val16  * OPUS_RESTRICT y;
288       celt_sig m = mem[c];
289       x =in[c];
290       y = pcm+c;
291 #ifdef CUSTOM_MODES
292       if (coef[1] != 0)
293       {
294          opus_val16 coef1 = coef[1];
295          opus_val16 coef3 = coef[3];
296          for (j=0;j<N;j++)
297          {
298             celt_sig tmp = x[j] + m + VERY_SMALL;
299             m = MULT16_32_Q15(coef0, tmp)
300                           - MULT16_32_Q15(coef1, x[j]);
301             tmp = SHL32(MULT16_32_Q15(coef3, tmp), 2);
302             scratch[j] = tmp;
303          }
304          apply_downsampling=1;
305       } else
306 #endif
307       if (downsample>1)
308       {
309          /* Shortcut for the standard (non-custom modes) case */
310          for (j=0;j<N;j++)
311          {
312             celt_sig tmp = x[j] + VERY_SMALL + m;
313             m = MULT16_32_Q15(coef0, tmp);
314             scratch[j] = tmp;
315          }
316          apply_downsampling=1;
317       } else {
318          /* Shortcut for the standard (non-custom modes) case */
319 #ifdef FIXED_POINT
320          if (accum)
321          {
322             for (j=0;j<N;j++)
323             {
324                celt_sig tmp = x[j] + m + VERY_SMALL;
325                m = MULT16_32_Q15(coef0, tmp);
326                y[j*C] = SAT16(ADD32(y[j*C], SCALEOUT(SIG2WORD16(tmp))));
327             }
328          } else
329 #endif
330          {
331             for (j=0;j<N;j++)
332             {
333                celt_sig tmp = x[j] + VERY_SMALL + m;
334                m = MULT16_32_Q15(coef0, tmp);
335                y[j*C] = SCALEOUT(SIG2WORD16(tmp));
336             }
337          }
338       }
339       mem[c] = m;
340
341       if (apply_downsampling)
342       {
343          /* Perform down-sampling */
344 #ifdef FIXED_POINT
345          if (accum)
346          {
347             for (j=0;j<Nd;j++)
348                y[j*C] = SAT16(ADD32(y[j*C], SCALEOUT(SIG2WORD16(scratch[j*downsample]))));
349          } else
350 #endif
351          {
352             for (j=0;j<Nd;j++)
353                y[j*C] = SCALEOUT(SIG2WORD16(scratch[j*downsample]));
354          }
355       }
356    } while (++c<C);
357    RESTORE_STACK;
358 }
359
360 #ifndef RESYNTH
361 static
362 #endif
363 void celt_synthesis(const CELTMode *mode, celt_norm *X, celt_sig * out_syn[],
364                     opus_val16 *oldBandE, int start, int effEnd, int C, int CC,
365                     int isTransient, int LM, int downsample,
366                     int silence, int arch)
367 {
368    int c, i;
369    int M;
370    int b;
371    int B;
372    int N, NB;
373    int shift;
374    int nbEBands;
375    int overlap;
376    VARDECL(celt_sig, freq);
377    SAVE_STACK;
378
379    overlap = mode->overlap;
380    nbEBands = mode->nbEBands;
381    N = mode->shortMdctSize<<LM;
382    ALLOC(freq, N, celt_sig); /**< Interleaved signal MDCTs */
383    M = 1<<LM;
384
385    if (isTransient)
386    {
387       B = M;
388       NB = mode->shortMdctSize;
389       shift = mode->maxLM;
390    } else {
391       B = 1;
392       NB = mode->shortMdctSize<<LM;
393       shift = mode->maxLM-LM;
394    }
395
396    if (CC==2&&C==1)
397    {
398       /* Copying a mono streams to two channels */
399       celt_sig *freq2;
400       denormalise_bands(mode, X, freq, oldBandE, start, effEnd, M,
401             downsample, silence);
402       /* Store a temporary copy in the output buffer because the IMDCT destroys its input. */
403       freq2 = out_syn[1]+overlap/2;
404       OPUS_COPY(freq2, freq, N);
405       for (b=0;b<B;b++)
406          clt_mdct_backward(&mode->mdct, &freq2[b], out_syn[0]+NB*b, mode->window, overlap, shift, B, arch);
407       for (b=0;b<B;b++)
408          clt_mdct_backward(&mode->mdct, &freq[b], out_syn[1]+NB*b, mode->window, overlap, shift, B, arch);
409    } else if (CC==1&&C==2)
410    {
411       /* Downmixing a stereo stream to mono */
412       celt_sig *freq2;
413       freq2 = out_syn[0]+overlap/2;
414       denormalise_bands(mode, X, freq, oldBandE, start, effEnd, M,
415             downsample, silence);
416       /* Use the output buffer as temp array before downmixing. */
417       denormalise_bands(mode, X+N, freq2, oldBandE+nbEBands, start, effEnd, M,
418             downsample, silence);
419       for (i=0;i<N;i++)
420          freq[i] = ADD32(HALF32(freq[i]), HALF32(freq2[i]));
421       for (b=0;b<B;b++)
422          clt_mdct_backward(&mode->mdct, &freq[b], out_syn[0]+NB*b, mode->window, overlap, shift, B, arch);
423    } else {
424       /* Normal case (mono or stereo) */
425       c=0; do {
426          denormalise_bands(mode, X+c*N, freq, oldBandE+c*nbEBands, start, effEnd, M,
427                downsample, silence);
428          for (b=0;b<B;b++)
429             clt_mdct_backward(&mode->mdct, &freq[b], out_syn[c]+NB*b, mode->window, overlap, shift, B, arch);
430       } while (++c<CC);
431    }
432    /* Saturate IMDCT output so that we can't overflow in the pitch postfilter
433       or in the */
434    c=0; do {
435       for (i=0;i<N;i++)
436          out_syn[c][i] = SATURATE(out_syn[c][i], SIG_SAT);
437    } while (++c<CC);
438    RESTORE_STACK;
439 }
440
441 static void tf_decode(int start, int end, int isTransient, int *tf_res, int LM, ec_dec *dec)
442 {
443    int i, curr, tf_select;
444    int tf_select_rsv;
445    int tf_changed;
446    int logp;
447    opus_uint32 budget;
448    opus_uint32 tell;
449
450    budget = dec->storage*8;
451    tell = ec_tell(dec);
452    logp = isTransient ? 2 : 4;
453    tf_select_rsv = LM>0 && tell+logp+1<=budget;
454    budget -= tf_select_rsv;
455    tf_changed = curr = 0;
456    for (i=start;i<end;i++)
457    {
458       if (tell+logp<=budget)
459       {
460          curr ^= ec_dec_bit_logp(dec, logp);
461          tell = ec_tell(dec);
462          tf_changed |= curr;
463       }
464       tf_res[i] = curr;
465       logp = isTransient ? 4 : 5;
466    }
467    tf_select = 0;
468    if (tf_select_rsv &&
469      tf_select_table[LM][4*isTransient+0+tf_changed] !=
470      tf_select_table[LM][4*isTransient+2+tf_changed])
471    {
472       tf_select = ec_dec_bit_logp(dec, 1);
473    }
474    for (i=start;i<end;i++)
475    {
476       tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]];
477    }
478 }
479
480 static int celt_plc_pitch_search(celt_sig *decode_mem[2], int C, int arch)
481 {
482    int pitch_index;
483    VARDECL( opus_val16, lp_pitch_buf );
484    SAVE_STACK;
485    ALLOC( lp_pitch_buf, DECODE_BUFFER_SIZE>>1, opus_val16 );
486    pitch_downsample(decode_mem, lp_pitch_buf,
487          DECODE_BUFFER_SIZE, C, arch);
488    pitch_search(lp_pitch_buf+(PLC_PITCH_LAG_MAX>>1), lp_pitch_buf,
489          DECODE_BUFFER_SIZE-PLC_PITCH_LAG_MAX,
490          PLC_PITCH_LAG_MAX-PLC_PITCH_LAG_MIN, &pitch_index, arch);
491    pitch_index = PLC_PITCH_LAG_MAX-pitch_index;
492    RESTORE_STACK;
493    return pitch_index;
494 }
495
496 static void celt_decode_lost(CELTDecoder * OPUS_RESTRICT st, int N, int LM)
497 {
498    int c;
499    int i;
500    const int C = st->channels;
501    celt_sig *decode_mem[2];
502    celt_sig *out_syn[2];
503    opus_val16 *lpc;
504    opus_val16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE;
505    const OpusCustomMode *mode;
506    int nbEBands;
507    int overlap;
508    int start;
509    int loss_count;
510    int noise_based;
511    const opus_int16 *eBands;
512    SAVE_STACK;
513
514    mode = st->mode;
515    nbEBands = mode->nbEBands;
516    overlap = mode->overlap;
517    eBands = mode->eBands;
518
519    c=0; do {
520       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+overlap);
521       out_syn[c] = decode_mem[c]+DECODE_BUFFER_SIZE-N;
522    } while (++c<C);
523    lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+overlap)*C);
524    oldBandE = lpc+C*LPC_ORDER;
525    oldLogE = oldBandE + 2*nbEBands;
526    oldLogE2 = oldLogE + 2*nbEBands;
527    backgroundLogE = oldLogE2  + 2*nbEBands;
528
529    loss_count = st->loss_count;
530    start = st->start;
531    noise_based = loss_count >= 5 || start != 0 || st->skip_plc;
532    if (noise_based)
533    {
534       /* Noise-based PLC/CNG */
535 #ifdef NORM_ALIASING_HACK
536       celt_norm *X;
537 #else
538       VARDECL(celt_norm, X);
539 #endif
540       opus_uint32 seed;
541       int end;
542       int effEnd;
543       opus_val16 decay;
544       end = st->end;
545       effEnd = IMAX(start, IMIN(end, mode->effEBands));
546
547 #ifdef NORM_ALIASING_HACK
548       /* This is an ugly hack that breaks aliasing rules and would be easily broken,
549          but it saves almost 4kB of stack. */
550       X = (celt_norm*)(out_syn[C-1]+overlap/2);
551 #else
552       ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
553 #endif
554
555       /* Energy decay */
556       decay = loss_count==0 ? QCONST16(1.5f, DB_SHIFT) : QCONST16(.5f, DB_SHIFT);
557       c=0; do
558       {
559          for (i=start;i<end;i++)
560             oldBandE[c*nbEBands+i] = MAX16(backgroundLogE[c*nbEBands+i], oldBandE[c*nbEBands+i] - decay);
561       } while (++c<C);
562       seed = st->rng;
563       for (c=0;c<C;c++)
564       {
565          for (i=start;i<effEnd;i++)
566          {
567             int j;
568             int boffs;
569             int blen;
570             boffs = N*c+(eBands[i]<<LM);
571             blen = (eBands[i+1]-eBands[i])<<LM;
572             for (j=0;j<blen;j++)
573             {
574                seed = celt_lcg_rand(seed);
575                X[boffs+j] = (celt_norm)((opus_int32)seed>>20);
576             }
577             renormalise_vector(X+boffs, blen, Q15ONE, st->arch);
578          }
579       }
580       st->rng = seed;
581
582       c=0; do {
583          OPUS_MOVE(decode_mem[c], decode_mem[c]+N,
584                DECODE_BUFFER_SIZE-N+(overlap>>1));
585       } while (++c<C);
586
587       celt_synthesis(mode, X, out_syn, oldBandE, start, effEnd, C, C, 0, LM, st->downsample, 0, st->arch);
588    } else {
589       int exc_length;
590       /* Pitch-based PLC */
591       const opus_val16 *window;
592       opus_val16 *exc;
593       opus_val16 fade = Q15ONE;
594       int pitch_index;
595       VARDECL(opus_val32, etmp);
596       VARDECL(opus_val16, _exc);
597       VARDECL(opus_val16, fir_tmp);
598
599       if (loss_count == 0)
600       {
601          st->last_pitch_index = pitch_index = celt_plc_pitch_search(decode_mem, C, st->arch);
602       } else {
603          pitch_index = st->last_pitch_index;
604          fade = QCONST16(.8f,15);
605       }
606
607       /* We want the excitation for 2 pitch periods in order to look for a
608          decaying signal, but we can't get more than MAX_PERIOD. */
609       exc_length = IMIN(2*pitch_index, MAX_PERIOD);
610
611       ALLOC(etmp, overlap, opus_val32);
612       ALLOC(_exc, MAX_PERIOD+LPC_ORDER, opus_val16);
613       ALLOC(fir_tmp, exc_length, opus_val16);
614       exc = _exc+LPC_ORDER;
615       window = mode->window;
616       c=0; do {
617          opus_val16 decay;
618          opus_val16 attenuation;
619          opus_val32 S1=0;
620          celt_sig *buf;
621          int extrapolation_offset;
622          int extrapolation_len;
623          int j;
624
625          buf = decode_mem[c];
626          for (i=0;i<MAX_PERIOD+LPC_ORDER;i++)
627             exc[i-LPC_ORDER] = ROUND16(buf[DECODE_BUFFER_SIZE-MAX_PERIOD-LPC_ORDER+i], SIG_SHIFT);
628
629          if (loss_count == 0)
630          {
631             opus_val32 ac[LPC_ORDER+1];
632             /* Compute LPC coefficients for the last MAX_PERIOD samples before
633                the first loss so we can work in the excitation-filter domain. */
634             _celt_autocorr(exc, ac, window, overlap,
635                    LPC_ORDER, MAX_PERIOD, st->arch);
636             /* Add a noise floor of -40 dB. */
637 #ifdef FIXED_POINT
638             ac[0] += SHR32(ac[0],13);
639 #else
640             ac[0] *= 1.0001f;
641 #endif
642             /* Use lag windowing to stabilize the Levinson-Durbin recursion. */
643             for (i=1;i<=LPC_ORDER;i++)
644             {
645                /*ac[i] *= exp(-.5*(2*M_PI*.002*i)*(2*M_PI*.002*i));*/
646 #ifdef FIXED_POINT
647                ac[i] -= MULT16_32_Q15(2*i*i, ac[i]);
648 #else
649                ac[i] -= ac[i]*(0.008f*0.008f)*i*i;
650 #endif
651             }
652             _celt_lpc(lpc+c*LPC_ORDER, ac, LPC_ORDER);
653 #ifdef FIXED_POINT
654          /* For fixed-point, apply bandwidth expansion until we can guarantee that
655             no overflow can happen in the IIR filter. This means:
656             32768*sum(abs(filter)) < 2^31 */
657          while (1) {
658             opus_val16 tmp=Q15ONE;
659             opus_val32 sum=QCONST16(1., SIG_SHIFT);
660             for (i=0;i<LPC_ORDER;i++)
661                sum += ABS16(lpc[c*LPC_ORDER+i]);
662             if (sum < 65535) break;
663             for (i=0;i<LPC_ORDER;i++)
664             {
665                tmp = MULT16_16_Q15(QCONST16(.99f,15), tmp);
666                lpc[c*LPC_ORDER+i] = MULT16_16_Q15(lpc[c*LPC_ORDER+i], tmp);
667             }
668          }
669 #endif
670          }
671          /* Initialize the LPC history with the samples just before the start
672             of the region for which we're computing the excitation. */
673          {
674             /* Compute the excitation for exc_length samples before the loss. We need the copy
675                because celt_fir() cannot filter in-place. */
676             celt_fir(exc+MAX_PERIOD-exc_length, lpc+c*LPC_ORDER,
677                   fir_tmp, exc_length, LPC_ORDER, st->arch);
678             OPUS_COPY(exc+MAX_PERIOD-exc_length, fir_tmp, exc_length);
679          }
680
681          /* Check if the waveform is decaying, and if so how fast.
682             We do this to avoid adding energy when concealing in a segment
683             with decaying energy. */
684          {
685             opus_val32 E1=1, E2=1;
686             int decay_length;
687 #ifdef FIXED_POINT
688             int shift = IMAX(0,2*celt_zlog2(celt_maxabs16(&exc[MAX_PERIOD-exc_length], exc_length))-20);
689 #endif
690             decay_length = exc_length>>1;
691             for (i=0;i<decay_length;i++)
692             {
693                opus_val16 e;
694                e = exc[MAX_PERIOD-decay_length+i];
695                E1 += SHR32(MULT16_16(e, e), shift);
696                e = exc[MAX_PERIOD-2*decay_length+i];
697                E2 += SHR32(MULT16_16(e, e), shift);
698             }
699             E1 = MIN32(E1, E2);
700             decay = celt_sqrt(frac_div32(SHR32(E1, 1), E2));
701          }
702
703          /* Move the decoder memory one frame to the left to give us room to
704             add the data for the new frame. We ignore the overlap that extends
705             past the end of the buffer, because we aren't going to use it. */
706          OPUS_MOVE(buf, buf+N, DECODE_BUFFER_SIZE-N);
707
708          /* Extrapolate from the end of the excitation with a period of
709             "pitch_index", scaling down each period by an additional factor of
710             "decay". */
711          extrapolation_offset = MAX_PERIOD-pitch_index;
712          /* We need to extrapolate enough samples to cover a complete MDCT
713             window (including overlap/2 samples on both sides). */
714          extrapolation_len = N+overlap;
715          /* We also apply fading if this is not the first loss. */
716          attenuation = MULT16_16_Q15(fade, decay);
717          for (i=j=0;i<extrapolation_len;i++,j++)
718          {
719             opus_val16 tmp;
720             if (j >= pitch_index) {
721                j -= pitch_index;
722                attenuation = MULT16_16_Q15(attenuation, decay);
723             }
724             buf[DECODE_BUFFER_SIZE-N+i] =
725                   SHL32(EXTEND32(MULT16_16_Q15(attenuation,
726                         exc[extrapolation_offset+j])), SIG_SHIFT);
727             /* Compute the energy of the previously decoded signal whose
728                excitation we're copying. */
729             tmp = ROUND16(
730                   buf[DECODE_BUFFER_SIZE-MAX_PERIOD-N+extrapolation_offset+j],
731                   SIG_SHIFT);
732             S1 += SHR32(MULT16_16(tmp, tmp), 10);
733          }
734          {
735             opus_val16 lpc_mem[LPC_ORDER];
736             /* Copy the last decoded samples (prior to the overlap region) to
737                synthesis filter memory so we can have a continuous signal. */
738             for (i=0;i<LPC_ORDER;i++)
739                lpc_mem[i] = ROUND16(buf[DECODE_BUFFER_SIZE-N-1-i], SIG_SHIFT);
740             /* Apply the synthesis filter to convert the excitation back into
741                the signal domain. */
742             celt_iir(buf+DECODE_BUFFER_SIZE-N, lpc+c*LPC_ORDER,
743                   buf+DECODE_BUFFER_SIZE-N, extrapolation_len, LPC_ORDER,
744                   lpc_mem, st->arch);
745 #ifdef FIXED_POINT
746             for (i=0; i < extrapolation_len; i++)
747                buf[DECODE_BUFFER_SIZE-N+i] = SATURATE(buf[DECODE_BUFFER_SIZE-N+i], SIG_SAT);
748 #endif
749          }
750
751          /* Check if the synthesis energy is higher than expected, which can
752             happen with the signal changes during our window. If so,
753             attenuate. */
754          {
755             opus_val32 S2=0;
756             for (i=0;i<extrapolation_len;i++)
757             {
758                opus_val16 tmp = ROUND16(buf[DECODE_BUFFER_SIZE-N+i], SIG_SHIFT);
759                S2 += SHR32(MULT16_16(tmp, tmp), 10);
760             }
761             /* This checks for an "explosion" in the synthesis. */
762 #ifdef FIXED_POINT
763             if (!(S1 > SHR32(S2,2)))
764 #else
765             /* The float test is written this way to catch NaNs in the output
766                of the IIR filter at the same time. */
767             if (!(S1 > 0.2f*S2))
768 #endif
769             {
770                for (i=0;i<extrapolation_len;i++)
771                   buf[DECODE_BUFFER_SIZE-N+i] = 0;
772             } else if (S1 < S2)
773             {
774                opus_val16 ratio = celt_sqrt(frac_div32(SHR32(S1,1)+1,S2+1));
775                for (i=0;i<overlap;i++)
776                {
777                   opus_val16 tmp_g = Q15ONE
778                         - MULT16_16_Q15(window[i], Q15ONE-ratio);
779                   buf[DECODE_BUFFER_SIZE-N+i] =
780                         MULT16_32_Q15(tmp_g, buf[DECODE_BUFFER_SIZE-N+i]);
781                }
782                for (i=overlap;i<extrapolation_len;i++)
783                {
784                   buf[DECODE_BUFFER_SIZE-N+i] =
785                         MULT16_32_Q15(ratio, buf[DECODE_BUFFER_SIZE-N+i]);
786                }
787             }
788          }
789
790          /* Apply the pre-filter to the MDCT overlap for the next frame because
791             the post-filter will be re-applied in the decoder after the MDCT
792             overlap. */
793          comb_filter(etmp, buf+DECODE_BUFFER_SIZE,
794               st->postfilter_period, st->postfilter_period, overlap,
795               -st->postfilter_gain, -st->postfilter_gain,
796               st->postfilter_tapset, st->postfilter_tapset, NULL, 0, st->arch);
797
798          /* Simulate TDAC on the concealed audio so that it blends with the
799             MDCT of the next frame. */
800          for (i=0;i<overlap/2;i++)
801          {
802             buf[DECODE_BUFFER_SIZE+i] =
803                MULT16_32_Q15(window[i], etmp[overlap-1-i])
804                + MULT16_32_Q15(window[overlap-i-1], etmp[i]);
805          }
806       } while (++c<C);
807    }
808
809    st->loss_count = loss_count+1;
810
811    RESTORE_STACK;
812 }
813
814 int celt_decode_with_ec(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data,
815       int len, opus_val16 * OPUS_RESTRICT pcm, int frame_size, ec_dec *dec, int accum)
816 {
817    int c, i, N;
818    int spread_decision;
819    opus_int32 bits;
820    ec_dec _dec;
821 #ifdef NORM_ALIASING_HACK
822    celt_norm *X;
823 #else
824    VARDECL(celt_norm, X);
825 #endif
826    VARDECL(int, fine_quant);
827    VARDECL(int, pulses);
828    VARDECL(int, cap);
829    VARDECL(int, offsets);
830    VARDECL(int, fine_priority);
831    VARDECL(int, tf_res);
832    VARDECL(unsigned char, collapse_masks);
833    celt_sig *decode_mem[2];
834    celt_sig *out_syn[2];
835    opus_val16 *lpc;
836    opus_val16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE;
837
838    int shortBlocks;
839    int isTransient;
840    int intra_ener;
841    const int CC = st->channels;
842    int LM, M;
843    int start;
844    int end;
845    int effEnd;
846    int codedBands;
847    int alloc_trim;
848    int postfilter_pitch;
849    opus_val16 postfilter_gain;
850    int intensity=0;
851    int dual_stereo=0;
852    opus_int32 total_bits;
853    opus_int32 balance;
854    opus_int32 tell;
855    int dynalloc_logp;
856    int postfilter_tapset;
857    int anti_collapse_rsv;
858    int anti_collapse_on=0;
859    int silence;
860    int C = st->stream_channels;
861    const OpusCustomMode *mode;
862    int nbEBands;
863    int overlap;
864    const opus_int16 *eBands;
865    ALLOC_STACK;
866
867    VALIDATE_CELT_DECODER(st);
868    mode = st->mode;
869    nbEBands = mode->nbEBands;
870    overlap = mode->overlap;
871    eBands = mode->eBands;
872    start = st->start;
873    end = st->end;
874    frame_size *= st->downsample;
875
876    lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+overlap)*CC);
877    oldBandE = lpc+CC*LPC_ORDER;
878    oldLogE = oldBandE + 2*nbEBands;
879    oldLogE2 = oldLogE + 2*nbEBands;
880    backgroundLogE = oldLogE2  + 2*nbEBands;
881
882 #ifdef CUSTOM_MODES
883    if (st->signalling && data!=NULL)
884    {
885       int data0=data[0];
886       /* Convert "standard mode" to Opus header */
887       if (mode->Fs==48000 && mode->shortMdctSize==120)
888       {
889          data0 = fromOpus(data0);
890          if (data0<0)
891             return OPUS_INVALID_PACKET;
892       }
893       st->end = end = IMAX(1, mode->effEBands-2*(data0>>5));
894       LM = (data0>>3)&0x3;
895       C = 1 + ((data0>>2)&0x1);
896       data++;
897       len--;
898       if (LM>mode->maxLM)
899          return OPUS_INVALID_PACKET;
900       if (frame_size < mode->shortMdctSize<<LM)
901          return OPUS_BUFFER_TOO_SMALL;
902       else
903          frame_size = mode->shortMdctSize<<LM;
904    } else {
905 #else
906    {
907 #endif
908       for (LM=0;LM<=mode->maxLM;LM++)
909          if (mode->shortMdctSize<<LM==frame_size)
910             break;
911       if (LM>mode->maxLM)
912          return OPUS_BAD_ARG;
913    }
914    M=1<<LM;
915
916    if (len<0 || len>1275 || pcm==NULL)
917       return OPUS_BAD_ARG;
918
919    N = M*mode->shortMdctSize;
920    c=0; do {
921       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+overlap);
922       out_syn[c] = decode_mem[c]+DECODE_BUFFER_SIZE-N;
923    } while (++c<CC);
924
925    effEnd = end;
926    if (effEnd > mode->effEBands)
927       effEnd = mode->effEBands;
928
929    if (data == NULL || len<=1)
930    {
931       celt_decode_lost(st, N, LM);
932       deemphasis(out_syn, pcm, N, CC, st->downsample, mode->preemph, st->preemph_memD, accum);
933       RESTORE_STACK;
934       return frame_size/st->downsample;
935    }
936
937    /* Check if there are at least two packets received consecutively before
938     * turning on the pitch-based PLC */
939    st->skip_plc = st->loss_count != 0;
940
941    if (dec == NULL)
942    {
943       ec_dec_init(&_dec,(unsigned char*)data,len);
944       dec = &_dec;
945    }
946
947    if (C==1)
948    {
949       for (i=0;i<nbEBands;i++)
950          oldBandE[i]=MAX16(oldBandE[i],oldBandE[nbEBands+i]);
951    }
952
953    total_bits = len*8;
954    tell = ec_tell(dec);
955
956    if (tell >= total_bits)
957       silence = 1;
958    else if (tell==1)
959       silence = ec_dec_bit_logp(dec, 15);
960    else
961       silence = 0;
962    if (silence)
963    {
964       /* Pretend we've read all the remaining bits */
965       tell = len*8;
966       dec->nbits_total+=tell-ec_tell(dec);
967    }
968
969    postfilter_gain = 0;
970    postfilter_pitch = 0;
971    postfilter_tapset = 0;
972    if (start==0 && tell+16 <= total_bits)
973    {
974       if(ec_dec_bit_logp(dec, 1))
975       {
976          int qg, octave;
977          octave = ec_dec_uint(dec, 6);
978          postfilter_pitch = (16<<octave)+ec_dec_bits(dec, 4+octave)-1;
979          qg = ec_dec_bits(dec, 3);
980          if (ec_tell(dec)+2<=total_bits)
981             postfilter_tapset = ec_dec_icdf(dec, tapset_icdf, 2);
982          postfilter_gain = QCONST16(.09375f,15)*(qg+1);
983       }
984       tell = ec_tell(dec);
985    }
986
987    if (LM > 0 && tell+3 <= total_bits)
988    {
989       isTransient = ec_dec_bit_logp(dec, 3);
990       tell = ec_tell(dec);
991    }
992    else
993       isTransient = 0;
994
995    if (isTransient)
996       shortBlocks = M;
997    else
998       shortBlocks = 0;
999
1000    /* Decode the global flags (first symbols in the stream) */
1001    intra_ener = tell+3<=total_bits ? ec_dec_bit_logp(dec, 3) : 0;
1002    /* Get band energies */
1003    unquant_coarse_energy(mode, start, end, oldBandE,
1004          intra_ener, dec, C, LM);
1005
1006    ALLOC(tf_res, nbEBands, int);
1007    tf_decode(start, end, isTransient, tf_res, LM, dec);
1008
1009    tell = ec_tell(dec);
1010    spread_decision = SPREAD_NORMAL;
1011    if (tell+4 <= total_bits)
1012       spread_decision = ec_dec_icdf(dec, spread_icdf, 5);
1013
1014    ALLOC(cap, nbEBands, int);
1015
1016    init_caps(mode,cap,LM,C);
1017
1018    ALLOC(offsets, nbEBands, int);
1019
1020    dynalloc_logp = 6;
1021    total_bits<<=BITRES;
1022    tell = ec_tell_frac(dec);
1023    for (i=start;i<end;i++)
1024    {
1025       int width, quanta;
1026       int dynalloc_loop_logp;
1027       int boost;
1028       width = C*(eBands[i+1]-eBands[i])<<LM;
1029       /* quanta is 6 bits, but no more than 1 bit/sample
1030          and no less than 1/8 bit/sample */
1031       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
1032       dynalloc_loop_logp = dynalloc_logp;
1033       boost = 0;
1034       while (tell+(dynalloc_loop_logp<<BITRES) < total_bits && boost < cap[i])
1035       {
1036          int flag;
1037          flag = ec_dec_bit_logp(dec, dynalloc_loop_logp);
1038          tell = ec_tell_frac(dec);
1039          if (!flag)
1040             break;
1041          boost += quanta;
1042          total_bits -= quanta;
1043          dynalloc_loop_logp = 1;
1044       }
1045       offsets[i] = boost;
1046       /* Making dynalloc more likely */
1047       if (boost>0)
1048          dynalloc_logp = IMAX(2, dynalloc_logp-1);
1049    }
1050
1051    ALLOC(fine_quant, nbEBands, int);
1052    alloc_trim = tell+(6<<BITRES) <= total_bits ?
1053          ec_dec_icdf(dec, trim_icdf, 7) : 5;
1054
1055    bits = (((opus_int32)len*8)<<BITRES) - ec_tell_frac(dec) - 1;
1056    anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0;
1057    bits -= anti_collapse_rsv;
1058
1059    ALLOC(pulses, nbEBands, int);
1060    ALLOC(fine_priority, nbEBands, int);
1061
1062    codedBands = clt_compute_allocation(mode, start, end, offsets, cap,
1063          alloc_trim, &intensity, &dual_stereo, bits, &balance, pulses,
1064          fine_quant, fine_priority, C, LM, dec, 0, 0, 0);
1065
1066    unquant_fine_energy(mode, start, end, oldBandE, fine_quant, dec, C);
1067
1068    c=0; do {
1069       OPUS_MOVE(decode_mem[c], decode_mem[c]+N, DECODE_BUFFER_SIZE-N+overlap/2);
1070    } while (++c<CC);
1071
1072    /* Decode fixed codebook */
1073    ALLOC(collapse_masks, C*nbEBands, unsigned char);
1074
1075 #ifdef NORM_ALIASING_HACK
1076    /* This is an ugly hack that breaks aliasing rules and would be easily broken,
1077       but it saves almost 4kB of stack. */
1078    X = (celt_norm*)(out_syn[CC-1]+overlap/2);
1079 #else
1080    ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
1081 #endif
1082
1083    quant_all_bands(0, mode, start, end, X, C==2 ? X+N : NULL, collapse_masks,
1084          NULL, pulses, shortBlocks, spread_decision, dual_stereo, intensity, tf_res,
1085          len*(8<<BITRES)-anti_collapse_rsv, balance, dec, LM, codedBands, &st->rng, 0,
1086          st->arch, st->disable_inv);
1087
1088    if (anti_collapse_rsv > 0)
1089    {
1090       anti_collapse_on = ec_dec_bits(dec, 1);
1091    }
1092
1093    unquant_energy_finalise(mode, start, end, oldBandE,
1094          fine_quant, fine_priority, len*8-ec_tell(dec), dec, C);
1095
1096    if (anti_collapse_on)
1097       anti_collapse(mode, X, collapse_masks, LM, C, N,
1098             start, end, oldBandE, oldLogE, oldLogE2, pulses, st->rng, st->arch);
1099
1100    if (silence)
1101    {
1102       for (i=0;i<C*nbEBands;i++)
1103          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
1104    }
1105
1106    celt_synthesis(mode, X, out_syn, oldBandE, start, effEnd,
1107                   C, CC, isTransient, LM, st->downsample, silence, st->arch);
1108
1109    c=0; do {
1110       st->postfilter_period=IMAX(st->postfilter_period, COMBFILTER_MINPERIOD);
1111       st->postfilter_period_old=IMAX(st->postfilter_period_old, COMBFILTER_MINPERIOD);
1112       comb_filter(out_syn[c], out_syn[c], st->postfilter_period_old, st->postfilter_period, mode->shortMdctSize,
1113             st->postfilter_gain_old, st->postfilter_gain, st->postfilter_tapset_old, st->postfilter_tapset,
1114             mode->window, overlap, st->arch);
1115       if (LM!=0)
1116          comb_filter(out_syn[c]+mode->shortMdctSize, out_syn[c]+mode->shortMdctSize, st->postfilter_period, postfilter_pitch, N-mode->shortMdctSize,
1117                st->postfilter_gain, postfilter_gain, st->postfilter_tapset, postfilter_tapset,
1118                mode->window, overlap, st->arch);
1119
1120    } while (++c<CC);
1121    st->postfilter_period_old = st->postfilter_period;
1122    st->postfilter_gain_old = st->postfilter_gain;
1123    st->postfilter_tapset_old = st->postfilter_tapset;
1124    st->postfilter_period = postfilter_pitch;
1125    st->postfilter_gain = postfilter_gain;
1126    st->postfilter_tapset = postfilter_tapset;
1127    if (LM!=0)
1128    {
1129       st->postfilter_period_old = st->postfilter_period;
1130       st->postfilter_gain_old = st->postfilter_gain;
1131       st->postfilter_tapset_old = st->postfilter_tapset;
1132    }
1133
1134    if (C==1)
1135       OPUS_COPY(&oldBandE[nbEBands], oldBandE, nbEBands);
1136
1137    /* In case start or end were to change */
1138    if (!isTransient)
1139    {
1140       opus_val16 max_background_increase;
1141       OPUS_COPY(oldLogE2, oldLogE, 2*nbEBands);
1142       OPUS_COPY(oldLogE, oldBandE, 2*nbEBands);
1143       /* In normal circumstances, we only allow the noise floor to increase by
1144          up to 2.4 dB/second, but when we're in DTX, we allow up to 6 dB
1145          increase for each update.*/
1146       if (st->loss_count < 10)
1147          max_background_increase = M*QCONST16(0.001f,DB_SHIFT);
1148       else
1149          max_background_increase = QCONST16(1.f,DB_SHIFT);
1150       for (i=0;i<2*nbEBands;i++)
1151          backgroundLogE[i] = MIN16(backgroundLogE[i] + max_background_increase, oldBandE[i]);
1152    } else {
1153       for (i=0;i<2*nbEBands;i++)
1154          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
1155    }
1156    c=0; do
1157    {
1158       for (i=0;i<start;i++)
1159       {
1160          oldBandE[c*nbEBands+i]=0;
1161          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
1162       }
1163       for (i=end;i<nbEBands;i++)
1164       {
1165          oldBandE[c*nbEBands+i]=0;
1166          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
1167       }
1168    } while (++c<2);
1169    st->rng = dec->rng;
1170
1171    deemphasis(out_syn, pcm, N, CC, st->downsample, mode->preemph, st->preemph_memD, accum);
1172    st->loss_count = 0;
1173    RESTORE_STACK;
1174    if (ec_tell(dec) > 8*len)
1175       return OPUS_INTERNAL_ERROR;
1176    if(ec_get_error(dec))
1177       st->error = 1;
1178    return frame_size/st->downsample;
1179 }
1180
1181
1182 #ifdef CUSTOM_MODES
1183
1184 #ifdef FIXED_POINT
1185 int opus_custom_decode(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, opus_int16 * OPUS_RESTRICT pcm, int frame_size)
1186 {
1187    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL, 0);
1188 }
1189
1190 #ifndef DISABLE_FLOAT_API
1191 int opus_custom_decode_float(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, float * OPUS_RESTRICT pcm, int frame_size)
1192 {
1193    int j, ret, C, N;
1194    VARDECL(opus_int16, out);
1195    ALLOC_STACK;
1196
1197    if (pcm==NULL)
1198       return OPUS_BAD_ARG;
1199
1200    C = st->channels;
1201    N = frame_size;
1202
1203    ALLOC(out, C*N, opus_int16);
1204    ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL, 0);
1205    if (ret>0)
1206       for (j=0;j<C*ret;j++)
1207          pcm[j]=out[j]*(1.f/32768.f);
1208
1209    RESTORE_STACK;
1210    return ret;
1211 }
1212 #endif /* DISABLE_FLOAT_API */
1213
1214 #else
1215
1216 int opus_custom_decode_float(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, float * OPUS_RESTRICT pcm, int frame_size)
1217 {
1218    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL, 0);
1219 }
1220
1221 int opus_custom_decode(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, opus_int16 * OPUS_RESTRICT pcm, int frame_size)
1222 {
1223    int j, ret, C, N;
1224    VARDECL(celt_sig, out);
1225    ALLOC_STACK;
1226
1227    if (pcm==NULL)
1228       return OPUS_BAD_ARG;
1229
1230    C = st->channels;
1231    N = frame_size;
1232    ALLOC(out, C*N, celt_sig);
1233
1234    ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL, 0);
1235
1236    if (ret>0)
1237       for (j=0;j<C*ret;j++)
1238          pcm[j] = FLOAT2INT16 (out[j]);
1239
1240    RESTORE_STACK;
1241    return ret;
1242 }
1243
1244 #endif
1245 #endif /* CUSTOM_MODES */
1246
1247 int opus_custom_decoder_ctl(CELTDecoder * OPUS_RESTRICT st, int request, ...)
1248 {
1249    va_list ap;
1250
1251    va_start(ap, request);
1252    switch (request)
1253    {
1254       case CELT_SET_START_BAND_REQUEST:
1255       {
1256          opus_int32 value = va_arg(ap, opus_int32);
1257          if (value<0 || value>=st->mode->nbEBands)
1258             goto bad_arg;
1259          st->start = value;
1260       }
1261       break;
1262       case CELT_SET_END_BAND_REQUEST:
1263       {
1264          opus_int32 value = va_arg(ap, opus_int32);
1265          if (value<1 || value>st->mode->nbEBands)
1266             goto bad_arg;
1267          st->end = value;
1268       }
1269       break;
1270       case CELT_SET_CHANNELS_REQUEST:
1271       {
1272          opus_int32 value = va_arg(ap, opus_int32);
1273          if (value<1 || value>2)
1274             goto bad_arg;
1275          st->stream_channels = value;
1276       }
1277       break;
1278       case CELT_GET_AND_CLEAR_ERROR_REQUEST:
1279       {
1280          opus_int32 *value = va_arg(ap, opus_int32*);
1281          if (value==NULL)
1282             goto bad_arg;
1283          *value=st->error;
1284          st->error = 0;
1285       }
1286       break;
1287       case OPUS_GET_LOOKAHEAD_REQUEST:
1288       {
1289          opus_int32 *value = va_arg(ap, opus_int32*);
1290          if (value==NULL)
1291             goto bad_arg;
1292          *value = st->overlap/st->downsample;
1293       }
1294       break;
1295       case OPUS_RESET_STATE:
1296       {
1297          int i;
1298          opus_val16 *lpc, *oldBandE, *oldLogE, *oldLogE2;
1299          lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*st->channels);
1300          oldBandE = lpc+st->channels*LPC_ORDER;
1301          oldLogE = oldBandE + 2*st->mode->nbEBands;
1302          oldLogE2 = oldLogE + 2*st->mode->nbEBands;
1303          OPUS_CLEAR((char*)&st->DECODER_RESET_START,
1304                opus_custom_decoder_get_size(st->mode, st->channels)-
1305                ((char*)&st->DECODER_RESET_START - (char*)st));
1306          for (i=0;i<2*st->mode->nbEBands;i++)
1307             oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT);
1308          st->skip_plc = 1;
1309       }
1310       break;
1311       case OPUS_GET_PITCH_REQUEST:
1312       {
1313          opus_int32 *value = va_arg(ap, opus_int32*);
1314          if (value==NULL)
1315             goto bad_arg;
1316          *value = st->postfilter_period;
1317       }
1318       break;
1319       case CELT_GET_MODE_REQUEST:
1320       {
1321          const CELTMode ** value = va_arg(ap, const CELTMode**);
1322          if (value==0)
1323             goto bad_arg;
1324          *value=st->mode;
1325       }
1326       break;
1327       case CELT_SET_SIGNALLING_REQUEST:
1328       {
1329          opus_int32 value = va_arg(ap, opus_int32);
1330          st->signalling = value;
1331       }
1332       break;
1333       case OPUS_GET_FINAL_RANGE_REQUEST:
1334       {
1335          opus_uint32 * value = va_arg(ap, opus_uint32 *);
1336          if (value==0)
1337             goto bad_arg;
1338          *value=st->rng;
1339       }
1340       break;
1341       case OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST:
1342       {
1343           opus_int32 value = va_arg(ap, opus_int32);
1344           if(value<0 || value>1)
1345           {
1346              goto bad_arg;
1347           }
1348           st->disable_inv = value;
1349       }
1350       break;
1351       case OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST:
1352       {
1353           opus_int32 *value = va_arg(ap, opus_int32*);
1354           if (!value)
1355           {
1356              goto bad_arg;
1357           }
1358           *value = st->disable_inv;
1359       }
1360       break;
1361       default:
1362          goto bad_request;
1363    }
1364    va_end(ap);
1365    return OPUS_OK;
1366 bad_arg:
1367    va_end(ap);
1368    return OPUS_BAD_ARG;
1369 bad_request:
1370       va_end(ap);
1371   return OPUS_UNIMPLEMENTED;
1372 }