Merge pull request #7 from Watcom/master

PulseAudio support for volume input

2 files changed, 273 insertions, 1 deletions

diff --git a/src/print_volume.c b/src/print_volume.c
index d8766b7..4359ac1 100644
--- a/src/print_volume.c
+++ b/src/print_volume.c
@@ -51,13 +51,40 @@ void print_volume(yajl_gen json_gen, char *buffer, const char *fmt, const char *
     char *outwalk = buffer;
     int pbval = 1;
 
-    /* Printing volume only works with ALSA at the moment */
+    /* Printing volume works with ALSA and PulseAudio at the moment */
     if (output_format == O_I3BAR) {
         char *instance;
         asprintf(&instance, "%s.%s.%d", device, mixer, mixer_idx);
         INSTANCE(instance);
         free(instance);
     }
+
+    /* Try PulseAudio first */
+
+    /* If the device name has the format "pulse[:N]" where N is the
+     * index of the PulseAudio sink then force PulseAudio, optionally
+     * overriding the default sink */
+    if (!strncasecmp(device, "pulse", strlen("pulse"))) {
+        uint32_t sink_idx = device[5] == ':' ? (uint32_t)atoi(device + 6)
+                                             : DEFAULT_SINK_INDEX;
+        int ivolume = pulse_initialize() ? volume_pulseaudio(sink_idx) : 0;
+        /* negative result means error, stick to 0 */
+        if (ivolume < 0)
+            ivolume = 0;
+        outwalk = apply_volume_format(fmt, outwalk, ivolume);
+        goto out;
+    } else if (!strcasecmp(device, "default") && pulse_initialize()) {
+        /* no device specified or "default" set */
+        int ivolume = volume_pulseaudio(DEFAULT_SINK_INDEX);
+        if (ivolume >= 0) {
+            outwalk = apply_volume_format(fmt, outwalk, ivolume);
+            goto out;
+        }
+        /* negative result means error, fail PulseAudio attempt */
+    }
+/* If some other device was specified or PulseAudio is not detected,
+ * proceed to ALSA / OSS */
+
 #ifdef LINUX
     int err;
     snd_mixer_t *m;
diff --git a/src/pulse.c b/src/pulse.c
new file mode 100644
index 0000000..76e2495
--- /dev/null
+++ b/src/pulse.c
@@ -0,0 +1,245 @@
+// vim:ts=4:sw=4:expandtab
+#include <string.h>
+#include <stdio.h>
+#include <pulse/pulseaudio.h>
+#include "i3status.h"
+#include "queue.h"
+
+#define APP_NAME "i3status"
+#define APP_ID "org.i3wm"
+
+typedef struct indexed_volume_s {
+    uint32_t idx;
+    int volume;
+    TAILQ_ENTRY(indexed_volume_s) entries;
+} indexed_volume_t;
+
+static pa_threaded_mainloop *main_loop = NULL;
+static pa_context *context = NULL;
+static pa_mainloop_api *api = NULL;
+static bool context_ready = false;
+static uint32_t default_sink_idx = DEFAULT_SINK_INDEX;
+TAILQ_HEAD(tailhead, indexed_volume_s) cached_volume =
+    TAILQ_HEAD_INITIALIZER(cached_volume);
+static pthread_mutex_t pulse_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static void pulseaudio_error_log(pa_context *c) {
+    fprintf(stderr,
+            "i3status: PulseAudio: %s\n",
+            pa_strerror(pa_context_errno(c)));
+}
+
+static bool pulseaudio_free_operation(pa_context *c, pa_operation *o) {
+    if (o)
+        pa_operation_unref(o);
+    else
+        pulseaudio_error_log(c);
+    /* return false if the operation failed */
+    return o;
+}
+
+/*
+ * save the volume for the specified sink index
+ * returning true if the value was changed
+ */
+static bool save_volume(uint32_t sink_idx, int new_volume) {
+    pthread_mutex_lock(&pulse_mutex);
+    indexed_volume_t *entry;
+    TAILQ_FOREACH(entry, &cached_volume, entries) {
+        if (entry->idx == sink_idx) {
+            const bool changed = (new_volume != entry->volume);
+            entry->volume = new_volume;
+            pthread_mutex_unlock(&pulse_mutex);
+            return changed;
+        }
+    }
+    /* index not found, store it */
+    entry = malloc(sizeof(*entry));
+    TAILQ_INSERT_HEAD(&cached_volume, entry, entries);
+    entry->idx = sink_idx;
+    entry->volume = new_volume;
+    pthread_mutex_unlock(&pulse_mutex);
+    return true;
+}
+
+static void store_volume_from_sink_cb(pa_context *c,
+                                      const pa_sink_info *info,
+                                      int eol,
+                                      void *userdata) {
+    if (eol < 0) {
+        if (pa_context_errno(c) == PA_ERR_NOENTITY)
+            return;
+
+        pulseaudio_error_log(c);
+        return;
+    }
+
+    if (eol > 0)
+        return;
+
+    int avg_vol = pa_cvolume_avg(&info->volume);
+    int vol_perc = (int)((long long)avg_vol * 100 / PA_VOLUME_NORM);
+
+    /* if this is the default sink we must try to save it twice: once with
+     * DEFAULT_SINK_INDEX as the index, and another with its proper value
+     * (using bitwise OR to avoid early-out logic) */
+    if ((info->index == default_sink_idx &&
+         save_volume(DEFAULT_SINK_INDEX, vol_perc)) |
+        save_volume(info->index, vol_perc)) {
+        /* if the volume changed, wake the main thread */
+        pthread_mutex_lock(&i3status_sleep_mutex);
+        pthread_cond_broadcast(&i3status_sleep_cond);
+        pthread_mutex_unlock(&i3status_sleep_mutex);
+    }
+}
+
+static void get_sink_info(pa_context *c, uint32_t idx) {
+    pa_operation *o =
+        idx == DEFAULT_SINK_INDEX ? pa_context_get_sink_info_by_name(
+                                        c, "@DEFAULT_SINK@", store_volume_from_sink_cb, NULL)
+                                  : pa_context_get_sink_info_by_index(
+                                        c, idx, store_volume_from_sink_cb, NULL);
+    pulseaudio_free_operation(c, o);
+}
+
+static void store_default_sink_cb(pa_context *c,
+                                  const pa_sink_info *i,
+                                  int eol,
+                                  void *userdata) {
+    if (i) {
+        if (default_sink_idx != i->index) {
+            /* default sink changed? */
+            default_sink_idx = i->index;
+            store_volume_from_sink_cb(c, i, eol, userdata);
+        }
+    }
+}
+
+static void update_default_sink(pa_context *c) {
+    pa_operation *o = pa_context_get_sink_info_by_name(
+        c,
+        "@DEFAULT_SINK@",
+        store_default_sink_cb,
+        NULL);
+    pulseaudio_free_operation(c, o);
+}
+
+static void subscribe_cb(pa_context *c, pa_subscription_event_type_t t,
+                         uint32_t idx, void *userdata) {
+    if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) != PA_SUBSCRIPTION_EVENT_CHANGE)
+        return;
+    pa_subscription_event_type_t facility =
+        t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK;
+    switch (facility) {
+        case PA_SUBSCRIPTION_EVENT_SERVER:
+            /* server change event, see if the default sink changed */
+            update_default_sink(c);
+            break;
+        case PA_SUBSCRIPTION_EVENT_SINK:
+            get_sink_info(c, idx);
+            break;
+        default:
+            break;
+    }
+}
+
+static void context_state_callback(pa_context *c, void *userdata) {
+    switch (pa_context_get_state(c)) {
+        case PA_CONTEXT_UNCONNECTED:
+        case PA_CONTEXT_CONNECTING:
+        case PA_CONTEXT_AUTHORIZING:
+        case PA_CONTEXT_SETTING_NAME:
+        case PA_CONTEXT_TERMINATED:
+        default:
+            break;
+
+        case PA_CONTEXT_READY: {
+            pa_context_set_subscribe_callback(c, subscribe_cb, NULL);
+            update_default_sink(c);
+
+            pa_operation *o = pa_context_subscribe(
+                c,
+                PA_SUBSCRIPTION_MASK_SINK | PA_SUBSCRIPTION_MASK_SERVER,
+                NULL,
+                NULL);
+            if (!pulseaudio_free_operation(c, o))
+                break;
+            context_ready = true;
+        } break;
+
+        case PA_CONTEXT_FAILED:
+            pulseaudio_error_log(c);
+            break;
+    }
+}
+
+/*
+ * returns the current volume in percent, which, as per PulseAudio,
+ * may be > 100%
+ */
+int volume_pulseaudio(uint32_t sink_idx) {
+    if (!context_ready || default_sink_idx == DEFAULT_SINK_INDEX)
+        return -1;
+
+    pthread_mutex_lock(&pulse_mutex);
+    const indexed_volume_t *entry;
+    TAILQ_FOREACH(entry, &cached_volume, entries) {
+        if (entry->idx == sink_idx) {
+            int vol = entry->volume;
+            pthread_mutex_unlock(&pulse_mutex);
+            return vol;
+        }
+    }
+    pthread_mutex_unlock(&pulse_mutex);
+    /* first time requires a prime callback call because we only get
+     * updates when the volume actually changes, but we need it to
+     * be correct even if it never changes */
+    pa_threaded_mainloop_lock(main_loop);
+    get_sink_info(context, sink_idx);
+    pa_threaded_mainloop_unlock(main_loop);
+    /* show 0 while we don't have this information */
+    return 0;
+}
+
+/*
+ *  detect and, if necessary, initialize the PulseAudio API
+ */
+bool pulse_initialize(void) {
+    if (!main_loop) {
+        main_loop = pa_threaded_mainloop_new();
+        if (!main_loop)
+            return false;
+    }
+    if (!api) {
+        api = pa_threaded_mainloop_get_api(main_loop);
+        if (!api)
+            return false;
+    }
+    if (!context) {
+        pa_proplist *proplist = pa_proplist_new();
+        pa_proplist_sets(proplist, PA_PROP_APPLICATION_NAME, APP_NAME);
+        pa_proplist_sets(proplist, PA_PROP_APPLICATION_ID, APP_ID);
+        pa_proplist_sets(proplist, PA_PROP_APPLICATION_VERSION, VERSION);
+        context = pa_context_new_with_proplist(api, APP_NAME, proplist);
+        pa_proplist_free(proplist);
+        if (!context)
+            return false;
+        pa_context_set_state_callback(context,
+                                      context_state_callback,
+                                      NULL);
+        if (pa_context_connect(context,
+                               NULL,
+                               PA_CONTEXT_NOFAIL | PA_CONTEXT_NOAUTOSPAWN,
+                               NULL) < 0) {
+            pulseaudio_error_log(context);
+            return false;
+        }
+        if (pa_threaded_mainloop_start(main_loop) < 0) {
+            pulseaudio_error_log(context);
+            pa_threaded_mainloop_free(main_loop);
+            main_loop = NULL;
+            return false;
+        }
+    }
+    return true;
+}