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