X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Fpulse.c;h=66e6a3d87282db832d7045c7803d15ebc925bc7e;hb=a84ad18fbfe2fa8d9280ca0ad3d131d9fd067afb;hp=76e2495367ad77564ab2a727d0063abeccaaf484;hpb=9abe0a9d593548c021c1ab8c3548578bdd58ee32;p=i3%2Fi3status

diff --git a/src/pulse.c b/src/pulse.c
index 76e2495..66e6a3d 100644
--- a/src/pulse.c
+++ b/src/pulse.c
@@ -1,6 +1,8 @@
 // vim:ts=4:sw=4:expandtab
 #include <string.h>
 #include <stdio.h>
+#include <math.h>
+#include <signal.h>
 #include <pulse/pulseaudio.h>
 #include "i3status.h"
 #include "queue.h"
@@ -9,17 +11,21 @@
 #define APP_ID "org.i3wm"
 
 typedef struct indexed_volume_s {
+    char *name;
     uint32_t idx;
     int volume;
-    TAILQ_ENTRY(indexed_volume_s) entries;
+    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(tailhead, indexed_volume_s)
+cached_volume =
     TAILQ_HEAD_INITIALIZER(cached_volume);
 static pthread_mutex_t pulse_mutex = PTHREAD_MUTEX_INITIALIZER;
 
@@ -42,22 +48,35 @@ static bool pulseaudio_free_operation(pa_context *c, pa_operation *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) {
+static bool save_volume(uint32_t sink_idx, int new_volume, const char *name) {
     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;
+        if (name) {
+            if (!entry->name || strcmp(entry->name, name)) {
+                continue;
+            }
+        } else {
+            if (entry->idx != sink_idx) {
+                continue;
+            }
         }
+        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;
+    if (name) {
+        entry->name = malloc(strlen(name) + 1);
+        strcpy(entry->name, name);
+    } else {
+        entry->name = NULL;
+    }
     pthread_mutex_unlock(&pulse_mutex);
     return true;
 }
@@ -78,28 +97,33 @@ static void store_volume_from_sink_cb(pa_context *c,
         return;
 
     int avg_vol = pa_cvolume_avg(&info->volume);
-    int vol_perc = (int)((long long)avg_vol * 100 / PA_VOLUME_NORM);
+    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, 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);
+         save_volume(DEFAULT_SINK_INDEX, composed_volume, NULL)) |
+        save_volume(info->index, composed_volume, info->name)) {
+        /* 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 get_sink_info(pa_context *c, uint32_t idx, const char *name) {
+    pa_operation *o;
+
+    if (name || idx == DEFAULT_SINK_INDEX) {
+        o = pa_context_get_sink_info_by_name(
+            c, name ? name : "@DEFAULT_SINK@", store_volume_from_sink_cb, NULL);
+    } else {
+        o = pa_context_get_sink_info_by_index(
+            c, idx, store_volume_from_sink_cb, NULL);
+    }
+    if (o) {
+        pulseaudio_free_operation(c, o);
+    }
 }
 
 static void store_default_sink_cb(pa_context *c,
@@ -136,7 +160,7 @@ static void subscribe_cb(pa_context *c, pa_subscription_event_type_t t,
             update_default_sink(c);
             break;
         case PA_SUBSCRIPTION_EVENT_SINK:
-            get_sink_info(c, idx);
+            get_sink_info(c, idx, NULL);
             break;
         default:
             break;
@@ -151,6 +175,7 @@ static void context_state_callback(pa_context *c, void *userdata) {
         case PA_CONTEXT_SETTING_NAME:
         case PA_CONTEXT_TERMINATED:
         default:
+            context_ready = false;
             break;
 
         case PA_CONTEXT_READY: {
@@ -168,7 +193,10 @@ static void context_state_callback(pa_context *c, void *userdata) {
         } break;
 
         case PA_CONTEXT_FAILED:
-            pulseaudio_error_log(c);
+            /* server disconnected us, attempt to reconnect */
+            context_ready = false;
+            pa_context_unref(context);
+            context = NULL;
             break;
     }
 }
@@ -177,25 +205,32 @@ static void context_state_callback(pa_context *c, void *userdata) {
  * returns the current volume in percent, which, as per PulseAudio,
  * may be > 100%
  */
-int volume_pulseaudio(uint32_t sink_idx) {
+int volume_pulseaudio(uint32_t sink_idx, const char *sink_name) {
     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;
+        if (sink_name) {
+            if (!entry->name || strcmp(entry->name, sink_name)) {
+                continue;
+            }
+        } else {
+            if (entry->idx != sink_idx) {
+                continue;
+            }
         }
+        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);
+    get_sink_info(context, sink_idx, sink_name);
     pa_threaded_mainloop_unlock(main_loop);
     /* show 0 while we don't have this information */
     return 0;
@@ -234,12 +269,14 @@ bool pulse_initialize(void) {
             pulseaudio_error_log(context);
             return false;
         }
-        if (pa_threaded_mainloop_start(main_loop) < 0) {
+        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;
 }