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