1032 lines
30 KiB
C
1032 lines
30 KiB
C
/* 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
|
|
# include "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"
|
|
#include "cpu_support.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;
|
|
int arch;
|
|
|
|
/* 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));
|
|
/* Initialize SILK decoder */
|
|
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;
|
|
st->arch = opus_select_arch();
|
|
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_silk_size;
|
|
VARDECL(opus_int16, pcm_silk);
|
|
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 bandwidth;
|
|
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;
|
|
int celt_accum;
|
|
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;
|
|
bandwidth = st->bandwidth;
|
|
ec_dec_init(&dec,(unsigned char*)data,len);
|
|
} else {
|
|
audiosize = frame_size;
|
|
mode = st->prev_mode;
|
|
bandwidth = 0;
|
|
|
|
if (mode == 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;
|
|
/* Decide where to allocate the stack memory for pcm_transition */
|
|
if (mode == MODE_CELT_ONLY)
|
|
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 ) {
|
|
if( bandwidth == OPUS_BANDWIDTH_NARROWBAND ) {
|
|
st->DecControl.internalSampleRate = 8000;
|
|
} else if( bandwidth == OPUS_BANDWIDTH_MEDIUMBAND ) {
|
|
st->DecControl.internalSampleRate = 12000;
|
|
} else if( bandwidth == OPUS_BANDWIDTH_WIDEBAND ) {
|
|
st->DecControl.internalSampleRate = 16000;
|
|
} else {
|
|
st->DecControl.internalSampleRate = 16000;
|
|
celt_assert( 0 );
|
|
}
|
|
} 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,
|
|
lost_flag, first_frame, &dec, pcm_ptr, &silk_frame_size, st->arch );
|
|
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;
|
|
return OPUS_INTERNAL_ERROR;
|
|
}
|
|
}
|
|
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;
|
|
|
|
switch(bandwidth)
|
|
{
|
|
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;
|
|
}
|
|
MUST_SUCCEED(celt_decoder_ctl(celt_dec, CELT_SET_END_BAND(endband)));
|
|
}
|
|
MUST_SUCCEED(celt_decoder_ctl(celt_dec, CELT_SET_CHANNELS(st->stream_channels)));
|
|
|
|
/* 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)
|
|
{
|
|
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)));
|
|
}
|
|
|
|
/* MUST be after PLC */
|
|
MUST_SUCCEED(celt_decoder_ctl(celt_dec, CELT_SET_START_BAND(start_band)));
|
|
|
|
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)
|
|
MUST_SUCCEED(celt_decoder_ctl(celt_dec, OPUS_RESET_STATE));
|
|
/* Decode CELT */
|
|
celt_ret = celt_decode_with_ec(celt_dec, decode_fec ? NULL : data,
|
|
len, pcm, celt_frame_size, &dec, celt_accum);
|
|
} 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);
|
|
}
|
|
}
|
|
|
|
if (mode != MODE_CELT_ONLY && !celt_accum)
|
|
{
|
|
#ifdef FIXED_POINT
|
|
for (i=0;i<frame_size*st->channels;i++)
|
|
pcm[i] = SAT16(ADD32(pcm[i], pcm_silk[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;
|
|
MUST_SUCCEED(celt_decoder_ctl(celt_dec, CELT_GET_MODE(&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 (celt_ret>=0)
|
|
{
|
|
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 self_delimited, opus_int32 *packet_offset, int soft_clip)
|
|
{
|
|
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];
|
|
VALIDATE_OPUS_DECODER(st);
|
|
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;
|
|
ret = opus_decode_frame(st, NULL, 0, pcm+pcm_count*st->channels, frame_size-pcm_count, 0);
|
|
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)
|
|
return opus_decode_native(st, NULL, 0, pcm, frame_size, 0, 0, NULL, soft_clip);
|
|
/* 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)
|
|
{
|
|
ret = opus_decode_native(st, NULL, 0, pcm, frame_size-packet_frame_size, 0, 0, NULL, soft_clip);
|
|
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;
|
|
ret = opus_decode_frame(st, data, size[i], pcm+nb_samples*st->channels, frame_size-nb_samples, 0);
|
|
if (ret<0)
|
|
return ret;
|
|
celt_assert(ret==packet_frame_size);
|
|
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;
|
|
int nb_samples;
|
|
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);
|
|
|
|
ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL, 0);
|
|
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;
|
|
int nb_samples;
|
|
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, float);
|
|
|
|
ret = opus_decode_native(st, data, len, out, frame_size, decode_fec, 0, NULL, 1);
|
|
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*);
|
|
if (!value)
|
|
{
|
|
goto bad_arg;
|
|
}
|
|
*value = st->Fs;
|
|
}
|
|
break;
|
|
case OPUS_GET_PITCH_REQUEST:
|
|
{
|
|
opus_int32 *value = va_arg(ap, opus_int32*);
|
|
if (!value)
|
|
{
|
|
goto bad_arg;
|
|
}
|
|
if (st->prev_mode == MODE_CELT_ONLY)
|
|
ret = celt_decoder_ctl(celt_dec, OPUS_GET_PITCH(value));
|
|
else
|
|
*value = st->DecControl.prevPitchLag;
|
|
}
|
|
break;
|
|
case OPUS_GET_GAIN_REQUEST:
|
|
{
|
|
opus_int32 *value = va_arg(ap, opus_int32*);
|
|
if (!value)
|
|
{
|
|
goto bad_arg;
|
|
}
|
|
*value = st->decode_gain;
|
|
}
|
|
break;
|
|
case OPUS_SET_GAIN_REQUEST:
|
|
{
|
|
opus_int32 value = va_arg(ap, opus_int32);
|
|
if (value<-32768 || value>32767)
|
|
{
|
|
goto bad_arg;
|
|
}
|
|
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;
|
|
if (count==0)
|
|
return 1;
|
|
else if (count!=3)
|
|
return 2;
|
|
else if (len<2)
|
|
return OPUS_INVALID_PACKET;
|
|
else
|
|
return packet[1]&0x3F;
|
|
}
|
|
|
|
int opus_packet_get_nb_samples(const unsigned char packet[], opus_int32 len,
|
|
opus_int32 Fs)
|
|
{
|
|
int samples;
|
|
int count = opus_packet_get_nb_frames(packet, len);
|
|
|
|
if (count<0)
|
|
return count;
|
|
|
|
samples = count*opus_packet_get_samples_per_frame(packet, Fs);
|
|
/* Can't have more than 120 ms */
|
|
if (samples*25 > Fs*3)
|
|
return OPUS_INVALID_PACKET;
|
|
else
|
|
return samples;
|
|
}
|
|
|
|
int opus_decoder_get_nb_samples(const OpusDecoder *dec,
|
|
const unsigned char packet[], opus_int32 len)
|
|
{
|
|
return opus_packet_get_nb_samples(packet, len, dec->Fs);
|
|
}
|