From ec926539a3a7a09b310e74a4fc84902e0971b29d Mon Sep 17 00:00:00 2001
From: Max Kellermann <max@duempel.org>
Date: Thu, 26 Feb 2009 22:04:59 +0100
Subject: [PATCH] output_plugin: report errors with GError
Use GLib's GError library for reporting output device failures.
Note that some init() methods don't clean up properly after a failure,
but that's ok for now, because the MPD core will abort anyway.
---
src/output/alsa_plugin.c | 55 +++++++-----
src/output/ao_plugin.c | 52 ++++++++----
src/output/fifo_plugin.c | 73 ++++++++++------
src/output/jack_plugin.c | 61 +++++++++-----
src/output/mvp_plugin.c | 67 ++++++++++-----
src/output/null_plugin.c | 9 +-
src/output/oss_plugin.c | 75 ++++++++++-------
src/output/osx_plugin.c | 41 ++++++---
src/output/pulse_plugin.c | 26 ++++--
src/output/shout_plugin.c | 173 +++++++++++++++++++++-----------------
src/output_init.c | 11 ++-
src/output_plugin.h | 34 +++++---
src/output_thread.c | 21 ++++-
13 files changed, 443 insertions(+), 255 deletions(-)
diff --git a/src/output/alsa_plugin.c b/src/output/alsa_plugin.c
index 1623dcac8..874e4ac93 100644
--- a/src/output/alsa_plugin.c
+++ b/src/output/alsa_plugin.c
@@ -74,6 +74,15 @@ struct alsa_data {
struct mixer *mixer;
};
+/**
+ * The quark used for GError.domain.
+ */
+static inline GQuark
+alsa_output_quark(void)
+{
+ return g_quark_from_static_string("alsa_output");
+}
+
static const char *
alsa_device(const struct alsa_data *ad)
{
@@ -130,7 +139,8 @@ alsa_configure(struct alsa_data *ad, const struct config_param *param)
static void *
alsa_init(G_GNUC_UNUSED const struct audio_format *audio_format,
- const struct config_param *param)
+ const struct config_param *param,
+ G_GNUC_UNUSED GError **error)
{
/* no need for pthread_once thread-safety when reading config */
static int free_global_registered;
@@ -198,7 +208,8 @@ get_bitformat(const struct audio_format *af)
*/
static bool
alsa_setup(struct alsa_data *ad, struct audio_format *audio_format,
- snd_pcm_format_t bitformat)
+ snd_pcm_format_t bitformat,
+ GError **error)
{
snd_pcm_hw_params_t *hwparams;
snd_pcm_sw_params_t *swparams;
@@ -256,17 +267,20 @@ configure_hw:
}
if (err < 0) {
- g_warning("ALSA device \"%s\" does not support %u bit audio: %s\n",
- alsa_device(ad), audio_format->bits, snd_strerror(-err));
+ g_set_error(error, alsa_output_quark(), err,
+ "ALSA device \"%s\" does not support %u bit audio: %s",
+ alsa_device(ad), audio_format->bits,
+ snd_strerror(-err));
return false;
}
err = snd_pcm_hw_params_set_channels_near(ad->pcm, hwparams,
&channels);
if (err < 0) {
- g_warning("ALSA device \"%s\" does not support %i channels: %s\n",
- alsa_device(ad), (int)audio_format->channels,
- snd_strerror(-err));
+ g_set_error(error, alsa_output_quark(), err,
+ "ALSA device \"%s\" does not support %i channels: %s",
+ alsa_device(ad), (int)audio_format->channels,
+ snd_strerror(-err));
return false;
}
audio_format->channels = (int8_t)channels;
@@ -274,8 +288,9 @@ configure_hw:
err = snd_pcm_hw_params_set_rate_near(ad->pcm, hwparams,
&sample_rate, NULL);
if (err < 0 || sample_rate == 0) {
- g_warning("ALSA device \"%s\" does not support %u Hz audio\n",
- alsa_device(ad), audio_format->sample_rate);
+ g_set_error(error, alsa_output_quark(), err,
+ "ALSA device \"%s\" does not support %u Hz audio",
+ alsa_device(ad), audio_format->sample_rate);
return false;
}
audio_format->sample_rate = sample_rate;
@@ -348,14 +363,14 @@ configure_hw:
return true;
error:
- g_warning("Error opening ALSA device \"%s\" (%s): %s\n",
- alsa_device(ad), cmd, snd_strerror(-err));
-
+ g_set_error(error, alsa_output_quark(), err,
+ "Error opening ALSA device \"%s\" (%s): %s",
+ alsa_device(ad), cmd, snd_strerror(-err));
return false;
}
static bool
-alsa_open(void *data, struct audio_format *audio_format)
+alsa_open(void *data, struct audio_format *audio_format, GError **error)
{
struct alsa_data *ad = data;
snd_pcm_format_t bitformat;
@@ -378,12 +393,13 @@ alsa_open(void *data, struct audio_format *audio_format)
if (err < 0) {
ad->pcm = NULL;
- g_warning("Error opening ALSA device \"%s\": %s\n",
- alsa_device(ad), snd_strerror(-err));
+ g_set_error(error, alsa_output_quark(), err,
+ "Failed to open ALSA device \"%s\": %s",
+ alsa_device(ad), snd_strerror(err));
return false;
}
- success = alsa_setup(ad, audio_format, bitformat);
+ success = alsa_setup(ad, audio_format, bitformat, error);
if (!success) {
snd_pcm_close(ad->pcm);
ad->pcm = NULL;
@@ -463,7 +479,7 @@ alsa_close(void *data)
}
static size_t
-alsa_play(void *data, const void *chunk, size_t size)
+alsa_play(void *data, const void *chunk, size_t size, GError **error)
{
struct alsa_data *ad = data;
int ret;
@@ -477,9 +493,8 @@ alsa_play(void *data, const void *chunk, size_t size)
if (ret < 0 && ret != -EAGAIN && ret != -EINTR &&
alsa_recover(ad, ret) < 0) {
- g_warning("closing ALSA device \"%s\" due to write "
- "error: %s\n",
- alsa_device(ad), snd_strerror(-errno));
+ g_set_error(error, alsa_output_quark(), errno,
+ "%s", snd_strerror(-errno));
return 0;
}
}
diff --git a/src/output/ao_plugin.c b/src/output/ao_plugin.c
index 565384b7b..09d345fd9 100644
--- a/src/output/ao_plugin.c
+++ b/src/output/ao_plugin.c
@@ -33,8 +33,14 @@ struct ao_data {
ao_device *device;
} AoData;
+static inline GQuark
+ao_output_quark(void)
+{
+ return g_quark_from_static_string("ao_output");
+}
+
static void
-ao_output_error(const char *msg)
+ao_output_error(GError **error_r)
{
const char *error;
@@ -63,12 +69,14 @@ ao_output_error(const char *msg)
error = strerror(errno);
}
- g_warning("%s: %s\n", msg, error);
+ g_set_error(error_r, ao_output_quark(), errno,
+ "%s", error);
}
static void *
ao_output_init(G_GNUC_UNUSED const struct audio_format *audio_format,
- const struct config_param *param)
+ const struct config_param *param,
+ GError **error)
{
struct ao_data *ad = g_new(struct ao_data, 1);
ao_info *ai;
@@ -84,15 +92,22 @@ ao_output_init(G_GNUC_UNUSED const struct audio_format *audio_format,
ao_output_ref++;
value = config_get_block_string(param, "driver", "default");
- if (0 == strcmp(value, "default")) {
+ if (0 == strcmp(value, "default"))
ad->driver = ao_default_driver_id();
- } else if ((ad->driver = ao_driver_id(value)) < 0)
- g_error("\"%s\" is not a valid ao driver at line %i\n",
- value, param->line);
+ else
+ ad->driver = ao_driver_id(value);
+
+ if (ad->driver < 0) {
+ g_set_error(error, ao_output_quark(), 0,
+ "\"%s\" is not a valid ao driver",
+ value);
+ return NULL;
+ }
if ((ai = ao_driver_info(ad->driver)) == NULL) {
- g_error("problems getting driver info for device defined at line %i\n"
- "you may not have permission to the audio device\n", param->line);
+ g_set_error(error, ao_output_quark(), 0,
+ "problems getting driver info");
+ return NULL;
}
g_debug("using ao driver \"%s\" for \"%s\"\n", ai->short_name,
@@ -105,9 +120,12 @@ ao_output_init(G_GNUC_UNUSED const struct audio_format *audio_format,
for (unsigned i = 0; options[i] != NULL; ++i) {
gchar **key_value = g_strsplit(options[i], "=", 2);
- if (key_value[0] == NULL || key_value[1] == NULL)
- g_error("problems parsing options \"%s\"\n",
- options[i]);
+ if (key_value[0] == NULL || key_value[1] == NULL) {
+ g_set_error(error, ao_output_quark(), 0,
+ "problems parsing options \"%s\"",
+ options[i]);
+ return NULL;
+ }
ao_append_option(&ad->options, key_value[0],
key_value[1]);
@@ -144,7 +162,8 @@ ao_output_close(void *data)
}
static bool
-ao_output_open(void *data, struct audio_format *audio_format)
+ao_output_open(void *data, struct audio_format *audio_format,
+ GError **error)
{
ao_sample_format format;
struct ao_data *ad = (struct ao_data *)data;
@@ -163,7 +182,7 @@ ao_output_open(void *data, struct audio_format *audio_format)
ad->device = ao_open_live(ad->driver, &format, ad->options);
if (ad->device == NULL) {
- ao_output_error("Failed to open libao");
+ ao_output_error(error);
return false;
}
@@ -188,7 +207,8 @@ static int ao_play_deconst(ao_device *device, const void *output_samples,
}
static size_t
-ao_output_play(void *data, const void *chunk, size_t size)
+ao_output_play(void *data, const void *chunk, size_t size,
+ GError **error)
{
struct ao_data *ad = (struct ao_data *)data;
@@ -196,7 +216,7 @@ ao_output_play(void *data, const void *chunk, size_t size)
size = ad->write_size;
if (ao_play_deconst(ad->device, chunk, size) == 0) {
- ao_output_error("Closing libao device due to play error");
+ ao_output_error(error);
return 0;
}
diff --git a/src/output/fifo_plugin.c b/src/output/fifo_plugin.c
index 47f0346a7..449faa24c 100644
--- a/src/output/fifo_plugin.c
+++ b/src/output/fifo_plugin.c
@@ -42,6 +42,15 @@ struct fifo_data {
Timer *timer;
};
+/**
+ * The quark used for GError.domain.
+ */
+static inline GQuark
+fifo_output_quark(void)
+{
+ return g_quark_from_static_string("fifo_output");
+}
+
static struct fifo_data *fifo_data_new(void)
{
struct fifo_data *ret;
@@ -95,11 +104,12 @@ fifo_close(struct fifo_data *fd)
}
static bool
-fifo_make(struct fifo_data *fd)
+fifo_make(struct fifo_data *fd, GError **error)
{
if (mkfifo(fd->path, 0666) < 0) {
- g_warning("Couldn't create FIFO \"%s\": %s",
- fd->path, strerror(errno));
+ g_set_error(error, fifo_output_quark(), errno,
+ "Couldn't create FIFO \"%s\": %s",
+ fd->path, strerror(errno));
return false;
}
@@ -109,24 +119,26 @@ fifo_make(struct fifo_data *fd)
}
static bool
-fifo_check(struct fifo_data *fd)
+fifo_check(struct fifo_data *fd, GError **error)
{
struct stat st;
if (stat(fd->path, &st) < 0) {
if (errno == ENOENT) {
/* Path doesn't exist */
- return fifo_make(fd);
+ return fifo_make(fd, error);
}
- g_warning("Failed to stat FIFO \"%s\": %s",
- fd->path, strerror(errno));
+ g_set_error(error, fifo_output_quark(), errno,
+ "Failed to stat FIFO \"%s\": %s",
+ fd->path, strerror(errno));
return false;
}
if (!S_ISFIFO(st.st_mode)) {
- g_warning("\"%s\" already exists, but is not a FIFO",
- fd->path);
+ g_set_error(error, fifo_output_quark(), 0,
+ "\"%s\" already exists, but is not a FIFO",
+ fd->path);
return false;
}
@@ -134,23 +146,25 @@ fifo_check(struct fifo_data *fd)
}
static bool
-fifo_open(struct fifo_data *fd)
+fifo_open(struct fifo_data *fd, GError **error)
{
- if (!fifo_check(fd))
+ if (!fifo_check(fd, error))
return false;
fd->input = open(fd->path, O_RDONLY|O_NONBLOCK);
if (fd->input < 0) {
- g_warning("Could not open FIFO \"%s\" for reading: %s",
- fd->path, strerror(errno));
+ g_set_error(error, fifo_output_quark(), errno,
+ "Could not open FIFO \"%s\" for reading: %s",
+ fd->path, strerror(errno));
fifo_close(fd);
return false;
}
fd->output = open(fd->path, O_WRONLY|O_NONBLOCK);
if (fd->output < 0) {
- g_warning("Could not open FIFO \"%s\" for writing: %s",
- fd->path, strerror(errno));
+ g_set_error(error, fifo_output_quark(), errno,
+ "Could not open FIFO \"%s\" for writing: %s",
+ fd->path, strerror(errno));
fifo_close(fd);
return false;
}
@@ -160,27 +174,31 @@ fifo_open(struct fifo_data *fd)
static void *
fifo_output_init(G_GNUC_UNUSED const struct audio_format *audio_format,
- const struct config_param *param)
+ const struct config_param *param,
+ GError **error)
{
struct fifo_data *fd;
char *value, *path;
value = config_dup_block_string(param, "path", NULL);
- if (value == NULL)
- g_error("No \"path\" parameter specified for fifo output "
- "defined at line %i", param->line);
+ if (value == NULL) {
+ g_set_error(error, fifo_output_quark(), errno,
+ "No \"path\" parameter specified");
+ return NULL;
+ }
path = parsePath(value);
g_free(value);
if (!path) {
- g_error("Could not parse \"path\" parameter for fifo output "
- "at line %i", param->line);
+ g_set_error(error, fifo_output_quark(), errno,
+ "Could not parse \"path\" parameter");
+ return NULL;
}
fd = fifo_data_new();
fd->path = path;
- if (!fifo_open(fd)) {
+ if (!fifo_open(fd, error)) {
fifo_data_free(fd);
return NULL;
}
@@ -198,7 +216,8 @@ fifo_output_finish(void *data)
}
static bool
-fifo_output_open(void *data, struct audio_format *audio_format)
+fifo_output_open(void *data, struct audio_format *audio_format,
+ G_GNUC_UNUSED GError **error)
{
struct fifo_data *fd = (struct fifo_data *)data;
@@ -234,7 +253,8 @@ fifo_output_cancel(void *data)
}
static size_t
-fifo_output_play(void *data, const void *chunk, size_t size)
+fifo_output_play(void *data, const void *chunk, size_t size,
+ GError **error)
{
struct fifo_data *fd = (struct fifo_data *)data;
ssize_t bytes;
@@ -261,8 +281,9 @@ fifo_output_play(void *data, const void *chunk, size_t size)
continue;
}
- g_warning("Closing FIFO output \"%s\" due to write error: %s",
- fd->path, strerror(errno));
+ g_set_error(error, fifo_output_quark(), errno,
+ "Failed to write to FIFO %s: %s",
+ fd->path, g_strerror(errno));
return 0;
}
}
diff --git a/src/output/jack_plugin.c b/src/output/jack_plugin.c
index a04d37f00..6b3dd9d03 100644
--- a/src/output/jack_plugin.c
+++ b/src/output/jack_plugin.c
@@ -58,6 +58,15 @@ struct jack_data {
bool shutdown;
};
+/**
+ * The quark used for GError.domain.
+ */
+static inline GQuark
+jack_output_quark(void)
+{
+ return g_quark_from_static_string("jack_output");
+}
+
static void
mpd_jack_client_free(struct jack_data *jd)
{
@@ -158,7 +167,7 @@ mpd_jack_info(const char *msg)
static void *
mpd_jack_init(G_GNUC_UNUSED const struct audio_format *audio_format,
- const struct config_param *param)
+ const struct config_param *param, GError **error)
{
struct jack_data *jd;
const char *value;
@@ -172,9 +181,12 @@ mpd_jack_init(G_GNUC_UNUSED const struct audio_format *audio_format,
if (value != NULL) {
char **ports = g_strsplit(value, ",", 0);
- if (ports[0] == NULL || ports[1] == NULL || ports[2] != NULL)
- g_error("two port names expected in line %d",
- param->line);
+ if (ports[0] == NULL || ports[1] == NULL || ports[2] != NULL) {
+ g_set_error(error, jack_output_quark(), 0,
+ "two port names expected in line %d",
+ param->line);
+ return NULL;
+ }
jd->output_ports[0] = ports[0];
jd->output_ports[1] = ports[1];
@@ -204,7 +216,7 @@ mpd_jack_test_default_device(void)
}
static bool
-mpd_jack_connect(struct jack_data *jd)
+mpd_jack_connect(struct jack_data *jd, GError **error)
{
const char *output_ports[2], **jports;
@@ -215,7 +227,8 @@ mpd_jack_connect(struct jack_data *jd)
jd->shutdown = false;
if ((jd->client = jack_client_new(jd->name)) == NULL) {
- g_warning("jack server not running?");
+ g_set_error(error, jack_output_quark(), 0,
+ "Failed to connect to JACK server");
return false;
}
@@ -227,14 +240,16 @@ mpd_jack_connect(struct jack_data *jd)
JACK_DEFAULT_AUDIO_TYPE,
JackPortIsOutput, 0);
if (jd->ports[i] == NULL) {
- g_warning("Cannot register %s output port.",
- port_names[i]);
+ g_set_error(error, jack_output_quark(), 0,
+ "Cannot register output port \"%s\"",
+ port_names[i]);
return false;
}
}
if ( jack_activate(jd->client) ) {
- g_warning("cannot activate client");
+ g_set_error(error, jack_output_quark(), 0,
+ "cannot activate client");
return false;
}
@@ -244,7 +259,8 @@ mpd_jack_connect(struct jack_data *jd)
jports = jack_get_ports(jd->client, NULL, NULL,
JackPortIsPhysical | JackPortIsInput);
if (jports == NULL) {
- g_warning("no ports found");
+ g_set_error(error, jack_output_quark(), 0,
+ "no ports found");
return false;
}
@@ -267,8 +283,9 @@ mpd_jack_connect(struct jack_data *jd)
ret = jack_connect(jd->client, jack_port_name(jd->ports[i]),
output_ports[i]);
if (ret != 0) {
- g_warning("%s is not a valid Jack Client / Port",
- output_ports[i]);
+ g_set_error(error, jack_output_quark(), 0,
+ "Not a valid JACK port: %s",
+ output_ports[i]);
if (jports != NULL)
free(jports);
@@ -284,13 +301,13 @@ mpd_jack_connect(struct jack_data *jd)
}
static bool
-mpd_jack_open(void *data, struct audio_format *audio_format)
+mpd_jack_open(void *data, struct audio_format *audio_format, GError **error)
{
struct jack_data *jd = data;
assert(jd != NULL);
- if (!mpd_jack_connect(jd)) {
+ if (!mpd_jack_connect(jd, error)) {
mpd_jack_client_free(jd);
return false;
}
@@ -381,21 +398,23 @@ mpd_jack_write_samples(struct jack_data *jd, const void *src,
}
static size_t
-mpd_jack_play(void *data, const void *chunk, size_t size)
+mpd_jack_play(void *data, const void *chunk, size_t size, GError **error)
{
struct jack_data *jd = data;
const size_t frame_size = audio_format_frame_size(&jd->audio_format);
size_t space = 0, space1;
- if (jd->shutdown) {
- g_warning("Refusing to play, because there is no client thread.");
- return 0;
- }
-
assert(size % frame_size == 0);
size /= frame_size;
- while (!jd->shutdown) {
+ while (true) {
+ if (jd->shutdown) {
+ g_set_error(error, jack_output_quark(), 0,
+ "Refusing to play, because "
+ "there is no client thread");
+ return 0;
+ }
+
space = jack_ringbuffer_write_space(jd->ringbuffer[0]);
space1 = jack_ringbuffer_write_space(jd->ringbuffer[1]);
if (space > space1)
diff --git a/src/output/mvp_plugin.c b/src/output/mvp_plugin.c
index 65df5a2aa..b9004029b 100644
--- a/src/output/mvp_plugin.c
+++ b/src/output/mvp_plugin.c
@@ -83,6 +83,15 @@ static const unsigned mvp_sample_rates[][3] = {
{15, 96000, 48000}
};
+/**
+ * The quark used for GError.domain.
+ */
+static inline GQuark
+mvp_output_quark(void)
+{
+ return g_quark_from_static_string("mvp_output");
+}
+
/**
* Translate a sample rate to a MVP sample rate.
*
@@ -118,7 +127,8 @@ mvp_output_test_default_device(void)
static void *
mvp_output_init(G_GNUC_UNUSED const struct audio_format *audio_format,
- G_GNUC_UNUSED const struct config_param *param)
+ G_GNUC_UNUSED const struct config_param *param,
+ G_GNUC_UNUSED GError **error)
{
struct mvp_data *md = g_new(struct mvp_data, 1);
md->fd = -1;
@@ -134,7 +144,8 @@ mvp_output_finish(void *data)
}
static bool
-mvp_set_pcm_params(struct mvp_data *md, struct audio_format *audio_format)
+mvp_set_pcm_params(struct mvp_data *md, struct audio_format *audio_format,
+ GError **error)
{
unsigned mix[5];
@@ -181,23 +192,27 @@ mvp_set_pcm_params(struct mvp_data *md, struct audio_format *audio_format)
*/
mix[2] = mvp_find_sample_rate(audio_format->sample_rate);
if (mix[2] == (unsigned)-1) {
- g_warning("Can not find suitable output frequency for %u\n",
- audio_format->sample_rate);
+ g_set_error(error, mvp_output_quark(), 0,
+ "Can not find suitable output frequency for %u",
+ audio_format->sample_rate);
return false;
}
if (ioctl(md->fd, MVP_SET_AUD_FORMAT, &mix) < 0) {
- g_warning("Can not set audio format\n");
+ g_set_error(error, mvp_output_quark(), errno,
+ "Can not set audio format");
return false;
}
if (ioctl(md->fd, MVP_SET_AUD_SYNC, 2) != 0) {
- g_warning("Can not set audio sync\n");
+ g_set_error(error, mvp_output_quark(), errno,
+ "Can not set audio sync");
return false;
}
if (ioctl(md->fd, MVP_SET_AUD_PLAY, 0) < 0) {
- g_warning("Can not set audio play mode\n");
+ g_set_error(error, mvp_output_quark(), errno,
+ "Can not set audio play mode");
return false;
}
@@ -205,7 +220,7 @@ mvp_set_pcm_params(struct mvp_data *md, struct audio_format *audio_format)
}
static bool
-mvp_output_open(void *data, struct audio_format *audio_format)
+mvp_output_open(void *data, struct audio_format *audio_format, GError **error)
{
struct mvp_data *md = data;
long long int stc = 0;
@@ -213,33 +228,38 @@ mvp_output_open(void *data, struct audio_format *audio_format)
bool success;
if ((md->fd = open("/dev/adec_pcm", O_RDWR | O_NONBLOCK)) < 0) {
- g_warning("Error opening /dev/adec_pcm: %s\n",
- strerror(errno));
+ g_set_error(error, mvp_output_quark(), errno,
+ "Error opening /dev/adec_pcm: %s",
+ strerror(errno));
return false;
}
if (ioctl(md->fd, MVP_SET_AUD_SRC, 1) < 0) {
- g_warning("Error setting audio source: %s\n",
- strerror(errno));
+ g_set_error(error, mvp_output_quark(), errno,
+ "Error setting audio source: %s",
+ strerror(errno));
return false;
}
if (ioctl(md->fd, MVP_SET_AUD_STREAMTYPE, 0) < 0) {
- g_warning("Error setting audio streamtype: %s\n",
- strerror(errno));
+ g_set_error(error, mvp_output_quark(), errno,
+ "Error setting audio streamtype: %s",
+ strerror(errno));
return false;
}
if (ioctl(md->fd, MVP_SET_AUD_FORMAT, &mix) < 0) {
- g_warning("Error setting audio format: %s\n",
- strerror(errno));
+ g_set_error(error, mvp_output_quark(), errno,
+ "Error setting audio format: %s",
+ strerror(errno));
return false;
}
ioctl(md->fd, MVP_SET_AUD_STC, &stc);
if (ioctl(md->fd, MVP_SET_AUD_BYPASS, 1) < 0) {
- g_warning("Error setting audio streamtype: %s\n",
- strerror(errno));
+ g_set_error(error, mvp_output_quark(), errno,
+ "Error setting audio streamtype: %s",
+ strerror(errno));
return false;
}
- success = mvp_set_pcm_params(md, audio_format);
+ success = mvp_set_pcm_params(md, audio_format, error);
if (!success)
return false;
@@ -266,7 +286,7 @@ static void mvp_output_cancel(void *data)
}
static size_t
-mvp_output_play(void *data, const void *chunk, size_t size)
+mvp_output_play(void *data, const void *chunk, size_t size, GError **error)
{
struct mvp_data *md = data;
ssize_t ret;
@@ -275,7 +295,7 @@ mvp_output_play(void *data, const void *chunk, size_t size)
if (md->fd < 0) {
bool success;
- success = mvp_output_open(md, &md->audio_format);
+ success = mvp_output_open(md, &md->audio_format, error);
if (!success)
return 0;
}
@@ -288,8 +308,9 @@ mvp_output_play(void *data, const void *chunk, size_t size)
if (ret < 0) {
if (errno == EINTR)
continue;
- g_warning("closing mvp PCM device due to write error: "
- "%s\n", strerror(errno));
+
+ g_set_error(error, mvp_output_quark(), errno,
+ "Failed to write: %s", strerror(errno));
return 0;
}
}
diff --git a/src/output/null_plugin.c b/src/output/null_plugin.c
index a10f5e45f..03a4b7fac 100644
--- a/src/output/null_plugin.c
+++ b/src/output/null_plugin.c
@@ -31,7 +31,8 @@ struct null_data {
static void *
null_init(G_GNUC_UNUSED const struct audio_format *audio_format,
- G_GNUC_UNUSED const struct config_param *param)
+ G_GNUC_UNUSED const struct config_param *param,
+ G_GNUC_UNUSED GError **error)
{
struct null_data *nd = g_new(struct null_data, 1);
@@ -52,7 +53,8 @@ null_finish(void *data)
}
static bool
-null_open(void *data, struct audio_format *audio_format)
+null_open(void *data, struct audio_format *audio_format,
+ G_GNUC_UNUSED GError **error)
{
struct null_data *nd = data;
@@ -74,7 +76,8 @@ null_close(void *data)
}
static size_t
-null_play(void *data, G_GNUC_UNUSED const void *chunk, size_t size)
+null_play(void *data, G_GNUC_UNUSED const void *chunk, size_t size,
+ G_GNUC_UNUSED GError **error)
{
struct null_data *nd = data;
Timer *timer = nd->timer;
diff --git a/src/output/oss_plugin.c b/src/output/oss_plugin.c
index b070b9a9d..d4ecf88f7 100644
--- a/src/output/oss_plugin.c
+++ b/src/output/oss_plugin.c
@@ -72,6 +72,15 @@ enum oss_param {
OSS_BITS = 2,
};
+/**
+ * The quark used for GError.domain.
+ */
+static inline GQuark
+oss_output_quark(void)
+{
+ return g_quark_from_static_string("oss_output");
+}
+
static enum oss_param
oss_param_from_ioctl(unsigned param)
{
@@ -353,7 +362,7 @@ oss_output_test_default_device(void)
}
static void *
-oss_open_default(const struct config_param *param)
+oss_open_default(GError **error)
{
int i;
int err[G_N_ELEMENTS(default_devices)];
@@ -364,17 +373,11 @@ oss_open_default(const struct config_param *param)
if (ret[i] == OSS_STAT_NO_ERROR) {
struct oss_data *od = oss_data_new();
od->device = default_devices[i];
- od->mixer = mixer_new(&oss_mixer, param);
+ od->mixer = mixer_new(&oss_mixer, NULL);
return od;
}
}
- if (param)
- g_warning("error trying to open specified OSS device"
- " at line %i\n", param->line);
- else
- g_warning("error trying to open default OSS device\n");
-
for (i = G_N_ELEMENTS(default_devices); --i >= 0; ) {
const char *dev = default_devices[i];
switch(ret[i]) {
@@ -395,13 +398,16 @@ oss_open_default(const struct config_param *param)
dev, strerror(err[i]));
}
}
- exit(EXIT_FAILURE);
- return NULL; /* some compilers can be dumb... */
+
+ g_set_error(error, oss_output_quark(), 0,
+ "error trying to open default OSS device");
+ return NULL;
}
static void *
oss_output_init(G_GNUC_UNUSED const struct audio_format *audio_format,
- const struct config_param *param)
+ const struct config_param *param,
+ GError **error)
{
const char *device = config_get_block_string(param, "device", NULL);
if (device != NULL) {
@@ -411,7 +417,7 @@ oss_output_init(G_GNUC_UNUSED const struct audio_format *audio_format,
return od;
}
- return oss_open_default(param);
+ return oss_open_default(error);
}
static void
@@ -473,24 +479,26 @@ oss_close(struct oss_data *od)
* Sets up the OSS device which was opened before.
*/
static bool
-oss_setup(struct oss_data *od)
+oss_setup(struct oss_data *od, GError **error)
{
int tmp;
tmp = od->audio_format.channels;
if (oss_set_param(od, SNDCTL_DSP_CHANNELS, &tmp)) {
- g_warning("OSS device \"%s\" does not support %u channels: %s\n",
- od->device, od->audio_format.channels,
- strerror(errno));
+ g_set_error(error, oss_output_quark(), errno,
+ "OSS device \"%s\" does not support %u channels: %s",
+ od->device, od->audio_format.channels,
+ strerror(errno));
return false;
}
od->audio_format.channels = tmp;
tmp = od->audio_format.sample_rate;
if (oss_set_param(od, SNDCTL_DSP_SPEED, &tmp)) {
- g_warning("OSS device \"%s\" does not support %u Hz audio: %s\n",
- od->device, od->audio_format.sample_rate,
- strerror(errno));
+ g_set_error(error, oss_output_quark(), errno,
+ "OSS device \"%s\" does not support %u Hz audio: %s",
+ od->device, od->audio_format.sample_rate,
+ strerror(errno));
return false;
}
od->audio_format.sample_rate = tmp;
@@ -511,8 +519,9 @@ oss_setup(struct oss_data *od)
}
if (oss_set_param(od, SNDCTL_DSP_SAMPLESIZE, &tmp)) {
- g_warning("OSS device \"%s\" does not support %u bit audio: %s\n",
- od->device, tmp, strerror(errno));
+ g_set_error(error, oss_output_quark(), errno,
+ "OSS device \"%s\" does not support %u bit audio: %s",
+ od->device, tmp, strerror(errno));
return false;
}
@@ -520,17 +529,18 @@ oss_setup(struct oss_data *od)
}
static bool
-oss_open(struct oss_data *od)
+oss_open(struct oss_data *od, GError **error)
{
bool success;
if ((od->fd = open(od->device, O_WRONLY)) < 0) {
- g_warning("Error opening OSS device \"%s\": %s\n", od->device,
- strerror(errno));
+ g_set_error(error, oss_output_quark(), errno,
+ "Error opening OSS device \"%s\": %s",
+ od->device, strerror(errno));
return false;
}
- success = oss_setup(od);
+ success = oss_setup(od, error);
if (!success) {
oss_close(od);
return false;
@@ -540,14 +550,14 @@ oss_open(struct oss_data *od)
}
static bool
-oss_output_open(void *data, struct audio_format *audio_format)
+oss_output_open(void *data, struct audio_format *audio_format, GError **error)
{
bool ret;
struct oss_data *od = data;
od->audio_format = *audio_format;
- ret = oss_open(od);
+ ret = oss_open(od, error);
if (!ret)
return false;
@@ -584,14 +594,14 @@ oss_output_cancel(void *data)
}
static size_t
-oss_output_play(void *data, const void *chunk, size_t size)
+oss_output_play(void *data, const void *chunk, size_t size, GError **error)
{
struct oss_data *od = data;
ssize_t ret;
/* reopen the device since it was closed by dropBufferedAudio */
- if (od->fd < 0 && !oss_open(od))
- return false;
+ if (od->fd < 0 && !oss_open(od, error))
+ return 0;
while (true) {
ret = write(od->fd, chunk, size);
@@ -599,8 +609,9 @@ oss_output_play(void *data, const void *chunk, size_t size)
return (size_t)ret;
if (ret < 0 && errno != EINTR) {
- g_warning("closing oss device \"%s\" due to write error: "
- "%s\n", od->device, strerror(errno));
+ g_set_error(error, oss_output_quark(), errno,
+ "Write error on %s: %s",
+ od->device, strerror(errno));
return 0;
}
}
diff --git a/src/output/osx_plugin.c b/src/output/osx_plugin.c
index fc3025ca1..7aa7659a8 100644
--- a/src/output/osx_plugin.c
+++ b/src/output/osx_plugin.c
@@ -34,6 +34,15 @@ struct osx_output {
size_t len;
};
+/**
+ * The quark used for GError.domain.
+ */
+static inline GQuark
+osx_output_quark(void)
+{
+ return g_quark_from_static_string("osx_output");
+}
+
static bool
osx_output_test_default_device(void)
{
@@ -44,7 +53,8 @@ osx_output_test_default_device(void)
static void *
osx_output_init(G_GNUC_UNUSED const struct audio_format *audio_format,
- G_GNUC_UNUSED const struct config_param *param)
+ G_GNUC_UNUSED const struct config_param *param,
+ G_GNUC_UNUSED GError **error)
{
struct osx_output *oo = g_new(struct osx_output, 1);
@@ -143,7 +153,7 @@ osx_render(void *vdata,
}
static bool
-osx_output_open(void *data, struct audio_format *audio_format)
+osx_output_open(void *data, struct audio_format *audio_format, GError **error)
{
struct osx_output *od = data;
ComponentDescription desc;
@@ -164,22 +174,25 @@ osx_output_open(void *data, struct audio_format *audio_format)
comp = FindNextComponent(NULL, &desc);
if (comp == 0) {
- g_warning("Error finding OS X component\n");
+ g_set_error(error, osx_output_quark(), 0,
+ "Error finding OS X component");
return false;
}
status = OpenAComponent(comp, &od->au);
if (status != noErr) {
- g_warning("Unable to open OS X component: %s",
- GetMacOSStatusCommentString(status));
+ g_set_error(error, osx_output_quark(), 0,
+ "Unable to open OS X component: %s",
+ GetMacOSStatusCommentString(status));
return false;
}
status = AudioUnitInitialize(od->au);
if (status != noErr) {
CloseComponent(od->au);
- g_warning("Unable to initialize OS X audio unit: %s",
- GetMacOSStatusCommentString(status));
+ g_set_error(error, osx_output_quark(), 0,
+ "Unable to initialize OS X audio unit: %s",
+ GetMacOSStatusCommentString(status));
return false;
}
@@ -193,7 +206,8 @@ osx_output_open(void *data, struct audio_format *audio_format)
if (result != noErr) {
AudioUnitUninitialize(od->au);
CloseComponent(od->au);
- g_warning("unable to set callback for OS X audio unit\n");
+ g_set_error(error, osx_output_quark(), 0,
+ "unable to set callback for OS X audio unit");
return false;
}
@@ -218,7 +232,8 @@ osx_output_open(void *data, struct audio_format *audio_format)
if (result != noErr) {
AudioUnitUninitialize(od->au);
CloseComponent(od->au);
- g_warning("Unable to set format on OS X device\n");
+ g_set_error(error, osx_output_quark(), 0,
+ "Unable to set format on OS X device");
return false;
}
@@ -232,8 +247,9 @@ osx_output_open(void *data, struct audio_format *audio_format)
status = AudioOutputUnitStart(od->au);
if (status != 0) {
- g_warning("unable to start audio output: %s",
- GetMacOSStatusCommentString(status));
+ g_set_error(error, osx_output_quark(), 0,
+ "unable to start audio output: %s",
+ GetMacOSStatusCommentString(status));
return false;
}
@@ -241,7 +257,8 @@ osx_output_open(void *data, struct audio_format *audio_format)
}
static size_t
-osx_output_play(void *data, const void *chunk, size_t size)
+osx_output_play(void *data, const void *chunk, size_t size,
+ G_GNUC_UNUSED GError **error)
{
struct osx_output *od = data;
size_t start, nbytes;
diff --git a/src/output/pulse_plugin.c b/src/output/pulse_plugin.c
index b8fe5ad88..dcdd427db 100644
--- a/src/output/pulse_plugin.c
+++ b/src/output/pulse_plugin.c
@@ -32,6 +32,15 @@ struct pulse_data {
char *sink;
};
+/**
+ * The quark used for GError.domain.
+ */
+static inline GQuark
+pulse_output_quark(void)
+{
+ return g_quark_from_static_string("pulse_output");
+}
+
static struct pulse_data *pulse_new_data(void)
{
struct pulse_data *ret;
@@ -53,7 +62,7 @@ static void pulse_free_data(struct pulse_data *pd)
static void *
pulse_init(G_GNUC_UNUSED const struct audio_format *audio_format,
- const struct config_param *param)
+ const struct config_param *param, G_GNUC_UNUSED GError **error)
{
struct pulse_data *pd;
@@ -98,7 +107,7 @@ static bool pulse_test_default_device(void)
}
static bool
-pulse_open(void *data, struct audio_format *audio_format)
+pulse_open(void *data, struct audio_format *audio_format, GError **error_r)
{
struct pulse_data *pd = data;
pa_sample_spec ss;
@@ -117,9 +126,9 @@ pulse_open(void *data, struct audio_format *audio_format)
&ss, NULL, NULL,
&error);
if (!pd->s) {
- g_warning("Cannot connect to server in PulseAudio output "
- "\"%s\": %s\n",
- pd->name, pa_strerror(error));
+ g_set_error(error_r, pulse_output_quark(), error,
+ "Cannot connect to PulseAudio server: %s",
+ pa_strerror(error));
return false;
}
@@ -151,15 +160,14 @@ static void pulse_close(void *data)
}
static size_t
-pulse_play(void *data, const void *chunk, size_t size)
+pulse_play(void *data, const void *chunk, size_t size, GError **error_r)
{
struct pulse_data *pd = data;
int error;
if (pa_simple_write(pd->s, chunk, size, &error) < 0) {
- g_warning("PulseAudio output \"%s\" disconnecting due to "
- "write error: %s\n",
- pd->name, pa_strerror(error));
+ g_set_error(error_r, pulse_output_quark(), error,
+ "%s", pa_strerror(error));
return 0;
}
diff --git a/src/output/shout_plugin.c b/src/output/shout_plugin.c
index 2a8f2f189..2ad7e7b56 100644
--- a/src/output/shout_plugin.c
+++ b/src/output/shout_plugin.c
@@ -53,6 +53,15 @@ struct shout_data {
static int shout_init_count;
+/**
+ * The quark used for GError.domain.
+ */
+static inline GQuark
+shout_output_quark(void)
+{
+ return g_quark_from_static_string("shout_output");
+}
+
static const struct encoder_plugin *
shout_encoder_plugin_get(const char *name)
{
@@ -97,7 +106,8 @@ static void free_shout_data(struct shout_data *sd)
static void *
my_shout_init_driver(const struct audio_format *audio_format,
- const struct config_param *param)
+ const struct config_param *param,
+ GError **error)
{
struct shout_data *sd;
char *test;
@@ -107,7 +117,6 @@ my_shout_init_driver(const struct audio_format *audio_format,
char *passwd;
const char *encoding;
const struct encoder_plugin *encoder_plugin;
- GError *error = NULL;
unsigned shout_format;
unsigned protocol;
const char *user;
@@ -131,8 +140,9 @@ my_shout_init_driver(const struct audio_format *audio_format,
port = config_get_block_unsigned(param, "port", 0);
if (port == 0) {
- g_error("shout port \"%s\" is not a positive integer, line %i\n",
- block_param->value, block_param->line);
+ g_set_error(error, shout_output_quark(), 0,
+ "shout port must be configured");
+ return NULL;
}
check_block_param("password");
@@ -150,27 +160,33 @@ my_shout_init_driver(const struct audio_format *audio_format,
sd->quality = strtod(value, &test);
if (*test != '\0' || sd->quality < -1.0 || sd->quality > 10.0) {
- g_error("shout quality \"%s\" is not a number in the "
- "range -1 to 10, line %i",
- value, param->line);
+ g_set_error(error, shout_output_quark(), 0,
+ "shout quality \"%s\" is not a number in the "
+ "range -1 to 10, line %i",
+ value, param->line);
+ return NULL;
}
if (config_get_block_string(param, "bitrate", NULL) != NULL) {
- g_error("quality and bitrate are "
- "both defined for shout output (line %i)",
- param->line);
+ g_set_error(error, shout_output_quark(), 0,
+ "quality and bitrate are "
+ "both defined");
+ return NULL;
}
} else {
value = config_get_block_string(param, "bitrate", NULL);
- if (value == NULL)
- g_error("neither bitrate nor quality defined for shout "
- "output at line %i", param->line);
+ if (value == NULL) {
+ g_set_error(error, shout_output_quark(), 0,
+ "neither bitrate nor quality defined");
+ return NULL;
+ }
sd->bitrate = strtol(value, &test, 10);
if (*test != '\0' || sd->bitrate <= 0) {
- g_error("bitrate at line %i should be a positive integer "
- "\n", param->line);
+ g_set_error(error, shout_output_quark(), 0,
+ "bitrate must be a positive integer");
+ return NULL;
}
}
@@ -178,13 +194,16 @@ my_shout_init_driver(const struct audio_format *audio_format,
encoding = config_get_block_string(param, "encoding", "ogg");
encoder_plugin = shout_encoder_plugin_get(encoding);
- if (encoder_plugin == NULL)
- g_error("couldn't find shout encoder plugin \"%s\"\n",
- encoding);
+ if (encoder_plugin == NULL) {
+ g_set_error(error, shout_output_quark(), 0,
+ "couldn't find shout encoder plugin \"%s\"",
+ encoding);
+ return NULL;
+ }
- sd->encoder = encoder_init(encoder_plugin, param, &error);
+ sd->encoder = encoder_init(encoder_plugin, param, error);
if (sd->encoder == NULL)
- g_error("%s", error->message);
+ return NULL;
if (strcmp(encoding, "mp3") == 0 || strcmp(encoding, "lame") == 0)
shout_format = SHOUT_FORMAT_MP3;
@@ -194,20 +213,24 @@ my_shout_init_driver(const struct audio_format *audio_format,
value = config_get_block_string(param, "protocol", NULL);
if (value != NULL) {
if (0 == strcmp(value, "shoutcast") &&
- 0 != strcmp(encoding, "mp3"))
- g_error("you cannot stream \"%s\" to shoutcast, use mp3\n",
- encoding);
- else if (0 == strcmp(value, "shoutcast"))
+ 0 != strcmp(encoding, "mp3")) {
+ g_set_error(error, shout_output_quark(), 0,
+ "you cannot stream \"%s\" to shoutcast, use mp3",
+ encoding);
+ return NULL;
+ } else if (0 == strcmp(value, "shoutcast"))
protocol = SHOUT_PROTOCOL_ICY;
else if (0 == strcmp(value, "icecast1"))
protocol = SHOUT_PROTOCOL_XAUDIOCAST;
else if (0 == strcmp(value, "icecast2"))
protocol = SHOUT_PROTOCOL_HTTP;
- else
- g_error("shout protocol \"%s\" is not \"shoutcast\" or "
- "\"icecast1\"or "
- "\"icecast2\", line %i\n",
- value, param->line);
+ else {
+ g_set_error(error, shout_output_quark(), 0,
+ "shout protocol \"%s\" is not \"shoutcast\" or "
+ "\"icecast1\"or \"icecast2\"",
+ value);
+ return NULL;
+ }
} else {
protocol = SHOUT_PROTOCOL_HTTP;
}
@@ -223,8 +246,9 @@ my_shout_init_driver(const struct audio_format *audio_format,
!= SHOUTERR_SUCCESS ||
shout_set_protocol(sd->shout_conn, protocol) != SHOUTERR_SUCCESS ||
shout_set_agent(sd->shout_conn, "MPD") != SHOUTERR_SUCCESS) {
- g_error("error configuring shout defined at line %i: %s\n",
- param->line, shout_get_error(sd->shout_conn));
+ g_set_error(error, shout_output_quark(), 0,
+ "%s", shout_get_error(sd->shout_conn));
+ return NULL;
}
/* optional paramters */
@@ -233,14 +257,16 @@ my_shout_init_driver(const struct audio_format *audio_format,
value = config_get_block_string(param, "genre", NULL);
if (value != NULL && shout_set_genre(sd->shout_conn, value)) {
- g_error("error configuring shout defined at line %i: %s\n",
- param->line, shout_get_error(sd->shout_conn));
+ g_set_error(error, shout_output_quark(), 0,
+ "%s", shout_get_error(sd->shout_conn));
+ return NULL;
}
value = config_get_block_string(param, "description", NULL);
if (value != NULL && shout_set_description(sd->shout_conn, value)) {
- g_error("error configuring shout defined at line %i: %s\n",
- param->line, shout_get_error(sd->shout_conn));
+ g_set_error(error, shout_output_quark(), 0,
+ "%s", shout_get_error(sd->shout_conn));
+ return NULL;
}
{
@@ -269,7 +295,7 @@ my_shout_init_driver(const struct audio_format *audio_format,
}
static bool
-handle_shout_error(struct shout_data *sd, int err)
+handle_shout_error(struct shout_data *sd, int err, GError **error)
{
switch (err) {
case SHOUTERR_SUCCESS:
@@ -277,17 +303,19 @@ handle_shout_error(struct shout_data *sd, int err)
case SHOUTERR_UNCONNECTED:
case SHOUTERR_SOCKET:
- g_warning("Lost shout connection to %s:%i: %s\n",
- shout_get_host(sd->shout_conn),
- shout_get_port(sd->shout_conn),
- shout_get_error(sd->shout_conn));
+ g_set_error(error, shout_output_quark(), err,
+ "Lost shout connection to %s:%i: %s",
+ shout_get_host(sd->shout_conn),
+ shout_get_port(sd->shout_conn),
+ shout_get_error(sd->shout_conn));
return false;
default:
- g_warning("shout: connection to %s:%i error: %s\n",
- shout_get_host(sd->shout_conn),
- shout_get_port(sd->shout_conn),
- shout_get_error(sd->shout_conn));
+ g_set_error(error, shout_output_quark(), err,
+ "connection to %s:%i error: %s",
+ shout_get_host(sd->shout_conn),
+ shout_get_port(sd->shout_conn),
+ shout_get_error(sd->shout_conn));
return false;
}
@@ -295,7 +323,7 @@ handle_shout_error(struct shout_data *sd, int err)
}
static bool
-write_page(struct shout_data *sd)
+write_page(struct shout_data *sd, GError **error)
{
int err;
@@ -308,7 +336,7 @@ write_page(struct shout_data *sd)
shout_sync(sd->shout_conn);
err = shout_send(sd->shout_conn, sd->buf.data, sd->buf.len);
- if (!handle_shout_error(sd, err))
+ if (!handle_shout_error(sd, err, error))
return false;
return true;
@@ -320,7 +348,7 @@ static void close_shout_conn(struct shout_data * sd)
if (sd->encoder != NULL) {
if (encoder_flush(sd->encoder, NULL))
- write_page(sd);
+ write_page(sd, NULL);
encoder_close(sd->encoder);
}
@@ -362,7 +390,7 @@ static void my_shout_close_device(void *data)
}
static bool
-shout_connect(struct shout_data *sd)
+shout_connect(struct shout_data *sd, GError **error)
{
int state;
@@ -373,58 +401,47 @@ shout_connect(struct shout_data *sd)
return true;
default:
- g_warning("problem opening connection to shout server %s:%i: %s\n",
- shout_get_host(sd->shout_conn),
- shout_get_port(sd->shout_conn),
- shout_get_error(sd->shout_conn));
+ g_set_error(error, shout_output_quark(), 0,
+ "problem opening connection to shout server %s:%i: %s",
+ shout_get_host(sd->shout_conn),
+ shout_get_port(sd->shout_conn),
+ shout_get_error(sd->shout_conn));
return false;
}
}
static bool
-my_shout_open_device(void *data, struct audio_format *audio_format)
+my_shout_open_device(void *data, struct audio_format *audio_format,
+ GError **error)
{
struct shout_data *sd = (struct shout_data *)data;
bool ret;
- GError *error = NULL;
- ret = shout_connect(sd);
+ ret = shout_connect(sd, error);
if (!ret)
return false;
sd->buf.len = 0;
- ret = encoder_open(sd->encoder, audio_format, &error);
+ ret = encoder_open(sd->encoder, audio_format, error) &&
+ write_page(sd, error);
if (!ret) {
shout_close(sd->shout_conn);
- g_warning("%s", error->message);
- g_error_free(error);
return false;
}
- write_page(sd);
-
return true;
}
static size_t
-my_shout_play(void *data, const void *chunk, size_t size)
+my_shout_play(void *data, const void *chunk, size_t size, GError **error)
{
struct shout_data *sd = (struct shout_data *)data;
- bool ret;
- GError *error = NULL;
- ret = encoder_write(sd->encoder, chunk, size, &error);
- if (!ret) {
- g_warning("%s", error->message);
- g_error_free(error);
- return false;
- }
-
- if (!write_page(sd))
- return 0;
-
- return size;
+ return encoder_write(sd->encoder, chunk, size, error) &&
+ write_page(sd, error)
+ ? size
+ : 0;
}
static bool
@@ -432,7 +449,7 @@ my_shout_pause(void *data)
{
static const char silence[1020];
- return my_shout_play(data, silence, sizeof(silence));
+ return my_shout_play(data, silence, sizeof(silence), NULL);
}
static void
@@ -479,7 +496,9 @@ static void my_shout_set_tag(void *data,
return;
}
- write_page(sd);
+ ret = write_page(sd, NULL);
+ if (!ret)
+ return;
ret = encoder_tag(sd->encoder, tag, &error);
if (!ret) {
@@ -499,7 +518,7 @@ static void my_shout_set_tag(void *data,
}
}
- write_page(sd);
+ write_page(sd, NULL);
}
const struct audio_output_plugin shoutPlugin = {
diff --git a/src/output_init.c b/src/output_init.c
index ab26e76ef..004b73e84 100644
--- a/src/output_init.c
+++ b/src/output_init.c
@@ -48,6 +48,7 @@ audio_output_init(struct audio_output *ao, const struct config_param *param)
char *format = NULL;
struct block_param *bp = NULL;
const struct audio_output_plugin *plugin = NULL;
+ GError *error = NULL;
if (param) {
const char *type = NULL;
@@ -97,7 +98,6 @@ audio_output_init(struct audio_output *ao, const struct config_param *param)
pcm_convert_init(&ao->convert_state);
if (format) {
- GError *error = NULL;
bool ret;
ret = audio_format_parse(&ao->config_audio_format, format,
@@ -114,9 +114,14 @@ audio_output_init(struct audio_output *ao, const struct config_param *param)
ao->data = ao_plugin_init(plugin,
format ? &ao->config_audio_format : NULL,
- param);
- if (ao->data == NULL)
+ param, &error);
+ if (ao->data == NULL) {
+ g_warning("Failed to initialize \"%s\" [%s]: %s",
+ ao->name, ao->plugin->name,
+ error->message);
+ g_error_free(error);
return false;
+ }
return true;
}
diff --git a/src/output_plugin.h b/src/output_plugin.h
index 2def73132..1c04ea921 100644
--- a/src/output_plugin.h
+++ b/src/output_plugin.h
@@ -19,6 +19,8 @@
#ifndef MPD_OUTPUT_PLUGIN_H
#define MPD_OUTPUT_PLUGIN_H
+#include <glib.h>
+
#include <stdbool.h>
#include <stddef.h>
@@ -45,16 +47,18 @@ struct audio_output_plugin {
* Configure and initialize the device, but do not open it
* yet.
*
- * @param ao an opaque pointer to the audio_output structure
* @param audio_format the configured audio format, or NULL if
* none is configured
* @param param the configuration section, or NULL if there is
* no configuration
+ * @param error location to store the error occuring, or NULL
+ * to ignore errors
* @return NULL on error, or an opaque pointer to the plugin's
* data
*/
void *(*init)(const struct audio_format *audio_format,
- const struct config_param *param);
+ const struct config_param *param,
+ GError **error);
/**
* Free resources allocated by this device.
@@ -72,10 +76,14 @@ struct audio_output_plugin {
/**
* Really open the device.
+ *
* @param audio_format the audio format in which data is going
* to be delivered; may be modified by the plugin
+ * @param error location to store the error occuring, or NULL
+ * to ignore errors
*/
- bool (*open)(void *data, struct audio_format *audio_format);
+ bool (*open)(void *data, struct audio_format *audio_format,
+ GError **error);
/**
* Close the device.
@@ -91,9 +99,12 @@ struct audio_output_plugin {
/**
* Play a chunk of audio data.
*
+ * @param error location to store the error occuring, or NULL
+ * to ignore errors
* @return the number of bytes played, or 0 on error
*/
- size_t (*play)(void *data, const void *chunk, size_t size);
+ size_t (*play)(void *data, const void *chunk, size_t size,
+ GError **error);
/**
* Try to cancel data which may still be in the device's
@@ -126,9 +137,10 @@ ao_plugin_test_default_device(const struct audio_output_plugin *plugin)
static inline void *
ao_plugin_init(const struct audio_output_plugin *plugin,
const struct audio_format *audio_format,
- const struct config_param *param)
+ const struct config_param *param,
+ GError **error)
{
- return plugin->init(audio_format, param);
+ return plugin->init(audio_format, param, error);
}
static inline void
@@ -147,9 +159,10 @@ ao_plugin_get_mixer(const struct audio_output_plugin *plugin, void *data)
static inline bool
ao_plugin_open(const struct audio_output_plugin *plugin,
- void *data, struct audio_format *audio_format)
+ void *data, struct audio_format *audio_format,
+ GError **error)
{
- return plugin->open(data, audio_format);
+ return plugin->open(data, audio_format, error);
}
static inline void
@@ -168,9 +181,10 @@ ao_plugin_send_tag(const struct audio_output_plugin *plugin,
static inline size_t
ao_plugin_play(const struct audio_output_plugin *plugin,
- void *data, const void *chunk, size_t size)
+ void *data, const void *chunk, size_t size,
+ GError **error)
{
- return plugin->play(data, chunk, size);
+ return plugin->play(data, chunk, size, error);
}
static inline void
diff --git a/src/output_thread.c b/src/output_thread.c
index 91fd8d406..b5a4c6117 100644
--- a/src/output_thread.c
+++ b/src/output_thread.c
@@ -56,6 +56,7 @@ static void ao_play(struct audio_output *ao)
{
const char *data = ao->args.play.data;
size_t size = ao->args.play.size;
+ GError *error = NULL;
assert(size > 0);
assert(size % audio_format_frame_size(&ao->in_audio_format) == 0);
@@ -76,9 +77,14 @@ static void ao_play(struct audio_output *ao)
while (size > 0) {
size_t nbytes;
- nbytes = ao_plugin_play(ao->plugin, ao->data, data, size);
+ nbytes = ao_plugin_play(ao->plugin, ao->data, data, size,
+ &error);
if (nbytes == 0) {
/* play()==0 means failure */
+ g_warning("\"%s\" [%s] failed to play: %s",
+ ao->name, ao->plugin->name, error->message);
+ g_error_free(error);
+
ao_plugin_cancel(ao->plugin, ao->data);
ao_close(ao);
break;
@@ -114,6 +120,7 @@ static gpointer audio_output_task(gpointer arg)
{
struct audio_output *ao = arg;
bool ret;
+ GError *error;
while (1) {
switch (ao->command) {
@@ -123,15 +130,23 @@ static gpointer audio_output_task(gpointer arg)
case AO_COMMAND_OPEN:
assert(!ao->open);
+ error = NULL;
ret = ao_plugin_open(ao->plugin, ao->data,
- &ao->out_audio_format);
+ &ao->out_audio_format,
+ &error);
assert(!ao->open);
if (ret) {
pcm_convert_init(&ao->convert_state);
ao->open = true;
- } else
+ } else {
+ g_warning("Failed to open \"%s\" [%s]: %s",
+ ao->name, ao->plugin->name,
+ error->message);
+ g_error_free(error);
+
ao->reopen_after = time(NULL) + REOPEN_AFTER;
+ }
ao_command_finished(ao);
break;