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