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