mirrors/pulseaudio
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git synced 2025-11-02 09:01:46 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

replace sink/source SET_STATE handlers with callbacks

Browse source 
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.
This commit is contained in:
Tanu Kaskinen 2018-03-13 19:40:38 +02:00
parent 73b8a57078
commit b2537a8f38
25 changed files with 874 additions and 658 deletions
Download patch file Download diff file Expand all files Collapse all files

89
src/modules/alsa/alsa-sink.c
View file

@ -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