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