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