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