mirrors/pulseaudio
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git synced 2025-10-29 05:40:23 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

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

Browse source
This commit is contained in:
Lennart Poettering 2009-01-23 22:38:30 +01:00
parent cf24b57279
commit 29cb778dcc
6 changed files with 258 additions and 125 deletions
Download patch file Download diff file Expand all files Collapse all files

68
src/modules/module-suspend-on-idle.c
View file

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

8
src/pulsecore/core.h
View file

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

136
src/pulsecore/sink-input.c
View file

@ -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,7 +378,9 @@ 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);
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);
@ -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);
}
if (i->sink) {
pa_sink_update_status(i->sink);
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);
pa_assert(i->sink);
if (!pa_sink_input_may_move(i))
return -1;
if (pa_hook_fire(&i->core->hooks[PA_CORE_HOOK_SINK_INPUT_MOVE_START], i) < 0)
return -1;
origin = i->sink;
if (dest == origin)
return 0;
if (!pa_sink_input_may_move_to(i, dest))
return -1;
/* 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;
}

16
src/pulsecore/sink-input.h
View file

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

129
src/pulsecore/source-output.c
View file

@ -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,7 +295,10 @@ 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);
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);
@ -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);
}
if (o->source) {
pa_source_update_status(o->source);
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;
}

14
src/pulsecore/source-output.h
View file

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