// vim:ts=4:sw=4:expandtab #include #include #include #include #include #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 bool mainloop_thread_running = 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 = roundf((float)avg_vol * 100 / PA_VOLUME_NORM); int composed_volume = COMPOSE_VOLUME_MUTE(vol_perc, info->mute); /* 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, composed_volume)) | save_volume(info->index, composed_volume)) { /* if the volume or mute flag changed, wake the main thread */ pthread_kill(main_thread, SIGUSR1); } } 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: context_ready = false; 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: /* server disconnected us, attempt to reconnect */ context_ready = false; pa_context_unref(context); context = NULL; 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 (!mainloop_thread_running && pa_threaded_mainloop_start(main_loop) < 0) { pulseaudio_error_log(context); pa_threaded_mainloop_free(main_loop); main_loop = NULL; return false; } mainloop_thread_running = true; } return true; }