[PATCH v2 3/5] replace sink/source SET_STATE handlers with callbacks

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



There are no behaviour changes, the code from almost all the SET_STATE
handlers is moved with minimal changes to the newly introduced
set_state_in_io_thread() callback. The only exception is module-tunnel,
which has to call pa_sink_render() after pa_sink.thread_info.state has
been updated. The set_state_in_io_thread() callback is called before
updating that variable, so moving the SET_STATE handler code to the
callback isn't possible.

The purpose of this change is to make it easier to get state change
handling right in modules. Hooking to the SET_STATE messages in modules
required care in calling pa_sink/source_process_msg() at the right time
(or not calling it at all, as was the case on resume failures), and
there were a few bugs (fixed before this patch). Now the core takes care
of ordering things correctly.

Another motivation for this change is that there was some talk about
adding a suspend_cause variable to pa_sink/source.thread_info. The
variable would be updated in the core SET_STATE handler, but that would
not work with the old design, because in case of resume failures modules
didn't call the core message handler.
---
 src/modules/alsa/alsa-sink.c                 |  89 ++++++++------
 src/modules/alsa/alsa-source.c               |  89 ++++++++------
 src/modules/bluetooth/module-bluez4-device.c | 172 ++++++++++++++------------
 src/modules/bluetooth/module-bluez5-device.c | 174 ++++++++++++++-------------
 src/modules/echo-cancel/module-echo-cancel.c |  31 +++--
 src/modules/module-combine-sink.c            |  33 +++--
 src/modules/module-equalizer-sink.c          |  30 +++--
 src/modules/module-esound-sink.c             |  59 +++++----
 src/modules/module-ladspa-sink.c             |  30 +++--
 src/modules/module-null-sink.c               |  25 ++--
 src/modules/module-null-source.c             |  21 ++--
 src/modules/module-pipe-sink.c               |  45 ++++---
 src/modules/module-remap-sink.c              |  30 +++--
 src/modules/module-sine-source.c             |  21 ++--
 src/modules/module-solaris.c                 | 126 ++++++++++---------
 src/modules/module-tunnel-sink-new.c         |  48 +++++---
 src/modules/module-tunnel-source-new.c       |  48 +++++---
 src/modules/module-virtual-sink.c            |  30 +++--
 src/modules/module-virtual-surround-sink.c   |  30 +++--
 src/modules/oss/module-oss.c                 | 152 ++++++++++++-----------
 src/modules/raop/raop-sink.c                 | 121 ++++++++++---------
 src/pulsecore/sink.c                         |   8 ++
 src/pulsecore/sink.h                         |  30 +++--
 src/pulsecore/source.c                       |   8 ++
 src/pulsecore/source.h                       |  32 +++--
 25 files changed, 849 insertions(+), 633 deletions(-)

diff --git a/src/modules/alsa/alsa-sink.c b/src/modules/alsa/alsa-sink.c
index dca8f6939..9e335374c 100644
--- a/src/modules/alsa/alsa-sink.c
+++ b/src/modules/alsa/alsa-sink.c
@@ -1184,46 +1184,6 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
 
             return 0;
         }
-
-        case PA_SINK_MESSAGE_SET_STATE:
-
-            switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
-
-                case PA_SINK_SUSPENDED: {
-                    pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
-
-                    suspend(u);
-
-                    break;
-                }
-
-                case PA_SINK_IDLE:
-                case PA_SINK_RUNNING: {
-                    int r;
-
-                    if (u->sink->thread_info.state == PA_SINK_INIT) {
-                        if (build_pollfd(u) < 0)
-                            /* FIXME: This will cause an assertion failure in
-                             * pa_sink_put(), because with the current design
-                             * pa_sink_put() is not allowed to fail. */
-                            return -PA_ERR_IO;
-                    }
-
-                    if (u->sink->thread_info.state == PA_SINK_SUSPENDED) {
-                        if ((r = unsuspend(u)) < 0)
-                            return r;
-                    }
-
-                    break;
-                }
-
-                case PA_SINK_UNLINKED:
-                case PA_SINK_INIT:
-                case PA_SINK_INVALID_STATE:
-                    ;
-            }
-
-            break;
     }
 
     return pa_sink_process_msg(o, code, data, offset, chunk);
@@ -1248,6 +1208,54 @@ static int sink_set_state_in_main_thread_cb(pa_sink *s, pa_sink_state_t new_stat
     return 0;
 }
 
+/* Called from the IO thread. */
+static int sink_set_state_in_io_thread_cb(pa_sink *s, pa_sink_state_t new_state) {
+    struct userdata *u;
+
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
+
+    switch (new_state) {
+
+        case PA_SINK_SUSPENDED: {
+            pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
+
+            suspend(u);
+
+            break;
+        }
+
+        case PA_SINK_IDLE:
+        case PA_SINK_RUNNING: {
+            int r;
+
+            if (u->sink->thread_info.state == PA_SINK_INIT) {
+                if (build_pollfd(u) < 0)
+                    /* FIXME: This will cause an assertion failure, because
+                     * with the current design pa_sink_put() is not allowed
+                     * to fail and pa_sink_put() has no fallback code that
+                     * would start the sink suspended if opening the device
+                     * fails. */
+                    return -PA_ERR_IO;
+            }
+
+            if (u->sink->thread_info.state == PA_SINK_SUSPENDED) {
+                if ((r = unsuspend(u)) < 0)
+                    return r;
+            }
+
+            break;
+        }
+
+        case PA_SINK_UNLINKED:
+        case PA_SINK_INIT:
+        case PA_SINK_INVALID_STATE:
+            break;
+    }
+
+    return 0;
+}
+
 static int ctl_mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
     struct userdata *u = snd_mixer_elem_get_callback_private(elem);
 
@@ -2360,6 +2368,7 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
     if (u->use_tsched)
         u->sink->update_requested_latency = sink_update_requested_latency_cb;
     u->sink->set_state_in_main_thread = sink_set_state_in_main_thread_cb;
+    u->sink->set_state_in_io_thread = sink_set_state_in_io_thread_cb;
     if (u->ucm_context)
         u->sink->set_port = sink_set_port_ucm_cb;
     else
diff --git a/src/modules/alsa/alsa-source.c b/src/modules/alsa/alsa-source.c
index b3adc7e79..312b2596a 100644
--- a/src/modules/alsa/alsa-source.c
+++ b/src/modules/alsa/alsa-source.c
@@ -1039,46 +1039,6 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off
 
             return 0;
         }
-
-        case PA_SOURCE_MESSAGE_SET_STATE:
-
-            switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
-
-                case PA_SOURCE_SUSPENDED: {
-                    pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
-
-                    suspend(u);
-
-                    break;
-                }
-
-                case PA_SOURCE_IDLE:
-                case PA_SOURCE_RUNNING: {
-                    int r;
-
-                    if (u->source->thread_info.state == PA_SOURCE_INIT) {
-                        if (build_pollfd(u) < 0)
-                            /* FIXME: This will cause an assertion failure in
-                             * pa_source_put(), because with the current design
-                             * pa_source_put() is not allowed to fail. */
-                            return -PA_ERR_IO;
-                    }
-
-                    if (u->source->thread_info.state == PA_SOURCE_SUSPENDED) {
-                        if ((r = unsuspend(u)) < 0)
-                            return r;
-                    }
-
-                    break;
-                }
-
-                case PA_SOURCE_UNLINKED:
-                case PA_SOURCE_INIT:
-                case PA_SOURCE_INVALID_STATE:
-                    ;
-            }
-
-            break;
     }
 
     return pa_source_process_msg(o, code, data, offset, chunk);
@@ -1103,6 +1063,54 @@ static int source_set_state_in_main_thread_cb(pa_source *s, pa_source_state_t ne
     return 0;
 }
 
+/* Called from the IO thread. */
+static int source_set_state_in_io_thread_cb(pa_source *s, pa_source_state_t new_state) {
+    struct userdata *u;
+
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
+
+    switch (new_state) {
+
+        case PA_SOURCE_SUSPENDED: {
+            pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
+
+            suspend(u);
+
+            break;
+        }
+
+        case PA_SOURCE_IDLE:
+        case PA_SOURCE_RUNNING: {
+            int r;
+
+            if (u->source->thread_info.state == PA_SOURCE_INIT) {
+                if (build_pollfd(u) < 0)
+                    /* FIXME: This will cause an assertion failure, because
+                     * with the current design pa_source_put() is not allowed
+                     * to fail and pa_source_put() has no fallback code that
+                     * would start the source suspended if opening the device
+                     * fails. */
+                    return -PA_ERR_IO;
+            }
+
+            if (u->source->thread_info.state == PA_SOURCE_SUSPENDED) {
+                if ((r = unsuspend(u)) < 0)
+                    return r;
+            }
+
+            break;
+        }
+
+        case PA_SOURCE_UNLINKED:
+        case PA_SOURCE_INIT:
+        case PA_SOURCE_INVALID_STATE:
+            ;
+    }
+
+    return 0;
+}
+
 static int ctl_mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
     struct userdata *u = snd_mixer_elem_get_callback_private(elem);
 
@@ -2036,6 +2044,7 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p
     if (u->use_tsched)
         u->source->update_requested_latency = source_update_requested_latency_cb;
     u->source->set_state_in_main_thread = source_set_state_in_main_thread_cb;
+    u->source->set_state_in_io_thread = source_set_state_in_io_thread_cb;
     if (u->ucm_context)
         u->source->set_port = source_set_port_ucm_cb;
     else
diff --git a/src/modules/bluetooth/module-bluez4-device.c b/src/modules/bluetooth/module-bluez4-device.c
index c6baee84c..85eb7986b 100644
--- a/src/modules/bluetooth/module-bluez4-device.c
+++ b/src/modules/bluetooth/module-bluez4-device.c
@@ -386,45 +386,6 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
 
     switch (code) {
 
-        case PA_SINK_MESSAGE_SET_STATE:
-
-            switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
-
-                case PA_SINK_SUSPENDED:
-                    /* Ignore if transition is PA_SINK_INIT->PA_SINK_SUSPENDED */
-                    if (!PA_SINK_IS_OPENED(u->sink->thread_info.state))
-                        break;
-
-                    /* Stop the device if the source is suspended as well */
-                    if (!u->source || u->source->state == PA_SOURCE_SUSPENDED)
-                        /* We deliberately ignore whether stopping
-                         * actually worked. Since the stream_fd is
-                         * closed it doesn't really matter */
-                        bt_transport_release(u);
-
-                    break;
-
-                case PA_SINK_IDLE:
-                case PA_SINK_RUNNING:
-                    if (u->sink->thread_info.state != PA_SINK_SUSPENDED)
-                        break;
-
-                    /* Resume the device if the source was suspended as well */
-                    if (!u->source || !PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
-                        if (bt_transport_acquire(u, false) < 0)
-                            return -1;
-                        else
-                            setup_stream(u);
-                    }
-                    break;
-
-                case PA_SINK_UNLINKED:
-                case PA_SINK_INIT:
-                case PA_SINK_INVALID_STATE:
-                    ;
-            }
-            break;
-
         case PA_SINK_MESSAGE_GET_LATENCY: {
 
             if (u->read_smoother) {
@@ -451,55 +412,61 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
     return pa_sink_process_msg(o, code, data, offset, chunk);
 }
 
-/* Run from IO thread */
-static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
-    struct userdata *u = PA_SOURCE(o)->userdata;
-
-    pa_assert(u->source == PA_SOURCE(o));
-    pa_assert(u->transport);
-
-    switch (code) {
+/* Called from the IO thread. */
+static int sink_set_state_in_io_thread_cb(pa_sink *s, pa_sink_state_t new_state) {
+    struct userdata *u;
 
-        case PA_SOURCE_MESSAGE_SET_STATE:
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
 
-            switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
+    switch (new_state) {
 
-                case PA_SOURCE_SUSPENDED:
-                    /* Ignore if transition is PA_SOURCE_INIT->PA_SOURCE_SUSPENDED */
-                    if (!PA_SOURCE_IS_OPENED(u->source->thread_info.state))
-                        break;
+        case PA_SINK_SUSPENDED:
+            /* Ignore if transition is PA_SINK_INIT->PA_SINK_SUSPENDED */
+            if (!PA_SINK_IS_OPENED(u->sink->thread_info.state))
+                break;
 
-                    /* Stop the device if the sink is suspended as well */
-                    if (!u->sink || u->sink->state == PA_SINK_SUSPENDED)
-                        bt_transport_release(u);
+            /* Stop the device if the source is suspended as well */
+            if (!u->source || u->source->state == PA_SOURCE_SUSPENDED)
+                /* We deliberately ignore whether stopping
+                 * actually worked. Since the stream_fd is
+                 * closed it doesn't really matter */
+                bt_transport_release(u);
 
-                    if (u->read_smoother)
-                        pa_smoother_pause(u->read_smoother, pa_rtclock_now());
-                    break;
+            break;
 
-                case PA_SOURCE_IDLE:
-                case PA_SOURCE_RUNNING:
-                    if (u->source->thread_info.state != PA_SOURCE_SUSPENDED)
-                        break;
-
-                    /* Resume the device if the sink was suspended as well */
-                    if (!u->sink || !PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
-                        if (bt_transport_acquire(u, false) < 0)
-                            return -1;
-                        else
-                            setup_stream(u);
-                    }
-                    /* We don't resume the smoother here. Instead we
-                     * wait until the first packet arrives */
-                    break;
+        case PA_SINK_IDLE:
+        case PA_SINK_RUNNING:
+            if (u->sink->thread_info.state != PA_SINK_SUSPENDED)
+                break;
 
-                case PA_SOURCE_UNLINKED:
-                case PA_SOURCE_INIT:
-                case PA_SOURCE_INVALID_STATE:
-                    ;
+            /* Resume the device if the source was suspended as well */
+            if (!u->source || !PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
+                if (bt_transport_acquire(u, false) < 0)
+                    return -1;
+                else
+                    setup_stream(u);
             }
             break;
 
+        case PA_SINK_UNLINKED:
+        case PA_SINK_INIT:
+        case PA_SINK_INVALID_STATE:
+            break;
+    }
+
+    return 0;
+}
+
+/* Run from IO thread */
+static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
+    struct userdata *u = PA_SOURCE(o)->userdata;
+
+    pa_assert(u->source == PA_SOURCE(o));
+    pa_assert(u->transport);
+
+    switch (code) {
+
         case PA_SOURCE_MESSAGE_GET_LATENCY: {
             int64_t wi, ri;
 
@@ -519,6 +486,53 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off
     return pa_source_process_msg(o, code, data, offset, chunk);
 }
 
+/* Called from the IO thread. */
+static int source_set_state_in_io_thread_cb(pa_source *s, pa_source_state_t new_state) {
+    struct userdata *u;
+
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
+
+    switch (new_state) {
+
+        case PA_SOURCE_SUSPENDED:
+            /* Ignore if transition is PA_SOURCE_INIT->PA_SOURCE_SUSPENDED */
+            if (!PA_SOURCE_IS_OPENED(u->source->thread_info.state))
+                break;
+
+            /* Stop the device if the sink is suspended as well */
+            if (!u->sink || u->sink->state == PA_SINK_SUSPENDED)
+                bt_transport_release(u);
+
+            if (u->read_smoother)
+                pa_smoother_pause(u->read_smoother, pa_rtclock_now());
+            break;
+
+        case PA_SOURCE_IDLE:
+        case PA_SOURCE_RUNNING:
+            if (u->source->thread_info.state != PA_SOURCE_SUSPENDED)
+                break;
+
+            /* Resume the device if the sink was suspended as well */
+            if (!u->sink || !PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
+                if (bt_transport_acquire(u, false) < 0)
+                    return -1;
+                else
+                    setup_stream(u);
+            }
+            /* We don't resume the smoother here. Instead we
+             * wait until the first packet arrives */
+            break;
+
+        case PA_SOURCE_UNLINKED:
+        case PA_SOURCE_INIT:
+        case PA_SOURCE_INVALID_STATE:
+            break;
+    }
+
+    return 0;
+}
+
 /* Called from main thread context */
 static int device_process_msg(pa_msgobject *obj, int code, void *data, int64_t offset, pa_memchunk *chunk) {
     struct bluetooth_msg *u = BLUETOOTH_MSG(obj);
@@ -1591,6 +1605,7 @@ static int add_sink(struct userdata *u) {
 
         u->sink->userdata = u;
         u->sink->parent.process_msg = sink_process_msg;
+        u->sink->set_state_in_io_thread = sink_set_state_in_io_thread_cb;
         u->sink->set_port = sink_set_port_cb;
     }
 
@@ -1663,6 +1678,7 @@ static int add_source(struct userdata *u) {
 
         u->source->userdata = u;
         u->source->parent.process_msg = source_process_msg;
+        u->source->set_state_in_io_thread = source_set_state_in_io_thread_cb;
         u->source->set_port = source_set_port_cb;
     }
 
diff --git a/src/modules/bluetooth/module-bluez5-device.c b/src/modules/bluetooth/module-bluez5-device.c
index b83f0eafa..5e189ba24 100644
--- a/src/modules/bluetooth/module-bluez5-device.c
+++ b/src/modules/bluetooth/module-bluez5-device.c
@@ -891,48 +891,6 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off
 
     switch (code) {
 
-        case PA_SOURCE_MESSAGE_SET_STATE:
-
-            switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
-
-                case PA_SOURCE_SUSPENDED:
-                    /* Ignore if transition is PA_SOURCE_INIT->PA_SOURCE_SUSPENDED */
-                    if (!PA_SOURCE_IS_OPENED(u->source->thread_info.state))
-                        break;
-
-                    /* Stop the device if the sink is suspended as well */
-                    if (!u->sink || u->sink->state == PA_SINK_SUSPENDED)
-                        transport_release(u);
-
-                    if (u->read_smoother)
-                        pa_smoother_pause(u->read_smoother, pa_rtclock_now());
-
-                    break;
-
-                case PA_SOURCE_IDLE:
-                case PA_SOURCE_RUNNING:
-                    if (u->source->thread_info.state != PA_SOURCE_SUSPENDED)
-                        break;
-
-                    /* Resume the device if the sink was suspended as well */
-                    if (!u->sink || !PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
-                        if (!setup_transport_and_stream(u))
-                            return -1;
-                    }
-
-                    /* We don't resume the smoother here. Instead we
-                     * wait until the first packet arrives */
-
-                    break;
-
-                case PA_SOURCE_UNLINKED:
-                case PA_SOURCE_INIT:
-                case PA_SOURCE_INVALID_STATE:
-                    break;
-            }
-
-            break;
-
         case PA_SOURCE_MESSAGE_GET_LATENCY: {
             int64_t wi, ri;
 
@@ -956,6 +914,53 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off
     return pa_source_process_msg(o, code, data, offset, chunk);
 }
 
+/* Called from the IO thread. */
+static int source_set_state_in_io_thread_cb(pa_source *s, pa_source_state_t new_state) {
+    struct userdata *u;
+
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
+
+    switch (new_state) {
+
+        case PA_SOURCE_SUSPENDED:
+            /* Ignore if transition is PA_SOURCE_INIT->PA_SOURCE_SUSPENDED */
+            if (!PA_SOURCE_IS_OPENED(u->source->thread_info.state))
+                break;
+
+            /* Stop the device if the sink is suspended as well */
+            if (!u->sink || u->sink->state == PA_SINK_SUSPENDED)
+                transport_release(u);
+
+            if (u->read_smoother)
+                pa_smoother_pause(u->read_smoother, pa_rtclock_now());
+
+            break;
+
+        case PA_SOURCE_IDLE:
+        case PA_SOURCE_RUNNING:
+            if (u->source->thread_info.state != PA_SOURCE_SUSPENDED)
+                break;
+
+            /* Resume the device if the sink was suspended as well */
+            if (!u->sink || !PA_SINK_IS_OPENED(u->sink->thread_info.state))
+                if (!setup_transport_and_stream(u))
+                    return -1;
+
+            /* We don't resume the smoother here. Instead we
+             * wait until the first packet arrives */
+
+            break;
+
+        case PA_SOURCE_UNLINKED:
+        case PA_SOURCE_INIT:
+        case PA_SOURCE_INVALID_STATE:
+            break;
+    }
+
+    return 0;
+}
+
 /* Run from main thread */
 static void source_set_volume_cb(pa_source *s) {
     uint16_t gain;
@@ -1044,6 +1049,7 @@ static int add_source(struct userdata *u) {
 
     u->source->userdata = u;
     u->source->parent.process_msg = source_process_msg;
+    u->source->set_state_in_io_thread = source_set_state_in_io_thread_cb;
 
     if (u->profile == PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT || u->profile == PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY) {
         pa_source_set_set_volume_callback(u->source, source_set_volume_cb);
@@ -1061,45 +1067,6 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
 
     switch (code) {
 
-        case PA_SINK_MESSAGE_SET_STATE:
-
-            switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
-
-                case PA_SINK_SUSPENDED:
-                    /* Ignore if transition is PA_SINK_INIT->PA_SINK_SUSPENDED */
-                    if (!PA_SINK_IS_OPENED(u->sink->thread_info.state))
-                        break;
-
-                    /* Stop the device if the source is suspended as well */
-                    if (!u->source || u->source->state == PA_SOURCE_SUSPENDED)
-                        /* We deliberately ignore whether stopping
-                         * actually worked. Since the stream_fd is
-                         * closed it doesn't really matter */
-                        transport_release(u);
-
-                    break;
-
-                case PA_SINK_IDLE:
-                case PA_SINK_RUNNING:
-                    if (u->sink->thread_info.state != PA_SINK_SUSPENDED)
-                        break;
-
-                    /* Resume the device if the source was suspended as well */
-                    if (!u->source || !PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
-                        if (!setup_transport_and_stream(u))
-                            return -1;
-                    }
-
-                    break;
-
-                case PA_SINK_UNLINKED:
-                case PA_SINK_INIT:
-                case PA_SINK_INVALID_STATE:
-                    break;
-            }
-
-            break;
-
         case PA_SINK_MESSAGE_GET_LATENCY: {
             int64_t wi, ri;
 
@@ -1124,6 +1091,50 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
     return pa_sink_process_msg(o, code, data, offset, chunk);
 }
 
+/* Called from the IO thread. */
+static int sink_set_state_in_io_thread_cb(pa_sink *s, pa_sink_state_t new_state) {
+    struct userdata *u;
+
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
+
+    switch (new_state) {
+
+        case PA_SINK_SUSPENDED:
+            /* Ignore if transition is PA_SINK_INIT->PA_SINK_SUSPENDED */
+            if (!PA_SINK_IS_OPENED(u->sink->thread_info.state))
+                break;
+
+            /* Stop the device if the source is suspended as well */
+            if (!u->source || u->source->state == PA_SOURCE_SUSPENDED)
+                /* We deliberately ignore whether stopping
+                 * actually worked. Since the stream_fd is
+                 * closed it doesn't really matter */
+                transport_release(u);
+
+            break;
+
+        case PA_SINK_IDLE:
+        case PA_SINK_RUNNING:
+            if (u->sink->thread_info.state != PA_SINK_SUSPENDED)
+                break;
+
+            /* Resume the device if the source was suspended as well */
+            if (!u->source || !PA_SOURCE_IS_OPENED(u->source->thread_info.state))
+                if (!setup_transport_and_stream(u))
+                    return -1;
+
+            break;
+
+        case PA_SINK_UNLINKED:
+        case PA_SINK_INIT:
+        case PA_SINK_INVALID_STATE:
+            break;
+    }
+
+    return 0;
+}
+
 /* Run from main thread */
 static void sink_set_volume_cb(pa_sink *s) {
     uint16_t gain;
@@ -1213,6 +1224,7 @@ static int add_sink(struct userdata *u) {
 
     u->sink->userdata = u;
     u->sink->parent.process_msg = sink_process_msg;
+    u->sink->set_state_in_io_thread = sink_set_state_in_io_thread_cb;
 
     if (u->profile == PA_BLUETOOTH_PROFILE_HEADSET_HEAD_UNIT || u->profile == PA_BLUETOOTH_PROFILE_HEADSET_AUDIO_GATEWAY) {
         pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb);
diff --git a/src/modules/echo-cancel/module-echo-cancel.c b/src/modules/echo-cancel/module-echo-cancel.c
index 7af2f4b22..893c41eeb 100644
--- a/src/modules/echo-cancel/module-echo-cancel.c
+++ b/src/modules/echo-cancel/module-echo-cancel.c
@@ -458,19 +458,6 @@ static int sink_process_msg_cb(pa_msgobject *o, int code, void *data, int64_t of
                 pa_bytes_to_usec(pa_memblockq_get_length(u->sink_input->thread_info.render_memblockq), &u->sink_input->sink->sample_spec);
 
             return 0;
-
-        case PA_SINK_MESSAGE_SET_STATE: {
-            pa_sink_state_t new_state = (pa_sink_state_t) PA_PTR_TO_UINT(data);
-
-            /* When set to running or idle for the first time, request a rewind
-             * of the master sink to make sure we are heard immediately */
-            if ((new_state == PA_SINK_IDLE || new_state == PA_SINK_RUNNING) && u->sink->thread_info.state == PA_SINK_INIT) {
-                pa_log_debug("Requesting rewind due to state change.");
-                pa_sink_input_request_rewind(u->sink_input, 0, false, true, true);
-            }
-            break;
-        }
-
     }
 
     return pa_sink_process_msg(o, code, data, offset, chunk);
@@ -526,6 +513,23 @@ static int sink_set_state_in_main_thread_cb(pa_sink *s, pa_sink_state_t state, p
     return 0;
 }
 
+/* Called from the IO thread. */
+static int sink_set_state_in_io_thread_cb(pa_sink *s, pa_sink_state_t new_state) {
+    struct userdata *u;
+
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
+
+    /* When set to running or idle for the first time, request a rewind
+     * of the master sink to make sure we are heard immediately */
+    if ((new_state == PA_SINK_IDLE || new_state == PA_SINK_RUNNING) && u->sink->thread_info.state == PA_SINK_INIT) {
+        pa_log_debug("Requesting rewind due to state change.");
+        pa_sink_input_request_rewind(u->sink_input, 0, false, true, true);
+    }
+
+    return 0;
+}
+
 /* Called from source I/O thread context */
 static void source_update_requested_latency_cb(pa_source *s) {
     struct userdata *u;
@@ -1926,6 +1930,7 @@ int pa__init(pa_module*m) {
 
     u->sink->parent.process_msg = sink_process_msg_cb;
     u->sink->set_state_in_main_thread = sink_set_state_in_main_thread_cb;
+    u->sink->set_state_in_io_thread = sink_set_state_in_io_thread_cb;
     u->sink->update_requested_latency = sink_update_requested_latency_cb;
     u->sink->request_rewind = sink_request_rewind_cb;
     pa_sink_set_set_mute_callback(u->sink, sink_set_mute_cb);
diff --git a/src/modules/module-combine-sink.c b/src/modules/module-combine-sink.c
index 22800a8bb..bbd416b6f 100644
--- a/src/modules/module-combine-sink.c
+++ b/src/modules/module-combine-sink.c
@@ -718,6 +718,25 @@ static int sink_set_state_in_main_thread_cb(pa_sink *sink, pa_sink_state_t state
     return 0;
 }
 
+/* Called from the IO thread. */
+static int sink_set_state_in_io_thread_cb(pa_sink *s, pa_sink_state_t new_state) {
+    struct userdata *u;
+    bool running;
+
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
+
+    running = new_state == PA_SINK_RUNNING;
+    pa_atomic_store(&u->thread_info.running, running);
+
+    if (running)
+        pa_smoother_resume(u->thread_info.smoother, pa_rtclock_now(), true);
+    else
+        pa_smoother_pause(u->thread_info.smoother, pa_rtclock_now());
+
+    return 0;
+}
+
 /* Called from IO context */
 static void update_max_request(struct userdata *u) {
     size_t max_request = 0;
@@ -859,19 +878,6 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
 
     switch (code) {
 
-        case PA_SINK_MESSAGE_SET_STATE: {
-            bool running = (PA_PTR_TO_UINT(data) == PA_SINK_RUNNING);
-
-            pa_atomic_store(&u->thread_info.running, running);
-
-            if (running)
-                pa_smoother_resume(u->thread_info.smoother, pa_rtclock_now(), true);
-            else
-                pa_smoother_pause(u->thread_info.smoother, pa_rtclock_now());
-
-            break;
-        }
-
         case PA_SINK_MESSAGE_GET_LATENCY: {
             pa_usec_t x, y, c;
             int64_t *delay = data;
@@ -1426,6 +1432,7 @@ int pa__init(pa_module*m) {
 
     u->sink->parent.process_msg = sink_process_msg;
     u->sink->set_state_in_main_thread = sink_set_state_in_main_thread_cb;
+    u->sink->set_state_in_io_thread = sink_set_state_in_io_thread_cb;
     u->sink->update_requested_latency = sink_update_requested_latency;
     u->sink->userdata = u;
 
diff --git a/src/modules/module-equalizer-sink.c b/src/modules/module-equalizer-sink.c
index efe95b3fb..36029b389 100644
--- a/src/modules/module-equalizer-sink.c
+++ b/src/modules/module-equalizer-sink.c
@@ -267,18 +267,6 @@ static int sink_process_msg_cb(pa_msgobject *o, int code, void *data, int64_t of
             //+ pa_bytes_to_usec(u->latency * fs, ss)
             return 0;
         }
-
-        case PA_SINK_MESSAGE_SET_STATE: {
-            pa_sink_state_t new_state = (pa_sink_state_t) PA_PTR_TO_UINT(data);
-
-            /* When set to running or idle for the first time, request a rewind
-             * of the master sink to make sure we are heard immediately */
-            if ((new_state == PA_SINK_IDLE || new_state == PA_SINK_RUNNING) && u->sink->thread_info.state == PA_SINK_INIT) {
-                pa_log_debug("Requesting rewind due to state change.");
-                pa_sink_input_request_rewind(u->sink_input, 0, false, true, true);
-            }
-            break;
-        }
     }
 
     return pa_sink_process_msg(o, code, data, offset, chunk);
@@ -299,6 +287,23 @@ static int sink_set_state_in_main_thread_cb(pa_sink *s, pa_sink_state_t state, p
     return 0;
 }
 
+/* Called from the IO thread. */
+static int sink_set_state_in_io_thread_cb(pa_sink *s, pa_sink_state_t new_state) {
+    struct userdata *u;
+
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
+
+    /* When set to running or idle for the first time, request a rewind
+     * of the master sink to make sure we are heard immediately */
+    if ((new_state == PA_SINK_IDLE || new_state == PA_SINK_RUNNING) && u->sink->thread_info.state == PA_SINK_INIT) {
+        pa_log_debug("Requesting rewind due to state change.");
+        pa_sink_input_request_rewind(u->sink_input, 0, false, true, true);
+    }
+
+    return 0;
+}
+
 /* Called from I/O thread context */
 static void sink_request_rewind_cb(pa_sink *s) {
     struct userdata *u;
@@ -1230,6 +1235,7 @@ int pa__init(pa_module*m) {
 
     u->sink->parent.process_msg = sink_process_msg_cb;
     u->sink->set_state_in_main_thread = sink_set_state_in_main_thread_cb;
+    u->sink->set_state_in_io_thread = sink_set_state_in_io_thread_cb;
     u->sink->update_requested_latency = sink_update_requested_latency_cb;
     u->sink->request_rewind = sink_request_rewind_cb;
     pa_sink_set_set_mute_callback(u->sink, sink_set_mute_cb);
diff --git a/src/modules/module-esound-sink.c b/src/modules/module-esound-sink.c
index d93ad9c5b..9fea2da74 100644
--- a/src/modules/module-esound-sink.c
+++ b/src/modules/module-esound-sink.c
@@ -141,32 +141,6 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
 
     switch (code) {
 
-        case PA_SINK_MESSAGE_SET_STATE:
-
-            switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
-
-                case PA_SINK_SUSPENDED:
-                    pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
-
-                    pa_smoother_pause(u->smoother, pa_rtclock_now());
-                    break;
-
-                case PA_SINK_IDLE:
-                case PA_SINK_RUNNING:
-
-                    if (u->sink->thread_info.state == PA_SINK_SUSPENDED)
-                        pa_smoother_resume(u->smoother, pa_rtclock_now(), true);
-
-                    break;
-
-                case PA_SINK_UNLINKED:
-                case PA_SINK_INIT:
-                case PA_SINK_INVALID_STATE:
-                    ;
-            }
-
-            break;
-
         case PA_SINK_MESSAGE_GET_LATENCY: {
             pa_usec_t w, r;
 
@@ -194,6 +168,38 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
     return pa_sink_process_msg(o, code, data, offset, chunk);
 }
 
+/* Called from the IO thread. */
+static int sink_set_state_in_io_thread_cb(pa_sink *s, pa_sink_state_t new_state) {
+    struct userdata *u;
+
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
+
+    switch (new_state) {
+
+        case PA_SINK_SUSPENDED:
+            pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
+
+            pa_smoother_pause(u->smoother, pa_rtclock_now());
+            break;
+
+        case PA_SINK_IDLE:
+        case PA_SINK_RUNNING:
+
+            if (u->sink->thread_info.state == PA_SINK_SUSPENDED)
+                pa_smoother_resume(u->smoother, pa_rtclock_now(), true);
+
+            break;
+
+        case PA_SINK_UNLINKED:
+        case PA_SINK_INIT:
+        case PA_SINK_INVALID_STATE:
+            ;
+    }
+
+    return 0;
+}
+
 static void thread_func(void *userdata) {
     struct userdata *u = userdata;
     int write_type = 0;
@@ -611,6 +617,7 @@ int pa__init(pa_module*m) {
     }
 
     u->sink->parent.process_msg = sink_process_msg;
+    u->sink->set_state_in_io_thread = sink_set_state_in_io_thread_cb;
     u->sink->userdata = u;
 
     pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
diff --git a/src/modules/module-ladspa-sink.c b/src/modules/module-ladspa-sink.c
index a2db68e1c..de866d96a 100644
--- a/src/modules/module-ladspa-sink.c
+++ b/src/modules/module-ladspa-sink.c
@@ -374,18 +374,6 @@ static int sink_process_msg_cb(pa_msgobject *o, int code, void *data, int64_t of
         connect_control_ports(u);
 
         return 0;
-
-        case PA_SINK_MESSAGE_SET_STATE: {
-            pa_sink_state_t new_state = (pa_sink_state_t) PA_PTR_TO_UINT(data);
-
-            /* When set to running or idle for the first time, request a rewind
-             * of the master sink to make sure we are heard immediately */
-            if ((new_state == PA_SINK_IDLE || new_state == PA_SINK_RUNNING) && u->sink->thread_info.state == PA_SINK_INIT) {
-                pa_log_debug("Requesting rewind due to state change.");
-                pa_sink_input_request_rewind(u->sink_input, 0, false, true, true);
-            }
-            break;
-        }
     }
 
     return pa_sink_process_msg(o, code, data, offset, chunk);
@@ -406,6 +394,23 @@ static int sink_set_state_in_main_thread_cb(pa_sink *s, pa_sink_state_t state, p
     return 0;
 }
 
+/* Called from the IO thread. */
+static int sink_set_state_in_io_thread_cb(pa_sink *s, pa_sink_state_t new_state) {
+    struct userdata *u;
+
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
+
+    /* When set to running or idle for the first time, request a rewind
+     * of the master sink to make sure we are heard immediately */
+    if ((new_state == PA_SINK_IDLE || new_state == PA_SINK_RUNNING) && u->sink->thread_info.state == PA_SINK_INIT) {
+        pa_log_debug("Requesting rewind due to state change.");
+        pa_sink_input_request_rewind(u->sink_input, 0, false, true, true);
+    }
+
+    return 0;
+}
+
 /* Called from I/O thread context */
 static void sink_request_rewind_cb(pa_sink *s) {
     struct userdata *u;
@@ -1298,6 +1303,7 @@ int pa__init(pa_module*m) {
 
     u->sink->parent.process_msg = sink_process_msg_cb;
     u->sink->set_state_in_main_thread = sink_set_state_in_main_thread_cb;
+    u->sink->set_state_in_io_thread = sink_set_state_in_io_thread_cb;
     u->sink->update_requested_latency = sink_update_requested_latency_cb;
     u->sink->request_rewind = sink_request_rewind_cb;
     pa_sink_set_set_mute_callback(u->sink, sink_set_mute_cb);
diff --git a/src/modules/module-null-sink.c b/src/modules/module-null-sink.c
index 3ace082df..16b0b6870 100644
--- a/src/modules/module-null-sink.c
+++ b/src/modules/module-null-sink.c
@@ -89,15 +89,6 @@ static int sink_process_msg(
     struct userdata *u = PA_SINK(o)->userdata;
 
     switch (code) {
-        case PA_SINK_MESSAGE_SET_STATE:
-
-            if (u->sink->thread_info.state == PA_SINK_SUSPENDED || u->sink->thread_info.state == PA_SINK_INIT) {
-                if (PA_SINK_IS_OPENED(PA_PTR_TO_UINT(data)))
-                    u->timestamp = pa_rtclock_now();
-            }
-
-            break;
-
         case PA_SINK_MESSAGE_GET_LATENCY: {
             pa_usec_t now;
 
@@ -111,6 +102,21 @@ static int sink_process_msg(
     return pa_sink_process_msg(o, code, data, offset, chunk);
 }
 
+/* Called from the IO thread. */
+static int sink_set_state_in_io_thread_cb(pa_sink *s, pa_sink_state_t new_state) {
+    struct userdata *u;
+
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
+
+    if (u->sink->thread_info.state == PA_SINK_SUSPENDED || u->sink->thread_info.state == PA_SINK_INIT) {
+        if (PA_SINK_IS_OPENED(new_state))
+            u->timestamp = pa_rtclock_now();
+    }
+
+    return 0;
+}
+
 static void sink_update_requested_latency_cb(pa_sink *s) {
     struct userdata *u;
     size_t nbytes;
@@ -297,6 +303,7 @@ int pa__init(pa_module*m) {
     }
 
     u->sink->parent.process_msg = sink_process_msg;
+    u->sink->set_state_in_io_thread = sink_set_state_in_io_thread_cb;
     u->sink->update_requested_latency = sink_update_requested_latency_cb;
     u->sink->userdata = u;
 
diff --git a/src/modules/module-null-source.c b/src/modules/module-null-source.c
index 41f17bd98..ae67206a3 100644
--- a/src/modules/module-null-source.c
+++ b/src/modules/module-null-source.c
@@ -89,13 +89,6 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off
     struct userdata *u = PA_SOURCE(o)->userdata;
 
     switch (code) {
-        case PA_SOURCE_MESSAGE_SET_STATE:
-
-            if (PA_PTR_TO_UINT(data) == PA_SOURCE_RUNNING)
-                u->timestamp = pa_rtclock_now();
-
-            break;
-
         case PA_SOURCE_MESSAGE_GET_LATENCY: {
             pa_usec_t now;
 
@@ -109,6 +102,19 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off
     return pa_source_process_msg(o, code, data, offset, chunk);
 }
 
+/* Called from the IO thread. */
+static int source_set_state_in_io_thread_cb(pa_source *s, pa_source_state_t new_state) {
+    struct userdata *u;
+
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
+
+    if (new_state == PA_SOURCE_RUNNING)
+        u->timestamp = pa_rtclock_now();
+
+    return 0;
+}
+
 static void source_update_requested_latency_cb(pa_source *s) {
     struct userdata *u;
 
@@ -229,6 +235,7 @@ int pa__init(pa_module*m) {
     u->latency_time = latency_time;
 
     u->source->parent.process_msg = source_process_msg;
+    u->source->set_state_in_io_thread = source_set_state_in_io_thread_cb;
     u->source->update_requested_latency = source_update_requested_latency_cb;
     u->source->userdata = u;
 
diff --git a/src/modules/module-pipe-sink.c b/src/modules/module-pipe-sink.c
index 995785e1e..b2378059b 100644
--- a/src/modules/module-pipe-sink.c
+++ b/src/modules/module-pipe-sink.c
@@ -110,24 +110,6 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
     struct userdata *u = PA_SINK(o)->userdata;
 
     switch (code) {
-        case PA_SINK_MESSAGE_SET_STATE:
-            if (u->sink->thread_info.state == PA_SINK_SUSPENDED || u->sink->thread_info.state == PA_SINK_INIT) {
-                if (PA_SINK_IS_OPENED(PA_PTR_TO_UINT(data)))
-                    u->timestamp = pa_rtclock_now();
-            } else if (u->sink->thread_info.state == PA_SINK_RUNNING || u->sink->thread_info.state == PA_SINK_IDLE) {
-                if (PA_PTR_TO_UINT(data) == PA_SINK_SUSPENDED) {
-                    /* Clear potential FIFO error flag */
-                    u->fifo_error = false;
-
-                    /* Continuously dropping data (clear counter on entering suspended state. */
-                    if (u->bytes_dropped != 0) {
-                        pa_log_debug("Pipe-sink continuously dropping data - clear statistics (%zu -> 0 bytes dropped)", u->bytes_dropped);
-                        u->bytes_dropped = 0;
-                    }
-                }
-            }
-            break;
-
         case PA_SINK_MESSAGE_GET_LATENCY:
             if (u->use_system_clock_for_timing) {
                 pa_usec_t now;
@@ -153,6 +135,32 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
     return pa_sink_process_msg(o, code, data, offset, chunk);
 }
 
+/* Called from the IO thread. */
+static int sink_set_state_in_io_thread_cb(pa_sink *s, pa_sink_state_t new_state) {
+    struct userdata *u;
+
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
+
+    if (u->sink->thread_info.state == PA_SINK_SUSPENDED || u->sink->thread_info.state == PA_SINK_INIT) {
+        if (PA_SINK_IS_OPENED(new_state))
+            u->timestamp = pa_rtclock_now();
+    } else if (u->sink->thread_info.state == PA_SINK_RUNNING || u->sink->thread_info.state == PA_SINK_IDLE) {
+        if (new_state == PA_SINK_SUSPENDED) {
+            /* Clear potential FIFO error flag */
+            u->fifo_error = false;
+
+            /* Continuously dropping data (clear counter on entering suspended state. */
+            if (u->bytes_dropped != 0) {
+                pa_log_debug("Pipe-sink continuously dropping data - clear statistics (%zu -> 0 bytes dropped)", u->bytes_dropped);
+                u->bytes_dropped = 0;
+            }
+        }
+    }
+
+    return 0;
+}
+
 static void sink_update_requested_latency_cb(pa_sink *s) {
     struct userdata *u;
     size_t nbytes;
@@ -505,6 +513,7 @@ int pa__init(pa_module *m) {
     }
 
     u->sink->parent.process_msg = sink_process_msg;
+    u->sink->set_state_in_io_thread = sink_set_state_in_io_thread_cb;
     if (u->use_system_clock_for_timing)
         u->sink->update_requested_latency = sink_update_requested_latency_cb;
     u->sink->userdata = u;
diff --git a/src/modules/module-remap-sink.c b/src/modules/module-remap-sink.c
index ec6698795..56e7a85fd 100644
--- a/src/modules/module-remap-sink.c
+++ b/src/modules/module-remap-sink.c
@@ -94,18 +94,6 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
                 pa_bytes_to_usec(pa_memblockq_get_length(u->sink_input->thread_info.render_memblockq), &u->sink_input->sink->sample_spec);
 
             return 0;
-
-        case PA_SINK_MESSAGE_SET_STATE: {
-            pa_sink_state_t new_state = (pa_sink_state_t) PA_PTR_TO_UINT(data);
-
-            /* When set to running or idle for the first time, request a rewind
-             * of the master sink to make sure we are heard immediately */
-            if ((new_state == PA_SINK_IDLE || new_state == PA_SINK_RUNNING) && u->sink->thread_info.state == PA_SINK_INIT) {
-                pa_log_debug("Requesting rewind due to state change.");
-                pa_sink_input_request_rewind(u->sink_input, 0, false, true, true);
-            }
-            break;
-        }
     }
 
     return pa_sink_process_msg(o, code, data, offset, chunk);
@@ -126,6 +114,23 @@ static int sink_set_state_in_main_thread(pa_sink *s, pa_sink_state_t state, pa_s
     return 0;
 }
 
+/* Called from the IO thread. */
+static int sink_set_state_in_io_thread_cb(pa_sink *s, pa_sink_state_t new_state) {
+    struct userdata *u;
+
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
+
+    /* When set to running or idle for the first time, request a rewind
+     * of the master sink to make sure we are heard immediately */
+    if ((new_state == PA_SINK_IDLE || new_state == PA_SINK_RUNNING) && u->sink->thread_info.state == PA_SINK_INIT) {
+        pa_log_debug("Requesting rewind due to state change.");
+        pa_sink_input_request_rewind(u->sink_input, 0, false, true, true);
+    }
+
+    return 0;
+}
+
 /* Called from I/O thread context */
 static void sink_request_rewind(pa_sink *s) {
     struct userdata *u;
@@ -411,6 +416,7 @@ int pa__init(pa_module*m) {
 
     u->sink->parent.process_msg = sink_process_msg;
     u->sink->set_state_in_main_thread = sink_set_state_in_main_thread;
+    u->sink->set_state_in_io_thread = sink_set_state_in_io_thread_cb;
     u->sink->update_requested_latency = sink_update_requested_latency;
     u->sink->request_rewind = sink_request_rewind;
     u->sink->userdata = u;
diff --git a/src/modules/module-sine-source.c b/src/modules/module-sine-source.c
index f4c297384..39fb71ab3 100644
--- a/src/modules/module-sine-source.c
+++ b/src/modules/module-sine-source.c
@@ -87,13 +87,6 @@ static int source_process_msg(
 
     switch (code) {
 
-        case PA_SOURCE_MESSAGE_SET_STATE:
-
-            if (PA_PTR_TO_UINT(data) == PA_SOURCE_RUNNING)
-                u->timestamp = pa_rtclock_now();
-
-            break;
-
         case PA_SOURCE_MESSAGE_GET_LATENCY: {
             pa_usec_t now, left_to_fill;
 
@@ -109,6 +102,19 @@ static int source_process_msg(
     return pa_source_process_msg(o, code, data, offset, chunk);
 }
 
+/* Called from the IO thread. */
+static int source_set_state_in_io_thread_cb(pa_source *s, pa_source_state_t new_state) {
+    struct userdata *u;
+
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
+
+    if (new_state == PA_SOURCE_RUNNING)
+        u->timestamp = pa_rtclock_now();
+
+    return 0;
+}
+
 static void source_update_requested_latency_cb(pa_source *s) {
     struct userdata *u;
 
@@ -257,6 +263,7 @@ int pa__init(pa_module*m) {
     }
 
     u->source->parent.process_msg = source_process_msg;
+    u->source->set_state_in_io_thread = source_set_state_in_io_thread_cb;
     u->source->update_requested_latency = source_update_requested_latency_cb;
     u->source->userdata = u;
 
diff --git a/src/modules/module-solaris.c b/src/modules/module-solaris.c
index a4960b8b7..e68f2a93d 100644
--- a/src/modules/module-solaris.c
+++ b/src/modules/module-solaris.c
@@ -390,51 +390,57 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
         case PA_SINK_MESSAGE_GET_LATENCY:
             *((int64_t*) data) = sink_get_latency(u, &PA_SINK(o)->sample_spec);
             return 0;
+    }
 
-        case PA_SINK_MESSAGE_SET_STATE:
+    return pa_sink_process_msg(o, code, data, offset, chunk);
+}
 
-            switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
+/* Called from the IO thread. */
+static int sink_set_state_in_io_thread_cb(pa_sink *s, pa_sink_state_t new_state) {
+    struct userdata *u;
 
-                case PA_SINK_SUSPENDED:
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
 
-                    pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
+    switch (new_state) {
 
-                    pa_smoother_pause(u->smoother, pa_rtclock_now());
+        case PA_SINK_SUSPENDED:
 
-                    if (!u->source || u->source_suspended)
-                        suspend(u);
+            pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
 
-                    u->sink_suspended = true;
-                    break;
+            pa_smoother_pause(u->smoother, pa_rtclock_now());
 
-                case PA_SINK_IDLE:
-                case PA_SINK_RUNNING:
-
-                    if (u->sink->thread_info.state == PA_SINK_SUSPENDED) {
-                        pa_smoother_resume(u->smoother, pa_rtclock_now(), true);
-
-                        if (!u->source || u->source_suspended) {
-                            bool mute;
-                            if (unsuspend(u) < 0)
-                                return -1;
-                            u->sink->get_volume(u->sink);
-                            if (u->sink->get_mute(u->sink, &mute) >= 0)
-                                pa_sink_set_mute(u->sink, mute, false);
-                        }
-                        u->sink_suspended = false;
-                    }
-                    break;
+            if (!u->source || u->source_suspended)
+                suspend(u);
 
-                case PA_SINK_INVALID_STATE:
-                case PA_SINK_UNLINKED:
-                case PA_SINK_INIT:
-                    ;
-            }
+            u->sink_suspended = true;
+            break;
+
+        case PA_SINK_IDLE:
+        case PA_SINK_RUNNING:
+
+            if (u->sink->thread_info.state == PA_SINK_SUSPENDED) {
+                pa_smoother_resume(u->smoother, pa_rtclock_now(), true);
 
+                if (!u->source || u->source_suspended) {
+                    bool mute;
+                    if (unsuspend(u) < 0)
+                        return -1;
+                    u->sink->get_volume(u->sink);
+                    if (u->sink->get_mute(u->sink, &mute) >= 0)
+                        pa_sink_set_mute(u->sink, mute, false);
+                }
+                u->sink_suspended = false;
+            }
             break;
+
+        case PA_SINK_INVALID_STATE:
+        case PA_SINK_UNLINKED:
+        case PA_SINK_INIT:
+            ;
     }
 
-    return pa_sink_process_msg(o, code, data, offset, chunk);
+    return 0;
 }
 
 static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
@@ -445,45 +451,51 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off
         case PA_SOURCE_MESSAGE_GET_LATENCY:
             *((pa_usec_t*) data) = source_get_latency(u, &PA_SOURCE(o)->sample_spec);
             return 0;
+    }
 
-        case PA_SOURCE_MESSAGE_SET_STATE:
+    return pa_source_process_msg(o, code, data, offset, chunk);
+}
 
-            switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
+/* Called from the IO thread. */
+static int source_set_state_in_io_thread_cb(pa_source *s, pa_source_state_t new_state) {
+    struct userdata *u;
 
-                case PA_SOURCE_SUSPENDED:
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
 
-                    pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
+    switch (new_state) {
 
-                    if (!u->sink || u->sink_suspended)
-                        suspend(u);
+        case PA_SOURCE_SUSPENDED:
 
-                    u->source_suspended = true;
-                    break;
+            pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
 
-                case PA_SOURCE_IDLE:
-                case PA_SOURCE_RUNNING:
+            if (!u->sink || u->sink_suspended)
+                suspend(u);
 
-                    if (u->source->thread_info.state == PA_SOURCE_SUSPENDED) {
-                        if (!u->sink || u->sink_suspended) {
-                            if (unsuspend(u) < 0)
-                                return -1;
-                            u->source->get_volume(u->source);
-                        }
-                        u->source_suspended = false;
-                    }
-                    break;
+            u->source_suspended = true;
+            break;
 
-                case PA_SOURCE_UNLINKED:
-                case PA_SOURCE_INIT:
-                case PA_SOURCE_INVALID_STATE:
-                    ;
+        case PA_SOURCE_IDLE:
+        case PA_SOURCE_RUNNING:
 
+            if (u->source->thread_info.state == PA_SOURCE_SUSPENDED) {
+                if (!u->sink || u->sink_suspended) {
+                    if (unsuspend(u) < 0)
+                        return -1;
+                    u->source->get_volume(u->source);
+                }
+                u->source_suspended = false;
             }
             break;
 
+        case PA_SOURCE_UNLINKED:
+        case PA_SOURCE_INIT:
+        case PA_SOURCE_INVALID_STATE:
+            ;
+
     }
 
-    return pa_source_process_msg(o, code, data, offset, chunk);
+    return 0;
 }
 
 static void sink_set_volume(pa_sink *s) {
@@ -960,6 +972,7 @@ int pa__init(pa_module *m) {
 
         u->source->userdata = u;
         u->source->parent.process_msg = source_process_msg;
+        u->source->set_state_in_io_thread = source_set_state_in_io_thread_cb;
 
         pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
         pa_source_set_rtpoll(u->source, u->rtpoll);
@@ -1003,6 +1016,7 @@ int pa__init(pa_module *m) {
         pa_assert(u->sink);
         u->sink->userdata = u;
         u->sink->parent.process_msg = sink_process_msg;
+        u->sink->set_state_in_io_thread = sink_set_state_in_io_thread_cb;
 
         pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
         pa_sink_set_rtpoll(u->sink, u->rtpoll);
diff --git a/src/modules/module-tunnel-sink-new.c b/src/modules/module-tunnel-sink-new.c
index 8a67b81f1..313903372 100644
--- a/src/modules/module-tunnel-sink-new.c
+++ b/src/modules/module-tunnel-sink-new.c
@@ -429,28 +429,37 @@ static int sink_process_msg_cb(pa_msgobject *o, int code, void *data, int64_t of
             *((int64_t*) data) = remote_latency;
             return 0;
         }
-        case PA_SINK_MESSAGE_SET_STATE:
-            if (!u->stream || pa_stream_get_state(u->stream) != PA_STREAM_READY)
-                break;
+    }
+    return pa_sink_process_msg(o, code, data, offset, chunk);
+}
 
-            switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
-                case PA_SINK_SUSPENDED: {
-                    cork_stream(u, true);
-                    break;
-                }
-                case PA_SINK_IDLE:
-                case PA_SINK_RUNNING: {
-                    cork_stream(u, false);
-                    break;
-                }
-                case PA_SINK_INVALID_STATE:
-                case PA_SINK_INIT:
-                case PA_SINK_UNLINKED:
-                    break;
-            }
+/* Called from the IO thread. */
+static int sink_set_state_in_io_thread_cb(pa_sink *s, pa_sink_state_t new_state) {
+    struct userdata *u;
+
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
+
+    if (!u->stream || pa_stream_get_state(u->stream) != PA_STREAM_READY)
+        return 0;
+
+    switch (new_state) {
+        case PA_SINK_SUSPENDED: {
+            cork_stream(u, true);
+            break;
+        }
+        case PA_SINK_IDLE:
+        case PA_SINK_RUNNING: {
+            cork_stream(u, false);
+            break;
+        }
+        case PA_SINK_INVALID_STATE:
+        case PA_SINK_INIT:
+        case PA_SINK_UNLINKED:
             break;
     }
-    return pa_sink_process_msg(o, code, data, offset, chunk);
+
+    return 0;
 }
 
 int pa__init(pa_module *m) {
@@ -545,6 +554,7 @@ int pa__init(pa_module *m) {
     pa_sink_new_data_done(&sink_data);
     u->sink->userdata = u;
     u->sink->parent.process_msg = sink_process_msg_cb;
+    u->sink->set_state_in_io_thread = sink_set_state_in_io_thread_cb;
     u->sink->update_requested_latency = sink_update_requested_latency_cb;
     pa_sink_set_latency_range(u->sink, 0, MAX_LATENCY_USEC);
 
diff --git a/src/modules/module-tunnel-source-new.c b/src/modules/module-tunnel-source-new.c
index 7ad077111..d0a5414ad 100644
--- a/src/modules/module-tunnel-source-new.c
+++ b/src/modules/module-tunnel-source-new.c
@@ -428,28 +428,37 @@ static int source_process_msg_cb(pa_msgobject *o, int code, void *data, int64_t
 
             return 0;
         }
-        case PA_SOURCE_MESSAGE_SET_STATE:
-            if (!u->stream || pa_stream_get_state(u->stream) != PA_STREAM_READY)
-                break;
+    }
+    return pa_source_process_msg(o, code, data, offset, chunk);
+}
 
-            switch ((pa_source_state_t) PA_PTR_TO_UINT(data)) {
-                case PA_SOURCE_SUSPENDED: {
-                    cork_stream(u, true);
-                    break;
-                }
-                case PA_SOURCE_IDLE:
-                case PA_SOURCE_RUNNING: {
-                    cork_stream(u, false);
-                    break;
-                }
-                case PA_SOURCE_INVALID_STATE:
-                case PA_SOURCE_INIT:
-                case PA_SOURCE_UNLINKED:
-                    break;
-            }
+/* Called from the IO thread. */
+static int source_set_state_in_io_thread_cb(pa_source *s, pa_source_state_t new_state) {
+    struct userdata *u;
+
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
+
+    if (!u->stream || pa_stream_get_state(u->stream) != PA_STREAM_READY)
+        return 0;
+
+    switch (new_state) {
+        case PA_SOURCE_SUSPENDED: {
+            cork_stream(u, true);
+            break;
+        }
+        case PA_SOURCE_IDLE:
+        case PA_SOURCE_RUNNING: {
+            cork_stream(u, false);
+            break;
+        }
+        case PA_SOURCE_INVALID_STATE:
+        case PA_SOURCE_INIT:
+        case PA_SOURCE_UNLINKED:
             break;
     }
-    return pa_source_process_msg(o, code, data, offset, chunk);
+
+    return 0;
 }
 
 int pa__init(pa_module *m) {
@@ -541,6 +550,7 @@ int pa__init(pa_module *m) {
     pa_source_new_data_done(&source_data);
     u->source->userdata = u;
     u->source->parent.process_msg = source_process_msg_cb;
+    u->source->set_state_in_io_thread = source_set_state_in_io_thread_cb;
     u->source->update_requested_latency = source_update_requested_latency_cb;
 
     pa_source_set_asyncmsgq(u->source, u->thread_mq->inq);
diff --git a/src/modules/module-virtual-sink.c b/src/modules/module-virtual-sink.c
index ca6ce5696..68ad20076 100644
--- a/src/modules/module-virtual-sink.c
+++ b/src/modules/module-virtual-sink.c
@@ -106,18 +106,6 @@ static int sink_process_msg_cb(pa_msgobject *o, int code, void *data, int64_t of
                 pa_bytes_to_usec(pa_memblockq_get_length(u->sink_input->thread_info.render_memblockq), &u->sink_input->sink->sample_spec);
 
             return 0;
-
-        case PA_SINK_MESSAGE_SET_STATE: {
-            pa_sink_state_t new_state = (pa_sink_state_t) PA_PTR_TO_UINT(data);
-
-            /* When set to running or idle for the first time, request a rewind
-             * of the master sink to make sure we are heard immediately */
-            if ((new_state == PA_SINK_IDLE || new_state == PA_SINK_RUNNING) && u->sink->thread_info.state == PA_SINK_INIT) {
-                pa_log_debug("Requesting rewind due to state change.");
-                pa_sink_input_request_rewind(u->sink_input, 0, false, true, true);
-            }
-            break;
-        }
     }
 
     return pa_sink_process_msg(o, code, data, offset, chunk);
@@ -138,6 +126,23 @@ static int sink_set_state_in_main_thread_cb(pa_sink *s, pa_sink_state_t state, p
     return 0;
 }
 
+/* Called from the IO thread. */
+static int sink_set_state_in_io_thread_cb(pa_sink *s, pa_sink_state_t new_state) {
+    struct userdata *u;
+
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
+
+    /* When set to running or idle for the first time, request a rewind
+     * of the master sink to make sure we are heard immediately */
+    if ((new_state == PA_SINK_IDLE || new_state == PA_SINK_RUNNING) && u->sink->thread_info.state == PA_SINK_INIT) {
+        pa_log_debug("Requesting rewind due to state change.");
+        pa_sink_input_request_rewind(u->sink_input, 0, false, true, true);
+    }
+
+    return 0;
+}
+
 /* Called from I/O thread context */
 static void sink_request_rewind_cb(pa_sink *s) {
     struct userdata *u;
@@ -556,6 +561,7 @@ int pa__init(pa_module*m) {
 
     u->sink->parent.process_msg = sink_process_msg_cb;
     u->sink->set_state_in_main_thread = sink_set_state_in_main_thread_cb;
+    u->sink->set_state_in_io_thread = sink_set_state_in_io_thread_cb;
     u->sink->update_requested_latency = sink_update_requested_latency_cb;
     u->sink->request_rewind = sink_request_rewind_cb;
     pa_sink_set_set_mute_callback(u->sink, sink_set_mute_cb);
diff --git a/src/modules/module-virtual-surround-sink.c b/src/modules/module-virtual-surround-sink.c
index 00780d8bd..7c5e246cf 100644
--- a/src/modules/module-virtual-surround-sink.c
+++ b/src/modules/module-virtual-surround-sink.c
@@ -134,18 +134,6 @@ static int sink_process_msg_cb(pa_msgobject *o, int code, void *data, int64_t of
                 pa_bytes_to_usec(pa_memblockq_get_length(u->sink_input->thread_info.render_memblockq), &u->sink_input->sink->sample_spec);
 
             return 0;
-
-        case PA_SINK_MESSAGE_SET_STATE: {
-            pa_sink_state_t new_state = (pa_sink_state_t) PA_PTR_TO_UINT(data);
-
-            /* When set to running or idle for the first time, request a rewind
-             * of the master sink to make sure we are heard immediately */
-            if ((new_state == PA_SINK_IDLE || new_state == PA_SINK_RUNNING) && u->sink->thread_info.state == PA_SINK_INIT) {
-                pa_log_debug("Requesting rewind due to state change.");
-                pa_sink_input_request_rewind(u->sink_input, 0, false, true, true);
-            }
-            break;
-        }
     }
 
     return pa_sink_process_msg(o, code, data, offset, chunk);
@@ -166,6 +154,23 @@ static int sink_set_state_in_main_thread_cb(pa_sink *s, pa_sink_state_t state, p
     return 0;
 }
 
+/* Called from the IO thread. */
+static int sink_set_state_in_io_thread_cb(pa_sink *s, pa_sink_state_t new_state) {
+    struct userdata *u;
+
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
+
+    /* When set to running or idle for the first time, request a rewind
+     * of the master sink to make sure we are heard immediately */
+    if ((new_state == PA_SINK_IDLE || new_state == PA_SINK_RUNNING) && u->sink->thread_info.state == PA_SINK_INIT) {
+        pa_log_debug("Requesting rewind due to state change.");
+        pa_sink_input_request_rewind(u->sink_input, 0, false, true, true);
+    }
+
+    return 0;
+}
+
 /* Called from I/O thread context */
 static void sink_request_rewind_cb(pa_sink *s) {
     struct userdata *u;
@@ -730,6 +735,7 @@ int pa__init(pa_module*m) {
 
     u->sink->parent.process_msg = sink_process_msg_cb;
     u->sink->set_state_in_main_thread = sink_set_state_in_main_thread_cb;
+    u->sink->set_state_in_io_thread = sink_set_state_in_io_thread_cb;
     u->sink->update_requested_latency = sink_update_requested_latency_cb;
     u->sink->request_rewind = sink_request_rewind_cb;
     pa_sink_set_set_mute_callback(u->sink, sink_set_mute_cb);
diff --git a/src/modules/oss/module-oss.c b/src/modules/oss/module-oss.c
index 7d1b9f52b..d2551bcfc 100644
--- a/src/modules/oss/module-oss.c
+++ b/src/modules/oss/module-oss.c
@@ -643,8 +643,6 @@ fail:
 /* Called from IO context */
 static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
     struct userdata *u = PA_SINK(o)->userdata;
-    bool do_trigger = false, quick = true;
-    pa_sink_state_t new_state;
 
     switch (code) {
 
@@ -662,68 +660,73 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
 
             return 0;
         }
+    }
 
-        case PA_SINK_MESSAGE_SET_STATE:
-            new_state = PA_PTR_TO_UINT(data);
+    return pa_sink_process_msg(o, code, data, offset, chunk);
+}
 
-            switch (new_state) {
+/* Called from the IO thread. */
+static int sink_set_state_in_io_thread_cb(pa_sink *s, pa_sink_state_t new_state) {
+    struct userdata *u;
+    bool do_trigger = false;
+    bool quick = true;
 
-                case PA_SINK_SUSPENDED:
-                    pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
 
-                    if (!u->source || u->source_suspended)
-                        suspend(u);
+    switch (new_state) {
 
-                    do_trigger = true;
+        case PA_SINK_SUSPENDED:
+            pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
 
-                    u->sink_suspended = true;
-                    break;
+            if (!u->source || u->source_suspended)
+                suspend(u);
 
-                case PA_SINK_IDLE:
-                case PA_SINK_RUNNING:
+            do_trigger = true;
 
-                    if (u->sink->thread_info.state == PA_SINK_INIT) {
-                        do_trigger = true;
-                        quick = u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state);
-                    }
+            u->sink_suspended = true;
+            break;
 
-                    if (u->sink->thread_info.state == PA_SINK_SUSPENDED) {
+        case PA_SINK_IDLE:
+        case PA_SINK_RUNNING:
 
-                        if (!u->source || u->source_suspended) {
-                            if (unsuspend(u) < 0)
-                                return -1;
-                            quick = false;
-                        }
+            if (u->sink->thread_info.state == PA_SINK_INIT) {
+                do_trigger = true;
+                quick = u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state);
+            }
 
-                        do_trigger = true;
+            if (u->sink->thread_info.state == PA_SINK_SUSPENDED) {
 
-                        u->out_mmap_current = 0;
-                        u->out_mmap_saved_nfrags = 0;
+                if (!u->source || u->source_suspended) {
+                    if (unsuspend(u) < 0)
+                        return -1;
+                    quick = false;
+                }
 
-                        u->sink_suspended = false;
-                    }
+                do_trigger = true;
 
-                    break;
+                u->out_mmap_current = 0;
+                u->out_mmap_saved_nfrags = 0;
 
-                case PA_SINK_INVALID_STATE:
-                case PA_SINK_UNLINKED:
-                case PA_SINK_INIT:
-                    ;
+                u->sink_suspended = false;
             }
 
             break;
+
+        case PA_SINK_INVALID_STATE:
+        case PA_SINK_UNLINKED:
+        case PA_SINK_INIT:
+            ;
     }
 
     if (do_trigger)
         trigger(u, new_state, u->source ? u->source->thread_info.state : PA_SOURCE_INVALID_STATE, quick);
 
-    return pa_sink_process_msg(o, code, data, offset, chunk);
+    return 0;
 }
 
 static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
     struct userdata *u = PA_SOURCE(o)->userdata;
-    bool do_trigger = false, quick = true;
-    pa_source_state_t new_state;
 
     switch (code) {
 
@@ -740,61 +743,68 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off
             *((int64_t*) data) = (int64_t)r;
             return 0;
         }
+    }
 
-        case PA_SOURCE_MESSAGE_SET_STATE:
-            new_state = PA_PTR_TO_UINT(data);
+    return pa_source_process_msg(o, code, data, offset, chunk);
+}
 
-            switch (new_state) {
+/* Called from the IO thread. */
+static int source_set_state_in_io_thread_cb(pa_source *s, pa_source_state_t new_state) {
+    struct userdata *u;
+    bool do_trigger = false;
+    bool quick = true;
 
-                case PA_SOURCE_SUSPENDED:
-                    pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
 
-                    if (!u->sink || u->sink_suspended)
-                        suspend(u);
+    switch (new_state) {
 
-                    do_trigger = true;
+        case PA_SOURCE_SUSPENDED:
+            pa_assert(PA_SOURCE_IS_OPENED(u->source->thread_info.state));
 
-                    u->source_suspended = true;
-                    break;
+            if (!u->sink || u->sink_suspended)
+                suspend(u);
 
-                case PA_SOURCE_IDLE:
-                case PA_SOURCE_RUNNING:
+            do_trigger = true;
 
-                    if (u->source->thread_info.state == PA_SOURCE_INIT) {
-                        do_trigger = true;
-                        quick = u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state);
-                    }
+            u->source_suspended = true;
+            break;
 
-                    if (u->source->thread_info.state == PA_SOURCE_SUSPENDED) {
+        case PA_SOURCE_IDLE:
+        case PA_SOURCE_RUNNING:
 
-                        if (!u->sink || u->sink_suspended) {
-                            if (unsuspend(u) < 0)
-                                return -1;
-                            quick = false;
-                        }
+            if (u->source->thread_info.state == PA_SOURCE_INIT) {
+                do_trigger = true;
+                quick = u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state);
+            }
 
-                        do_trigger = true;
+            if (u->source->thread_info.state == PA_SOURCE_SUSPENDED) {
 
-                        u->in_mmap_current = 0;
-                        u->in_mmap_saved_nfrags = 0;
+                if (!u->sink || u->sink_suspended) {
+                    if (unsuspend(u) < 0)
+                        return -1;
+                    quick = false;
+                }
 
-                        u->source_suspended = false;
-                    }
-                    break;
+                do_trigger = true;
 
-                case PA_SOURCE_UNLINKED:
-                case PA_SOURCE_INIT:
-                case PA_SOURCE_INVALID_STATE:
-                    ;
+                u->in_mmap_current = 0;
+                u->in_mmap_saved_nfrags = 0;
 
+                u->source_suspended = false;
             }
             break;
+
+        case PA_SOURCE_UNLINKED:
+        case PA_SOURCE_INIT:
+        case PA_SOURCE_INVALID_STATE:
+            ;
     }
 
     if (do_trigger)
         trigger(u, u->sink ? u->sink->thread_info.state : PA_SINK_INVALID_STATE, new_state, quick);
 
-    return pa_source_process_msg(o, code, data, offset, chunk);
+    return 0;
 }
 
 static void sink_get_volume(pa_sink *s) {
@@ -1334,6 +1344,7 @@ int pa__init(pa_module*m) {
         }
 
         u->source->parent.process_msg = source_process_msg;
+        u->source->set_state_in_io_thread = source_set_state_in_io_thread_cb;
         u->source->userdata = u;
 
         pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
@@ -1403,6 +1414,7 @@ int pa__init(pa_module*m) {
         }
 
         u->sink->parent.process_msg = sink_process_msg;
+        u->sink->set_state_in_io_thread = sink_set_state_in_io_thread_cb;
         u->sink->userdata = u;
 
         pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
diff --git a/src/modules/raop/raop-sink.c b/src/modules/raop/raop-sink.c
index 936129cf5..baa346641 100644
--- a/src/modules/raop/raop-sink.c
+++ b/src/modules/raop/raop-sink.c
@@ -136,64 +136,6 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
     pa_assert(u->raop);
 
     switch (code) {
-        case PA_SINK_MESSAGE_SET_STATE: {
-            switch ((pa_sink_state_t) PA_PTR_TO_UINT(data)) {
-                case PA_SINK_SUSPENDED: {
-                    pa_log_debug("RAOP: SUSPENDED");
-
-                    pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
-
-                    /* Issue a TEARDOWN if we are still connected */
-                    if (pa_raop_client_is_alive(u->raop)) {
-                        pa_raop_client_teardown(u->raop);
-                    }
-
-                    break;
-                }
-
-                case PA_SINK_IDLE: {
-                    pa_log_debug("RAOP: IDLE");
-
-                    /* Issue a FLUSH if we're comming from running state */
-                    if (u->sink->thread_info.state == PA_SINK_RUNNING) {
-                        pa_rtpoll_set_timer_disabled(u->rtpoll);
-                        pa_raop_client_flush(u->raop);
-                    }
-
-                    break;
-                }
-
-                case PA_SINK_RUNNING: {
-                    pa_usec_t now;
-
-                    pa_log_debug("RAOP: RUNNING");
-
-                    now = pa_rtclock_now();
-                    pa_smoother_reset(u->smoother, now, false);
-
-                    if (!pa_raop_client_is_alive(u->raop)) {
-                        /* Connecting will trigger a RECORD and start steaming */
-                        pa_raop_client_announce(u->raop);
-                    } else if (!pa_raop_client_can_stream(u->raop)) {
-                        /* RECORD alredy sent, simply start streaming */
-                        pa_raop_client_stream(u->raop);
-                        pa_rtpoll_set_timer_absolute(u->rtpoll, now);
-                        u->write_count = 0;
-                        u->start = now;
-                    }
-
-                    break;
-                }
-
-                case PA_SINK_UNLINKED:
-                case PA_SINK_INIT:
-                case PA_SINK_INVALID_STATE:
-                    break;
-            }
-
-            break;
-        }
-
         case PA_SINK_MESSAGE_GET_LATENCY: {
             int64_t r = 0;
 
@@ -278,6 +220,68 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
     return pa_sink_process_msg(o, code, data, offset, chunk);
 }
 
+/* Called from the IO thread. */
+static int sink_set_state_in_io_thread_cb(pa_sink *s, pa_sink_state_t new_state) {
+    struct userdata *u;
+
+    pa_assert(s);
+    pa_assert_se(u = s->userdata);
+
+    switch (new_state) {
+        case PA_SINK_SUSPENDED:
+            pa_log_debug("RAOP: SUSPENDED");
+
+            pa_assert(PA_SINK_IS_OPENED(u->sink->thread_info.state));
+
+            /* Issue a TEARDOWN if we are still connected */
+            if (pa_raop_client_is_alive(u->raop)) {
+                pa_raop_client_teardown(u->raop);
+            }
+
+            break;
+
+        case PA_SINK_IDLE:
+            pa_log_debug("RAOP: IDLE");
+
+            /* Issue a FLUSH if we're comming from running state */
+            if (u->sink->thread_info.state == PA_SINK_RUNNING) {
+                pa_rtpoll_set_timer_disabled(u->rtpoll);
+                pa_raop_client_flush(u->raop);
+            }
+
+            break;
+
+        case PA_SINK_RUNNING: {
+            pa_usec_t now;
+
+            pa_log_debug("RAOP: RUNNING");
+
+            now = pa_rtclock_now();
+            pa_smoother_reset(u->smoother, now, false);
+
+            if (!pa_raop_client_is_alive(u->raop)) {
+                /* Connecting will trigger a RECORD and start steaming */
+                pa_raop_client_announce(u->raop);
+            } else if (!pa_raop_client_can_stream(u->raop)) {
+                /* RECORD alredy sent, simply start streaming */
+                pa_raop_client_stream(u->raop);
+                pa_rtpoll_set_timer_absolute(u->rtpoll, now);
+                u->write_count = 0;
+                u->start = now;
+            }
+
+            break;
+        }
+
+        case PA_SINK_UNLINKED:
+        case PA_SINK_INIT:
+        case PA_SINK_INVALID_STATE:
+            break;
+    }
+
+    return 0;
+}
+
 static void sink_set_volume_cb(pa_sink *s) {
     struct userdata *u = s->userdata;
     pa_cvolume hw;
@@ -696,6 +700,7 @@ pa_sink* pa_raop_sink_new(pa_module *m, pa_modargs *ma, const char *driver) {
     }
 
     u->sink->parent.process_msg = sink_process_msg;
+    u->sink->set_state_in_io_thread = sink_set_state_in_io_thread_cb;
     pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb);
     pa_sink_set_set_mute_callback(u->sink, sink_set_mute_cb);
     u->sink->userdata = u;
diff --git a/src/pulsecore/sink.c b/src/pulsecore/sink.c
index 6549515b5..2c9334931 100644
--- a/src/pulsecore/sink.c
+++ b/src/pulsecore/sink.c
@@ -151,6 +151,7 @@ static void reset_callbacks(pa_sink *s) {
     pa_assert(s);
 
     s->set_state_in_main_thread = NULL;
+    s->set_state_in_io_thread = NULL;
     s->get_volume = NULL;
     s->set_volume = NULL;
     s->write_volume = NULL;
@@ -2850,6 +2851,13 @@ int pa_sink_process_msg(pa_msgobject *o, int code, void *userdata, int64_t offse
                 (s->thread_info.state == PA_SINK_SUSPENDED && PA_SINK_IS_OPENED(PA_PTR_TO_UINT(userdata))) ||
                 (PA_SINK_IS_OPENED(s->thread_info.state) && PA_PTR_TO_UINT(userdata) == PA_SINK_SUSPENDED);
 
+            if (s->set_state_in_io_thread) {
+                int r;
+
+                if ((r = s->set_state_in_io_thread(s, PA_PTR_TO_UINT(userdata))) < 0)
+                    return r;
+            }
+
             s->thread_info.state = PA_PTR_TO_UINT(userdata);
 
             if (s->thread_info.state == PA_SINK_SUSPENDED) {
diff --git a/src/pulsecore/sink.h b/src/pulsecore/sink.h
index 0caeb550b..e1ea52495 100644
--- a/src/pulsecore/sink.h
+++ b/src/pulsecore/sink.h
@@ -124,19 +124,31 @@ struct pa_sink {
 
     bool set_mute_in_progress;
 
-    /* Called when the main loop requests a state change. Called from
-     * main loop context. If returns -1 the state change will be
-     * inhibited. This will also be called even if only the suspend cause
+    /* Callbacks for doing things when the sink state and/or suspend cause is
+     * changed. It's fine to set either or both of the callbacks to NULL if the
+     * implementation doesn't have anything to do on state or suspend cause
      * changes.
      *
-     * s->state and s->suspend_cause haven't been updated yet when this is
-     * called, so the callback can get the old state through those variables.
+     * set_state_in_main_thread() is called first. The callback is allowed to
+     * report failure if and only if the sink changes its state from
+     * SUSPENDED to IDLE or RUNNING. (FIXME: It would make sense to allow
+     * failure also when changing state from INIT to IDLE or RUNNING, but
+     * currently that will crash pa_sink_put().) If
+     * set_state_in_main_thread() fails, set_state_in_io_thread() won't be
+     * called.
      *
-     * If set_state_in_main_thread() is successful, the IO thread will be
-     * notified with the SET_STATE message. The message handler is allowed to
-     * fail, in which case the old state is restored, and
-     * set_state_in_main_thread() is called again. */
+     * If set_state_in_main_thread() is successful (or not set), then
+     * set_state_in_io_thread() is called. Again, failure is allowed if and
+     * only if the sink changes state from SUSPENDED to IDLE or RUNNING. If
+     * set_state_in_io_thread() fails, then set_state_in_main_thread() is
+     * called again, this time with the state parameter set to SUSPENDED and
+     * the suspend_cause parameter set to 0.
+     *
+     * pa_sink.state, pa_sink.thread_info.state and pa_sink.suspend_cause
+     * are updated only after all the callback calls. In case of failure, the
+     * state is set to SUSPENDED and the suspend cause is set to 0. */
     int (*set_state_in_main_thread)(pa_sink *s, pa_sink_state_t state, pa_suspend_cause_t suspend_cause); /* may be NULL */
+    int (*set_state_in_io_thread)(pa_sink *s, pa_sink_state_t state); /* may be NULL */
 
     /* Sink drivers that support hardware volume may set this
      * callback. This is called when the current volume needs to be
diff --git a/src/pulsecore/source.c b/src/pulsecore/source.c
index ad8e5e364..dd56eb082 100644
--- a/src/pulsecore/source.c
+++ b/src/pulsecore/source.c
@@ -142,6 +142,7 @@ static void reset_callbacks(pa_source *s) {
     pa_assert(s);
 
     s->set_state_in_main_thread = NULL;
+    s->set_state_in_io_thread = NULL;
     s->get_volume = NULL;
     s->set_volume = NULL;
     s->write_volume = NULL;
@@ -2224,6 +2225,13 @@ int pa_source_process_msg(pa_msgobject *object, int code, void *userdata, int64_
                 (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);
 
+            if (s->set_state_in_io_thread) {
+                int r;
+
+                if ((r = s->set_state_in_io_thread(s, PA_PTR_TO_UINT(userdata))) < 0)
+                    return r;
+            }
+
             s->thread_info.state = PA_PTR_TO_UINT(userdata);
 
             if (suspend_change) {
diff --git a/src/pulsecore/source.h b/src/pulsecore/source.h
index d60e8a1a8..c4fda7965 100644
--- a/src/pulsecore/source.h
+++ b/src/pulsecore/source.h
@@ -125,19 +125,31 @@ struct pa_source {
 
     bool set_mute_in_progress;
 
-    /* Called when the main loop requests a state change. Called from
-     * main loop context. If returns -1 the state change will be
-     * inhibited. This will also be called even if only the suspend cause
+    /* Callbacks for doing things when the source state and/or suspend cause is
+     * changed. It's fine to set either or both of the callbacks to NULL if the
+     * implementation doesn't have anything to do on state or suspend cause
      * changes.
      *
-     * s->state and s->suspend_cause haven't been updated yet when this is
-     * called, so the callback can get the old state through those variables.
+     * set_state_in_main_thread() is called first. The callback is allowed to
+     * report failure if and only if the source changes its state from
+     * SUSPENDED to IDLE or RUNNING. (FIXME: It would make sense to allow
+     * failure also when changing state from INIT to IDLE or RUNNING, but
+     * currently that will crash pa_source_put().) If
+     * set_state_in_main_thread() fails, set_state_in_io_thread() won't be
+     * called.
      *
-     * If set_state_in_main_thread() is successful, the IO thread will be
-     * notified with the SET_STATE message. The message handler is allowed to
-     * fail, in which case the old state is restored, and
-     * set_state_in_main_thread() is called again. */
-    int (*set_state_in_main_thread)(pa_source *source, pa_source_state_t state, pa_suspend_cause_t suspend_cause); /* may be NULL */
+     * If set_state_in_main_thread() is successful (or not set), then
+     * set_state_in_io_thread() is called. Again, failure is allowed if and
+     * only if the source changes state from SUSPENDED to IDLE or RUNNING. If
+     * set_state_in_io_thread() fails, then set_state_in_main_thread() is
+     * called again, this time with the state parameter set to SUSPENDED and
+     * the suspend_cause parameter set to 0.
+     *
+     * pa_source.state, pa_source.thread_info.state and pa_source.suspend_cause
+     * are updated only after all the callback calls. In case of failure, the
+     * state is set to SUSPENDED and the suspend cause is set to 0. */
+    int (*set_state_in_main_thread)(pa_source *s, pa_source_state_t state, pa_suspend_cause_t suspend_cause); /* may be NULL */
+    int (*set_state_in_io_thread)(pa_source *s, pa_source_state_t state); /* may be NULL */
 
     /* Called when the volume is queried. Called from main loop
      * context. If this is NULL a PA_SOURCE_MESSAGE_GET_VOLUME message
-- 
2.16.1



[Index of Archives]     [Linux Audio Users]     [AMD Graphics]     [Linux USB Devel]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]

  Powered by Linux