diff options
Diffstat (limited to '')
50 files changed, 511 insertions, 214 deletions
diff --git a/Makefile.am b/Makefile.am index 049506980..760e07765 100644 --- a/Makefile.am +++ b/Makefile.am @@ -877,6 +877,7 @@ test_run_normalize_LDADD = \ $(GLIB_LIBS) test_run_convert_SOURCES = test/run_convert.c \ + src/audio_format.c \ src/audio_check.c \ src/audio_parser.c \ src/pcm_channels.c \ diff --git a/src/audio_check.c b/src/audio_check.c index 4046e8862..a843975fa 100644 --- a/src/audio_check.c +++ b/src/audio_check.c @@ -35,7 +35,7 @@ audio_check_sample_rate(unsigned long sample_rate, GError **error_r) } bool -audio_check_sample_format(unsigned sample_format, GError **error_r) +audio_check_sample_format(enum sample_format sample_format, GError **error_r) { if (!audio_valid_sample_format(sample_format)) { g_set_error(error_r, audio_format_quark(), 0, @@ -60,7 +60,7 @@ audio_check_channel_count(unsigned channels, GError **error_r) bool audio_format_init_checked(struct audio_format *af, unsigned long sample_rate, - unsigned sample_format, unsigned channels, + enum sample_format sample_format, unsigned channels, GError **error_r) { if (audio_check_sample_rate(sample_rate, error_r) && diff --git a/src/audio_check.h b/src/audio_check.h index a11fbe3d3..197dedd48 100644 --- a/src/audio_check.h +++ b/src/audio_check.h @@ -20,11 +20,11 @@ #ifndef MPD_AUDIO_CHECK_H #define MPD_AUDIO_CHECK_H +#include "audio_format.h" + #include <glib.h> #include <stdbool.h> -struct audio_format; - /** * The GLib quark used for errors reported by this library. */ @@ -48,7 +48,7 @@ audio_check_channel_count(unsigned sample_format, GError **error_r); */ bool audio_format_init_checked(struct audio_format *af, unsigned long sample_rate, - unsigned sample_format, unsigned channels, + enum sample_format sample_format, unsigned channels, GError **error_r); #endif diff --git a/src/audio_format.c b/src/audio_format.c index f88735c73..33cd90f58 100644 --- a/src/audio_format.c +++ b/src/audio_format.c @@ -29,14 +29,39 @@ #endif const char * +sample_format_to_string(enum sample_format format) +{ + switch (format) { + case SAMPLE_FORMAT_UNDEFINED: + return "?"; + + case SAMPLE_FORMAT_S8: + return "8"; + + case SAMPLE_FORMAT_S16: + return "16"; + + case SAMPLE_FORMAT_S24_P32: + return "24"; + + case SAMPLE_FORMAT_S32: + return "32"; + } + + /* unreachable */ + assert(false); + return "?"; +} + +const char * audio_format_to_string(const struct audio_format *af, struct audio_format_string *s) { assert(af != NULL); assert(s != NULL); - snprintf(s->buffer, sizeof(s->buffer), "%u:%u%s:%u", - af->sample_rate, af->bits, + snprintf(s->buffer, sizeof(s->buffer), "%u:%s%s:%u", + af->sample_rate, sample_format_to_string(af->format), af->reverse_endian ? REVERSE_ENDIAN_SUFFIX : "", af->channels); diff --git a/src/audio_format.h b/src/audio_format.h index 0c1e425a9..6e7d50c46 100644 --- a/src/audio_format.h +++ b/src/audio_format.h @@ -23,6 +23,21 @@ #include <stdint.h> #include <stdbool.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, +}; + /** * This structure describes the format of a raw PCM stream. */ @@ -35,11 +50,10 @@ struct audio_format { uint32_t sample_rate; /** - * The number of significant bits per sample. Samples are - * currently always signed. Supported values are 8, 16, 24, - * 32. 24 bit samples are packed in 32 bit integers. + * The format samples are stored in. See the #sample_format + * enum for valid values. */ - uint8_t bits; + uint8_t format; /** * The number of channels. Only mono (1) and stereo (2) are @@ -69,7 +83,7 @@ struct audio_format_string { static inline void audio_format_clear(struct audio_format *af) { af->sample_rate = 0; - af->bits = 0; + af->format = SAMPLE_FORMAT_UNDEFINED; af->channels = 0; af->reverse_endian = 0; } @@ -80,10 +94,10 @@ static inline void audio_format_clear(struct audio_format *af) */ static inline void audio_format_init(struct audio_format *af, uint32_t sample_rate, - uint8_t bits, uint8_t channels) + enum sample_format format, uint8_t channels) { af->sample_rate = sample_rate; - af->bits = bits; + af->format = (uint8_t)format; af->channels = channels; af->reverse_endian = 0; } @@ -105,7 +119,8 @@ static inline bool audio_format_defined(const struct audio_format *af) static inline bool audio_format_fully_defined(const struct audio_format *af) { - return af->sample_rate != 0 && af->bits != 0 && af->channels != 0; + return af->sample_rate != 0 && af->format != SAMPLE_FORMAT_UNDEFINED && + af->channels != 0; } /** @@ -115,7 +130,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->bits != 0 || af->channels != 0; + return af->sample_rate != 0 || af->format != SAMPLE_FORMAT_UNDEFINED || + af->channels != 0; } /** @@ -135,9 +151,20 @@ audio_valid_sample_rate(unsigned sample_rate) * @param bits the number of significant bits per sample */ static inline bool -audio_valid_sample_format(unsigned bits) +audio_valid_sample_format(enum sample_format format) { - return bits == 16 || bits == 24 || bits == 32 || bits == 8; + switch (format) { + case SAMPLE_FORMAT_S8: + case SAMPLE_FORMAT_S16: + case SAMPLE_FORMAT_S24_P32: + case SAMPLE_FORMAT_S32: + return true; + + case SAMPLE_FORMAT_UNDEFINED: + break; + } + + return false; } /** @@ -156,7 +183,7 @@ audio_valid_channel_count(unsigned channels) static inline bool audio_format_valid(const struct audio_format *af) { return audio_valid_sample_rate(af->sample_rate) && - audio_valid_sample_format(af->bits) && + audio_valid_sample_format((enum sample_format)af->format) && audio_valid_channel_count(af->channels); } @@ -168,7 +195,8 @@ 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->bits == 0 || audio_valid_sample_format(af->bits)) && + (af->format == SAMPLE_FORMAT_UNDEFINED || + audio_valid_sample_format((enum sample_format)af->format)) && (af->channels == 0 || audio_valid_channel_count(af->channels)); } @@ -176,7 +204,7 @@ static inline bool audio_format_equals(const struct audio_format *a, const struct audio_format *b) { return a->sample_rate == b->sample_rate && - a->bits == b->bits && + a->format == b->format && a->channels == b->channels && a->reverse_endian == b->reverse_endian; } @@ -188,8 +216,8 @@ audio_format_mask_apply(struct audio_format *af, if (mask->sample_rate != 0) af->sample_rate = mask->sample_rate; - if (mask->bits != 0) - af->bits = mask->bits; + if (mask->format != SAMPLE_FORMAT_UNDEFINED) + af->format = mask->format; if (mask->channels != 0) af->channels = mask->channels; @@ -200,12 +228,22 @@ audio_format_mask_apply(struct audio_format *af, */ static inline unsigned audio_format_sample_size(const struct audio_format *af) { - if (af->bits <= 8) + switch (af->format) { + case SAMPLE_FORMAT_S8: return 1; - else if (af->bits <= 16) + + case SAMPLE_FORMAT_S16: return 2; - else + + case SAMPLE_FORMAT_S24_P32: + case SAMPLE_FORMAT_S32: return 4; + + case SAMPLE_FORMAT_UNDEFINED: + break; + } + + return 0; } /** @@ -227,6 +265,16 @@ static inline double audio_format_time_to_size(const struct audio_format *af) } /** + * Renders a #sample_format enum into a string, e.g. for printing it + * in a log file. + * + * @param format a #sample_format enum value + * @return the string + */ +const char * +sample_format_to_string(enum sample_format format); + +/** * Renders the #audio_format object into a string, e.g. for printing * it in a log file. * diff --git a/src/audio_parser.c b/src/audio_parser.c index df87be325..210ea7a62 100644 --- a/src/audio_parser.c +++ b/src/audio_parser.c @@ -27,6 +27,7 @@ #include "audio_format.h" #include "audio_check.h" +#include <assert.h> #include <stdlib.h> /** @@ -65,14 +66,16 @@ parse_sample_rate(const char *src, bool mask, uint32_t *sample_rate_r, } static bool -parse_sample_format(const char *src, bool mask, uint8_t *bits_r, +parse_sample_format(const char *src, bool mask, + enum sample_format *sample_format_r, const char **endptr_r, GError **error_r) { unsigned long value; char *endptr; + enum sample_format sample_format; if (mask && *src == '*') { - *bits_r = 0; + *sample_format_r = SAMPLE_FORMAT_UNDEFINED; *endptr_r = src + 1; return true; } @@ -82,10 +85,34 @@ parse_sample_format(const char *src, bool mask, uint8_t *bits_r, g_set_error(error_r, audio_parser_quark(), 0, "Failed to parse the sample format"); return false; - } else if (!audio_check_sample_format(value, error_r)) + } + + switch (value) { + case 8: + sample_format = SAMPLE_FORMAT_S8; + break; + + case 16: + sample_format = SAMPLE_FORMAT_S16; + break; + + case 24: + sample_format = SAMPLE_FORMAT_S24_P32; + break; + + case 32: + sample_format = SAMPLE_FORMAT_S32; + break; + + default: + g_set_error(error_r, audio_parser_quark(), 0, + "Invalid sample format: %lu", value); return false; + } + + assert(audio_valid_sample_format(sample_format)); - *bits_r = value; + *sample_format_r = sample_format; *endptr_r = endptr; return true; } @@ -121,7 +148,8 @@ audio_format_parse(struct audio_format *dest, const char *src, bool mask, GError **error_r) { uint32_t rate; - uint8_t bits, channels; + enum sample_format sample_format; + uint8_t channels; audio_format_clear(dest); @@ -138,7 +166,7 @@ audio_format_parse(struct audio_format *dest, const char *src, /* parse sample format */ - if (!parse_sample_format(src, mask, &bits, &src, error_r)) + if (!parse_sample_format(src, mask, &sample_format, &src, error_r)) return false; if (*src++ != ':') { @@ -158,7 +186,7 @@ audio_format_parse(struct audio_format *dest, const char *src, return false; } - audio_format_init(dest, rate, bits, channels); + audio_format_init(dest, rate, sample_format, channels); return true; } diff --git a/src/decoder/_flac_common.c b/src/decoder/_flac_common.c index f12b8bff0..70b2c0202 100644 --- a/src/decoder/_flac_common.c +++ b/src/decoder/_flac_common.c @@ -60,6 +60,27 @@ flac_data_deinit(struct flac_data *data) tag_free(data->tag); } +static enum sample_format +flac_sample_format(const FLAC__StreamMetadata_StreamInfo *si) +{ + switch (si->bits_per_sample) { + case 8: + return SAMPLE_FORMAT_S8; + + case 16: + return SAMPLE_FORMAT_S16; + + case 24: + return SAMPLE_FORMAT_S24_P32; + + case 32: + return SAMPLE_FORMAT_S32; + + default: + return SAMPLE_FORMAT_UNDEFINED; + } +} + bool flac_data_get_audio_format(struct flac_data *data, struct audio_format *audio_format) @@ -71,9 +92,11 @@ flac_data_get_audio_format(struct flac_data *data, return false; } + data->sample_format = flac_sample_format(&data->stream_info); + if (!audio_format_init_checked(audio_format, data->stream_info.sample_rate, - data->stream_info.bits_per_sample, + data->sample_format, data->stream_info.channels, &error)) { g_warning("%s", error->message); g_error_free(error); @@ -144,7 +167,7 @@ flac_common_write(struct flac_data *data, const FLAC__Frame * frame, buffer = pcm_buffer_get(&data->buffer, buffer_size); flac_convert(buffer, frame->header.channels, - frame->header.bits_per_sample, buf, + data->sample_format, buf, 0, frame->header.blocksize); if (data->next_frame >= data->first_frame) diff --git a/src/decoder/_flac_common.h b/src/decoder/_flac_common.h index 1d211fcfb..2f328afa6 100644 --- a/src/decoder/_flac_common.h +++ b/src/decoder/_flac_common.h @@ -38,6 +38,8 @@ struct flac_data { struct pcm_buffer buffer; + enum sample_format sample_format; + /** * The size of one frame in the output buffer. */ diff --git a/src/decoder/audiofile_plugin.c b/src/decoder/audiofile_plugin.c index 5a2096d00..fcb431db7 100644 --- a/src/decoder/audiofile_plugin.c +++ b/src/decoder/audiofile_plugin.c @@ -101,13 +101,33 @@ setup_virtual_fops(struct input_stream *stream) return vf; } -static uint8_t +static enum sample_format +audiofile_bits_to_sample_format(int bits) +{ + switch (bits) { + case 8: + return SAMPLE_FORMAT_S8; + + case 16: + return SAMPLE_FORMAT_S16; + + case 24: + return SAMPLE_FORMAT_S24_P32; + + case 32: + return SAMPLE_FORMAT_S32; + } + + return SAMPLE_FORMAT_UNDEFINED; +} + +static enum sample_format audiofile_setup_sample_format(AFfilehandle af_fp) { int fs, bits; afGetSampleFormat(af_fp, AF_DEFAULT_TRACK, &fs, &bits); - if (!audio_valid_sample_format(bits)) { + if (!audio_valid_sample_format(audiofile_bits_to_sample_format(bits))) { g_debug("input file has %d bit samples, converting to 16", bits); bits = 16; @@ -117,7 +137,7 @@ audiofile_setup_sample_format(AFfilehandle af_fp) AF_SAMPFMT_TWOSCOMP, bits); afGetVirtualSampleFormat(af_fp, AF_DEFAULT_TRACK, &fs, &bits); - return bits; + return audiofile_bits_to_sample_format(bits); } static void diff --git a/src/decoder/faad_plugin.c b/src/decoder/faad_plugin.c index 55df15555..2a05e33e8 100644 --- a/src/decoder/faad_plugin.c +++ b/src/decoder/faad_plugin.c @@ -283,7 +283,7 @@ faad_decoder_init(faacDecHandle decoder, struct decoder_buffer *buffer, decoder_buffer_consume(buffer, nbytes); return audio_format_init_checked(audio_format, sample_rate, - 16, channels, error_r); + SAMPLE_FORMAT_S16, channels, error_r); } /** diff --git a/src/decoder/ffmpeg_plugin.c b/src/decoder/ffmpeg_plugin.c index 9b025153b..af9320322 100644 --- a/src/decoder/ffmpeg_plugin.c +++ b/src/decoder/ffmpeg_plugin.c @@ -277,6 +277,26 @@ ffmpeg_send_packet(struct decoder *decoder, struct input_stream *is, return cmd; } +static enum sample_format +ffmpeg_sample_format(G_GNUC_UNUSED const AVCodecContext *codec_context) +{ +#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(41<<8)+0) + int bits = (uint8_t) av_get_bits_per_sample_format(codec_context->sample_fmt); + + /* XXX implement & test other sample formats */ + + switch (bits) { + case 16: + return SAMPLE_FORMAT_S16; + } + + return SAMPLE_FORMAT_UNDEFINED; +#else + /* XXX fixme 16-bit for older ffmpeg (13 Aug 2007) */ + return SAMPLE_FORMAT_S16; +#endif +} + static bool ffmpeg_decode_internal(struct ffmpeg_context *ctx) { @@ -288,7 +308,6 @@ ffmpeg_decode_internal(struct ffmpeg_context *ctx) struct audio_format audio_format; enum decoder_command cmd; int total_time; - uint8_t bits; total_time = 0; @@ -296,14 +315,9 @@ ffmpeg_decode_internal(struct ffmpeg_context *ctx) codec_context->channels = 2; } -#if LIBAVCODEC_VERSION_INT >= ((51<<16)+(41<<8)+0) - bits = (uint8_t) av_get_bits_per_sample_format(codec_context->sample_fmt); -#else - /* XXX fixme 16-bit for older ffmpeg (13 Aug 2007) */ - bits = (uint8_t) 16; -#endif if (!audio_format_init_checked(&audio_format, - codec_context->sample_rate, bits, + codec_context->sample_rate, + ffmpeg_sample_format(codec_context), codec_context->channels, &error)) { g_warning("%s", error->message); g_error_free(error); diff --git a/src/decoder/flac_pcm.c b/src/decoder/flac_pcm.c index 737d5b043..a8bf6f293 100644 --- a/src/decoder/flac_pcm.c +++ b/src/decoder/flac_pcm.c @@ -20,6 +20,8 @@ #include "config.h" #include "flac_pcm.h" +#include <assert.h> + static void flac_convert_stereo16(int16_t *dest, const FLAC__int32 * const buf[], unsigned int position, unsigned int end) @@ -74,12 +76,12 @@ flac_convert_8(int8_t *dest, void flac_convert(void *dest, - unsigned int num_channels, unsigned sample_format, + unsigned int num_channels, enum sample_format sample_format, const FLAC__int32 *const buf[], unsigned int position, unsigned int end) { switch (sample_format) { - case 16: + case SAMPLE_FORMAT_S16: if (num_channels == 2) flac_convert_stereo16((int16_t*)dest, buf, position, end); @@ -88,15 +90,19 @@ flac_convert(void *dest, position, end); break; - case 24: - case 32: + case SAMPLE_FORMAT_S24_P32: + case SAMPLE_FORMAT_S32: flac_convert_32((int32_t*)dest, num_channels, buf, position, end); break; - case 8: + case SAMPLE_FORMAT_S8: flac_convert_8((int8_t*)dest, num_channels, buf, position, end); break; + + case SAMPLE_FORMAT_UNDEFINED: + /* unreachable */ + assert(false); } } diff --git a/src/decoder/flac_pcm.h b/src/decoder/flac_pcm.h index dca9d6824..4d7a51c4d 100644 --- a/src/decoder/flac_pcm.h +++ b/src/decoder/flac_pcm.h @@ -20,11 +20,13 @@ #ifndef MPD_FLAC_PCM_H #define MPD_FLAC_PCM_H +#include "audio_format.h" + #include <FLAC/ordinals.h> void flac_convert(void *dest, - unsigned int num_channels, unsigned sample_format, + unsigned int num_channels, enum sample_format sample_format, const FLAC__int32 *const buf[], unsigned int position, unsigned int end); diff --git a/src/decoder/fluidsynth_plugin.c b/src/decoder/fluidsynth_plugin.c index 3e8a4edc4..1b1e6a531 100644 --- a/src/decoder/fluidsynth_plugin.c +++ b/src/decoder/fluidsynth_plugin.c @@ -88,7 +88,7 @@ fluidsynth_file_decode(struct decoder *decoder, const char *path_fs) { static const struct audio_format audio_format = { .sample_rate = 48000, - .bits = 16, + .format = SAMPLE_FORMAT_S16, .channels = 2, }; char setting_sample_rate[] = "synth.sample-rate"; diff --git a/src/decoder/mad_plugin.c b/src/decoder/mad_plugin.c index da93fe45b..cba40aea0 100644 --- a/src/decoder/mad_plugin.c +++ b/src/decoder/mad_plugin.c @@ -1188,7 +1188,8 @@ mp3_decode(struct decoder *decoder, struct input_stream *input_stream) } if (!audio_format_init_checked(&audio_format, - data.frame.header.samplerate, 24, + data.frame.header.samplerate, + SAMPLE_FORMAT_S24_P32, MAD_NCHANNELS(&data.frame.header), &error)) { g_warning("%s", error->message); diff --git a/src/decoder/mikmod_plugin.c b/src/decoder/mikmod_plugin.c index 204dd5ce0..1e64aeffd 100644 --- a/src/decoder/mikmod_plugin.c +++ b/src/decoder/mikmod_plugin.c @@ -163,7 +163,7 @@ mikmod_decoder_file_decode(struct decoder *decoder, const char *path_fs) /* Prevent module from looping forever */ handle->loop = 0; - audio_format_init(&audio_format, mikmod_sample_rate, 16, 2); + audio_format_init(&audio_format, mikmod_sample_rate, SAMPLE_FORMAT_S16, 2); assert(audio_format_valid(&audio_format)); decoder_initialized(decoder, &audio_format, false, 0); diff --git a/src/decoder/modplug_plugin.c b/src/decoder/modplug_plugin.c index 6c08c2199..02292992d 100644 --- a/src/decoder/modplug_plugin.c +++ b/src/decoder/modplug_plugin.c @@ -122,7 +122,7 @@ mod_decode(struct decoder *decoder, struct input_stream *is) return; } - audio_format_init(&audio_format, 44100, 16, 2); + audio_format_init(&audio_format, 44100, SAMPLE_FORMAT_S16, 2); assert(audio_format_valid(&audio_format)); decoder_initialized(decoder, &audio_format, diff --git a/src/decoder/mp4ff_plugin.c b/src/decoder/mp4ff_plugin.c index 70ca4bdc3..8d3a4b9e9 100644 --- a/src/decoder/mp4ff_plugin.c +++ b/src/decoder/mp4ff_plugin.c @@ -132,7 +132,8 @@ mp4_faad_new(mp4ff_t *mp4fh, int *track_r, struct audio_format *audio_format) return NULL; } - if (!audio_format_init_checked(audio_format, sample_rate, 16, channels, + if (!audio_format_init_checked(audio_format, sample_rate, + SAMPLE_FORMAT_S16, channels, &error)) { g_warning("%s", error->message); g_error_free(error); diff --git a/src/decoder/mpcdec_plugin.c b/src/decoder/mpcdec_plugin.c index d985f8459..2f1936e55 100644 --- a/src/decoder/mpcdec_plugin.c +++ b/src/decoder/mpcdec_plugin.c @@ -196,7 +196,8 @@ mpcdec_decode(struct decoder *mpd_decoder, struct input_stream *is) mpc_demux_get_info(demux, &info); #endif - if (!audio_format_init_checked(&audio_format, info.sample_freq, 24, + if (!audio_format_init_checked(&audio_format, info.sample_freq, + SAMPLE_FORMAT_S24_P32, info.channels, &error)) { g_warning("%s", error->message); g_error_free(error); diff --git a/src/decoder/mpg123_decoder_plugin.c b/src/decoder/mpg123_decoder_plugin.c index 922e56484..62e6b00b0 100644 --- a/src/decoder/mpg123_decoder_plugin.c +++ b/src/decoder/mpg123_decoder_plugin.c @@ -87,7 +87,7 @@ mpd_mpg123_open(mpg123_handle *handle, const char *path_fs, return false; } - if (!audio_format_init_checked(audio_format, rate, 16, + if (!audio_format_init_checked(audio_format, rate, SAMPLE_FORMAT_S16, channels, &gerror)) { g_warning("%s", gerror->message); g_error_free(gerror); diff --git a/src/decoder/sidplay_plugin.cxx b/src/decoder/sidplay_plugin.cxx index b6e557e08..63e46a285 100644 --- a/src/decoder/sidplay_plugin.cxx +++ b/src/decoder/sidplay_plugin.cxx @@ -277,7 +277,7 @@ sidplay_file_decode(struct decoder *decoder, const char *path_fs) /* initialize the MPD decoder */ struct audio_format audio_format; - audio_format_init(&audio_format, 48000, 16, 2); + audio_format_init(&audio_format, 48000, SAMPLE_FORMAT_S16, 2); assert(audio_format_valid(&audio_format)); decoder_initialized(decoder, &audio_format, true, (float)song_len); diff --git a/src/decoder/sndfile_decoder_plugin.c b/src/decoder/sndfile_decoder_plugin.c index 84835c449..fee0f8292 100644 --- a/src/decoder/sndfile_decoder_plugin.c +++ b/src/decoder/sndfile_decoder_plugin.c @@ -130,7 +130,8 @@ sndfile_stream_decode(struct decoder *decoder, struct input_stream *is) /* for now, always read 32 bit samples. Later, we could lower MPD's CPU usage by reading 16 bit samples with sf_readf_short() on low-quality source files. */ - if (!audio_format_init_checked(&audio_format, info.samplerate, 32, + if (!audio_format_init_checked(&audio_format, info.samplerate, + SAMPLE_FORMAT_S32, info.channels, &error)) { g_warning("%s", error->message); g_error_free(error); diff --git a/src/decoder/vorbis_plugin.c b/src/decoder/vorbis_plugin.c index 3a41869a0..cb61e5999 100755 --- a/src/decoder/vorbis_plugin.c +++ b/src/decoder/vorbis_plugin.c @@ -311,7 +311,8 @@ vorbis_stream_decode(struct decoder *decoder, return; } - if (!audio_format_init_checked(&audio_format, vi->rate, 16, + if (!audio_format_init_checked(&audio_format, vi->rate, + SAMPLE_FORMAT_S16, vi->channels, &error)) { g_warning("%s", error->message); g_error_free(error); diff --git a/src/decoder/wavpack_plugin.c b/src/decoder/wavpack_plugin.c index 9b32a79f2..dffa078f9 100644 --- a/src/decoder/wavpack_plugin.c +++ b/src/decoder/wavpack_plugin.c @@ -123,6 +123,33 @@ format_samples_float(G_GNUC_UNUSED int bytes_per_sample, void *buffer, } } +/** + * Choose a MPD sample format from libwavpacks' number of bits. + */ +static enum sample_format +wavpack_bits_to_sample_format(bool is_float, int bytes_per_sample) +{ + if (is_float) + return SAMPLE_FORMAT_S24_P32; + + switch (bytes_per_sample) { + case 1: + return SAMPLE_FORMAT_S8; + + case 2: + return SAMPLE_FORMAT_S16; + + case 3: + return SAMPLE_FORMAT_S24_P32; + + case 4: + return SAMPLE_FORMAT_S32; + + default: + return SAMPLE_FORMAT_UNDEFINED; + } +} + /* * This does the main decoding thing. * Requires an already opened WavpackContext. @@ -132,7 +159,8 @@ wavpack_decode(struct decoder *decoder, WavpackContext *wpc, bool can_seek, struct replay_gain_info *replay_gain_info) { GError *error = NULL; - unsigned bits; + bool is_float; + enum sample_format sample_format; struct audio_format audio_format; format_samples_t format_samples; char chunk[CHUNK_SIZE]; @@ -141,19 +169,14 @@ wavpack_decode(struct decoder *decoder, WavpackContext *wpc, bool can_seek, int bytes_per_sample, output_sample_size; int position; - bits = WavpackGetBitsPerSample(wpc); - - /* round bitwidth to 8-bit units */ - bits = (bits + 7) & (~7); - /* MPD handles max 32-bit samples */ - if (bits > 32) - bits = 32; - - if ((WavpackGetMode(wpc) & MODE_FLOAT) == MODE_FLOAT) - bits = 24; + is_float = (WavpackGetMode(wpc) & MODE_FLOAT) != 0; + sample_format = + wavpack_bits_to_sample_format(is_float, + WavpackGetBytesPerSample(wpc)); if (!audio_format_init_checked(&audio_format, - WavpackGetSampleRate(wpc), bits, + WavpackGetSampleRate(wpc), + sample_format, WavpackGetNumChannels(wpc), &error)) { g_warning("%s", error->message); g_error_free(error); diff --git a/src/decoder/wildmidi_plugin.c b/src/decoder/wildmidi_plugin.c index 718f24c2e..70b4d5ef9 100644 --- a/src/decoder/wildmidi_plugin.c +++ b/src/decoder/wildmidi_plugin.c @@ -59,7 +59,7 @@ wildmidi_file_decode(struct decoder *decoder, const char *path_fs) { static const struct audio_format audio_format = { .sample_rate = WILDMIDI_SAMPLE_RATE, - .bits = 16, + .format = SAMPLE_FORMAT_S16, .channels = 2, }; midi *wm; diff --git a/src/encoder/flac_encoder.c b/src/encoder/flac_encoder.c index ab7dc0c39..4f80fe568 100644 --- a/src/encoder/flac_encoder.c +++ b/src/encoder/flac_encoder.c @@ -89,7 +89,8 @@ flac_encoder_finish(struct encoder *_encoder) } static bool -flac_encoder_setup(struct flac_encoder *encoder, GError **error) +flac_encoder_setup(struct flac_encoder *encoder, unsigned bits_per_sample, + GError **error) { if ( !FLAC__stream_encoder_set_compression_level(encoder->fse, encoder->compression)) { @@ -106,10 +107,10 @@ flac_encoder_setup(struct flac_encoder *encoder, GError **error) return false; } if ( !FLAC__stream_encoder_set_bits_per_sample(encoder->fse, - encoder->audio_format.bits)) { + bits_per_sample)) { g_set_error(error, flac_encoder_quark(), 0, "error setting flac bit format to %d", - encoder->audio_format.bits); + bits_per_sample); return false; } if ( !FLAC__stream_encoder_set_sample_rate(encoder->fse, @@ -143,13 +144,29 @@ flac_encoder_open(struct encoder *_encoder, struct audio_format *audio_format, GError **error) { struct flac_encoder *encoder = (struct flac_encoder *)_encoder; + unsigned bits_per_sample; FLAC__StreamEncoderInitStatus init_status; encoder->audio_format = *audio_format; /* FIXME: flac should support 32bit as well */ - if (audio_format->bits > 24) - audio_format->bits = 24; + switch (audio_format->format) { + case SAMPLE_FORMAT_S8: + bits_per_sample = 8; + break; + + case SAMPLE_FORMAT_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; + } /* allocate the encoder */ encoder->fse = FLAC__stream_encoder_new(); @@ -159,7 +176,7 @@ flac_encoder_open(struct encoder *_encoder, struct audio_format *audio_format, return false; } - if (!flac_encoder_setup(encoder, error)) { + if (!flac_encoder_setup(encoder, bits_per_sample, error)) { FLAC__stream_encoder_delete(encoder->fse); return false; } @@ -237,20 +254,23 @@ flac_encoder_write(struct encoder *_encoder, num_frames = length / audio_format_frame_size(&encoder->audio_format); num_samples = num_frames * encoder->audio_format.channels; - switch (encoder->audio_format.bits) { - case 8: + switch (encoder->audio_format.format) { + case SAMPLE_FORMAT_S8: exbuffer = pcm_buffer_get(&encoder->expand_buffer, length*4); pcm8_to_flac(exbuffer, data, num_samples); buffer = exbuffer; break; - case 16: + + case SAMPLE_FORMAT_S16: exbuffer = pcm_buffer_get(&encoder->expand_buffer, length*2); pcm16_to_flac(exbuffer, data, num_samples); buffer = exbuffer; break; - case 24: - case 32: /* nothing need to be done - * format is the same for both mpd and libFLAC */ + + 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; } diff --git a/src/encoder/lame_encoder.c b/src/encoder/lame_encoder.c index 812ff39c5..97431a817 100644 --- a/src/encoder/lame_encoder.c +++ b/src/encoder/lame_encoder.c @@ -185,7 +185,7 @@ lame_encoder_open(struct encoder *_encoder, struct audio_format *audio_format, { struct lame_encoder *encoder = (struct lame_encoder *)_encoder; - audio_format->bits = 16; + audio_format->format = SAMPLE_FORMAT_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 cddf5773e..e7af89bf6 100644 --- a/src/encoder/twolame_encoder.c +++ b/src/encoder/twolame_encoder.c @@ -192,7 +192,7 @@ twolame_encoder_open(struct encoder *_encoder, struct audio_format *audio_format { struct twolame_encoder *encoder = (struct twolame_encoder *)_encoder; - audio_format->bits = 16; + audio_format->format = SAMPLE_FORMAT_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 2fa0fd950..d072bcd3f 100644 --- a/src/encoder/vorbis_encoder.c +++ b/src/encoder/vorbis_encoder.c @@ -212,7 +212,7 @@ vorbis_encoder_open(struct encoder *_encoder, struct vorbis_encoder *encoder = (struct vorbis_encoder *)_encoder; bool ret; - audio_format->bits = 16; + audio_format->format = SAMPLE_FORMAT_S16; encoder->audio_format = *audio_format; diff --git a/src/encoder/wave_encoder.c b/src/encoder/wave_encoder.c index e66cc1917..f34ae0241 100644 --- a/src/encoder/wave_encoder.c +++ b/src/encoder/wave_encoder.c @@ -114,16 +114,39 @@ wave_encoder_open(struct encoder *_encoder, struct wave_encoder *encoder = (struct wave_encoder *)_encoder; void *buffer; - encoder->bits = audio_format->bits; + assert(audio_format_valid(audio_format)); + + switch (audio_format->format) { + case SAMPLE_FORMAT_S8: + encoder->bits = 8; + break; + + case SAMPLE_FORMAT_S16: + encoder->bits = 16; + break; + + case SAMPLE_FORMAT_S24_P32: + encoder->bits = 24; + break; + + case SAMPLE_FORMAT_S32: + encoder->bits = 32; + break; + + default: + audio_format->format = SAMPLE_FORMAT_S16; + encoder->bits = 16; + break; + } buffer = pcm_buffer_get(&encoder->buffer, sizeof(struct wave_header) ); /* create PCM wave header in initial buffer */ fill_wave_header((struct wave_header *) buffer, audio_format->channels, - audio_format->bits, + encoder->bits, audio_format->sample_rate, - (audio_format->bits / 8) * audio_format->channels ); + (encoder->bits / 8) * audio_format->channels ); encoder->buffer_length = sizeof(struct wave_header); return true; diff --git a/src/filter/volume_filter_plugin.c b/src/filter/volume_filter_plugin.c index f6639a75f..285a4b7a4 100644 --- a/src/filter/volume_filter_plugin.c +++ b/src/filter/volume_filter_plugin.c @@ -75,8 +75,9 @@ volume_filter_open(struct filter *_filter, { struct volume_filter *filter = (struct volume_filter *)_filter; - if (audio_format->bits != 8 && audio_format->bits != 16 && - audio_format->bits != 24) { + if (audio_format->format != SAMPLE_FORMAT_S8 && + audio_format->format != SAMPLE_FORMAT_S16 && + audio_format->format != SAMPLE_FORMAT_S24_P32) { g_set_error(error_r, volume_quark(), 0, "Unsupported audio format"); return false; diff --git a/src/normalize.c b/src/normalize.c index f9201df64..1c8173def 100644 --- a/src/normalize.c +++ b/src/normalize.c @@ -47,7 +47,8 @@ void finishNormalization(void) void normalizeData(void *buffer, int bufferSize, const struct audio_format *format) { - if ((format->bits != 16) || (format->channels != 2)) return; + if (format->format != SAMPLE_FORMAT_S16 || format->channels != 2) + return; Compressor_Process_int16(compressor, buffer, bufferSize / 2); } diff --git a/src/output/alsa_plugin.c b/src/output/alsa_plugin.c index 2c642015d..b7325de07 100644 --- a/src/output/alsa_plugin.c +++ b/src/output/alsa_plugin.c @@ -185,13 +185,22 @@ alsa_test_default_device(void) static snd_pcm_format_t get_bitformat(const struct audio_format *af) { - switch (af->bits) { - case 8: return SND_PCM_FORMAT_S8; - case 16: return SND_PCM_FORMAT_S16; - case 24: return SND_PCM_FORMAT_S24; - case 32: return SND_PCM_FORMAT_S32; + switch (af->format) { + case SAMPLE_FORMAT_S8: + return SND_PCM_FORMAT_S8; + + case SAMPLE_FORMAT_S16: + return SND_PCM_FORMAT_S16; + + case SAMPLE_FORMAT_S24_P32: + return SND_PCM_FORMAT_S24; + + case SAMPLE_FORMAT_S32: + return SND_PCM_FORMAT_S32; + + default: + return SND_PCM_FORMAT_UNKNOWN; } - return SND_PCM_FORMAT_UNKNOWN; } static snd_pcm_format_t @@ -264,61 +273,67 @@ configure_hw: err = snd_pcm_hw_params_set_format(ad->pcm, hwparams, byteswap_bitformat(bitformat)); if (err == 0) { - g_debug("ALSA device \"%s\": converting %u bit to reverse-endian\n", - alsa_device(ad), audio_format->bits); + g_debug("ALSA device \"%s\": converting format %s to reverse-endian", + alsa_device(ad), + sample_format_to_string(audio_format->format)); audio_format->reverse_endian = 1; } } - if (err == -EINVAL && (audio_format->bits == 24 || - audio_format->bits == 16)) { + if (err == -EINVAL && (audio_format->format == SAMPLE_FORMAT_S24_P32 || + audio_format->format == SAMPLE_FORMAT_S16)) { /* fall back to 32 bit, let pcm_convert.c do the conversion */ err = snd_pcm_hw_params_set_format(ad->pcm, hwparams, SND_PCM_FORMAT_S32); if (err == 0) { - g_debug("ALSA device \"%s\": converting %u bit to 32 bit\n", - alsa_device(ad), audio_format->bits); - audio_format->bits = 32; + g_debug("ALSA device \"%s\": converting format %s to 32 bit\n", + alsa_device(ad), + sample_format_to_string(audio_format->format)); + audio_format->format = SAMPLE_FORMAT_S32; } } - if (err == -EINVAL && (audio_format->bits == 24 || - audio_format->bits == 16)) { + if (err == -EINVAL && (audio_format->format == SAMPLE_FORMAT_S24_P32 || + audio_format->format == SAMPLE_FORMAT_S16)) { /* fall back to 32 bit, let pcm_convert.c do the conversion */ err = snd_pcm_hw_params_set_format(ad->pcm, hwparams, byteswap_bitformat(SND_PCM_FORMAT_S32)); if (err == 0) { - g_debug("ALSA device \"%s\": converting %u bit to 32 bit backward-endian\n", - alsa_device(ad), audio_format->bits); - audio_format->bits = 32; + g_debug("ALSA device \"%s\": converting format %s to 32 bit backward-endian\n", + alsa_device(ad), + sample_format_to_string(audio_format->format)); + audio_format->format = SAMPLE_FORMAT_S32; audio_format->reverse_endian = 1; } } - if (err == -EINVAL && audio_format->bits != 16) { + if (err == -EINVAL && audio_format->format != SAMPLE_FORMAT_S16) { /* fall back to 16 bit, let pcm_convert.c do the conversion */ err = snd_pcm_hw_params_set_format(ad->pcm, hwparams, SND_PCM_FORMAT_S16); if (err == 0) { - g_debug("ALSA device \"%s\": converting %u bit to 16 bit\n", - alsa_device(ad), audio_format->bits); - audio_format->bits = 16; + g_debug("ALSA device \"%s\": converting format %s to 16 bit\n", + alsa_device(ad), + sample_format_to_string(audio_format->format)); + audio_format->format = SAMPLE_FORMAT_S16; } } - if (err == -EINVAL && audio_format->bits != 16) { + if (err == -EINVAL && audio_format->format != SAMPLE_FORMAT_S16) { /* fall back to 16 bit, let pcm_convert.c do the conversion */ err = snd_pcm_hw_params_set_format(ad->pcm, hwparams, byteswap_bitformat(SND_PCM_FORMAT_S16)); if (err == 0) { - g_debug("ALSA device \"%s\": converting %u bit to 16 bit backward-endian\n", - alsa_device(ad), audio_format->bits); - audio_format->bits = 16; + g_debug("ALSA device \"%s\": converting format %s to 16 bit backward-endian\n", + alsa_device(ad), + sample_format_to_string(audio_format->format)); + audio_format->format = SAMPLE_FORMAT_S16; audio_format->reverse_endian = 1; } } if (err < 0) { g_set_error(error, alsa_output_quark(), err, - "ALSA device \"%s\" does not support %u bit audio: %s", - alsa_device(ad), audio_format->bits, + "ALSA device \"%s\" does not support format %s: %s", + alsa_device(ad), + sample_format_to_string(audio_format->format), snd_strerror(-err)); return false; } @@ -449,7 +464,7 @@ alsa_open(void *data, struct audio_format *audio_format, GError **error) /* sample format is not supported by this plugin - fall back to 16 bit samples */ - audio_format->bits = 16; + audio_format->format = SAMPLE_FORMAT_S16; bitformat = SND_PCM_FORMAT_S16; } diff --git a/src/output/ao_plugin.c b/src/output/ao_plugin.c index d69175272..7afca0db2 100644 --- a/src/output/ao_plugin.c +++ b/src/output/ao_plugin.c @@ -170,13 +170,24 @@ ao_output_open(void *data, struct audio_format *audio_format, ao_sample_format format; struct ao_data *ad = (struct ao_data *)data; - /* support for 24 bit samples in libao is currently dubious, - and until we have sorted that out, resample everything to - 16 bit */ - if (audio_format->bits > 16) - audio_format->bits = 16; + switch (audio_format->format) { + case SAMPLE_FORMAT_S8: + format.bits = 8; + break; + + case SAMPLE_FORMAT_S16: + format.bits = 16; + break; + + default: + /* 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; + format.bits = 16; + break; + } - format.bits = audio_format->bits; format.rate = audio_format->sample_rate; format.byte_format = AO_FMT_NATIVE; format.channels = audio_format->channels; diff --git a/src/output/jack_output_plugin.c b/src/output/jack_output_plugin.c index 7e5a52993..f50bc37d0 100644 --- a/src/output/jack_output_plugin.c +++ b/src/output/jack_output_plugin.c @@ -157,8 +157,9 @@ 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->bits != 16 && audio_format->bits != 24) - audio_format->bits = 24; + if (audio_format->format != SAMPLE_FORMAT_S16 && + audio_format->format != SAMPLE_FORMAT_S24_P32) + audio_format->format = SAMPLE_FORMAT_S24_P32; } static void @@ -606,13 +607,13 @@ static void mpd_jack_write_samples(struct jack_data *jd, const void *src, unsigned num_samples) { - switch (jd->audio_format.bits) { - case 16: + switch (jd->audio_format.format) { + case SAMPLE_FORMAT_S16: mpd_jack_write_samples_16(jd, (const int16_t*)src, num_samples); break; - case 24: + case SAMPLE_FORMAT_S24_P32: mpd_jack_write_samples_24(jd, (const int32_t*)src, num_samples); break; diff --git a/src/output/mvp_plugin.c b/src/output/mvp_plugin.c index 5a9a9b48b..86f147e5a 100644 --- a/src/output/mvp_plugin.c +++ b/src/output/mvp_plugin.c @@ -172,19 +172,19 @@ mvp_set_pcm_params(struct mvp_data *md, struct audio_format *audio_format, } /* 0,1=24bit(24) , 2,3=16bit */ - switch (audio_format->bits) { - case 16: + switch (audio_format->format) { + case SAMPLE_FORMAT_S16: mix[1] = 2; break; - case 24: + case SAMPLE_FORMAT_S24_P32: mix[1] = 0; break; default: - g_debug("unsupported sample format %u - falling back to stereo", - audio_format->bits); - audio_format->bits = 16; + g_debug("unsupported sample format %s - falling back to 16 bit", + sample_format_to_string(audio_format->format)); + audio_format->format = SAMPLE_FORMAT_S16; mix[1] = 2; break; } diff --git a/src/output/openal_plugin.c b/src/output/openal_plugin.c index 8fda110e1..0aded4d9a 100644 --- a/src/output/openal_plugin.c +++ b/src/output/openal_plugin.c @@ -58,25 +58,29 @@ openal_output_quark(void) static ALenum openal_audio_format(struct audio_format *audio_format) { - /* Only 8 and 16 bit samples are supported */ - if (audio_format->bits != 16 && audio_format->bits != 8) - audio_format->bits = 16; - - switch (audio_format->bits) - { - case 16: + switch (audio_format->format) { + case SAMPLE_FORMAT_S16: if (audio_format->channels == 2) return AL_FORMAT_STEREO16; if (audio_format->channels == 1) return AL_FORMAT_MONO16; break; - case 8: + case SAMPLE_FORMAT_S8: if (audio_format->channels == 2) return AL_FORMAT_STEREO8; if (audio_format->channels == 1) return AL_FORMAT_MONO8; break; + + default: + /* fall back to 16 bit */ + audio_format->format = SAMPLE_FORMAT_S16; + if (audio_format->channels == 2) + return AL_FORMAT_STEREO16; + if (audio_format->channels == 1) + return AL_FORMAT_MONO16; + break; } return 0; diff --git a/src/output/oss_plugin.c b/src/output/oss_plugin.c index b02d7d62e..f16374e39 100644 --- a/src/output/oss_plugin.c +++ b/src/output/oss_plugin.c @@ -490,17 +490,18 @@ oss_setup(struct oss_data *od, GError **error) } od->audio_format.sample_rate = tmp; - switch (od->audio_format.bits) { - case 8: + switch (od->audio_format.format) { + case SAMPLE_FORMAT_S8: tmp = AFMT_S8; break; - case 16: + + case SAMPLE_FORMAT_S16: tmp = AFMT_S16_MPD; break; default: /* not supported by OSS - fall back to 16 bit */ - od->audio_format.bits = 16; + od->audio_format.format = SAMPLE_FORMAT_S16; tmp = AFMT_S16_MPD; break; } diff --git a/src/output/osx_plugin.c b/src/output/osx_plugin.c index afcd143b3..22b742ee5 100644 --- a/src/output/osx_plugin.c +++ b/src/output/osx_plugin.c @@ -166,9 +166,6 @@ osx_output_open(void *data, struct audio_format *audio_format, GError **error) OSStatus status; ComponentResult result; - if (audio_format->bits > 16) - audio_format->bits = 16; - desc.componentType = kAudioUnitType_Output; desc.componentSubType = kAudioUnitSubType_DefaultOutput; desc.componentManufacturer = kAudioUnitManufacturer_Apple; @@ -226,7 +223,21 @@ osx_output_open(void *data, struct audio_format *audio_format, GError **error) stream_description.mFramesPerPacket = 1; stream_description.mBytesPerFrame = stream_description.mBytesPerPacket; stream_description.mChannelsPerFrame = audio_format->channels; - stream_description.mBitsPerChannel = audio_format->bits; + + switch (audio_format->format) { + case SAMPLE_FORMAT_S8: + stream_description.mBitsPerChannel = 8; + break; + + case SAMPLE_FORMAT_S16: + stream_description.mBitsPerChannel = 16; + break; + + default: + audio_format->format = SAMPLE_FORMAT_S16; + stream_description.mBitsPerChannel = 16; + break; + } result = AudioUnitSetProperty(od->au, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, 0, diff --git a/src/output/pulse_output_plugin.c b/src/output/pulse_output_plugin.c index 3da1b3593..a64157920 100644 --- a/src/output/pulse_output_plugin.c +++ b/src/output/pulse_output_plugin.c @@ -467,7 +467,7 @@ pulse_output_open(void *data, 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->bits = 16; + audio_format->format = SAMPLE_FORMAT_S16; ss.format = PA_SAMPLE_S16NE; ss.rate = audio_format->sample_rate; diff --git a/src/output/solaris_output_plugin.c b/src/output/solaris_output_plugin.c index b187630ee..fe84068f1 100644 --- a/src/output/solaris_output_plugin.c +++ b/src/output/solaris_output_plugin.c @@ -89,7 +89,7 @@ solaris_output_open(void *data, struct audio_format *audio_format, /* support only 16 bit mono/stereo for now; nothing else has been tested */ - audio_format->bits = 16; + audio_format->format = SAMPLE_FORMAT_S16; /* open the device in non-blocking mode */ @@ -119,7 +119,7 @@ solaris_output_open(void *data, struct audio_format *audio_format, info.play.sample_rate = audio_format->sample_rate; info.play.channels = audio_format->channels; - info.play.precision = audio_format->bits; + info.play.precision = 16; info.play.encoding = AUDIO_ENCODING_LINEAR; ret = ioctl(so->fd, AUDIO_SETINFO, &info); diff --git a/src/pcm_convert.c b/src/pcm_convert.c index 1d6299964..8d529dd5f 100644 --- a/src/pcm_convert.c +++ b/src/pcm_convert.c @@ -63,15 +63,15 @@ pcm_convert_16(struct pcm_convert_state *state, const int16_t *buf; size_t len; - assert(dest_format->bits == 16); + assert(dest_format->format == SAMPLE_FORMAT_S16); buf = pcm_convert_to_16(&state->format_buffer, &state->dither, - src_format->bits, src_buffer, src_size, + src_format->format, src_buffer, src_size, &len); if (buf == NULL) { g_set_error(error_r, pcm_convert_quark(), 0, - "Conversion from %u to 16 bit is not implemented", - src_format->bits); + "Conversion from %s to 16 bit is not implemented", + sample_format_to_string(src_format->format)); return NULL; } @@ -119,14 +119,14 @@ pcm_convert_24(struct pcm_convert_state *state, const int32_t *buf; size_t len; - assert(dest_format->bits == 24); + assert(dest_format->format == SAMPLE_FORMAT_S24_P32); - buf = pcm_convert_to_24(&state->format_buffer, src_format->bits, + buf = pcm_convert_to_24(&state->format_buffer, src_format->format, src_buffer, src_size, &len); if (buf == NULL) { g_set_error(error_r, pcm_convert_quark(), 0, - "Conversion from %u to 24 bit is not implemented", - src_format->bits); + "Conversion from %s to 24 bit is not implemented", + sample_format_to_string(src_format->format)); return NULL; } @@ -174,14 +174,14 @@ pcm_convert_32(struct pcm_convert_state *state, const int32_t *buf; size_t len; - assert(dest_format->bits == 32); + assert(dest_format->format == SAMPLE_FORMAT_S32); - buf = pcm_convert_to_32(&state->format_buffer, src_format->bits, + buf = pcm_convert_to_32(&state->format_buffer, src_format->format, src_buffer, src_size, &len); if (buf == NULL) { g_set_error(error_r, pcm_convert_quark(), 0, - "Conversion from %u to 24 bit is not implemented", - src_format->bits); + "Conversion from %s to 24 bit is not implemented", + sample_format_to_string(src_format->format)); return NULL; } @@ -227,20 +227,20 @@ pcm_convert(struct pcm_convert_state *state, size_t *dest_size_r, GError **error_r) { - switch (dest_format->bits) { - case 16: + switch (dest_format->format) { + case SAMPLE_FORMAT_S16: return pcm_convert_16(state, src_format, src, src_size, dest_format, dest_size_r, error_r); - case 24: + case SAMPLE_FORMAT_S24_P32: return pcm_convert_24(state, src_format, src, src_size, dest_format, dest_size_r, error_r); - case 32: + case SAMPLE_FORMAT_S32: return pcm_convert_32(state, src_format, src, src_size, dest_format, dest_size_r, @@ -248,8 +248,8 @@ pcm_convert(struct pcm_convert_state *state, default: g_set_error(error_r, pcm_convert_quark(), 0, - "PCM conversion to %u bit is not implemented", - dest_format->bits); + "PCM conversion to %s is not implemented", + sample_format_to_string(dest_format->format)); return NULL; } } diff --git a/src/pcm_format.c b/src/pcm_format.c index 8da253db9..b0dad2ba3 100644 --- a/src/pcm_format.c +++ b/src/pcm_format.c @@ -50,14 +50,17 @@ pcm_convert_32_to_16(struct pcm_dither *dither, const int16_t * pcm_convert_to_16(struct pcm_buffer *buffer, struct pcm_dither *dither, - uint8_t bits, const void *src, + enum sample_format src_format, const void *src, size_t src_size, size_t *dest_size_r) { unsigned num_samples; int16_t *dest; - switch (bits) { - case 8: + switch (src_format) { + case SAMPLE_FORMAT_UNDEFINED: + break; + + case SAMPLE_FORMAT_S8: num_samples = src_size; *dest_size_r = src_size * sizeof(*dest); dest = pcm_buffer_get(buffer, *dest_size_r); @@ -67,11 +70,11 @@ pcm_convert_to_16(struct pcm_buffer *buffer, struct pcm_dither *dither, num_samples); return dest; - case 16: + case SAMPLE_FORMAT_S16: *dest_size_r = src_size; return src; - case 24: + case SAMPLE_FORMAT_S24_P32: num_samples = src_size / 4; *dest_size_r = num_samples * sizeof(*dest); dest = pcm_buffer_get(buffer, *dest_size_r); @@ -81,7 +84,7 @@ pcm_convert_to_16(struct pcm_buffer *buffer, struct pcm_dither *dither, num_samples); return dest; - case 32: + case SAMPLE_FORMAT_S32: num_samples = src_size / 4; *dest_size_r = num_samples * sizeof(*dest); dest = pcm_buffer_get(buffer, *dest_size_r); @@ -127,14 +130,17 @@ pcm_convert_32_to_24(int32_t *out, const int16_t *in, const int32_t * pcm_convert_to_24(struct pcm_buffer *buffer, - uint8_t bits, const void *src, + enum sample_format src_format, const void *src, size_t src_size, size_t *dest_size_r) { unsigned num_samples; int32_t *dest; - switch (bits) { - case 8: + switch (src_format) { + case SAMPLE_FORMAT_UNDEFINED: + break; + + case SAMPLE_FORMAT_S8: num_samples = src_size; *dest_size_r = src_size * sizeof(*dest); dest = pcm_buffer_get(buffer, *dest_size_r); @@ -143,7 +149,7 @@ pcm_convert_to_24(struct pcm_buffer *buffer, num_samples); return dest; - case 16: + case SAMPLE_FORMAT_S16: num_samples = src_size / 2; *dest_size_r = num_samples * sizeof(*dest); dest = pcm_buffer_get(buffer, *dest_size_r); @@ -152,11 +158,11 @@ pcm_convert_to_24(struct pcm_buffer *buffer, num_samples); return dest; - case 24: + case SAMPLE_FORMAT_S24_P32: *dest_size_r = src_size; return src; - case 32: + case SAMPLE_FORMAT_S32: num_samples = src_size / 4; *dest_size_r = num_samples * sizeof(*dest); dest = pcm_buffer_get(buffer, *dest_size_r); @@ -201,14 +207,17 @@ pcm_convert_24_to_32(int32_t *out, const int32_t *in, const int32_t * pcm_convert_to_32(struct pcm_buffer *buffer, - uint8_t bits, const void *src, + enum sample_format src_format, const void *src, size_t src_size, size_t *dest_size_r) { unsigned num_samples; int32_t *dest; - switch (bits) { - case 8: + switch (src_format) { + case SAMPLE_FORMAT_UNDEFINED: + break; + + case SAMPLE_FORMAT_S8: num_samples = src_size; *dest_size_r = src_size * sizeof(*dest); dest = pcm_buffer_get(buffer, *dest_size_r); @@ -217,7 +226,7 @@ pcm_convert_to_32(struct pcm_buffer *buffer, num_samples); return dest; - case 16: + case SAMPLE_FORMAT_S16: num_samples = src_size / 2; *dest_size_r = num_samples * sizeof(*dest); dest = pcm_buffer_get(buffer, *dest_size_r); @@ -226,7 +235,7 @@ pcm_convert_to_32(struct pcm_buffer *buffer, num_samples); return dest; - case 24: + case SAMPLE_FORMAT_S24_P32: num_samples = src_size / 4; *dest_size_r = num_samples * sizeof(*dest); dest = pcm_buffer_get(buffer, *dest_size_r); @@ -235,7 +244,7 @@ pcm_convert_to_32(struct pcm_buffer *buffer, num_samples); return dest; - case 32: + case SAMPLE_FORMAT_S32: *dest_size_r = src_size; return src; } diff --git a/src/pcm_format.h b/src/pcm_format.h index 350566827..6ea5573bd 100644 --- a/src/pcm_format.h +++ b/src/pcm_format.h @@ -20,6 +20,8 @@ #ifndef PCM_FORMAT_H #define PCM_FORMAT_H +#include "audio_format.h" + #include <stdint.h> #include <stddef.h> @@ -40,7 +42,7 @@ struct pcm_dither; */ const int16_t * pcm_convert_to_16(struct pcm_buffer *buffer, struct pcm_dither *dither, - uint8_t bits, const void *src, + enum sample_format src_format, const void *src, size_t src_size, size_t *dest_size_r); /** @@ -55,7 +57,7 @@ pcm_convert_to_16(struct pcm_buffer *buffer, struct pcm_dither *dither, */ const int32_t * pcm_convert_to_24(struct pcm_buffer *buffer, - uint8_t bits, const void *src, + enum sample_format src_format, const void *src, size_t src_size, size_t *dest_size_r); /** @@ -70,7 +72,7 @@ pcm_convert_to_24(struct pcm_buffer *buffer, */ const int32_t * pcm_convert_to_32(struct pcm_buffer *buffer, - uint8_t bits, const void *src, + enum sample_format src_format, const void *src, size_t src_size, size_t *dest_size_r); #endif diff --git a/src/pcm_mix.c b/src/pcm_mix.c index 6e678a912..0f767a1d9 100644 --- a/src/pcm_mix.c +++ b/src/pcm_mix.c @@ -103,18 +103,18 @@ pcm_add(void *buffer1, const void *buffer2, size_t size, int vol1, int vol2, const struct audio_format *format) { - switch (format->bits) { - case 8: + switch (format->format) { + case SAMPLE_FORMAT_S8: pcm_add_8((int8_t *)buffer1, (const int8_t *)buffer2, size, vol1, vol2); break; - case 16: + case SAMPLE_FORMAT_S16: pcm_add_16((int16_t *)buffer1, (const int16_t *)buffer2, size / 2, vol1, vol2); break; - case 24: + case SAMPLE_FORMAT_S24_P32: pcm_add_24((int32_t*)buffer1, (const int32_t*)buffer2, size / 4, vol1, vol2); @@ -127,7 +127,8 @@ pcm_add(void *buffer1, const void *buffer2, size_t size, break; default: - g_error("%u bits not supported by pcm_add!\n", format->bits); + g_error("format %s not supported by pcm_add", + sample_format_to_string(format->format)); } } diff --git a/src/pcm_volume.c b/src/pcm_volume.c index 90ad17d6d..acb6c41a8 100644 --- a/src/pcm_volume.c +++ b/src/pcm_volume.c @@ -150,17 +150,17 @@ pcm_volume(void *buffer, int length, return true; } - switch (format->bits) { - case 8: + switch (format->format) { + case SAMPLE_FORMAT_S8: pcm_volume_change_8((int8_t *)buffer, length, volume); return true; - case 16: + case SAMPLE_FORMAT_S16: pcm_volume_change_16((int16_t *)buffer, length / 2, volume); return true; - case 24: + case SAMPLE_FORMAT_S24_P32: pcm_volume_change_24((int32_t*)buffer, length / 4, volume); return true; diff --git a/test/run_encoder.c b/test/run_encoder.c index aaafd2e8f..bb73e7b6e 100644 --- a/test/run_encoder.c +++ b/test/run_encoder.c @@ -63,7 +63,7 @@ int main(int argc, char **argv) else encoder_name = "vorbis"; - audio_format_init(&audio_format, 44100, 16, 2); + audio_format_init(&audio_format, 44100, SAMPLE_FORMAT_S16, 2); /* create the encoder */ diff --git a/test/run_filter.c b/test/run_filter.c index 30495b1fd..62cafdbc1 100644 --- a/test/run_filter.c +++ b/test/run_filter.c @@ -85,7 +85,7 @@ int main(int argc, char **argv) return 1; } - audio_format_init(&audio_format, 44100, 16, 2); + audio_format_init(&audio_format, 44100, SAMPLE_FORMAT_S16, 2); g_thread_init(NULL); diff --git a/test/run_output.c b/test/run_output.c index 1acc7b377..9ae4e4c4b 100644 --- a/test/run_output.c +++ b/test/run_output.c @@ -119,7 +119,7 @@ int main(int argc, char **argv) return 1; } - audio_format_init(&audio_format, 44100, 16, 2); + audio_format_init(&audio_format, 44100, SAMPLE_FORMAT_S16, 2); g_thread_init(NULL); diff --git a/test/software_volume.c b/test/software_volume.c index 3b4c5f0fb..11345764d 100644 --- a/test/software_volume.c +++ b/test/software_volume.c @@ -55,7 +55,7 @@ int main(int argc, char **argv) return 1; } } else - audio_format_init(&audio_format, 48000, 16, 2); + audio_format_init(&audio_format, 48000, SAMPLE_FORMAT_S16, 2); while ((nbytes = read(0, buffer, sizeof(buffer))) > 0) { if (!pcm_volume(buffer, nbytes, &audio_format, |