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