Merge branch 'surround'
[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             decay_length = exc_length>>1;
510             for (i=0;i<decay_length;i++)
511             {
512                opus_val16 e;
513                e = exc[MAX_PERIOD-decay_length+i];
514                E1 += SHR32(MULT16_16(e, e), 8);
515                e = exc[MAX_PERIOD-2*decay_length+i];
516                E2 += SHR32(MULT16_16(e, e), 8);
517             }
518             E1 = MIN32(E1, E2);
519             decay = celt_sqrt(frac_div32(SHR32(E1, 1), E2));
520          }
521
522          /* Move the decoder memory one frame to the left to give us room to
523             add the data for the new frame. We ignore the overlap that extends
524             past the end of the buffer, because we aren't going to use it. */
525          OPUS_MOVE(buf, buf+N, DECODE_BUFFER_SIZE-N);
526
527          /* Extrapolate from the end of the excitation with a period of
528             "pitch_index", scaling down each period by an additional factor of
529             "decay". */
530          extrapolation_offset = MAX_PERIOD-pitch_index;
531          /* We need to extrapolate enough samples to cover a complete MDCT
532             window (including overlap/2 samples on both sides). */
533          extrapolation_len = N+overlap;
534          /* We also apply fading if this is not the first loss. */
535          attenuation = MULT16_16_Q15(fade, decay);
536          for (i=j=0;i<extrapolation_len;i++,j++)
537          {
538             opus_val16 tmp;
539             if (j >= pitch_index) {
540                j -= pitch_index;
541                attenuation = MULT16_16_Q15(attenuation, decay);
542             }
543             buf[DECODE_BUFFER_SIZE-N+i] =
544                   SHL32(EXTEND32(MULT16_16_Q15(attenuation,
545                         exc[extrapolation_offset+j])), SIG_SHIFT);
546             /* Compute the energy of the previously decoded signal whose
547                excitation we're copying. */
548             tmp = ROUND16(
549                   buf[DECODE_BUFFER_SIZE-MAX_PERIOD-N+extrapolation_offset+j],
550                   SIG_SHIFT);
551             S1 += SHR32(MULT16_16(tmp, tmp), 8);
552          }
553
554          {
555             opus_val16 lpc_mem[LPC_ORDER];
556             /* Copy the last decoded samples (prior to the overlap region) to
557                synthesis filter memory so we can have a continuous signal. */
558             for (i=0;i<LPC_ORDER;i++)
559                lpc_mem[i] = ROUND16(buf[DECODE_BUFFER_SIZE-N-1-i], SIG_SHIFT);
560             /* Apply the synthesis filter to convert the excitation back into
561                the signal domain. */
562             celt_iir(buf+DECODE_BUFFER_SIZE-N, lpc+c*LPC_ORDER,
563                   buf+DECODE_BUFFER_SIZE-N, extrapolation_len, LPC_ORDER,
564                   lpc_mem);
565          }
566
567          /* Check if the synthesis energy is higher than expected, which can
568             happen with the signal changes during our window. If so,
569             attenuate. */
570          {
571             opus_val32 S2=0;
572             for (i=0;i<extrapolation_len;i++)
573             {
574                opus_val16 tmp = ROUND16(buf[DECODE_BUFFER_SIZE-N+i], SIG_SHIFT);
575                S2 += SHR32(MULT16_16(tmp, tmp), 8);
576             }
577             /* This checks for an "explosion" in the synthesis. */
578 #ifdef FIXED_POINT
579             if (!(S1 > SHR32(S2,2)))
580 #else
581             /* The float test is written this way to catch NaNs in the output
582                of the IIR filter at the same time. */
583             if (!(S1 > 0.2f*S2))
584 #endif
585             {
586                for (i=0;i<extrapolation_len;i++)
587                   buf[DECODE_BUFFER_SIZE-N+i] = 0;
588             } else if (S1 < S2)
589             {
590                opus_val16 ratio = celt_sqrt(frac_div32(SHR32(S1,1)+1,S2+1));
591                for (i=0;i<overlap;i++)
592                {
593                   opus_val16 tmp_g = Q15ONE
594                         - MULT16_16_Q15(window[i], Q15ONE-ratio);
595                   buf[DECODE_BUFFER_SIZE-N+i] =
596                         MULT16_32_Q15(tmp_g, buf[DECODE_BUFFER_SIZE-N+i]);
597                }
598                for (i=overlap;i<extrapolation_len;i++)
599                {
600                   buf[DECODE_BUFFER_SIZE-N+i] =
601                         MULT16_32_Q15(ratio, buf[DECODE_BUFFER_SIZE-N+i]);
602                }
603             }
604          }
605
606          /* Apply the pre-filter to the MDCT overlap for the next frame because
607             the post-filter will be re-applied in the decoder after the MDCT
608             overlap. */
609          comb_filter(etmp, buf+DECODE_BUFFER_SIZE,
610               st->postfilter_period, st->postfilter_period, overlap,
611               -st->postfilter_gain, -st->postfilter_gain,
612               st->postfilter_tapset, st->postfilter_tapset, NULL, 0);
613
614          /* Simulate TDAC on the concealed audio so that it blends with the
615             MDCT of the next frame. */
616          for (i=0;i<overlap/2;i++)
617          {
618             buf[DECODE_BUFFER_SIZE+i] =
619                MULT16_32_Q15(window[i], etmp[overlap-1-i])
620                + MULT16_32_Q15(window[overlap-i-1], etmp[i]);
621          }
622       } while (++c<C);
623    }
624
625    deemphasis(out_syn, pcm, N, C, downsample,
626          mode->preemph, st->preemph_memD, scratch);
627
628    st->loss_count = loss_count+1;
629
630    RESTORE_STACK;
631 }
632
633 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)
634 {
635    int c, i, N;
636    int spread_decision;
637    opus_int32 bits;
638    ec_dec _dec;
639    VARDECL(celt_sig, freq);
640    VARDECL(celt_norm, X);
641    VARDECL(celt_ener, bandE);
642    VARDECL(int, fine_quant);
643    VARDECL(int, pulses);
644    VARDECL(int, cap);
645    VARDECL(int, offsets);
646    VARDECL(int, fine_priority);
647    VARDECL(int, tf_res);
648    VARDECL(unsigned char, collapse_masks);
649    celt_sig *out_mem[2];
650    celt_sig *decode_mem[2];
651    celt_sig *out_syn[2];
652    opus_val16 *lpc;
653    opus_val16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE;
654
655    int shortBlocks;
656    int isTransient;
657    int intra_ener;
658    const int CC = st->channels;
659    int LM, M;
660    int effEnd;
661    int codedBands;
662    int alloc_trim;
663    int postfilter_pitch;
664    opus_val16 postfilter_gain;
665    int intensity=0;
666    int dual_stereo=0;
667    opus_int32 total_bits;
668    opus_int32 balance;
669    opus_int32 tell;
670    int dynalloc_logp;
671    int postfilter_tapset;
672    int anti_collapse_rsv;
673    int anti_collapse_on=0;
674    int silence;
675    int C = st->stream_channels;
676    const OpusCustomMode *mode;
677    int nbEBands;
678    int overlap;
679    const opus_int16 *eBands;
680    ALLOC_STACK;
681
682    mode = st->mode;
683    nbEBands = mode->nbEBands;
684    overlap = mode->overlap;
685    eBands = mode->eBands;
686    frame_size *= st->downsample;
687
688    c=0; do {
689       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+overlap);
690       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
691    } while (++c<CC);
692    lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+overlap)*CC);
693    oldBandE = lpc+CC*LPC_ORDER;
694    oldLogE = oldBandE + 2*nbEBands;
695    oldLogE2 = oldLogE + 2*nbEBands;
696    backgroundLogE = oldLogE2  + 2*nbEBands;
697
698 #ifdef CUSTOM_MODES
699    if (st->signalling && data!=NULL)
700    {
701       int data0=data[0];
702       /* Convert "standard mode" to Opus header */
703       if (mode->Fs==48000 && mode->shortMdctSize==120)
704       {
705          data0 = fromOpus(data0);
706          if (data0<0)
707             return OPUS_INVALID_PACKET;
708       }
709       st->end = IMAX(1, mode->effEBands-2*(data0>>5));
710       LM = (data0>>3)&0x3;
711       C = 1 + ((data0>>2)&0x1);
712       data++;
713       len--;
714       if (LM>mode->maxLM)
715          return OPUS_INVALID_PACKET;
716       if (frame_size < mode->shortMdctSize<<LM)
717          return OPUS_BUFFER_TOO_SMALL;
718       else
719          frame_size = mode->shortMdctSize<<LM;
720    } else {
721 #else
722    {
723 #endif
724       for (LM=0;LM<=mode->maxLM;LM++)
725          if (mode->shortMdctSize<<LM==frame_size)
726             break;
727       if (LM>mode->maxLM)
728          return OPUS_BAD_ARG;
729    }
730    M=1<<LM;
731
732    if (len<0 || len>1275 || pcm==NULL)
733       return OPUS_BAD_ARG;
734
735    N = M*mode->shortMdctSize;
736
737    effEnd = st->end;
738    if (effEnd > mode->effEBands)
739       effEnd = mode->effEBands;
740
741    if (data == NULL || len<=1)
742    {
743       celt_decode_lost(st, pcm, N, LM);
744       RESTORE_STACK;
745       return frame_size/st->downsample;
746    }
747
748    if (dec == NULL)
749    {
750       ec_dec_init(&_dec,(unsigned char*)data,len);
751       dec = &_dec;
752    }
753
754    if (C==1)
755    {
756       for (i=0;i<nbEBands;i++)
757          oldBandE[i]=MAX16(oldBandE[i],oldBandE[nbEBands+i]);
758    }
759
760    total_bits = len*8;
761    tell = ec_tell(dec);
762
763    if (tell >= total_bits)
764       silence = 1;
765    else if (tell==1)
766       silence = ec_dec_bit_logp(dec, 15);
767    else
768       silence = 0;
769    if (silence)
770    {
771       /* Pretend we've read all the remaining bits */
772       tell = len*8;
773       dec->nbits_total+=tell-ec_tell(dec);
774    }
775
776    postfilter_gain = 0;
777    postfilter_pitch = 0;
778    postfilter_tapset = 0;
779    if (st->start==0 && tell+16 <= total_bits)
780    {
781       if(ec_dec_bit_logp(dec, 1))
782       {
783          int qg, octave;
784          octave = ec_dec_uint(dec, 6);
785          postfilter_pitch = (16<<octave)+ec_dec_bits(dec, 4+octave)-1;
786          qg = ec_dec_bits(dec, 3);
787          if (ec_tell(dec)+2<=total_bits)
788             postfilter_tapset = ec_dec_icdf(dec, tapset_icdf, 2);
789          postfilter_gain = QCONST16(.09375f,15)*(qg+1);
790       }
791       tell = ec_tell(dec);
792    }
793
794    if (LM > 0 && tell+3 <= total_bits)
795    {
796       isTransient = ec_dec_bit_logp(dec, 3);
797       tell = ec_tell(dec);
798    }
799    else
800       isTransient = 0;
801
802    if (isTransient)
803       shortBlocks = M;
804    else
805       shortBlocks = 0;
806
807    /* Decode the global flags (first symbols in the stream) */
808    intra_ener = tell+3<=total_bits ? ec_dec_bit_logp(dec, 3) : 0;
809    /* Get band energies */
810    unquant_coarse_energy(mode, st->start, st->end, oldBandE,
811          intra_ener, dec, C, LM);
812
813    ALLOC(tf_res, nbEBands, int);
814    tf_decode(st->start, st->end, isTransient, tf_res, LM, dec);
815
816    tell = ec_tell(dec);
817    spread_decision = SPREAD_NORMAL;
818    if (tell+4 <= total_bits)
819       spread_decision = ec_dec_icdf(dec, spread_icdf, 5);
820
821    ALLOC(cap, nbEBands, int);
822
823    init_caps(mode,cap,LM,C);
824
825    ALLOC(offsets, nbEBands, int);
826
827    dynalloc_logp = 6;
828    total_bits<<=BITRES;
829    tell = ec_tell_frac(dec);
830    for (i=st->start;i<st->end;i++)
831    {
832       int width, quanta;
833       int dynalloc_loop_logp;
834       int boost;
835       width = C*(eBands[i+1]-eBands[i])<<LM;
836       /* quanta is 6 bits, but no more than 1 bit/sample
837          and no less than 1/8 bit/sample */
838       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
839       dynalloc_loop_logp = dynalloc_logp;
840       boost = 0;
841       while (tell+(dynalloc_loop_logp<<BITRES) < total_bits && boost < cap[i])
842       {
843          int flag;
844          flag = ec_dec_bit_logp(dec, dynalloc_loop_logp);
845          tell = ec_tell_frac(dec);
846          if (!flag)
847             break;
848          boost += quanta;
849          total_bits -= quanta;
850          dynalloc_loop_logp = 1;
851       }
852       offsets[i] = boost;
853       /* Making dynalloc more likely */
854       if (boost>0)
855          dynalloc_logp = IMAX(2, dynalloc_logp-1);
856    }
857
858    ALLOC(fine_quant, nbEBands, int);
859    alloc_trim = tell+(6<<BITRES) <= total_bits ?
860          ec_dec_icdf(dec, trim_icdf, 7) : 5;
861
862    bits = (((opus_int32)len*8)<<BITRES) - ec_tell_frac(dec) - 1;
863    anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0;
864    bits -= anti_collapse_rsv;
865
866    ALLOC(pulses, nbEBands, int);
867    ALLOC(fine_priority, nbEBands, int);
868
869    codedBands = compute_allocation(mode, st->start, st->end, offsets, cap,
870          alloc_trim, &intensity, &dual_stereo, bits, &balance, pulses,
871          fine_quant, fine_priority, C, LM, dec, 0, 0, 0);
872
873    unquant_fine_energy(mode, st->start, st->end, oldBandE, fine_quant, dec, C);
874
875    /* Decode fixed codebook */
876    ALLOC(collapse_masks, C*nbEBands, unsigned char);
877    ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
878
879    quant_all_bands(0, mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
880          NULL, pulses, shortBlocks, spread_decision, dual_stereo, intensity, tf_res,
881          len*(8<<BITRES)-anti_collapse_rsv, balance, dec, LM, codedBands, &st->rng);
882
883    if (anti_collapse_rsv > 0)
884    {
885       anti_collapse_on = ec_dec_bits(dec, 1);
886    }
887
888    unquant_energy_finalise(mode, st->start, st->end, oldBandE,
889          fine_quant, fine_priority, len*8-ec_tell(dec), dec, C);
890
891    if (anti_collapse_on)
892       anti_collapse(mode, X, collapse_masks, LM, C, N,
893             st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
894
895    ALLOC(bandE, nbEBands*C, celt_ener);
896
897    log2Amp(mode, st->start, st->end, bandE, oldBandE, C);
898
899    if (silence)
900    {
901       for (i=0;i<C*nbEBands;i++)
902       {
903          bandE[i] = 0;
904          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
905       }
906    }
907    ALLOC(freq, IMAX(CC,C)*N, celt_sig); /**< Interleaved signal MDCTs */
908    /* Synthesis */
909    denormalise_bands(mode, X, freq, bandE, st->start, effEnd, C, M);
910
911    c=0; do {
912       OPUS_MOVE(decode_mem[c], decode_mem[c]+N, DECODE_BUFFER_SIZE-N+overlap/2);
913    } while (++c<CC);
914
915    c=0; do {
916       int bound = M*eBands[effEnd];
917       if (st->downsample!=1)
918          bound = IMIN(bound, N/st->downsample);
919       for (i=bound;i<N;i++)
920          freq[c*N+i] = 0;
921    } while (++c<C);
922
923    c=0; do {
924       out_syn[c] = out_mem[c]+MAX_PERIOD-N;
925    } while (++c<CC);
926
927    if (CC==2&&C==1)
928    {
929       for (i=0;i<N;i++)
930          freq[N+i] = freq[i];
931    }
932    if (CC==1&&C==2)
933    {
934       for (i=0;i<N;i++)
935          freq[i] = HALF32(ADD32(freq[i],freq[N+i]));
936    }
937
938    /* Compute inverse MDCTs */
939    compute_inv_mdcts(mode, shortBlocks, freq, out_syn, CC, LM);
940
941    c=0; do {
942       st->postfilter_period=IMAX(st->postfilter_period, COMBFILTER_MINPERIOD);
943       st->postfilter_period_old=IMAX(st->postfilter_period_old, COMBFILTER_MINPERIOD);
944       comb_filter(out_syn[c], out_syn[c], st->postfilter_period_old, st->postfilter_period, mode->shortMdctSize,
945             st->postfilter_gain_old, st->postfilter_gain, st->postfilter_tapset_old, st->postfilter_tapset,
946             mode->window, overlap);
947       if (LM!=0)
948          comb_filter(out_syn[c]+mode->shortMdctSize, out_syn[c]+mode->shortMdctSize, st->postfilter_period, postfilter_pitch, N-mode->shortMdctSize,
949                st->postfilter_gain, postfilter_gain, st->postfilter_tapset, postfilter_tapset,
950                mode->window, overlap);
951
952    } while (++c<CC);
953    st->postfilter_period_old = st->postfilter_period;
954    st->postfilter_gain_old = st->postfilter_gain;
955    st->postfilter_tapset_old = st->postfilter_tapset;
956    st->postfilter_period = postfilter_pitch;
957    st->postfilter_gain = postfilter_gain;
958    st->postfilter_tapset = postfilter_tapset;
959    if (LM!=0)
960    {
961       st->postfilter_period_old = st->postfilter_period;
962       st->postfilter_gain_old = st->postfilter_gain;
963       st->postfilter_tapset_old = st->postfilter_tapset;
964    }
965
966    if (C==1) {
967       for (i=0;i<nbEBands;i++)
968          oldBandE[nbEBands+i]=oldBandE[i];
969    }
970
971    /* In case start or end were to change */
972    if (!isTransient)
973    {
974       for (i=0;i<2*nbEBands;i++)
975          oldLogE2[i] = oldLogE[i];
976       for (i=0;i<2*nbEBands;i++)
977          oldLogE[i] = oldBandE[i];
978       for (i=0;i<2*nbEBands;i++)
979          backgroundLogE[i] = MIN16(backgroundLogE[i] + M*QCONST16(0.001f,DB_SHIFT), oldBandE[i]);
980    } else {
981       for (i=0;i<2*nbEBands;i++)
982          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
983    }
984    c=0; do
985    {
986       for (i=0;i<st->start;i++)
987       {
988          oldBandE[c*nbEBands+i]=0;
989          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
990       }
991       for (i=st->end;i<nbEBands;i++)
992       {
993          oldBandE[c*nbEBands+i]=0;
994          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
995       }
996    } while (++c<2);
997    st->rng = dec->rng;
998
999    /* We reuse freq[] as scratch space for the de-emphasis */
1000    deemphasis(out_syn, pcm, N, CC, st->downsample, mode->preemph, st->preemph_memD, freq);
1001    st->loss_count = 0;
1002    RESTORE_STACK;
1003    if (ec_tell(dec) > 8*len)
1004       return OPUS_INTERNAL_ERROR;
1005    if(ec_get_error(dec))
1006       st->error = 1;
1007    return frame_size/st->downsample;
1008 }
1009
1010
1011 #ifdef CUSTOM_MODES
1012
1013 #ifdef FIXED_POINT
1014 int opus_custom_decode(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, opus_int16 * OPUS_RESTRICT pcm, int frame_size)
1015 {
1016    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
1017 }
1018
1019 #ifndef DISABLE_FLOAT_API
1020 int opus_custom_decode_float(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, float * OPUS_RESTRICT pcm, int frame_size)
1021 {
1022    int j, ret, C, N;
1023    VARDECL(opus_int16, out);
1024    ALLOC_STACK;
1025
1026    if (pcm==NULL)
1027       return OPUS_BAD_ARG;
1028
1029    C = st->channels;
1030    N = frame_size;
1031
1032    ALLOC(out, C*N, opus_int16);
1033    ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL);
1034    if (ret>0)
1035       for (j=0;j<C*ret;j++)
1036          pcm[j]=out[j]*(1.f/32768.f);
1037
1038    RESTORE_STACK;
1039    return ret;
1040 }
1041 #endif /* DISABLE_FLOAT_API */
1042
1043 #else
1044
1045 int opus_custom_decode_float(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, float * OPUS_RESTRICT pcm, int frame_size)
1046 {
1047    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
1048 }
1049
1050 int opus_custom_decode(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, opus_int16 * OPUS_RESTRICT pcm, int frame_size)
1051 {
1052    int j, ret, C, N;
1053    VARDECL(celt_sig, out);
1054    ALLOC_STACK;
1055
1056    if (pcm==NULL)
1057       return OPUS_BAD_ARG;
1058
1059    C = st->channels;
1060    N = frame_size;
1061    ALLOC(out, C*N, celt_sig);
1062
1063    ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL);
1064
1065    if (ret>0)
1066       for (j=0;j<C*ret;j++)
1067          pcm[j] = FLOAT2INT16 (out[j]);
1068
1069    RESTORE_STACK;
1070    return ret;
1071 }
1072
1073 #endif
1074 #endif /* CUSTOM_MODES */
1075
1076 int opus_custom_decoder_ctl(CELTDecoder * OPUS_RESTRICT st, int request, ...)
1077 {
1078    va_list ap;
1079
1080    va_start(ap, request);
1081    switch (request)
1082    {
1083       case CELT_SET_START_BAND_REQUEST:
1084       {
1085          opus_int32 value = va_arg(ap, opus_int32);
1086          if (value<0 || value>=st->mode->nbEBands)
1087             goto bad_arg;
1088          st->start = value;
1089       }
1090       break;
1091       case CELT_SET_END_BAND_REQUEST:
1092       {
1093          opus_int32 value = va_arg(ap, opus_int32);
1094          if (value<1 || value>st->mode->nbEBands)
1095             goto bad_arg;
1096          st->end = value;
1097       }
1098       break;
1099       case CELT_SET_CHANNELS_REQUEST:
1100       {
1101          opus_int32 value = va_arg(ap, opus_int32);
1102          if (value<1 || value>2)
1103             goto bad_arg;
1104          st->stream_channels = value;
1105       }
1106       break;
1107       case CELT_GET_AND_CLEAR_ERROR_REQUEST:
1108       {
1109          opus_int32 *value = va_arg(ap, opus_int32*);
1110          if (value==NULL)
1111             goto bad_arg;
1112          *value=st->error;
1113          st->error = 0;
1114       }
1115       break;
1116       case OPUS_GET_LOOKAHEAD_REQUEST:
1117       {
1118          opus_int32 *value = va_arg(ap, opus_int32*);
1119          if (value==NULL)
1120             goto bad_arg;
1121          *value = st->overlap/st->downsample;
1122       }
1123       break;
1124       case OPUS_RESET_STATE:
1125       {
1126          int i;
1127          opus_val16 *lpc, *oldBandE, *oldLogE, *oldLogE2;
1128          lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*st->channels);
1129          oldBandE = lpc+st->channels*LPC_ORDER;
1130          oldLogE = oldBandE + 2*st->mode->nbEBands;
1131          oldLogE2 = oldLogE + 2*st->mode->nbEBands;
1132          OPUS_CLEAR((char*)&st->DECODER_RESET_START,
1133                opus_custom_decoder_get_size(st->mode, st->channels)-
1134                ((char*)&st->DECODER_RESET_START - (char*)st));
1135          for (i=0;i<2*st->mode->nbEBands;i++)
1136             oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT);
1137       }
1138       break;
1139       case OPUS_GET_PITCH_REQUEST:
1140       {
1141          opus_int32 *value = va_arg(ap, opus_int32*);
1142          if (value==NULL)
1143             goto bad_arg;
1144          *value = st->postfilter_period;
1145       }
1146       break;
1147       case CELT_GET_MODE_REQUEST:
1148       {
1149          const CELTMode ** value = va_arg(ap, const CELTMode**);
1150          if (value==0)
1151             goto bad_arg;
1152          *value=st->mode;
1153       }
1154       break;
1155       case CELT_SET_SIGNALLING_REQUEST:
1156       {
1157          opus_int32 value = va_arg(ap, opus_int32);
1158          st->signalling = value;
1159       }
1160       break;
1161       case OPUS_GET_FINAL_RANGE_REQUEST:
1162       {
1163          opus_uint32 * value = va_arg(ap, opus_uint32 *);
1164          if (value==0)
1165             goto bad_arg;
1166          *value=st->rng;
1167       }
1168       break;
1169       default:
1170          goto bad_request;
1171    }
1172    va_end(ap);
1173    return OPUS_OK;
1174 bad_arg:
1175    va_end(ap);
1176    return OPUS_BAD_ARG;
1177 bad_request:
1178       va_end(ap);
1179   return OPUS_UNIMPLEMENTED;
1180 }