int celt_size = av_audio_fifo_size(s->celt_delay);
int ret, i;
ret = swr_convert(s->swr,
- (uint8_t**)s->out, nb_samples,
+ (uint8_t**)s->cur_out, nb_samples,
NULL, 0);
if (ret < 0)
return ret;
}
av_audio_fifo_read(s->celt_delay, (void**)s->celt_output, nb_samples);
for (i = 0; i < s->output_channels; i++) {
- s->fdsp->vector_fmac_scalar(s->out[i],
+ s->fdsp->vector_fmac_scalar(s->cur_out[i],
s->celt_output[i], 1.0,
nb_samples);
}
if (s->redundancy_idx) {
for (i = 0; i < s->output_channels; i++)
- opus_fade(s->out[i], s->out[i],
+ opus_fade(s->cur_out[i], s->cur_out[i],
s->redundancy_output[i] + 120 + s->redundancy_idx,
ff_celt_window2 + s->redundancy_idx, 120 - s->redundancy_idx);
s->redundancy_idx = 0;
}
- s->out[0] += nb_samples;
- s->out[1] += nb_samples;
- s->out_size -= nb_samples * sizeof(float);
+ s->cur_out[0] += nb_samples;
+ s->cur_out[1] += nb_samples;
+ s->remaining_out_size -= nb_samples * sizeof(float);
return 0;
}
return samples;
}
samples = swr_convert(s->swr,
- (uint8_t**)s->out, s->packet.frame_duration,
+ (uint8_t**)s->cur_out, s->packet.frame_duration,
(const uint8_t**)s->silk_output, samples);
if (samples < 0) {
av_log(s->avctx, AV_LOG_ERROR, "Error resampling SILK data.\n");
/* decode the CELT frame */
if (s->packet.mode == OPUS_MODE_CELT || s->packet.mode == OPUS_MODE_HYBRID) {
- float *out_tmp[2] = { s->out[0], s->out[1] };
+ float *out_tmp[2] = { s->cur_out[0], s->cur_out[1] };
float **dst = (s->packet.mode == OPUS_MODE_CELT) ?
out_tmp : s->celt_output;
int celt_output_samples = samples;
if (s->redundancy_idx) {
for (i = 0; i < s->output_channels; i++)
- opus_fade(s->out[i], s->out[i],
+ opus_fade(s->cur_out[i], s->cur_out[i],
s->redundancy_output[i] + 120 + s->redundancy_idx,
ff_celt_window2 + s->redundancy_idx, 120 - s->redundancy_idx);
s->redundancy_idx = 0;
return ret;
for (i = 0; i < s->output_channels; i++) {
- opus_fade(s->out[i] + samples - 120 + delayed_samples,
- s->out[i] + samples - 120 + delayed_samples,
+ opus_fade(s->cur_out[i] + samples - 120 + delayed_samples,
+ s->cur_out[i] + samples - 120 + delayed_samples,
s->redundancy_output[i] + 120,
ff_celt_window2, 120 - delayed_samples);
if (delayed_samples)
}
} else {
for (i = 0; i < s->output_channels; i++) {
- memcpy(s->out[i] + delayed_samples, s->redundancy_output[i], 120 * sizeof(float));
- opus_fade(s->out[i] + 120 + delayed_samples,
+ memcpy(s->cur_out[i] + delayed_samples, s->redundancy_output[i], 120 * sizeof(float));
+ opus_fade(s->cur_out[i] + 120 + delayed_samples,
s->redundancy_output[i] + 120,
- s->out[i] + 120 + delayed_samples,
+ s->cur_out[i] + 120 + delayed_samples,
ff_celt_window2, 120);
}
}
static int opus_decode_subpacket(OpusStreamContext *s,
const uint8_t *buf, int buf_size,
- float **out, int out_size,
int nb_samples)
{
int output_samples = 0;
int flush_needed = 0;
int i, j, ret;
- s->out[0] = out[0];
- s->out[1] = out[1];
- s->out_size = out_size;
+ s->cur_out[0] = s->out[0];
+ s->cur_out[1] = s->out[1];
+ s->remaining_out_size = s->out_size;
/* check if we need to flush the resampler */
if (swr_is_initialized(s->swr)) {
return 0;
/* use dummy output buffers if the channel is not mapped to anything */
- if (!s->out[0] ||
- (s->output_channels == 2 && !s->out[1])) {
- av_fast_malloc(&s->out_dummy, &s->out_dummy_allocated_size, s->out_size);
+ if (!s->cur_out[0] ||
+ (s->output_channels == 2 && !s->cur_out[1])) {
+ av_fast_malloc(&s->out_dummy, &s->out_dummy_allocated_size,
+ s->remaining_out_size);
if (!s->out_dummy)
return AVERROR(ENOMEM);
- if (!s->out[0])
- s->out[0] = s->out_dummy;
- if (!s->out[1])
- s->out[1] = s->out_dummy;
+ if (!s->cur_out[0])
+ s->cur_out[0] = s->out_dummy;
+ if (!s->cur_out[1])
+ s->cur_out[1] = s->out_dummy;
}
/* flush the resampler if necessary */
return samples;
for (j = 0; j < s->output_channels; j++)
- memset(s->out[j], 0, s->packet.frame_duration * sizeof(float));
+ memset(s->cur_out[j], 0, s->packet.frame_duration * sizeof(float));
samples = s->packet.frame_duration;
}
output_samples += samples;
for (j = 0; j < s->output_channels; j++)
- s->out[j] += samples;
- s->out_size -= samples * sizeof(float);
+ s->cur_out[j] += samples;
+ s->remaining_out_size -= samples * sizeof(float);
}
finish:
- s->out[0] = s->out[1] = NULL;
- s->out_size = 0;
+ s->cur_out[0] = s->cur_out[1] = NULL;
+ s->remaining_out_size = 0;
return output_samples;
}
s->out[0] =
s->out[1] = NULL;
delayed_samples = FFMAX(delayed_samples,
- s->delayed_samples + av_audio_fifo_size(c->sync_buffers[i]));
+ s->delayed_samples + av_audio_fifo_size(s->sync_buffer));
}
/* decode the header of the first sub-packet to find out the sample count */
return ret;
frame->nb_samples = 0;
- memset(c->out, 0, c->nb_streams * 2 * sizeof(*c->out));
for (i = 0; i < avctx->channels; i++) {
ChannelMap *map = &c->channel_maps[i];
if (!map->copy)
- c->out[2 * map->stream_idx + map->channel_idx] = (float*)frame->extended_data[i];
+ c->streams[map->stream_idx].out[map->channel_idx] = (float*)frame->extended_data[i];
}
/* read the data from the sync buffers */
for (i = 0; i < c->nb_streams; i++) {
- float **out = c->out + 2 * i;
- int sync_size = av_audio_fifo_size(c->sync_buffers[i]);
+ OpusStreamContext *s = &c->streams[i];
+ float **out = s->out;
+ int sync_size = av_audio_fifo_size(s->sync_buffer);
float sync_dummy[32];
int out_dummy = (!out[0]) | ((!out[1]) << 1);
if (out_dummy && sync_size > FF_ARRAY_ELEMS(sync_dummy))
return AVERROR_BUG;
- ret = av_audio_fifo_read(c->sync_buffers[i], (void**)out, sync_size);
+ ret = av_audio_fifo_read(s->sync_buffer, (void**)out, sync_size);
if (ret < 0)
return ret;
else
out[1] += ret;
- c->out_size[i] = frame->linesize[0] - ret * sizeof(float);
+ s->out_size = frame->linesize[0] - ret * sizeof(float);
}
/* decode each sub-packet */
}
ret = opus_decode_subpacket(&c->streams[i], buf, s->packet.data_size,
- c->out + 2 * i, c->out_size[i], coded_samples);
+ coded_samples);
if (ret < 0)
return ret;
- c->decoded_samples[i] = ret;
+ s->decoded_samples = ret;
decoded_samples = FFMIN(decoded_samples, ret);
buf += s->packet.packet_size;
/* buffer the extra samples */
for (i = 0; i < c->nb_streams; i++) {
- int buffer_samples = c->decoded_samples[i] - decoded_samples;
+ OpusStreamContext *s = &c->streams[i];
+ int buffer_samples = s->decoded_samples - decoded_samples;
if (buffer_samples) {
- float *buf[2] = { c->out[2 * i + 0] ? c->out[2 * i + 0] : (float*)frame->extended_data[0],
- c->out[2 * i + 1] ? c->out[2 * i + 1] : (float*)frame->extended_data[0] };
+ float *buf[2] = { s->out[0] ? s->out[0] : (float*)frame->extended_data[0],
+ s->out[1] ? s->out[1] : (float*)frame->extended_data[0] };
buf[0] += decoded_samples;
buf[1] += decoded_samples;
- ret = av_audio_fifo_write(c->sync_buffers[i], (void**)buf, buffer_samples);
+ ret = av_audio_fifo_write(s->sync_buffer, (void**)buf, buffer_samples);
if (ret < 0)
return ret;
}
memset(&s->packet, 0, sizeof(s->packet));
s->delayed_samples = 0;
- if (s->celt_delay)
- av_audio_fifo_drain(s->celt_delay, av_audio_fifo_size(s->celt_delay));
+ av_audio_fifo_drain(s->celt_delay, av_audio_fifo_size(s->celt_delay));
swr_close(s->swr);
- av_audio_fifo_drain(c->sync_buffers[i], av_audio_fifo_size(c->sync_buffers[i]));
+ av_audio_fifo_drain(s->sync_buffer, av_audio_fifo_size(s->sync_buffer));
ff_silk_flush(s->silk);
ff_celt_flush(s->celt);
av_freep(&s->out_dummy);
s->out_dummy_allocated_size = 0;
+ av_audio_fifo_free(s->sync_buffer);
av_audio_fifo_free(s->celt_delay);
swr_free(&s->swr);
}
av_freep(&c->streams);
- if (c->sync_buffers) {
- for (i = 0; i < c->nb_streams; i++)
- av_audio_fifo_free(c->sync_buffers[i]);
- }
- av_freep(&c->sync_buffers);
- av_freep(&c->decoded_samples);
- av_freep(&c->out);
- av_freep(&c->out_size);
-
c->nb_streams = 0;
av_freep(&c->channel_maps);
/* find out the channel configuration */
ret = ff_opus_parse_extradata(avctx, c);
- if (ret < 0) {
- av_freep(&c->fdsp);
+ if (ret < 0)
return ret;
- }
/* allocate and init each independent decoder */
c->streams = av_mallocz_array(c->nb_streams, sizeof(*c->streams));
- c->out = av_mallocz_array(c->nb_streams, 2 * sizeof(*c->out));
- c->out_size = av_mallocz_array(c->nb_streams, sizeof(*c->out_size));
- c->sync_buffers = av_mallocz_array(c->nb_streams, sizeof(*c->sync_buffers));
- c->decoded_samples = av_mallocz_array(c->nb_streams, sizeof(*c->decoded_samples));
- if (!c->streams || !c->sync_buffers || !c->decoded_samples || !c->out || !c->out_size) {
+ if (!c->streams) {
c->nb_streams = 0;
- ret = AVERROR(ENOMEM);
- goto fail;
+ return AVERROR(ENOMEM);
}
for (i = 0; i < c->nb_streams; i++) {
s->swr =swr_alloc();
if (!s->swr)
- goto fail;
+ return AVERROR(ENOMEM);
layout = (s->output_channels == 1) ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
av_opt_set_int(s->swr, "in_sample_fmt", avctx->sample_fmt, 0);
ret = ff_silk_init(avctx, &s->silk, s->output_channels);
if (ret < 0)
- goto fail;
+ return ret;
ret = ff_celt_init(avctx, &s->celt, s->output_channels, c->apply_phase_inv);
if (ret < 0)
- goto fail;
+ return ret;
s->celt_delay = av_audio_fifo_alloc(avctx->sample_fmt,
s->output_channels, 1024);
- if (!s->celt_delay) {
- ret = AVERROR(ENOMEM);
- goto fail;
- }
+ if (!s->celt_delay)
+ return AVERROR(ENOMEM);
- c->sync_buffers[i] = av_audio_fifo_alloc(avctx->sample_fmt,
- s->output_channels, 32);
- if (!c->sync_buffers[i]) {
- ret = AVERROR(ENOMEM);
- goto fail;
- }
+ s->sync_buffer = av_audio_fifo_alloc(avctx->sample_fmt,
+ s->output_channels, 32);
+ if (!s->sync_buffer)
+ return AVERROR(ENOMEM);
}
return 0;
-fail:
- opus_decode_close(avctx);
- return ret;
}
#define OFFSET(x) offsetof(OpusContext, x)
.version = LIBAVUTIL_VERSION_INT,
};
-AVCodec ff_opus_decoder = {
+const AVCodec ff_opus_decoder = {
.name = "opus",
.long_name = NULL_IF_CONFIG_SMALL("Opus"),
.priv_class = &opus_class,
.decode = opus_decode_packet,
.flush = opus_decode_flush,
.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_CHANNEL_CONF,
+ .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
};