bfcdf4152d231b89ebc0568b68eb21a156445ec8
[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 /* The maximum pitch lag to allow in the pitch-based PLC. It's possible to save
305    CPU time in the PLC pitch search by making this smaller than MAX_PERIOD. The
306    current value corresponds to a pitch of 66.67 Hz. */
307 #define PLC_PITCH_LAG_MAX (720)
308 /* The minimum pitch lag to allow in the pitch-based PLC. This corresponds to a
309    pitch of 480 Hz. */
310 #define PLC_PITCH_LAG_MIN (100)
311
312 static void celt_decode_lost(CELTDecoder * OPUS_RESTRICT st, opus_val16 * OPUS_RESTRICT pcm, int N, int LM)
313 {
314    int c;
315    int i;
316    const int C = st->channels;
317    celt_sig *decode_mem[2];
318    celt_sig *out_syn[2];
319    opus_val16 *lpc;
320    opus_val16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE;
321    const OpusCustomMode *mode;
322    int nbEBands;
323    int overlap;
324    int start;
325    int downsample;
326    int loss_count;
327    int noise_based;
328    const opus_int16 *eBands;
329    VARDECL(celt_sig, scratch);
330    SAVE_STACK;
331
332    mode = st->mode;
333    nbEBands = mode->nbEBands;
334    overlap = mode->overlap;
335    eBands = mode->eBands;
336
337    c=0; do {
338       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+overlap);
339       out_syn[c] = decode_mem[c]+DECODE_BUFFER_SIZE-N;
340    } while (++c<C);
341    lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+overlap)*C);
342    oldBandE = lpc+C*LPC_ORDER;
343    oldLogE = oldBandE + 2*nbEBands;
344    oldLogE2 = oldLogE + 2*nbEBands;
345    backgroundLogE = oldLogE2  + 2*nbEBands;
346
347    loss_count = st->loss_count;
348    start = st->start;
349    downsample = st->downsample;
350    noise_based = loss_count >= 5 || start != 0;
351    ALLOC(scratch, noise_based?N*C:N, celt_sig);
352    if (noise_based)
353    {
354       /* Noise-based PLC/CNG */
355       celt_sig *freq;
356       VARDECL(celt_norm, X);
357       VARDECL(celt_ener, bandE);
358       opus_uint32 seed;
359       int end;
360       int effEnd;
361
362       end = st->end;
363       effEnd = IMAX(start, IMIN(end, mode->effEBands));
364
365       /* Share the interleaved signal MDCT coefficient buffer with the
366          deemphasis scratch buffer. */
367       freq = scratch;
368       ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
369       ALLOC(bandE, nbEBands*C, celt_ener);
370
371       if (loss_count >= 5)
372          log2Amp(mode, start, end, bandE, backgroundLogE, C);
373       else {
374          /* Energy decay */
375          opus_val16 decay = loss_count==0 ?
376                QCONST16(1.5f, DB_SHIFT) : QCONST16(.5f, DB_SHIFT);
377          c=0; do
378          {
379             for (i=start;i<end;i++)
380                oldBandE[c*nbEBands+i] -= decay;
381          } while (++c<C);
382          log2Amp(mode, start, end, bandE, oldBandE, C);
383       }
384       seed = st->rng;
385       for (c=0;c<C;c++)
386       {
387          for (i=start;i<effEnd;i++)
388          {
389             int j;
390             int boffs;
391             int blen;
392             boffs = N*c+(eBands[i]<<LM);
393             blen = (eBands[i+1]-eBands[i])<<LM;
394             for (j=0;j<blen;j++)
395             {
396                seed = celt_lcg_rand(seed);
397                X[boffs+j] = (celt_norm)((opus_int32)seed>>20);
398             }
399             renormalise_vector(X+boffs, blen, Q15ONE);
400          }
401       }
402       st->rng = seed;
403
404       denormalise_bands(mode, X, freq, bandE, start, effEnd, C, 1<<LM);
405
406       c=0; do {
407          int bound = eBands[effEnd]<<LM;
408          if (downsample!=1)
409             bound = IMIN(bound, N/downsample);
410          for (i=bound;i<N;i++)
411             freq[c*N+i] = 0;
412       } while (++c<C);
413       c=0; do {
414          OPUS_MOVE(decode_mem[c], decode_mem[c]+N,
415                DECODE_BUFFER_SIZE-N+(overlap>>1));
416       } while (++c<C);
417       compute_inv_mdcts(mode, 0, freq, out_syn, C, LM);
418    } else {
419       /* Pitch-based PLC */
420       const opus_val16 *window;
421       opus_val16 fade = Q15ONE;
422       int pitch_index;
423       VARDECL(opus_val32, etmp);
424
425       if (loss_count == 0)
426       {
427          opus_val16 lp_pitch_buf[DECODE_BUFFER_SIZE>>1];
428          pitch_downsample(decode_mem, lp_pitch_buf, DECODE_BUFFER_SIZE, C);
429          pitch_search(lp_pitch_buf+(PLC_PITCH_LAG_MAX>>1), lp_pitch_buf,
430                DECODE_BUFFER_SIZE-PLC_PITCH_LAG_MAX,
431                PLC_PITCH_LAG_MAX-PLC_PITCH_LAG_MIN, &pitch_index);
432          pitch_index = PLC_PITCH_LAG_MAX-pitch_index;
433          st->last_pitch_index = pitch_index;
434       } else {
435          pitch_index = st->last_pitch_index;
436          fade = QCONST16(.8f,15);
437       }
438
439       ALLOC(etmp, overlap, opus_val32);
440       window = mode->window;
441       c=0; do {
442          opus_val16 exc[MAX_PERIOD];
443          opus_val32 ac[LPC_ORDER+1];
444          opus_val16 decay;
445          opus_val16 attenuation;
446          opus_val32 S1=0;
447          opus_val16 lpc_mem[LPC_ORDER];
448          celt_sig *buf;
449          int extrapolation_offset;
450          int extrapolation_len;
451          int exc_length;
452          int j;
453
454          buf = decode_mem[c];
455          for (i=0;i<MAX_PERIOD;i++) {
456             exc[i] = ROUND16(buf[DECODE_BUFFER_SIZE-MAX_PERIOD+i], SIG_SHIFT);
457          }
458
459          if (loss_count == 0)
460          {
461             /* Compute LPC coefficients for the last MAX_PERIOD samples before
462                the first loss so we can work in the excitation-filter domain. */
463             _celt_autocorr(exc, ac, window, overlap, LPC_ORDER, MAX_PERIOD);
464             /* Add a noise floor of -40 dB. */
465 #ifdef FIXED_POINT
466             ac[0] += SHR32(ac[0],13);
467 #else
468             ac[0] *= 1.0001f;
469 #endif
470             /* Use lag windowing to stabilize the Levinson-Durbin recursion. */
471             for (i=1;i<=LPC_ORDER;i++)
472             {
473                /*ac[i] *= exp(-.5*(2*M_PI*.002*i)*(2*M_PI*.002*i));*/
474 #ifdef FIXED_POINT
475                ac[i] -= MULT16_32_Q15(2*i*i, ac[i]);
476 #else
477                ac[i] -= ac[i]*(0.008f*0.008f)*i*i;
478 #endif
479             }
480             _celt_lpc(lpc+c*LPC_ORDER, ac, LPC_ORDER);
481          }
482          /* We want the excitation for 2 pitch periods in order to look for a
483             decaying signal, but we can't get more than MAX_PERIOD. */
484          exc_length = IMIN(2*pitch_index, MAX_PERIOD);
485          /* Initialize the LPC history with the samples just before the start
486             of the region for which we're computing the excitation. */
487          for (i=0;i<LPC_ORDER;i++)
488          {
489             lpc_mem[i] =
490                   ROUND16(buf[DECODE_BUFFER_SIZE-exc_length-1-i], SIG_SHIFT);
491          }
492          /* Compute the excitation for exc_length samples before the loss. */
493          celt_fir(exc+MAX_PERIOD-exc_length, lpc+c*LPC_ORDER,
494                exc+MAX_PERIOD-exc_length, exc_length, LPC_ORDER, lpc_mem);
495
496          /* Check if the waveform is decaying, and if so how fast.
497             We do this to avoid adding energy when concealing in a segment
498             with decaying energy. */
499          {
500             opus_val32 E1=1, E2=1;
501             int decay_length;
502             decay_length = exc_length>>1;
503             for (i=0;i<decay_length;i++)
504             {
505                opus_val16 e;
506                e = exc[MAX_PERIOD-decay_length+i];
507                E1 += SHR32(MULT16_16(e, e), 8);
508                e = exc[MAX_PERIOD-2*decay_length+i];
509                E2 += SHR32(MULT16_16(e, e), 8);
510             }
511             E1 = MIN32(E1, E2);
512             decay = celt_sqrt(frac_div32(SHR32(E1, 1), E2));
513          }
514
515          /* Move the decoder memory one frame to the left to give us room to
516             add the data for the new frame. We ignore the overlap that extends
517             past the end of the buffer, because we aren't going to use it. */
518          OPUS_MOVE(buf, buf+N, DECODE_BUFFER_SIZE-N);
519
520          /* Extrapolate from the end of the excitation with a period of
521             "pitch_index", scaling down each period by an additional factor of
522             "decay". */
523          extrapolation_offset = MAX_PERIOD-pitch_index;
524          /* We need to extrapolate enough samples to cover a complete MDCT
525             window (including overlap/2 samples on both sides). */
526          extrapolation_len = N+overlap;
527          /* We also apply fading if this is not the first loss. */
528          attenuation = MULT16_16_Q15(fade, decay);
529          for (i=j=0;i<extrapolation_len;i++,j++)
530          {
531             opus_val16 tmp;
532             if (j >= pitch_index) {
533                j -= pitch_index;
534                attenuation = MULT16_16_Q15(attenuation, decay);
535             }
536             buf[DECODE_BUFFER_SIZE-N+i] =
537                   SHL32(EXTEND32(MULT16_16_Q15(attenuation,
538                         exc[extrapolation_offset+j])), SIG_SHIFT);
539             /* Compute the energy of the previously decoded signal whose
540                excitation we're copying. */
541             tmp = ROUND16(
542                   buf[DECODE_BUFFER_SIZE-MAX_PERIOD-N+extrapolation_offset+j],
543                   SIG_SHIFT);
544             S1 += SHR32(MULT16_16(tmp, tmp), 8);
545          }
546
547          /* Copy the last decoded samples (prior to the overlap region) to
548             synthesis filter memory so we can have a continuous signal. */
549          for (i=0;i<LPC_ORDER;i++)
550             lpc_mem[i] = ROUND16(buf[DECODE_BUFFER_SIZE-N-1-i], SIG_SHIFT);
551          /* Apply the synthesis filter to convert the excitation back into the
552             signal domain. */
553          celt_iir(buf+DECODE_BUFFER_SIZE-N, lpc+c*LPC_ORDER,
554                buf+DECODE_BUFFER_SIZE-N, extrapolation_len, LPC_ORDER, lpc_mem);
555
556          /* Check if the synthesis energy is higher than expected, which can
557             happen with the signal changes during our window. If so,
558             attenuate. */
559          {
560             opus_val32 S2=0;
561             for (i=0;i<extrapolation_len;i++)
562             {
563                opus_val16 tmp = ROUND16(buf[DECODE_BUFFER_SIZE-N+i], SIG_SHIFT);
564                S2 += SHR32(MULT16_16(tmp, tmp), 8);
565             }
566             /* This checks for an "explosion" in the synthesis. */
567 #ifdef FIXED_POINT
568             if (!(S1 > SHR32(S2,2)))
569 #else
570             /* The float test is written this way to catch NaNs in the output
571                of the IIR filter at the same time. */
572             if (!(S1 > 0.2f*S2))
573 #endif
574             {
575                for (i=0;i<extrapolation_len;i++)
576                   buf[DECODE_BUFFER_SIZE-N+i] = 0;
577             } else if (S1 < S2)
578             {
579                opus_val16 ratio = celt_sqrt(frac_div32(SHR32(S1,1)+1,S2+1));
580                for (i=0;i<overlap;i++)
581                {
582                   opus_val16 tmp_g = Q15ONE
583                         - MULT16_16_Q15(window[i], Q15ONE-ratio);
584                   buf[DECODE_BUFFER_SIZE-N+i] =
585                         MULT16_32_Q15(tmp_g, buf[DECODE_BUFFER_SIZE-N+i]);
586                }
587                for (i=overlap;i<extrapolation_len;i++)
588                {
589                   buf[DECODE_BUFFER_SIZE-N+i] =
590                         MULT16_32_Q15(ratio, buf[DECODE_BUFFER_SIZE-N+i]);
591                }
592             }
593          }
594
595          /* Apply the pre-filter to the MDCT overlap for the next frame because
596             the post-filter will be re-applied in the decoder after the MDCT
597             overlap. */
598          comb_filter(etmp, buf+DECODE_BUFFER_SIZE,
599               st->postfilter_period, st->postfilter_period, overlap,
600               -st->postfilter_gain, -st->postfilter_gain,
601               st->postfilter_tapset, st->postfilter_tapset, NULL, 0);
602
603          /* Simulate TDAC on the concealed audio so that it blends with the
604             MDCT of the next frame. */
605          for (i=0;i<overlap/2;i++)
606          {
607             buf[DECODE_BUFFER_SIZE+i] =
608                MULT16_32_Q15(window[i], etmp[overlap-1-i])
609                + MULT16_32_Q15(window[overlap-i-1], etmp[i]);
610          }
611       } while (++c<C);
612    }
613
614    deemphasis(out_syn, pcm, N, C, downsample,
615          mode->preemph, st->preemph_memD, scratch);
616
617    st->loss_count = loss_count+1;
618
619    RESTORE_STACK;
620 }
621
622 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)
623 {
624    int c, i, N;
625    int spread_decision;
626    opus_int32 bits;
627    ec_dec _dec;
628    VARDECL(celt_sig, freq);
629    VARDECL(celt_norm, X);
630    VARDECL(celt_ener, bandE);
631    VARDECL(int, fine_quant);
632    VARDECL(int, pulses);
633    VARDECL(int, cap);
634    VARDECL(int, offsets);
635    VARDECL(int, fine_priority);
636    VARDECL(int, tf_res);
637    VARDECL(unsigned char, collapse_masks);
638    celt_sig *out_mem[2];
639    celt_sig *decode_mem[2];
640    celt_sig *out_syn[2];
641    opus_val16 *lpc;
642    opus_val16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE;
643
644    int shortBlocks;
645    int isTransient;
646    int intra_ener;
647    const int CC = st->channels;
648    int LM, M;
649    int effEnd;
650    int codedBands;
651    int alloc_trim;
652    int postfilter_pitch;
653    opus_val16 postfilter_gain;
654    int intensity=0;
655    int dual_stereo=0;
656    opus_int32 total_bits;
657    opus_int32 balance;
658    opus_int32 tell;
659    int dynalloc_logp;
660    int postfilter_tapset;
661    int anti_collapse_rsv;
662    int anti_collapse_on=0;
663    int silence;
664    int C = st->stream_channels;
665    const OpusCustomMode *mode;
666    int nbEBands;
667    int overlap;
668    const opus_int16 *eBands;
669    ALLOC_STACK;
670
671    mode = st->mode;
672    nbEBands = mode->nbEBands;
673    overlap = mode->overlap;
674    eBands = mode->eBands;
675    frame_size *= st->downsample;
676
677    c=0; do {
678       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+overlap);
679       out_mem[c] = decode_mem[c]+DECODE_BUFFER_SIZE-MAX_PERIOD;
680    } while (++c<CC);
681    lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+overlap)*CC);
682    oldBandE = lpc+CC*LPC_ORDER;
683    oldLogE = oldBandE + 2*nbEBands;
684    oldLogE2 = oldLogE + 2*nbEBands;
685    backgroundLogE = oldLogE2  + 2*nbEBands;
686
687 #ifdef CUSTOM_MODES
688    if (st->signalling && data!=NULL)
689    {
690       int data0=data[0];
691       /* Convert "standard mode" to Opus header */
692       if (mode->Fs==48000 && mode->shortMdctSize==120)
693       {
694          data0 = fromOpus(data0);
695          if (data0<0)
696             return OPUS_INVALID_PACKET;
697       }
698       st->end = IMAX(1, mode->effEBands-2*(data0>>5));
699       LM = (data0>>3)&0x3;
700       C = 1 + ((data0>>2)&0x1);
701       data++;
702       len--;
703       if (LM>mode->maxLM)
704          return OPUS_INVALID_PACKET;
705       if (frame_size < mode->shortMdctSize<<LM)
706          return OPUS_BUFFER_TOO_SMALL;
707       else
708          frame_size = mode->shortMdctSize<<LM;
709    } else {
710 #else
711    {
712 #endif
713       for (LM=0;LM<=mode->maxLM;LM++)
714          if (mode->shortMdctSize<<LM==frame_size)
715             break;
716       if (LM>mode->maxLM)
717          return OPUS_BAD_ARG;
718    }
719    M=1<<LM;
720
721    if (len<0 || len>1275 || pcm==NULL)
722       return OPUS_BAD_ARG;
723
724    N = M*mode->shortMdctSize;
725
726    effEnd = st->end;
727    if (effEnd > mode->effEBands)
728       effEnd = mode->effEBands;
729
730    if (data == NULL || len<=1)
731    {
732       celt_decode_lost(st, pcm, N, LM);
733       RESTORE_STACK;
734       return frame_size/st->downsample;
735    }
736
737    if (dec == NULL)
738    {
739       ec_dec_init(&_dec,(unsigned char*)data,len);
740       dec = &_dec;
741    }
742
743    if (C==1)
744    {
745       for (i=0;i<nbEBands;i++)
746          oldBandE[i]=MAX16(oldBandE[i],oldBandE[nbEBands+i]);
747    }
748
749    total_bits = len*8;
750    tell = ec_tell(dec);
751
752    if (tell >= total_bits)
753       silence = 1;
754    else if (tell==1)
755       silence = ec_dec_bit_logp(dec, 15);
756    else
757       silence = 0;
758    if (silence)
759    {
760       /* Pretend we've read all the remaining bits */
761       tell = len*8;
762       dec->nbits_total+=tell-ec_tell(dec);
763    }
764
765    postfilter_gain = 0;
766    postfilter_pitch = 0;
767    postfilter_tapset = 0;
768    if (st->start==0 && tell+16 <= total_bits)
769    {
770       if(ec_dec_bit_logp(dec, 1))
771       {
772          int qg, octave;
773          octave = ec_dec_uint(dec, 6);
774          postfilter_pitch = (16<<octave)+ec_dec_bits(dec, 4+octave)-1;
775          qg = ec_dec_bits(dec, 3);
776          if (ec_tell(dec)+2<=total_bits)
777             postfilter_tapset = ec_dec_icdf(dec, tapset_icdf, 2);
778          postfilter_gain = QCONST16(.09375f,15)*(qg+1);
779       }
780       tell = ec_tell(dec);
781    }
782
783    if (LM > 0 && tell+3 <= total_bits)
784    {
785       isTransient = ec_dec_bit_logp(dec, 3);
786       tell = ec_tell(dec);
787    }
788    else
789       isTransient = 0;
790
791    if (isTransient)
792       shortBlocks = M;
793    else
794       shortBlocks = 0;
795
796    /* Decode the global flags (first symbols in the stream) */
797    intra_ener = tell+3<=total_bits ? ec_dec_bit_logp(dec, 3) : 0;
798    /* Get band energies */
799    unquant_coarse_energy(mode, st->start, st->end, oldBandE,
800          intra_ener, dec, C, LM);
801
802    ALLOC(tf_res, nbEBands, int);
803    tf_decode(st->start, st->end, isTransient, tf_res, LM, dec);
804
805    tell = ec_tell(dec);
806    spread_decision = SPREAD_NORMAL;
807    if (tell+4 <= total_bits)
808       spread_decision = ec_dec_icdf(dec, spread_icdf, 5);
809
810    ALLOC(cap, nbEBands, int);
811
812    init_caps(mode,cap,LM,C);
813
814    ALLOC(offsets, nbEBands, int);
815
816    dynalloc_logp = 6;
817    total_bits<<=BITRES;
818    tell = ec_tell_frac(dec);
819    for (i=st->start;i<st->end;i++)
820    {
821       int width, quanta;
822       int dynalloc_loop_logp;
823       int boost;
824       width = C*(eBands[i+1]-eBands[i])<<LM;
825       /* quanta is 6 bits, but no more than 1 bit/sample
826          and no less than 1/8 bit/sample */
827       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
828       dynalloc_loop_logp = dynalloc_logp;
829       boost = 0;
830       while (tell+(dynalloc_loop_logp<<BITRES) < total_bits && boost < cap[i])
831       {
832          int flag;
833          flag = ec_dec_bit_logp(dec, dynalloc_loop_logp);
834          tell = ec_tell_frac(dec);
835          if (!flag)
836             break;
837          boost += quanta;
838          total_bits -= quanta;
839          dynalloc_loop_logp = 1;
840       }
841       offsets[i] = boost;
842       /* Making dynalloc more likely */
843       if (boost>0)
844          dynalloc_logp = IMAX(2, dynalloc_logp-1);
845    }
846
847    ALLOC(fine_quant, nbEBands, int);
848    alloc_trim = tell+(6<<BITRES) <= total_bits ?
849          ec_dec_icdf(dec, trim_icdf, 7) : 5;
850
851    bits = (((opus_int32)len*8)<<BITRES) - ec_tell_frac(dec) - 1;
852    anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0;
853    bits -= anti_collapse_rsv;
854
855    ALLOC(pulses, nbEBands, int);
856    ALLOC(fine_priority, nbEBands, int);
857
858    codedBands = compute_allocation(mode, st->start, st->end, offsets, cap,
859          alloc_trim, &intensity, &dual_stereo, bits, &balance, pulses,
860          fine_quant, fine_priority, C, LM, dec, 0, 0, 0);
861
862    unquant_fine_energy(mode, st->start, st->end, oldBandE, fine_quant, dec, C);
863
864    /* Decode fixed codebook */
865    ALLOC(collapse_masks, C*nbEBands, unsigned char);
866    ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
867
868    quant_all_bands(0, mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
869          NULL, pulses, shortBlocks, spread_decision, dual_stereo, intensity, tf_res,
870          len*(8<<BITRES)-anti_collapse_rsv, balance, dec, LM, codedBands, &st->rng);
871
872    if (anti_collapse_rsv > 0)
873    {
874       anti_collapse_on = ec_dec_bits(dec, 1);
875    }
876
877    unquant_energy_finalise(mode, st->start, st->end, oldBandE,
878          fine_quant, fine_priority, len*8-ec_tell(dec), dec, C);
879
880    if (anti_collapse_on)
881       anti_collapse(mode, X, collapse_masks, LM, C, N,
882             st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
883
884    ALLOC(bandE, nbEBands*C, celt_ener);
885
886    log2Amp(mode, st->start, st->end, bandE, oldBandE, C);
887
888    if (silence)
889    {
890       for (i=0;i<C*nbEBands;i++)
891       {
892          bandE[i] = 0;
893          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
894       }
895    }
896    ALLOC(freq, IMAX(CC,C)*N, celt_sig); /**< Interleaved signal MDCTs */
897    /* Synthesis */
898    denormalise_bands(mode, X, freq, bandE, st->start, effEnd, C, M);
899
900    c=0; do {
901       OPUS_MOVE(decode_mem[c], decode_mem[c]+N, DECODE_BUFFER_SIZE-N+overlap/2);
902    } while (++c<CC);
903
904    c=0; do {
905       int bound = M*eBands[effEnd];
906       if (st->downsample!=1)
907          bound = IMIN(bound, N/st->downsample);
908       for (i=bound;i<N;i++)
909          freq[c*N+i] = 0;
910    } while (++c<C);
911
912    c=0; do {
913       out_syn[c] = out_mem[c]+MAX_PERIOD-N;
914    } while (++c<CC);
915
916    if (CC==2&&C==1)
917    {
918       for (i=0;i<N;i++)
919          freq[N+i] = freq[i];
920    }
921    if (CC==1&&C==2)
922    {
923       for (i=0;i<N;i++)
924          freq[i] = HALF32(ADD32(freq[i],freq[N+i]));
925    }
926
927    /* Compute inverse MDCTs */
928    compute_inv_mdcts(mode, shortBlocks, freq, out_syn, CC, LM);
929
930    c=0; do {
931       st->postfilter_period=IMAX(st->postfilter_period, COMBFILTER_MINPERIOD);
932       st->postfilter_period_old=IMAX(st->postfilter_period_old, COMBFILTER_MINPERIOD);
933       comb_filter(out_syn[c], out_syn[c], st->postfilter_period_old, st->postfilter_period, mode->shortMdctSize,
934             st->postfilter_gain_old, st->postfilter_gain, st->postfilter_tapset_old, st->postfilter_tapset,
935             mode->window, overlap);
936       if (LM!=0)
937          comb_filter(out_syn[c]+mode->shortMdctSize, out_syn[c]+mode->shortMdctSize, st->postfilter_period, postfilter_pitch, N-mode->shortMdctSize,
938                st->postfilter_gain, postfilter_gain, st->postfilter_tapset, postfilter_tapset,
939                mode->window, overlap);
940
941    } while (++c<CC);
942    st->postfilter_period_old = st->postfilter_period;
943    st->postfilter_gain_old = st->postfilter_gain;
944    st->postfilter_tapset_old = st->postfilter_tapset;
945    st->postfilter_period = postfilter_pitch;
946    st->postfilter_gain = postfilter_gain;
947    st->postfilter_tapset = postfilter_tapset;
948    if (LM!=0)
949    {
950       st->postfilter_period_old = st->postfilter_period;
951       st->postfilter_gain_old = st->postfilter_gain;
952       st->postfilter_tapset_old = st->postfilter_tapset;
953    }
954
955    if (C==1) {
956       for (i=0;i<nbEBands;i++)
957          oldBandE[nbEBands+i]=oldBandE[i];
958    }
959
960    /* In case start or end were to change */
961    if (!isTransient)
962    {
963       for (i=0;i<2*nbEBands;i++)
964          oldLogE2[i] = oldLogE[i];
965       for (i=0;i<2*nbEBands;i++)
966          oldLogE[i] = oldBandE[i];
967       for (i=0;i<2*nbEBands;i++)
968          backgroundLogE[i] = MIN16(backgroundLogE[i] + M*QCONST16(0.001f,DB_SHIFT), oldBandE[i]);
969    } else {
970       for (i=0;i<2*nbEBands;i++)
971          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
972    }
973    c=0; do
974    {
975       for (i=0;i<st->start;i++)
976       {
977          oldBandE[c*nbEBands+i]=0;
978          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
979       }
980       for (i=st->end;i<nbEBands;i++)
981       {
982          oldBandE[c*nbEBands+i]=0;
983          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
984       }
985    } while (++c<2);
986    st->rng = dec->rng;
987
988    /* We reuse freq[] as scratch space for the de-emphasis */
989    deemphasis(out_syn, pcm, N, CC, st->downsample, mode->preemph, st->preemph_memD, freq);
990    st->loss_count = 0;
991    RESTORE_STACK;
992    if (ec_tell(dec) > 8*len)
993       return OPUS_INTERNAL_ERROR;
994    if(ec_get_error(dec))
995       st->error = 1;
996    return frame_size/st->downsample;
997 }
998
999
1000 #ifdef CUSTOM_MODES
1001
1002 #ifdef FIXED_POINT
1003 int opus_custom_decode(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, opus_int16 * OPUS_RESTRICT pcm, int frame_size)
1004 {
1005    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
1006 }
1007
1008 #ifndef DISABLE_FLOAT_API
1009 int opus_custom_decode_float(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, float * OPUS_RESTRICT pcm, int frame_size)
1010 {
1011    int j, ret, C, N;
1012    VARDECL(opus_int16, out);
1013    ALLOC_STACK;
1014
1015    if (pcm==NULL)
1016       return OPUS_BAD_ARG;
1017
1018    C = st->channels;
1019    N = frame_size;
1020
1021    ALLOC(out, C*N, opus_int16);
1022    ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL);
1023    if (ret>0)
1024       for (j=0;j<C*ret;j++)
1025          pcm[j]=out[j]*(1.f/32768.f);
1026
1027    RESTORE_STACK;
1028    return ret;
1029 }
1030 #endif /* DISABLE_FLOAT_API */
1031
1032 #else
1033
1034 int opus_custom_decode_float(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, float * OPUS_RESTRICT pcm, int frame_size)
1035 {
1036    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
1037 }
1038
1039 int opus_custom_decode(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, opus_int16 * OPUS_RESTRICT pcm, int frame_size)
1040 {
1041    int j, ret, C, N;
1042    VARDECL(celt_sig, out);
1043    ALLOC_STACK;
1044
1045    if (pcm==NULL)
1046       return OPUS_BAD_ARG;
1047
1048    C = st->channels;
1049    N = frame_size;
1050    ALLOC(out, C*N, celt_sig);
1051
1052    ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL);
1053
1054    if (ret>0)
1055       for (j=0;j<C*ret;j++)
1056          pcm[j] = FLOAT2INT16 (out[j]);
1057
1058    RESTORE_STACK;
1059    return ret;
1060 }
1061
1062 #endif
1063 #endif /* CUSTOM_MODES */
1064
1065 int opus_custom_decoder_ctl(CELTDecoder * OPUS_RESTRICT st, int request, ...)
1066 {
1067    va_list ap;
1068
1069    va_start(ap, request);
1070    switch (request)
1071    {
1072       case CELT_SET_START_BAND_REQUEST:
1073       {
1074          opus_int32 value = va_arg(ap, opus_int32);
1075          if (value<0 || value>=st->mode->nbEBands)
1076             goto bad_arg;
1077          st->start = value;
1078       }
1079       break;
1080       case CELT_SET_END_BAND_REQUEST:
1081       {
1082          opus_int32 value = va_arg(ap, opus_int32);
1083          if (value<1 || value>st->mode->nbEBands)
1084             goto bad_arg;
1085          st->end = value;
1086       }
1087       break;
1088       case CELT_SET_CHANNELS_REQUEST:
1089       {
1090          opus_int32 value = va_arg(ap, opus_int32);
1091          if (value<1 || value>2)
1092             goto bad_arg;
1093          st->stream_channels = value;
1094       }
1095       break;
1096       case CELT_GET_AND_CLEAR_ERROR_REQUEST:
1097       {
1098          opus_int32 *value = va_arg(ap, opus_int32*);
1099          if (value==NULL)
1100             goto bad_arg;
1101          *value=st->error;
1102          st->error = 0;
1103       }
1104       break;
1105       case OPUS_GET_LOOKAHEAD_REQUEST:
1106       {
1107          opus_int32 *value = va_arg(ap, opus_int32*);
1108          if (value==NULL)
1109             goto bad_arg;
1110          *value = st->overlap/st->downsample;
1111       }
1112       break;
1113       case OPUS_RESET_STATE:
1114       {
1115          int i;
1116          opus_val16 *lpc, *oldBandE, *oldLogE, *oldLogE2;
1117          lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*st->channels);
1118          oldBandE = lpc+st->channels*LPC_ORDER;
1119          oldLogE = oldBandE + 2*st->mode->nbEBands;
1120          oldLogE2 = oldLogE + 2*st->mode->nbEBands;
1121          OPUS_CLEAR((char*)&st->DECODER_RESET_START,
1122                opus_custom_decoder_get_size(st->mode, st->channels)-
1123                ((char*)&st->DECODER_RESET_START - (char*)st));
1124          for (i=0;i<2*st->mode->nbEBands;i++)
1125             oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT);
1126       }
1127       break;
1128       case OPUS_GET_PITCH_REQUEST:
1129       {
1130          opus_int32 *value = va_arg(ap, opus_int32*);
1131          if (value==NULL)
1132             goto bad_arg;
1133          *value = st->postfilter_period;
1134       }
1135       break;
1136       case CELT_GET_MODE_REQUEST:
1137       {
1138          const CELTMode ** value = va_arg(ap, const CELTMode**);
1139          if (value==0)
1140             goto bad_arg;
1141          *value=st->mode;
1142       }
1143       break;
1144       case CELT_SET_SIGNALLING_REQUEST:
1145       {
1146          opus_int32 value = va_arg(ap, opus_int32);
1147          st->signalling = value;
1148       }
1149       break;
1150       case OPUS_GET_FINAL_RANGE_REQUEST:
1151       {
1152          opus_uint32 * value = va_arg(ap, opus_uint32 *);
1153          if (value==0)
1154             goto bad_arg;
1155          *value=st->rng;
1156       }
1157       break;
1158       default:
1159          goto bad_request;
1160    }
1161    va_end(ap);
1162    return OPUS_OK;
1163 bad_arg:
1164    va_end(ap);
1165    return OPUS_BAD_ARG;
1166 bad_request:
1167       va_end(ap);
1168   return OPUS_UNIMPLEMENTED;
1169 }