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