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