int pa_scache_add_file(pa_core *c, const char *name, const char *filename, uint32_t *idx) {
pa_sample_spec ss;
pa_channel_map map;
pa_memchunk chunk;
int r;
pa_proplist *p;
#ifdef OS_IS_WIN32
char buf[MAX_PATH];
if (ExpandEnvironmentStrings(filename, buf, MAX_PATH))
filename = buf;
#endif
pa_assert(c);
pa_assert(name);
pa_assert(filename);
p = pa_proplist_new();
pa_proplist_sets(p, PA_PROP_MEDIA_FILENAME, filename);
if (pa_sound_file_load(c->mempool, filename, &ss, &map, &chunk, p) < 0) {
pa_proplist_free(p);
return -1;
}
r = pa_scache_add_item(c, name, &ss, &map, &chunk, p, idx);
pa_memblock_unref(chunk.memblock);
pa_proplist_free(p);
return r;
}
/* Called from main context */
void pa_source_output_send_event(pa_source_output *o, const char *event, pa_proplist *data) {
pa_proplist *pl = NULL;
pa_source_output_send_event_hook_data hook_data;
pa_source_output_assert_ref(o);
pa_assert_ctl_context();
pa_assert(event);
if (!o->send_event)
return;
if (!data)
data = pl = pa_proplist_new();
hook_data.source_output = o;
hook_data.data = data;
hook_data.event = event;
if (pa_hook_fire(&o->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_SEND_EVENT], &hook_data) < 0)
goto finish;
o->send_event(o, event, data);
finish:
if (pl)
pa_proplist_free(pl);
}
void alc_pulse_deinit(void)
{
ALuint i;
for(i = 0;i < numDevNames;++i)
{
free(allDevNameMap[i].name);
free(allDevNameMap[i].device_name);
}
free(allDevNameMap);
allDevNameMap = NULL;
numDevNames = 0;
for(i = 0;i < numCaptureDevNames;++i)
{
free(allCaptureDevNameMap[i].name);
free(allCaptureDevNameMap[i].device_name);
}
free(allCaptureDevNameMap);
allCaptureDevNameMap = NULL;
numCaptureDevNames = 0;
if(prop_filter)
pa_proplist_free(prop_filter);
prop_filter = NULL;
/* PulseAudio doesn't like being CloseLib'd sometimes */
}
pa_operation* pa_context_set_name(pa_context *c, const char *name, pa_context_success_cb_t cb, void *userdata) {
pa_operation *o;
pa_assert(c);
pa_assert(PA_REFCNT_VALUE(c) >= 1);
pa_assert(name);
PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
if (c->version >= 13) {
pa_proplist *p = pa_proplist_new();
pa_proplist_sets(p, PA_PROP_APPLICATION_NAME, name);
o = pa_context_proplist_update(c, PA_UPDATE_REPLACE, p, cb, userdata);
pa_proplist_free(p);
} else {
pa_tagstruct *t;
uint32_t tag;
o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
t = pa_tagstruct_command(c, PA_COMMAND_SET_CLIENT_NAME, &tag);
pa_tagstruct_puts(t, name);
pa_pstream_send_tagstruct(c->pstream, t);
pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
}
return o;
}
void SinkInput::sink_input_cb(pa_context *, const pa_sink_input_info *i, int eol, void *userdata)
{
cout << "SinkInput::sink_cb" << endl;
SinkInput *p = reinterpret_cast<SinkInput *>(userdata);
SinkInput::Private *dd = p->d;
if (eol) return;
if (!i) {
cout << "Sink callback failure" << endl;
return;
}
if ( dd->valid ) assert ( i->index == dd->index );
//p->mSinkInfo = *i;
dd->name = QString(i->name);
dd->sampleSpec = i->sample_spec;
dd->channelMap = i->channel_map;
dd->owner = i->owner_module;
dd->volume = i->volume;
dd->muted = i->mute;
dd->driver = QString(i->driver);
dd->valid = true;
if(dd->proplist != 0)
pa_proplist_free(dd->proplist);
dd->proplist = pa_proplist_copy(i->proplist);
//std::cout << pa_proplist_to_string(dd->proplist) << std::endl;
emit p->updated();
}
static void
gst_pulsesrc_finalize (GObject * object)
{
GstPulseSrc *pulsesrc = GST_PULSESRC_CAST (object);
g_free (pulsesrc->server);
g_free (pulsesrc->device);
if (pulsesrc->properties)
gst_structure_free (pulsesrc->properties);
if (pulsesrc->proplist)
pa_proplist_free (pulsesrc->proplist);
if (pulsesrc->mixer) {
gst_pulsemixer_ctrl_free (pulsesrc->mixer);
pulsesrc->mixer = NULL;
}
if (pulsesrc->probe) {
gst_pulseprobe_free (pulsesrc->probe);
pulsesrc->probe = NULL;
}
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gst_pulsesrc_set_property (GObject * object,
guint prop_id, const GValue * value, GParamSpec * pspec)
{
GstPulseSrc *pulsesrc = GST_PULSESRC_CAST (object);
switch (prop_id) {
case PROP_SERVER:
g_free (pulsesrc->server);
pulsesrc->server = g_value_dup_string (value);
if (pulsesrc->probe)
gst_pulseprobe_set_server (pulsesrc->probe, pulsesrc->server);
break;
case PROP_DEVICE:
g_free (pulsesrc->device);
pulsesrc->device = g_value_dup_string (value);
break;
case PROP_STREAM_PROPERTIES:
if (pulsesrc->properties)
gst_structure_free (pulsesrc->properties);
pulsesrc->properties =
gst_structure_copy (gst_value_get_structure (value));
if (pulsesrc->proplist)
pa_proplist_free (pulsesrc->proplist);
pulsesrc->proplist = gst_pulse_make_proplist (pulsesrc->properties);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/* Called from main thread */
static void sink_input_moving_cb(pa_sink_input *i, pa_sink *dest) {
struct userdata *u;
pa_proplist *p;
const char *n;
if (!dest)
return;
pa_sink_input_assert_ref(i);
pa_assert_ctl_context();
pa_assert_se(u = i->userdata);
p = pa_proplist_new();
pa_proplist_setf(p, PA_PROP_MEDIA_NAME, "Loopback to %s", pa_strnull(pa_proplist_gets(dest->proplist, PA_PROP_DEVICE_DESCRIPTION)));
if ((n = pa_proplist_gets(dest->proplist, PA_PROP_DEVICE_ICON_NAME)))
pa_proplist_sets(p, PA_PROP_MEDIA_ICON_NAME, n);
pa_source_output_update_proplist(u->source_output, PA_UPDATE_REPLACE, p);
pa_proplist_free(p);
if (pa_sink_get_state(dest) == PA_SINK_SUSPENDED)
pa_source_output_cork(u->source_output, true);
else
pa_source_output_cork(u->source_output, false);
update_adjust_timer(u);
}
/* Called from main thread */
static void source_output_moving_cb(pa_source_output *o, pa_source *dest) {
struct userdata *u;
pa_source_output_assert_ref(o);
pa_assert_ctl_context();
pa_assert_se(u = o->userdata);
if (dest) {
pa_source_set_asyncmsgq(u->source, dest->asyncmsgq);
pa_source_update_flags(u->source, PA_SOURCE_LATENCY|PA_SOURCE_DYNAMIC_LATENCY, dest->flags);
} else
pa_source_set_asyncmsgq(u->source, NULL);
if (u->auto_desc && dest) {
const char *k;
pa_proplist *pl;
pl = pa_proplist_new();
k = pa_proplist_gets(dest->proplist, PA_PROP_DEVICE_DESCRIPTION);
pa_proplist_setf(pl, PA_PROP_DEVICE_DESCRIPTION, "Remapped %s", k ? k : dest->name);
pa_source_update_proplist(u->source, PA_UPDATE_REPLACE, pl);
pa_proplist_free(pl);
}
}
void pa_client_send_event(pa_client *c, const char *event, pa_proplist *data) {
pa_proplist *pl = NULL;
pa_client_send_event_hook_data hook_data;
pa_assert(c);
pa_assert(event);
if (!c->send_event)
return;
if (!data)
data = pl = pa_proplist_new();
hook_data.client = c;
hook_data.data = data;
hook_data.event = event;
if (pa_hook_fire(&c->core->hooks[PA_CORE_HOOK_CLIENT_SEND_EVENT], &hook_data) < 0)
goto finish;
c->send_event(c, event, data);
finish:
if (pl)
pa_proplist_free(pl);
}
void pa_client_free(pa_client *c) {
pa_core *core;
pa_assert(c);
pa_assert(c->core);
core = c->core;
pa_hook_fire(&core->hooks[PA_CORE_HOOK_CLIENT_UNLINK], c);
pa_idxset_remove_by_data(c->core->clients, c, NULL);
pa_log_info("Freed %u \"%s\"", c->index, pa_strnull(pa_proplist_gets(c->proplist, PA_PROP_APPLICATION_NAME)));
pa_subscription_post(c->core, PA_SUBSCRIPTION_EVENT_CLIENT|PA_SUBSCRIPTION_EVENT_REMOVE, c->index);
pa_assert(pa_idxset_isempty(c->sink_inputs));
pa_idxset_free(c->sink_inputs, NULL);
pa_assert(pa_idxset_isempty(c->source_outputs));
pa_idxset_free(c->source_outputs, NULL);
pa_proplist_free(c->proplist);
pa_xfree(c->driver);
pa_xfree(c);
pa_core_check_idle(core);
}
/* Called from main context */
static void sink_input_moving_cb(pa_sink_input *i, pa_sink *dest) {
struct userdata *u;
pa_sink_input_assert_ref(i);
pa_assert_se(u = i->userdata);
if (dest) {
pa_sink_set_asyncmsgq(u->sink, dest->asyncmsgq);
pa_sink_update_flags(u->sink, PA_SINK_LATENCY|PA_SINK_DYNAMIC_LATENCY, dest->flags);
} else
pa_sink_set_asyncmsgq(u->sink, NULL);
if (u->auto_desc && dest) {
const char *z;
pa_proplist *pl;
pl = pa_proplist_new();
z = pa_proplist_gets(dest->proplist, PA_PROP_DEVICE_DESCRIPTION);
pa_proplist_setf(pl, PA_PROP_DEVICE_DESCRIPTION, "Virtual Sink %s on %s",
pa_proplist_gets(u->sink->proplist, "device.vsink.name"), z ? z : dest->name);
pa_sink_update_proplist(u->sink, PA_UPDATE_REPLACE, pl);
pa_proplist_free(pl);
}
}
static void switch_mode(struct userdata *u, const char *mode) {
pa_proplist *proplist = pa_proplist_new();
pa_log_debug("Switching to mode %s", mode);
pa_proplist_sets(proplist, PA_NOKIA_PROP_AUDIO_MODE, mode);
pa_proplist_sets(proplist, PA_NOKIA_PROP_AUDIO_ACCESSORY_HWID, "");
pa_sink_update_proplist(u->mode_sink, PA_UPDATE_REPLACE, proplist);
pa_proplist_free(proplist);
}
static void rule_free(struct rule *r) {
pa_assert(r);
pa_xfree(r->process_name);
pa_xfree(r->application_name);
pa_xfree(r->icon_name);
pa_xfree(r->role);
if (r->proplist)
pa_proplist_free(r->proplist);
pa_xfree(r);
}
static int m_pa_stream_connect(pa_context *pa_ctx)
{
if (pa_context_get_server_protocol_version (pa_ctx) < 13) {
return -1;
}
printf("server version: %d\n", pa_context_get_server_protocol_version(pa_ctx));
if (s) {
pa_stream_disconnect(s);
pa_stream_unref(s);
}
pa_proplist *proplist;
pa_buffer_attr attr;
pa_sample_spec ss;
int res;
//char dev_name[40];
// pa_sample_spec
ss.channels = 1;
ss.format = PA_SAMPLE_FLOAT32;
ss.rate = 25;
// pa_buffer_attr
memset(&attr, 0, sizeof(attr));
attr.fragsize = sizeof(float);
attr.maxlength = (uint32_t) -1;
// pa_proplist
proplist = pa_proplist_new ();
pa_proplist_sets (proplist, PA_PROP_APPLICATION_ID, "Deepin Sound Settings");
// create new stream
if (!(s = pa_stream_new_with_proplist(pa_ctx, "Deepin Sound Settings", &ss, NULL, proplist))) {
fprintf(stderr, "pa_stream_new error\n");
return -2;
}
pa_proplist_free(proplist);
pa_stream_set_read_callback(s, on_monitor_read_callback, NULL);
pa_stream_set_suspended_callback(s, on_monitor_suspended_callback, NULL);
res = pa_stream_connect_record(s, NULL, &attr,
(pa_stream_flags_t) (PA_STREAM_DONT_MOVE
|PA_STREAM_PEAK_DETECT
|PA_STREAM_ADJUST_LATENCY));
if (res < 0) {
fprintf(stderr, "Failed to connect monitoring stream\n");
return -3;
}
return 0;
}
APULSE_EXPORT
pa_stream *
pa_stream_new(pa_context *c, const char *name, const pa_sample_spec *ss, const pa_channel_map *map)
{
trace_info_f("F %s c=%p, name=%s, ss=%p, map=%p\n", __func__, c, name, ss, map);
pa_proplist *p = pa_proplist_new();
pa_stream *s = pa_stream_new_with_proplist(c, name, ss, map, p);
pa_proplist_free(p);
return s;
}
pa_proplist *pa_dbus_get_proplist_arg(DBusConnection *c, DBusMessage *msg, DBusMessageIter *iter) {
DBusMessageIter dict_iter;
DBusMessageIter dict_entry_iter;
char *signature;
pa_proplist *proplist = NULL;
const char *key = NULL;
const uint8_t *value = NULL;
int value_length = 0;
pa_assert(c);
pa_assert(msg);
pa_assert(iter);
pa_assert(signature = dbus_message_iter_get_signature(iter));
pa_assert_se(pa_streq(signature, "a{say}"));
dbus_free(signature);
proplist = pa_proplist_new();
dbus_message_iter_recurse(iter, &dict_iter);
while (dbus_message_iter_get_arg_type(&dict_iter) != DBUS_TYPE_INVALID) {
dbus_message_iter_recurse(&dict_iter, &dict_entry_iter);
dbus_message_iter_get_basic(&dict_entry_iter, &key);
dbus_message_iter_next(&dict_entry_iter);
if (strlen(key) <= 0 || !pa_ascii_valid(key)) {
pa_dbus_send_error(c, msg, DBUS_ERROR_INVALID_ARGS, "Invalid property list key: '%s'.", key);
goto fail;
}
dbus_message_iter_get_fixed_array(&dict_entry_iter, &value, &value_length);
pa_assert(value_length >= 0);
pa_assert_se(pa_proplist_set(proplist, key, value, value_length) >= 0);
dbus_message_iter_next(&dict_iter);
}
dbus_message_iter_next(iter);
return proplist;
fail:
if (proplist)
pa_proplist_free(proplist);
return NULL;
}
static void free_entry(pa_scache_entry *e) {
pa_assert(e);
pa_namereg_unregister(e->core, e->name);
pa_subscription_post(e->core, PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE|PA_SUBSCRIPTION_EVENT_REMOVE, e->index);
pa_xfree(e->name);
pa_xfree(e->filename);
if (e->memchunk.memblock)
pa_memblock_unref(e->memchunk.memblock);
if (e->proplist)
pa_proplist_free(e->proplist);
pa_xfree(e);
}
static void device_port_free(pa_object *o) {
pa_device_port *p = PA_DEVICE_PORT(o);
pa_assert(p);
pa_assert(pa_device_port_refcnt(p) == 0);
if (p->proplist)
pa_proplist_free(p->proplist);
if (p->profiles)
pa_hashmap_free(p->profiles, NULL, NULL);
pa_xfree(p->name);
pa_xfree(p->description);
pa_xfree(p);
}
pa_stream* pulse_stream_new(const char* name, const pa_sample_spec* ss,
const pa_channel_map* map)
{
if (pulse_context_ready() < 0)
return NULL;
pulse_lock();
pa_proplist *p = pulse_properties();
pa_stream *s = pa_stream_new_with_proplist(
pulse_context, name, ss, map, p);
pa_proplist_free(p);
pulse_unlock();
return s;
}
/**
* Initialize the pulse audio context with properties and callback
*/
static void pulse_init_context()
{
pulse_lock();
pa_proplist *p = pulse_properties();
pulse_context = pa_context_new_with_proplist(
pa_threaded_mainloop_get_api(pulse_mainloop), "OBS", p);
pa_context_set_state_callback(pulse_context,
pulse_context_state_changed, NULL);
pa_context_connect(pulse_context, NULL, PA_CONTEXT_NOAUTOSPAWN, NULL);
pa_proplist_free(p);
pulse_unlock();
}
static void
gst_pulsesrc_set_property (GObject * object,
guint prop_id, const GValue * value, GParamSpec * pspec)
{
GstPulseSrc *pulsesrc = GST_PULSESRC_CAST (object);
switch (prop_id) {
case PROP_SERVER:
g_free (pulsesrc->server);
pulsesrc->server = g_value_dup_string (value);
if (pulsesrc->probe)
gst_pulseprobe_set_server (pulsesrc->probe, pulsesrc->server);
break;
case PROP_DEVICE:
g_free (pulsesrc->device);
pulsesrc->device = g_value_dup_string (value);
break;
case PROP_CLIENT_NAME:
g_free (pulsesrc->client_name);
if (!g_value_get_string (value)) {
GST_WARNING_OBJECT (pulsesrc,
"Empty PulseAudio client name not allowed. Resetting to default value");
pulsesrc->client_name = gst_pulse_client_name ();
} else
pulsesrc->client_name = g_value_dup_string (value);
break;
case PROP_STREAM_PROPERTIES:
if (pulsesrc->properties)
gst_structure_free (pulsesrc->properties);
pulsesrc->properties =
gst_structure_copy (gst_value_get_structure (value));
if (pulsesrc->proplist)
pa_proplist_free (pulsesrc->proplist);
pulsesrc->proplist = gst_pulse_make_proplist (pulsesrc->properties);
break;
case PROP_VOLUME:
gst_pulsesrc_set_stream_volume (pulsesrc, g_value_get_double (value));
break;
case PROP_MUTE:
gst_pulsesrc_set_stream_mute (pulsesrc, g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
void pa_source_new_data_done(pa_source_new_data *data) {
pa_assert(data);
pa_proplist_free(data->proplist);
if (data->ports) {
pa_device_port *p;
while ((p = pa_hashmap_steal_first(data->ports)))
pa_device_port_free(p);
pa_hashmap_free(data->ports, NULL, NULL);
}
pa_xfree(data->name);
pa_xfree(data->active_port);
}
/* Called from main thread */
static void source_output_moving_cb(pa_source_output *o, pa_source *dest) {
pa_proplist *p;
const char *n;
struct userdata *u;
pa_source_output_assert_ref(o);
pa_assert_ctl_context();
pa_assert_se(u = o->userdata);
p = pa_proplist_new();
pa_proplist_setf(p, PA_PROP_MEDIA_NAME, "Loopback of %s", pa_strnull(pa_proplist_gets(dest->proplist, PA_PROP_DEVICE_DESCRIPTION)));
if ((n = pa_proplist_gets(dest->proplist, PA_PROP_DEVICE_ICON_NAME)))
pa_proplist_sets(p, PA_PROP_MEDIA_ICON_NAME, n);
pa_sink_input_update_proplist(u->sink_input, PA_UPDATE_REPLACE, p);
pa_proplist_free(p);
}
/*
* Create a new pulseaudio context
*/
static pa_context *pulse_context_create(pa_threaded_mainloop *m)
{
pa_context *c;
pa_proplist *p;
p = pa_proplist_new();
pa_proplist_sets(p, PA_PROP_APPLICATION_NAME, "OBS Studio");
pa_proplist_sets(p, PA_PROP_APPLICATION_ICON_NAME, "application-exit");
pa_proplist_sets(p, PA_PROP_MEDIA_ROLE, "production");
pa_threaded_mainloop_lock(m);
c = pa_context_new_with_proplist(pa_threaded_mainloop_get_api(m),
"OBS Studio", p);
pa_threaded_mainloop_unlock(m);
pa_proplist_free(p);
return c;
}
static int parse_properties(pa_config_parser_state *state) {
struct rule *r;
pa_proplist *n;
pa_assert(state);
r = state->userdata;
if (!(n = pa_proplist_from_string(state->rvalue)))
return -1;
if (r->proplist) {
pa_proplist_update(r->proplist, PA_UPDATE_MERGE, n);
pa_proplist_free(n);
} else
r->proplist = n;
return 0;
}
pa_operation *pa_context_play_sample_with_proplist(pa_context *c, const char *name, const char *dev, pa_volume_t volume, pa_proplist *p, pa_context_play_sample_cb_t cb, void *userdata) {
pa_operation *o;
pa_tagstruct *t;
uint32_t tag;
pa_assert(c);
pa_assert(PA_REFCNT_VALUE(c) >= 1);
PA_CHECK_VALIDITY_RETURN_NULL(c, !pa_detect_fork(), PA_ERR_FORKED);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->state == PA_CONTEXT_READY, PA_ERR_BADSTATE);
PA_CHECK_VALIDITY_RETURN_NULL(c, name && *name, PA_ERR_INVALID);
PA_CHECK_VALIDITY_RETURN_NULL(c, !dev || *dev, PA_ERR_INVALID);
PA_CHECK_VALIDITY_RETURN_NULL(c, c->version >= 13, PA_ERR_NOTSUPPORTED);
o = pa_operation_new(c, NULL, (pa_operation_cb_t) cb, userdata);
if (!dev)
dev = c->conf->default_sink;
t = pa_tagstruct_command(c, PA_COMMAND_PLAY_SAMPLE, &tag);
pa_tagstruct_putu32(t, PA_INVALID_INDEX);
pa_tagstruct_puts(t, dev);
if (!PA_VOLUME_IS_VALID(volume) && c->version < 15)
volume = PA_VOLUME_NORM;
pa_tagstruct_putu32(t, volume);
pa_tagstruct_puts(t, name);
if (p)
pa_tagstruct_put_proplist(t, p);
else {
p = pa_proplist_new();
pa_tagstruct_put_proplist(t, p);
pa_proplist_free(p);
}
pa_pstream_send_tagstruct(c->pstream, t);
pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, play_sample_with_proplist_ack_callback, pa_operation_ref(o), (pa_free_cb_t) pa_operation_unref);
return o;
}
/*
* Destroy the plugin object and free all memory
*/
static void pulse_destroy(void *vptr)
{
PULSE_DATA(vptr);
if (!data)
return;
if (data->thread) {
void *ret;
os_event_signal(data->event);
pthread_join(data->thread, &ret);
}
os_event_destroy(data->event);
pa_proplist_free(data->props);
blog(LOG_DEBUG, "pulse-input: Input destroyed");
bfree(data);
}
static void do_free_audio_output(_mbx_out out) {
if ( out != NULL ) {
if ( out->pa_props != NULL ) {
pa_proplist_free(out->pa_props);
out->pa_props = NULL;
}
if ( out->pa_ml != NULL ) {
pa_threaded_mainloop_free(out->pa_ml);
out->pa_ml = NULL;
}
if ( out->dev_name != NULL ) {
_mbx_xfree((void *) out->dev_name);
out->dev_name = NULL;
}
if ( out->name != NULL ) {
_mbx_xfree((void *) out->name);
out->name = NULL;
}
_mbx_xfree(out);
}
}
static void destroy_pa(struct SoundIoPrivate *si) {
struct SoundIoPulseAudio *sipa = &si->backend_data.pulseaudio;
if (sipa->main_loop)
pa_threaded_mainloop_stop(sipa->main_loop);
pa_context_disconnect(sipa->pulse_context);
pa_context_unref(sipa->pulse_context);
soundio_destroy_devices_info(sipa->current_devices_info);
soundio_destroy_devices_info(sipa->ready_devices_info);
if (sipa->main_loop)
pa_threaded_mainloop_free(sipa->main_loop);
if (sipa->props)
pa_proplist_free(sipa->props);
free(sipa->default_sink_name);
free(sipa->default_source_name);
}
