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