void pa__done(pa_module*m) { struct userdata *u; pa_assert(m); if (!(u = m->userdata)) return; if (u->sink) pa_sink_unlink(u->sink); if (u->thread) { pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL); pa_thread_free(u->thread); } pa_thread_mq_done(&u->thread_mq); if (u->sink) pa_sink_unref(u->sink); if (u->rtpoll) pa_rtpoll_free(u->rtpoll); pa_xfree(u); }
void pa__done(pa_module *m) { pa_assert(m); struct example_sink_userdata *u = m->userdata; if (!u) { return; } if (u->sink) { pa_sink_unlink(u->sink); } if (u->thread) { pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL); pa_thread_free(u->thread); } pa_thread_mq_done(&u->thread_mq); if (u->sink) { pa_sink_unref(u->sink); } if (u->rtpoll) { pa_rtpoll_free(u->rtpoll); } if (u->output_fd != -1) { close(u->output_fd); } pa_xfree(u); }
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); }
void pa__done(pa_module *module) { struct context *context; pa_assert(module); context = module->userdata; if (!context) return; if (context->sink) { pa_sink_unlink(context->sink); } if (context->thread) { pa_asyncmsgq_send(context->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL); pa_thread_free(context->thread); } pa_thread_mq_done(&context->thread_mq); if (context->sink) { pa_sink_unref(context->sink); } if (context->rtpoll) { pa_rtpoll_free(context->rtpoll); } pa_xfree(context); }
void pa__done(pa_module *m) { struct userdata *u; pa_assert(m); if (!(u = m->userdata)) return; if (u->sig) { ioctl(u->fd, I_SETSIG, 0); pa_signal_free(u->sig); } if (u->sink) pa_sink_unlink(u->sink); if (u->source) pa_source_unlink(u->source); if (u->thread) { pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL); pa_thread_free(u->thread); } pa_thread_mq_done(&u->thread_mq); if (u->sink) pa_sink_unref(u->sink); if (u->source) pa_source_unref(u->source); if (u->memchunk.memblock) pa_memblock_unref(u->memchunk.memblock); if (u->rtpoll_item) pa_rtpoll_item_free(u->rtpoll_item); if (u->rtpoll) pa_rtpoll_free(u->rtpoll); if (u->fd >= 0) close(u->fd); if (u->smoother) pa_smoother_free(u->smoother); pa_xfree(u->device_name); pa_xfree(u); }
void pa__done(pa_module*m) { struct userdata *u; pa_assert(m); if (!(u = m->userdata)) return; if (u->sink) pa_sink_unlink(u->sink); if (u->thread) { pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL); pa_thread_free(u->thread); } pa_thread_mq_done(&u->thread_mq); if (u->sink) pa_sink_unref(u->sink); if (u->rtpoll_item) pa_rtpoll_item_free(u->rtpoll_item); if (u->rtpoll) pa_rtpoll_free(u->rtpoll); if (u->raw_memchunk.memblock) pa_memblock_unref(u->raw_memchunk.memblock); if (u->encoded_memchunk.memblock) pa_memblock_unref(u->encoded_memchunk.memblock); if (u->raop) pa_raop_client_free(u->raop); pa_xfree(u->read_data); pa_xfree(u->write_data); if (u->smoother) pa_smoother_free(u->smoother); if (u->fd >= 0) pa_close(u->fd); 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); }
void pa__done(pa_module *m) { struct userdata *u; pa_assert(m); if (!(u = m->userdata)) return; if (u->sink) pa_sink_unlink(u->sink); if (u->thread) { pa_asyncmsgq_send(u->thread_mq->inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL); pa_thread_free(u->thread); } if (u->thread_mq) { pa_thread_mq_done(u->thread_mq); pa_xfree(u->thread_mq); } if (u->thread_mainloop) pa_mainloop_free(u->thread_mainloop); if (u->cookie_file) pa_xfree(u->cookie_file); if (u->remote_sink_name) pa_xfree(u->remote_sink_name); if (u->remote_server) pa_xfree(u->remote_server); if (u->sink) pa_sink_unref(u->sink); if(u->transcode.encoding != -1) pa_transcode_free(&u->transcode); 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 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); }
void pa__done(pa_module *m) { struct userdata *u; pa_assert(m); if (!(u = m->userdata)) return; if (u->sink) pa_sink_unlink(u->sink); if (u->thread) { pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL); pa_thread_free(u->thread); } pa_thread_mq_done(&u->thread_mq); if (u->sink) pa_sink_unref(u->sink); if (u->memchunk.memblock) pa_memblock_unref(u->memchunk.memblock); if (u->rtpoll_item) pa_rtpoll_item_free(u->rtpoll_item); if (u->rtpoll) pa_rtpoll_free(u->rtpoll); if (u->filename) { unlink(u->filename); pa_xfree(u->filename); } if (u->fd >= 0) pa_assert_se(pa_close(u->fd) == 0); pa_xfree(u); }
int pa__init(pa_module*m) { struct userdata *u = NULL; pa_sample_spec ss; pa_channel_map map; pa_modargs *ma = NULL; pa_sink_new_data data; size_t nbytes; pa_assert(m); if (!(ma = pa_modargs_new(m->argument, valid_modargs))) { pa_log("Failed to parse module arguments."); goto fail; } ss = m->core->default_sample_spec; map = m->core->default_channel_map; if (pa_modargs_get_sample_spec_and_channel_map(ma, &ss, &map, PA_CHANNEL_MAP_DEFAULT) < 0) { pa_log("Invalid sample format specification or channel map"); goto fail; } m->userdata = u = pa_xnew0(struct userdata, 1); u->core = m->core; u->module = m; u->rtpoll = pa_rtpoll_new(); pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll); pa_sink_new_data_init(&data); data.driver = __FILE__; data.module = m; pa_sink_new_data_set_name(&data, pa_modargs_get_value(ma, "sink_name", DEFAULT_SINK_NAME)); pa_sink_new_data_set_sample_spec(&data, &ss); pa_sink_new_data_set_channel_map(&data, &map); pa_proplist_sets(data.proplist, PA_PROP_DEVICE_DESCRIPTION, "xrdp sink"); pa_proplist_sets(data.proplist, PA_PROP_DEVICE_CLASS, "abstract"); if (pa_modargs_get_proplist(ma, "sink_properties", data.proplist, PA_UPDATE_REPLACE) < 0) { pa_log("Invalid properties"); pa_sink_new_data_done(&data); goto fail; } u->sink = pa_sink_new(m->core, &data, PA_SINK_LATENCY | PA_SINK_DYNAMIC_LATENCY); pa_sink_new_data_done(&data); if (!u->sink) { pa_log("Failed to create sink object."); goto fail; } u->sink->parent.process_msg = sink_process_msg; u->sink->update_requested_latency = sink_update_requested_latency_cb; u->sink->userdata = u; pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq); pa_sink_set_rtpoll(u->sink, u->rtpoll); u->block_usec = BLOCK_USEC; pa_log_debug("3 block_usec %d", u->block_usec); nbytes = pa_usec_to_bytes(u->block_usec, &u->sink->sample_spec); pa_sink_set_max_rewind(u->sink, nbytes); pa_sink_set_max_request(u->sink, nbytes); u->display_num = get_display_num_from_display(getenv("DISPLAY")); #if defined(PA_CHECK_VERSION) #if PA_CHECK_VERSION(0, 9, 22) if (!(u->thread = pa_thread_new("xrdp-sink", thread_func, u))) { #else if (!(u->thread = pa_thread_new(thread_func, u))) { #endif #else if (!(u->thread = pa_thread_new(thread_func, u))) { #endif pa_log("Failed to create thread."); goto fail; } pa_sink_put(u->sink); pa_modargs_free(ma); return 0; fail: if (ma) { pa_modargs_free(ma); } pa__done(m); return -1; } int pa__get_n_used(pa_module *m) { struct userdata *u; pa_assert(m); pa_assert_se(u = m->userdata); return pa_sink_linked_by(u->sink); } void pa__done(pa_module*m) { struct userdata *u; pa_assert(m); if (!(u = m->userdata)) { return; } if (u->sink) { pa_sink_unlink(u->sink); } if (u->thread) { pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL); pa_thread_free(u->thread); } pa_thread_mq_done(&u->thread_mq); if (u->sink) { pa_sink_unref(u->sink); } if (u->rtpoll) { pa_rtpoll_free(u->rtpoll); } pa_xfree(u); }
int pa__init(pa_module * m) { struct userdata *u; pa_sample_spec ss; pa_channel_map map; pa_modargs *ma; struct pollfd *pollfd; pa_sink_new_data data_sink; pa_source_new_data data_source; pa_assert(m); pa_log("vchan module loading"); if (!(ma = pa_modargs_new(m->argument, valid_modargs))) { pa_log("Failed to parse module arguments."); goto fail; } ss = m->core->default_sample_spec; map = m->core->default_channel_map; if (pa_modargs_get_sample_spec_and_channel_map (ma, &ss, &map, PA_CHANNEL_MAP_DEFAULT) < 0) { pa_log ("Invalid sample format specification or channel map"); goto fail; } u = pa_xnew0(struct userdata, 1); u->core = m->core; u->module = m; m->userdata = u; pa_memchunk_reset(&u->memchunk_sink); pa_memchunk_reset(&u->memchunk_source); u->rtpoll = pa_rtpoll_new(); pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll); if ((do_conn(u)) < 0) { pa_log("get_early_allocated_vchan: %s", pa_cstrerror(errno)); goto fail; } /* SINK preparation */ pa_sink_new_data_init(&data_sink); data_sink.driver = __FILE__; data_sink.module = m; pa_sink_new_data_set_name(&data_sink, pa_modargs_get_value(ma, "sink_name", DEFAULT_SINK_NAME)); pa_proplist_sets(data_sink.proplist, PA_PROP_DEVICE_STRING, DEFAULT_SINK_NAME); pa_proplist_setf(data_sink.proplist, PA_PROP_DEVICE_DESCRIPTION, "Qubes VCHAN sink"); pa_sink_new_data_set_sample_spec(&data_sink, &ss); pa_sink_new_data_set_channel_map(&data_sink, &map); if (pa_modargs_get_proplist (ma, "sink_properties", data_sink.proplist, PA_UPDATE_REPLACE) < 0) { pa_log("Invalid properties"); pa_sink_new_data_done(&data_sink); goto fail; } u->sink = pa_sink_new(m->core, &data_sink, PA_SINK_LATENCY); pa_sink_new_data_done(&data_sink); if (!u->sink) { pa_log("Failed to create sink."); goto fail; } u->sink->parent.process_msg = sink_process_msg; u->sink->userdata = u; pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq); pa_sink_set_rtpoll(u->sink, u->rtpoll); pa_sink_set_max_request(u->sink, VCHAN_BUF); pa_sink_set_fixed_latency(u->sink, pa_bytes_to_usec (VCHAN_BUF, &u->sink->sample_spec)); u->play_rtpoll_item = pa_rtpoll_item_new(u->rtpoll, PA_RTPOLL_NEVER, 1); pollfd = pa_rtpoll_item_get_pollfd(u->play_rtpoll_item, NULL); pollfd->fd = libvchan_fd_for_select(u->play_ctrl); pollfd->events = POLLIN; pollfd->revents = 0; /* SOURCE preparation */ pa_source_new_data_init(&data_source); data_source.driver = __FILE__; data_source.module = m; pa_source_new_data_set_name(&data_source, pa_modargs_get_value(ma, "source_name", DEFAULT_SOURCE_NAME)); pa_proplist_sets(data_source.proplist, PA_PROP_DEVICE_STRING, DEFAULT_SOURCE_NAME); pa_proplist_setf(data_source.proplist, PA_PROP_DEVICE_DESCRIPTION, "Qubes VCHAN source"); pa_source_new_data_set_sample_spec(&data_source, &ss); pa_source_new_data_set_channel_map(&data_source, &map); if (pa_modargs_get_proplist(ma, "source_properties", data_source.proplist, PA_UPDATE_REPLACE) < 0) { pa_log("Invalid properties"); pa_source_new_data_done(&data_source); goto fail; } u->source = pa_source_new(m->core, &data_source, PA_SOURCE_LATENCY); pa_source_new_data_done(&data_source); if (!u->source) { pa_log("Failed to create source."); goto fail; } u->source->parent.process_msg = source_process_msg; u->source->userdata = u; pa_source_set_asyncmsgq(u->source, u->thread_mq.inq); pa_source_set_rtpoll(u->source, u->rtpoll); pa_source_set_fixed_latency(u->source, pa_bytes_to_usec(PIPE_BUF, &u->source->sample_spec)); u->rec_rtpoll_item = pa_rtpoll_item_new(u->rtpoll, PA_RTPOLL_NEVER, 1); pollfd = pa_rtpoll_item_get_pollfd(u->rec_rtpoll_item, NULL); pollfd->fd = libvchan_fd_for_select(u->rec_ctrl); pollfd->events = POLLIN; pollfd->revents = 0; #if PA_CHECK_VERSION(0,9,22) if (!(u->thread = pa_thread_new("vchan-sink", thread_func, u))) { #else if (!(u->thread = pa_thread_new(thread_func, u))) { #endif pa_log("Failed to create thread."); goto fail; } pa_sink_put(u->sink); pa_source_put(u->source); pa_modargs_free(ma); return 0; fail: if (ma) pa_modargs_free(ma); pa__done(m); return -1; } int pa__get_n_used(pa_module * m) { struct userdata *u; pa_assert(m); pa_assert_se(u = m->userdata); return pa_sink_linked_by(u->sink); } void pa__done(pa_module * m) { struct userdata *u; pa_assert(m); if (!(u = m->userdata)) return; if (u->sink) pa_sink_unlink(u->sink); if (u->source) pa_source_unlink(u->source); if (u->thread) { pa_asyncmsgq_send(u->thread_mq.inq, NULL, PA_MESSAGE_SHUTDOWN, NULL, 0, NULL); pa_thread_free(u->thread); } pa_thread_mq_done(&u->thread_mq); if (u->sink) pa_sink_unref(u->sink); if (u->source) pa_source_unref(u->source); if (u->memchunk_sink.memblock) pa_memblock_unref(u->memchunk_sink.memblock); if (u->memchunk_source.memblock) pa_memblock_unref(u->memchunk_source.memblock); if (u->play_rtpoll_item) pa_rtpoll_item_free(u->play_rtpoll_item); if (u->rec_rtpoll_item) pa_rtpoll_item_free(u->rec_rtpoll_item); if (u->rtpoll) pa_rtpoll_free(u->rtpoll); if (u->play_ctrl) libvchan_close(u->play_ctrl); if (u->rec_ctrl) libvchan_close(u->rec_ctrl); pa_xfree(u); }
/*** 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); }