1 // vim:ts=4:sw=4:expandtab
4 #include <pulse/pulseaudio.h>
8 #define APP_NAME "i3status"
9 #define APP_ID "org.i3wm"
11 typedef struct indexed_volume_s {
14 TAILQ_ENTRY(indexed_volume_s) entries;
17 static pa_threaded_mainloop *main_loop = NULL;
18 static pa_context *context = NULL;
19 static pa_mainloop_api *api = NULL;
20 static bool context_ready = false;
21 static uint32_t default_sink_idx = DEFAULT_SINK_INDEX;
22 TAILQ_HEAD(tailhead, indexed_volume_s) cached_volume =
23 TAILQ_HEAD_INITIALIZER(cached_volume);
24 static pthread_mutex_t pulse_mutex = PTHREAD_MUTEX_INITIALIZER;
26 static void pulseaudio_error_log(pa_context *c) {
28 "i3status: PulseAudio: %s\n",
29 pa_strerror(pa_context_errno(c)));
32 static bool pulseaudio_free_operation(pa_context *c, pa_operation *o) {
34 pa_operation_unref(o);
36 pulseaudio_error_log(c);
37 /* return false if the operation failed */
42 * save the volume for the specified sink index
43 * returning true if the value was changed
45 static bool save_volume(uint32_t sink_idx, int new_volume) {
46 pthread_mutex_lock(&pulse_mutex);
47 indexed_volume_t *entry;
48 TAILQ_FOREACH(entry, &cached_volume, entries) {
49 if (entry->idx == sink_idx) {
50 const bool changed = (new_volume != entry->volume);
51 entry->volume = new_volume;
52 pthread_mutex_unlock(&pulse_mutex);
56 /* index not found, store it */
57 entry = malloc(sizeof(*entry));
58 TAILQ_INSERT_HEAD(&cached_volume, entry, entries);
59 entry->idx = sink_idx;
60 entry->volume = new_volume;
61 pthread_mutex_unlock(&pulse_mutex);
65 static void store_volume_from_sink_cb(pa_context *c,
66 const pa_sink_info *info,
70 if (pa_context_errno(c) == PA_ERR_NOENTITY)
73 pulseaudio_error_log(c);
80 int avg_vol = pa_cvolume_avg(&info->volume);
81 int vol_perc = (int)((long long)avg_vol * 100 / PA_VOLUME_NORM);
82 int composed_volume = COMPOSE_VOLUME_MUTE(vol_perc, info->mute);
84 /* if this is the default sink we must try to save it twice: once with
85 * DEFAULT_SINK_INDEX as the index, and another with its proper value
86 * (using bitwise OR to avoid early-out logic) */
87 if ((info->index == default_sink_idx &&
88 save_volume(DEFAULT_SINK_INDEX, composed_volume)) |
89 save_volume(info->index, composed_volume)) {
90 /* if the volume or mute flag changed, wake the main thread */
91 pthread_mutex_lock(&i3status_sleep_mutex);
92 pthread_cond_broadcast(&i3status_sleep_cond);
93 pthread_mutex_unlock(&i3status_sleep_mutex);
97 static void get_sink_info(pa_context *c, uint32_t idx) {
99 idx == DEFAULT_SINK_INDEX ? pa_context_get_sink_info_by_name(
100 c, "@DEFAULT_SINK@", store_volume_from_sink_cb, NULL)
101 : pa_context_get_sink_info_by_index(
102 c, idx, store_volume_from_sink_cb, NULL);
103 pulseaudio_free_operation(c, o);
106 static void store_default_sink_cb(pa_context *c,
107 const pa_sink_info *i,
111 if (default_sink_idx != i->index) {
112 /* default sink changed? */
113 default_sink_idx = i->index;
114 store_volume_from_sink_cb(c, i, eol, userdata);
119 static void update_default_sink(pa_context *c) {
120 pa_operation *o = pa_context_get_sink_info_by_name(
123 store_default_sink_cb,
125 pulseaudio_free_operation(c, o);
128 static void subscribe_cb(pa_context *c, pa_subscription_event_type_t t,
129 uint32_t idx, void *userdata) {
130 if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) != PA_SUBSCRIPTION_EVENT_CHANGE)
132 pa_subscription_event_type_t facility =
133 t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK;
135 case PA_SUBSCRIPTION_EVENT_SERVER:
136 /* server change event, see if the default sink changed */
137 update_default_sink(c);
139 case PA_SUBSCRIPTION_EVENT_SINK:
140 get_sink_info(c, idx);
147 static void context_state_callback(pa_context *c, void *userdata) {
148 switch (pa_context_get_state(c)) {
149 case PA_CONTEXT_UNCONNECTED:
150 case PA_CONTEXT_CONNECTING:
151 case PA_CONTEXT_AUTHORIZING:
152 case PA_CONTEXT_SETTING_NAME:
153 case PA_CONTEXT_TERMINATED:
157 case PA_CONTEXT_READY: {
158 pa_context_set_subscribe_callback(c, subscribe_cb, NULL);
159 update_default_sink(c);
161 pa_operation *o = pa_context_subscribe(
163 PA_SUBSCRIPTION_MASK_SINK | PA_SUBSCRIPTION_MASK_SERVER,
166 if (!pulseaudio_free_operation(c, o))
168 context_ready = true;
171 case PA_CONTEXT_FAILED:
172 pulseaudio_error_log(c);
178 * returns the current volume in percent, which, as per PulseAudio,
181 int volume_pulseaudio(uint32_t sink_idx) {
182 if (!context_ready || default_sink_idx == DEFAULT_SINK_INDEX)
185 pthread_mutex_lock(&pulse_mutex);
186 const indexed_volume_t *entry;
187 TAILQ_FOREACH(entry, &cached_volume, entries) {
188 if (entry->idx == sink_idx) {
189 int vol = entry->volume;
190 pthread_mutex_unlock(&pulse_mutex);
194 pthread_mutex_unlock(&pulse_mutex);
195 /* first time requires a prime callback call because we only get
196 * updates when the volume actually changes, but we need it to
197 * be correct even if it never changes */
198 pa_threaded_mainloop_lock(main_loop);
199 get_sink_info(context, sink_idx);
200 pa_threaded_mainloop_unlock(main_loop);
201 /* show 0 while we don't have this information */
206 * detect and, if necessary, initialize the PulseAudio API
208 bool pulse_initialize(void) {
210 main_loop = pa_threaded_mainloop_new();
215 api = pa_threaded_mainloop_get_api(main_loop);
220 pa_proplist *proplist = pa_proplist_new();
221 pa_proplist_sets(proplist, PA_PROP_APPLICATION_NAME, APP_NAME);
222 pa_proplist_sets(proplist, PA_PROP_APPLICATION_ID, APP_ID);
223 pa_proplist_sets(proplist, PA_PROP_APPLICATION_VERSION, VERSION);
224 context = pa_context_new_with_proplist(api, APP_NAME, proplist);
225 pa_proplist_free(proplist);
228 pa_context_set_state_callback(context,
229 context_state_callback,
231 if (pa_context_connect(context,
233 PA_CONTEXT_NOFAIL | PA_CONTEXT_NOAUTOSPAWN,
235 pulseaudio_error_log(context);
238 if (pa_threaded_mainloop_start(main_loop) < 0) {
239 pulseaudio_error_log(context);
240 pa_threaded_mainloop_free(main_loop);