From 0bbe5ac82ef2845efafbf190044f16712db113b2 Mon Sep 17 00:00:00 2001 From: Anton Khirnov Date: Tue, 23 Apr 2013 15:30:50 +0200 Subject: Switch to Libav sample formats everywhere. Drop 24bit format for now. It should be restored later by properly distinguishing between internal and packed formats. --- src/audio_check.c | 70 +++++++++--------- src/audio_check.h | 24 +++---- src/audio_format.c | 42 +++-------- src/audio_format.h | 136 ++++++++--------------------------- src/audio_parser.c | 43 ++++------- src/chunk.c | 4 ++ src/decoder/libav_decoder_plugin.c | 12 +--- src/decoder_api.c | 3 + src/decoder_internal.c | 2 +- src/encoder/flac_encoder.c | 23 ++---- src/encoder/lame_encoder.c | 4 +- src/encoder/twolame_encoder.c | 4 +- src/encoder/vorbis_encoder.c | 4 +- src/encoder/wave_encoder.c | 17 ++--- src/filter/normalize_filter_plugin.c | 2 +- src/filter_plugin.c | 8 ++- src/output/alsa_output_plugin.c | 54 +++++++------- src/output/ao_output_plugin.c | 8 ++- src/output/ffado_output_plugin.c | 5 +- src/output/jack_output_plugin.c | 15 ++-- src/output/mvp_output_plugin.c | 10 ++- src/output/openal_output_plugin.c | 13 ++-- src/output/oss_output_plugin.c | 105 ++++++++------------------- src/output/osx_output_plugin.c | 14 ++-- src/output/pulse_output_plugin.c | 4 +- src/output/roar_output_plugin.c | 21 ++---- src/output/solaris_output_plugin.c | 4 +- src/output/winmm_output_plugin.c | 15 ++-- src/pcm_convert.c | 2 +- src/pcm_export.c | 56 ++------------- src/pcm_export.h | 15 +--- src/pcm_mix.c | 124 +++++++++++++------------------- src/pcm_mix.h | 8 +-- src/pcm_volume.c | 36 ++++------ src/pcm_volume.h | 7 +- src/player_thread.c | 2 +- 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 -bool -audio_check_sample_rate(unsigned long sample_rate, GError **error_r) +#include + +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 #include +#include + /** * 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 -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 #include +#include + /** * 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 #include +#include #include @@ -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 #include #include +#include #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 #include +#include + 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 #include +#include + 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 +#include + #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 #include +#include + 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 + +#include + #include #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 #include +#include + #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 + +#include + #include #include @@ -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 #include + +#include + #include #include #include @@ -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 +#include + #include #include #include @@ -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 +#include + #ifndef HAVE_OSX #include #include @@ -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 +#include + #include #include #include @@ -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 + +#include + #include #include #include @@ -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 +#include + #include #include #include @@ -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 +#include + #include #include #include @@ -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 #include +#include + #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 + 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 @@ -53,17 +53,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 @@ -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 #include +#include + /* * 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 #include +#include + #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); -- cgit v1.2.3