From 29cb778dcc3ceff2bb16520a16388cc21cd32884 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Fri, 23 Jan 2009 22:38:30 +0100 Subject: move sink input/source output move functions into two parts so that we can start the move, delete the original sink, create a new sink, finish the move; similar for source outputs --- src/modules/module-suspend-on-idle.c | 68 ++++++++++++----- src/pulsecore/core.h | 8 +- src/pulsecore/sink-input.c | 140 ++++++++++++++++++++++++----------- src/pulsecore/sink-input.h | 16 ++-- src/pulsecore/source-output.c | 135 ++++++++++++++++++++++----------- src/pulsecore/source-output.h | 14 ++-- 6 files changed, 257 insertions(+), 124 deletions(-) diff --git a/src/modules/module-suspend-on-idle.c b/src/modules/module-suspend-on-idle.c index 8ab84e08..5e5e53e7 100644 --- a/src/modules/module-suspend-on-idle.c +++ b/src/modules/module-suspend-on-idle.c @@ -62,8 +62,10 @@ struct userdata { *source_output_new_slot, *sink_input_unlink_slot, *source_output_unlink_slot, - *sink_input_move_slot, - *source_output_move_slot, + *sink_input_move_start_slot, + *source_output_move_start_slot, + *sink_input_move_finish_slot, + *source_output_move_finish_slot, *sink_input_state_changed_slot, *source_output_state_changed_slot; }; @@ -181,40 +183,60 @@ static pa_hook_result_t source_output_unlink_hook_cb(pa_core *c, pa_source_outpu return PA_HOOK_OK; } -static pa_hook_result_t sink_input_move_hook_cb(pa_core *c, pa_sink_input_move_hook_data *data, struct userdata *u) { +static pa_hook_result_t sink_input_move_start_hook_cb(pa_core *c, pa_sink_input *s, struct userdata *u) { struct device_info *d; pa_assert(c); - pa_assert(data); + pa_sink_input_assert_ref(s); pa_assert(u); - if ((d = pa_hashmap_get(u->device_infos, data->destination))) - resume(d); - - if (pa_sink_check_suspend(data->sink_input->sink) <= 1) - if ((d = pa_hashmap_get(u->device_infos, data->sink_input->sink))) + if (pa_sink_check_suspend(s->sink) <= 1) + if ((d = pa_hashmap_get(u->device_infos, s->sink))) restart(d); return PA_HOOK_OK; } -static pa_hook_result_t source_output_move_hook_cb(pa_core *c, pa_source_output_move_hook_data *data, struct userdata *u) { +static pa_hook_result_t sink_input_move_finish_hook_cb(pa_core *c, pa_sink_input *s, struct userdata *u) { struct device_info *d; pa_assert(c); - pa_assert(data); + pa_sink_input_assert_ref(s); pa_assert(u); - if ((d = pa_hashmap_get(u->device_infos, data->destination))) + if ((d = pa_hashmap_get(u->device_infos, s->sink))) resume(d); - if (pa_source_check_suspend(data->source_output->source) <= 1) - if ((d = pa_hashmap_get(u->device_infos, data->source_output->source))) + return PA_HOOK_OK; +} + +static pa_hook_result_t source_output_move_start_hook_cb(pa_core *c, pa_source_output *s, struct userdata *u) { + struct device_info *d; + + pa_assert(c); + pa_source_output_assert_ref(s); + pa_assert(u); + + if (pa_source_check_suspend(s->source) <= 1) + if ((d = pa_hashmap_get(u->device_infos, s->source))) restart(d); return PA_HOOK_OK; } +static pa_hook_result_t source_output_move_finish_hook_cb(pa_core *c, pa_source_output *s, struct userdata *u) { + struct device_info *d; + + pa_assert(c); + pa_source_output_assert_ref(s); + pa_assert(u); + + if ((d = pa_hashmap_get(u->device_infos, s->source))) + resume(d); + + return PA_HOOK_OK; +} + static pa_hook_result_t sink_input_state_changed_hook_cb(pa_core *c, pa_sink_input *s, struct userdata *u) { struct device_info *d; pa_sink_input_state_t state; @@ -376,8 +398,10 @@ int pa__init(pa_module*m) { u->source_output_new_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_FIXATE], PA_HOOK_NORMAL, (pa_hook_cb_t) source_output_fixate_hook_cb, u); u->sink_input_unlink_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_INPUT_UNLINK_POST], PA_HOOK_NORMAL, (pa_hook_cb_t) sink_input_unlink_hook_cb, u); u->source_output_unlink_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_UNLINK_POST], PA_HOOK_NORMAL, (pa_hook_cb_t) source_output_unlink_hook_cb, u); - u->sink_input_move_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE], PA_HOOK_NORMAL, (pa_hook_cb_t) sink_input_move_hook_cb, u); - u->source_output_move_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_MOVE], PA_HOOK_NORMAL, (pa_hook_cb_t) source_output_move_hook_cb, u); + u->sink_input_move_start_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_START], PA_HOOK_NORMAL, (pa_hook_cb_t) sink_input_move_start_hook_cb, u); + u->source_output_move_start_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_MOVE_START], PA_HOOK_NORMAL, (pa_hook_cb_t) source_output_move_start_hook_cb, u); + u->sink_input_move_finish_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FINISH], PA_HOOK_NORMAL, (pa_hook_cb_t) sink_input_move_finish_hook_cb, u); + u->source_output_move_finish_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_MOVE_FINISH], PA_HOOK_NORMAL, (pa_hook_cb_t) source_output_move_finish_hook_cb, u); u->sink_input_state_changed_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED], PA_HOOK_NORMAL, (pa_hook_cb_t) sink_input_state_changed_hook_cb, u); u->source_output_state_changed_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_STATE_CHANGED], PA_HOOK_NORMAL, (pa_hook_cb_t) source_output_state_changed_hook_cb, u); @@ -421,8 +445,10 @@ void pa__done(pa_module*m) { pa_hook_slot_free(u->sink_input_new_slot); if (u->sink_input_unlink_slot) pa_hook_slot_free(u->sink_input_unlink_slot); - if (u->sink_input_move_slot) - pa_hook_slot_free(u->sink_input_move_slot); + if (u->sink_input_move_start_slot) + pa_hook_slot_free(u->sink_input_move_start_slot); + if (u->sink_input_move_finish_slot) + pa_hook_slot_free(u->sink_input_move_finish_slot); if (u->sink_input_state_changed_slot) pa_hook_slot_free(u->sink_input_state_changed_slot); @@ -430,8 +456,10 @@ void pa__done(pa_module*m) { pa_hook_slot_free(u->source_output_new_slot); if (u->source_output_unlink_slot) pa_hook_slot_free(u->source_output_unlink_slot); - if (u->source_output_move_slot) - pa_hook_slot_free(u->source_output_move_slot); + if (u->source_output_move_start_slot) + pa_hook_slot_free(u->source_output_move_start_slot); + if (u->source_output_move_finish_slot) + pa_hook_slot_free(u->source_output_move_finish_slot); if (u->source_output_state_changed_slot) pa_hook_slot_free(u->source_output_state_changed_slot); diff --git a/src/pulsecore/core.h b/src/pulsecore/core.h index a91d7526..ffac6d37 100644 --- a/src/pulsecore/core.h +++ b/src/pulsecore/core.h @@ -68,8 +68,8 @@ typedef enum pa_core_hook { PA_CORE_HOOK_SINK_INPUT_PUT, PA_CORE_HOOK_SINK_INPUT_UNLINK, PA_CORE_HOOK_SINK_INPUT_UNLINK_POST, - PA_CORE_HOOK_SINK_INPUT_MOVE, - PA_CORE_HOOK_SINK_INPUT_MOVE_POST, + PA_CORE_HOOK_SINK_INPUT_MOVE_START, + PA_CORE_HOOK_SINK_INPUT_MOVE_FINISH, PA_CORE_HOOK_SINK_INPUT_STATE_CHANGED, PA_CORE_HOOK_SINK_INPUT_PROPLIST_CHANGED, PA_CORE_HOOK_SINK_INPUT_SET_VOLUME, @@ -78,8 +78,8 @@ typedef enum pa_core_hook { PA_CORE_HOOK_SOURCE_OUTPUT_PUT, PA_CORE_HOOK_SOURCE_OUTPUT_UNLINK, PA_CORE_HOOK_SOURCE_OUTPUT_UNLINK_POST, - PA_CORE_HOOK_SOURCE_OUTPUT_MOVE, - PA_CORE_HOOK_SOURCE_OUTPUT_MOVE_POST, + PA_CORE_HOOK_SOURCE_OUTPUT_MOVE_START, + PA_CORE_HOOK_SOURCE_OUTPUT_MOVE_FINISH, PA_CORE_HOOK_SOURCE_OUTPUT_STATE_CHANGED, PA_CORE_HOOK_SOURCE_OUTPUT_PROPLIST_CHANGED, PA_CORE_HOOK_CLIENT_NEW, diff --git a/src/pulsecore/sink-input.c b/src/pulsecore/sink-input.c index 0323bb81..e25e0c22 100644 --- a/src/pulsecore/sink-input.c +++ b/src/pulsecore/sink-input.c @@ -306,6 +306,9 @@ pa_sink_input* pa_sink_input_new( static void update_n_corked(pa_sink_input *i, pa_sink_input_state_t state) { pa_assert(i); + if (!i->sink) + return; + if (i->state == PA_SINK_INPUT_CORKED && state != PA_SINK_INPUT_CORKED) pa_assert_se(i->sink->n_corked -- >= 1); else if (i->state != PA_SINK_INPUT_CORKED && state == PA_SINK_INPUT_CORKED) @@ -375,9 +378,11 @@ void pa_sink_input_unlink(pa_sink_input *i) { i->sync_prev = i->sync_next = NULL; - pa_idxset_remove_by_data(i->sink->core->sink_inputs, i, NULL); - if (pa_idxset_remove_by_data(i->sink->inputs, i, NULL)) - pa_sink_input_unref(i); + pa_idxset_remove_by_data(i->core->sink_inputs, i, NULL); + + if (i->sink) + if (pa_idxset_remove_by_data(i->sink->inputs, i, NULL)) + pa_sink_input_unref(i); if (i->client) pa_idxset_remove_by_data(i->client->sink_inputs, i, NULL); @@ -391,7 +396,7 @@ void pa_sink_input_unlink(pa_sink_input *i) { update_n_corked(i, PA_SINK_INPUT_UNLINKED); i->state = PA_SINK_INPUT_UNLINKED; - if (linked) + if (linked && i->sink) if (i->sink->asyncmsgq) pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_REMOVE_INPUT, i, 0, NULL) == 0); @@ -402,9 +407,11 @@ void pa_sink_input_unlink(pa_sink_input *i) { pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_UNLINK_POST], i); } - pa_sink_update_status(i->sink); + if (i->sink) { + pa_sink_update_status(i->sink); + i->sink = NULL; + } - i->sink = NULL; pa_sink_input_unref(i); } @@ -943,13 +950,9 @@ pa_resample_method_t pa_sink_input_get_resample_method(pa_sink_input *i) { } /* Called from main context */ -pa_bool_t pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest) { +pa_bool_t pa_sink_input_may_move(pa_sink_input *i) { pa_sink_input_assert_ref(i); pa_assert(PA_SINK_INPUT_IS_LINKED(i->state)); - pa_sink_assert_ref(dest); - - if (dest == i->sink) - return TRUE; if (i->flags & PA_SINK_INPUT_DONT_MOVE) return FALSE; @@ -959,6 +962,21 @@ pa_bool_t pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest) { return FALSE; } + return TRUE; +} + +/* Called from main context */ +pa_bool_t pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest) { + pa_sink_input_assert_ref(i); + pa_assert(PA_SINK_INPUT_IS_LINKED(i->state)); + pa_sink_assert_ref(dest); + + if (dest == i->sink) + return TRUE; + + if (!pa_sink_input_may_move(i)) + return FALSE; + if (pa_idxset_size(dest->inputs) >= PA_MAX_INPUTS_PER_SINK) { pa_log_warn("Failed to move sink input: too many inputs per sink."); return FALSE; @@ -972,34 +990,64 @@ pa_bool_t pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest) { } /* Called from main context */ -int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest) { - pa_resampler *new_resampler; - pa_sink *origin; - pa_sink_input_move_hook_data hook_data; +int pa_sink_input_start_move(pa_sink_input *i) { pa_source_output *o, *p = NULL; + pa_sink *origin; pa_sink_input_assert_ref(i); pa_assert(PA_SINK_INPUT_IS_LINKED(i->state)); - pa_sink_assert_ref(dest); - - origin = i->sink; + pa_assert(i->sink); - if (dest == origin) - return 0; + if (!pa_sink_input_may_move(i)) + return -1; - if (!pa_sink_input_may_move_to(i, dest)) + if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_START], i) < 0) return -1; + origin = i->sink; + /* Kill directly connected outputs */ while ((o = pa_idxset_first(i->direct_outputs, NULL))) { pa_assert(o != p); pa_source_output_kill(o); p = o; } + pa_assert(pa_idxset_isempty(i->direct_outputs)); + + pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_START_MOVE, i, 0, NULL) == 0); + + if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED) + pa_assert_se(i->sink->n_corked-- >= 1); + + pa_idxset_remove_by_data(i->sink->inputs, i, NULL); + i->sink = NULL; + + pa_sink_update_status(origin); + + return 0; +} + +/* Called from main context */ +int pa_sink_input_finish_move(pa_sink_input *i, pa_sink *dest) { + pa_resampler *new_resampler; + + pa_sink_input_assert_ref(i); + pa_assert(PA_SINK_INPUT_IS_LINKED(i->state)); + pa_assert(!i->sink); + pa_sink_assert_ref(dest); + + if (!pa_sink_input_may_move_to(i, dest)) + return -1; + + i->sink = dest; + pa_idxset_put(dest->inputs, i, NULL); + + if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED) + i->sink->n_corked++; if (i->thread_info.resampler && - pa_sample_spec_equal(&origin->sample_spec, &dest->sample_spec) && - pa_channel_map_equal(&origin->channel_map, &dest->channel_map)) + pa_sample_spec_equal(pa_resampler_output_sample_spec(i->thread_info.resampler), &dest->sample_spec) && + pa_channel_map_equal(pa_resampler_output_channel_map(i->thread_info.resampler), &dest->channel_map)) /* Try to reuse the old resampler if possible */ new_resampler = i->thread_info.resampler; @@ -1024,21 +1072,6 @@ int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest) { } else new_resampler = NULL; - hook_data.sink_input = i; - hook_data.destination = dest; - pa_hook_fire(&i->sink->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE], &hook_data); - - pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_START_MOVE, i, 0, NULL) == 0); - - pa_idxset_remove_by_data(origin->inputs, i, NULL); - pa_idxset_put(dest->inputs, i, NULL); - i->sink = dest; - - if (pa_sink_input_get_state(i) == PA_SINK_INPUT_CORKED) { - pa_assert_se(origin->n_corked-- >= 1); - dest->n_corked++; - } - /* Replace resampler and render queue */ if (new_resampler != i->thread_info.resampler) { @@ -1059,20 +1092,39 @@ int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest) { &i->sink->silence); } - pa_sink_update_status(origin); pa_sink_update_status(dest); - pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_FINISH_MOVE, i, 0, NULL) == 0); + pa_log_debug("Successfully moved sink input %i to %s.", i->index, dest->name); + + /* Notify everyone */ if (i->moved) i->moved(i); - pa_hook_fire(&i->sink->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_POST], i); + pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_FINISH], i); + pa_subscription_post(i->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index); - pa_log_debug("Successfully moved sink input %i from %s to %s.", i->index, origin->name, dest->name); + return 0; +} - /* Notify everyone */ - pa_subscription_post(i->sink->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index); +/* Called from main context */ +int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest) { + pa_sink_input_assert_ref(i); + pa_assert(PA_SINK_INPUT_IS_LINKED(i->state)); + pa_assert(!i->sink); + pa_sink_assert_ref(dest); + + if (dest == i->sink) + return 0; + + if (!pa_sink_input_may_move_to(i, dest)) + return -1; + + if (pa_sink_input_start_move(i) < 0) + return -1; + + if (pa_sink_input_finish_move(i, dest) < 0) + return -1; return 0; } diff --git a/src/pulsecore/sink-input.h b/src/pulsecore/sink-input.h index 3d2a8c0d..a533046b 100644 --- a/src/pulsecore/sink-input.h +++ b/src/pulsecore/sink-input.h @@ -78,7 +78,7 @@ struct pa_sink_input { pa_module *module; /* may be NULL */ pa_client *client; /* may be NULL */ - pa_sink *sink; + pa_sink *sink; /* NULL while we are being moved */ /* A sink input may be connected to multiple source outputs * directly, so that they don't get mixed data of the entire @@ -246,11 +246,6 @@ void pa_sink_input_new_data_set_volume(pa_sink_input_new_data *data, const pa_cv void pa_sink_input_new_data_set_muted(pa_sink_input_new_data *data, pa_bool_t mute); void pa_sink_input_new_data_done(pa_sink_input_new_data *data); -typedef struct pa_sink_input_move_hook_data { - pa_sink_input *sink_input; - pa_sink *destination; -} pa_sink_input_move_hook_data; - typedef struct pa_sink_set_input_volume_data { pa_sink_input *sink_input; pa_cvolume virtual_volume; @@ -300,7 +295,14 @@ pa_bool_t pa_sink_input_update_proplist(pa_sink_input *i, pa_update_mode_t mode, pa_resample_method_t pa_sink_input_get_resample_method(pa_sink_input *i); int pa_sink_input_move_to(pa_sink_input *i, pa_sink *dest); -pa_bool_t pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest); +pa_bool_t pa_sink_input_may_move(pa_sink_input *i); /* may this sink input move at all? */ +pa_bool_t pa_sink_input_may_move_to(pa_sink_input *i, pa_sink *dest); /* may this sink input move to this sink? */ + +/* The same as pa_sink_input_move_to() but in two seperate steps, + * first the detaching from the old sink, then the attaching to the + * new sink */ +int pa_sink_input_start_move(pa_sink_input *i); +int pa_sink_input_finish_move(pa_sink_input *i, pa_sink *dest); pa_sink_input_state_t pa_sink_input_get_state(pa_sink_input *i); diff --git a/src/pulsecore/source-output.c b/src/pulsecore/source-output.c index c832dadb..d4f0367e 100644 --- a/src/pulsecore/source-output.c +++ b/src/pulsecore/source-output.c @@ -249,11 +249,13 @@ pa_source_output* pa_source_output_new( static void update_n_corked(pa_source_output *o, pa_source_output_state_t state) { pa_assert(o); + if (!o->source) + return; + if (o->state == PA_SOURCE_OUTPUT_CORKED && state != PA_SOURCE_OUTPUT_CORKED) pa_assert_se(o->source->n_corked -- >= 1); else if (o->state != PA_SOURCE_OUTPUT_CORKED && state == PA_SOURCE_OUTPUT_CORKED) o->source->n_corked++; - } /* Called from main context */ @@ -293,9 +295,12 @@ void pa_source_output_unlink(pa_source_output*o) { if (o->direct_on_input) pa_idxset_remove_by_data(o->direct_on_input->direct_outputs, o, NULL); - pa_idxset_remove_by_data(o->source->core->source_outputs, o, NULL); - if (pa_idxset_remove_by_data(o->source->outputs, o, NULL)) - pa_source_output_unref(o); + + pa_idxset_remove_by_data(o->core->source_outputs, o, NULL); + + if (o->source) + if (pa_idxset_remove_by_data(o->source->outputs, o, NULL)) + pa_source_output_unref(o); if (o->client) pa_idxset_remove_by_data(o->client->source_outputs, o, NULL); @@ -303,7 +308,7 @@ void pa_source_output_unlink(pa_source_output*o) { update_n_corked(o, PA_SOURCE_OUTPUT_UNLINKED); o->state = PA_SOURCE_OUTPUT_UNLINKED; - if (linked) + if (linked && o->source) if (o->source->asyncmsgq) pa_assert_se(pa_asyncmsgq_send(o->source->asyncmsgq, PA_MSGOBJECT(o->source), PA_SOURCE_MESSAGE_REMOVE_OUTPUT, o, 0, NULL) == 0); @@ -314,9 +319,11 @@ void pa_source_output_unlink(pa_source_output*o) { pa_hook_fire(&o->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_UNLINK_POST], o); } - pa_source_update_status(o->source); + if (o->source) { + pa_source_update_status(o->source); + o->source = NULL; + } - o->source = NULL; pa_source_output_unref(o); } @@ -624,6 +631,21 @@ pa_resample_method_t pa_source_output_get_resample_method(pa_source_output *o) { return o->resample_method; } +/* Called from main context */ +pa_bool_t pa_source_output_may_move(pa_source_output *o) { + pa_source_output_assert_ref(o); + pa_assert(PA_SOURCE_OUTPUT_IS_LINKED(o->state)); + + if (o->flags & PA_SOURCE_OUTPUT_DONT_MOVE) + return FALSE; + + if (o->direct_on_input) + return FALSE; + + return TRUE; +} + +/* Called from main context */ pa_bool_t pa_source_output_may_move_to(pa_source_output *o, pa_source *dest) { pa_source_output_assert_ref(o); pa_assert(PA_SOURCE_OUTPUT_IS_LINKED(o->state)); @@ -632,10 +654,7 @@ pa_bool_t pa_source_output_may_move_to(pa_source_output *o, pa_source *dest) { if (dest == o->source) return TRUE; - if (o->flags & PA_SOURCE_OUTPUT_DONT_MOVE) - return FALSE; - - if (o->direct_on_input) + if (!pa_source_output_may_move(o)) return FALSE; if (pa_idxset_size(dest->outputs) >= PA_MAX_OUTPUTS_PER_SOURCE) { @@ -651,26 +670,52 @@ pa_bool_t pa_source_output_may_move_to(pa_source_output *o, pa_source *dest) { } /* Called from main context */ -int pa_source_output_move_to(pa_source_output *o, pa_source *dest) { +int pa_source_output_start_move(pa_source_output *o) { pa_source *origin; - pa_resampler *new_resampler; - pa_source_output_move_hook_data hook_data; pa_source_output_assert_ref(o); pa_assert(PA_SOURCE_OUTPUT_IS_LINKED(o->state)); - pa_source_assert_ref(dest); + pa_assert(o->source); + + if (!pa_source_output_may_move(o)) + return -1; + + if (pa_hook_fire(&o->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_MOVE_START], o) < 0) + return -1; origin = o->source; - if (dest == origin) - return 0; + pa_assert_se(pa_asyncmsgq_send(o->source->asyncmsgq, PA_MSGOBJECT(o->source), PA_SOURCE_MESSAGE_REMOVE_OUTPUT, o, 0, NULL) == 0); - if (!pa_source_output_may_move_to(o, dest)) - return -1; + if (pa_source_output_get_state(o) == PA_SOURCE_OUTPUT_CORKED) + pa_assert_se(origin->n_corked-- >= 1); + + pa_idxset_remove_by_data(o->source->outputs, o, NULL); + o->source = NULL; + + pa_source_update_status(origin); + + return 0; +} + +/* Called from main context */ +int pa_source_output_finish_move(pa_source_output *o, pa_source *dest) { + pa_resampler *new_resampler; + + pa_source_output_assert_ref(o); + pa_assert(PA_SOURCE_OUTPUT_IS_LINKED(o->state)); + pa_assert(!o->source); + pa_source_assert_ref(dest); + + o->source = dest; + pa_idxset_put(o->source->outputs, o, NULL); + + if (pa_source_output_get_state(o) == PA_SOURCE_OUTPUT_CORKED) + o->source->n_corked++; if (o->thread_info.resampler && - pa_sample_spec_equal(&origin->sample_spec, &dest->sample_spec) && - pa_channel_map_equal(&origin->channel_map, &dest->channel_map)) + pa_sample_spec_equal(pa_resampler_input_sample_spec(o->thread_info.resampler), &dest->sample_spec) && + pa_channel_map_equal(pa_resampler_input_channel_map(o->thread_info.resampler), &dest->channel_map)) /* Try to reuse the old resampler if possible */ new_resampler = o->thread_info.resampler; @@ -695,22 +740,6 @@ int pa_source_output_move_to(pa_source_output *o, pa_source *dest) { } else new_resampler = NULL; - hook_data.source_output = o; - hook_data.destination = dest; - pa_hook_fire(&o->source->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_MOVE], &hook_data); - - /* Okey, let's move it */ - pa_assert_se(pa_asyncmsgq_send(o->source->asyncmsgq, PA_MSGOBJECT(o->source), PA_SOURCE_MESSAGE_REMOVE_OUTPUT, o, 0, NULL) == 0); - - pa_idxset_remove_by_data(origin->outputs, o, NULL); - pa_idxset_put(dest->outputs, o, NULL); - o->source = dest; - - if (pa_source_output_get_state(o) == PA_SOURCE_OUTPUT_CORKED) { - pa_assert_se(origin->n_corked-- >= 1); - dest->n_corked++; - } - /* Replace resampler */ if (new_resampler != o->thread_info.resampler) { if (o->thread_info.resampler) @@ -730,20 +759,40 @@ int pa_source_output_move_to(pa_source_output *o, pa_source *dest) { &o->source->silence); } - pa_source_update_status(origin); pa_source_update_status(dest); - pa_assert_se(pa_asyncmsgq_send(o->source->asyncmsgq, PA_MSGOBJECT(o->source), PA_SOURCE_MESSAGE_ADD_OUTPUT, o, 0, NULL) == 0); + pa_log_debug("Successfully moved source output %i to %s.", o->index, dest->name); + + /* Notify everyone */ if (o->moved) o->moved(o); - pa_hook_fire(&o->source->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_MOVE_POST], o); + pa_hook_fire(&o->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_MOVE_FINISH], o); + pa_subscription_post(o->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, o->index); - pa_log_debug("Successfully moved source output %i from %s to %s.", o->index, origin->name, dest->name); + return 0; +} - /* Notify everyone */ - pa_subscription_post(o->source->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, o->index); +/* Called from main context */ +int pa_source_output_move_to(pa_source_output *o, pa_source *dest) { + + pa_source_output_assert_ref(o); + pa_assert(PA_SOURCE_OUTPUT_IS_LINKED(o->state)); + pa_assert(o->source); + pa_source_assert_ref(dest); + + if (dest == o->source) + return 0; + + if (!pa_source_output_may_move_to(o, dest)) + return -1; + + if (pa_source_output_start_move(o) < 0) + return -1; + + if (pa_source_output_finish_move(o, dest) < 0) + return -1; return 0; } diff --git a/src/pulsecore/source-output.h b/src/pulsecore/source-output.h index 2fdebae0..a27602ec 100644 --- a/src/pulsecore/source-output.h +++ b/src/pulsecore/source-output.h @@ -71,7 +71,7 @@ struct pa_source_output { pa_module *module; /* may be NULL */ pa_client *client; /* may be NULL */ - pa_source *source; + pa_source *source; /* NULL while being moved */ /* A source output can monitor just a single input of a sink, in which case we find it here */ pa_sink_input *direct_on_input; /* may be NULL */ @@ -194,11 +194,6 @@ void pa_source_output_new_data_set_sample_spec(pa_source_output_new_data *data, void pa_source_output_new_data_set_channel_map(pa_source_output_new_data *data, const pa_channel_map *map); void pa_source_output_new_data_done(pa_source_output_new_data *data); -typedef struct pa_source_output_move_hook_data { - pa_source_output *source_output; - pa_source *destination; -} pa_source_output_move_hook_data; - /* To be called by the implementing module only */ pa_source_output* pa_source_output_new( @@ -228,9 +223,16 @@ pa_bool_t pa_source_output_update_proplist(pa_source_output *o, pa_update_mode_t pa_resample_method_t pa_source_output_get_resample_method(pa_source_output *o); +pa_bool_t pa_source_output_may_move(pa_source_output *o); pa_bool_t pa_source_output_may_move_to(pa_source_output *o, pa_source *dest); int pa_source_output_move_to(pa_source_output *o, pa_source *dest); +/* The same as pa_source_output_move_to() but in two seperate steps, + * first the detaching from the old source, then the attaching to the + * new source */ +int pa_source_output_start_move(pa_source_output *o); +int pa_source_output_finish_move(pa_source_output *o, pa_source *dest); + #define pa_source_output_get_state(o) ((o)->state) pa_usec_t pa_source_output_get_requested_latency(pa_source_output *o); -- cgit