Switch to Libav sample formats everywhere.

Drop 24bit format for now. It should be restored later by properly
distinguishing between internal and packed formats.

36 files changed, 316 insertions, 600 deletions

diff --git a/src/audio_check.c b/src/audio_check.c
index a9aa2dd8..4874e2da 100644
--- a/src/audio_check.c
+++ b/src/audio_check.c
@@ -22,53 +22,53 @@
 
 #include <assert.h>
 
-bool
-audio_check_sample_rate(unsigned long sample_rate, GError **error_r)
+#include <libavutil/samplefmt.h>
+
+bool audio_check_sample_rate(unsigned long sample_rate, GError **error_r)
 {
-	if (!audio_valid_sample_rate(sample_rate)) {
-		g_set_error(error_r, audio_format_quark(), 0,
-			    "Invalid sample rate: %lu", sample_rate);
-		return false;
-	}
+    if (!audio_valid_sample_rate(sample_rate)) {
+        g_set_error(error_r, audio_format_quark(), 0,
+                    "Invalid sample rate: %lu", sample_rate);
+        return false;
+    }
 
-	return true;
+    return true;
 }
 
-bool
-audio_check_sample_format(enum sample_format sample_format, GError **error_r)
+    bool
+audio_check_sample_format(enum AVSampleFormat sample_format, GError **error_r)
 {
-	if (!audio_valid_sample_format(sample_format)) {
-		g_set_error(error_r, audio_format_quark(), 0,
-			    "Invalid sample format: %u", sample_format);
-		return false;
-	}
+    if (!audio_valid_sample_format(sample_format)) {
+        g_set_error(error_r, audio_format_quark(), 0,
+                    "Invalid sample format: %u", sample_format);
+        return false;
+    }
 
-	return true;
+    return true;
 }
 
-bool
+    bool
 audio_check_channel_count(unsigned channels, GError **error_r)
 {
-	if (!audio_valid_channel_count(channels)) {
-		g_set_error(error_r, audio_format_quark(), 0,
-			    "Invalid channel count: %u", channels);
-		return false;
-	}
+    if (!audio_valid_channel_count(channels)) {
+        g_set_error(error_r, audio_format_quark(), 0,
+                    "Invalid channel count: %u", channels);
+        return false;
+    }
 
-	return true;
+    return true;
 }
 
-bool
-audio_format_init_checked(struct audio_format *af, unsigned long sample_rate,
-			  enum sample_format sample_format, unsigned channels,
-			  GError **error_r)
+bool audio_format_init_checked(struct audio_format *af, unsigned long sample_rate,
+                               enum AVSampleFormat sample_format, unsigned channels,
+                               GError **error_r)
 {
-	if (audio_check_sample_rate(sample_rate, error_r) &&
-	    audio_check_sample_format(sample_format, error_r) &&
-	    audio_check_channel_count(channels, error_r)) {
-		audio_format_init(af, sample_rate, sample_format, channels);
-		assert(audio_format_valid(af));
-		return true;
-	} else
-		return false;
+    if (audio_check_sample_rate(sample_rate, error_r) &&
+        audio_check_sample_format(sample_format, error_r) &&
+        audio_check_channel_count(channels, error_r)) {
+        audio_format_init(af, sample_rate, sample_format, channels);
+        assert(audio_format_valid(af));
+        return true;
+    } else
+        return false;
 }
diff --git a/src/audio_check.h b/src/audio_check.h
index 9f71cf9c..17b8eb5b 100644
--- a/src/audio_check.h
+++ b/src/audio_check.h
@@ -25,31 +25,27 @@
 #include <glib.h>
 #include <stdbool.h>
 
+#include <libavutil/samplefmt.h>
+
 /**
  * The GLib quark used for errors reported by this library.
  */
-G_GNUC_CONST
-static inline GQuark
-audio_format_quark(void)
+static inline GQuark audio_format_quark(void)
 {
-	return g_quark_from_static_string("audio_format");
+    return g_quark_from_static_string("audio_format");
 }
 
-bool
-audio_check_sample_rate(unsigned long sample_rate, GError **error_r);
+bool audio_check_sample_rate(unsigned long sample_rate, GError **error_r);
 
-bool
-audio_check_sample_format(enum sample_format, GError **error_r);
+bool audio_check_sample_format(enum AVSampleFormat, GError **error_r);
 
-bool
-audio_check_channel_count(unsigned sample_format, GError **error_r);
+bool audio_check_channel_count(unsigned sample_format, GError **error_r);
 
 /**
  * Wrapper for audio_format_init(), which checks all attributes.
  */
-bool
-audio_format_init_checked(struct audio_format *af, unsigned long sample_rate,
-			  enum sample_format sample_format, unsigned channels,
-			  GError **error_r);
+bool audio_format_init_checked(struct audio_format *af, unsigned long sample_rate,
+                               enum AVSampleFormat sample_format, unsigned channels,
+                               GError **error_r);
 
 #endif
diff --git a/src/audio_format.c b/src/audio_format.c
index 1ac29d1c..f10370fc 100644
--- a/src/audio_format.c
+++ b/src/audio_format.c
@@ -34,7 +34,7 @@ audio_format_mask_apply(struct audio_format *af,
 	if (mask->sample_rate != 0)
 		af->sample_rate = mask->sample_rate;
 
-	if (mask->format != SAMPLE_FORMAT_UNDEFINED)
+	if (mask->format != AV_SAMPLE_FMT_NONE)
 		af->format = mask->format;
 
 	if (mask->channels != 0)
@@ -43,32 +43,20 @@ audio_format_mask_apply(struct audio_format *af,
 	assert(audio_format_valid(af));
 }
 
-const char *
-sample_format_to_string(enum sample_format format)
+const char * sample_format_to_string(enum AVSampleFormat format)
 {
 	switch (format) {
-	case SAMPLE_FORMAT_UNDEFINED:
-		return "?";
-
-	case SAMPLE_FORMAT_S8:
+    case AV_SAMPLE_FMT_U8:
 		return "8";
-
-	case SAMPLE_FORMAT_S16:
+    case AV_SAMPLE_FMT_S16:
 		return "16";
-
-	case SAMPLE_FORMAT_S24_P32:
-		return "24";
-
-	case SAMPLE_FORMAT_S32:
+    case AV_SAMPLE_FMT_S32:
 		return "32";
-
-	case SAMPLE_FORMAT_FLOAT:
+    case AV_SAMPLE_FMT_FLT:
 		return "f";
+    default:
+		return "?";
 	}
-
-	/* unreachable */
-	assert(false);
-	return "?";
 }
 
 const char *
@@ -79,20 +67,8 @@ audio_format_to_string(const struct audio_format *af,
 	assert(s != NULL);
 
 	snprintf(s->buffer, sizeof(s->buffer), "%u:%s:%u",
-		 af->sample_rate, sample_format_to_string(af->format),
+		 af->sample_rate, av_get_sample_fmt_name(af->format),
 		 af->channels);
 
 	return s->buffer;
 }
-
-enum AVSampleFormat sample_fmt_native_to_libav(enum sample_format sample_fmt)
-{
-    switch (sample_fmt) {
-    case SAMPLE_FORMAT_S8:      return AV_SAMPLE_FMT_U8;
-    case SAMPLE_FORMAT_S16:     return AV_SAMPLE_FMT_S16;
-    case SAMPLE_FORMAT_S24_P32:
-    case SAMPLE_FORMAT_S32:     return AV_SAMPLE_FMT_S32;
-    case SAMPLE_FORMAT_FLOAT:   return AV_SAMPLE_FMT_FLT;
-    default:                    return AV_SAMPLE_FMT_NONE;
-    }
-}
diff --git a/src/audio_format.h b/src/audio_format.h
index bb79de39..021aa10a 100644
--- a/src/audio_format.h
+++ b/src/audio_format.h
@@ -27,27 +27,6 @@
 
 #include <libavutil/samplefmt.h>
 
-enum sample_format {
-	SAMPLE_FORMAT_UNDEFINED = 0,
-
-	SAMPLE_FORMAT_S8,
-	SAMPLE_FORMAT_S16,
-
-	/**
-	 * Signed 24 bit integer samples, packed in 32 bit integers
-	 * (the most significant byte is filled with the sign bit).
-	 */
-	SAMPLE_FORMAT_S24_P32,
-
-	SAMPLE_FORMAT_S32,
-
-	/**
-	 * 32 bit floating point samples in the host's format.  The
-	 * range is -1.0f to +1.0f.
-	 */
-	SAMPLE_FORMAT_FLOAT,
-};
-
 static const unsigned MAX_CHANNELS = 8;
 
 /**
@@ -65,7 +44,7 @@ struct audio_format {
 	 * The format samples are stored in.  See the #sample_format
 	 * enum for valid values.
 	 */
-	uint8_t format;
+	enum AVSampleFormat format;
 
 	/**
 	 * The number of channels.  Only mono (1) and stereo (2) are
@@ -88,7 +67,7 @@ struct audio_format_string {
 static inline void audio_format_clear(struct audio_format *af)
 {
 	af->sample_rate = 0;
-	af->format = SAMPLE_FORMAT_UNDEFINED;
+	af->format = AV_SAMPLE_FMT_NONE;
 	af->channels = 0;
 }
 
@@ -98,11 +77,11 @@ static inline void audio_format_clear(struct audio_format *af)
  */
 static inline void audio_format_init(struct audio_format *af,
 				     uint32_t sample_rate,
-				     enum sample_format format, uint8_t channels)
+				     enum AVSampleFormat format, uint8_t channels)
 {
-	af->sample_rate = sample_rate;
-	af->format = (uint8_t)format;
-	af->channels = channels;
+    af->sample_rate = sample_rate;
+    af->format      = format;
+    af->channels    = channels;
 }
 
 /**
@@ -119,11 +98,10 @@ static inline bool audio_format_defined(const struct audio_format *af)
  * attributes are defined.  This is more complete than
  * audio_format_defined(), but slower.
  */
-static inline bool
-audio_format_fully_defined(const struct audio_format *af)
+static inline bool audio_format_fully_defined(const struct audio_format *af)
 {
-	return af->sample_rate != 0 && af->format != SAMPLE_FORMAT_UNDEFINED &&
-		af->channels != 0;
+    return af->sample_rate != 0 && af->format != AV_SAMPLE_FMT_NONE &&
+           af->channels != 0;
 }
 
 /**
@@ -133,8 +111,8 @@ audio_format_fully_defined(const struct audio_format *af)
 static inline bool
 audio_format_mask_defined(const struct audio_format *af)
 {
-	return af->sample_rate != 0 || af->format != SAMPLE_FORMAT_UNDEFINED ||
-		af->channels != 0;
+	return af->sample_rate != 0 || af->format != AV_SAMPLE_FMT_NONE ||
+		   af->channels != 0;
 }
 
 /**
@@ -153,22 +131,9 @@ audio_valid_sample_rate(unsigned sample_rate)
  *
  * @param bits the number of significant bits per sample
  */
-static inline bool
-audio_valid_sample_format(enum sample_format format)
+static inline bool audio_valid_sample_format(enum AVSampleFormat format)
 {
-	switch (format) {
-	case SAMPLE_FORMAT_S8:
-	case SAMPLE_FORMAT_S16:
-	case SAMPLE_FORMAT_S24_P32:
-	case SAMPLE_FORMAT_S32:
-	case SAMPLE_FORMAT_FLOAT:
-		return true;
-
-	case SAMPLE_FORMAT_UNDEFINED:
-		break;
-	}
-
-	return false;
+    return format != AV_SAMPLE_FMT_NONE;
 }
 
 /**
@@ -184,26 +149,24 @@ audio_valid_channel_count(unsigned channels)
  * Returns false if the format is not valid for playback with MPD.
  * This function performs some basic validity checks.
  */
-G_GNUC_PURE
 static inline bool audio_format_valid(const struct audio_format *af)
 {
-	return audio_valid_sample_rate(af->sample_rate) &&
-		audio_valid_sample_format((enum sample_format)af->format) &&
-		audio_valid_channel_count(af->channels);
+    return audio_valid_sample_rate(af->sample_rate) &&
+           audio_valid_sample_format(af->format)    &&
+        audio_valid_channel_count(af->channels);
 }
 
 /**
  * Returns false if the format mask is not valid for playback with
  * MPD.  This function performs some basic validity checks.
  */
-G_GNUC_PURE
 static inline bool audio_format_mask_valid(const struct audio_format *af)
 {
-	return (af->sample_rate == 0 ||
-		audio_valid_sample_rate(af->sample_rate)) &&
-		(af->format == SAMPLE_FORMAT_UNDEFINED ||
-		 audio_valid_sample_format((enum sample_format)af->format)) &&
-		(af->channels == 0 || audio_valid_channel_count(af->channels));
+    return (af->sample_rate == 0 ||
+            audio_valid_sample_rate(af->sample_rate)) &&
+           (af->format == AV_SAMPLE_FMT_NONE ||
+            audio_valid_sample_format(af->format)) &&
+           (af->channels == 0 || audio_valid_channel_count(af->channels));
 }
 
 static inline bool audio_format_equals(const struct audio_format *a,
@@ -214,58 +177,21 @@ static inline bool audio_format_equals(const struct audio_format *a,
 		a->channels == b->channels;
 }
 
-void
-audio_format_mask_apply(struct audio_format *af,
-			const struct audio_format *mask);
-
-G_GNUC_CONST
-static inline unsigned
-sample_format_size(enum sample_format format)
-{
-	switch (format) {
-	case SAMPLE_FORMAT_S8:
-		return 1;
-
-	case SAMPLE_FORMAT_S16:
-		return 2;
-
-	case SAMPLE_FORMAT_S24_P32:
-	case SAMPLE_FORMAT_S32:
-	case SAMPLE_FORMAT_FLOAT:
-		return 4;
-
-	case SAMPLE_FORMAT_UNDEFINED:
-		return 0;
-	}
-
-	assert(false);
-	return 0;
-}
-
-/**
- * Returns the size of each (mono) sample in bytes.
- */
-G_GNUC_PURE
-static inline unsigned audio_format_sample_size(const struct audio_format *af)
-{
-	return sample_format_size((enum sample_format)af->format);
-}
+void audio_format_mask_apply(struct audio_format *af,
+                             const struct audio_format *mask);
 
 /**
  * Returns the size of each full frame in bytes.
  */
-G_GNUC_PURE
-static inline unsigned
-audio_format_frame_size(const struct audio_format *af)
+static inline unsigned audio_format_frame_size(const struct audio_format *af)
 {
-	return audio_format_sample_size(af) * af->channels;
+	return av_get_bytes_per_sample(af->format) * af->channels;
 }
 
 /**
  * Returns the floating point factor which converts a time span to a
  * storage size in bytes.
  */
-G_GNUC_PURE
 static inline double audio_format_time_to_size(const struct audio_format *af)
 {
 	return af->sample_rate * audio_format_frame_size(af);
@@ -278,9 +204,7 @@ static inline double audio_format_time_to_size(const struct audio_format *af)
  * @param format a #sample_format enum value
  * @return the string
  */
-G_GNUC_PURE G_GNUC_MALLOC
-const char *
-sample_format_to_string(enum sample_format format);
+const char *sample_format_to_string(enum AVSampleFormat format);
 
 /**
  * Renders the #audio_format object into a string, e.g. for printing
@@ -290,11 +214,7 @@ sample_format_to_string(enum sample_format format);
  * @param s a buffer to print into
  * @return the string, or NULL if the #audio_format object is invalid
  */
-G_GNUC_PURE G_GNUC_MALLOC
-const char *
-audio_format_to_string(const struct audio_format *af,
-		       struct audio_format_string *s);
-
-enum AVSampleFormat sample_fmt_native_to_libav(enum sample_format);
+const char *audio_format_to_string(const struct audio_format *af,
+                                   struct audio_format_string *s);
 
 #endif
diff --git a/src/audio_parser.c b/src/audio_parser.c
index c37effff..99a448cd 100644
--- a/src/audio_parser.c
+++ b/src/audio_parser.c
@@ -32,6 +32,8 @@
 #include <string.h>
 #include <stdlib.h>
 
+#include <libavutil/samplefmt.h>
+
 /**
  * The GLib quark used for errors reported by this library.
  */
@@ -67,23 +69,22 @@ parse_sample_rate(const char *src, bool mask, uint32_t *sample_rate_r,
 	return true;
 }
 
-static bool
-parse_sample_format(const char *src, bool mask,
-		    enum sample_format *sample_format_r,
-		    const char **endptr_r, GError **error_r)
+static bool parse_sample_format(const char *src, bool mask,
+                                enum AVSampleFormat *sample_format_r,
+                                const char **endptr_r, GError **error_r)
 {
 	unsigned long value;
 	char *endptr;
-	enum sample_format sample_format;
+	enum AVSampleFormat sample_format;
 
 	if (mask && *src == '*') {
-		*sample_format_r = SAMPLE_FORMAT_UNDEFINED;
+		*sample_format_r = AV_SAMPLE_FMT_NONE;
 		*endptr_r = src + 1;
 		return true;
 	}
 
 	if (*src == 'f') {
-		*sample_format_r = SAMPLE_FORMAT_FLOAT;
+		*sample_format_r = AV_SAMPLE_FMT_FLT;
 		*endptr_r = src + 1;
 		return true;
 	}
@@ -97,23 +98,15 @@ parse_sample_format(const char *src, bool mask,
 
 	switch (value) {
 	case 8:
-		sample_format = SAMPLE_FORMAT_S8;
+		sample_format = AV_SAMPLE_FMT_U8;
 		break;
 
 	case 16:
-		sample_format = SAMPLE_FORMAT_S16;
-		break;
-
-	case 24:
-		if (memcmp(endptr, "_3", 2) == 0)
-			/* for backwards compatibility */
-			endptr += 2;
-
-		sample_format = SAMPLE_FORMAT_S24_P32;
+		sample_format = AV_SAMPLE_FMT_S16;
 		break;
 
 	case 32:
-		sample_format = SAMPLE_FORMAT_S32;
+		sample_format = AV_SAMPLE_FMT_S32;
 		break;
 
 	default:
@@ -160,18 +153,12 @@ audio_format_parse(struct audio_format *dest, const char *src,
 		   bool mask, GError **error_r)
 {
 	uint32_t rate;
-	enum sample_format sample_format;
+	enum AVSampleFormat sample_format;
 	uint8_t channels;
 
 	audio_format_clear(dest);
 
 	/* parse sample rate */
-
-#if GCC_CHECK_VERSION(4,7)
-	/* workaround -Wmaybe-uninitialized false positive */
-	rate = 0;
-#endif
-
 	if (!parse_sample_rate(src, mask, &rate, &src, error_r))
 		return false;
 
@@ -182,12 +169,6 @@ audio_format_parse(struct audio_format *dest, const char *src,
 	}
 
 	/* parse sample format */
-
-#if GCC_CHECK_VERSION(4,7)
-	/* workaround -Wmaybe-uninitialized false positive */
-	sample_format = SAMPLE_FORMAT_UNDEFINED;
-#endif
-
 	if (!parse_sample_format(src, mask, &sample_format, &src, error_r))
 		return false;
 
diff --git a/src/chunk.c b/src/chunk.c
index a7f11c3f..b9dc6c80 100644
--- a/src/chunk.c
+++ b/src/chunk.c
@@ -24,6 +24,7 @@
 
 #include <libavutil/frame.h>
 #include <libavutil/mem.h>
+#include <libavutil/samplefmt.h>
 
 #include <assert.h>
 
@@ -34,6 +35,9 @@ music_chunk_init(struct music_chunk *chunk)
 	chunk->frame = NULL;
 	chunk->tag = NULL;
 	chunk->replay_gain_serial = 0;
+#ifndef NDEBUG
+    chunk->audio_format.format = AV_SAMPLE_FMT_NONE;
+#endif
 }
 
 struct music_chunk *music_chunk_alloc(void)
diff --git a/src/decoder/libav_decoder_plugin.c b/src/decoder/libav_decoder_plugin.c
index 05b9b2fb..a1e05b6b 100644
--- a/src/decoder/libav_decoder_plugin.c
+++ b/src/decoder/libav_decoder_plugin.c
@@ -42,6 +42,7 @@
 #include <libavutil/mathematics.h>
 #include <libavutil/dict.h>
 #include <libavutil/opt.h>
+#include <libavutil/samplefmt.h>
 
 #undef G_LOG_DOMAIN
 #define G_LOG_DOMAIN "libav"
@@ -203,15 +204,6 @@ static enum decoder_command libav_send_packet(struct decoder *decoder,
     return cmd;
 }
 
-static enum sample_format libav_sample_format(const AVCodecContext *codec_context)
-{
-    switch (codec_context->sample_fmt) {
-    case AV_SAMPLE_FMT_S16: return SAMPLE_FORMAT_S16;
-    case AV_SAMPLE_FMT_S32: return SAMPLE_FORMAT_S32;
-    default:                return SAMPLE_FORMAT_UNDEFINED;
-    }
-}
-
 static void libav_decode(struct decoder *decoder, struct input_stream *input)
 {
     LibavDecContext s = { .decoder = decoder };
@@ -236,7 +228,7 @@ static void libav_decode(struct decoder *decoder, struct input_stream *input)
 
     if (!audio_format_init_checked(&audio_format,
                                    dec->sample_rate,
-                                   libav_sample_format(dec),
+                                   dec->sample_fmt,
                                    dec->channels, &error)) {
         g_warning("%s", error->message);
         g_error_free(error);
diff --git a/src/decoder_api.c b/src/decoder_api.c
index 939e4470..662b9d8e 100644
--- a/src/decoder_api.c
+++ b/src/decoder_api.c
@@ -398,6 +398,9 @@ enum decoder_command decoder_data(struct decoder *decoder,
     chunk->frame    = frame;
     chunk->bit_rate = kbit_rate;
     chunk->times    = decoder->timestamp - dc->song->start_ms / 1000.0;
+#ifndef NDEBUG
+    chunk->audio_format = dc->out_audio_format;
+#endif
 
     frame = NULL;
 
diff --git a/src/decoder_internal.c b/src/decoder_internal.c
index 5078591b..cd8f03c1 100644
--- a/src/decoder_internal.c
+++ b/src/decoder_internal.c
@@ -56,7 +56,7 @@ struct music_chunk *decoder_get_chunk(struct decoder *decoder)
     assert(decoder != NULL);
 
     do {
-        if (music_pipe_size(dc->pipe) >= dc->buffer_samples) {
+        if (music_pipe_size(dc->pipe) <= dc->buffer_samples) {
             chunk = music_chunk_alloc();
             if (!chunk)
                 return NULL;
diff --git a/src/encoder/flac_encoder.c b/src/encoder/flac_encoder.c
index e32588e2..d5b9ae26 100644
--- a/src/encoder/flac_encoder.c
+++ b/src/encoder/flac_encoder.c
@@ -173,21 +173,17 @@ flac_encoder_open(struct encoder *_encoder, struct audio_format *audio_format,
 
 	/* FIXME: flac should support 32bit as well */
 	switch (audio_format->format) {
-	case SAMPLE_FORMAT_S8:
+    case AV_SAMPLE_FMT_U8:
 		bits_per_sample = 8;
 		break;
 
-	case SAMPLE_FORMAT_S16:
+    case AV_SAMPLE_FMT_S16:
 		bits_per_sample = 16;
 		break;
 
-	case SAMPLE_FORMAT_S24_P32:
-		bits_per_sample = 24;
-		break;
-
 	default:
-		bits_per_sample = 24;
-		audio_format->format = SAMPLE_FORMAT_S24_P32;
+		bits_per_sample = 16;
+		audio_format->format = AV_SAMPLE_FMT_S16;
 	}
 
 	/* allocate the encoder */
@@ -291,24 +287,17 @@ flac_encoder_write(struct encoder *_encoder,
 	num_samples = num_frames * encoder->audio_format.channels;
 
 	switch (encoder->audio_format.format) {
-	case SAMPLE_FORMAT_S8:
+    case AV_SAMPLE_FMT_U8:
 		exbuffer = pcm_buffer_get(&encoder->expand_buffer, length*4);
 		pcm8_to_flac(exbuffer, data, num_samples);
 		buffer = exbuffer;
 		break;
 
-	case SAMPLE_FORMAT_S16:
+    case AV_SAMPLE_FMT_S16:
 		exbuffer = pcm_buffer_get(&encoder->expand_buffer, length*2);
 		pcm16_to_flac(exbuffer, data, num_samples);
 		buffer = exbuffer;
 		break;
-
-	case SAMPLE_FORMAT_S24_P32:
-	case SAMPLE_FORMAT_S32:
-		/* nothing need to be done; format is the same for
-		   both mpd and libFLAC */
-		buffer = data;
-		break;
 	}
 
 	/* feed samples to encoder */
diff --git a/src/encoder/lame_encoder.c b/src/encoder/lame_encoder.c
index 3bb99ea2..e7c3b5a7 100644
--- a/src/encoder/lame_encoder.c
+++ b/src/encoder/lame_encoder.c
@@ -26,6 +26,8 @@
 #include <assert.h>
 #include <string.h>
 
+#include <libavutil/samplefmt.h>
+
 struct lame_encoder {
 	struct encoder encoder;
 
@@ -192,7 +194,7 @@ lame_encoder_open(struct encoder *_encoder, struct audio_format *audio_format,
 {
 	struct lame_encoder *encoder = (struct lame_encoder *)_encoder;
 
-	audio_format->format = SAMPLE_FORMAT_S16;
+	audio_format->format = AV_SAMPLE_FMT_S16;
 	audio_format->channels = 2;
 
 	encoder->audio_format = *audio_format;
diff --git a/src/encoder/twolame_encoder.c b/src/encoder/twolame_encoder.c
index 934b2ab2..cdbe1f1b 100644
--- a/src/encoder/twolame_encoder.c
+++ b/src/encoder/twolame_encoder.c
@@ -26,6 +26,8 @@
 #include <assert.h>
 #include <string.h>
 
+#include <libavutil/samplefmt.h>
+
 struct twolame_encoder {
 	struct encoder encoder;
 
@@ -192,7 +194,7 @@ twolame_encoder_open(struct encoder *_encoder, struct audio_format *audio_format
 {
 	struct twolame_encoder *encoder = (struct twolame_encoder *)_encoder;
 
-	audio_format->format = SAMPLE_FORMAT_S16;
+	audio_format->format = AV_SAMPLE_FMT_S16;
 	audio_format->channels = 2;
 
 	encoder->audio_format = *audio_format;
diff --git a/src/encoder/vorbis_encoder.c b/src/encoder/vorbis_encoder.c
index fcf2b513..728d1f76 100644
--- a/src/encoder/vorbis_encoder.c
+++ b/src/encoder/vorbis_encoder.c
@@ -28,6 +28,8 @@
 
 #include <assert.h>
 
+#include <libavutil/samplefmt.h>
+
 #undef G_LOG_DOMAIN
 #define G_LOG_DOMAIN "vorbis_encoder"
 
@@ -213,7 +215,7 @@ vorbis_encoder_open(struct encoder *_encoder,
 	struct vorbis_encoder *encoder = (struct vorbis_encoder *)_encoder;
 	bool ret;
 
-	audio_format->format = SAMPLE_FORMAT_S16;
+	audio_format->format = AV_SAMPLE_FMT_S16;
 
 	encoder->audio_format = *audio_format;
 
diff --git a/src/encoder/wave_encoder.c b/src/encoder/wave_encoder.c
index 9eeb4d51..fe087659 100644
--- a/src/encoder/wave_encoder.c
+++ b/src/encoder/wave_encoder.c
@@ -26,6 +26,8 @@
 #include <assert.h>
 #include <string.h>
 
+#include <libavutil/samplefmt.h>
+
 struct wave_encoder {
 	struct encoder encoder;
 	unsigned bits;
@@ -114,24 +116,17 @@ wave_encoder_open(struct encoder *_encoder,
 	assert(audio_format_valid(audio_format));
 
 	switch (audio_format->format) {
-	case SAMPLE_FORMAT_S8:
+    case AV_SAMPLE_FMT_U8:
 		encoder->bits = 8;
 		break;
-
-	case SAMPLE_FORMAT_S16:
+    case AV_SAMPLE_FMT_S16:
 		encoder->bits = 16;
 		break;
-
-	case SAMPLE_FORMAT_S24_P32:
-		encoder->bits = 24;
-		break;
-
-	case SAMPLE_FORMAT_S32:
+    case AV_SAMPLE_FMT_S32:
 		encoder->bits = 32;
 		break;
-
 	default:
-		audio_format->format = SAMPLE_FORMAT_S16;
+		audio_format->format = AV_SAMPLE_FMT_S16;
 		encoder->bits = 16;
 		break;
 	}
diff --git a/src/filter/normalize_filter_plugin.c b/src/filter/normalize_filter_plugin.c
index b17a8773..eb44bbb3 100644
--- a/src/filter/normalize_filter_plugin.c
+++ b/src/filter/normalize_filter_plugin.c
@@ -66,7 +66,7 @@ normalize_filter_open(struct filter *_filter,
 {
 	struct normalize_filter *filter = (struct normalize_filter *)_filter;
 
-	audio_format->format = SAMPLE_FORMAT_S16;
+	audio_format->format = AV_SAMPLE_FMT_S16;
 
 	filter->compressor = Compressor_new(0);
 
diff --git a/src/filter_plugin.c b/src/filter_plugin.c
index 61b340c7..aa7479fa 100644
--- a/src/filter_plugin.c
+++ b/src/filter_plugin.c
@@ -84,7 +84,10 @@ filter_open(struct filter *filter, struct audio_format *audio_format,
 	assert(audio_format_valid(audio_format));
 	assert(error_r == NULL || *error_r == NULL);
 
-	out_audio_format = filter->plugin->open(filter, audio_format, error_r);
+    if (filter->plugin->open)
+        out_audio_format = filter->plugin->open(filter, audio_format, error_r);
+    else
+        out_audio_format = audio_format;
 
 	assert(out_audio_format == NULL || audio_format_valid(audio_format));
 	assert(out_audio_format == NULL ||
@@ -98,7 +101,8 @@ filter_close(struct filter *filter)
 {
 	assert(filter != NULL);
 
-	filter->plugin->close(filter);
+    if (filter->plugin->close)
+        filter->plugin->close(filter);
 }
 
 AVFrame *filter_filter(struct filter *filter, AVFrame *src)
diff --git a/src/output/alsa_output_plugin.c b/src/output/alsa_output_plugin.c
index 4470e05e..18f65143 100644
--- a/src/output/alsa_output_plugin.c
+++ b/src/output/alsa_output_plugin.c
@@ -24,6 +24,9 @@
 #include "pcm_export.h"
 
 #include <glib.h>
+
+#include <libavutil/samplefmt.h>
+
 #include <alsa/asoundlib.h>
 
 #undef G_LOG_DOMAIN
@@ -211,27 +214,20 @@ alsa_test_default_device(void)
 	return true;
 }
 
-static snd_pcm_format_t
-get_bitformat(enum sample_format sample_format)
+static snd_pcm_format_t get_bitformat(enum AVSampleFormat sample_format)
 {
 	switch (sample_format) {
-	case SAMPLE_FORMAT_UNDEFINED:
-		return SND_PCM_FORMAT_UNKNOWN;
-
-	case SAMPLE_FORMAT_S8:
-		return SND_PCM_FORMAT_S8;
-
-	case SAMPLE_FORMAT_S16:
+    case AV_SAMPLE_FMT_U8:
+		return SND_PCM_FORMAT_U8;
+    case AV_SAMPLE_FMT_S16:
 		return SND_PCM_FORMAT_S16;
-
-	case SAMPLE_FORMAT_S24_P32:
-		return SND_PCM_FORMAT_S24;
-
-	case SAMPLE_FORMAT_S32:
+    case AV_SAMPLE_FMT_S32:
 		return SND_PCM_FORMAT_S32;
-
-	case SAMPLE_FORMAT_FLOAT:
+    case AV_SAMPLE_FMT_FLT:
 		return SND_PCM_FORMAT_FLOAT;
+    default:
+		return SND_PCM_FORMAT_UNKNOWN;
+
 	}
 
 	assert(false);
@@ -300,10 +296,9 @@ alsa_try_format_or_packed(snd_pcm_t *pcm, snd_pcm_hw_params_t *hwparams,
  * Attempts to configure the specified sample format, and tries the
  * reversed host byte order if was not supported.
  */
-static int
-alsa_output_try_format(snd_pcm_t *pcm, snd_pcm_hw_params_t *hwparams,
-		       enum sample_format sample_format,
-		       bool *packed_r, bool *reverse_endian_r)
+static int alsa_output_try_format(snd_pcm_t *pcm, snd_pcm_hw_params_t *hwparams,
+                                  enum AVSampleFormat sample_format,
+                                  bool *packed_r, bool *reverse_endian_r)
 {
 	snd_pcm_format_t alsa_format = get_bitformat(sample_format);
 	if (alsa_format == SND_PCM_FORMAT_UNKNOWN)
@@ -343,18 +338,17 @@ alsa_output_setup_format(snd_pcm_t *pcm, snd_pcm_hw_params_t *hwparams,
 
 	/* if unsupported by the hardware, try other formats */
 
-	static const enum sample_format probe_formats[] = {
-		SAMPLE_FORMAT_S24_P32,
-		SAMPLE_FORMAT_S32,
-		SAMPLE_FORMAT_S16,
-		SAMPLE_FORMAT_S8,
-		SAMPLE_FORMAT_UNDEFINED,
+	static const enum AVSampleFormat probe_formats[] = {
+	    AV_SAMPLE_FMT_S32,
+        AV_SAMPLE_FMT_S16,
+        AV_SAMPLE_FMT_U8,
+        AV_SAMPLE_FMT_NONE,
 	};
 
 	for (unsigned i = 0;
-	     err == -EINVAL && probe_formats[i] != SAMPLE_FORMAT_UNDEFINED;
+	     err == -EINVAL && probe_formats[i] != AV_SAMPLE_FMT_NONE;
 	     ++i) {
-		const enum sample_format mpd_format = probe_formats[i];
+		const enum AVSampleFormat mpd_format = probe_formats[i];
 		if (mpd_format == audio_format->format)
 			continue;
 
@@ -578,13 +572,13 @@ static bool
 alsa_setup_or_dsd(struct alsa_data *ad, struct audio_format *audio_format,
 		  GError **error_r)
 {
-	bool shift8 = false, packed, reverse_endian;
+	bool packed, reverse_endian;
 
 	const bool success = alsa_setup(ad, audio_format, &packed, &reverse_endian, error_r);
 	if (!success)
 		return false;
 
-	pcm_export_open(&ad->export, audio_format->format, shift8, packed, reverse_endian);
+	pcm_export_open(&ad->export, audio_format->format, packed, reverse_endian);
 	return true;
 }
 
diff --git a/src/output/ao_output_plugin.c b/src/output/ao_output_plugin.c
index d7e577fa..6f28ab3d 100644
--- a/src/output/ao_output_plugin.c
+++ b/src/output/ao_output_plugin.c
@@ -24,6 +24,8 @@
 #include <ao/ao.h>
 #include <glib.h>
 
+#include <libavutil/samplefmt.h>
+
 #undef G_LOG_DOMAIN
 #define G_LOG_DOMAIN "ao"
 
@@ -189,11 +191,11 @@ ao_output_open(struct audio_output *ao, struct audio_format *audio_format,
 	struct ao_data *ad = (struct ao_data *)ao;
 
 	switch (audio_format->format) {
-	case SAMPLE_FORMAT_S8:
+    case AV_SAMPLE_FMT_U8:
 		format.bits = 8;
 		break;
 
-	case SAMPLE_FORMAT_S16:
+    case AV_SAMPLE_FMT_S16:
 		format.bits = 16;
 		break;
 
@@ -201,7 +203,7 @@ ao_output_open(struct audio_output *ao, struct audio_format *audio_format,
 		/* support for 24 bit samples in libao is currently
 		   dubious, and until we have sorted that out,
 		   convert everything to 16 bit */
-		audio_format->format = SAMPLE_FORMAT_S16;
+		audio_format->format = AV_SAMPLE_FMT_S16;
 		format.bits = 16;
 		break;
 	}
diff --git a/src/output/ffado_output_plugin.c b/src/output/ffado_output_plugin.c
index ba239a4a..58c367ca 100644
--- a/src/output/ffado_output_plugin.c
+++ b/src/output/ffado_output_plugin.c
@@ -35,6 +35,9 @@
 #include "timer.h"
 
 #include <glib.h>
+
+#include <libavutil/samplefmt.h>
+
 #include <assert.h>
 
 #include <libffado/ffado.h>
@@ -244,7 +247,7 @@ ffado_open(struct audio_output *ao, struct audio_format *audio_format,
 
 	/* will be converted to floating point, choose best input
 	   format */
-	audio_format->format = SAMPLE_FORMAT_S24_P32;
+	audio_format->format = AV_SAMPLE_FMT_S16;
 
 	ffado_device_info_t device_info;
 	memset(&device_info, 0, sizeof(device_info));
diff --git a/src/output/jack_output_plugin.c b/src/output/jack_output_plugin.c
index a24cb855..81a2ca3d 100644
--- a/src/output/jack_output_plugin.c
+++ b/src/output/jack_output_plugin.c
@@ -24,6 +24,9 @@
 #include <assert.h>
 
 #include <glib.h>
+
+#include <libavutil/samplefmt.h>
+
 #include <jack/jack.h>
 #include <jack/types.h>
 #include <jack/ringbuffer.h>
@@ -197,9 +200,7 @@ set_audioformat(struct jack_data *jd, struct audio_format *audio_format)
 	else if (audio_format->channels > jd->num_source_ports)
 		audio_format->channels = 2;
 
-	if (audio_format->format != SAMPLE_FORMAT_S16 &&
-	    audio_format->format != SAMPLE_FORMAT_S24_P32)
-		audio_format->format = SAMPLE_FORMAT_S24_P32;
+    audio_format->format = AV_SAMPLE_FMT_S16;
 }
 
 static void
@@ -657,16 +658,10 @@ mpd_jack_write_samples(struct jack_data *jd, const void *src,
 		       unsigned num_samples)
 {
 	switch (jd->audio_format.format) {
-	case SAMPLE_FORMAT_S16:
+    case AV_SAMPLE_FMT_S16:
 		mpd_jack_write_samples_16(jd, (const int16_t*)src,
 					  num_samples);
 		break;
-
-	case SAMPLE_FORMAT_S24_P32:
-		mpd_jack_write_samples_24(jd, (const int32_t*)src,
-					  num_samples);
-		break;
-
 	default:
 		assert(false);
 	}
diff --git a/src/output/mvp_output_plugin.c b/src/output/mvp_output_plugin.c
index 37e0f7c9..783c072d 100644
--- a/src/output/mvp_output_plugin.c
+++ b/src/output/mvp_output_plugin.c
@@ -29,6 +29,8 @@
 
 #include <glib.h>
 
+#include <libavutil/samplefmt.h>
+
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <sys/ioctl.h>
@@ -181,18 +183,14 @@ mvp_set_pcm_params(struct mvp_data *md, struct audio_format *audio_format,
 
 	/* 0,1=24bit(24) , 2,3=16bit */
 	switch (audio_format->format) {
-	case SAMPLE_FORMAT_S16:
+    case AV_SAMPLE_FMT_S16:
 		mix[1] = 2;
 		break;
 
-	case SAMPLE_FORMAT_S24_P32:
-		mix[1] = 0;
-		break;
-
 	default:
 		g_debug("unsupported sample format %s - falling back to 16 bit",
 			sample_format_to_string(audio_format->format));
-		audio_format->format = SAMPLE_FORMAT_S16;
+		audio_format->format = AV_SAMPLE_FMT_S16;
 		mix[1] = 2;
 		break;
 	}
diff --git a/src/output/openal_output_plugin.c b/src/output/openal_output_plugin.c
index ebd35ef1..dac9e54e 100644
--- a/src/output/openal_output_plugin.c
+++ b/src/output/openal_output_plugin.c
@@ -23,6 +23,8 @@
 
 #include <glib.h>
 
+#include <libavutil/samplefmt.h>
+
 #ifndef HAVE_OSX
 #include <AL/al.h>
 #include <AL/alc.h>
@@ -56,15 +58,10 @@ openal_output_quark(void)
 	return g_quark_from_static_string("openal_output");
 }
 
-static ALenum
-openal_audio_format(struct audio_format *audio_format)
+static ALenum openal_audio_format(struct audio_format *audio_format)
 {
-	/* note: cannot map SAMPLE_FORMAT_S8 to AL_FORMAT_STEREO8 or
-	   AL_FORMAT_MONO8 since OpenAL expects unsigned 8 bit
-	   samples, while MPD uses signed samples */
-
 	switch (audio_format->format) {
-	case SAMPLE_FORMAT_S16:
+    case AV_SAMPLE_FMT_S16:
 		if (audio_format->channels == 2)
 			return AL_FORMAT_STEREO16;
 		if (audio_format->channels == 1)
@@ -76,7 +73,7 @@ openal_audio_format(struct audio_format *audio_format)
 
 	default:
 		/* fall back to 16 bit */
-		audio_format->format = SAMPLE_FORMAT_S16;
+		audio_format->format = AV_SAMPLE_FMT_S16;
 		return openal_audio_format(audio_format);
 	}
 }
diff --git a/src/output/oss_output_plugin.c b/src/output/oss_output_plugin.c
index aa9c00fc..84b1b485 100644
--- a/src/output/oss_output_plugin.c
+++ b/src/output/oss_output_plugin.c
@@ -26,6 +26,8 @@
 
 #include <glib.h>
 
+#include <libavutil/samplefmt.h>
+
 #include <sys/stat.h>
 #include <sys/ioctl.h>
 #include <fcntl.h>
@@ -427,85 +429,57 @@ oss_setup_sample_rate(int fd, struct audio_format *audio_format,
  * AFMT_QUERY if there is no direct counterpart.
  */
 static int
-sample_format_to_oss(enum sample_format format)
+sample_format_to_oss(enum AVSampleFormat format)
 {
 	switch (format) {
-	case SAMPLE_FORMAT_UNDEFINED:
-	case SAMPLE_FORMAT_FLOAT:
-		return AFMT_QUERY;
-
-	case SAMPLE_FORMAT_S8:
-		return AFMT_S8;
-
-	case SAMPLE_FORMAT_S16:
+    case AV_SAMPLE_FMT_U8:
+        return AFMT_U8;
+    case AV_SAMPLE_FMT_S16:
 		return AFMT_S16_NE;
-
-	case SAMPLE_FORMAT_S24_P32:
-#ifdef AFMT_S24_NE
-		return AFMT_S24_NE;
-#else
-		return AFMT_QUERY;
-#endif
-
-	case SAMPLE_FORMAT_S32:
+    case AV_SAMPLE_FMT_S32:
 #ifdef AFMT_S32_NE
 		return AFMT_S32_NE;
 #else
 		return AFMT_QUERY;
 #endif
+    default:
+		return AFMT_QUERY;
 	}
 
 	return AFMT_QUERY;
 }
 
 /**
- * Convert an OSS sample format to its MPD counterpart.  Returns
- * SAMPLE_FORMAT_UNDEFINED if there is no direct counterpart.
+ * Convert an OSS sample format to its libav counterpart.  Returns
+ * AV_SAMPLE_FMT_NONE if there is no direct counterpart.
  */
-static enum sample_format
+static enum AVSampleFormat
 sample_format_from_oss(int format)
 {
 	switch (format) {
-	case AFMT_S8:
-		return SAMPLE_FORMAT_S8;
-
+	case AFMT_U8:
+		return AV_SAMPLE_FMT_U8;
 	case AFMT_S16_NE:
-		return SAMPLE_FORMAT_S16;
-
-#ifdef AFMT_S24_PACKED
-	case AFMT_S24_PACKED:
-		return SAMPLE_FORMAT_S24_P32;
-#endif
-
-#ifdef AFMT_S24_NE
-	case AFMT_S24_NE:
-		return SAMPLE_FORMAT_S24_P32;
-#endif
-
+		return AV_SAMPLE_FMT_S16;
 #ifdef AFMT_S32_NE
 	case AFMT_S32_NE:
-		return SAMPLE_FORMAT_S32;
+		return AV_SAMPLE_FMT_S32;
 #endif
-
 	default:
-		return SAMPLE_FORMAT_UNDEFINED;
+		return AV_SAMPLE_FMT_NONE;
 	}
 }
 
 /**
  * Probe one sample format.
- *
- * @return the selected sample format or SAMPLE_FORMAT_UNDEFINED on
- * error
  */
-static enum oss_setup_result
-oss_probe_sample_format(int fd, enum sample_format sample_format,
-			enum sample_format *sample_format_r,
-			int *oss_format_r,
+static enum oss_setup_result oss_probe_sample_format(int fd, enum AVSampleFormat sample_format,
+                                                     enum AVSampleFormat *sample_format_r,
+                                                     int *oss_format_r,
 #ifdef AFMT_S24_PACKED
-			struct pcm_export_state *export,
+                                                     struct pcm_export_state *export,
 #endif
-			GError **error_r)
+                                                     GError **error_r)
 {
 	int oss_format = sample_format_to_oss(sample_format);
 	if (oss_format == AFMT_QUERY)
@@ -516,34 +490,16 @@ oss_probe_sample_format(int fd, enum sample_format sample_format,
 				&oss_format,
 				"Failed to set sample format", error_r);
 
-#ifdef AFMT_S24_PACKED
-	if (result == UNSUPPORTED && sample_format == SAMPLE_FORMAT_S24_P32) {
-		/* if the driver doesn't support padded 24 bit, try
-		   packed 24 bit */
-		oss_format = AFMT_S24_PACKED;
-		result = oss_try_ioctl_r(fd, SNDCTL_DSP_SAMPLESIZE,
-					 &oss_format,
-					 "Failed to set sample format", error_r);
-	}
-#endif
-
 	if (result != SUCCESS)
 		return result;
 
 	sample_format = sample_format_from_oss(oss_format);
-	if (sample_format == SAMPLE_FORMAT_UNDEFINED)
+	if (sample_format == AV_SAMPLE_FMT_NONE)
 		return UNSUPPORTED;
 
 	*sample_format_r = sample_format;
 	*oss_format_r = oss_format;
 
-#ifdef AFMT_S24_PACKED
-	pcm_export_open(export, sample_format, false,
-			oss_format == AFMT_S24_PACKED,
-			oss_format == AFMT_S24_PACKED &&
-			G_BYTE_ORDER != G_LITTLE_ENDIAN);
-#endif
-
 	return SUCCESS;
 }
 
@@ -559,7 +515,7 @@ oss_setup_sample_format(int fd, struct audio_format *audio_format,
 #endif
 			GError **error_r)
 {
-	enum sample_format mpd_format;
+	enum AVSampleFormat mpd_format;
 	enum oss_setup_result result =
 		oss_probe_sample_format(fd, audio_format->format,
 					&mpd_format, oss_format_r,
@@ -585,15 +541,14 @@ oss_setup_sample_format(int fd, struct audio_format *audio_format,
 	/* the requested sample format is not available - probe for
 	   other formats supported by MPD */
 
-	static const enum sample_format sample_formats[] = {
-		SAMPLE_FORMAT_S24_P32,
-		SAMPLE_FORMAT_S32,
-		SAMPLE_FORMAT_S16,
-		SAMPLE_FORMAT_S8,
-		SAMPLE_FORMAT_UNDEFINED /* sentinel */
+	static const enum AVSampleFormat sample_formats[] = {
+		AV_SAMPLE_FMT_S32,
+		AV_SAMPLE_FMT_S16,
+		AV_SAMPLE_FMT_U8,
+		AV_SAMPLE_FMT_NONE /* sentinel */
 	};
 
-	for (unsigned i = 0; sample_formats[i] != SAMPLE_FORMAT_UNDEFINED; ++i) {
+	for (unsigned i = 0; sample_formats[i] != AV_SAMPLE_FMT_NONE; ++i) {
 		mpd_format = sample_formats[i];
 		if (mpd_format == audio_format->format)
 			/* don't try that again */
diff --git a/src/output/osx_output_plugin.c b/src/output/osx_output_plugin.c
index fbba8174..11851186 100644
--- a/src/output/osx_output_plugin.c
+++ b/src/output/osx_output_plugin.c
@@ -23,6 +23,9 @@
 #include "fifo_buffer.h"
 
 #include <glib.h>
+
+#include <libavutil/samplefmt.h>
+
 #include <CoreAudio/AudioHardware.h>
 #include <AudioUnit/AudioUnit.h>
 #include <CoreServices/CoreServices.h>
@@ -326,20 +329,17 @@ osx_output_open(struct audio_output *ao, struct audio_format *audio_format, GErr
 	stream_description.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger;
 
 	switch (audio_format->format) {
-	case SAMPLE_FORMAT_S8:
+    case AV_SAMPLE_FMT_U8:
 		stream_description.mBitsPerChannel = 8;
 		break;
-
-	case SAMPLE_FORMAT_S16:
+    case AV_SAMPLE_FMT_S16:
 		stream_description.mBitsPerChannel = 16;
 		break;
-
-	case SAMPLE_FORMAT_S32:
+    case AV_SAMPLE_FMT_S32:
 		stream_description.mBitsPerChannel = 32;
 		break;
-
 	default:
-		audio_format->format = SAMPLE_FORMAT_S32;
+		audio_format->format = AV_SAMPLE_FMT_S32;
 		stream_description.mBitsPerChannel = 32;
 		break;
 	}
diff --git a/src/output/pulse_output_plugin.c b/src/output/pulse_output_plugin.c
index 0dc9be0e..5f8ef1d5 100644
--- a/src/output/pulse_output_plugin.c
+++ b/src/output/pulse_output_plugin.c
@@ -25,6 +25,8 @@
 
 #include <glib.h>
 
+#include <libavutil/samplefmt.h>
+
 #include <pulse/thread-mainloop.h>
 #include <pulse/context.h>
 #include <pulse/stream.h>
@@ -616,7 +618,7 @@ pulse_output_open(struct audio_output *ao, struct audio_format *audio_format,
 
 	/* MPD doesn't support the other pulseaudio sample formats, so
 	   we just force MPD to send us everything as 16 bit */
-	audio_format->format = SAMPLE_FORMAT_S16;
+	audio_format->format = AV_SAMPLE_FMT_S16;
 
 	ss.format = PA_SAMPLE_S16NE;
 	ss.rate = audio_format->sample_rate;
diff --git a/src/output/roar_output_plugin.c b/src/output/roar_output_plugin.c
index 1c2c4832..90dc2ac0 100644
--- a/src/output/roar_output_plugin.c
+++ b/src/output/roar_output_plugin.c
@@ -154,27 +154,20 @@ roar_use_audio_format(struct roar_audio_info *info,
 	info->codec = ROAR_CODEC_PCM_S;
 
 	switch (audio_format->format) {
-	case SAMPLE_FORMAT_UNDEFINED:
-		info->bits = 16;
-		audio_format->format = SAMPLE_FORMAT_S16;
-		break;
-
-	case SAMPLE_FORMAT_S8:
+    case AV_SAMPLE_FMT_U8:
 		info->bits = 8;
 		break;
-
-	case SAMPLE_FORMAT_S16:
+    case AV_SAMPLE_FMT_S16:
 		info->bits = 16;
 		break;
-
-	case SAMPLE_FORMAT_S24_P32:
+    case AV_SAMPLE_FMT_S32:
 		info->bits = 32;
-		audio_format->format = SAMPLE_FORMAT_S32;
 		break;
-
-	case SAMPLE_FORMAT_S32:
-		info->bits = 32;
+    default:
+		info->bits = 16;
+		audio_format->format = AV_SAMPLE_FMT_S16;
 		break;
+
 	}
 }
 
diff --git a/src/output/solaris_output_plugin.c b/src/output/solaris_output_plugin.c
index ce726009..2c3cc677 100644
--- a/src/output/solaris_output_plugin.c
+++ b/src/output/solaris_output_plugin.c
@@ -24,6 +24,8 @@
 
 #include <glib.h>
 
+#include <libavutil/samplefmt.h>
+
 #include <sys/stropts.h>
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -114,7 +116,7 @@ solaris_output_open(struct audio_output *ao, struct audio_format *audio_format,
 
 	/* support only 16 bit mono/stereo for now; nothing else has
 	   been tested */
-	audio_format->format = SAMPLE_FORMAT_S16;
+	audio_format->format = AV_SAMPLE_FMT_S16;
 
 	/* open the device in non-blocking mode */
 
diff --git a/src/output/winmm_output_plugin.c b/src/output/winmm_output_plugin.c
index 4d95834b..f2c9cb6a 100644
--- a/src/output/winmm_output_plugin.c
+++ b/src/output/winmm_output_plugin.c
@@ -28,6 +28,8 @@
 #include <string.h>
 #include <windows.h>
 
+#include <libavutil/samplefmt.h>
+
 #undef G_LOG_DOMAIN
 #define G_LOG_DOMAIN "winmm_output"
 
@@ -157,15 +159,12 @@ winmm_output_open(struct audio_output *ao, struct audio_format *audio_format,
 	}
 
 	switch (audio_format->format) {
-	case SAMPLE_FORMAT_S8:
-	case SAMPLE_FORMAT_S16:
+    case AV_SAMPLE_FMT_U8:
+    case AV_SAMPLE_FMT_S16:
 		break;
-
-	case SAMPLE_FORMAT_S24_P32:
-	case SAMPLE_FORMAT_S32:
-	case SAMPLE_FORMAT_UNDEFINED:
+    default:
 		/* we havn't tested formats other than S16 */
-		audio_format->format = SAMPLE_FORMAT_S16;
+		audio_format->format = AV_SAMPLE_FMT_S16;
 		break;
 	}
 
@@ -179,7 +178,7 @@ winmm_output_open(struct audio_output *ao, struct audio_format *audio_format,
 	format.nSamplesPerSec = audio_format->sample_rate;
 	format.nBlockAlign = audio_format_frame_size(audio_format);
 	format.nAvgBytesPerSec = format.nSamplesPerSec * format.nBlockAlign;
-	format.wBitsPerSample = audio_format_sample_size(audio_format) * 8;
+	format.wBitsPerSample = av_get_bytes_per_sample(audio_format->format) * 8;
 	format.cbSize = 0;
 
 	MMRESULT result = waveOutOpen(&wo->handle, wo->device_id, &format,
diff --git a/src/pcm_convert.c b/src/pcm_convert.c
index 67f8d5e7..267e32c8 100644
--- a/src/pcm_convert.c
+++ b/src/pcm_convert.c
@@ -64,7 +64,7 @@ AVFrame *pcm_convert(struct pcm_convert_state *state,
 
         state->dst_channel_layout = av_get_default_channel_layout(dest_format->channels);
         state->dst_samplerate     = dest_format->sample_rate;
-        state->dst_format         = sample_fmt_native_to_libav(dest_format->format);
+        state->dst_format         = dest_format->format;
 
         av_opt_set_int(state->avr, "in_channel_layout",  src->channel_layout, 0);
         av_opt_set_int(state->avr, "out_channel_layout", state->dst_channel_layout, 0);
diff --git a/src/pcm_export.c b/src/pcm_export.c
index b430318e..b6773d4c 100644
--- a/src/pcm_export.c
+++ b/src/pcm_export.c
@@ -22,6 +22,8 @@
 #include "pcm_pack.h"
 #include "util/byte_reverse.h"
 
+#include <libavutil/samplefmt.h>
+
 void
 pcm_export_init(struct pcm_export_state *state)
 {
@@ -35,23 +37,15 @@ void pcm_export_deinit(struct pcm_export_state *state)
 	pcm_buffer_deinit(&state->pack_buffer);
 }
 
-void
-pcm_export_open(struct pcm_export_state *state,
-		enum sample_format sample_format,
-		bool shift8, bool pack, bool reverse_endian)
+void pcm_export_open(struct pcm_export_state *state,
+                     enum AVSampleFormat sample_format,
+                     bool pack, bool reverse_endian)
 {
 	assert(audio_valid_sample_format(sample_format));
 
-	state->shift8 = shift8 && sample_format == SAMPLE_FORMAT_S24_P32;
-	state->pack24 = pack && sample_format == SAMPLE_FORMAT_S24_P32;
-
-	assert(!state->shift8 || !state->pack24);
-
 	state->reverse_endian = 0;
 	if (reverse_endian) {
-		size_t sample_size = state->pack24
-			? 3
-			: sample_format_size(sample_format);
+		size_t sample_size = av_get_bytes_per_sample(sample_format);
 		assert(sample_size <= 0xff);
 
 		if (sample_size > 1)
@@ -66,10 +60,6 @@ pcm_export_frame_size(const struct pcm_export_state *state,
 	assert(state != NULL);
 	assert(audio_format != NULL);
 
-	if (state->pack24)
-		/* packed 24 bit samples (3 bytes per sample) */
-		return audio_format->channels * 3;
-
 	return audio_format_frame_size(audio_format);
 }
 
@@ -77,36 +67,6 @@ const void *
 pcm_export(struct pcm_export_state *state, const void *data, size_t size,
 	   size_t *dest_size_r)
 {
-	if (state->pack24) {
-		assert(size % 4 == 0);
-
-		const size_t num_samples = size / 4;
-		const size_t dest_size = num_samples * 3;
-
-		const uint8_t *src8 = data, *src_end8 = src8 + size;
-		uint8_t *dest = pcm_buffer_get(&state->pack_buffer, dest_size);
-		assert(dest != NULL);
-
-		pcm_pack_24(dest, (const int32_t *)src8,
-			    (const int32_t *)src_end8);
-
-		data = dest;
-		size = dest_size;
-	} else if (state->shift8) {
-		assert(size % 4 == 0);
-
-		const uint8_t *src8 = data, *src_end8 = src8 + size;
-		const uint32_t *src = (const uint32_t *)src8;
-		const uint32_t *const src_end = (const uint32_t *)src_end8;
-
-		uint32_t *dest = pcm_buffer_get(&state->pack_buffer, size);
-		data = dest;
-
-		while (src < src_end)
-			*dest++ = *src++ << 8;
-	}
-
-
 	if (state->reverse_endian > 0) {
 		assert(state->reverse_endian >= 2);
 
@@ -126,9 +86,5 @@ pcm_export(struct pcm_export_state *state, const void *data, size_t size,
 size_t
 pcm_export_source_size(const struct pcm_export_state *state, size_t size)
 {
-	if (state->pack24)
-		/* 32 bit to 24 bit conversion (4 to 3 bytes) */
-		size = (size / 3) * 4;
-
 	return size;
 }
diff --git a/src/pcm_export.h b/src/pcm_export.h
index 096ae8a6..941036c9 100644
--- a/src/pcm_export.h
+++ b/src/pcm_export.h
@@ -54,17 +54,6 @@ struct pcm_export_state {
 	uint8_t channels;
 
 	/**
-	 * Convert (padded) 24 bit samples to 32 bit by shifting 8
-	 * bits to the left?
-	 */
-	bool shift8;
-
-	/**
-	 * Pack 24 bit samples?
-	 */
-	bool pack24;
-
-	/**
 	 * Export the samples in reverse byte order?  A non-zero value
 	 * means the option is enabled and represents the size of each
 	 * sample (2 or bigger).
@@ -93,8 +82,8 @@ pcm_export_deinit(struct pcm_export_state *state);
  * This function cannot fail.
  */
 void pcm_export_open(struct pcm_export_state *state,
-                     enum sample_format sample_format,
-                     bool shift8, bool pack, bool reverse_endian);
+                     enum AVSampleFormat sample_format,
+                     bool pack, bool reverse_endian);
 
 /**
  * Calculate the size of one output frame.
diff --git a/src/pcm_mix.c b/src/pcm_mix.c
index 9f344f78..ac1fd7a0 100644
--- a/src/pcm_mix.c
+++ b/src/pcm_mix.c
@@ -112,46 +112,33 @@ pcm_add_vol_float(float *buffer1, const float *buffer2,
 	}
 }
 
-static bool
-pcm_add_vol(void *buffer1, const void *buffer2, size_t size,
-	    int vol1, int vol2,
-	    enum sample_format format)
+static bool pcm_add_vol(void *buffer1, const void *buffer2, size_t size,
+                        int vol1, int vol2,
+                        enum AVSampleFormat format)
 {
-	switch (format) {
-	case SAMPLE_FORMAT_UNDEFINED:
-		/* not implemented */
-		return false;
-
-	case SAMPLE_FORMAT_S8:
-		pcm_add_vol_8((int8_t *)buffer1, (const int8_t *)buffer2,
-			      size, vol1, vol2);
-		return true;
-
-	case SAMPLE_FORMAT_S16:
-		pcm_add_vol_16((int16_t *)buffer1, (const int16_t *)buffer2,
-			       size / 2, vol1, vol2);
-		return true;
-
-	case SAMPLE_FORMAT_S24_P32:
-		pcm_add_vol_24((int32_t *)buffer1, (const int32_t *)buffer2,
-			       size / 4, vol1, vol2);
-		return true;
-
-	case SAMPLE_FORMAT_S32:
-		pcm_add_vol_32((int32_t *)buffer1, (const int32_t *)buffer2,
-			       size / 4, vol1, vol2);
-		return true;
-
-	case SAMPLE_FORMAT_FLOAT:
-		pcm_add_vol_float(buffer1, buffer2, size / 4,
-				  pcm_volume_to_float(vol1),
-				  pcm_volume_to_float(vol2));
-		return true;
-	}
-
-	/* unreachable */
-	assert(false);
-	return false;
+    switch (format) {
+    case AV_SAMPLE_FMT_U8:
+        pcm_add_vol_8((int8_t *)buffer1, (const int8_t *)buffer2,
+                      size, vol1, vol2);
+        return true;
+    case AV_SAMPLE_FMT_S16:
+        pcm_add_vol_16((int16_t *)buffer1, (const int16_t *)buffer2,
+                       size / 2, vol1, vol2);
+        return true;
+    case AV_SAMPLE_FMT_S32:
+        pcm_add_vol_32((int32_t *)buffer1, (const int32_t *)buffer2,
+                       size / 4, vol1, vol2);
+        return true;
+
+    case AV_SAMPLE_FMT_FLT:
+        pcm_add_vol_float(buffer1, buffer2, size / 4,
+                          pcm_volume_to_float(vol1),
+                          pcm_volume_to_float(vol2));
+        return true;
+    default:
+        /* not implemented */
+        return false;
+    }
 }
 
 static void
@@ -221,44 +208,33 @@ pcm_add_float(float *buffer1, const float *buffer2, unsigned num_samples)
 	}
 }
 
-static bool
-pcm_add(void *buffer1, const void *buffer2, size_t size,
-	enum sample_format format)
+static bool pcm_add(void *buffer1, const void *buffer2, size_t size,
+                    enum AVSampleFormat format)
 {
-	switch (format) {
-	case SAMPLE_FORMAT_UNDEFINED:
-		/* not implemented */
-		return false;
-
-	case SAMPLE_FORMAT_S8:
-		pcm_add_8((int8_t *)buffer1, (const int8_t *)buffer2, size);
-		return true;
-
-	case SAMPLE_FORMAT_S16:
-		pcm_add_16((int16_t *)buffer1, (const int16_t *)buffer2, size / 2);
-		return true;
-
-	case SAMPLE_FORMAT_S24_P32:
-		pcm_add_24((int32_t *)buffer1, (const int32_t *)buffer2, size / 4);
-		return true;
-
-	case SAMPLE_FORMAT_S32:
-		pcm_add_32((int32_t *)buffer1, (const int32_t *)buffer2, size / 4);
-		return true;
-
-	case SAMPLE_FORMAT_FLOAT:
-		pcm_add_float(buffer1, buffer2, size / 4);
-		return true;
-	}
-
-	/* unreachable */
-	assert(false);
-	return false;
+    switch (format) {
+    case AV_SAMPLE_FMT_U8:
+        pcm_add_8((int8_t *)buffer1, (const int8_t *)buffer2, size);
+        return true;
+
+    case AV_SAMPLE_FMT_S16:
+        pcm_add_16((int16_t *)buffer1, (const int16_t *)buffer2, size / 2);
+        return true;
+
+    case AV_SAMPLE_FMT_S32:
+        pcm_add_32((int32_t *)buffer1, (const int32_t *)buffer2, size / 4);
+        return true;
+
+    case AV_SAMPLE_FMT_FLT:
+        pcm_add_float(buffer1, buffer2, size / 4);
+        return true;
+    default:
+        /* not implemented */
+        return false;
+    }
 }
 
-bool
-pcm_mix(void *buffer1, const void *buffer2, size_t size,
-	enum sample_format format, float portion1)
+bool pcm_mix(void *buffer1, const void *buffer2, size_t size,
+             enum AVSampleFormat format, float portion1)
 {
 	int vol1;
 	float s;
diff --git a/src/pcm_mix.h b/src/pcm_mix.h
index 0e58d01e..6be4e4e9 100644
--- a/src/pcm_mix.h
+++ b/src/pcm_mix.h
@@ -25,6 +25,8 @@
 #include <stdbool.h>
 #include <stddef.h>
 
+#include <libavutil/samplefmt.h>
+
 /*
  * Linearly mixes two PCM buffers.  Both must have the same length and
  * the same audio format.  The formula is:
@@ -41,9 +43,7 @@
  *
  * @return true on success, false if the format is not supported
  */
-G_GNUC_WARN_UNUSED_RESULT
-bool
-pcm_mix(void *buffer1, const void *buffer2, size_t size,
-	enum sample_format format, float portion1);
+bool pcm_mix(void *buffer1, const void *buffer2, size_t size,
+             enum AVSampleFormat format, float portion1);
 
 #endif
diff --git a/src/pcm_volume.c b/src/pcm_volume.c
index d6c282c9..7b6e8635 100644
--- a/src/pcm_volume.c
+++ b/src/pcm_volume.c
@@ -27,6 +27,8 @@
 #include <stdint.h>
 #include <string.h>
 
+#include <libavutil/samplefmt.h>
+
 #undef G_LOG_DOMAIN
 #define G_LOG_DOMAIN "pcm_volume"
 
@@ -142,10 +144,9 @@ pcm_volume_change_float(float *buffer, const float *end, float volume)
 	}
 }
 
-bool
-pcm_volume(void *buffer, size_t length,
-	   enum sample_format format,
-	   int volume)
+bool pcm_volume(void *buffer, size_t length,
+                enum AVSampleFormat format,
+                int volume)
 {
 	if (volume == PCM_VOLUME_1)
 		return true;
@@ -157,33 +158,22 @@ pcm_volume(void *buffer, size_t length,
 
 	const void *end = pcm_end_pointer(buffer, length);
 	switch (format) {
-	case SAMPLE_FORMAT_UNDEFINED:
-		/* not implemented */
-		return false;
-
-	case SAMPLE_FORMAT_S8:
+    case AV_SAMPLE_FMT_U8:
 		pcm_volume_change_8(buffer, end, volume);
 		return true;
-
-	case SAMPLE_FORMAT_S16:
+    case AV_SAMPLE_FMT_S16:
 		pcm_volume_change_16(buffer, end, volume);
 		return true;
-
-	case SAMPLE_FORMAT_S24_P32:
-		pcm_volume_change_24(buffer, end, volume);
-		return true;
-
-	case SAMPLE_FORMAT_S32:
+    case AV_SAMPLE_FMT_S32:
 		pcm_volume_change_32(buffer, end, volume);
 		return true;
-
-	case SAMPLE_FORMAT_FLOAT:
+    case AV_SAMPLE_FMT_FLT:
 		pcm_volume_change_float(buffer, end,
 					pcm_volume_to_float(volume));
 		return true;
-	}
+    default:
+		/* not implemented */
+		return false;
 
-	/* unreachable */
-	assert(false);
-	return false;
+	}
 }
diff --git a/src/pcm_volume.h b/src/pcm_volume.h
index 64e3c764..58ff2fd3 100644
--- a/src/pcm_volume.h
+++ b/src/pcm_volume.h
@@ -73,9 +73,8 @@ pcm_volume_dither(void)
  * @param volume the volume between 0 and #PCM_VOLUME_1
  * @return true on success, false if the audio format is not supported
  */
-bool
-pcm_volume(void *buffer, size_t length,
-	   enum sample_format format,
-	   int volume);
+bool pcm_volume(void *buffer, size_t length,
+                enum AVSampleFormat format,
+                int volume);
 
 #endif
diff --git a/src/player_thread.c b/src/player_thread.c
index 8efff1ad..5c9b7015 100644
--- a/src/player_thread.c
+++ b/src/player_thread.c
@@ -426,7 +426,7 @@ player_send_silence(struct player *player)
     if (!chunk->frame)
         goto fail;
     frame->nb_samples     = 2048;
-    frame->format         = sample_fmt_native_to_libav(player->play_audio_format.format);
+    frame->format         = player->play_audio_format.format;
     frame->sample_rate    = player->play_audio_format.sample_rate;
     frame->channel_layout = av_get_default_channel_layout(player->play_audio_format.channels);