1 files changed, 286 insertions, 324 deletions

diff --git a/src/decoder/plugins/FfmpegDecoderPlugin.cxx b/src/decoder/plugins/FfmpegDecoderPlugin.cxx
index d5191a3c3..90699ef5e 100644
--- a/src/decoder/plugins/FfmpegDecoderPlugin.cxx
+++ b/src/decoder/plugins/FfmpegDecoderPlugin.cxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2014 The Music Player Daemon Project
+ * Copyright (C) 2003-2015 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -20,14 +20,24 @@
 /* necessary because libavutil/common.h uses UINT64_C */
 #define __STDC_CONSTANT_MACROS
 
+#include "lib/ffmpeg/Time.hxx"
 #include "config.h"
 #include "FfmpegDecoderPlugin.hxx"
 #include "lib/ffmpeg/Domain.hxx"
+#include "lib/ffmpeg/Error.hxx"
+#include "lib/ffmpeg/LogError.hxx"
+#include "lib/ffmpeg/Init.hxx"
+#include "lib/ffmpeg/Buffer.hxx"
 #include "../DecoderAPI.hxx"
 #include "FfmpegMetaData.hxx"
+#include "FfmpegIo.hxx"
+#include "tag/TagBuilder.hxx"
 #include "tag/TagHandler.hxx"
+#include "tag/ReplayGain.hxx"
+#include "tag/MixRamp.hxx"
 #include "input/InputStream.hxx"
 #include "CheckAudioFormat.hxx"
+#include "util/ConstBuffer.hxx"
 #include "util/Error.hxx"
 #include "util/Domain.hxx"
 #include "LogV.hxx"
@@ -38,7 +48,6 @@ extern "C" {
 #include <libavformat/avio.h>
 #include <libavutil/avutil.h>
 #include <libavutil/log.h>
-#include <libavutil/mathematics.h>
 
 #if LIBAVUTIL_VERSION_MAJOR >= 53
 #include <libavutil/frame.h>
@@ -48,205 +57,50 @@ extern "C" {
 #include <assert.h>
 #include <string.h>
 
-/* suppress the ffmpeg compatibility macro */
-#ifdef SampleFormat
-#undef SampleFormat
-#endif
-
-static LogLevel
-import_ffmpeg_level(int level)
-{
-	if (level <= AV_LOG_FATAL)
-		return LogLevel::ERROR;
-
-	if (level <= AV_LOG_WARNING)
-		return LogLevel::WARNING;
-
-	if (level <= AV_LOG_INFO)
-		return LogLevel::INFO;
-
-	return LogLevel::DEBUG;
-}
-
-static void
-mpd_ffmpeg_log_callback(gcc_unused void *ptr, int level,
-			const char *fmt, va_list vl)
-{
-	const AVClass * cls = nullptr;
-
-	if (ptr != nullptr)
-		cls = *(const AVClass *const*)ptr;
-
-	if (cls != nullptr) {
-		char domain[64];
-		snprintf(domain, sizeof(domain), "%s/%s",
-			 ffmpeg_domain.GetName(), cls->item_name(ptr));
-		const Domain d(domain);
-		LogFormatV(d, import_ffmpeg_level(level), fmt, vl);
-	}
-}
-
-struct AvioStream {
-	Decoder *const decoder;
-	InputStream &input;
-
-	AVIOContext *io;
-
-	unsigned char buffer[8192];
-
-	AvioStream(Decoder *_decoder, InputStream &_input)
-		:decoder(_decoder), input(_input), io(nullptr) {}
-
-	~AvioStream() {
-		if (io != nullptr)
-			av_free(io);
-	}
-
-	bool Open();
-};
-
-static int
-mpd_ffmpeg_stream_read(void *opaque, uint8_t *buf, int size)
-{
-	AvioStream *stream = (AvioStream *)opaque;
-
-	return decoder_read(stream->decoder, stream->input,
-			    (void *)buf, size);
-}
-
-static int64_t
-mpd_ffmpeg_stream_seek(void *opaque, int64_t pos, int whence)
-{
-	AvioStream *stream = (AvioStream *)opaque;
-
-	switch (whence) {
-	case SEEK_SET:
-		break;
-
-	case SEEK_CUR:
-		pos += stream->input.GetOffset();
-		break;
-
-	case SEEK_END:
-		if (!stream->input.KnownSize())
-			return -1;
-
-		pos += stream->input.GetSize();
-		break;
-
-	case AVSEEK_SIZE:
-		if (!stream->input.KnownSize())
-			return -1;
-
-		return stream->input.GetSize();
-
-	default:
-		return -1;
-	}
-
-	if (!stream->input.LockSeek(pos, IgnoreError()))
-		return -1;
-
-	return stream->input.GetOffset();
-}
-
-bool
-AvioStream::Open()
-{
-	io = avio_alloc_context(buffer, sizeof(buffer),
-				false, this,
-				mpd_ffmpeg_stream_read, nullptr,
-				input.IsSeekable()
-				? mpd_ffmpeg_stream_seek : nullptr);
-	return io != nullptr;
-}
-
-/**
- * API compatibility wrapper for av_open_input_stream() and
- * avformat_open_input().
- */
-static int
-mpd_ffmpeg_open_input(AVFormatContext **ic_ptr,
-		      AVIOContext *pb,
-		      const char *filename,
-		      AVInputFormat *fmt)
+static AVFormatContext *
+FfmpegOpenInput(AVIOContext *pb,
+		const char *filename,
+		AVInputFormat *fmt)
 {
 	AVFormatContext *context = avformat_alloc_context();
 	if (context == nullptr)
-		return AVERROR(ENOMEM);
+		return nullptr;
 
 	context->pb = pb;
-	*ic_ptr = context;
-	return avformat_open_input(ic_ptr, filename, fmt, nullptr);
+
+	avformat_open_input(&context, filename, fmt, nullptr);
+	return context;
 }
 
 static bool
-ffmpeg_init(gcc_unused const config_param &param)
+ffmpeg_init(gcc_unused const ConfigBlock &block)
 {
-	av_log_set_callback(mpd_ffmpeg_log_callback);
-
-	av_register_all();
+	FfmpegInit();
 	return true;
 }
 
+gcc_pure
 static int
-ffmpeg_find_audio_stream(const AVFormatContext *format_context)
+ffmpeg_find_audio_stream(const AVFormatContext &format_context)
 {
-	for (unsigned i = 0; i < format_context->nb_streams; ++i)
-		if (format_context->streams[i]->codec->codec_type ==
+	for (unsigned i = 0; i < format_context.nb_streams; ++i)
+		if (format_context.streams[i]->codec->codec_type ==
 		    AVMEDIA_TYPE_AUDIO)
 			return i;
 
 	return -1;
 }
 
-gcc_const
-static double
-time_from_ffmpeg(int64_t t, const AVRational time_base)
-{
-	assert(t != (int64_t)AV_NOPTS_VALUE);
-
-	return (double)av_rescale_q(t, time_base, (AVRational){1, 1024})
-		/ (double)1024;
-}
-
-template<typename Ratio>
-static constexpr AVRational
-RatioToAVRational()
-{
-	return { Ratio::num, Ratio::den };
-}
-
-gcc_const
-static int64_t
-time_to_ffmpeg(SongTime t, const AVRational time_base)
-{
-	return av_rescale_q(t.count(),
-			    RatioToAVRational<SongTime::period>(),
-			    time_base);
-}
-
-/**
- * Replace #AV_NOPTS_VALUE with the given fallback.
- */
-static constexpr int64_t
-timestamp_fallback(int64_t t, int64_t fallback)
-{
-	return gcc_likely(t != int64_t(AV_NOPTS_VALUE))
-		? t
-		: fallback;
-}
-
 /**
  * Accessor for AVStream::start_time that replaces AV_NOPTS_VALUE with
  * zero.  We can't use AV_NOPTS_VALUE in calculations, and we simply
  * assume that the stream's start time is zero, which appears to be
  * the best way out of that situation.
  */
-static int64_t
+static constexpr int64_t
 start_time_fallback(const AVStream &stream)
 {
-	return timestamp_fallback(stream.start_time, 0);
+	return FfmpegTimestampFallback(stream.start_time, 0);
 }
 
 static void
@@ -264,45 +118,48 @@ copy_interleave_frame2(uint8_t *dest, uint8_t **src,
 }
 
 /**
- * Copy PCM data from a AVFrame to an interleaved buffer.
+ * Copy PCM data from a non-empty AVFrame to an interleaved buffer.
  */
-static int
-copy_interleave_frame(const AVCodecContext *codec_context,
-		      const AVFrame *frame,
-		      uint8_t **output_buffer,
-		      uint8_t **global_buffer, int *global_buffer_size)
+static ConstBuffer<void>
+copy_interleave_frame(const AVCodecContext &codec_context,
+		      const AVFrame &frame,
+		      FfmpegBuffer &global_buffer,
+		      Error &error)
 {
+	assert(frame.nb_samples > 0);
+
 	int plane_size;
 	const int data_size =
 		av_samples_get_buffer_size(&plane_size,
-					   codec_context->channels,
-					   frame->nb_samples,
-					   codec_context->sample_fmt, 1);
-	if (data_size <= 0)
-		return data_size;
-
-	if (av_sample_fmt_is_planar(codec_context->sample_fmt) &&
-	    codec_context->channels > 1) {
-		if(*global_buffer_size < data_size) {
-			av_freep(global_buffer);
-
-			*global_buffer = (uint8_t*)av_malloc(data_size);
-
-			if (!*global_buffer)
-				/* Not enough memory - shouldn't happen */
-				return AVERROR(ENOMEM);
-			*global_buffer_size = data_size;
+					   codec_context.channels,
+					   frame.nb_samples,
+					   codec_context.sample_fmt, 1);
+	assert(data_size != 0);
+	if (data_size < 0) {
+		SetFfmpegError(error, data_size);
+		return 0;
+	}
+
+	void *output_buffer;
+	if (av_sample_fmt_is_planar(codec_context.sample_fmt) &&
+	    codec_context.channels > 1) {
+		output_buffer = global_buffer.GetT<uint8_t>(data_size);
+		if (output_buffer == nullptr) {
+			/* Not enough memory - shouldn't happen */
+			error.SetErrno(ENOMEM);
+			return 0;
 		}
-		*output_buffer = *global_buffer;
-		copy_interleave_frame2(*output_buffer, frame->extended_data,
-				       frame->nb_samples,
-				       codec_context->channels,
-				       av_get_bytes_per_sample(codec_context->sample_fmt));
+
+		copy_interleave_frame2((uint8_t *)output_buffer,
+				       frame.extended_data,
+				       frame.nb_samples,
+				       codec_context.channels,
+				       av_get_bytes_per_sample(codec_context.sample_fmt));
 	} else {
-		*output_buffer = frame->extended_data[0];
+		output_buffer = frame.extended_data[0];
 	}
 
-	return data_size;
+	return { output_buffer, (size_t)data_size };
 }
 
 /**
@@ -334,81 +191,82 @@ PtsToPcmFrame(uint64_t pts, const AVStream &stream,
 }
 
 /**
+ * Decode an #AVPacket and send the resulting PCM data to the decoder
+ * API.
+ *
  * @param min_frame skip all data before this PCM frame number; this
  * is used after seeking to skip data in an AVPacket until the exact
  * desired time stamp has been reached
  */
 static DecoderCommand
 ffmpeg_send_packet(Decoder &decoder, InputStream &is,
-		   const AVPacket *packet,
-		   AVCodecContext *codec_context,
-		   const AVStream *stream,
-		   AVFrame *frame,
+		   AVPacket packet,
+		   AVCodecContext &codec_context,
+		   const AVStream &stream,
+		   AVFrame &frame,
 		   uint64_t min_frame, size_t pcm_frame_size,
-		   uint8_t **buffer, int *buffer_size)
+		   FfmpegBuffer &buffer)
 {
 	size_t skip_bytes = 0;
 
-	const auto pts = StreamRelativePts(*packet, *stream);
+	const auto pts = StreamRelativePts(packet, stream);
 	if (pts >= 0) {
 		if (min_frame > 0) {
-			auto cur_frame = PtsToPcmFrame(pts, *stream,
-						       *codec_context);
+			auto cur_frame = PtsToPcmFrame(pts, stream,
+						       codec_context);
 			if (cur_frame < min_frame)
 				skip_bytes = pcm_frame_size * (min_frame - cur_frame);
 		} else
 			decoder_timestamp(decoder,
-					  time_from_ffmpeg(pts, stream->time_base));
+					  FfmpegTimeToDouble(pts,
+							     stream.time_base));
 	}
 
-	AVPacket packet2 = *packet;
-
-	uint8_t *output_buffer;
+	Error error;
 
 	DecoderCommand cmd = DecoderCommand::NONE;
-	while (packet2.size > 0 && cmd == DecoderCommand::NONE) {
-		int audio_size = 0;
+	while (packet.size > 0 && cmd == DecoderCommand::NONE) {
 		int got_frame = 0;
-		int len = avcodec_decode_audio4(codec_context,
-						frame, &got_frame,
-						&packet2);
-		if (len >= 0 && got_frame) {
-			audio_size = copy_interleave_frame(codec_context,
-							   frame,
-							   &output_buffer,
-							   buffer, buffer_size);
-			if (audio_size < 0)
-				len = audio_size;
-		}
-
+		int len = avcodec_decode_audio4(&codec_context,
+						&frame, &got_frame,
+						&packet);
 		if (len < 0) {
 			/* if error, we skip the frame */
-			LogDefault(ffmpeg_domain,
-				   "decoding failed, frame skipped");
+			LogFfmpegError(len, "decoding failed, frame skipped");
 			break;
 		}
 
-		packet2.data += len;
-		packet2.size -= len;
+		packet.data += len;
+		packet.size -= len;
 
-		if (audio_size <= 0)
+		if (!got_frame || frame.nb_samples <= 0)
 			continue;
 
-		const uint8_t *data = output_buffer;
+		auto output_buffer =
+			copy_interleave_frame(codec_context, frame,
+					      buffer, error);
+		if (output_buffer.IsNull()) {
+			/* this must be a serious error,
+			   e.g. OOM */
+			LogError(error);
+			return DecoderCommand::STOP;
+		}
+
 		if (skip_bytes > 0) {
-			if (skip_bytes >= size_t(audio_size)) {
-				skip_bytes -= audio_size;
+			if (skip_bytes >= output_buffer.size) {
+				skip_bytes -= output_buffer.size;
 				continue;
 			}
 
-			data += skip_bytes;
-			audio_size -= skip_bytes;
+			output_buffer.data =
+				(const uint8_t *)output_buffer.data + skip_bytes;
+			output_buffer.size -= skip_bytes;
 			skip_bytes = 0;
 		}
 
 		cmd = decoder_data(decoder, is,
-				   data, audio_size,
-				   codec_context->bit_rate / 1000);
+				   output_buffer.data, output_buffer.size,
+				   codec_context.bit_rate / 1000);
 	}
 	return cmd;
 }
@@ -451,10 +309,8 @@ ffmpeg_sample_format(enum AVSampleFormat sample_fmt)
 static AVInputFormat *
 ffmpeg_probe(Decoder *decoder, InputStream &is)
 {
-	enum {
-		BUFFER_SIZE = 16384,
-		PADDING = 16,
-	};
+	constexpr size_t BUFFER_SIZE = 16384;
+	constexpr size_t PADDING = 16;
 
 	unsigned char buffer[BUFFER_SIZE];
 	size_t nbytes = decoder_read(decoder, is, buffer, BUFFER_SIZE);
@@ -494,85 +350,163 @@ ffmpeg_probe(Decoder *decoder, InputStream &is)
 }
 
 static void
-ffmpeg_decode(Decoder &decoder, InputStream &input)
+FfmpegParseMetaData(AVDictionary &dict, ReplayGainInfo &rg, MixRampInfo &mr)
 {
-	AVInputFormat *input_format = ffmpeg_probe(&decoder, input);
-	if (input_format == nullptr)
-		return;
+	AVDictionaryEntry *i = nullptr;
 
-	FormatDebug(ffmpeg_domain, "detected input format '%s' (%s)",
-		    input_format->name, input_format->long_name);
+	while ((i = av_dict_get(&dict, "", i,
+				AV_DICT_IGNORE_SUFFIX)) != nullptr) {
+		const char *name = i->key;
+		const char *value = i->value;
 
-	AvioStream stream(&decoder, input);
-	if (!stream.Open()) {
-		LogError(ffmpeg_domain, "Failed to open stream");
-		return;
+		if (!ParseReplayGainTag(rg, name, value))
+			ParseMixRampTag(mr, name, value);
 	}
+}
 
-	//ffmpeg works with ours "fileops" helper
-	AVFormatContext *format_context = nullptr;
-	if (mpd_ffmpeg_open_input(&format_context, stream.io,
-				  input.GetURI(),
-				  input_format) != 0) {
-		LogError(ffmpeg_domain, "Open failed");
+static void
+FfmpegParseMetaData(const AVStream &stream,
+		    ReplayGainInfo &rg, MixRampInfo &mr)
+{
+	FfmpegParseMetaData(*stream.metadata, rg, mr);
+}
+
+static void
+FfmpegParseMetaData(const AVFormatContext &format_context, int audio_stream,
+		    ReplayGainInfo &rg, MixRampInfo &mr)
+{
+	assert(audio_stream >= 0);
+
+	FfmpegParseMetaData(*format_context.metadata, rg, mr);
+	FfmpegParseMetaData(*format_context.streams[audio_stream],
+				    rg, mr);
+}
+
+static void
+FfmpegParseMetaData(Decoder &decoder,
+		    const AVFormatContext &format_context, int audio_stream)
+{
+	ReplayGainInfo rg;
+	rg.Clear();
+
+	MixRampInfo mr;
+	mr.Clear();
+
+	FfmpegParseMetaData(format_context, audio_stream, rg, mr);
+
+	if (rg.IsDefined())
+		decoder_replay_gain(decoder, &rg);
+
+	if (mr.IsDefined())
+		decoder_mixramp(decoder, std::move(mr));
+}
+
+static void
+FfmpegScanMetadata(const AVStream &stream,
+		   const tag_handler &handler, void *handler_ctx)
+{
+	FfmpegScanDictionary(stream.metadata, &handler, handler_ctx);
+}
+
+static void
+FfmpegScanMetadata(const AVFormatContext &format_context, int audio_stream,
+		   const tag_handler &handler, void *handler_ctx)
+{
+	assert(audio_stream >= 0);
+
+	FfmpegScanDictionary(format_context.metadata, &handler, handler_ctx);
+	FfmpegScanMetadata(*format_context.streams[audio_stream],
+			   handler, handler_ctx);
+}
+
+#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(56, 1, 0)
+
+static void
+FfmpegScanTag(const AVFormatContext &format_context, int audio_stream,
+	      TagBuilder &tag)
+{
+	FfmpegScanMetadata(format_context, audio_stream,
+			   full_tag_handler, &tag);
+}
+
+/**
+ * Check if a new stream tag was received and pass it to
+ * decoder_tag().
+ */
+static void
+FfmpegCheckTag(Decoder &decoder, InputStream &is,
+	       AVFormatContext &format_context, int audio_stream)
+{
+	AVStream &stream = *format_context.streams[audio_stream];
+	if ((stream.event_flags & AVSTREAM_EVENT_FLAG_METADATA_UPDATED) == 0)
+		/* no new metadata */
 		return;
-	}
 
+	/* clear the flag */
+	stream.event_flags &= ~AVSTREAM_EVENT_FLAG_METADATA_UPDATED;
+
+	TagBuilder tag;
+	FfmpegScanTag(format_context, audio_stream, tag);
+	if (!tag.IsEmpty())
+		decoder_tag(decoder, is, tag.Commit());
+}
+
+#endif
+
+static void
+FfmpegDecode(Decoder &decoder, InputStream &input,
+	     AVFormatContext &format_context)
+{
 	const int find_result =
-		avformat_find_stream_info(format_context, nullptr);
+		avformat_find_stream_info(&format_context, nullptr);
 	if (find_result < 0) {
 		LogError(ffmpeg_domain, "Couldn't find stream info");
-		avformat_close_input(&format_context);
 		return;
 	}
 
 	int audio_stream = ffmpeg_find_audio_stream(format_context);
 	if (audio_stream == -1) {
 		LogError(ffmpeg_domain, "No audio stream inside");
-		avformat_close_input(&format_context);
 		return;
 	}
 
-	AVStream *av_stream = format_context->streams[audio_stream];
+	AVStream &av_stream = *format_context.streams[audio_stream];
 
-	AVCodecContext *codec_context = av_stream->codec;
+	AVCodecContext &codec_context = *av_stream.codec;
 
 #if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(54, 25, 0)
 	const AVCodecDescriptor *codec_descriptor =
-		avcodec_descriptor_get(codec_context->codec_id);
+		avcodec_descriptor_get(codec_context.codec_id);
 	if (codec_descriptor != nullptr)
 		FormatDebug(ffmpeg_domain, "codec '%s'",
 			    codec_descriptor->name);
 #else
-	if (codec_context->codec_name[0] != 0)
+	if (codec_context.codec_name[0] != 0)
 		FormatDebug(ffmpeg_domain, "codec '%s'",
-			    codec_context->codec_name);
+			    codec_context.codec_name);
 #endif
 
-	AVCodec *codec = avcodec_find_decoder(codec_context->codec_id);
+	AVCodec *codec = avcodec_find_decoder(codec_context.codec_id);
 
 	if (!codec) {
 		LogError(ffmpeg_domain, "Unsupported audio codec");
-		avformat_close_input(&format_context);
 		return;
 	}
 
 	const SampleFormat sample_format =
-		ffmpeg_sample_format(codec_context->sample_fmt);
+		ffmpeg_sample_format(codec_context.sample_fmt);
 	if (sample_format == SampleFormat::UNDEFINED) {
 		// (error message already done by ffmpeg_sample_format())
-		avformat_close_input(&format_context);
 		return;
 	}
 
 	Error error;
 	AudioFormat audio_format;
 	if (!audio_format_init_checked(audio_format,
-				       codec_context->sample_rate,
+				       codec_context.sample_rate,
 				       sample_format,
-				       codec_context->channels, error)) {
+				       codec_context.channels, error)) {
 		LogError(error);
-		avformat_close_input(&format_context);
 		return;
 	}
 
@@ -581,22 +515,20 @@ ffmpeg_decode(Decoder &decoder, InputStream &input)
 	   values into AVCodecContext.channels - a change that will be
 	   reverted later by avcodec_decode_audio3() */
 
-	const int open_result = avcodec_open2(codec_context, codec, nullptr);
+	const int open_result = avcodec_open2(&codec_context, codec, nullptr);
 	if (open_result < 0) {
 		LogError(ffmpeg_domain, "Could not open codec");
-		avformat_close_input(&format_context);
 		return;
 	}
 
 	const SignedSongTime total_time =
-		format_context->duration != (int64_t)AV_NOPTS_VALUE
-		? SignedSongTime::FromScale<uint64_t>(format_context->duration,
-						      AV_TIME_BASE)
-		: SignedSongTime::Negative();
+		FromFfmpegTimeChecked(av_stream.duration, av_stream.time_base);
 
 	decoder_initialized(decoder, audio_format,
 			    input.IsSeekable(), total_time);
 
+	FfmpegParseMetaData(decoder, format_context, audio_stream);
+
 #if LIBAVUTIL_VERSION_MAJOR >= 53
 	AVFrame *frame = av_frame_alloc();
 #else
@@ -604,29 +536,31 @@ ffmpeg_decode(Decoder &decoder, InputStream &input)
 #endif
 	if (!frame) {
 		LogError(ffmpeg_domain, "Could not allocate frame");
-		avformat_close_input(&format_context);
 		return;
 	}
 
-	uint8_t *interleaved_buffer = nullptr;
-	int interleaved_buffer_size = 0;
+	FfmpegBuffer interleaved_buffer;
 
 	uint64_t min_frame = 0;
 
 	DecoderCommand cmd;
 	do {
 		AVPacket packet;
-		if (av_read_frame(format_context, &packet) < 0)
+		if (av_read_frame(&format_context, &packet) < 0)
 			/* end of file */
 			break;
 
+#if LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(56, 1, 0)
+		FfmpegCheckTag(decoder, input, format_context, audio_stream);
+#endif
+
 		if (packet.stream_index == audio_stream) {
 			cmd = ffmpeg_send_packet(decoder, input,
-						 &packet, codec_context,
+						 packet, codec_context,
 						 av_stream,
-						 frame,
+						 *frame,
 						 min_frame, audio_format.GetFrameSize(),
-						 &interleaved_buffer, &interleaved_buffer_size);
+						 interleaved_buffer);
 			min_frame = 0;
 		} else
 			cmd = decoder_get_command(decoder);
@@ -635,19 +569,18 @@ ffmpeg_decode(Decoder &decoder, InputStream &input)
 
 		if (cmd == DecoderCommand::SEEK) {
 			int64_t where =
-				time_to_ffmpeg(decoder_seek_time(decoder),
-					       av_stream->time_base) +
-				start_time_fallback(*av_stream);
+				ToFfmpegTime(decoder_seek_time(decoder),
+					     av_stream.time_base) +
+				start_time_fallback(av_stream);
 
 			/* AVSEEK_FLAG_BACKWARD asks FFmpeg to seek to
 			   the packet boundary before the seek time
 			   stamp, not after */
-
-			if (av_seek_frame(format_context, audio_stream, where,
+			if (av_seek_frame(&format_context, audio_stream, where,
 					  AVSEEK_FLAG_ANY|AVSEEK_FLAG_BACKWARD) < 0)
 				decoder_seek_error(decoder);
 			else {
-				avcodec_flush_buffers(codec_context);
+				avcodec_flush_buffers(&codec_context);
 				min_frame = decoder_seek_where_frame(decoder);
 				decoder_command_finished(decoder);
 			}
@@ -659,15 +592,63 @@ ffmpeg_decode(Decoder &decoder, InputStream &input)
 #elif LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(54, 28, 0)
 	avcodec_free_frame(&frame);
 #else
-	av_freep(&frame);
+	av_free(frame);
 #endif
-	av_freep(&interleaved_buffer);
 
-	avcodec_close(codec_context);
+	avcodec_close(&codec_context);
+}
+
+static void
+ffmpeg_decode(Decoder &decoder, InputStream &input)
+{
+	AVInputFormat *input_format = ffmpeg_probe(&decoder, input);
+	if (input_format == nullptr)
+		return;
+
+	FormatDebug(ffmpeg_domain, "detected input format '%s' (%s)",
+		    input_format->name, input_format->long_name);
+
+	AvioStream stream(&decoder, input);
+	if (!stream.Open()) {
+		LogError(ffmpeg_domain, "Failed to open stream");
+		return;
+	}
+
+	AVFormatContext *format_context =
+		FfmpegOpenInput(stream.io, input.GetURI(), input_format);
+	if (format_context == nullptr) {
+		LogError(ffmpeg_domain, "Open failed");
+		return;
+	}
+
+	FfmpegDecode(decoder, input, *format_context);
 	avformat_close_input(&format_context);
 }
 
-//no tag reading in ffmpeg, check if playable
+static bool
+FfmpegScanStream(AVFormatContext &format_context,
+		 const struct tag_handler &handler, void *handler_ctx)
+{
+	const int find_result =
+		avformat_find_stream_info(&format_context, nullptr);
+	if (find_result < 0)
+		return false;
+
+	const int audio_stream = ffmpeg_find_audio_stream(format_context);
+	if (audio_stream < 0)
+		return false;
+
+	const AVStream &stream = *format_context.streams[audio_stream];
+	if (stream.duration != (int64_t)AV_NOPTS_VALUE)
+		tag_handler_invoke_duration(&handler, handler_ctx,
+					    FromFfmpegTime(stream.duration,
+							   stream.time_base));
+
+	FfmpegScanMetadata(format_context, audio_stream, handler, handler_ctx);
+
+	return true;
+}
+
 static bool
 ffmpeg_scan_stream(InputStream &is,
 		   const struct tag_handler *handler, void *handler_ctx)
@@ -680,33 +661,14 @@ ffmpeg_scan_stream(InputStream &is,
 	if (!stream.Open())
 		return false;
 
-	AVFormatContext *f = nullptr;
-	if (mpd_ffmpeg_open_input(&f, stream.io, is.GetURI(),
-				  input_format) != 0)
-		return false;
-
-	const int find_result =
-		avformat_find_stream_info(f, nullptr);
-	if (find_result < 0) {
-		avformat_close_input(&f);
+	AVFormatContext *f =
+		FfmpegOpenInput(stream.io, is.GetURI(), input_format);
+	if (f == nullptr)
 		return false;
-	}
-
-	if (f->duration != (int64_t)AV_NOPTS_VALUE) {
-		const auto duration =
-			SongTime::FromScale<uint64_t>(f->duration,
-						      AV_TIME_BASE);
-		tag_handler_invoke_duration(handler, handler_ctx, duration);
-	}
-
-	ffmpeg_scan_dictionary(f->metadata, handler, handler_ctx);
-	int idx = ffmpeg_find_audio_stream(f);
-	if (idx >= 0)
-		ffmpeg_scan_dictionary(f->streams[idx]->metadata,
-				       handler, handler_ctx);
 
+	bool result = FfmpegScanStream(*f, *handler, handler_ctx);
 	avformat_close_input(&f);
-	return true;
+	return result;
 }
 
 /**