X-Git-Url: https://code.delx.au/pulseaudio/blobdiff_plain/638b0264e09bd68d75a79754c180519fbda86b36..7ac850d3b7ce803044b58a357b4e27730cf53bc7:/src/pulsecore/source.c

diff --git a/src/pulsecore/source.c b/src/pulsecore/source.c
index f7196cfc..5c1847e1 100644
--- a/src/pulsecore/source.c
+++ b/src/pulsecore/source.c
@@ -40,7 +40,7 @@
 #include <pulsecore/namereg.h>
 #include <pulsecore/core-subscribe.h>
 #include <pulsecore/log.h>
-#include <pulsecore/sample-util.h>
+#include <pulsecore/mix.h>
 #include <pulsecore/flist.h>
 
 #include "source.h"
@@ -73,6 +73,7 @@ pa_source_new_data* pa_source_new_data_init(pa_source_new_data *data) {
 
     pa_zero(*data);
     data->proplist = pa_proplist_new();
+    data->ports = pa_hashmap_new_full(pa_idxset_string_hash_func, pa_idxset_string_compare_func, NULL, (pa_free_cb_t) pa_device_port_unref);
 
     return data;
 }
@@ -101,7 +102,7 @@ void pa_source_new_data_set_channel_map(pa_source_new_data *data, const pa_chann
 void pa_source_new_data_set_alternate_sample_rate(pa_source_new_data *data, const uint32_t alternate_sample_rate) {
     pa_assert(data);
 
-    data->alternate_sample_rate_is_set = TRUE;
+    data->alternate_sample_rate_is_set = true;
     data->alternate_sample_rate = alternate_sample_rate;
 }
 
@@ -112,10 +113,10 @@ void pa_source_new_data_set_volume(pa_source_new_data *data, const pa_cvolume *v
         data->volume = *volume;
 }
 
-void pa_source_new_data_set_muted(pa_source_new_data *data, pa_bool_t mute) {
+void pa_source_new_data_set_muted(pa_source_new_data *data, bool mute) {
     pa_assert(data);
 
-    data->muted_is_set = TRUE;
+    data->muted_is_set = true;
     data->muted = !!mute;
 }
 
@@ -132,7 +133,7 @@ void pa_source_new_data_done(pa_source_new_data *data) {
     pa_proplist_free(data->proplist);
 
     if (data->ports)
-        pa_device_port_hashmap_free(data->ports);
+        pa_hashmap_free(data->ports);
 
     pa_xfree(data->name);
     pa_xfree(data->active_port);
@@ -205,22 +206,28 @@ pa_source* pa_source_new(
 
     if (!data->volume_is_set) {
         pa_cvolume_reset(&data->volume, data->sample_spec.channels);
-        data->save_volume = FALSE;
+        data->save_volume = false;
     }
 
     pa_return_null_if_fail(pa_cvolume_valid(&data->volume));
     pa_return_null_if_fail(pa_cvolume_compatible(&data->volume, &data->sample_spec));
 
     if (!data->muted_is_set)
-        data->muted = FALSE;
+        data->muted = false;
 
     if (data->card)
         pa_proplist_update(data->proplist, PA_UPDATE_MERGE, data->card->proplist);
 
-    pa_device_init_description(data->proplist);
-    pa_device_init_icon(data->proplist, FALSE);
+    pa_device_init_description(data->proplist, data->card);
+    pa_device_init_icon(data->proplist, false);
     pa_device_init_intended_roles(data->proplist);
 
+    if (!data->active_port) {
+        pa_device_port *p = pa_device_port_find_best(data->ports);
+        if (p)
+            pa_source_new_data_set_port(data, p->name);
+    }
+
     if (pa_hook_fire(&core->hooks[PA_CORE_HOOK_SOURCE_FIXATE], data) < 0) {
         pa_xfree(s);
         pa_namereg_unregister(core, name);
@@ -234,7 +241,8 @@ pa_source* pa_source_new(
     s->state = PA_SOURCE_INIT;
     s->flags = flags;
     s->priority = 0;
-    s->suspend_cause = 0;
+    s->suspend_cause = data->suspend_cause;
+    pa_source_set_mixer_dirty(s, false);
     s->name = pa_xstrdup(name);
     s->proplist = pa_proplist_copy(data->proplist);
     s->driver = pa_xstrdup(pa_path_get_filename(data->driver));
@@ -267,7 +275,7 @@ pa_source* pa_source_new(
     s->base_volume = PA_VOLUME_NORM;
     s->n_volume_steps = PA_VOLUME_NORM+1;
     s->muted = data->muted;
-    s->refresh_volume = s->refresh_muted = FALSE;
+    s->refresh_volume = s->refresh_muted = false;
 
     reset_callbacks(s);
     s->userdata = NULL;
@@ -280,20 +288,21 @@ pa_source* pa_source_new(
     data->ports = NULL;
 
     s->active_port = NULL;
-    s->save_port = FALSE;
+    s->save_port = false;
 
-    if (data->active_port && s->ports)
+    if (data->active_port)
         if ((s->active_port = pa_hashmap_get(s->ports, data->active_port)))
             s->save_port = data->save_port;
 
-    if (!s->active_port && s->ports) {
-        void *state;
-        pa_device_port *p;
+    /* Hopefully the active port has already been assigned in the previous call
+       to pa_device_port_find_best, but better safe than sorry */
+    if (!s->active_port)
+        s->active_port = pa_device_port_find_best(s->ports);
 
-        PA_HASHMAP_FOREACH(p, s->ports, state)
-            if (!s->active_port || p->priority > s->active_port->priority)
-                s->active_port = p;
-    }
+    if (s->active_port)
+        s->latency_offset = s->active_port->latency_offset;
+    else
+        s->latency_offset = 0;
 
     s->save_volume = data->save_volume;
     s->save_muted = data->save_muted;
@@ -306,12 +315,13 @@ pa_source* pa_source_new(
             0);
 
     s->thread_info.rtpoll = NULL;
-    s->thread_info.outputs = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
+    s->thread_info.outputs = pa_hashmap_new_full(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func, NULL,
+                                                 (pa_free_cb_t) pa_source_output_unref);
     s->thread_info.soft_volume = s->soft_volume;
     s->thread_info.soft_muted = s->muted;
     s->thread_info.state = s->state;
     s->thread_info.max_rewind = 0;
-    s->thread_info.requested_latency_valid = FALSE;
+    s->thread_info.requested_latency_valid = false;
     s->thread_info.requested_latency = 0;
     s->thread_info.min_latency = ABSOLUTE_MIN_LATENCY;
     s->thread_info.max_latency = ABSOLUTE_MAX_LATENCY;
@@ -322,6 +332,7 @@ pa_source* pa_source_new(
     pa_sw_cvolume_multiply(&s->thread_info.current_hw_volume, &s->soft_volume, &s->real_volume);
     s->thread_info.volume_change_safety_margin = core->deferred_volume_safety_margin_usec;
     s->thread_info.volume_change_extra_delay = core->deferred_volume_extra_delay_usec;
+    s->thread_info.latency_offset = s->latency_offset;
 
     /* FIXME: This should probably be moved to pa_source_put() */
     pa_assert_se(pa_idxset_put(core->sources, s, &s->index) >= 0);
@@ -344,7 +355,7 @@ pa_source* pa_source_new(
 /* Called from main context */
 static int source_set_state(pa_source *s, pa_source_state_t state) {
     int ret;
-    pa_bool_t suspend_change;
+    bool suspend_change;
     pa_source_state_t original_state;
 
     pa_assert(s);
@@ -474,7 +485,7 @@ void pa_source_set_set_mute_callback(pa_source *s, pa_source_cb_t cb) {
         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 }
 
-static void enable_flat_volume(pa_source *s, pa_bool_t enable) {
+static void enable_flat_volume(pa_source *s, bool enable) {
     pa_source_flags_t flags;
 
     pa_assert(s);
@@ -495,7 +506,7 @@ static void enable_flat_volume(pa_source *s, pa_bool_t enable) {
         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 }
 
-void pa_source_enable_decibel_volume(pa_source *s, pa_bool_t enable) {
+void pa_source_enable_decibel_volume(pa_source *s, bool enable) {
     pa_source_flags_t flags;
 
     pa_assert(s);
@@ -505,10 +516,10 @@ void pa_source_enable_decibel_volume(pa_source *s, pa_bool_t enable) {
 
     if (enable) {
         s->flags |= PA_SOURCE_DECIBEL_VOLUME;
-        enable_flat_volume(s, TRUE);
+        enable_flat_volume(s, true);
     } else {
         s->flags &= ~PA_SOURCE_DECIBEL_VOLUME;
-        enable_flat_volume(s, FALSE);
+        enable_flat_volume(s, false);
     }
 
     /* If the flags have changed after init, let any clients know via a change event */
@@ -554,12 +565,12 @@ void pa_source_put(pa_source *s) {
      *
      * Note: This flag can also change over the life time of the source. */
     if (!(s->flags & PA_SOURCE_HW_VOLUME_CTRL) && !(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
-        pa_source_enable_decibel_volume(s, TRUE);
+        pa_source_enable_decibel_volume(s, true);
 
     /* If the source implementor support DB volumes by itself, we should always
      * try and enable flat volumes too */
     if ((s->flags & PA_SOURCE_DECIBEL_VOLUME))
-        enable_flat_volume(s, TRUE);
+        enable_flat_volume(s, true);
 
     if (s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER) {
         pa_source *root_source = pa_source_get_master(s);
@@ -587,7 +598,10 @@ void pa_source_put(pa_source *s) {
     pa_assert(!(s->flags & PA_SOURCE_DECIBEL_VOLUME) || s->n_volume_steps == PA_VOLUME_NORM+1);
     pa_assert(!(s->flags & PA_SOURCE_DYNAMIC_LATENCY) == (s->thread_info.fixed_latency != 0));
 
-    pa_assert_se(source_set_state(s, PA_SOURCE_IDLE) == 0);
+    if (s->suspend_cause)
+        pa_assert_se(source_set_state(s, PA_SOURCE_SUSPENDED) == 0);
+    else
+        pa_assert_se(source_set_state(s, PA_SOURCE_IDLE) == 0);
 
     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE | PA_SUBSCRIPTION_EVENT_NEW, s->index);
     pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_PUT], s);
@@ -595,7 +609,7 @@ void pa_source_put(pa_source *s) {
 
 /* Called from main context */
 void pa_source_unlink(pa_source *s) {
-    pa_bool_t linked;
+    bool linked;
     pa_source_output *o, *j = NULL;
 
     pa_assert(s);
@@ -637,7 +651,6 @@ void pa_source_unlink(pa_source *s) {
 
 /* Called from main context */
 static void source_free(pa_object *o) {
-    pa_source_output *so;
     pa_source *s = PA_SOURCE(o);
 
     pa_assert(s);
@@ -649,12 +662,8 @@ static void source_free(pa_object *o) {
 
     pa_log_info("Freeing source %u \"%s\"", s->index, s->name);
 
-    pa_idxset_free(s->outputs, NULL, NULL);
-
-    while ((so = pa_hashmap_steal_first(s->thread_info.outputs)))
-        pa_source_output_unref(so);
-
-    pa_hashmap_free(s->thread_info.outputs, NULL, NULL);
+    pa_idxset_free(s->outputs, NULL);
+    pa_hashmap_free(s->thread_info.outputs);
 
     if (s->silence.memblock)
         pa_memblock_unref(s->silence.memblock);
@@ -666,7 +675,7 @@ static void source_free(pa_object *o) {
         pa_proplist_free(s->proplist);
 
     if (s->ports)
-        pa_device_port_hashmap_free(s->ports);
+        pa_hashmap_free(s->ports);
 
     pa_xfree(s);
 }
@@ -681,16 +690,36 @@ void pa_source_set_asyncmsgq(pa_source *s, pa_asyncmsgq *q) {
 
 /* Called from main context, and not while the IO thread is active, please */
 void pa_source_update_flags(pa_source *s, pa_source_flags_t mask, pa_source_flags_t value) {
+    pa_source_flags_t old_flags;
+    pa_source_output *output;
+    uint32_t idx;
+
     pa_source_assert_ref(s);
     pa_assert_ctl_context();
 
-    if (mask == 0)
-        return;
-
     /* For now, allow only a minimal set of flags to be changed. */
     pa_assert((mask & ~(PA_SOURCE_DYNAMIC_LATENCY|PA_SOURCE_LATENCY)) == 0);
 
+    old_flags = s->flags;
     s->flags = (s->flags & ~mask) | (value & mask);
+
+    if (s->flags == old_flags)
+        return;
+
+    if ((s->flags & PA_SOURCE_LATENCY) != (old_flags & PA_SOURCE_LATENCY))
+        pa_log_debug("Source %s: LATENCY flag %s.", s->name, (s->flags & PA_SOURCE_LATENCY) ? "enabled" : "disabled");
+
+    if ((s->flags & PA_SOURCE_DYNAMIC_LATENCY) != (old_flags & PA_SOURCE_DYNAMIC_LATENCY))
+        pa_log_debug("Source %s: DYNAMIC_LATENCY flag %s.",
+                     s->name, (s->flags & PA_SOURCE_DYNAMIC_LATENCY) ? "enabled" : "disabled");
+
+    pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE | PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
+    pa_hook_fire(&s->core->hooks[PA_CORE_HOOK_SOURCE_FLAGS_CHANGED], s);
+
+    PA_IDXSET_FOREACH(output, s->outputs, idx) {
+        if (output->destination_source)
+            pa_source_update_flags(output->destination_source, mask, value);
+    }
 }
 
 /* Called from IO context, or before _put() from main context */
@@ -713,8 +742,13 @@ int pa_source_update_status(pa_source*s) {
     return source_set_state(s, pa_source_used_by(s) ? PA_SOURCE_RUNNING : PA_SOURCE_IDLE);
 }
 
+/* Called from any context - must be threadsafe */
+void pa_source_set_mixer_dirty(pa_source *s, bool is_dirty) {
+    pa_atomic_store(&s->mixer_dirty, is_dirty ? 1 : 0);
+}
+
 /* Called from main context */
-int pa_source_suspend(pa_source *s, pa_bool_t suspend, pa_suspend_cause_t cause) {
+int pa_source_suspend(pa_source *s, bool suspend, pa_suspend_cause_t cause) {
     pa_source_assert_ref(s);
     pa_assert_ctl_context();
     pa_assert(PA_SOURCE_IS_LINKED(s->state));
@@ -728,6 +762,27 @@ int pa_source_suspend(pa_source *s, pa_bool_t suspend, pa_suspend_cause_t cause)
     else
         s->suspend_cause &= ~cause;
 
+    if (!(s->suspend_cause & PA_SUSPEND_SESSION) && (pa_atomic_load(&s->mixer_dirty) != 0)) {
+        /* This might look racy but isn't: If somebody sets mixer_dirty exactly here,
+           it'll be handled just fine. */
+        pa_source_set_mixer_dirty(s, false);
+        pa_log_debug("Mixer is now accessible. Updating alsa mixer settings.");
+        if (s->active_port && s->set_port) {
+            if (s->flags & PA_SOURCE_DEFERRED_VOLUME) {
+                struct source_message_set_port msg = { .port = s->active_port, .ret = 0 };
+                pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_PORT, &msg, 0, NULL) == 0);
+            }
+            else
+                s->set_port(s, s->active_port);
+        }
+        else {
+            if (s->set_mute)
+                s->set_mute(s);
+            if (s->set_volume)
+                s->set_volume(s);
+        }
+    }
+
     if ((pa_source_get_state(s) == PA_SOURCE_SUSPENDED) == !!s->suspend_cause)
         return 0;
 
@@ -785,7 +840,7 @@ pa_queue *pa_source_move_all_start(pa_source *s, pa_queue *q) {
 }
 
 /* Called from main context */
-void pa_source_move_all_finish(pa_source *s, pa_queue *q, pa_bool_t save) {
+void pa_source_move_all_finish(pa_source *s, pa_queue *q, bool save) {
     pa_source_output *o;
 
     pa_source_assert_ref(s);
@@ -915,69 +970,116 @@ void pa_source_post_direct(pa_source*s, pa_source_output *o, const pa_memchunk *
 }
 
 /* Called from main thread */
-pa_bool_t pa_source_update_rate(pa_source *s, uint32_t rate, pa_bool_t passthrough)
-{
-    if (s->update_rate) {
-        uint32_t desired_rate = rate;
-        uint32_t default_rate = s->default_sample_rate;
-        uint32_t alternate_rate = s->alternate_sample_rate;
-        uint32_t idx;
-        pa_source_output *o;
-        pa_bool_t use_alternate = FALSE;
+int pa_source_update_rate(pa_source *s, uint32_t rate, bool passthrough) {
+    int ret;
+    uint32_t desired_rate = rate;
+    uint32_t default_rate = s->default_sample_rate;
+    uint32_t alternate_rate = s->alternate_sample_rate;
+    bool use_alternate = false;
 
-        if (PA_UNLIKELY(default_rate == alternate_rate)) {
-            pa_log_warn("Default and alternate sample rates are the same.");
-            return FALSE;
-        }
+    if (rate == s->sample_spec.rate)
+        return 0;
+
+    if (!s->update_rate && !s->monitor_of)
+        return -1;
+
+    if (PA_UNLIKELY(default_rate == alternate_rate && !passthrough)) {
+        pa_log_debug("Default and alternate sample rates are the same.");
+        return -1;
+    }
 
-        if (PA_SOURCE_IS_RUNNING(s->state)) {
-            pa_log_info("Cannot update rate, SOURCE_IS_RUNNING, will keep using %u Hz",
-                        s->sample_spec.rate);
-            return FALSE;
+    if (PA_SOURCE_IS_RUNNING(s->state)) {
+        pa_log_info("Cannot update rate, SOURCE_IS_RUNNING, will keep using %u Hz",
+                    s->sample_spec.rate);
+        return -1;
+    }
+
+    if (s->monitor_of) {
+        if (PA_SINK_IS_RUNNING(s->monitor_of->state)) {
+            pa_log_info("Cannot update rate, this is a monitor source and the sink is running.");
+            return -1;
         }
+    }
 
-        if (PA_UNLIKELY (desired_rate < 8000 ||
-                         desired_rate > PA_RATE_MAX))
-            return FALSE;
+    if (PA_UNLIKELY(!pa_sample_rate_valid(desired_rate)))
+        return -1;
 
-        if (!passthrough) {
-            pa_assert(default_rate % 4000 || default_rate % 11025);
-            pa_assert(alternate_rate % 4000 || alternate_rate % 11025);
-
-            if (default_rate % 4000) {
-                /* default is a 11025 multiple */
-                if ((alternate_rate % 4000 == 0) && (desired_rate % 4000 == 0))
-                    use_alternate=TRUE;
-            } else {
-                /* default is 4000 multiple */
-                if ((alternate_rate % 11025 == 0) && (desired_rate % 11025 == 0))
-                    use_alternate=TRUE;
-            }
+    if (!passthrough) {
+        pa_assert((default_rate % 4000 == 0) || (default_rate % 11025 == 0));
+        pa_assert((alternate_rate % 4000 == 0) || (alternate_rate % 11025 == 0));
 
-            if (use_alternate)
-                desired_rate = alternate_rate;
-            else
-                desired_rate = default_rate;
+        if (default_rate % 11025 == 0) {
+            if ((alternate_rate % 4000 == 0) && (desired_rate % 4000 == 0))
+                use_alternate=true;
         } else {
-            desired_rate = rate; /* use stream sampling rate, discard default/alternate settings */
+            /* default is 4000 multiple */
+            if ((alternate_rate % 11025 == 0) && (desired_rate % 11025 == 0))
+                use_alternate=true;
         }
 
-        if (!passthrough && pa_source_used_by(s) > 0)
-            return FALSE;
+        if (use_alternate)
+            desired_rate = alternate_rate;
+        else
+            desired_rate = default_rate;
+    } else {
+        desired_rate = rate; /* use stream sampling rate, discard default/alternate settings */
+    }
+
+    if (desired_rate == s->sample_spec.rate)
+        return -1;
+
+    if (!passthrough && pa_source_used_by(s) > 0)
+        return -1;
 
-        pa_source_suspend(s, TRUE, PA_SUSPEND_IDLE); /* needed before rate update, will be resumed automatically */
+    pa_log_debug("Suspending source %s due to changing the sample rate.", s->name);
+    pa_source_suspend(s, true, PA_SUSPEND_INTERNAL);
 
-        if (s->update_rate(s, desired_rate) == TRUE) {
-            pa_log_info("Changed sampling rate successfully ");
+    if (s->update_rate)
+        ret = s->update_rate(s, desired_rate);
+    else {
+        /* This is a monitor source. */
 
-            PA_IDXSET_FOREACH(o, s->outputs, idx) {
-                if (o->state == PA_SOURCE_OUTPUT_CORKED)
-                    pa_source_output_update_rate(o);
+        /* XXX: This code is written with non-passthrough streams in mind. I
+         * have no idea whether the behaviour with passthrough streams is
+         * sensible. */
+        if (!passthrough) {
+            uint32_t old_rate = s->sample_spec.rate;
+
+            s->sample_spec.rate = desired_rate;
+            ret = pa_sink_update_rate(s->monitor_of, desired_rate, false);
+
+            if (ret < 0) {
+                /* Changing the sink rate failed, roll back the old rate for
+                 * the monitor source. Why did we set the source rate before
+                 * calling pa_sink_update_rate(), you may ask. The reason is
+                 * that pa_sink_update_rate() tries to update the monitor
+                 * source rate, but we are already in the process of updating
+                 * the monitor source rate, so there's a risk of entering an
+                 * infinite loop. Setting the source rate before calling
+                 * pa_sink_update_rate() makes the rate == s->sample_spec.rate
+                 * check in the beginning of this function return early, so we
+                 * avoid looping. */
+                s->sample_spec.rate = old_rate;
             }
-            return TRUE;
+        } else
+            ret = -1;
+    }
+
+    if (ret >= 0) {
+        uint32_t idx;
+        pa_source_output *o;
+
+        PA_IDXSET_FOREACH(o, s->outputs, idx) {
+            if (o->state == PA_SOURCE_OUTPUT_CORKED)
+                pa_source_output_update_rate(o);
         }
+
+        pa_log_info("Changed sampling rate successfully");
     }
-    return FALSE;
+
+    pa_source_suspend(s, false, PA_SUSPEND_INTERNAL);
+
+    return ret;
 }
 
 /* Called from main thread */
@@ -996,6 +1098,13 @@ pa_usec_t pa_source_get_latency(pa_source *s) {
 
     pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_LATENCY, &usec, 0, NULL) == 0);
 
+    /* usec is unsigned, so check that the offset can be added to usec without
+     * underflowing. */
+    if (-s->latency_offset <= (int64_t) usec)
+        usec += s->latency_offset;
+    else
+        usec = 0;
+
     return usec;
 }
 
@@ -1023,6 +1132,13 @@ pa_usec_t pa_source_get_latency_within_thread(pa_source *s) {
     if (o->process_msg(o, PA_SOURCE_MESSAGE_GET_LATENCY, &usec, 0, NULL) < 0)
         return -1;
 
+    /* usec is unsigned, so check that the offset can be added to usec without
+     * underflowing. */
+    if (-s->thread_info.latency_offset <= (int64_t) usec)
+        usec += s->thread_info.latency_offset;
+    else
+        usec = 0;
+
     return usec;
 }
 
@@ -1032,7 +1148,7 @@ pa_usec_t pa_source_get_latency_within_thread(pa_source *s) {
  * When a source uses volume sharing, it never has the PA_SOURCE_FLAT_VOLUME flag
  * set. Instead, flat volume mode is detected by checking whether the root source
  * has the flag set. */
-pa_bool_t pa_source_flat_volume_enabled(pa_source *s) {
+bool pa_source_flat_volume_enabled(pa_source *s) {
     pa_source_assert_ref(s);
 
     s = pa_source_get_master(s);
@@ -1040,7 +1156,7 @@ pa_bool_t pa_source_flat_volume_enabled(pa_source *s) {
     if (PA_LIKELY(s))
         return (s->flags & PA_SOURCE_FLAT_VOLUME);
     else
-        return FALSE;
+        return false;
 }
 
 /* Called from the main thread (and also from the IO thread while the main
@@ -1059,7 +1175,7 @@ pa_source *pa_source_get_master(pa_source *s) {
 }
 
 /* Called from main context */
-pa_bool_t pa_source_is_passthrough(pa_source *s) {
+bool pa_source_is_passthrough(pa_source *s) {
 
     pa_source_assert_ref(s);
 
@@ -1072,20 +1188,20 @@ void pa_source_enter_passthrough(pa_source *s) {
     pa_cvolume volume;
 
     /* set the volume to NORM */
-    s->saved_volume = *pa_source_get_volume(s, TRUE);
+    s->saved_volume = *pa_source_get_volume(s, true);
     s->saved_save_volume = s->save_volume;
 
     pa_cvolume_set(&volume, s->sample_spec.channels, PA_MIN(s->base_volume, PA_VOLUME_NORM));
-    pa_source_set_volume(s, &volume, TRUE, FALSE);
+    pa_source_set_volume(s, &volume, true, false);
 }
 
 /* Called from main context */
 void pa_source_leave_passthrough(pa_source *s) {
     /* Restore source volume to what it was before we entered passthrough mode */
-    pa_source_set_volume(s, &s->saved_volume, TRUE, s->saved_save_volume);
+    pa_source_set_volume(s, &s->saved_volume, true, s->saved_save_volume);
 
     pa_cvolume_init(&s->saved_volume);
-    s->saved_save_volume = FALSE;
+    s->saved_save_volume = false;
 }
 
 /* Called from main context. */
@@ -1283,7 +1399,7 @@ static void get_maximum_output_volume(pa_source *s, pa_cvolume *max_volume, cons
 
 /* Called from main thread. Only called for the root source in volume sharing
  * cases, except for internal recursive calls. */
-static pa_bool_t has_outputs(pa_source *s) {
+static bool has_outputs(pa_source *s) {
     pa_source_output *o;
     uint32_t idx;
 
@@ -1291,10 +1407,10 @@ static pa_bool_t has_outputs(pa_source *s) {
 
     PA_IDXSET_FOREACH(o, s->outputs, idx) {
         if (!o->destination_source || !(o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER) || has_outputs(o->destination_source))
-            return TRUE;
+            return true;
     }
 
-    return FALSE;
+    return false;
 }
 
 /* Called from main thread. Only called for the root source in volume sharing
@@ -1313,20 +1429,13 @@ static void update_real_volume(pa_source *s, const pa_cvolume *new_volume, pa_ch
     PA_IDXSET_FOREACH(o, s->outputs, idx) {
         if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
             if (pa_source_flat_volume_enabled(s)) {
-                pa_cvolume old_volume = o->volume;
+                pa_cvolume new_output_volume;
 
                 /* Follow the root source's real volume. */
-                o->volume = *new_volume;
-                pa_cvolume_remap(&o->volume, channel_map, &o->channel_map);
+                new_output_volume = *new_volume;
+                pa_cvolume_remap(&new_output_volume, channel_map, &o->channel_map);
+                pa_source_output_set_volume_direct(o, &new_output_volume);
                 compute_reference_ratio(o);
-
-                /* The volume changed, let's tell people so */
-                if (!pa_cvolume_equal(&old_volume, &o->volume)) {
-                    if (o->volume_changed)
-                        o->volume_changed(o);
-
-                    pa_subscription_post(o->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, o->index);
-                }
             }
 
             update_real_volume(o->destination_source, new_volume, channel_map);
@@ -1381,7 +1490,7 @@ static void propagate_reference_volume(pa_source *s) {
      * source output volumes accordingly */
 
     PA_IDXSET_FOREACH(o, s->outputs, idx) {
-        pa_cvolume old_volume;
+        pa_cvolume new_volume;
 
         if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER)) {
             propagate_reference_volume(o->destination_source);
@@ -1392,33 +1501,23 @@ static void propagate_reference_volume(pa_source *s) {
             continue;
         }
 
-        old_volume = o->volume;
-
         /* This basically calculates:
          *
          * o->volume := o->reference_volume * o->reference_ratio  */
 
-        o->volume = s->reference_volume;
-        pa_cvolume_remap(&o->volume, &s->channel_map, &o->channel_map);
-        pa_sw_cvolume_multiply(&o->volume, &o->volume, &o->reference_ratio);
-
-        /* The volume changed, let's tell people so */
-        if (!pa_cvolume_equal(&old_volume, &o->volume)) {
-
-            if (o->volume_changed)
-                o->volume_changed(o);
-
-            pa_subscription_post(o->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, o->index);
-        }
+        new_volume = s->reference_volume;
+        pa_cvolume_remap(&new_volume, &s->channel_map, &o->channel_map);
+        pa_sw_cvolume_multiply(&new_volume, &new_volume, &o->reference_ratio);
+        pa_source_output_set_volume_direct(o, &new_volume);
     }
 }
 
 /* Called from main thread. Only called for the root source in volume sharing
  * cases, except for internal recursive calls. The return value indicates
  * whether any reference volume actually changed. */
-static pa_bool_t update_reference_volume(pa_source *s, const pa_cvolume *v, const pa_channel_map *channel_map, pa_bool_t save) {
+static bool update_reference_volume(pa_source *s, const pa_cvolume *v, const pa_channel_map *channel_map, bool save) {
     pa_cvolume volume;
-    pa_bool_t reference_volume_changed;
+    bool reference_volume_changed;
     pa_source_output *o;
     uint32_t idx;
 
@@ -1432,13 +1531,11 @@ static pa_bool_t update_reference_volume(pa_source *s, const pa_cvolume *v, cons
     pa_cvolume_remap(&volume, channel_map, &s->channel_map);
 
     reference_volume_changed = !pa_cvolume_equal(&volume, &s->reference_volume);
-    s->reference_volume = volume;
+    pa_source_set_reference_volume_direct(s, &volume);
 
     s->save_volume = (!reference_volume_changed && s->save_volume) || save;
 
-    if (reference_volume_changed)
-        pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
-    else if (!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
+    if (!reference_volume_changed && !(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
         /* If the root source's volume doesn't change, then there can't be any
          * changes in the other source in the source tree either.
          *
@@ -1449,24 +1546,24 @@ static pa_bool_t update_reference_volume(pa_source *s, const pa_cvolume *v, cons
          * intermediate source that didn't change its volume. This theoretical
          * possibility is the reason why we have that !(s->flags &
          * PA_SOURCE_SHARE_VOLUME_WITH_MASTER) condition. Probably nobody would
-         * notice even if we returned here FALSE always if
-         * reference_volume_changed is FALSE. */
-        return FALSE;
+         * notice even if we returned here false always if
+         * reference_volume_changed is false. */
+        return false;
 
     PA_IDXSET_FOREACH(o, s->outputs, idx) {
         if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
-            update_reference_volume(o->destination_source, v, channel_map, FALSE);
+            update_reference_volume(o->destination_source, v, channel_map, false);
     }
 
-    return TRUE;
+    return true;
 }
 
 /* Called from main thread */
 void pa_source_set_volume(
         pa_source *s,
         const pa_cvolume *volume,
-        pa_bool_t send_msg,
-        pa_bool_t save) {
+        bool send_msg,
+        bool save) {
 
     pa_cvolume new_reference_volume;
     pa_source *root_source;
@@ -1481,7 +1578,7 @@ void pa_source_set_volume(
     /* make sure we don't change the volume in PASSTHROUGH mode ...
      * ... *except* if we're being invoked to reset the volume to ensure 0 dB gain */
     if (pa_source_is_passthrough(s) && (!volume || !pa_cvolume_is_norm(volume))) {
-        pa_log_warn("Cannot change volume, Source is monitor of a PASSTHROUGH sink");
+        pa_log_warn("Cannot change volume, source is monitor of a PASSTHROUGH sink");
         return;
     }
 
@@ -1527,7 +1624,7 @@ void pa_source_set_volume(
 
         /* Let's 'push' the reference volume if necessary */
         pa_cvolume_merge(&new_reference_volume, &s->reference_volume, &root_source->real_volume);
-        /* If the source and it's root don't have the same number of channels, we need to remap */
+        /* If the source and its root don't have the same number of channels, we need to remap */
         if (s != root_source && !pa_channel_map_equal(&s->channel_map, &root_source->channel_map))
             pa_cvolume_remap(&new_reference_volume, &s->channel_map, &root_source->channel_map);
         update_reference_volume(root_source, &new_reference_volume, &root_source->channel_map, save);
@@ -1600,13 +1697,12 @@ static void propagate_real_volume(pa_source *s, const pa_cvolume *old_real_volum
             return;
 
         /* 1. Make the real volume the reference volume */
-        update_reference_volume(s, &s->real_volume, &s->channel_map, TRUE);
+        update_reference_volume(s, &s->real_volume, &s->channel_map, true);
     }
 
     if (pa_source_flat_volume_enabled(s)) {
-
         PA_IDXSET_FOREACH(o, s->outputs, idx) {
-            pa_cvolume old_volume = o->volume;
+            pa_cvolume new_volume;
 
             /* 2. Since the source's reference and real volumes are equal
              * now our ratios should be too. */
@@ -1620,18 +1716,10 @@ static void propagate_real_volume(pa_source *s, const pa_cvolume *old_real_volum
              * o->volume = s->reference_volume * o->reference_ratio
              *
              * This is identical to propagate_reference_volume() */
-            o->volume = s->reference_volume;
-            pa_cvolume_remap(&o->volume, &s->channel_map, &o->channel_map);
-            pa_sw_cvolume_multiply(&o->volume, &o->volume, &o->reference_ratio);
-
-            /* Notify if something changed */
-            if (!pa_cvolume_equal(&old_volume, &o->volume)) {
-
-                if (o->volume_changed)
-                    o->volume_changed(o);
-
-                pa_subscription_post(o->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, o->index);
-            }
+            new_volume = s->reference_volume;
+            pa_cvolume_remap(&new_volume, &s->channel_map, &o->channel_map);
+            pa_sw_cvolume_multiply(&new_volume, &new_volume, &o->reference_ratio);
+            pa_source_output_set_volume_direct(o, &new_volume);
 
             if (o->destination_source && (o->destination_source->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
                 propagate_real_volume(o->destination_source, old_real_volume);
@@ -1642,7 +1730,7 @@ static void propagate_real_volume(pa_source *s, const pa_cvolume *old_real_volum
      * to save changed hw settings given that hw volume changes not
      * triggered by PA are almost certainly done by the user. */
     if (!(s->flags & PA_SOURCE_SHARE_VOLUME_WITH_MASTER))
-        s->save_volume = TRUE;
+        s->save_volume = true;
 }
 
 /* Called from io thread */
@@ -1654,7 +1742,7 @@ void pa_source_update_volume_and_mute(pa_source *s) {
 }
 
 /* Called from main thread */
-const pa_cvolume *pa_source_get_volume(pa_source *s, pa_bool_t force_refresh) {
+const pa_cvolume *pa_source_get_volume(pa_source *s, bool force_refresh) {
     pa_source_assert_ref(s);
     pa_assert_ctl_context();
     pa_assert(PA_SOURCE_IS_LINKED(s->state));
@@ -1696,8 +1784,8 @@ void pa_source_volume_changed(pa_source *s, const pa_cvolume *new_real_volume) {
 }
 
 /* Called from main thread */
-void pa_source_set_mute(pa_source *s, pa_bool_t mute, pa_bool_t save) {
-    pa_bool_t old_muted;
+void pa_source_set_mute(pa_source *s, bool mute, bool save) {
+    bool old_muted;
 
     pa_source_assert_ref(s);
     pa_assert_ctl_context();
@@ -1717,14 +1805,14 @@ void pa_source_set_mute(pa_source *s, pa_bool_t mute, pa_bool_t save) {
 }
 
 /* Called from main thread */
-pa_bool_t pa_source_get_mute(pa_source *s, pa_bool_t force_refresh) {
+bool pa_source_get_mute(pa_source *s, bool force_refresh) {
 
     pa_source_assert_ref(s);
     pa_assert_ctl_context();
     pa_assert(PA_SOURCE_IS_LINKED(s->state));
 
     if (s->refresh_muted || force_refresh) {
-        pa_bool_t old_muted = s->muted;
+        bool old_muted = s->muted;
 
         if (!(s->flags & PA_SOURCE_DEFERRED_VOLUME) && s->get_mute)
             s->get_mute(s);
@@ -1732,7 +1820,7 @@ pa_bool_t pa_source_get_mute(pa_source *s, pa_bool_t force_refresh) {
         pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_GET_MUTE, NULL, 0, NULL) == 0);
 
         if (old_muted != s->muted) {
-            s->save_muted = TRUE;
+            s->save_muted = true;
 
             pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 
@@ -1745,7 +1833,7 @@ pa_bool_t pa_source_get_mute(pa_source *s, pa_bool_t force_refresh) {
 }
 
 /* Called from main thread */
-void pa_source_mute_changed(pa_source *s, pa_bool_t new_muted) {
+void pa_source_mute_changed(pa_source *s, bool new_muted) {
     pa_source_assert_ref(s);
     pa_assert_ctl_context();
     pa_assert(PA_SOURCE_IS_LINKED(s->state));
@@ -1756,13 +1844,13 @@ void pa_source_mute_changed(pa_source *s, pa_bool_t new_muted) {
         return;
 
     s->muted = new_muted;
-    s->save_muted = TRUE;
+    s->save_muted = true;
 
     pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
 }
 
 /* Called from main thread */
-pa_bool_t pa_source_update_proplist(pa_source *s, pa_update_mode_t mode, pa_proplist *p) {
+bool pa_source_update_proplist(pa_source *s, pa_update_mode_t mode, pa_proplist *p) {
     pa_source_assert_ref(s);
     pa_assert_ctl_context();
 
@@ -1774,7 +1862,7 @@ pa_bool_t pa_source_update_proplist(pa_source *s, pa_update_mode_t mode, pa_prop
         pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
     }
 
-    return TRUE;
+    return true;
 }
 
 /* Called from main thread */
@@ -1878,7 +1966,7 @@ static void sync_output_volumes_within_thread(pa_source *s) {
             continue;
 
         o->thread_info.soft_volume = o->soft_volume;
-        //pa_source_output_request_rewind(o, 0, TRUE, FALSE, FALSE);
+        //pa_source_output_request_rewind(o, 0, true, false, false);
     }
 }
 
@@ -1916,7 +2004,7 @@ int pa_source_process_msg(pa_msgobject *object, int code, void *userdata, int64_
             }
 
             pa_assert(!o->thread_info.attached);
-            o->thread_info.attached = TRUE;
+            o->thread_info.attached = true;
 
             if (o->attach)
                 o->attach(o);
@@ -1947,17 +2035,15 @@ int pa_source_process_msg(pa_msgobject *object, int code, void *userdata, int64_
                 o->detach(o);
 
             pa_assert(o->thread_info.attached);
-            o->thread_info.attached = FALSE;
+            o->thread_info.attached = false;
 
             if (o->thread_info.direct_on_input) {
                 pa_hashmap_remove(o->thread_info.direct_on_input->thread_info.direct_outputs, PA_UINT32_TO_PTR(o->index));
                 o->thread_info.direct_on_input = NULL;
             }
 
-            if (pa_hashmap_remove(s->thread_info.outputs, PA_UINT32_TO_PTR(o->index)))
-                pa_source_output_unref(o);
-
-            pa_source_invalidate_requested_latency(s, TRUE);
+            pa_hashmap_remove_and_free(s->thread_info.outputs, PA_UINT32_TO_PTR(o->index));
+            pa_source_invalidate_requested_latency(s, true);
 
             /* In flat volume mode we need to update the volume as
              * well */
@@ -2028,7 +2114,7 @@ int pa_source_process_msg(pa_msgobject *object, int code, void *userdata, int64_
 
         case PA_SOURCE_MESSAGE_SET_STATE: {
 
-            pa_bool_t suspend_change =
+            bool suspend_change =
                 (s->thread_info.state == PA_SOURCE_SUSPENDED && PA_SOURCE_IS_OPENED(PA_PTR_TO_UINT(userdata))) ||
                 (PA_SOURCE_IS_OPENED(s->thread_info.state) && PA_PTR_TO_UINT(userdata) == PA_SOURCE_SUSPENDED);
 
@@ -2046,18 +2132,6 @@ int pa_source_process_msg(pa_msgobject *object, int code, void *userdata, int64_
             return 0;
         }
 
-        case PA_SOURCE_MESSAGE_DETACH:
-
-            /* Detach all streams */
-            pa_source_detach_within_thread(s);
-            return 0;
-
-        case PA_SOURCE_MESSAGE_ATTACH:
-
-            /* Reattach all streams */
-            pa_source_attach_within_thread(s);
-            return 0;
-
         case PA_SOURCE_MESSAGE_GET_REQUESTED_LATENCY: {
 
             pa_usec_t *usec = userdata;
@@ -2136,8 +2210,12 @@ int pa_source_process_msg(pa_msgobject *object, int code, void *userdata, int64_
             if (!PA_SOURCE_IS_LINKED(s->state))
                 return 0;
 
-            pa_source_get_volume(s, TRUE);
-            pa_source_get_mute(s, TRUE);
+            pa_source_get_volume(s, true);
+            pa_source_get_mute(s, true);
+            return 0;
+
+        case PA_SOURCE_MESSAGE_SET_LATENCY_OFFSET:
+            s->thread_info.latency_offset = offset;
             return 0;
 
         case PA_SOURCE_MESSAGE_MAX:
@@ -2148,7 +2226,7 @@ int pa_source_process_msg(pa_msgobject *object, int code, void *userdata, int64_
 }
 
 /* Called from main thread */
-int pa_source_suspend_all(pa_core *c, pa_bool_t suspend, pa_suspend_cause_t cause) {
+int pa_source_suspend_all(pa_core *c, bool suspend, pa_suspend_cause_t cause) {
     pa_source *source;
     uint32_t idx;
     int ret = 0;
@@ -2170,24 +2248,6 @@ int pa_source_suspend_all(pa_core *c, pa_bool_t suspend, pa_suspend_cause_t caus
     return ret;
 }
 
-/* Called from main thread */
-void pa_source_detach(pa_source *s) {
-    pa_source_assert_ref(s);
-    pa_assert_ctl_context();
-    pa_assert(PA_SOURCE_IS_LINKED(s->state));
-
-    pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_DETACH, NULL, 0, NULL) == 0);
-}
-
-/* Called from main thread */
-void pa_source_attach(pa_source *s) {
-    pa_source_assert_ref(s);
-    pa_assert_ctl_context();
-    pa_assert(PA_SOURCE_IS_LINKED(s->state));
-
-    pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_ATTACH, NULL, 0, NULL) == 0);
-}
-
 /* Called from IO thread */
 void pa_source_detach_within_thread(pa_source *s) {
     pa_source_output *o;
@@ -2242,7 +2302,7 @@ pa_usec_t pa_source_get_requested_latency_within_thread(pa_source *s) {
     if (PA_SOURCE_IS_LINKED(s->thread_info.state)) {
         /* Only cache this if we are fully set up */
         s->thread_info.requested_latency = result;
-        s->thread_info.requested_latency_valid = TRUE;
+        s->thread_info.requested_latency_valid = true;
     }
 
     return result;
@@ -2294,7 +2354,7 @@ void pa_source_set_max_rewind(pa_source *s, size_t max_rewind) {
 }
 
 /* Called from IO thread */
-void pa_source_invalidate_requested_latency(pa_source *s, pa_bool_t dynamic) {
+void pa_source_invalidate_requested_latency(pa_source *s, bool dynamic) {
     pa_source_output *o;
     void *state = NULL;
 
@@ -2302,7 +2362,7 @@ void pa_source_invalidate_requested_latency(pa_source *s, pa_bool_t dynamic) {
     pa_source_assert_io_context(s);
 
     if ((s->flags & PA_SOURCE_DYNAMIC_LATENCY))
-        s->thread_info.requested_latency_valid = FALSE;
+        s->thread_info.requested_latency_valid = false;
     else if (dynamic)
         return;
 
@@ -2406,7 +2466,7 @@ void pa_source_set_latency_range_within_thread(pa_source *s, pa_usec_t min_laten
                 o->update_source_latency_range(o);
     }
 
-    pa_source_invalidate_requested_latency(s, FALSE);
+    pa_source_invalidate_requested_latency(s, false);
 }
 
 /* Called from main thread, before the source is put */
@@ -2456,6 +2516,8 @@ void pa_source_set_fixed_latency_within_thread(pa_source *s, pa_usec_t latency)
 
     if (s->flags & PA_SOURCE_DYNAMIC_LATENCY) {
         pa_assert(latency == 0);
+        s->thread_info.fixed_latency = 0;
+
         return;
     }
 
@@ -2476,7 +2538,19 @@ void pa_source_set_fixed_latency_within_thread(pa_source *s, pa_usec_t latency)
                 o->update_source_fixed_latency(o);
     }
 
-    pa_source_invalidate_requested_latency(s, FALSE);
+    pa_source_invalidate_requested_latency(s, false);
+}
+
+/* Called from main thread */
+void pa_source_set_latency_offset(pa_source *s, int64_t offset) {
+    pa_source_assert_ref(s);
+
+    s->latency_offset = offset;
+
+    if (PA_SOURCE_IS_LINKED(s->state))
+        pa_assert_se(pa_asyncmsgq_send(s->asyncmsgq, PA_MSGOBJECT(s), PA_SOURCE_MESSAGE_SET_LATENCY_OFFSET, NULL, offset, NULL) == 0);
+    else
+        s->thread_info.latency_offset = offset;
 }
 
 /* Called from main thread */
@@ -2494,7 +2568,7 @@ size_t pa_source_get_max_rewind(pa_source *s) {
 }
 
 /* Called from main context */
-int pa_source_set_port(pa_source *s, const char *name, pa_bool_t save) {
+int pa_source_set_port(pa_source *s, const char *name, bool save) {
     pa_device_port *port;
     int ret;
 
@@ -2506,7 +2580,7 @@ int pa_source_set_port(pa_source *s, const char *name, pa_bool_t save) {
         return -PA_ERR_NOTIMPLEMENTED;
     }
 
-    if (!s->ports)
+    if (!name)
         return -PA_ERR_NOENTITY;
 
     if (!(port = pa_hashmap_get(s->ports, name)))
@@ -2644,9 +2718,9 @@ static void pa_source_volume_change_flush(pa_source *s) {
 }
 
 /* Called from the IO thread. */
-pa_bool_t pa_source_volume_change_apply(pa_source *s, pa_usec_t *usec_to_next) {
+bool pa_source_volume_change_apply(pa_source *s, pa_usec_t *usec_to_next) {
     pa_usec_t now;
-    pa_bool_t ret = FALSE;
+    bool ret = false;
 
     pa_assert(s);
 
@@ -2665,7 +2739,7 @@ pa_bool_t pa_source_volume_change_apply(pa_source *s, pa_usec_t *usec_to_next) {
         PA_LLIST_REMOVE(pa_source_volume_change, s->thread_info.volume_changes, c);
         pa_log_debug("Volume change to %d at %llu was written %llu usec late",
                      pa_cvolume_avg(&c->hw_volume), (long long unsigned) c->at, (long long unsigned) (now - c->at));
-        ret = TRUE;
+        ret = true;
         s->thread_info.current_hw_volume = c->hw_volume;
         pa_source_volume_change_free(c);
     }
@@ -2687,7 +2761,6 @@ pa_bool_t pa_source_volume_change_apply(pa_source *s, pa_usec_t *usec_to_next) {
     return ret;
 }
 
-
 /* Called from the main thread */
 /* Gets the list of formats supported by the source. The members and idxset must
  * be freed by the caller. */
@@ -2713,10 +2786,9 @@ pa_idxset* pa_source_get_formats(pa_source *s) {
 
 /* Called from the main thread */
 /* Checks if the source can accept this format */
-pa_bool_t pa_source_check_format(pa_source *s, pa_format_info *f)
-{
+bool pa_source_check_format(pa_source *s, pa_format_info *f) {
     pa_idxset *formats = NULL;
-    pa_bool_t ret = FALSE;
+    bool ret = false;
 
     pa_assert(s);
     pa_assert(f);
@@ -2729,12 +2801,12 @@ pa_bool_t pa_source_check_format(pa_source *s, pa_format_info *f)
 
         PA_IDXSET_FOREACH(finfo_device, formats, i) {
             if (pa_format_info_is_compatible(finfo_device, f)) {
-                ret = TRUE;
+                ret = true;
                 break;
             }
         }
 
-        pa_idxset_free(formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
+        pa_idxset_free(formats, (pa_free_cb_t) pa_format_info_free);
     }
 
     return ret;
@@ -2764,7 +2836,31 @@ pa_idxset* pa_source_check_formats(pa_source *s, pa_idxset *in_formats) {
 
 done:
     if (source_formats)
-        pa_idxset_free(source_formats, (pa_free2_cb_t) pa_format_info_free2, NULL);
+        pa_idxset_free(source_formats, (pa_free_cb_t) pa_format_info_free);
 
     return out_formats;
 }
+
+/* Called from the main thread. */
+void pa_source_set_reference_volume_direct(pa_source *s, const pa_cvolume *volume) {
+    pa_cvolume old_volume;
+    char old_volume_str[PA_CVOLUME_SNPRINT_VERBOSE_MAX];
+    char new_volume_str[PA_CVOLUME_SNPRINT_VERBOSE_MAX];
+
+    pa_assert(s);
+    pa_assert(volume);
+
+    old_volume = s->reference_volume;
+
+    if (pa_cvolume_equal(volume, &old_volume))
+        return;
+
+    s->reference_volume = *volume;
+    pa_log_debug("The reference volume of source %s changed from %s to %s.", s->name,
+                 pa_cvolume_snprint_verbose(old_volume_str, sizeof(old_volume_str), &old_volume, &s->channel_map,
+                                            s->flags & PA_SOURCE_DECIBEL_VOLUME),
+                 pa_cvolume_snprint_verbose(new_volume_str, sizeof(new_volume_str), volume, &s->channel_map,
+                                            s->flags & PA_SOURCE_DECIBEL_VOLUME));
+
+    pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index);
+}