/* Called from main context */
static void teardown(struct userdata *u) {
pa_assert(u);
pa_assert_ctl_context();
u->adjust_time = 0;
enable_adjust_timer(u, false);
/* Handling the asyncmsgq between the source output and the sink input
* requires some care. When the source output is unlinked, nothing needs
* to be done for the asyncmsgq, because the source output is the sending
* end. But when the sink input is unlinked, we should ensure that the
* asyncmsgq is emptied, because the messages in the queue hold references
* to the sink input. Also, we need to ensure that new messages won't be
* written to the queue after we have emptied it.
*
* Emptying the queue can be done in the state_changed() callback of the
* sink input, when the new state is "unlinked".
*
* Preventing new messages from being written to the queue can be achieved
* by unlinking the source output before unlinking the sink input. There
* are no other writers for that queue, so this is sufficient. */
if (u->source_output) {
pa_source_output_unlink(u->source_output);
pa_source_output_unref(u->source_output);
u->source_output = NULL;
}
if (u->sink_input) {
pa_sink_input_unlink(u->sink_input);
pa_sink_input_unref(u->sink_input);
u->sink_input = NULL;
}
}
void pa__done(pa_module*m) {
struct userdata *u;
pa_assert(m);
if (!(u = m->userdata))
return;
/* See comments in sink_input_kill_cb() above regarding
* destruction order! */
if (u->sink_input)
pa_sink_input_unlink(u->sink_input);
if (u->sink)
pa_sink_unlink(u->sink);
if (u->sink_input)
pa_sink_input_unref(u->sink_input);
if (u->sink)
pa_sink_unref(u->sink);
if (u->memblockq)
pa_memblockq_free(u->memblockq);
pa_xfree(u);
}
static void sink_input_kill_cb(pa_sink_input *i) {
struct userdata *u;
pa_sink_input_assert_ref(i);
pa_assert_se(u = i->userdata);
pa_sink_input_unlink(u->sink_input);
pa_sink_input_unref(u->sink_input);
u->sink_input = NULL;
pa_module_unload_request(u->module, true);
}
static void memblockq_stream_unlink(memblockq_stream *u) {
pa_assert(u);
if (!u->sink_input)
return;
pa_sink_input_unlink(u->sink_input);
pa_sink_input_unref(u->sink_input);
u->sink_input = NULL;
memblockq_stream_unref(u);
}
/* Called from main context */
static void file_stream_unlink(file_stream *u) {
pa_assert(u);
if (!u->sink_input)
return;
pa_sink_input_unlink(u->sink_input);
pa_sink_input_unref(u->sink_input);
u->sink_input = NULL;
/* Make sure we don't decrease the ref count twice. */
file_stream_unref(u);
}
void cmtspeech_delete_sink_input(struct userdata *u) {
pa_assert(u);
ENTER();
if (!u->sink_input) {
pa_log_info("Delete called but no sink input exists");
return;
}
pa_sink_input_unlink(u->sink_input);
pa_sink_input_unref(u->sink_input);
u->sink_input = NULL;
pa_log_info("cmtspeech sink-input deleted");
}
/* Called from main context */
static void aep_sink_input_kill_cb(pa_sink_input *i) {
struct userdata *u;
pa_log_debug("Kill called");
pa_sink_input_assert_ref(i);
pa_assert_se(u = i->userdata);
/* FIXME: this is sort-of understandable with the may_move hack... we avoid abort in free() here */
u->aep_sink_input->thread_info.attached = FALSE;
pa_sink_input_unlink(u->aep_sink_input);
pa_sink_input_unref(u->aep_sink_input);
u->aep_sink_input = NULL;
pa_module_unload_request(u->module, TRUE);
}
void pa__done(pa_module*m) {
struct userdata *u;
pa_assert(m);
if (!(u = m->userdata))
return;
if (u->sink_input) {
pa_sink_input_unlink(u->sink_input);
pa_sink_input_unref(u->sink_input);
}
if (u->memchunk.memblock)
pa_memblock_unref(u->memchunk.memblock);
pa_xfree(u);
}
void pa__done(pa_module*m) {
struct userdata *u;
unsigned c;
pa_assert(m);
if (!(u = m->userdata))
return;
/* See comments in sink_input_kill_cb() above regarding
* destruction order! */
if (u->sink_input)
pa_sink_input_unlink(u->sink_input);
if (u->sink)
pa_sink_unlink(u->sink);
if (u->sink_input)
pa_sink_input_unref(u->sink_input);
if (u->sink)
pa_sink_unref(u->sink);
for (c = 0; c < u->channels; c++)
if (u->handle[c]) {
if (u->descriptor->deactivate)
u->descriptor->deactivate(u->handle[c]);
u->descriptor->cleanup(u->handle[c]);
}
if (u->output != u->input)
pa_xfree(u->output);
if (u->memblockq)
pa_memblockq_free(u->memblockq);
pa_xfree(u->input);
pa_xfree(u->control);
pa_xfree(u);
}
/* Called from main context */
static void sink_input_kill_cb(pa_sink_input *i) {
struct userdata *u;
pa_sink_input_assert_ref(i);
pa_assert_se(u = i->userdata);
/* The order here matters! We first kill the sink input, followed
* by the sink. That means the sink callbacks must be protected
* against an unconnected sink input! */
pa_sink_input_unlink(u->sink_input);
pa_sink_unlink(u->sink);
pa_sink_input_unref(u->sink_input);
u->sink_input = NULL;
pa_sink_unref(u->sink);
u->sink = NULL;
pa_module_unload_request(u->module, TRUE);
}
/* Called from main context */
static void teardown(struct userdata *u) {
pa_assert(u);
pa_assert_ctl_context();
if (u->sink_input)
pa_sink_input_unlink(u->sink_input);
if (u->source_output)
pa_source_output_unlink(u->source_output);
if (u->sink_input) {
pa_sink_input_unref(u->sink_input);
u->sink_input = NULL;
}
if (u->source_output) {
pa_source_output_unref(u->source_output);
u->source_output = NULL;
}
}
/* Called from main context */
static void sink_input_kill_cb(pa_sink_input *i) {
struct userdata *u;
pa_sink_input_assert_ref(i);
pa_assert_se(u = i->userdata);
/* The order here matters! We first kill the sink so that streams
* can properly be moved away while the sink input is still connected
* to the master. */
pa_sink_input_cork(u->sink_input, true);
pa_sink_unlink(u->sink);
pa_sink_input_unlink(u->sink_input);
pa_sink_input_unref(u->sink_input);
u->sink_input = NULL;
pa_sink_unref(u->sink);
u->sink = NULL;
pa_module_unload_request(u->module, true);
}
static void connection_unlink(connection *c) {
pa_assert(c);
if (!c->protocol)
return;
if (c->options) {
pa_simple_options_unref(c->options);
c->options = NULL;
}
if (c->sink_input) {
pa_sink_input_unlink(c->sink_input);
pa_sink_input_unref(c->sink_input);
c->sink_input = NULL;
}
if (c->source_output) {
pa_source_output_unlink(c->source_output);
pa_source_output_unref(c->source_output);
c->source_output = NULL;
}
if (c->client) {
pa_client_free(c->client);
c->client = NULL;
}
if (c->io) {
pa_iochannel_free(c->io);
c->io = NULL;
}
pa_idxset_remove_by_data(c->protocol->connections, c, NULL);
c->protocol = NULL;
connection_unref(c);
}
/*** Deallocate stuff ***/
void voice_clear_up(struct userdata *u) {
pa_assert(u);
if (u->mainloop_handler) {
u->mainloop_handler->parent.free((pa_object *)u->mainloop_handler);
u->mainloop_handler = NULL;
}
if (u->hw_sink_input) {
pa_sink_input_unlink(u->hw_sink_input);
pa_sink_input_unref(u->hw_sink_input);
u->hw_sink_input = NULL;
}
if (u->raw_sink) {
pa_sink_unlink(u->raw_sink);
pa_sink_unref(u->raw_sink);
u->raw_sink = NULL;
}
if (u->dl_memblockq) {
pa_memblockq_free(u->dl_memblockq);
u->dl_memblockq = NULL;
}
if (u->voip_sink) {
pa_sink_unlink(u->voip_sink);
pa_sink_unref(u->voip_sink);
u->voip_sink = NULL;
}
if (u->hw_source_output) {
pa_source_output_unlink(u->hw_source_output);
pa_source_output_unref(u->hw_source_output);
u->hw_source_output = NULL;
}
if (u->voip_source) {
pa_source_unlink(u->voip_source);
pa_source_unref(u->voip_source);
u->voip_source = NULL;
}
if (u->raw_source) {
pa_source_unlink(u->raw_source);
pa_source_unref(u->raw_source);
u->raw_source = NULL;
}
if (u->hw_source_memblockq) {
pa_memblockq_free(u->hw_source_memblockq);
u->hw_source_memblockq = NULL;
}
if (u->ul_memblockq) {
pa_memblockq_free(u->ul_memblockq);
u->ul_memblockq = NULL;
}
if (u->dl_sideinfo_queue) {
pa_queue_free(u->dl_sideinfo_queue, NULL, u);
u->dl_sideinfo_queue = NULL;
}
voice_aep_ear_ref_unload(u);
if (u->aep_silence_memchunk.memblock) {
pa_memblock_unref(u->aep_silence_memchunk.memblock);
pa_memchunk_reset(&u->aep_silence_memchunk);
}
if (u->sink_temp_buff) {
pa_xfree(u->sink_temp_buff);
u->sink_temp_buff = NULL;
}
if (u->sink_subscription) {
pa_subscription_free(u->sink_subscription);
u->sink_subscription = NULL;
}
if (u->sink_proplist_changed_slot) {
pa_hook_slot_free(u->sink_proplist_changed_slot);
u->sink_proplist_changed_slot = NULL;
}
if (u->source_proplist_changed_slot) {
pa_hook_slot_free(u->source_proplist_changed_slot);
u->source_proplist_changed_slot = NULL;
}
voice_convert_free(u);
voice_memchunk_pool_unload(u);
voice_unload_event_forwarder(u);
}
