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