/* Copyright (c) 2010 Xiph.Org Foundation, Skype Limited

Written by Jean-Marc Valin and Koen Vos */

/*

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions

are met:

- Redistributions of source code must retain the above copyright

notice, this list of conditions and the following disclaimer.

- Redistributions in binary form must reproduce the above copyright

notice, this list of conditions and the following disclaimer in the

documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER

OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

#ifdef HAVE_CONFIG_H

#endif

#ifndef OPUS_BUILD

# error "OPUS_BUILD _MUST_ be defined to build Opus. This probably means you need other defines as well, as in a config.h. See the included build files for details."

#endif

#if defined(__GNUC__) && (__GNUC__ >= 2) && !defined(__OPTIMIZE__) && !defined(OPUS_WILL_BE_SLOW)

# pragma message "You appear to be compiling without optimization, if so opus will be very slow."

#endif

#include <stdarg.h>

#include "celt.h"

#include "opus.h"

#include "entdec.h"

#include "modes.h"

#include "API.h"

#include "stack_alloc.h"

#include "float_cast.h"

#include "opus_private.h"

#include "os_support.h"

#include "structs.h"

#include "define.h"

#include "mathops.h"

struct OpusDecoder {

int celt_dec_offset;

int silk_dec_offset;

int channels;

opus_int32 Fs; /** Sampling rate (at the API level) */

silk_DecControlStruct DecControl;

int decode_gain;

/* Everything beyond this point gets cleared on a reset */

#define OPUS_DECODER_RESET_START stream_channels

int stream_channels;

int bandwidth;

int mode;

int prev_mode;

int frame_size;

int prev_redundancy;

int last_packet_duration;

#ifndef FIXED_POINT

opus_val16 softclip_mem[2];

#endif

opus_uint32 rangeFinal;

};

#if defined(ENABLE_HARDENING) || defined(ENABLE_ASSERTIONS)

static void validate_opus_decoder(OpusDecoder *st)

{

celt_assert(st->channels == 1 || st->channels == 2);

celt_assert(st->Fs == 48000 || st->Fs == 24000 || st->Fs == 16000 || st->Fs == 12000 || st->Fs == 8000);

celt_assert(st->DecControl.API_sampleRate == st->Fs);

celt_assert(st->DecControl.internalSampleRate == 0 || st->DecControl.internalSampleRate == 16000 || st->DecControl.internalSampleRate == 12000 || st->DecControl.internalSampleRate == 8000);

celt_assert(st->DecControl.nChannelsAPI == st->channels);

celt_assert(st->DecControl.nChannelsInternal == 0 || st->DecControl.nChannelsInternal == 1 || st->DecControl.nChannelsInternal == 2);

celt_assert(st->DecControl.payloadSize_ms == 0 || st->DecControl.payloadSize_ms == 10 || st->DecControl.payloadSize_ms == 20 || st->DecControl.payloadSize_ms == 40 || st->DecControl.payloadSize_ms == 60);

#ifdef OPUS_ARCHMASK

celt_assert(st->arch >= 0);

celt_assert(st->arch <= OPUS_ARCHMASK);

#endif

celt_assert(st->stream_channels == 1 || st->stream_channels == 2);

#define VALIDATE_OPUS_DECODER(st) validate_opus_decoder(st)

#else

#define VALIDATE_OPUS_DECODER(st)

#endif

int opus_decoder_get_size(int channels)

{

int silkDecSizeBytes, celtDecSizeBytes;

int ret;

if (channels<1 || channels > 2)

return 0;

ret = silk_Get_Decoder_Size( &silkDecSizeBytes );

if(ret)

return 0;

silkDecSizeBytes = align(silkDecSizeBytes);

celtDecSizeBytes = celt_decoder_get_size(channels);

return align(sizeof(OpusDecoder))+silkDecSizeBytes+celtDecSizeBytes;

}

int opus_decoder_init(OpusDecoder *st, opus_int32 Fs, int channels)

{

void *silk_dec;

CELTDecoder *celt_dec;

int ret, silkDecSizeBytes;

if ((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)

|| (channels!=1&&channels!=2))

return OPUS_BAD_ARG;

OPUS_CLEAR((char*)st, opus_decoder_get_size(channels));

ret = silk_Get_Decoder_Size(&silkDecSizeBytes);

if (ret)

return OPUS_INTERNAL_ERROR;

silkDecSizeBytes = align(silkDecSizeBytes);

st->silk_dec_offset = align(sizeof(OpusDecoder));

st->celt_dec_offset = st->silk_dec_offset+silkDecSizeBytes;

silk_dec = (char*)st+st->silk_dec_offset;

celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);

st->stream_channels = st->channels = channels;

st->Fs = Fs;

st->DecControl.API_sampleRate = st->Fs;

st->DecControl.nChannelsAPI = st->channels;

/* Reset decoder */

ret = silk_InitDecoder( silk_dec );

if(ret)return OPUS_INTERNAL_ERROR;

/* Initialize CELT decoder */

ret = celt_decoder_init(celt_dec, Fs, channels);

if(ret!=OPUS_OK)return OPUS_INTERNAL_ERROR;

celt_decoder_ctl(celt_dec, CELT_SET_SIGNALLING(0));

st->prev_mode = 0;

st->frame_size = Fs/400;

return OPUS_OK;

}

OpusDecoder *opus_decoder_create(opus_int32 Fs, int channels, int *error)

{

int ret;

OpusDecoder *st;

if ((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)

|| (channels!=1&&channels!=2))

{

if (error)

*error = OPUS_BAD_ARG;

return NULL;

}

st = (OpusDecoder *)opus_alloc(opus_decoder_get_size(channels));

if (st == NULL)

{

if (error)

*error = OPUS_ALLOC_FAIL;

return NULL;

}

ret = opus_decoder_init(st, Fs, channels);

if (error)

*error = ret;

if (ret != OPUS_OK)

{

opus_free(st);

st = NULL;

}

return st;

}

static void smooth_fade(const opus_val16 *in1, const opus_val16 *in2,

opus_val16 *out, int overlap, int channels,

const opus_val16 *window, opus_int32 Fs)

{

int i, c;

int inc = 48000/Fs;

for (c=0;c<channels;c++)

{

for (i=0;i<overlap;i++)

{

opus_val16 w = MULT16_16_Q15(window[i*inc], window[i*inc]);

out[i*channels+c] = SHR32(MAC16_16(MULT16_16(w,in2[i*channels+c]),

Q15ONE-w, in1[i*channels+c]), 15);

}

}

}

static int opus_packet_get_mode(const unsigned char *data)

{

int mode;

if (data[0]&0x80)

{

mode = MODE_CELT_ONLY;

} else if ((data[0]&0x60) == 0x60)

{

mode = MODE_HYBRID;

} else {

mode = MODE_SILK_ONLY;

}

return mode;

}

static int opus_decode_frame(OpusDecoder *st, const unsigned char *data,

opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec)

{

void *silk_dec;

CELTDecoder *celt_dec;

int i, silk_ret=0, celt_ret=0;

ec_dec dec;

opus_int32 silk_frame_size;

int pcm_transition_silk_size;

VARDECL(opus_val16, pcm_transition_silk);

int pcm_transition_celt_size;

VARDECL(opus_val16, pcm_transition_celt);

opus_val16 *pcm_transition=NULL;

int redundant_audio_size;

VARDECL(opus_val16, redundant_audio);

int audiosize;

int mode;

int transition=0;

int start_band;

int redundancy=0;

int redundancy_bytes = 0;

int celt_to_silk=0;

int c;

int F2_5, F5, F10, F20;

const opus_val16 *window;

opus_uint32 redundant_rng = 0;

ALLOC_STACK;

silk_dec = (char*)st+st->silk_dec_offset;

celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);

F20 = st->Fs/50;

F10 = F20>>1;

F5 = F10>>1;

F2_5 = F5>>1;

if (frame_size < F2_5)

{

RESTORE_STACK;

return OPUS_BUFFER_TOO_SMALL;

}

/* Limit frame_size to avoid excessive stack allocations. */

frame_size = IMIN(frame_size, st->Fs/25*3);

/* Payloads of 1 (2 including ToC) or 0 trigger the PLC/DTX */

if (len<=1)

{

data = NULL;

/* In that case, don't conceal more than what the ToC says */

frame_size = IMIN(frame_size, st->frame_size);

}

if (data != NULL)

{

audiosize = st->frame_size;

mode = st->mode;

ec_dec_init(&dec,(unsigned char*)data,len);

} else {

audiosize = frame_size;

mode = st->prev_mode;

bandwidth = 0;

{

/* If we haven't got any packet yet, all we can do is return zeros */

for (i=0;i<audiosize*st->channels;i++)

pcm[i] = 0;

RESTORE_STACK;

return audiosize;

}

/* Avoids trying to run the PLC on sizes other than 2.5 (CELT), 5 (CELT),

10, or 20 (e.g. 12.5 or 30 ms). */

if (audiosize > F20)

{

do {

int ret = opus_decode_frame(st, NULL, 0, pcm, IMIN(audiosize, F20), 0);

if (ret<0)

{

RESTORE_STACK;

return ret;

}

pcm += ret*st->channels;

audiosize -= ret;

} while (audiosize > 0);

RESTORE_STACK;

return frame_size;

} else if (audiosize < F20)

{

if (audiosize > F10)

audiosize = F10;

else if (mode != MODE_SILK_ONLY && audiosize > F5 && audiosize < F10)

audiosize = F5;

}

}

/* In fixed-point, we can tell CELT to do the accumulation on top of the

SILK PCM buffer. This saves some stack space. */

#ifdef FIXED_POINT

celt_accum = (mode != MODE_CELT_ONLY) && (frame_size >= F10);

#else

celt_accum = 0;

#endif

pcm_transition_silk_size = ALLOC_NONE;

pcm_transition_celt_size = ALLOC_NONE;

if (data!=NULL && st->prev_mode > 0 && (

(mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY && !st->prev_redundancy)

|| (mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) )

)

{

transition = 1;

pcm_transition_celt_size = F5*st->channels;

else

pcm_transition_silk_size = F5*st->channels;

}

ALLOC(pcm_transition_celt, pcm_transition_celt_size, opus_val16);

if (transition && mode == MODE_CELT_ONLY)

{

pcm_transition = pcm_transition_celt;

opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0);

}

if (audiosize > frame_size)

{

/*fprintf(stderr, "PCM buffer too small: %d vs %d (mode = %d)\n", audiosize, frame_size, mode);*/

RESTORE_STACK;

return OPUS_BAD_ARG;

} else {

frame_size = audiosize;

}

/* Don't allocate any memory when in CELT-only mode */

pcm_silk_size = (mode != MODE_CELT_ONLY && !celt_accum) ? IMAX(F10, frame_size)*st->channels : ALLOC_NONE;

ALLOC(pcm_silk, pcm_silk_size, opus_int16);

/* SILK processing */

if (mode != MODE_CELT_ONLY)

{

int lost_flag, decoded_samples;

opus_int16 *pcm_ptr;

#ifdef FIXED_POINT

if (celt_accum)

pcm_ptr = pcm;

else

#endif

pcm_ptr = pcm_silk;

if (st->prev_mode==MODE_CELT_ONLY)

silk_InitDecoder( silk_dec );

/* The SILK PLC cannot produce frames of less than 10 ms */

st->DecControl.payloadSize_ms = IMAX(10, 1000 * audiosize / st->Fs);

if (data != NULL)

{

st->DecControl.nChannelsInternal = st->stream_channels;

if( mode == MODE_SILK_ONLY ) {

st->DecControl.internalSampleRate = 16000;

} else {

st->DecControl.internalSampleRate = 16000;

}

} else {

/* Hybrid mode */

st->DecControl.internalSampleRate = 16000;

}

}

lost_flag = data == NULL ? 1 : 2 * decode_fec;

decoded_samples = 0;

do {

/* Call SILK decoder */

int first_frame = decoded_samples == 0;

silk_ret = silk_Decode( silk_dec, &st->DecControl,

if( silk_ret ) {

if (lost_flag) {

/* PLC failure should not be fatal */

silk_frame_size = frame_size;

for (i=0;i<frame_size*st->channels;i++)

pcm_ptr[i] = 0;

} else {

RESTORE_STACK;

}

}

pcm_ptr += silk_frame_size * st->channels;

decoded_samples += silk_frame_size;

} while( decoded_samples < frame_size );

}

start_band = 0;

if (!decode_fec && mode != MODE_CELT_ONLY && data != NULL

&& ec_tell(&dec)+17+20*(st->mode == MODE_HYBRID) <= 8*len)

{

/* Check if we have a redundant 0-8 kHz band */

if (mode == MODE_HYBRID)

redundancy = ec_dec_bit_logp(&dec, 12);

else

redundancy = 1;

if (redundancy)

{

celt_to_silk = ec_dec_bit_logp(&dec, 1);

/* redundancy_bytes will be at least two, in the non-hybrid

case due to the ec_tell() check above */

redundancy_bytes = mode==MODE_HYBRID ?

(opus_int32)ec_dec_uint(&dec, 256)+2 :

len-((ec_tell(&dec)+7)>>3);

len -= redundancy_bytes;

/* This is a sanity check. It should never happen for a valid

packet, so the exact behaviour is not normative. */

if (len*8 < ec_tell(&dec))

{

len = 0;

redundancy_bytes = 0;

redundancy = 0;

}

/* Shrink decoder because of raw bits */

dec.storage -= redundancy_bytes;

}

}

if (mode != MODE_CELT_ONLY)

start_band = 17;

if (redundancy)

{

transition = 0;

pcm_transition_silk_size=ALLOC_NONE;

}

ALLOC(pcm_transition_silk, pcm_transition_silk_size, opus_val16);

if (transition && mode != MODE_CELT_ONLY)

{

pcm_transition = pcm_transition_silk;

opus_decode_frame(st, NULL, 0, pcm_transition, IMIN(F5, audiosize), 0);

}

if (bandwidth)

{

int endband=21;

{

case OPUS_BANDWIDTH_NARROWBAND:

endband = 13;

break;

case OPUS_BANDWIDTH_MEDIUMBAND:

case OPUS_BANDWIDTH_WIDEBAND:

endband = 17;

break;

case OPUS_BANDWIDTH_SUPERWIDEBAND:

endband = 19;

break;

case OPUS_BANDWIDTH_FULLBAND:

endband = 21;

break;

default:

celt_assert(0);

break;

/* Only allocation memory for redundancy if/when needed */

redundant_audio_size = redundancy ? F5*st->channels : ALLOC_NONE;

ALLOC(redundant_audio, redundant_audio_size, opus_val16);

/* 5 ms redundant frame for CELT->SILK*/

if (redundancy && celt_to_silk)

{

redundant_audio, F5, NULL, 0);

MUST_SUCCEED(celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng)));

}

/* MUST be after PLC */

if (mode != MODE_SILK_ONLY)

{

int celt_frame_size = IMIN(F20, frame_size);

/* Make sure to discard any previous CELT state */

if (mode != st->prev_mode && st->prev_mode > 0 && !st->prev_redundancy)

/* Decode CELT */

celt_ret = celt_decode_with_ec(celt_dec, decode_fec ? NULL : data,

} else {

unsigned char silence[2] = {0xFF, 0xFF};

if (!celt_accum)

{

for (i=0;i<frame_size*st->channels;i++)

pcm[i] = 0;

}

/* For hybrid -> SILK transitions, we let the CELT MDCT

do a fade-out by decoding a silence frame */

if (st->prev_mode == MODE_HYBRID && !(redundancy && celt_to_silk && st->prev_redundancy) )

{

MUST_SUCCEED(celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0)));

celt_decode_with_ec(celt_dec, silence, 2, pcm, F2_5, NULL, celt_accum);

}

}

{

#ifdef FIXED_POINT

for (i=0;i<frame_size*st->channels;i++)

#else

for (i=0;i<frame_size*st->channels;i++)

pcm[i] = pcm[i] + (opus_val16)((1.f/32768.f)*pcm_silk[i]);

#endif

}

{

const CELTMode *celt_mode;

window = celt_mode->window;

}

/* 5 ms redundant frame for SILK->CELT */

if (redundancy && !celt_to_silk)

{

MUST_SUCCEED(celt_decoder_ctl(celt_dec, OPUS_RESET_STATE));

MUST_SUCCEED(celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(0)));

celt_decode_with_ec(celt_dec, data+len, redundancy_bytes, redundant_audio, F5, NULL, 0);

MUST_SUCCEED(celt_decoder_ctl(celt_dec, OPUS_GET_FINAL_RANGE(&redundant_rng)));

smooth_fade(pcm+st->channels*(frame_size-F2_5), redundant_audio+st->channels*F2_5,

pcm+st->channels*(frame_size-F2_5), F2_5, st->channels, window, st->Fs);

}

if (redundancy && celt_to_silk)

{

for (c=0;c<st->channels;c++)

{

for (i=0;i<F2_5;i++)

pcm[st->channels*i+c] = redundant_audio[st->channels*i+c];

}

smooth_fade(redundant_audio+st->channels*F2_5, pcm+st->channels*F2_5,

pcm+st->channels*F2_5, F2_5, st->channels, window, st->Fs);

}

if (transition)

{

if (audiosize >= F5)

{

for (i=0;i<st->channels*F2_5;i++)

pcm[i] = pcm_transition[i];

smooth_fade(pcm_transition+st->channels*F2_5, pcm+st->channels*F2_5,

pcm+st->channels*F2_5, F2_5,

st->channels, window, st->Fs);

} else {

/* Not enough time to do a clean transition, but we do it anyway

This will not preserve amplitude perfectly and may introduce

a bit of temporal aliasing, but it shouldn't be too bad and

that's pretty much the best we can do. In any case, generating this

transition it pretty silly in the first place */

smooth_fade(pcm_transition, pcm,

pcm, F2_5,

st->channels, window, st->Fs);

}

}

if(st->decode_gain)

{

opus_val32 gain;

gain = celt_exp2(MULT16_16_P15(QCONST16(6.48814081e-4f, 25), st->decode_gain));

for (i=0;i<frame_size*st->channels;i++)

{

opus_val32 x;

x = MULT16_32_P16(pcm[i],gain);

pcm[i] = SATURATE(x, 32767);

}

}

if (len <= 1)

st->rangeFinal = 0;

else

st->rangeFinal = dec.rng ^ redundant_rng;

st->prev_mode = mode;

st->prev_redundancy = redundancy && !celt_to_silk;

if (OPUS_CHECK_ARRAY(pcm, audiosize*st->channels))

OPUS_PRINT_INT(audiosize);

}

RESTORE_STACK;

return celt_ret < 0 ? celt_ret : audiosize;

}

int opus_decode_native(OpusDecoder *st, const unsigned char *data,

opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec,

{

int i, nb_samples;

int count, offset;

unsigned char toc;

int packet_frame_size, packet_bandwidth, packet_mode, packet_stream_channels;

/* 48 x 2.5 ms = 120 ms */

opus_int16 size[48];

if (decode_fec<0 || decode_fec>1)

return OPUS_BAD_ARG;

/* For FEC/PLC, frame_size has to be to have a multiple of 2.5 ms */

if ((decode_fec || len==0 || data==NULL) && frame_size%(st->Fs/400)!=0)

return OPUS_BAD_ARG;

if (len==0 || data==NULL)

{

int pcm_count=0;

do {

int ret;

if (ret<0)

return ret;

pcm_count += ret;

} while (pcm_count < frame_size);

celt_assert(pcm_count == frame_size);

if (OPUS_CHECK_ARRAY(pcm, pcm_count*st->channels))

OPUS_PRINT_INT(pcm_count);

st->last_packet_duration = pcm_count;

return pcm_count;

} else if (len<0)

return OPUS_BAD_ARG;

packet_mode = opus_packet_get_mode(data);

packet_bandwidth = opus_packet_get_bandwidth(data);

packet_frame_size = opus_packet_get_samples_per_frame(data, st->Fs);

packet_stream_channels = opus_packet_get_nb_channels(data);

count = opus_packet_parse_impl(data, len, self_delimited, &toc, NULL,

size, &offset, packet_offset);

if (count<0)

return count;

data += offset;

if (decode_fec)

{

int duration_copy;

int ret;

/* If no FEC can be present, run the PLC (recursive call) */

if (frame_size < packet_frame_size || packet_mode == MODE_CELT_ONLY || st->mode == MODE_CELT_ONLY)

/* Otherwise, run the PLC on everything except the size for which we might have FEC */

duration_copy = st->last_packet_duration;

if (frame_size-packet_frame_size!=0)

{

if (ret<0)

{

st->last_packet_duration = duration_copy;

return ret;

}

celt_assert(ret==frame_size-packet_frame_size);

}

/* Complete with FEC */

st->mode = packet_mode;

st->bandwidth = packet_bandwidth;

st->frame_size = packet_frame_size;

st->stream_channels = packet_stream_channels;

ret = opus_decode_frame(st, data, size[0], pcm+st->channels*(frame_size-packet_frame_size),

packet_frame_size, 1);

if (ret<0)

return ret;

else {

if (OPUS_CHECK_ARRAY(pcm, frame_size*st->channels))

OPUS_PRINT_INT(frame_size);

st->last_packet_duration = frame_size;

return frame_size;

}

}

if (count*packet_frame_size > frame_size)

return OPUS_BUFFER_TOO_SMALL;

/* Update the state as the last step to avoid updating it on an invalid packet */

st->mode = packet_mode;

st->bandwidth = packet_bandwidth;

st->frame_size = packet_frame_size;

st->stream_channels = packet_stream_channels;

nb_samples=0;

for (i=0;i<count;i++)

{

int ret;

if (ret<0)

return ret;

data += size[i];

nb_samples += ret;

}

st->last_packet_duration = nb_samples;

if (OPUS_CHECK_ARRAY(pcm, nb_samples*st->channels))

OPUS_PRINT_INT(nb_samples);

#ifndef FIXED_POINT

if (soft_clip)

opus_pcm_soft_clip(pcm, nb_samples, st->channels, st->softclip_mem);

else

st->softclip_mem[0]=st->softclip_mem[1]=0;

#endif

return nb_samples;

}

#ifdef FIXED_POINT

int opus_decode(OpusDecoder *st, const unsigned char *data,

opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec)

{

if(frame_size<=0)

return OPUS_BAD_ARG;

return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL, 0);

}

#ifndef DISABLE_FLOAT_API

int opus_decode_float(OpusDecoder *st, const unsigned char *data,

opus_int32 len, float *pcm, int frame_size, int decode_fec)

{

VARDECL(opus_int16, out);

int ret, i;

ALLOC_STACK;

if(frame_size<=0)

{

RESTORE_STACK;

return OPUS_BAD_ARG;

}

if (data != NULL && len > 0 && !decode_fec)

{

nb_samples = opus_decoder_get_nb_samples(st, data, len);

if (nb_samples>0)

frame_size = IMIN(frame_size, nb_samples);

else

return OPUS_INVALID_PACKET;

}

celt_assert(st->channels == 1 || st->channels == 2);

ALLOC(out, frame_size*st->channels, opus_int16);

if (ret > 0)

{

for (i=0;i<ret*st->channels;i++)

pcm[i] = (1.f/32768.f)*(out[i]);

}

RESTORE_STACK;

return ret;

}

#endif

#else

int opus_decode(OpusDecoder *st, const unsigned char *data,

opus_int32 len, opus_int16 *pcm, int frame_size, int decode_fec)

{

VARDECL(float, out);

int ret, i;

ALLOC_STACK;

{

RESTORE_STACK;

return OPUS_BAD_ARG;

}

if (data != NULL && len > 0 && !decode_fec)

{

nb_samples = opus_decoder_get_nb_samples(st, data, len);

if (nb_samples>0)

frame_size = IMIN(frame_size, nb_samples);

else

return OPUS_INVALID_PACKET;

}

celt_assert(st->channels == 1 || st->channels == 2);

ALLOC(out, frame_size*st->channels, float);

if (ret > 0)

{

for (i=0;i<ret*st->channels;i++)

pcm[i] = FLOAT2INT16(out[i]);

}

RESTORE_STACK;

return ret;

}

int opus_decode_float(OpusDecoder *st, const unsigned char *data,

opus_int32 len, opus_val16 *pcm, int frame_size, int decode_fec)

{

if(frame_size<=0)

return OPUS_BAD_ARG;

return opus_decode_native(st, data, len, pcm, frame_size, decode_fec, 0, NULL, 0);

}

#endif

int opus_decoder_ctl(OpusDecoder *st, int request, ...)

{

int ret = OPUS_OK;

va_list ap;

void *silk_dec;

CELTDecoder *celt_dec;

silk_dec = (char*)st+st->silk_dec_offset;

celt_dec = (CELTDecoder*)((char*)st+st->celt_dec_offset);

va_start(ap, request);

switch (request)

{

case OPUS_GET_BANDWIDTH_REQUEST:

{

opus_int32 *value = va_arg(ap, opus_int32*);

if (!value)

{

goto bad_arg;

}

*value = st->bandwidth;

}

break;

case OPUS_GET_FINAL_RANGE_REQUEST:

{

opus_uint32 *value = va_arg(ap, opus_uint32*);

if (!value)

{

goto bad_arg;

}

*value = st->rangeFinal;

}

break;

case OPUS_RESET_STATE:

{

OPUS_CLEAR((char*)&st->OPUS_DECODER_RESET_START,

sizeof(OpusDecoder)-

((char*)&st->OPUS_DECODER_RESET_START - (char*)st));

celt_decoder_ctl(celt_dec, OPUS_RESET_STATE);

silk_InitDecoder( silk_dec );

st->stream_channels = st->channels;

st->frame_size = st->Fs/400;

}

break;

case OPUS_GET_SAMPLE_RATE_REQUEST:

{

opus_int32 *value = va_arg(ap, opus_int32*);

}

*value = st->Fs;

}

break;

case OPUS_GET_PITCH_REQUEST:

{

opus_int32 *value = va_arg(ap, opus_int32*);

}

if (st->prev_mode == MODE_CELT_ONLY)

else

*value = st->DecControl.prevPitchLag;

}

break;

case OPUS_GET_GAIN_REQUEST:

{

opus_int32 *value = va_arg(ap, opus_int32*);

}

*value = st->decode_gain;

}

break;

case OPUS_SET_GAIN_REQUEST:

{

opus_int32 value = va_arg(ap, opus_int32);

if (value<-32768 || value>32767)

{

}

st->decode_gain = value;

}

break;

case OPUS_GET_LAST_PACKET_DURATION_REQUEST:

{

opus_int32 *value = va_arg(ap, opus_int32*);

if (!value)

{

goto bad_arg;

}

*value = st->last_packet_duration;

}

break;

case OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST:

{

opus_int32 value = va_arg(ap, opus_int32);

if(value<0 || value>1)

{

goto bad_arg;

}

ret = celt_decoder_ctl(celt_dec, OPUS_SET_PHASE_INVERSION_DISABLED(value));

}

break;

case OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST:

{

opus_int32 *value = va_arg(ap, opus_int32*);

if (!value)

{

goto bad_arg;

}

ret = celt_decoder_ctl(celt_dec, OPUS_GET_PHASE_INVERSION_DISABLED(value));

}

break;

default:

/*fprintf(stderr, "unknown opus_decoder_ctl() request: %d", request);*/

ret = OPUS_UNIMPLEMENTED;

break;

}

va_end(ap);

return ret;

bad_arg:

va_end(ap);

return OPUS_BAD_ARG;

}

void opus_decoder_destroy(OpusDecoder *st)

{

opus_free(st);

}

int opus_packet_get_bandwidth(const unsigned char *data)

{

int bandwidth;

if (data[0]&0x80)

{

bandwidth = OPUS_BANDWIDTH_MEDIUMBAND + ((data[0]>>5)&0x3);

if (bandwidth == OPUS_BANDWIDTH_MEDIUMBAND)

bandwidth = OPUS_BANDWIDTH_NARROWBAND;

} else if ((data[0]&0x60) == 0x60)

{

bandwidth = (data[0]&0x10) ? OPUS_BANDWIDTH_FULLBAND :

OPUS_BANDWIDTH_SUPERWIDEBAND;

} else {

bandwidth = OPUS_BANDWIDTH_NARROWBAND + ((data[0]>>5)&0x3);

}

return bandwidth;

}

int opus_packet_get_nb_channels(const unsigned char *data)

{

return (data[0]&0x4) ? 2 : 1;

}

int opus_packet_get_nb_frames(const unsigned char packet[], opus_int32 len)

{

int count;

if (len<1)

return OPUS_BAD_ARG;

count = packet[0]&0x3;