--- /dev/null
+// 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;
+}
projects / i3 / i3status / blobdiff