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