michael@0: /* Copyright (c) 2007-2008 CSIRO
michael@0:    Copyright (c) 2007-2010 Xiph.Org Foundation
michael@0:    Copyright (c) 2008 Gregory Maxwell
michael@0:    Written by Jean-Marc Valin and Gregory Maxwell */
michael@0: /*
michael@0:    Redistribution and use in source and binary forms, with or without
michael@0:    modification, are permitted provided that the following conditions
michael@0:    are met:
michael@0: 
michael@0:    - Redistributions of source code must retain the above copyright
michael@0:    notice, this list of conditions and the following disclaimer.
michael@0: 
michael@0:    - Redistributions in binary form must reproduce the above copyright
michael@0:    notice, this list of conditions and the following disclaimer in the
michael@0:    documentation and/or other materials provided with the distribution.
michael@0: 
michael@0:    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
michael@0:    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
michael@0:    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
michael@0:    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
michael@0:    OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
michael@0:    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
michael@0:    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
michael@0:    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
michael@0:    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
michael@0:    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
michael@0:    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
michael@0: */
michael@0: 
michael@0: #ifdef HAVE_CONFIG_H
michael@0: #include "config.h"
michael@0: #endif
michael@0: 
michael@0: #define CELT_DECODER_C
michael@0: 
michael@0: #include "cpu_support.h"
michael@0: #include "os_support.h"
michael@0: #include "mdct.h"
michael@0: #include <math.h>
michael@0: #include "celt.h"
michael@0: #include "pitch.h"
michael@0: #include "bands.h"
michael@0: #include "modes.h"
michael@0: #include "entcode.h"
michael@0: #include "quant_bands.h"
michael@0: #include "rate.h"
michael@0: #include "stack_alloc.h"
michael@0: #include "mathops.h"
michael@0: #include "float_cast.h"
michael@0: #include <stdarg.h>
michael@0: #include "celt_lpc.h"
michael@0: #include "vq.h"
michael@0: 
michael@0: /**********************************************************************/
michael@0: /*                                                                    */
michael@0: /*                             DECODER                                */
michael@0: /*                                                                    */
michael@0: /**********************************************************************/
michael@0: #define DECODE_BUFFER_SIZE 2048
michael@0: 
michael@0: /** Decoder state
michael@0:  @brief Decoder state
michael@0:  */
michael@0: struct OpusCustomDecoder {
michael@0:    const OpusCustomMode *mode;
michael@0:    int overlap;
michael@0:    int channels;
michael@0:    int stream_channels;
michael@0: 
michael@0:    int downsample;
michael@0:    int start, end;
michael@0:    int signalling;
michael@0:    int arch;
michael@0: 
michael@0:    /* Everything beyond this point gets cleared on a reset */
michael@0: #define DECODER_RESET_START rng
michael@0: 
michael@0:    opus_uint32 rng;
michael@0:    int error;
michael@0:    int last_pitch_index;
michael@0:    int loss_count;
michael@0:    int postfilter_period;
michael@0:    int postfilter_period_old;
michael@0:    opus_val16 postfilter_gain;
michael@0:    opus_val16 postfilter_gain_old;
michael@0:    int postfilter_tapset;
michael@0:    int postfilter_tapset_old;
michael@0: 
michael@0:    celt_sig preemph_memD[2];
michael@0: 
michael@0:    celt_sig _decode_mem[1]; /* Size = channels*(DECODE_BUFFER_SIZE+mode->overlap) */
michael@0:    /* opus_val16 lpc[],  Size = channels*LPC_ORDER */
michael@0:    /* opus_val16 oldEBands[], Size = 2*mode->nbEBands */
michael@0:    /* opus_val16 oldLogE[], Size = 2*mode->nbEBands */
michael@0:    /* opus_val16 oldLogE2[], Size = 2*mode->nbEBands */
michael@0:    /* opus_val16 backgroundLogE[], Size = 2*mode->nbEBands */
michael@0: };
michael@0: 
michael@0: int celt_decoder_get_size(int channels)
michael@0: {
michael@0:    const CELTMode *mode = opus_custom_mode_create(48000, 960, NULL);
michael@0:    return opus_custom_decoder_get_size(mode, channels);
michael@0: }
michael@0: 
michael@0: OPUS_CUSTOM_NOSTATIC int opus_custom_decoder_get_size(const CELTMode *mode, int channels)
michael@0: {
michael@0:    int size = sizeof(struct CELTDecoder)
michael@0:             + (channels*(DECODE_BUFFER_SIZE+mode->overlap)-1)*sizeof(celt_sig)
michael@0:             + channels*LPC_ORDER*sizeof(opus_val16)
michael@0:             + 4*2*mode->nbEBands*sizeof(opus_val16);
michael@0:    return size;
michael@0: }
michael@0: 
michael@0: #ifdef CUSTOM_MODES
michael@0: CELTDecoder *opus_custom_decoder_create(const CELTMode *mode, int channels, int *error)
michael@0: {
michael@0:    int ret;
michael@0:    CELTDecoder *st = (CELTDecoder *)opus_alloc(opus_custom_decoder_get_size(mode, channels));
michael@0:    ret = opus_custom_decoder_init(st, mode, channels);
michael@0:    if (ret != OPUS_OK)
michael@0:    {
michael@0:       opus_custom_decoder_destroy(st);
michael@0:       st = NULL;
michael@0:    }
michael@0:    if (error)
michael@0:       *error = ret;
michael@0:    return st;
michael@0: }
michael@0: #endif /* CUSTOM_MODES */
michael@0: 
michael@0: int celt_decoder_init(CELTDecoder *st, opus_int32 sampling_rate, int channels)
michael@0: {
michael@0:    int ret;
michael@0:    ret = opus_custom_decoder_init(st, opus_custom_mode_create(48000, 960, NULL), channels);
michael@0:    if (ret != OPUS_OK)
michael@0:       return ret;
michael@0:    st->downsample = resampling_factor(sampling_rate);
michael@0:    if (st->downsample==0)
michael@0:       return OPUS_BAD_ARG;
michael@0:    else
michael@0:       return OPUS_OK;
michael@0: }
michael@0: 
michael@0: OPUS_CUSTOM_NOSTATIC int opus_custom_decoder_init(CELTDecoder *st, const CELTMode *mode, int channels)
michael@0: {
michael@0:    if (channels < 0 || channels > 2)
michael@0:       return OPUS_BAD_ARG;
michael@0: 
michael@0:    if (st==NULL)
michael@0:       return OPUS_ALLOC_FAIL;
michael@0: 
michael@0:    OPUS_CLEAR((char*)st, opus_custom_decoder_get_size(mode, channels));
michael@0: 
michael@0:    st->mode = mode;
michael@0:    st->overlap = mode->overlap;
michael@0:    st->stream_channels = st->channels = channels;
michael@0: 
michael@0:    st->downsample = 1;
michael@0:    st->start = 0;
michael@0:    st->end = st->mode->effEBands;
michael@0:    st->signalling = 1;
michael@0:    st->arch = opus_select_arch();
michael@0: 
michael@0:    st->loss_count = 0;
michael@0: 
michael@0:    opus_custom_decoder_ctl(st, OPUS_RESET_STATE);
michael@0: 
michael@0:    return OPUS_OK;
michael@0: }
michael@0: 
michael@0: #ifdef CUSTOM_MODES
michael@0: void opus_custom_decoder_destroy(CELTDecoder *st)
michael@0: {
michael@0:    opus_free(st);
michael@0: }
michael@0: #endif /* CUSTOM_MODES */
michael@0: 
michael@0: static OPUS_INLINE opus_val16 SIG2WORD16(celt_sig x)
michael@0: {
michael@0: #ifdef FIXED_POINT
michael@0:    x = PSHR32(x, SIG_SHIFT);
michael@0:    x = MAX32(x, -32768);
michael@0:    x = MIN32(x, 32767);
michael@0:    return EXTRACT16(x);
michael@0: #else
michael@0:    return (opus_val16)x;
michael@0: #endif
michael@0: }
michael@0: 
michael@0: #ifndef RESYNTH
michael@0: static
michael@0: #endif
michael@0: 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)
michael@0: {
michael@0:    int c;
michael@0:    int Nd;
michael@0:    int apply_downsampling=0;
michael@0:    opus_val16 coef0;
michael@0: 
michael@0:    coef0 = coef[0];
michael@0:    Nd = N/downsample;
michael@0:    c=0; do {
michael@0:       int j;
michael@0:       celt_sig * OPUS_RESTRICT x;
michael@0:       opus_val16  * OPUS_RESTRICT y;
michael@0:       celt_sig m = mem[c];
michael@0:       x =in[c];
michael@0:       y = pcm+c;
michael@0: #ifdef CUSTOM_MODES
michael@0:       if (coef[1] != 0)
michael@0:       {
michael@0:          opus_val16 coef1 = coef[1];
michael@0:          opus_val16 coef3 = coef[3];
michael@0:          for (j=0;j<N;j++)
michael@0:          {
michael@0:             celt_sig tmp = x[j] + m + VERY_SMALL;
michael@0:             m = MULT16_32_Q15(coef0, tmp)
michael@0:                           - MULT16_32_Q15(coef1, x[j]);
michael@0:             tmp = SHL32(MULT16_32_Q15(coef3, tmp), 2);
michael@0:             scratch[j] = tmp;
michael@0:          }
michael@0:          apply_downsampling=1;
michael@0:       } else
michael@0: #endif
michael@0:       if (downsample>1)
michael@0:       {
michael@0:          /* Shortcut for the standard (non-custom modes) case */
michael@0:          for (j=0;j<N;j++)
michael@0:          {
michael@0:             celt_sig tmp = x[j] + m + VERY_SMALL;
michael@0:             m = MULT16_32_Q15(coef0, tmp);
michael@0:             scratch[j] = tmp;
michael@0:          }
michael@0:          apply_downsampling=1;
michael@0:       } else {
michael@0:          /* Shortcut for the standard (non-custom modes) case */
michael@0:          for (j=0;j<N;j++)
michael@0:          {
michael@0:             celt_sig tmp = x[j] + m + VERY_SMALL;
michael@0:             m = MULT16_32_Q15(coef0, tmp);
michael@0:             y[j*C] = SCALEOUT(SIG2WORD16(tmp));
michael@0:          }
michael@0:       }
michael@0:       mem[c] = m;
michael@0: 
michael@0:       if (apply_downsampling)
michael@0:       {
michael@0:          /* Perform down-sampling */
michael@0:          for (j=0;j<Nd;j++)
michael@0:             y[j*C] = SCALEOUT(SIG2WORD16(scratch[j*downsample]));
michael@0:       }
michael@0:    } while (++c<C);
michael@0: }
michael@0: 
michael@0: /** Compute the IMDCT and apply window for all sub-frames and
michael@0:     all channels in a frame */
michael@0: #ifndef RESYNTH
michael@0: static
michael@0: #endif
michael@0: void compute_inv_mdcts(const CELTMode *mode, int shortBlocks, celt_sig *X,
michael@0:       celt_sig * OPUS_RESTRICT out_mem[], int C, int LM)
michael@0: {
michael@0:    int b, c;
michael@0:    int B;
michael@0:    int N;
michael@0:    int shift;
michael@0:    const int overlap = OVERLAP(mode);
michael@0: 
michael@0:    if (shortBlocks)
michael@0:    {
michael@0:       B = shortBlocks;
michael@0:       N = mode->shortMdctSize;
michael@0:       shift = mode->maxLM;
michael@0:    } else {
michael@0:       B = 1;
michael@0:       N = mode->shortMdctSize<<LM;
michael@0:       shift = mode->maxLM-LM;
michael@0:    }
michael@0:    c=0; do {
michael@0:       /* IMDCT on the interleaved the sub-frames, overlap-add is performed by the IMDCT */
michael@0:       for (b=0;b<B;b++)
michael@0:          clt_mdct_backward(&mode->mdct, &X[b+c*N*B], out_mem[c]+N*b, mode->window, overlap, shift, B);
michael@0:    } while (++c<C);
michael@0: }
michael@0: 
michael@0: static void tf_decode(int start, int end, int isTransient, int *tf_res, int LM, ec_dec *dec)
michael@0: {
michael@0:    int i, curr, tf_select;
michael@0:    int tf_select_rsv;
michael@0:    int tf_changed;
michael@0:    int logp;
michael@0:    opus_uint32 budget;
michael@0:    opus_uint32 tell;
michael@0: 
michael@0:    budget = dec->storage*8;
michael@0:    tell = ec_tell(dec);
michael@0:    logp = isTransient ? 2 : 4;
michael@0:    tf_select_rsv = LM>0 && tell+logp+1<=budget;
michael@0:    budget -= tf_select_rsv;
michael@0:    tf_changed = curr = 0;
michael@0:    for (i=start;i<end;i++)
michael@0:    {
michael@0:       if (tell+logp<=budget)
michael@0:       {
michael@0:          curr ^= ec_dec_bit_logp(dec, logp);
michael@0:          tell = ec_tell(dec);
michael@0:          tf_changed |= curr;
michael@0:       }
michael@0:       tf_res[i] = curr;
michael@0:       logp = isTransient ? 4 : 5;
michael@0:    }
michael@0:    tf_select = 0;
michael@0:    if (tf_select_rsv &&
michael@0:      tf_select_table[LM][4*isTransient+0+tf_changed] !=
michael@0:      tf_select_table[LM][4*isTransient+2+tf_changed])
michael@0:    {
michael@0:       tf_select = ec_dec_bit_logp(dec, 1);
michael@0:    }
michael@0:    for (i=start;i<end;i++)
michael@0:    {
michael@0:       tf_res[i] = tf_select_table[LM][4*isTransient+2*tf_select+tf_res[i]];
michael@0:    }
michael@0: }
michael@0: 
michael@0: /* The maximum pitch lag to allow in the pitch-based PLC. It's possible to save
michael@0:    CPU time in the PLC pitch search by making this smaller than MAX_PERIOD. The
michael@0:    current value corresponds to a pitch of 66.67 Hz. */
michael@0: #define PLC_PITCH_LAG_MAX (720)
michael@0: /* The minimum pitch lag to allow in the pitch-based PLC. This corresponds to a
michael@0:    pitch of 480 Hz. */
michael@0: #define PLC_PITCH_LAG_MIN (100)
michael@0: 
michael@0: static void celt_decode_lost(CELTDecoder * OPUS_RESTRICT st, opus_val16 * OPUS_RESTRICT pcm, int N, int LM)
michael@0: {
michael@0:    int c;
michael@0:    int i;
michael@0:    const int C = st->channels;
michael@0:    celt_sig *decode_mem[2];
michael@0:    celt_sig *out_syn[2];
michael@0:    opus_val16 *lpc;
michael@0:    opus_val16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE;
michael@0:    const OpusCustomMode *mode;
michael@0:    int nbEBands;
michael@0:    int overlap;
michael@0:    int start;
michael@0:    int downsample;
michael@0:    int loss_count;
michael@0:    int noise_based;
michael@0:    const opus_int16 *eBands;
michael@0:    VARDECL(celt_sig, scratch);
michael@0:    SAVE_STACK;
michael@0: 
michael@0:    mode = st->mode;
michael@0:    nbEBands = mode->nbEBands;
michael@0:    overlap = mode->overlap;
michael@0:    eBands = mode->eBands;
michael@0: 
michael@0:    c=0; do {
michael@0:       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+overlap);
michael@0:       out_syn[c] = decode_mem[c]+DECODE_BUFFER_SIZE-N;
michael@0:    } while (++c<C);
michael@0:    lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+overlap)*C);
michael@0:    oldBandE = lpc+C*LPC_ORDER;
michael@0:    oldLogE = oldBandE + 2*nbEBands;
michael@0:    oldLogE2 = oldLogE + 2*nbEBands;
michael@0:    backgroundLogE = oldLogE2  + 2*nbEBands;
michael@0: 
michael@0:    loss_count = st->loss_count;
michael@0:    start = st->start;
michael@0:    downsample = st->downsample;
michael@0:    noise_based = loss_count >= 5 || start != 0;
michael@0:    ALLOC(scratch, noise_based?N*C:N, celt_sig);
michael@0:    if (noise_based)
michael@0:    {
michael@0:       /* Noise-based PLC/CNG */
michael@0:       celt_sig *freq;
michael@0:       VARDECL(celt_norm, X);
michael@0:       opus_uint32 seed;
michael@0:       opus_val16 *plcLogE;
michael@0:       int end;
michael@0:       int effEnd;
michael@0: 
michael@0:       end = st->end;
michael@0:       effEnd = IMAX(start, IMIN(end, mode->effEBands));
michael@0: 
michael@0:       /* Share the interleaved signal MDCT coefficient buffer with the
michael@0:          deemphasis scratch buffer. */
michael@0:       freq = scratch;
michael@0:       ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
michael@0: 
michael@0:       if (loss_count >= 5)
michael@0:          plcLogE = backgroundLogE;
michael@0:       else {
michael@0:          /* Energy decay */
michael@0:          opus_val16 decay = loss_count==0 ?
michael@0:                QCONST16(1.5f, DB_SHIFT) : QCONST16(.5f, DB_SHIFT);
michael@0:          c=0; do
michael@0:          {
michael@0:             for (i=start;i<end;i++)
michael@0:                oldBandE[c*nbEBands+i] -= decay;
michael@0:          } while (++c<C);
michael@0:          plcLogE = oldBandE;
michael@0:       }
michael@0:       seed = st->rng;
michael@0:       for (c=0;c<C;c++)
michael@0:       {
michael@0:          for (i=start;i<effEnd;i++)
michael@0:          {
michael@0:             int j;
michael@0:             int boffs;
michael@0:             int blen;
michael@0:             boffs = N*c+(eBands[i]<<LM);
michael@0:             blen = (eBands[i+1]-eBands[i])<<LM;
michael@0:             for (j=0;j<blen;j++)
michael@0:             {
michael@0:                seed = celt_lcg_rand(seed);
michael@0:                X[boffs+j] = (celt_norm)((opus_int32)seed>>20);
michael@0:             }
michael@0:             renormalise_vector(X+boffs, blen, Q15ONE);
michael@0:          }
michael@0:       }
michael@0:       st->rng = seed;
michael@0: 
michael@0:       denormalise_bands(mode, X, freq, plcLogE, start, effEnd, C, 1<<LM);
michael@0: 
michael@0:       c=0; do {
michael@0:          int bound = eBands[effEnd]<<LM;
michael@0:          if (downsample!=1)
michael@0:             bound = IMIN(bound, N/downsample);
michael@0:          for (i=bound;i<N;i++)
michael@0:             freq[c*N+i] = 0;
michael@0:       } while (++c<C);
michael@0:       c=0; do {
michael@0:          OPUS_MOVE(decode_mem[c], decode_mem[c]+N,
michael@0:                DECODE_BUFFER_SIZE-N+(overlap>>1));
michael@0:       } while (++c<C);
michael@0:       compute_inv_mdcts(mode, 0, freq, out_syn, C, LM);
michael@0:    } else {
michael@0:       /* Pitch-based PLC */
michael@0:       const opus_val16 *window;
michael@0:       opus_val16 fade = Q15ONE;
michael@0:       int pitch_index;
michael@0:       VARDECL(opus_val32, etmp);
michael@0:       VARDECL(opus_val16, exc);
michael@0: 
michael@0:       if (loss_count == 0)
michael@0:       {
michael@0:          VARDECL( opus_val16, lp_pitch_buf );
michael@0:          ALLOC( lp_pitch_buf, DECODE_BUFFER_SIZE>>1, opus_val16 );
michael@0:          pitch_downsample(decode_mem, lp_pitch_buf,
michael@0:                DECODE_BUFFER_SIZE, C, st->arch);
michael@0:          pitch_search(lp_pitch_buf+(PLC_PITCH_LAG_MAX>>1), lp_pitch_buf,
michael@0:                DECODE_BUFFER_SIZE-PLC_PITCH_LAG_MAX,
michael@0:                PLC_PITCH_LAG_MAX-PLC_PITCH_LAG_MIN, &pitch_index, st->arch);
michael@0:          pitch_index = PLC_PITCH_LAG_MAX-pitch_index;
michael@0:          st->last_pitch_index = pitch_index;
michael@0:       } else {
michael@0:          pitch_index = st->last_pitch_index;
michael@0:          fade = QCONST16(.8f,15);
michael@0:       }
michael@0: 
michael@0:       ALLOC(etmp, overlap, opus_val32);
michael@0:       ALLOC(exc, MAX_PERIOD, opus_val16);
michael@0:       window = mode->window;
michael@0:       c=0; do {
michael@0:          opus_val16 decay;
michael@0:          opus_val16 attenuation;
michael@0:          opus_val32 S1=0;
michael@0:          celt_sig *buf;
michael@0:          int extrapolation_offset;
michael@0:          int extrapolation_len;
michael@0:          int exc_length;
michael@0:          int j;
michael@0: 
michael@0:          buf = decode_mem[c];
michael@0:          for (i=0;i<MAX_PERIOD;i++) {
michael@0:             exc[i] = ROUND16(buf[DECODE_BUFFER_SIZE-MAX_PERIOD+i], SIG_SHIFT);
michael@0:          }
michael@0: 
michael@0:          if (loss_count == 0)
michael@0:          {
michael@0:             opus_val32 ac[LPC_ORDER+1];
michael@0:             /* Compute LPC coefficients for the last MAX_PERIOD samples before
michael@0:                the first loss so we can work in the excitation-filter domain. */
michael@0:             _celt_autocorr(exc, ac, window, overlap,
michael@0:                    LPC_ORDER, MAX_PERIOD, st->arch);
michael@0:             /* Add a noise floor of -40 dB. */
michael@0: #ifdef FIXED_POINT
michael@0:             ac[0] += SHR32(ac[0],13);
michael@0: #else
michael@0:             ac[0] *= 1.0001f;
michael@0: #endif
michael@0:             /* Use lag windowing to stabilize the Levinson-Durbin recursion. */
michael@0:             for (i=1;i<=LPC_ORDER;i++)
michael@0:             {
michael@0:                /*ac[i] *= exp(-.5*(2*M_PI*.002*i)*(2*M_PI*.002*i));*/
michael@0: #ifdef FIXED_POINT
michael@0:                ac[i] -= MULT16_32_Q15(2*i*i, ac[i]);
michael@0: #else
michael@0:                ac[i] -= ac[i]*(0.008f*0.008f)*i*i;
michael@0: #endif
michael@0:             }
michael@0:             _celt_lpc(lpc+c*LPC_ORDER, ac, LPC_ORDER);
michael@0:          }
michael@0:          /* We want the excitation for 2 pitch periods in order to look for a
michael@0:             decaying signal, but we can't get more than MAX_PERIOD. */
michael@0:          exc_length = IMIN(2*pitch_index, MAX_PERIOD);
michael@0:          /* Initialize the LPC history with the samples just before the start
michael@0:             of the region for which we're computing the excitation. */
michael@0:          {
michael@0:             opus_val16 lpc_mem[LPC_ORDER];
michael@0:             for (i=0;i<LPC_ORDER;i++)
michael@0:             {
michael@0:                lpc_mem[i] =
michael@0:                      ROUND16(buf[DECODE_BUFFER_SIZE-exc_length-1-i], SIG_SHIFT);
michael@0:             }
michael@0:             /* Compute the excitation for exc_length samples before the loss. */
michael@0:             celt_fir(exc+MAX_PERIOD-exc_length, lpc+c*LPC_ORDER,
michael@0:                   exc+MAX_PERIOD-exc_length, exc_length, LPC_ORDER, lpc_mem);
michael@0:          }
michael@0: 
michael@0:          /* Check if the waveform is decaying, and if so how fast.
michael@0:             We do this to avoid adding energy when concealing in a segment
michael@0:             with decaying energy. */
michael@0:          {
michael@0:             opus_val32 E1=1, E2=1;
michael@0:             int decay_length;
michael@0: #ifdef FIXED_POINT
michael@0:             int shift = IMAX(0,2*celt_zlog2(celt_maxabs16(&exc[MAX_PERIOD-exc_length], exc_length))-20);
michael@0: #endif
michael@0:             decay_length = exc_length>>1;
michael@0:             for (i=0;i<decay_length;i++)
michael@0:             {
michael@0:                opus_val16 e;
michael@0:                e = exc[MAX_PERIOD-decay_length+i];
michael@0:                E1 += SHR32(MULT16_16(e, e), shift);
michael@0:                e = exc[MAX_PERIOD-2*decay_length+i];
michael@0:                E2 += SHR32(MULT16_16(e, e), shift);
michael@0:             }
michael@0:             E1 = MIN32(E1, E2);
michael@0:             decay = celt_sqrt(frac_div32(SHR32(E1, 1), E2));
michael@0:          }
michael@0: 
michael@0:          /* Move the decoder memory one frame to the left to give us room to
michael@0:             add the data for the new frame. We ignore the overlap that extends
michael@0:             past the end of the buffer, because we aren't going to use it. */
michael@0:          OPUS_MOVE(buf, buf+N, DECODE_BUFFER_SIZE-N);
michael@0: 
michael@0:          /* Extrapolate from the end of the excitation with a period of
michael@0:             "pitch_index", scaling down each period by an additional factor of
michael@0:             "decay". */
michael@0:          extrapolation_offset = MAX_PERIOD-pitch_index;
michael@0:          /* We need to extrapolate enough samples to cover a complete MDCT
michael@0:             window (including overlap/2 samples on both sides). */
michael@0:          extrapolation_len = N+overlap;
michael@0:          /* We also apply fading if this is not the first loss. */
michael@0:          attenuation = MULT16_16_Q15(fade, decay);
michael@0:          for (i=j=0;i<extrapolation_len;i++,j++)
michael@0:          {
michael@0:             opus_val16 tmp;
michael@0:             if (j >= pitch_index) {
michael@0:                j -= pitch_index;
michael@0:                attenuation = MULT16_16_Q15(attenuation, decay);
michael@0:             }
michael@0:             buf[DECODE_BUFFER_SIZE-N+i] =
michael@0:                   SHL32(EXTEND32(MULT16_16_Q15(attenuation,
michael@0:                         exc[extrapolation_offset+j])), SIG_SHIFT);
michael@0:             /* Compute the energy of the previously decoded signal whose
michael@0:                excitation we're copying. */
michael@0:             tmp = ROUND16(
michael@0:                   buf[DECODE_BUFFER_SIZE-MAX_PERIOD-N+extrapolation_offset+j],
michael@0:                   SIG_SHIFT);
michael@0:             S1 += SHR32(MULT16_16(tmp, tmp), 8);
michael@0:          }
michael@0: 
michael@0:          {
michael@0:             opus_val16 lpc_mem[LPC_ORDER];
michael@0:             /* Copy the last decoded samples (prior to the overlap region) to
michael@0:                synthesis filter memory so we can have a continuous signal. */
michael@0:             for (i=0;i<LPC_ORDER;i++)
michael@0:                lpc_mem[i] = ROUND16(buf[DECODE_BUFFER_SIZE-N-1-i], SIG_SHIFT);
michael@0:             /* Apply the synthesis filter to convert the excitation back into
michael@0:                the signal domain. */
michael@0:             celt_iir(buf+DECODE_BUFFER_SIZE-N, lpc+c*LPC_ORDER,
michael@0:                   buf+DECODE_BUFFER_SIZE-N, extrapolation_len, LPC_ORDER,
michael@0:                   lpc_mem);
michael@0:          }
michael@0: 
michael@0:          /* Check if the synthesis energy is higher than expected, which can
michael@0:             happen with the signal changes during our window. If so,
michael@0:             attenuate. */
michael@0:          {
michael@0:             opus_val32 S2=0;
michael@0:             for (i=0;i<extrapolation_len;i++)
michael@0:             {
michael@0:                opus_val16 tmp = ROUND16(buf[DECODE_BUFFER_SIZE-N+i], SIG_SHIFT);
michael@0:                S2 += SHR32(MULT16_16(tmp, tmp), 8);
michael@0:             }
michael@0:             /* This checks for an "explosion" in the synthesis. */
michael@0: #ifdef FIXED_POINT
michael@0:             if (!(S1 > SHR32(S2,2)))
michael@0: #else
michael@0:             /* The float test is written this way to catch NaNs in the output
michael@0:                of the IIR filter at the same time. */
michael@0:             if (!(S1 > 0.2f*S2))
michael@0: #endif
michael@0:             {
michael@0:                for (i=0;i<extrapolation_len;i++)
michael@0:                   buf[DECODE_BUFFER_SIZE-N+i] = 0;
michael@0:             } else if (S1 < S2)
michael@0:             {
michael@0:                opus_val16 ratio = celt_sqrt(frac_div32(SHR32(S1,1)+1,S2+1));
michael@0:                for (i=0;i<overlap;i++)
michael@0:                {
michael@0:                   opus_val16 tmp_g = Q15ONE
michael@0:                         - MULT16_16_Q15(window[i], Q15ONE-ratio);
michael@0:                   buf[DECODE_BUFFER_SIZE-N+i] =
michael@0:                         MULT16_32_Q15(tmp_g, buf[DECODE_BUFFER_SIZE-N+i]);
michael@0:                }
michael@0:                for (i=overlap;i<extrapolation_len;i++)
michael@0:                {
michael@0:                   buf[DECODE_BUFFER_SIZE-N+i] =
michael@0:                         MULT16_32_Q15(ratio, buf[DECODE_BUFFER_SIZE-N+i]);
michael@0:                }
michael@0:             }
michael@0:          }
michael@0: 
michael@0:          /* Apply the pre-filter to the MDCT overlap for the next frame because
michael@0:             the post-filter will be re-applied in the decoder after the MDCT
michael@0:             overlap. */
michael@0:          comb_filter(etmp, buf+DECODE_BUFFER_SIZE,
michael@0:               st->postfilter_period, st->postfilter_period, overlap,
michael@0:               -st->postfilter_gain, -st->postfilter_gain,
michael@0:               st->postfilter_tapset, st->postfilter_tapset, NULL, 0);
michael@0: 
michael@0:          /* Simulate TDAC on the concealed audio so that it blends with the
michael@0:             MDCT of the next frame. */
michael@0:          for (i=0;i<overlap/2;i++)
michael@0:          {
michael@0:             buf[DECODE_BUFFER_SIZE+i] =
michael@0:                MULT16_32_Q15(window[i], etmp[overlap-1-i])
michael@0:                + MULT16_32_Q15(window[overlap-i-1], etmp[i]);
michael@0:          }
michael@0:       } while (++c<C);
michael@0:    }
michael@0: 
michael@0:    deemphasis(out_syn, pcm, N, C, downsample,
michael@0:          mode->preemph, st->preemph_memD, scratch);
michael@0: 
michael@0:    st->loss_count = loss_count+1;
michael@0: 
michael@0:    RESTORE_STACK;
michael@0: }
michael@0: 
michael@0: 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)
michael@0: {
michael@0:    int c, i, N;
michael@0:    int spread_decision;
michael@0:    opus_int32 bits;
michael@0:    ec_dec _dec;
michael@0:    VARDECL(celt_sig, freq);
michael@0:    VARDECL(celt_norm, X);
michael@0:    VARDECL(int, fine_quant);
michael@0:    VARDECL(int, pulses);
michael@0:    VARDECL(int, cap);
michael@0:    VARDECL(int, offsets);
michael@0:    VARDECL(int, fine_priority);
michael@0:    VARDECL(int, tf_res);
michael@0:    VARDECL(unsigned char, collapse_masks);
michael@0:    celt_sig *decode_mem[2];
michael@0:    celt_sig *out_syn[2];
michael@0:    opus_val16 *lpc;
michael@0:    opus_val16 *oldBandE, *oldLogE, *oldLogE2, *backgroundLogE;
michael@0: 
michael@0:    int shortBlocks;
michael@0:    int isTransient;
michael@0:    int intra_ener;
michael@0:    const int CC = st->channels;
michael@0:    int LM, M;
michael@0:    int effEnd;
michael@0:    int codedBands;
michael@0:    int alloc_trim;
michael@0:    int postfilter_pitch;
michael@0:    opus_val16 postfilter_gain;
michael@0:    int intensity=0;
michael@0:    int dual_stereo=0;
michael@0:    opus_int32 total_bits;
michael@0:    opus_int32 balance;
michael@0:    opus_int32 tell;
michael@0:    int dynalloc_logp;
michael@0:    int postfilter_tapset;
michael@0:    int anti_collapse_rsv;
michael@0:    int anti_collapse_on=0;
michael@0:    int silence;
michael@0:    int C = st->stream_channels;
michael@0:    const OpusCustomMode *mode;
michael@0:    int nbEBands;
michael@0:    int overlap;
michael@0:    const opus_int16 *eBands;
michael@0:    ALLOC_STACK;
michael@0: 
michael@0:    mode = st->mode;
michael@0:    nbEBands = mode->nbEBands;
michael@0:    overlap = mode->overlap;
michael@0:    eBands = mode->eBands;
michael@0:    frame_size *= st->downsample;
michael@0: 
michael@0:    c=0; do {
michael@0:       decode_mem[c] = st->_decode_mem + c*(DECODE_BUFFER_SIZE+overlap);
michael@0:    } while (++c<CC);
michael@0:    lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+overlap)*CC);
michael@0:    oldBandE = lpc+CC*LPC_ORDER;
michael@0:    oldLogE = oldBandE + 2*nbEBands;
michael@0:    oldLogE2 = oldLogE + 2*nbEBands;
michael@0:    backgroundLogE = oldLogE2  + 2*nbEBands;
michael@0: 
michael@0: #ifdef CUSTOM_MODES
michael@0:    if (st->signalling && data!=NULL)
michael@0:    {
michael@0:       int data0=data[0];
michael@0:       /* Convert "standard mode" to Opus header */
michael@0:       if (mode->Fs==48000 && mode->shortMdctSize==120)
michael@0:       {
michael@0:          data0 = fromOpus(data0);
michael@0:          if (data0<0)
michael@0:             return OPUS_INVALID_PACKET;
michael@0:       }
michael@0:       st->end = IMAX(1, mode->effEBands-2*(data0>>5));
michael@0:       LM = (data0>>3)&0x3;
michael@0:       C = 1 + ((data0>>2)&0x1);
michael@0:       data++;
michael@0:       len--;
michael@0:       if (LM>mode->maxLM)
michael@0:          return OPUS_INVALID_PACKET;
michael@0:       if (frame_size < mode->shortMdctSize<<LM)
michael@0:          return OPUS_BUFFER_TOO_SMALL;
michael@0:       else
michael@0:          frame_size = mode->shortMdctSize<<LM;
michael@0:    } else {
michael@0: #else
michael@0:    {
michael@0: #endif
michael@0:       for (LM=0;LM<=mode->maxLM;LM++)
michael@0:          if (mode->shortMdctSize<<LM==frame_size)
michael@0:             break;
michael@0:       if (LM>mode->maxLM)
michael@0:          return OPUS_BAD_ARG;
michael@0:    }
michael@0:    M=1<<LM;
michael@0: 
michael@0:    if (len<0 || len>1275 || pcm==NULL)
michael@0:       return OPUS_BAD_ARG;
michael@0: 
michael@0:    N = M*mode->shortMdctSize;
michael@0: 
michael@0:    effEnd = st->end;
michael@0:    if (effEnd > mode->effEBands)
michael@0:       effEnd = mode->effEBands;
michael@0: 
michael@0:    if (data == NULL || len<=1)
michael@0:    {
michael@0:       celt_decode_lost(st, pcm, N, LM);
michael@0:       RESTORE_STACK;
michael@0:       return frame_size/st->downsample;
michael@0:    }
michael@0: 
michael@0:    if (dec == NULL)
michael@0:    {
michael@0:       ec_dec_init(&_dec,(unsigned char*)data,len);
michael@0:       dec = &_dec;
michael@0:    }
michael@0: 
michael@0:    if (C==1)
michael@0:    {
michael@0:       for (i=0;i<nbEBands;i++)
michael@0:          oldBandE[i]=MAX16(oldBandE[i],oldBandE[nbEBands+i]);
michael@0:    }
michael@0: 
michael@0:    total_bits = len*8;
michael@0:    tell = ec_tell(dec);
michael@0: 
michael@0:    if (tell >= total_bits)
michael@0:       silence = 1;
michael@0:    else if (tell==1)
michael@0:       silence = ec_dec_bit_logp(dec, 15);
michael@0:    else
michael@0:       silence = 0;
michael@0:    if (silence)
michael@0:    {
michael@0:       /* Pretend we've read all the remaining bits */
michael@0:       tell = len*8;
michael@0:       dec->nbits_total+=tell-ec_tell(dec);
michael@0:    }
michael@0: 
michael@0:    postfilter_gain = 0;
michael@0:    postfilter_pitch = 0;
michael@0:    postfilter_tapset = 0;
michael@0:    if (st->start==0 && tell+16 <= total_bits)
michael@0:    {
michael@0:       if(ec_dec_bit_logp(dec, 1))
michael@0:       {
michael@0:          int qg, octave;
michael@0:          octave = ec_dec_uint(dec, 6);
michael@0:          postfilter_pitch = (16<<octave)+ec_dec_bits(dec, 4+octave)-1;
michael@0:          qg = ec_dec_bits(dec, 3);
michael@0:          if (ec_tell(dec)+2<=total_bits)
michael@0:             postfilter_tapset = ec_dec_icdf(dec, tapset_icdf, 2);
michael@0:          postfilter_gain = QCONST16(.09375f,15)*(qg+1);
michael@0:       }
michael@0:       tell = ec_tell(dec);
michael@0:    }
michael@0: 
michael@0:    if (LM > 0 && tell+3 <= total_bits)
michael@0:    {
michael@0:       isTransient = ec_dec_bit_logp(dec, 3);
michael@0:       tell = ec_tell(dec);
michael@0:    }
michael@0:    else
michael@0:       isTransient = 0;
michael@0: 
michael@0:    if (isTransient)
michael@0:       shortBlocks = M;
michael@0:    else
michael@0:       shortBlocks = 0;
michael@0: 
michael@0:    /* Decode the global flags (first symbols in the stream) */
michael@0:    intra_ener = tell+3<=total_bits ? ec_dec_bit_logp(dec, 3) : 0;
michael@0:    /* Get band energies */
michael@0:    unquant_coarse_energy(mode, st->start, st->end, oldBandE,
michael@0:          intra_ener, dec, C, LM);
michael@0: 
michael@0:    ALLOC(tf_res, nbEBands, int);
michael@0:    tf_decode(st->start, st->end, isTransient, tf_res, LM, dec);
michael@0: 
michael@0:    tell = ec_tell(dec);
michael@0:    spread_decision = SPREAD_NORMAL;
michael@0:    if (tell+4 <= total_bits)
michael@0:       spread_decision = ec_dec_icdf(dec, spread_icdf, 5);
michael@0: 
michael@0:    ALLOC(cap, nbEBands, int);
michael@0: 
michael@0:    init_caps(mode,cap,LM,C);
michael@0: 
michael@0:    ALLOC(offsets, nbEBands, int);
michael@0: 
michael@0:    dynalloc_logp = 6;
michael@0:    total_bits<<=BITRES;
michael@0:    tell = ec_tell_frac(dec);
michael@0:    for (i=st->start;i<st->end;i++)
michael@0:    {
michael@0:       int width, quanta;
michael@0:       int dynalloc_loop_logp;
michael@0:       int boost;
michael@0:       width = C*(eBands[i+1]-eBands[i])<<LM;
michael@0:       /* quanta is 6 bits, but no more than 1 bit/sample
michael@0:          and no less than 1/8 bit/sample */
michael@0:       quanta = IMIN(width<<BITRES, IMAX(6<<BITRES, width));
michael@0:       dynalloc_loop_logp = dynalloc_logp;
michael@0:       boost = 0;
michael@0:       while (tell+(dynalloc_loop_logp<<BITRES) < total_bits && boost < cap[i])
michael@0:       {
michael@0:          int flag;
michael@0:          flag = ec_dec_bit_logp(dec, dynalloc_loop_logp);
michael@0:          tell = ec_tell_frac(dec);
michael@0:          if (!flag)
michael@0:             break;
michael@0:          boost += quanta;
michael@0:          total_bits -= quanta;
michael@0:          dynalloc_loop_logp = 1;
michael@0:       }
michael@0:       offsets[i] = boost;
michael@0:       /* Making dynalloc more likely */
michael@0:       if (boost>0)
michael@0:          dynalloc_logp = IMAX(2, dynalloc_logp-1);
michael@0:    }
michael@0: 
michael@0:    ALLOC(fine_quant, nbEBands, int);
michael@0:    alloc_trim = tell+(6<<BITRES) <= total_bits ?
michael@0:          ec_dec_icdf(dec, trim_icdf, 7) : 5;
michael@0: 
michael@0:    bits = (((opus_int32)len*8)<<BITRES) - ec_tell_frac(dec) - 1;
michael@0:    anti_collapse_rsv = isTransient&&LM>=2&&bits>=((LM+2)<<BITRES) ? (1<<BITRES) : 0;
michael@0:    bits -= anti_collapse_rsv;
michael@0: 
michael@0:    ALLOC(pulses, nbEBands, int);
michael@0:    ALLOC(fine_priority, nbEBands, int);
michael@0: 
michael@0:    codedBands = compute_allocation(mode, st->start, st->end, offsets, cap,
michael@0:          alloc_trim, &intensity, &dual_stereo, bits, &balance, pulses,
michael@0:          fine_quant, fine_priority, C, LM, dec, 0, 0, 0);
michael@0: 
michael@0:    unquant_fine_energy(mode, st->start, st->end, oldBandE, fine_quant, dec, C);
michael@0: 
michael@0:    /* Decode fixed codebook */
michael@0:    ALLOC(collapse_masks, C*nbEBands, unsigned char);
michael@0:    ALLOC(X, C*N, celt_norm);   /**< Interleaved normalised MDCTs */
michael@0: 
michael@0:    quant_all_bands(0, mode, st->start, st->end, X, C==2 ? X+N : NULL, collapse_masks,
michael@0:          NULL, pulses, shortBlocks, spread_decision, dual_stereo, intensity, tf_res,
michael@0:          len*(8<<BITRES)-anti_collapse_rsv, balance, dec, LM, codedBands, &st->rng);
michael@0: 
michael@0:    if (anti_collapse_rsv > 0)
michael@0:    {
michael@0:       anti_collapse_on = ec_dec_bits(dec, 1);
michael@0:    }
michael@0: 
michael@0:    unquant_energy_finalise(mode, st->start, st->end, oldBandE,
michael@0:          fine_quant, fine_priority, len*8-ec_tell(dec), dec, C);
michael@0: 
michael@0:    if (anti_collapse_on)
michael@0:       anti_collapse(mode, X, collapse_masks, LM, C, N,
michael@0:             st->start, st->end, oldBandE, oldLogE, oldLogE2, pulses, st->rng);
michael@0: 
michael@0:    ALLOC(freq, IMAX(CC,C)*N, celt_sig); /**< Interleaved signal MDCTs */
michael@0: 
michael@0:    if (silence)
michael@0:    {
michael@0:       for (i=0;i<C*nbEBands;i++)
michael@0:          oldBandE[i] = -QCONST16(28.f,DB_SHIFT);
michael@0:       for (i=0;i<C*N;i++)
michael@0:          freq[i] = 0;
michael@0:    } else {
michael@0:       /* Synthesis */
michael@0:       denormalise_bands(mode, X, freq, oldBandE, st->start, effEnd, C, M);
michael@0:    }
michael@0:    c=0; do {
michael@0:       OPUS_MOVE(decode_mem[c], decode_mem[c]+N, DECODE_BUFFER_SIZE-N+overlap/2);
michael@0:    } while (++c<CC);
michael@0: 
michael@0:    c=0; do {
michael@0:       int bound = M*eBands[effEnd];
michael@0:       if (st->downsample!=1)
michael@0:          bound = IMIN(bound, N/st->downsample);
michael@0:       for (i=bound;i<N;i++)
michael@0:          freq[c*N+i] = 0;
michael@0:    } while (++c<C);
michael@0: 
michael@0:    c=0; do {
michael@0:       out_syn[c] = decode_mem[c]+DECODE_BUFFER_SIZE-N;
michael@0:    } while (++c<CC);
michael@0: 
michael@0:    if (CC==2&&C==1)
michael@0:    {
michael@0:       for (i=0;i<N;i++)
michael@0:          freq[N+i] = freq[i];
michael@0:    }
michael@0:    if (CC==1&&C==2)
michael@0:    {
michael@0:       for (i=0;i<N;i++)
michael@0:          freq[i] = HALF32(ADD32(freq[i],freq[N+i]));
michael@0:    }
michael@0: 
michael@0:    /* Compute inverse MDCTs */
michael@0:    compute_inv_mdcts(mode, shortBlocks, freq, out_syn, CC, LM);
michael@0: 
michael@0:    c=0; do {
michael@0:       st->postfilter_period=IMAX(st->postfilter_period, COMBFILTER_MINPERIOD);
michael@0:       st->postfilter_period_old=IMAX(st->postfilter_period_old, COMBFILTER_MINPERIOD);
michael@0:       comb_filter(out_syn[c], out_syn[c], st->postfilter_period_old, st->postfilter_period, mode->shortMdctSize,
michael@0:             st->postfilter_gain_old, st->postfilter_gain, st->postfilter_tapset_old, st->postfilter_tapset,
michael@0:             mode->window, overlap);
michael@0:       if (LM!=0)
michael@0:          comb_filter(out_syn[c]+mode->shortMdctSize, out_syn[c]+mode->shortMdctSize, st->postfilter_period, postfilter_pitch, N-mode->shortMdctSize,
michael@0:                st->postfilter_gain, postfilter_gain, st->postfilter_tapset, postfilter_tapset,
michael@0:                mode->window, overlap);
michael@0: 
michael@0:    } while (++c<CC);
michael@0:    st->postfilter_period_old = st->postfilter_period;
michael@0:    st->postfilter_gain_old = st->postfilter_gain;
michael@0:    st->postfilter_tapset_old = st->postfilter_tapset;
michael@0:    st->postfilter_period = postfilter_pitch;
michael@0:    st->postfilter_gain = postfilter_gain;
michael@0:    st->postfilter_tapset = postfilter_tapset;
michael@0:    if (LM!=0)
michael@0:    {
michael@0:       st->postfilter_period_old = st->postfilter_period;
michael@0:       st->postfilter_gain_old = st->postfilter_gain;
michael@0:       st->postfilter_tapset_old = st->postfilter_tapset;
michael@0:    }
michael@0: 
michael@0:    if (C==1) {
michael@0:       for (i=0;i<nbEBands;i++)
michael@0:          oldBandE[nbEBands+i]=oldBandE[i];
michael@0:    }
michael@0: 
michael@0:    /* In case start or end were to change */
michael@0:    if (!isTransient)
michael@0:    {
michael@0:       for (i=0;i<2*nbEBands;i++)
michael@0:          oldLogE2[i] = oldLogE[i];
michael@0:       for (i=0;i<2*nbEBands;i++)
michael@0:          oldLogE[i] = oldBandE[i];
michael@0:       for (i=0;i<2*nbEBands;i++)
michael@0:          backgroundLogE[i] = MIN16(backgroundLogE[i] + M*QCONST16(0.001f,DB_SHIFT), oldBandE[i]);
michael@0:    } else {
michael@0:       for (i=0;i<2*nbEBands;i++)
michael@0:          oldLogE[i] = MIN16(oldLogE[i], oldBandE[i]);
michael@0:    }
michael@0:    c=0; do
michael@0:    {
michael@0:       for (i=0;i<st->start;i++)
michael@0:       {
michael@0:          oldBandE[c*nbEBands+i]=0;
michael@0:          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
michael@0:       }
michael@0:       for (i=st->end;i<nbEBands;i++)
michael@0:       {
michael@0:          oldBandE[c*nbEBands+i]=0;
michael@0:          oldLogE[c*nbEBands+i]=oldLogE2[c*nbEBands+i]=-QCONST16(28.f,DB_SHIFT);
michael@0:       }
michael@0:    } while (++c<2);
michael@0:    st->rng = dec->rng;
michael@0: 
michael@0:    /* We reuse freq[] as scratch space for the de-emphasis */
michael@0:    deemphasis(out_syn, pcm, N, CC, st->downsample, mode->preemph, st->preemph_memD, freq);
michael@0:    st->loss_count = 0;
michael@0:    RESTORE_STACK;
michael@0:    if (ec_tell(dec) > 8*len)
michael@0:       return OPUS_INTERNAL_ERROR;
michael@0:    if(ec_get_error(dec))
michael@0:       st->error = 1;
michael@0:    return frame_size/st->downsample;
michael@0: }
michael@0: 
michael@0: 
michael@0: #ifdef CUSTOM_MODES
michael@0: 
michael@0: #ifdef FIXED_POINT
michael@0: int opus_custom_decode(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, opus_int16 * OPUS_RESTRICT pcm, int frame_size)
michael@0: {
michael@0:    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
michael@0: }
michael@0: 
michael@0: #ifndef DISABLE_FLOAT_API
michael@0: int opus_custom_decode_float(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, float * OPUS_RESTRICT pcm, int frame_size)
michael@0: {
michael@0:    int j, ret, C, N;
michael@0:    VARDECL(opus_int16, out);
michael@0:    ALLOC_STACK;
michael@0: 
michael@0:    if (pcm==NULL)
michael@0:       return OPUS_BAD_ARG;
michael@0: 
michael@0:    C = st->channels;
michael@0:    N = frame_size;
michael@0: 
michael@0:    ALLOC(out, C*N, opus_int16);
michael@0:    ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL);
michael@0:    if (ret>0)
michael@0:       for (j=0;j<C*ret;j++)
michael@0:          pcm[j]=out[j]*(1.f/32768.f);
michael@0: 
michael@0:    RESTORE_STACK;
michael@0:    return ret;
michael@0: }
michael@0: #endif /* DISABLE_FLOAT_API */
michael@0: 
michael@0: #else
michael@0: 
michael@0: int opus_custom_decode_float(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, float * OPUS_RESTRICT pcm, int frame_size)
michael@0: {
michael@0:    return celt_decode_with_ec(st, data, len, pcm, frame_size, NULL);
michael@0: }
michael@0: 
michael@0: int opus_custom_decode(CELTDecoder * OPUS_RESTRICT st, const unsigned char *data, int len, opus_int16 * OPUS_RESTRICT pcm, int frame_size)
michael@0: {
michael@0:    int j, ret, C, N;
michael@0:    VARDECL(celt_sig, out);
michael@0:    ALLOC_STACK;
michael@0: 
michael@0:    if (pcm==NULL)
michael@0:       return OPUS_BAD_ARG;
michael@0: 
michael@0:    C = st->channels;
michael@0:    N = frame_size;
michael@0:    ALLOC(out, C*N, celt_sig);
michael@0: 
michael@0:    ret=celt_decode_with_ec(st, data, len, out, frame_size, NULL);
michael@0: 
michael@0:    if (ret>0)
michael@0:       for (j=0;j<C*ret;j++)
michael@0:          pcm[j] = FLOAT2INT16 (out[j]);
michael@0: 
michael@0:    RESTORE_STACK;
michael@0:    return ret;
michael@0: }
michael@0: 
michael@0: #endif
michael@0: #endif /* CUSTOM_MODES */
michael@0: 
michael@0: int opus_custom_decoder_ctl(CELTDecoder * OPUS_RESTRICT st, int request, ...)
michael@0: {
michael@0:    va_list ap;
michael@0: 
michael@0:    va_start(ap, request);
michael@0:    switch (request)
michael@0:    {
michael@0:       case CELT_SET_START_BAND_REQUEST:
michael@0:       {
michael@0:          opus_int32 value = va_arg(ap, opus_int32);
michael@0:          if (value<0 || value>=st->mode->nbEBands)
michael@0:             goto bad_arg;
michael@0:          st->start = value;
michael@0:       }
michael@0:       break;
michael@0:       case CELT_SET_END_BAND_REQUEST:
michael@0:       {
michael@0:          opus_int32 value = va_arg(ap, opus_int32);
michael@0:          if (value<1 || value>st->mode->nbEBands)
michael@0:             goto bad_arg;
michael@0:          st->end = value;
michael@0:       }
michael@0:       break;
michael@0:       case CELT_SET_CHANNELS_REQUEST:
michael@0:       {
michael@0:          opus_int32 value = va_arg(ap, opus_int32);
michael@0:          if (value<1 || value>2)
michael@0:             goto bad_arg;
michael@0:          st->stream_channels = value;
michael@0:       }
michael@0:       break;
michael@0:       case CELT_GET_AND_CLEAR_ERROR_REQUEST:
michael@0:       {
michael@0:          opus_int32 *value = va_arg(ap, opus_int32*);
michael@0:          if (value==NULL)
michael@0:             goto bad_arg;
michael@0:          *value=st->error;
michael@0:          st->error = 0;
michael@0:       }
michael@0:       break;
michael@0:       case OPUS_GET_LOOKAHEAD_REQUEST:
michael@0:       {
michael@0:          opus_int32 *value = va_arg(ap, opus_int32*);
michael@0:          if (value==NULL)
michael@0:             goto bad_arg;
michael@0:          *value = st->overlap/st->downsample;
michael@0:       }
michael@0:       break;
michael@0:       case OPUS_RESET_STATE:
michael@0:       {
michael@0:          int i;
michael@0:          opus_val16 *lpc, *oldBandE, *oldLogE, *oldLogE2;
michael@0:          lpc = (opus_val16*)(st->_decode_mem+(DECODE_BUFFER_SIZE+st->overlap)*st->channels);
michael@0:          oldBandE = lpc+st->channels*LPC_ORDER;
michael@0:          oldLogE = oldBandE + 2*st->mode->nbEBands;
michael@0:          oldLogE2 = oldLogE + 2*st->mode->nbEBands;
michael@0:          OPUS_CLEAR((char*)&st->DECODER_RESET_START,
michael@0:                opus_custom_decoder_get_size(st->mode, st->channels)-
michael@0:                ((char*)&st->DECODER_RESET_START - (char*)st));
michael@0:          for (i=0;i<2*st->mode->nbEBands;i++)
michael@0:             oldLogE[i]=oldLogE2[i]=-QCONST16(28.f,DB_SHIFT);
michael@0:       }
michael@0:       break;
michael@0:       case OPUS_GET_PITCH_REQUEST:
michael@0:       {
michael@0:          opus_int32 *value = va_arg(ap, opus_int32*);
michael@0:          if (value==NULL)
michael@0:             goto bad_arg;
michael@0:          *value = st->postfilter_period;
michael@0:       }
michael@0:       break;
michael@0:       case CELT_GET_MODE_REQUEST:
michael@0:       {
michael@0:          const CELTMode ** value = va_arg(ap, const CELTMode**);
michael@0:          if (value==0)
michael@0:             goto bad_arg;
michael@0:          *value=st->mode;
michael@0:       }
michael@0:       break;
michael@0:       case CELT_SET_SIGNALLING_REQUEST:
michael@0:       {
michael@0:          opus_int32 value = va_arg(ap, opus_int32);
michael@0:          st->signalling = value;
michael@0:       }
michael@0:       break;
michael@0:       case OPUS_GET_FINAL_RANGE_REQUEST:
michael@0:       {
michael@0:          opus_uint32 * value = va_arg(ap, opus_uint32 *);
michael@0:          if (value==0)
michael@0:             goto bad_arg;
michael@0:          *value=st->rng;
michael@0:       }
michael@0:       break;
michael@0:       default:
michael@0:          goto bad_request;
michael@0:    }
michael@0:    va_end(ap);
michael@0:    return OPUS_OK;
michael@0: bad_arg:
michael@0:    va_end(ap);
michael@0:    return OPUS_BAD_ARG;
michael@0: bad_request:
michael@0:       va_end(ap);
michael@0:   return OPUS_UNIMPLEMENTED;
michael@0: }