har0ke/FFmpeg
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

avcodec/opusdec: Move per-stream fields to OpusStreamContext

Browse Source 
Besides being more natural it also avoids allocations for separate
arrays of decoded samples/output buffers/....

Reviewed-by: Lynne <dev@lynne.ee>
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@gmail.com>
This commit is contained in:
Andreas Rheinhardt 2020-12-28 17:46:44 +01:00
parent 794fb18369
commit f03eade869
2 changed files with 62 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
libavcodec/opus.h
View File

@ -101,6 +101,15 @@ typedef struct OpusStreamContext {
AVCodecContext *avctx; AVCodecContext *avctx;
int output_channels; int output_channels;
/* number of decoded samples for this stream */
int decoded_samples;
/* current output buffers for this stream */
float *out[2];
int out_size;
/* Buffer with samples from this stream for synchronizing
* the streams when they have different resampling delays */
AVAudioFifo *sync_buffer;
OpusRangeCoder rc; OpusRangeCoder rc;
OpusRangeCoder redundancy_rc; OpusRangeCoder redundancy_rc;
SilkContext *silk; SilkContext *silk;
@ -115,9 +124,9 @@ typedef struct OpusStreamContext {
DECLARE_ALIGNED(32, float, redundancy_buf)[2][960]; DECLARE_ALIGNED(32, float, redundancy_buf)[2][960];
float *redundancy_output[2]; float *redundancy_output[2];
/* data buffers for the final output data */ /* buffers for the next samples to be decoded */
float *out[2]; float *cur_out[2];
int out_size; int remaining_out_size;
float *out_dummy; float *out_dummy;
int out_dummy_allocated_size; int out_dummy_allocated_size;
@ -154,15 +163,6 @@ typedef struct OpusContext {
OpusStreamContext *streams; OpusStreamContext *streams;
int apply_phase_inv; int apply_phase_inv;
/* current output buffers for each streams */
float **out;
int *out_size;
/* Buffers for synchronizing the streams when they have different
* resampling delays */
AVAudioFifo **sync_buffers;
/* number of decoded samples for each stream */
int *decoded_samples;
int nb_streams; int nb_streams;
int nb_stereo_streams; int nb_stereo_streams;

111
libavcodec/opusdec.c
View File

@ -87,7 +87,7 @@ static int opus_flush_resample(OpusStreamContext *s, int nb_samples)
int celt_size = av_audio_fifo_size(s->celt_delay); int celt_size = av_audio_fifo_size(s->celt_delay);
int ret, i; int ret, i;
ret = swr_convert(s->swr, ret = swr_convert(s->swr,
(uint8_t**)s->out, nb_samples, (uint8_t**)s->cur_out, nb_samples,
NULL, 0); NULL, 0);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -104,7 +104,7 @@ static int opus_flush_resample(OpusStreamContext *s, int nb_samples)
} }
av_audio_fifo_read(s->celt_delay, (void**)s->celt_output, nb_samples); av_audio_fifo_read(s->celt_delay, (void**)s->celt_output, nb_samples);
for (i = 0; i < s->output_channels; i++) { 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, s->celt_output[i], 1.0,
nb_samples); nb_samples);
} }
@ -112,15 +112,15 @@ static int opus_flush_resample(OpusStreamContext *s, int nb_samples)
if (s->redundancy_idx) { if (s->redundancy_idx) {
for (i = 0; i < s->output_channels; i++) 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, s->redundancy_output[i] + 120 + s->redundancy_idx,
ff_celt_window2 + s->redundancy_idx, 120 - s->redundancy_idx); ff_celt_window2 + s->redundancy_idx, 120 - s->redundancy_idx);
s->redundancy_idx = 0; s->redundancy_idx = 0;
} }
s->out[0] += nb_samples; s->cur_out[0] += nb_samples;
s->out[1] += nb_samples; s->cur_out[1] += nb_samples;
s->out_size -= nb_samples * sizeof(float); s->remaining_out_size -= nb_samples * sizeof(float);
return 0; return 0;
} }
@ -199,7 +199,7 @@ static int opus_decode_frame(OpusStreamContext *s, const uint8_t *data, int size
return samples; return samples;
} }
samples = swr_convert(s->swr, 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); (const uint8_t**)s->silk_output, samples);
if (samples < 0) { if (samples < 0) {
av_log(s->avctx, AV_LOG_ERROR, "Error resampling SILK data.\n"); av_log(s->avctx, AV_LOG_ERROR, "Error resampling SILK data.\n");
@ -240,7 +240,7 @@ static int opus_decode_frame(OpusStreamContext *s, const uint8_t *data, int size
/* decode the CELT frame */ /* decode the CELT frame */
if (s->packet.mode == OPUS_MODE_CELT || s->packet.mode == OPUS_MODE_HYBRID) { 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) ? float **dst = (s->packet.mode == OPUS_MODE_CELT) ?
out_tmp : s->celt_output; out_tmp : s->celt_output;
int celt_output_samples = samples; int celt_output_samples = samples;
@ -295,7 +295,7 @@ static int opus_decode_frame(OpusStreamContext *s, const uint8_t *data, int size
if (s->redundancy_idx) { if (s->redundancy_idx) {
for (i = 0; i < s->output_channels; i++) 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, s->redundancy_output[i] + 120 + s->redundancy_idx,
ff_celt_window2 + s->redundancy_idx, 120 - s->redundancy_idx); ff_celt_window2 + s->redundancy_idx, 120 - s->redundancy_idx);
s->redundancy_idx = 0; s->redundancy_idx = 0;
@ -308,8 +308,8 @@ static int opus_decode_frame(OpusStreamContext *s, const uint8_t *data, int size
return ret; return ret;
for (i = 0; i < s->output_channels; i++) { for (i = 0; i < s->output_channels; i++) {
opus_fade(s->out[i] + samples - 120 + delayed_samples, opus_fade(s->cur_out[i] + samples - 120 + delayed_samples,
s->out[i] + samples - 120 + delayed_samples, s->cur_out[i] + samples - 120 + delayed_samples,
s->redundancy_output[i] + 120, s->redundancy_output[i] + 120,
ff_celt_window2, 120 - delayed_samples); ff_celt_window2, 120 - delayed_samples);
if (delayed_samples) if (delayed_samples)
@ -317,10 +317,10 @@ static int opus_decode_frame(OpusStreamContext *s, const uint8_t *data, int size
} }
} else { } else {
for (i = 0; i < s->output_channels; i++) { for (i = 0; i < s->output_channels; i++) {
memcpy(s->out[i] + delayed_samples, s->redundancy_output[i], 120 * sizeof(float)); memcpy(s->cur_out[i] + delayed_samples, s->redundancy_output[i], 120 * sizeof(float));
opus_fade(s->out[i] + 120 + delayed_samples, opus_fade(s->cur_out[i] + 120 + delayed_samples,
s->redundancy_output[i] + 120, s->redundancy_output[i] + 120,
s->out[i] + 120 + delayed_samples, s->cur_out[i] + 120 + delayed_samples,
ff_celt_window2, 120); ff_celt_window2, 120);
} }
} }
@ -331,16 +331,15 @@ static int opus_decode_frame(OpusStreamContext *s, const uint8_t *data, int size
static int opus_decode_subpacket(OpusStreamContext *s, static int opus_decode_subpacket(OpusStreamContext *s,
const uint8_t *buf, int buf_size, const uint8_t *buf, int buf_size,
float **out, int out_size,
int nb_samples) int nb_samples)
{ {
int output_samples = 0; int output_samples = 0;
int flush_needed = 0; int flush_needed = 0;
int i, j, ret; int i, j, ret;
s->out[0] = out[0]; s->cur_out[0] = s->out[0];
s->out[1] = out[1]; s->cur_out[1] = s->out[1];
s->out_size = out_size; s->remaining_out_size = s->out_size;
/* check if we need to flush the resampler */ /* check if we need to flush the resampler */
if (swr_is_initialized(s->swr)) { if (swr_is_initialized(s->swr)) {
@ -357,15 +356,16 @@ static int opus_decode_subpacket(OpusStreamContext *s,
return 0; return 0;
/* use dummy output buffers if the channel is not mapped to anything */ /* use dummy output buffers if the channel is not mapped to anything */
if (!s->out[0] || if (!s->cur_out[0] ||
(s->output_channels == 2 && !s->out[1])) { (s->output_channels == 2 && !s->cur_out[1])) {
av_fast_malloc(&s->out_dummy, &s->out_dummy_allocated_size, s->out_size); av_fast_malloc(&s->out_dummy, &s->out_dummy_allocated_size,
s->remaining_out_size);
if (!s->out_dummy) if (!s->out_dummy)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
if (!s->out[0]) if (!s->cur_out[0])
s->out[0] = s->out_dummy; s->cur_out[0] = s->out_dummy;
if (!s->out[1]) if (!s->cur_out[1])
s->out[1] = s->out_dummy; s->cur_out[1] = s->out_dummy;
} }
/* flush the resampler if necessary */ /* flush the resampler if necessary */
@ -394,19 +394,19 @@ static int opus_decode_subpacket(OpusStreamContext *s,
return samples; return samples;
for (j = 0; j < s->output_channels; j++) 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; samples = s->packet.frame_duration;
} }
output_samples += samples; output_samples += samples;
for (j = 0; j < s->output_channels; j++) for (j = 0; j < s->output_channels; j++)
s->out[j] += samples; s->cur_out[j] += samples;
s->out_size -= samples * sizeof(float); s->remaining_out_size -= samples * sizeof(float);
} }
finish: finish:
s->out[0] = s->out[1] = NULL; s->cur_out[0] = s->cur_out[1] = NULL;
s->out_size = 0; s->remaining_out_size = 0;
return output_samples; return output_samples;
} }
@ -429,7 +429,7 @@ static int opus_decode_packet(AVCodecContext *avctx, void *data,
s->out[0] = s->out[0] =
s->out[1] = NULL; s->out[1] = NULL;
delayed_samples = FFMAX(delayed_samples, 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 */ /* decode the header of the first sub-packet to find out the sample count */
@ -458,17 +458,17 @@ static int opus_decode_packet(AVCodecContext *avctx, void *data,
return ret; return ret;
frame->nb_samples = 0; frame->nb_samples = 0;
memset(c->out, 0, c->nb_streams * 2 * sizeof(*c->out));
for (i = 0; i < avctx->channels; i++) { for (i = 0; i < avctx->channels; i++) {
ChannelMap *map = &c->channel_maps[i]; ChannelMap *map = &c->channel_maps[i];
if (!map->copy) 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 */ /* read the data from the sync buffers */
for (i = 0; i < c->nb_streams; i++) { for (i = 0; i < c->nb_streams; i++) {
float **out = c->out + 2 * i; OpusStreamContext *s = &c->streams[i];
int sync_size = av_audio_fifo_size(c->sync_buffers[i]); float **out = s->out;
int sync_size = av_audio_fifo_size(s->sync_buffer);
float sync_dummy[32]; float sync_dummy[32];
int out_dummy = (!out[0]) | ((!out[1]) << 1); int out_dummy = (!out[0]) | ((!out[1]) << 1);
@ -480,7 +480,7 @@ static int opus_decode_packet(AVCodecContext *avctx, void *data,
if (out_dummy && sync_size > FF_ARRAY_ELEMS(sync_dummy)) if (out_dummy && sync_size > FF_ARRAY_ELEMS(sync_dummy))
return AVERROR_BUG; 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) if (ret < 0)
return ret; return ret;
@ -493,7 +493,7 @@ static int opus_decode_packet(AVCodecContext *avctx, void *data,
else else
out[1] += ret; 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 */ /* decode each sub-packet */
@ -516,10 +516,10 @@ static int opus_decode_packet(AVCodecContext *avctx, void *data,
} }
ret = opus_decode_subpacket(&c->streams[i], buf, s->packet.data_size, 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) if (ret < 0)
return ret; return ret;
c->decoded_samples[i] = ret; s->decoded_samples = ret;
decoded_samples = FFMIN(decoded_samples, ret); decoded_samples = FFMIN(decoded_samples, ret);
buf += s->packet.packet_size; buf += s->packet.packet_size;
@ -528,13 +528,14 @@ static int opus_decode_packet(AVCodecContext *avctx, void *data,
/* buffer the extra samples */ /* buffer the extra samples */
for (i = 0; i < c->nb_streams; i++) { 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) { if (buffer_samples) {
float *buf[2] = { c->out[2 * i + 0] ? c->out[2 * i + 0] : (float*)frame->extended_data[0], float *buf[2] = { s->out[0] ? s->out[0] : (float*)frame->extended_data[0],
c->out[2 * i + 1] ? c->out[2 * i + 1] : (float*)frame->extended_data[0] }; s->out[1] ? s->out[1] : (float*)frame->extended_data[0] };
buf[0] += decoded_samples; buf[0] += decoded_samples;
buf[1] += 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) if (ret < 0)
return ret; return ret;
} }
@ -579,7 +580,7 @@ static av_cold void opus_decode_flush(AVCodecContext *ctx)
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); 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_silk_flush(s->silk);
ff_celt_flush(s->celt); ff_celt_flush(s->celt);
@ -600,21 +601,13 @@ static av_cold int opus_decode_close(AVCodecContext *avctx)
av_freep(&s->out_dummy); av_freep(&s->out_dummy);
s->out_dummy_allocated_size = 0; s->out_dummy_allocated_size = 0;
av_audio_fifo_free(s->sync_buffer);
av_audio_fifo_free(s->celt_delay); av_audio_fifo_free(s->celt_delay);
swr_free(&s->swr); swr_free(&s->swr);
} }
av_freep(&c->streams); 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; c->nb_streams = 0;
av_freep(&c->channel_maps); av_freep(&c->channel_maps);
@ -644,11 +637,7 @@ static av_cold int opus_decode_init(AVCodecContext *avctx)
/* allocate and init each independent decoder */ /* allocate and init each independent decoder */
c->streams = av_mallocz_array(c->nb_streams, sizeof(*c->streams)); c->streams = av_mallocz_array(c->nb_streams, sizeof(*c->streams));
c->out = av_mallocz_array(c->nb_streams, 2 * sizeof(*c->out)); if (!c->streams) {
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) {
c->nb_streams = 0; c->nb_streams = 0;
ret = AVERROR(ENOMEM); ret = AVERROR(ENOMEM);
goto fail; goto fail;
@ -699,9 +688,9 @@ static av_cold int opus_decode_init(AVCodecContext *avctx)
goto fail; goto fail;
} }
c->sync_buffers[i] = av_audio_fifo_alloc(avctx->sample_fmt, s->sync_buffer = av_audio_fifo_alloc(avctx->sample_fmt,
s->output_channels, 32); s->output_channels, 32);
if (!c->sync_buffers[i]) { if (!s->sync_buffer) {
ret = AVERROR(ENOMEM); ret = AVERROR(ENOMEM);
goto fail; goto fail;
} }