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