AM_UINT CAudioCodecOpus::decode(AM_U8 *input, AM_UINT inDataSize,
AM_U8 *output, AM_UINT *outDataSize)
{
int totalFrames = opus_packet_get_nb_frames(input, inDataSize);
int totalSamples = (totalFrames > 0) ?
totalFrames * opus_packet_get_samples_per_frame(input, 48000) : -1;
AM_UINT ret = (AM_UINT)-1;
if (AM_LIKELY((totalSamples >= 120) && (totalSamples <= 120*48))) {
*outDataSize = 0;
while (totalSamples > 0) {
int decodedSample = opus_decode(mDecoder, (const unsigned char*)input,
(opus_int32)inDataSize,
(((opus_int16*)output) + *outDataSize),
120*48, 0);
if (AM_LIKELY(decodedSample > 0)) {
totalSamples -= decodedSample;
*outDataSize += decodedSample * sizeof(AM_U16) * 2;
} else {
ret = (AM_UINT)-1;
break;
}
}
if (AM_LIKELY(totalSamples == 0)) {
ret = inDataSize;
}
}
return ret;
}
static int opus_repacketizer_cat_impl(OpusRepacketizer *rp, const unsigned char *data, opus_int32 len, int self_delimited)
{
unsigned char tmp_toc;
int curr_nb_frames,ret;
/* Set of check ToC */
if (len<1) return OPUS_INVALID_PACKET;
if (rp->nb_frames == 0)
{
rp->toc = data[0];
rp->framesize = opus_packet_get_samples_per_frame(data, 8000);
} else if ((rp->toc&0xFC) != (data[0]&0xFC))
{
/*fprintf(stderr, "toc mismatch: 0x%x vs 0x%x\n", rp->toc, data[0]);*/
return OPUS_INVALID_PACKET;
}
curr_nb_frames = opus_packet_get_nb_frames(data, len);
if(curr_nb_frames<1) return OPUS_INVALID_PACKET;
/* Check the 120 ms maximum packet size */
if ((curr_nb_frames+rp->nb_frames)*rp->framesize > 960)
{
return OPUS_INVALID_PACKET;
}
ret=opus_packet_parse_impl(data, len, self_delimited, &tmp_toc, &rp->frames[rp->nb_frames], &rp->len[rp->nb_frames], NULL, NULL);
if(ret<1)return ret;
rp->nb_frames += curr_nb_frames;
return OPUS_OK;
}
void AudioOutputSpeech::addFrameToBuffer(const QByteArray &qbaPacket, unsigned int iSeq) {
QMutexLocker lock(&qmJitter);
if (qbaPacket.size() < 2)
return;
PacketDataStream pds(qbaPacket);
// skip flags
pds.next();
int samples = 0;
if (umtType == MessageHandler::UDPVoiceOpus) {
int size;
pds >> size;
size &= 0x1fff;
const QByteArray &qba = pds.dataBlock(size);
const unsigned char *packet = reinterpret_cast<const unsigned char*>(qba.constData());
#ifdef USE_OPUS
int frames = opus_packet_get_nb_frames(packet, size);
samples = frames * opus_packet_get_samples_per_frame(packet, SAMPLE_RATE);
#else
return;
#endif
// We can't handle frames which are not a multiple of 10ms.
Q_ASSERT(samples % iFrameSize == 0);
} else {
/*****************************************************************************
* DecodePacket: decodes a Opus packet.
*****************************************************************************/
static block_t *DecodePacket( decoder_t *p_dec, ogg_packet *p_oggpacket,
int i_nb_samples, int i_end_trim )
{
decoder_sys_t *p_sys = p_dec->p_sys;
if( !p_oggpacket->bytes )
return NULL;
int spp;
spp=opus_packet_get_nb_frames(p_oggpacket->packet,p_oggpacket->bytes);
if(spp>0)spp*=opus_packet_get_samples_per_frame(p_oggpacket->packet,48000);
if(spp<120||spp>120*48)return NULL;
block_t *p_aout_buffer=decoder_NewAudioBuffer( p_dec, spp );
if ( !p_aout_buffer )
{
msg_Err(p_dec, "Oops: No new buffer was returned!");
return NULL;
}
spp=opus_multistream_decode_float(p_sys->p_st, p_oggpacket->packet,
p_oggpacket->bytes, (float *)p_aout_buffer->p_buffer, spp, 0);
if( spp < 0 || i_nb_samples <= 0 || i_end_trim >= i_nb_samples)
{
block_Release(p_aout_buffer);
if( spp < 0 )
msg_Err( p_dec, "Error: corrupted stream?" );
return NULL;
}
p_aout_buffer->i_buffer = (i_nb_samples - i_end_trim) *
p_sys->header.channels * sizeof(float);
if( spp > i_nb_samples )
{
memmove(p_aout_buffer->p_buffer,
p_aout_buffer->p_buffer
+ (spp - i_nb_samples)*p_sys->header.channels*sizeof(float),
(i_nb_samples - i_end_trim)*p_sys->header.channels*sizeof(float));
}
i_nb_samples -= i_end_trim;
#ifndef OPUS_SET_GAIN
if(p_sys->header.gain!=0)
{
float gain = pow(10., p_sys->header.gain/5120.);
float *buf =(float *)p_aout_buffer->p_buffer;
int i;
for( i = 0; i < i_nb_samples*p_sys->header.channels; i++)
buf[i] *= gain;
}
#endif
p_aout_buffer->i_nb_samples = i_nb_samples;
p_aout_buffer->i_pts = date_Get( &p_sys->end_date );
p_aout_buffer->i_length = date_Increment( &p_sys->end_date, i_nb_samples )
- p_aout_buffer->i_pts;
return p_aout_buffer;
}
static void rp_fill_framecell(FrameCell *fc, unsigned char toc, const unsigned char *data, int len)
{
fc->next = NULL;
fc->toc = toc;
fc->size = len;
fc->data = malloc(len);
memcpy(fc->data, data, len);
fc->duration = opus_packet_get_samples_per_frame(&toc, 48000);
}
// Helper method to return the change in granule position due to an Opus packet
// (as distinct from the number of samples in the packet, which depends on the
// decoder rate). It should work with a multistream Opus file, and continue to
// work should we ever allow the decoder to decode at a rate other than 48 kHz.
// It even works before we've created the actual Opus decoder.
static int GetOpusDeltaGP(ogg_packet* packet)
{
int nframes;
nframes = opus_packet_get_nb_frames(packet->packet, packet->bytes);
if (nframes > 0) {
return nframes*opus_packet_get_samples_per_frame(packet->packet, 48000);
}
NS_WARNING("Invalid Opus packet.");
return nframes;
}
int opus_decode_native(OpusDecoder *st, const unsigned char *data,
int len, opus_val16 *pcm, int frame_size, int decode_fec,
int self_delimited, int *packet_offset)
{
int i, nb_samples;
int count, offset;
unsigned char toc;
int tot_offset;
/* 48 x 2.5 ms = 120 ms */
short size[48];
if (decode_fec<0 || decode_fec>1)
return OPUS_BAD_ARG;
if (len==0 || data==NULL)
return opus_decode_frame(st, NULL, 0, pcm, frame_size, 0);
else if (len<0)
return OPUS_BAD_ARG;
tot_offset = 0;
st->mode = opus_packet_get_mode(data);
st->bandwidth = opus_packet_get_bandwidth(data);
st->frame_size = opus_packet_get_samples_per_frame(data, st->Fs);
st->stream_channels = opus_packet_get_nb_channels(data);
count = opus_packet_parse_impl(data, len, self_delimited, &toc, NULL, size, &offset);
if (count < 0)
return count;
data += offset;
tot_offset += offset;
if (count*st->frame_size > frame_size)
return OPUS_BUFFER_TOO_SMALL;
nb_samples=0;
for (i=0;i<count;i++)
{
int ret;
ret = opus_decode_frame(st, data, size[i], pcm, frame_size-nb_samples, decode_fec);
if (ret<0)
return ret;
data += size[i];
tot_offset += size[i];
pcm += ret*st->channels;
nb_samples += ret;
}
if (packet_offset != NULL)
*packet_offset = tot_offset;
return nb_samples;
}
virtual bool Transcode(const void * fromPtr,
unsigned & fromLen,
void * toPtr,
unsigned & toLen,
unsigned & flags)
{
opus_int32 result = opus_encode(m_encoder,
(const opus_int16 *)fromPtr, fromLen/m_channels/2,
(unsigned char *)toPtr, toLen);
if (result < 0) {
PTRACE(1, MY_CODEC_LOG, "Encoder error " << result << ' ' << opus_strerror(result));
return false;
}
toLen = result;
fromLen = opus_packet_get_samples_per_frame((const unsigned char *)toPtr, m_sampleRate) *
opus_packet_get_nb_frames((const unsigned char *)toPtr, toLen) * m_channels * 2;
return true;
}
static pj_status_t opus_codec_parse(pjmedia_codec *codec, void *pkt,
pj_size_t pkt_size, const pj_timestamp *ts,
unsigned *frame_cnt,
pjmedia_frame frames[]) {
struct opus_private *opus;
unsigned char toc;
const unsigned char *raw_frames[48];
short size[48];
int payload_offset, samples_per_frame;
unsigned i;
PJ_ASSERT_RETURN(frame_cnt, PJ_EINVAL);
opus = (struct opus_private *)codec->codec_data;
*frame_cnt =
opus_packet_parse(pkt, pkt_size, &toc, raw_frames, size, &payload_offset);
samples_per_frame = opus_packet_get_samples_per_frame(pkt, opus->externalFs);
#if _TRACE_OPUS
PJ_LOG(4, (THIS_FILE,
"Pkt info : bw -> %d , spf -> %d, offset %d, packet_size %d",
opus_packet_get_bandwidth(pkt), samples_per_frame, payload_offset,
pkt_size));
#endif
for (i = 0; i < *frame_cnt; i++) {
frames[i].type = PJMEDIA_FRAME_TYPE_AUDIO;
frames[i].bit_info = (((unsigned)ts->u64 & 0xFFFF) << 16) |
(((unsigned)pkt & 0xFF) << 8) | i;
frames[i].buf = pkt;
frames[i].size = pkt_size;
frames[i].timestamp.u64 =
ts->u64 * opus->externalFs / OPUS_CLOCK_RATE + i * samples_per_frame;
#if _TRACE_OPUS
PJ_LOG(4, (THIS_FILE, "parsed %d of %d", frames[i].size, *frame_cnt));
#endif
}
return PJ_SUCCESS;
}
int WebRtcOpus_DurationEst(OpusDecInst* inst,
const uint8_t* payload,
int payload_length_bytes)
{
int frames, samples;
frames = opus_packet_get_nb_frames(payload, payload_length_bytes);
if (frames < 0) {
/* Invalid payload data. */
return 0;
}
samples = frames * opus_packet_get_samples_per_frame(payload, 48000);
if (samples < 120 || samples > 5760) {
/* Invalid payload duration. */
return 0;
}
/* Compensate for the down-sampling from 48 kHz to 32 kHz.
* This should be removed when the resampling in WebRtcOpus_Decode is
* removed. */
samples = samples * 2 / 3;
return samples;
}
int opus_packet_parse_impl(const unsigned char *data, opus_int32 len,
int self_delimited, unsigned char *out_toc,
const unsigned char *frames[48], opus_int16 size[48],
int *payload_offset, opus_int32 *packet_offset) {
int i, bytes;
int count;
int cbr;
unsigned char ch, toc;
int framesize;
opus_int32 last_size;
opus_int32 pad = 0;
const unsigned char *data0 = data;
if (size == NULL)
return OPUS_BAD_ARG;
framesize = opus_packet_get_samples_per_frame(data, 48000);
cbr = 0;
toc = *data++;
len--;
last_size = len;
switch (toc & 0x3) {
/* One frame */
case 0:
count = 1;
break;
/* Two CBR frames */
case 1:
count = 2;
cbr = 1;
if (!self_delimited) {
if (len & 0x1)
return OPUS_INVALID_PACKET;
last_size = len / 2;
/* If last_size doesn't fit in size[0], we'll catch it later */
size[0] = (opus_int16) last_size;
}
break;
/* Two VBR frames */
case 2:
count = 2;
bytes = parse_size(data, len, size);
len -= bytes;
if (size[0] < 0 || size[0] > len)
return OPUS_INVALID_PACKET;
data += bytes;
last_size = len - size[0];
break;
/* Multiple CBR/VBR frames (from 0 to 120 ms) */
default: /*case 3:*/
if (len < 1)
return OPUS_INVALID_PACKET;
/* Number of frames encoded in bits 0 to 5 */
ch = *data++;
count = ch & 0x3F;
if (count <= 0 || framesize * count > 5760)
return OPUS_INVALID_PACKET;
len--;
/* Padding flag is bit 6 */
if (ch & 0x40) {
int p;
do {
int tmp;
if (len <= 0)
return OPUS_INVALID_PACKET;
p = *data++;
len--;
tmp = p == 255 ? 254 : p;
len -= tmp;
pad += tmp;
} while (p == 255);
}
if (len < 0)
return OPUS_INVALID_PACKET;
/* VBR flag is bit 7 */
cbr = !(ch & 0x80);
if (!cbr) {
/* VBR case */
last_size = len;
for (i = 0; i < count - 1; i++) {
bytes = parse_size(data, len, size + i);
len -= bytes;
if (size[i] < 0 || size[i] > len)
return OPUS_INVALID_PACKET;
data += bytes;
last_size -= bytes + size[i];
}
if (last_size < 0)
return OPUS_INVALID_PACKET;
} else if (!self_delimited) {
/* CBR case */
last_size = len / count;
if (last_size * count != len)
return OPUS_INVALID_PACKET;
for (i = 0; i < count - 1; i++)
size[i] = (opus_int16) last_size;
}
break;
}
/* Self-delimited framing has an extra size for the last frame. */
if (self_delimited) {
bytes = parse_size(data, len, size + count - 1);
len -= bytes;
if (size[count - 1] < 0 || size[count - 1] > len)
return OPUS_INVALID_PACKET;
data += bytes;
/* For CBR packets, apply the size to all the frames. */
if (cbr) {
if (size[count - 1] * count > len)
return OPUS_INVALID_PACKET;
for (i = 0; i < count - 1; i++)
size[i] = size[count - 1];
} else if (bytes + size[count - 1] > last_size)
return OPUS_INVALID_PACKET;
} else {
/* Because it's not encoded explicitly, it's possible the size of the
last packet (or all the packets, for the CBR case) is larger than
1275. Reject them here.*/
if (last_size > 1275)
return OPUS_INVALID_PACKET;
size[count - 1] = (opus_int16) last_size;
}
if (payload_offset)
*payload_offset = (int) (data - data0);
for (i = 0; i < count; i++) {
if (frames)
frames[i] = data;
data += size[i];
}
if (packet_offset)
*packet_offset = pad + (opus_int32)(data - data0);
if (out_toc)
*out_toc = toc;
return count;
}
static pj_status_t opus_codec_decode(pjmedia_codec *codec,
const struct pjmedia_frame *input,
unsigned output_buf_len,
struct pjmedia_frame *output) {
int ret = 0;
struct opus_private *opus;
int frm_cnt, out_size;
unsigned pkt_info, frm_info;
PJ_ASSERT_RETURN(codec && input && output_buf_len && output, PJ_EINVAL);
opus = (struct opus_private *)codec->codec_data;
frm_cnt = opus_packet_get_nb_frames(input->buf, input->size);
pkt_info = input->bit_info & 0xFFFFFF00;
frm_info = input->bit_info & 0xF;
if (opus->pkt_info != pkt_info || input->bit_info == 0) {
opus->pkt_info = pkt_info;
opus->dec_buf_sample_per_frame =
opus_packet_get_samples_per_frame(input->buf, opus->externalFs);
/* We need to decode all the frames in the packet. */
opus->dec_buf_size = opus_decode(
opus->psDec, (const unsigned char *)input->buf, (opus_int32)input->size,
opus->dec_buf, opus->dec_buf_max_size, 0 /* decode FEC */);
if (opus->dec_buf_size <= 0) {
PJ_LOG(3, (THIS_FILE, "Failed to decode frame (err=%d)",
opus->dec_buf_size));
opus->dec_buf_size = 0;
} else {
opus->dec_buf_size = opus->dec_buf_size * opus->pcm_bytes_per_sample;
}
}
/* We have this packet decoded now (either was previously in the buffer or was
* just added to buffer). */
if (opus->dec_buf_size == 0) {
/* The decoding was a failure. */
output->size = 0;
} else {
unsigned frm_size =
opus->dec_buf_sample_per_frame * opus->pcm_bytes_per_sample;
#if _TRACE_OPUS
PJ_LOG(4, (THIS_FILE, "Decode : copy from big buffer %d to %d",
output_buf_len, frm_size));
#endif
if (output_buf_len < frm_size) {
return PJ_ETOOSMALL;
}
/* Copy the decoded frame from the buffer. */
pj_memcpy(output->buf,
((opus_int16 *)opus->dec_buf) + (frm_info * frm_size), frm_size);
output->size = frm_size;
}
if (output->size == 0) {
output->type = PJMEDIA_TYPE_NONE;
output->buf = NULL;
return PJMEDIA_CODEC_EFAILED;
}
output->type = PJMEDIA_TYPE_AUDIO;
output->timestamp = input->timestamp;
#if _TRACE_OPUS
PJ_LOG(4, (THIS_FILE, "Decoded %d to %d with max %d", input->size,
output->size, output_buf_len));
#endif
return PJ_SUCCESS;
}
static GstFlowReturn
opus_dec_chain_parse_data (GstOpusDec * dec, GstBuffer * buf,
GstClockTime timestamp, GstClockTime duration)
{
GstFlowReturn res = GST_FLOW_OK;
gint size;
guint8 *data;
GstBuffer *outbuf;
gint16 *out_data;
int n;
if (timestamp != -1) {
dec->segment.last_stop = timestamp;
dec->granulepos = -1;
}
if (dec->state == NULL) {
GstCaps *caps;
dec->state = opus_decoder_create (dec->sample_rate, dec->n_channels);
/* set caps */
caps = gst_caps_new_simple ("audio/x-raw-int",
"rate", G_TYPE_INT, dec->sample_rate,
"channels", G_TYPE_INT, dec->n_channels,
"signed", G_TYPE_BOOLEAN, TRUE,
"endianness", G_TYPE_INT, G_BYTE_ORDER,
"width", G_TYPE_INT, 16, "depth", G_TYPE_INT, 16, NULL);
GST_DEBUG_OBJECT (dec, "rate=%d channels=%d frame-size=%d",
dec->sample_rate, dec->n_channels, dec->frame_size);
if (!gst_pad_set_caps (dec->srcpad, caps))
GST_ERROR ("nego failure");
gst_caps_unref (caps);
}
if (buf) {
data = GST_BUFFER_DATA (buf);
size = GST_BUFFER_SIZE (buf);
GST_DEBUG_OBJECT (dec, "received buffer of size %u", size);
/* copy timestamp */
} else {
/* concealment data, pass NULL as the bits parameters */
GST_DEBUG_OBJECT (dec, "creating concealment data");
data = NULL;
size = 0;
}
GST_DEBUG ("bandwidth %d", opus_packet_get_bandwidth (data));
GST_DEBUG ("samples_per_frame %d", opus_packet_get_samples_per_frame (data,
48000));
GST_DEBUG ("channels %d", opus_packet_get_nb_channels (data));
res = gst_pad_alloc_buffer_and_set_caps (dec->srcpad,
GST_BUFFER_OFFSET_NONE, dec->frame_samples * dec->n_channels * 2,
GST_PAD_CAPS (dec->srcpad), &outbuf);
if (res != GST_FLOW_OK) {
GST_DEBUG_OBJECT (dec, "buf alloc flow: %s", gst_flow_get_name (res));
return res;
}
out_data = (gint16 *) GST_BUFFER_DATA (outbuf);
GST_LOG_OBJECT (dec, "decoding frame");
n = opus_decode (dec->state, data, size, out_data, dec->frame_samples, TRUE);
if (n < 0) {
GST_ELEMENT_ERROR (dec, STREAM, DECODE, ("Decoding error: %d", n), (NULL));
return GST_FLOW_ERROR;
}
if (!GST_CLOCK_TIME_IS_VALID (timestamp)) {
timestamp = gst_util_uint64_scale_int (dec->granulepos - dec->frame_size,
GST_SECOND, dec->sample_rate);
}
GST_DEBUG_OBJECT (dec, "timestamp=%" GST_TIME_FORMAT,
GST_TIME_ARGS (timestamp));
GST_BUFFER_TIMESTAMP (outbuf) = GST_BUFFER_TIMESTAMP (buf);
GST_BUFFER_DURATION (outbuf) = GST_BUFFER_DURATION (buf);
if (dec->discont) {
GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_DISCONT);
dec->discont = 0;
}
dec->segment.last_stop += dec->frame_duration;
GST_LOG_OBJECT (dec, "pushing buffer with ts=%" GST_TIME_FORMAT ", dur=%"
GST_TIME_FORMAT, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (outbuf)),
GST_TIME_ARGS (dec->frame_duration));
res = gst_pad_push (dec->srcpad, outbuf);
if (res != GST_FLOW_OK)
GST_DEBUG_OBJECT (dec, "flow: %s", gst_flow_get_name (res));
return res;
}
int rp_load_packet(Repacketizer *st, const unsigned char *data, int len)
{
int i, bytes, nb_samples;
int count;
unsigned char ch, toc;
int multimode=0;
int frame_size;
/* 48 x 2.5 ms = 120 ms */
short size[48];
if (len==0 || data==NULL)
return OPUS_CORRUPTED_DATA; /* FIXME: handle lost packets */
else if (len<0)
return OPUS_BAD_ARG;
frame_size = opus_packet_get_samples_per_frame(data, 48000);
toc = *data++;
len--;
switch (toc&0x3)
{
/* One frame */
case 0:
count=1;
size[0] = len;
break;
/* Two CBR frames */
case 1:
count=2;
if (len&0x1)
return OPUS_CORRUPTED_DATA;
size[0] = size[1] = len/2;
break;
/* Two VBR frames */
case 2:
count = 2;
bytes = parse_size(data, len, size);
len -= bytes;
if (size[0]<0 || size[0] > len)
return OPUS_CORRUPTED_DATA;
data += bytes;
size[1] = len-size[0];
break;
/* Multiple CBR/VBR frames (from 0 to 120 ms) */
case 3:
if (len<1)
return OPUS_CORRUPTED_DATA;
/* Number of frames encoded in bits 0 to 5 */
ch = *data++;
if (ch == 49) /* 49 is a reserved value indicating multimode */
{
multimode = 1;
len--;
ch = *data++; /* In multimode the next byte is the real ch */
}
count = ch&0x3F;
if (count <= 0 || (!multimode && frame_size*count*25 > 3*48000))
return OPUS_CORRUPTED_DATA;
len--;
/* Padding flag is bit 6 */
if (ch&0x40)
{
int padding=0;
int p;
do {
if (len<=0)
return OPUS_CORRUPTED_DATA;
p = *data++;
len--;
padding += p==255 ? 254: p;
} while (p==255);
len -= padding;
}
/* Account for the extra count-1 TOC bytes in multimode */
if (multimode)
len -= count-1;
if (len<0)
return OPUS_CORRUPTED_DATA;
/* VBR flag is bit 7 */
if (ch&0x80)
{
/* VBR case */
int last_size=len;
for (i=0;i<count-1;i++)
{
bytes = parse_size(data, len, size+i);
len -= bytes;
if (size[i]<0 || size[i] > len)
return OPUS_CORRUPTED_DATA;
data += bytes;
last_size -= bytes+size[i];
}
if (last_size<0)
return OPUS_CORRUPTED_DATA;
size[count-1]=last_size;
} else {
/* CBR case */
int sz = len/count;
if (sz*count!=len)
return OPUS_CORRUPTED_DATA;
for (i=0;i<count;i++)
size[i] = sz;
}
break;
}
/* Because it's not encoded explicitly, it's possible the size of the
last packet (or all the packets, for the CBR case) is larger than
1275.
Reject them here.*/
if (size[count-1] > MAX_PACKET)
return OPUS_CORRUPTED_DATA;
nb_samples=0;
for (i=0;i<count;i++)
{
int ret;
/* Multimode only affects the second and subsequent frames */
if (multimode && i > 0)
{
if (*data&0x3 != 0) /* Subpackets in multimode must have Code 0 */
return OPUS_CORRUPTED_DATA;
/* Add 1 byte to size, to account for the TOC byte */
ret = rp_load_packet(st, data, size[i]+1);
/* Move the pointer past the TOC byte */
data++;
} else
{
ret = rp_load_frame(st, toc, data, size[i]);
}
if (ret<0)
return ret;
data += size[i];
nb_samples += ret;
}
return nb_samples;
}
static GstFlowReturn
opus_dec_chain_parse_header (GstOpusDec * dec, GstBuffer * buf)
{
GstCaps *caps;
//gint error = OPUS_OK;
#if 0
dec->samples_per_frame = opus_packet_get_samples_per_frame (
(const unsigned char *) GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
#endif
#if 0
if (memcmp (dec->header.codec_id, "OPUS ", 8) != 0)
goto invalid_header;
#endif
#if 0
#ifdef HAVE_OPUS_0_7
dec->mode =
opus_mode_create (dec->sample_rate, dec->header.frame_size, &error);
#else
dec->mode =
opus_mode_create (dec->sample_rate, dec->header.nb_channels,
dec->header.frame_size, &error);
#endif
if (!dec->mode)
goto mode_init_failed;
/* initialize the decoder */
#ifdef HAVE_OPUS_0_11
dec->state =
opus_decoder_create_custom (dec->mode, dec->header.nb_channels, &error);
#else
#ifdef HAVE_OPUS_0_7
dec->state = opus_decoder_create (dec->mode, dec->header.nb_channels, &error);
#else
dec->state = opus_decoder_create (dec->mode);
#endif
#endif
#endif
dec->state = opus_decoder_create (dec->sample_rate, dec->n_channels);
if (!dec->state)
goto init_failed;
#if 0
#ifdef HAVE_OPUS_0_8
dec->frame_size = dec->header.frame_size;
#else
opus_mode_info (dec->mode, OPUS_GET_FRAME_SIZE, &dec->frame_size);
#endif
#endif
dec->frame_duration = gst_util_uint64_scale_int (dec->frame_size,
GST_SECOND, dec->sample_rate);
/* set caps */
caps = gst_caps_new_simple ("audio/x-raw-int",
"rate", G_TYPE_INT, dec->sample_rate,
"channels", G_TYPE_INT, dec->n_channels,
"signed", G_TYPE_BOOLEAN, TRUE,
"endianness", G_TYPE_INT, G_BYTE_ORDER,
"width", G_TYPE_INT, 16, "depth", G_TYPE_INT, 16, NULL);
GST_DEBUG_OBJECT (dec, "rate=%d channels=%d frame-size=%d",
dec->sample_rate, dec->n_channels, dec->frame_size);
if (!gst_pad_set_caps (dec->srcpad, caps))
goto nego_failed;
gst_caps_unref (caps);
return GST_FLOW_OK;
/* ERRORS */
#if 0
invalid_header:
{
GST_ELEMENT_ERROR (GST_ELEMENT (dec), STREAM, DECODE,
(NULL), ("Invalid header"));
return GST_FLOW_ERROR;
}
mode_init_failed:
{
GST_ELEMENT_ERROR (GST_ELEMENT (dec), STREAM, DECODE,
(NULL), ("Mode initialization failed: %d", error));
return GST_FLOW_ERROR;
}
#endif
init_failed:
{
GST_ELEMENT_ERROR (GST_ELEMENT (dec), STREAM, DECODE,
(NULL), ("couldn't initialize decoder"));
return GST_FLOW_ERROR;
}
nego_failed:
{
GST_ELEMENT_ERROR (GST_ELEMENT (dec), STREAM, DECODE,
(NULL), ("couldn't negotiate format"));
gst_caps_unref (caps);
return GST_FLOW_NOT_NEGOTIATED;
}
}
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];
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;
}
int main(int argc, char **argv)
{
int c;
int option_index = 0;
char *inFile, *outFile;
FILE *fin, *fout=NULL, *frange=NULL;
float *output;
int frame_size=0;
OpusMSDecoder *st=NULL;
opus_int64 packet_count=0;
int total_links=0;
int stream_init = 0;
int quiet = 0;
ogg_int64_t page_granule=0;
ogg_int64_t link_out=0;
struct option long_options[] =
{
{"help", no_argument, NULL, 0},
{"quiet", no_argument, NULL, 0},
{"version", no_argument, NULL, 0},
{"version-short", no_argument, NULL, 0},
{"rate", required_argument, NULL, 0},
{"gain", required_argument, NULL, 0},
{"no-dither", no_argument, NULL, 0},
{"packet-loss", required_argument, NULL, 0},
{"save-range", required_argument, NULL, 0},
{0, 0, 0, 0}
};
ogg_sync_state oy;
ogg_page og;
ogg_packet op;
ogg_stream_state os;
int close_in=0;
int eos=0;
ogg_int64_t audio_size=0;
double last_coded_seconds=0;
float loss_percent=-1;
float manual_gain=0;
int channels=-1;
int mapping_family;
int rate=0;
int wav_format=0;
int preskip=0;
int gran_offset=0;
int has_opus_stream=0;
ogg_int32_t opus_serialno;
int dither=1;
shapestate shapemem;
SpeexResamplerState *resampler=NULL;
float gain=1;
int streams=0;
size_t last_spin=0;
#ifdef WIN_UNICODE
int argc_utf8;
char **argv_utf8;
#endif
if(query_cpu_support()){
fprintf(stderr,"\n\n** WARNING: This program with compiled with SSE%s\n",query_cpu_support()>1?"2":"");
fprintf(stderr," but this CPU claims to lack these instructions. **\n\n");
}
#ifdef WIN_UNICODE
(void)argc;
(void)argv;
init_console_utf8();
init_commandline_arguments_utf8(&argc_utf8, &argv_utf8);
#endif
output=0;
shapemem.a_buf=0;
shapemem.b_buf=0;
shapemem.mute=960;
shapemem.fs=0;
/*Process options*/
while(1)
{
c = getopt_long (argc_utf8, argv_utf8, "hV",
long_options, &option_index);
if (c==-1)
break;
switch(c)
{
case 0:
if (strcmp(long_options[option_index].name,"help")==0)
{
usage();
quit(0);
} else if (strcmp(long_options[option_index].name,"quiet")==0)
{
quiet = 1;
} else if (strcmp(long_options[option_index].name,"version")==0)
{
version();
quit(0);
} else if (strcmp(long_options[option_index].name,"version-short")==0)
{
version_short();
quit(0);
} else if (strcmp(long_options[option_index].name,"no-dither")==0)
{
dither=0;
} else if (strcmp(long_options[option_index].name,"rate")==0)
{
rate=atoi (optarg);
} else if (strcmp(long_options[option_index].name,"gain")==0)
{
manual_gain=atof (optarg);
}else if(strcmp(long_options[option_index].name,"save-range")==0){
frange=fopen_utf8(optarg,"w");
if(frange==NULL){
perror(optarg);
fprintf(stderr,"Could not open save-range file: %s\n",optarg);
fprintf(stderr,"Must provide a writable file name.\n");
quit(1);
}
} else if (strcmp(long_options[option_index].name,"packet-loss")==0)
{
loss_percent = atof(optarg);
}
break;
case 'h':
usage();
quit(0);
break;
case 'V':
version();
quit(0);
break;
case '?':
usage();
quit(1);
break;
}
}
if (argc_utf8-optind!=2 && argc_utf8-optind!=1)
{
usage();
quit(1);
}
inFile=argv_utf8[optind];
/*Output to a file or playback?*/
if (argc_utf8-optind==2){
/*If we're outputting to a file, should we apply a wav header?*/
int i;
char *ext;
outFile=argv_utf8[optind+1];
ext=".wav";
i=strlen(outFile)-4;
wav_format=i>=0;
while(wav_format&&ext&&outFile[i]) {
wav_format&=tolower(outFile[i++])==*ext++;
}
}else {
outFile="";
wav_format=0;
/*If playing to audio out, default the rate to 48000
instead of the original rate. The original rate is
only important for minimizing surprise about the rate
of output files and preserving length, which aren't
relevant for playback. Many audio devices sound
better at 48kHz and not resampling also saves CPU.*/
if(rate==0)rate=48000;
}
/*Open input file*/
if (strcmp(inFile, "-")==0)
{
#if defined WIN32 || defined _WIN32
_setmode(_fileno(stdin), _O_BINARY);
#endif
fin=stdin;
}
else
{
fin = fopen_utf8(inFile, "rb");
if (!fin)
{
perror(inFile);
quit(1);
}
close_in=1;
}
/* .opus files use the Ogg container to provide framing and timekeeping.
* http://tools.ietf.org/html/draft-terriberry-oggopus
* The easiest way to decode the Ogg container is to use libogg, so
* thats what we do here.
* Using libogg is fairly straight forward-- you take your stream of bytes
* and feed them to ogg_sync_ and it periodically returns Ogg pages, you
* check if the pages belong to the stream you're decoding then you give
* them to libogg and it gives you packets. You decode the packets. The
* pages also provide timing information.*/
ogg_sync_init(&oy);
/*Main decoding loop*/
while (1)
{
char *data;
int i, nb_read;
/*Get the ogg buffer for writing*/
data = ogg_sync_buffer(&oy, 200);
/*Read bitstream from input file*/
nb_read = fread(data, sizeof(char), 200, fin);
ogg_sync_wrote(&oy, nb_read);
/*Loop for all complete pages we got (most likely only one)*/
while (ogg_sync_pageout(&oy, &og)==1)
{
if (stream_init == 0) {
ogg_stream_init(&os, ogg_page_serialno(&og));
stream_init = 1;
}
if (ogg_page_serialno(&og) != os.serialno) {
/* so all streams are read. */
ogg_stream_reset_serialno(&os, ogg_page_serialno(&og));
}
/*Add page to the bitstream*/
ogg_stream_pagein(&os, &og);
page_granule = ogg_page_granulepos(&og);
/*Extract all available packets*/
while (ogg_stream_packetout(&os, &op) == 1)
{
/*OggOpus streams are identified by a magic string in the initial
stream header.*/
if (op.b_o_s && op.bytes>=8 && !memcmp(op.packet, "OpusHead", 8)) {
if(!has_opus_stream)
{
opus_serialno = os.serialno;
has_opus_stream = 1;
link_out = 0;
packet_count = 0;
eos = 0;
total_links++;
} else {
fprintf(stderr,"Warning: ignoring opus stream %" I64FORMAT "\n",(long long)os.serialno);
}
}
if (!has_opus_stream || os.serialno != opus_serialno)
break;
/*If first packet in a logical stream, process the Opus header*/
if (packet_count==0)
{
st = process_header(&op, &rate, &mapping_family, &channels, &preskip, &gain, manual_gain, &streams, wav_format, quiet);
if (!st)
quit(1);
/*Remember how many samples at the front we were told to skip
so that we can adjust the timestamp counting.*/
gran_offset=preskip;
/*Setup the memory for the dithered output*/
if(!shapemem.a_buf)
{
shapemem.a_buf=calloc(channels,sizeof(float)*4);
shapemem.b_buf=calloc(channels,sizeof(float)*4);
shapemem.fs=rate;
}
if(!output)output=malloc(sizeof(float)*MAX_FRAME_SIZE*channels);
/*Normal players should just play at 48000 or their maximum rate,
as described in the OggOpus spec. But for commandline tools
like opusdec it can be desirable to exactly preserve the original
sampling rate and duration, so we have a resampler here.*/
if (rate != 48000)
{
int err;
resampler = speex_resampler_init(channels, 48000, rate, 5, &err);
if (err!=0)
fprintf(stderr, "resampler error: %s\n", speex_resampler_strerror(err));
speex_resampler_skip_zeros(resampler);
}
if(!fout)fout=out_file_open(outFile, &wav_format, rate, mapping_family, &channels);
} else if (packet_count==1)
{
if (!quiet)
print_comments((char*)op.packet, op.bytes);
} else {
int ret;
opus_int64 maxout;
opus_int64 outsamp;
int lost=0;
if (loss_percent>0 && 100*((float)rand())/RAND_MAX<loss_percent)
lost=1;
/*End of stream condition*/
if (op.e_o_s && os.serialno == opus_serialno)eos=1; /* don't care for anything except opus eos */
/*Are we simulating loss for this packet?*/
if (!lost){
/*Decode Opus packet*/
ret = opus_multistream_decode_float(st, (unsigned char*)op.packet, op.bytes, output, MAX_FRAME_SIZE, 0);
} else {
/*Extract the original duration.
Normally you wouldn't have it for a lost packet, but normally the
transports used on lossy channels will effectively tell you.
This avoids opusdec squaking when the decoded samples and
granpos mismatches.*/
opus_int32 lost_size;
lost_size = MAX_FRAME_SIZE;
if(op.bytes>0){
opus_int32 spp;
spp=opus_packet_get_nb_frames(op.packet,op.bytes);
if(spp>0){
spp*=opus_packet_get_samples_per_frame(op.packet,48000/*decoding_rate*/);
if(spp>0)lost_size=spp;
}
}
/*Invoke packet loss concealment.*/
ret = opus_multistream_decode_float(st, NULL, 0, output, lost_size, 0);
}
if(!quiet){
/*Display a progress spinner while decoding.*/
static const char spinner[]="|/-\\";
double coded_seconds = (double)audio_size/(channels*rate*sizeof(short));
if(coded_seconds>=last_coded_seconds+1){
fprintf(stderr,"\r[%c] %02d:%02d:%02d", spinner[last_spin&3],
(int)(coded_seconds/3600),(int)(coded_seconds/60)%60,
(int)(coded_seconds)%60);
fflush(stderr);
last_spin++;
last_coded_seconds=coded_seconds;
}
}
/*If the decoder returned less than zero, we have an error.*/
if (ret<0)
{
fprintf (stderr, "Decoding error: %s\n", opus_strerror(ret));
break;
}
frame_size = ret;
/*If we're collecting --save-range debugging data, collect it now.*/
if(frange!=NULL){
OpusDecoder *od;
opus_uint32 rngs[256];
for(i=0;i<streams;i++){
ret=opus_multistream_decoder_ctl(st,OPUS_MULTISTREAM_GET_DECODER_STATE(i,&od));
ret=opus_decoder_ctl(od,OPUS_GET_FINAL_RANGE(&rngs[i]));
}
save_range(frange,frame_size*(48000/48000/*decoding_rate*/),op.packet,op.bytes,
rngs,streams);
}
/*Apply header gain, if we're not using an opus library new
enough to do this internally.*/
if (gain!=0){
for (i=0;i<frame_size*channels;i++)
output[i] *= gain;
}
/*This handles making sure that our output duration respects
the final end-trim by not letting the output sample count
get ahead of the granpos indicated value.*/
maxout=((page_granule-gran_offset)*rate/48000)-link_out;
outsamp=audio_write(output, channels, frame_size, fout, resampler, &preskip, dither?&shapemem:0, strlen(outFile)!=0,0>maxout?0:maxout);
link_out+=outsamp;
audio_size+=sizeof(short)*outsamp*channels;
}
packet_count++;
}
/*We're done, drain the resampler if we were using it.*/
if(eos && resampler)
{
float *zeros;
int drain;
zeros=(float *)calloc(100*channels,sizeof(float));
drain = speex_resampler_get_input_latency(resampler);
do {
opus_int64 outsamp;
int tmp = drain;
if (tmp > 100)
tmp = 100;
outsamp=audio_write(zeros, channels, tmp, fout, resampler, NULL, &shapemem, strlen(outFile)!=0, ((page_granule-gran_offset)*rate/48000)-link_out);
link_out+=outsamp;
audio_size+=sizeof(short)*outsamp*channels;
drain -= tmp;
} while (drain>0);
free(zeros);
speex_resampler_destroy(resampler);
resampler=NULL;
}
if(eos)
{
has_opus_stream=0;
if(st)opus_multistream_decoder_destroy(st);
st=NULL;
}
}
if (feof(fin)) {
if(!quiet) {
fprintf(stderr, "\rDecoding complete. \n");
fflush(stderr);
}
break;
}
}
/*If we were writing wav, go set the duration.*/
if (strlen(outFile)!=0 && fout && wav_format>=0 && audio_size<0x7FFFFFFF)
{
if (fseek(fout,4,SEEK_SET)==0)
{
int tmp;
tmp = le_int(audio_size+20+wav_format);
if(fwrite(&tmp,4,1,fout)!=1)fprintf(stderr,"Error writing end length.\n");
if (fseek(fout,16+wav_format,SEEK_CUR)==0)
{
tmp = le_int(audio_size);
if(fwrite(&tmp,4,1,fout)!=1)fprintf(stderr,"Error writing header length.\n");
} else
{
fprintf (stderr, "First seek worked, second didn't\n");
}
} else {
fprintf (stderr, "Cannot seek on wave file, size will be incorrect\n");
}
}
/*Did we make it to the end without recovering ANY opus logical streams?*/
if(!total_links)fprintf (stderr, "This doesn't look like a Opus file\n");
if (stream_init)
ogg_stream_clear(&os);
ogg_sync_clear(&oy);
#if defined WIN32 || defined _WIN32
if (strlen(outFile)==0)
WIN_Audio_close ();
#endif
if(shapemem.a_buf)free(shapemem.a_buf);
if(shapemem.b_buf)free(shapemem.b_buf);
if(output)free(output);
if(frange)fclose(frange);
if (close_in)
fclose(fin);
if (fout != NULL)
fclose(fout);
#ifdef WIN_UNICODE
free_commandline_arguments_utf8(&argc_utf8, &argv_utf8);
uninit_console_utf8();
#endif
return 0;
}
/**
* Output debug information regarding the state of a single Opus packet
*/
void DebugFrameInfoInternal(const uint8* PacketData, uint32 PacketLength, uint32 SampleRate, bool bEncode)
{
int32 NumFrames = opus_packet_get_nb_frames(PacketData, PacketLength);
if (NumFrames == OPUS_BAD_ARG || NumFrames == OPUS_INVALID_PACKET)
{
UE_LOG(LogVoice, Warning, TEXT("opus_packet_get_nb_frames: Invalid voice packet data!"));
}
int32 NumSamples = opus_packet_get_nb_samples(PacketData, PacketLength, SampleRate);
if (NumSamples == OPUS_BAD_ARG || NumSamples == OPUS_INVALID_PACKET)
{
UE_LOG(LogVoice, Warning, TEXT("opus_packet_get_nb_samples: Invalid voice packet data!"));
}
int32 NumSamplesPerFrame = opus_packet_get_samples_per_frame(PacketData, SampleRate);
int32 Bandwidth = opus_packet_get_bandwidth(PacketData);
const TCHAR* BandwidthStr = NULL;
switch (Bandwidth)
{
case OPUS_BANDWIDTH_NARROWBAND: // Narrowband (4kHz bandpass)
BandwidthStr = TEXT("NB");
break;
case OPUS_BANDWIDTH_MEDIUMBAND: // Mediumband (6kHz bandpass)
BandwidthStr = TEXT("MB");
break;
case OPUS_BANDWIDTH_WIDEBAND: // Wideband (8kHz bandpass)
BandwidthStr = TEXT("WB");
break;
case OPUS_BANDWIDTH_SUPERWIDEBAND: // Superwideband (12kHz bandpass)
BandwidthStr = TEXT("SWB");
break;
case OPUS_BANDWIDTH_FULLBAND: // Fullband (20kHz bandpass)
BandwidthStr = TEXT("FB");
break;
case OPUS_INVALID_PACKET:
default:
BandwidthStr = TEXT("Invalid");
break;
}
/*
* 0
* 0 1 2 3 4 5 6 7
* +-+-+-+-+-+-+-+-+
* | config |s| c |
* +-+-+-+-+-+-+-+-+
*/
uint8 TOC;
// (max 48 x 2.5ms frames in a packet = 120ms)
const uint8* frames[48];
int16 size[48];
int32 payload_offset = 0;
int32 NumFramesParsed = opus_packet_parse(PacketData, PacketLength, &TOC, frames, size, &payload_offset);
// Frame Encoding see http://tools.ietf.org/html/rfc6716#section-3.1
int32 TOCEncoding = (TOC & 0xf8) >> 3;
// Number of channels
bool TOCStereo = (TOC & 0x4) != 0 ? true : false;
// Number of frames and their configuration
// 0: 1 frame in the packet
// 1: 2 frames in the packet, each with equal compressed size
// 2: 2 frames in the packet, with different compressed sizes
// 3: an arbitrary number of frames in the packet
int32 TOCMode = TOC & 0x3;
if (bEncode)
{
UE_LOG(LogVoiceEncode, Verbose, TEXT("PacketLength: %d NumFrames: %d NumSamples: %d Bandwidth: %s Encoding: %d Stereo: %d FrameDesc: %d"),
PacketLength, NumFrames, NumSamples, BandwidthStr, TOCEncoding, TOCStereo, TOCMode);
}
else
{
UE_LOG(LogVoiceDecode, Verbose, TEXT("PacketLength: %d NumFrames: %d NumSamples: %d Bandwidth: %s Encoding: %d Stereo: %d FrameDesc: %d"),
PacketLength, NumFrames, NumSamples, BandwidthStr, TOCEncoding, TOCStereo, TOCMode);
}
}
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, int *packet_offset)
{
int i, nb_samples;
int count, offset;
unsigned char toc;
int tot_offset;
int packet_frame_size, packet_bandwidth, packet_mode, packet_stream_channels;
/* 48 x 2.5 ms = 120 ms */
short 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;
ret = opus_decode_frame(st, NULL, 0, pcm, frame_size-pcm_count, 0);
if (ret<0)
return ret;
pcm += st->channels*ret;
pcm_count += ret;
} while (pcm_count < frame_size);
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);
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);
/* Otherwise, run the PLC on everything except the size for which we might have FEC */
duration_copy = st->last_packet_duration;
ret = opus_decode_native(st, NULL, 0, pcm, frame_size-packet_frame_size, 0, 0, NULL);
if (ret<0)
{
st->last_packet_duration = duration_copy;
return ret;
}
/* 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;
st->last_packet_duration = frame_size;
return frame_size;
}
tot_offset = 0;
if (count < 0)
return count;
tot_offset += offset;
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, frame_size-nb_samples, decode_fec);
if (ret<0)
return ret;
data += size[i];
tot_offset += size[i];
pcm += ret*st->channels;
nb_samples += ret;
}
if (packet_offset != NULL)
*packet_offset = tot_offset;
st->last_packet_duration = nb_samples;
return nb_samples;
}
