static void apply_rule(struct rule *r, pa_proplist *p) {
pa_assert(r);
pa_assert(p);
if (!r->good)
return;
if (r->proplist)
pa_proplist_update(p, PA_UPDATE_MERGE, r->proplist);
if (r->icon_name)
if (!pa_proplist_contains(p, PA_PROP_APPLICATION_ICON_NAME))
pa_proplist_sets(p, PA_PROP_APPLICATION_ICON_NAME, r->icon_name);
if (r->application_name) {
const char *t;
t = pa_proplist_gets(p, PA_PROP_APPLICATION_NAME);
if (!t || pa_streq(t, r->process_name))
pa_proplist_sets(p, PA_PROP_APPLICATION_NAME, r->application_name);
}
if (r->role)
if (!pa_proplist_contains(p, PA_PROP_MEDIA_ROLE))
pa_proplist_sets(p, PA_PROP_MEDIA_ROLE, r->role);
}
/*
* Create the plugin object
*/
static void *pulse_create(obs_data_t settings, obs_source_t source)
{
UNUSED_PARAMETER(settings);
struct pulse_data *data = bmalloc(sizeof(struct pulse_data));
memset(data, 0, sizeof(struct pulse_data));
data->source = source;
data->speakers = SPEAKERS_STEREO;
blog(LOG_DEBUG, "pulse-input: obs wants '%s'",
obs_data_getstring(settings, "device_id"));
/* TODO: use obs-studio icon */
data->props = pa_proplist_new();
pa_proplist_sets(data->props, PA_PROP_APPLICATION_NAME,
"OBS Studio");
pa_proplist_sets(data->props, PA_PROP_APPLICATION_ICON_NAME,
"application-exit");
pa_proplist_sets(data->props, PA_PROP_MEDIA_ROLE,
"production");
if (os_event_init(&data->event, OS_EVENT_TYPE_MANUAL) != 0)
goto fail;
if (pthread_create(&data->thread, NULL, pulse_thread, data) != 0)
goto fail;
return data;
fail:
pulse_destroy(data);
return NULL;
}
int cmtspeech_create_source_output(struct userdata *u)
{
pa_source_output_new_data data;
char t[256];
pa_assert(u);
pa_assert(!u->source);
ENTER();
if (u->source_output) {
pa_log_info("Create called but output already exists");
return 1;
}
if (!(u->source = pa_namereg_get(u->core, u->source_name, PA_NAMEREG_SOURCE))) {
pa_log_error("Couldn't find source %s", u->source_name);
return 2;
}
if (cmtspeech_check_source_api(u->source))
return 3;
pa_source_output_new_data_init(&data);
data.driver = __FILE__;
data.module = u->module;
data.source = u->source;
snprintf(t, sizeof(t), "Cellular call up link");
pa_proplist_sets(data.proplist, PA_PROP_MEDIA_NAME, t);
snprintf(t, sizeof(t), "phone");
pa_proplist_sets(data.proplist, PA_PROP_MEDIA_ROLE, t);
snprintf(t, sizeof(t), "cmtspeech module");
pa_proplist_sets(data.proplist, PA_PROP_APPLICATION_NAME, t);
pa_source_output_new_data_set_sample_spec(&data, &u->ss);
pa_source_output_new_data_set_channel_map(&data, &u->map);
data.flags = PA_SOURCE_OUTPUT_DONT_MOVE|PA_SOURCE_OUTPUT_START_CORKED;
pa_source_output_new(&u->source_output, u->core, &data);
pa_source_output_new_data_done(&data);
if (!u->source_output) {
pa_log("Creating cmtspeech source output failed");
return -1;
}
u->source_output->push = cmtspeech_source_output_push_cb;
u->source_output->kill = cmtspeech_source_output_kill_cb;
u->source_output->attach = cmtspeech_source_output_attach_cb;
u->source_output->detach = cmtspeech_source_output_detach_cb;
u->source_output->moving = cmtspeech_source_output_moving_cb;
u->source_output->state_change = cmtspeech_source_output_state_change_cb;
u->source_output->may_move_to = cmtspeech_source_output_may_move_to_cb;
u->source_output->userdata = u;
pa_source_output_put(u->source_output);
pa_log_info("cmtspeech source-output created");
return 0;
}
/**
* get the default properties
*/
static pa_proplist *pulse_properties()
{
pa_proplist *p = pa_proplist_new();
pa_proplist_sets(p, PA_PROP_APPLICATION_NAME, "OBS");
pa_proplist_sets(p, PA_PROP_APPLICATION_ICON_NAME, "obs");
pa_proplist_sets(p, PA_PROP_MEDIA_ROLE, "production");
return p;
}
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 pa_proplist* tunnel_new_proplist(struct userdata *u) {
pa_proplist *proplist = pa_proplist_new();
pa_assert(proplist);
pa_proplist_sets(proplist, PA_PROP_APPLICATION_NAME, "PulseAudio");
pa_proplist_sets(proplist, PA_PROP_APPLICATION_ID, "org.PulseAudio.PulseAudio");
pa_proplist_sets(proplist, PA_PROP_APPLICATION_VERSION, PACKAGE_VERSION);
pa_init_proplist(proplist);
return proplist;
}
JNIEXPORT jlong JNICALL
Java_com_harrcharr_pulse_Stream_JNINewStream(
JNIEnv *jenv, jclass jcls, jlong c, jstring server) {
pa_sample_spec ss;
pa_stream *stream;
ss.channels = 1;
ss.format = PA_SAMPLE_FLOAT32;
ss.rate = 25;
pa_proplist *p = pa_proplist_new();
pa_proplist_sets(p, PA_PROP_APPLICATION_NAME, "Reverb PulseAudio Remote");
const char *sname;
sname = (*jenv)->GetStringUTFChars(jenv, server, NULL);
if (sname == NULL) {
return NULL; /* OutOfMemoryError already thrown */
}
if (!(stream = pa_stream_new_with_proplist((pa_context*)c, sname, &ss, NULL, p))) {
LOGE("Failed to create new stream");
stream = NULL;
}
(*jenv)->ReleaseStringUTFChars(jenv, server, sname);
return stream;
}
int pa_scache_add_file_lazy(pa_core *c, const char *name, const char *filename, uint32_t *idx) {
pa_scache_entry *e;
#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);
if (!(e = scache_add_item(c, name)))
return -1;
e->lazy = TRUE;
e->filename = pa_xstrdup(filename);
pa_proplist_sets(e->proplist, PA_PROP_MEDIA_FILENAME, filename);
if (!c->scache_auto_unload_event)
c->scache_auto_unload_event = pa_core_rttime_new(c, pa_rtclock_now() + UNLOAD_POLL_TIME, timeout_callback, c);
if (idx)
*idx = e->index;
return 0;
}
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 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);
}
pa_cli* pa_cli_new(pa_core *core, pa_iochannel *io, pa_module *m) {
char cname[256];
pa_cli *c;
pa_client_new_data data;
pa_client *client;
pa_assert(io);
pa_iochannel_socket_peer_to_string(io, cname, sizeof(cname));
pa_client_new_data_init(&data);
data.driver = __FILE__;
data.module = m;
pa_proplist_sets(data.proplist, PA_PROP_APPLICATION_NAME, cname);
client = pa_client_new(core, &data);
pa_client_new_data_done(&data);
if (!client)
return NULL;
c = pa_xnew0(pa_cli, 1);
c->core = core;
c->client = client;
pa_assert_se(c->line = pa_ioline_new(io));
c->client->kill = client_kill;
c->client->userdata = c;
pa_ioline_set_callback(c->line, line_callback, c);
return c;
}
pa_context *pa_context_new_with_proplist(pa_mainloop_api *mainloop, const char *name, pa_proplist *p) {
pa_context *c;
pa_assert(mainloop);
if (pa_detect_fork())
return NULL;
pa_init_i18n();
c = pa_xnew0(pa_context, 1);
PA_REFCNT_INIT(c);
c->proplist = p ? pa_proplist_copy(p) : pa_proplist_new();
if (name)
pa_proplist_sets(c->proplist, PA_PROP_APPLICATION_NAME, name);
#ifdef HAVE_DBUS
c->system_bus = c->session_bus = NULL;
#endif
c->mainloop = mainloop;
c->playback_streams = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
c->record_streams = pa_hashmap_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
c->client_index = PA_INVALID_INDEX;
c->use_rtclock = pa_mainloop_is_our_api(mainloop);
PA_LLIST_HEAD_INIT(pa_stream, c->streams);
PA_LLIST_HEAD_INIT(pa_operation, c->operations);
c->error = PA_OK;
c->state = PA_CONTEXT_UNCONNECTED;
reset_callbacks(c);
#ifndef MSG_NOSIGNAL
#ifdef SIGPIPE
pa_check_signal_is_blocked(SIGPIPE);
#endif
#endif
c->conf = pa_client_conf_new();
pa_client_conf_load(c->conf, true, true);
c->srb_template.readfd = -1;
c->srb_template.writefd = -1;
if (!(c->mempool = pa_mempool_new(!c->conf->disable_shm, c->conf->shm_size))) {
if (!c->conf->disable_shm)
c->mempool = pa_mempool_new(false, c->conf->shm_size);
if (!c->mempool) {
context_free(c);
return NULL;
}
}
return c;
}
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 pa_client_set_name(pa_client *c, const char *name) {
pa_assert(c);
pa_assert(name);
pa_log_info("Client %u changed name from \"%s\" to \"%s\"", c->index, pa_strnull(pa_proplist_gets(c->proplist, PA_PROP_APPLICATION_NAME)), name);
pa_proplist_sets(c->proplist, PA_PROP_APPLICATION_NAME, name);
pa_client_update_proplist(c, 0, NULL);
}
int voice_init_voip_sink(struct userdata *u, const char *name) {
pa_sink_new_data sink_data;
pa_assert(u);
pa_assert(u->core);
pa_assert(u->master_sink);
ENTER();
pa_sink_new_data_init(&sink_data);
sink_data.module = u->module;
sink_data.driver = __FILE__;
pa_sink_new_data_set_name(&sink_data, name);
pa_sink_new_data_set_sample_spec(&sink_data, &u->aep_sample_spec);
pa_sink_new_data_set_channel_map(&sink_data, &u->aep_channel_map);
pa_proplist_setf(sink_data.proplist, PA_PROP_DEVICE_DESCRIPTION, "%s connected conceptually to %s", name, u->raw_sink->name);
pa_proplist_sets(sink_data.proplist, PA_PROP_DEVICE_MASTER_DEVICE, u->raw_sink->name);
pa_proplist_sets(sink_data.proplist, "module-suspend-on-idle.timeout", "1");
pa_proplist_sets(sink_data.proplist, PA_PROP_SINK_API_EXTENSION_PROPERTY_NAME,
PA_PROP_SINK_API_EXTENSION_PROPERTY_VALUE);
u->voip_sink = pa_sink_new(u->core, &sink_data,
(u->master_sink->flags & (PA_SINK_LATENCY | PA_SINK_DYNAMIC_LATENCY)) | PA_SINK_SHARE_VOLUME_WITH_MASTER);
pa_sink_new_data_done(&sink_data);
/* Create sink */
if (!u->voip_sink) {
pa_log_error("Failed to create sink.");
return -1;
}
u->voip_sink->parent.process_msg = voip_sink_process_msg;
u->voip_sink->set_state = voip_sink_set_state;
u->voip_sink->update_requested_latency = voip_sink_update_requested_latency;
u->voip_sink->request_rewind = voip_sink_request_rewind;
u->voip_sink->userdata = u;
pa_memblock_ref(u->aep_silence_memchunk.memblock);
u->voip_sink->silence = u->aep_silence_memchunk;
pa_sink_set_asyncmsgq(u->voip_sink, u->master_sink->asyncmsgq);
pa_sink_set_rtpoll(u->voip_sink, u->master_sink->thread_info.rtpoll);
return 0;
}
/*
* 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 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;
}
static void set_object_property(struct pa_policy_object *object,
const char *property, const char *value)
{
pa_proplist *proplist;
if (object->ptr != NULL) {
if ((proplist = get_object_proplist(object)) != NULL) {
pa_proplist_sets(proplist, property, value);
fire_object_property_changed_hook(object);
}
}
}
void pa_format_info_set_prop_string(pa_format_info *f, const char *key, const char *value) {
json_object *o;
pa_assert(f);
pa_assert(key);
o = json_object_new_string(value);
pa_proplist_sets(f->plist, key, json_object_to_json_string(o));
json_object_put(o);
}
audio_class_t *
audio_driver_init(void)
{
TRACE(TRACE_DEBUG, "PA", "Headerversion: %s, library: %s",
pa_get_headers_version(), pa_get_library_version());
mainloop = pa_threaded_mainloop_new();
api = pa_threaded_mainloop_get_api(mainloop);
pa_threaded_mainloop_lock(mainloop);
pa_threaded_mainloop_start(mainloop);
#if PA_API_VERSION >= 12
pa_proplist *pl = pa_proplist_new();
pa_proplist_sets(pl, PA_PROP_APPLICATION_ID, "com.lonelycoder.hts.showtime");
pa_proplist_sets(pl, PA_PROP_APPLICATION_NAME, "Showtime");
/* Create a new connection context */
ctx = pa_context_new_with_proplist(api, "Showtime", pl);
pa_proplist_free(pl);
#else
ctx = pa_context_new(api, "Showtime");
#endif
pa_context_set_state_callback(ctx, context_state_callback, NULL);
/* Connect the context */
if(pa_context_connect(ctx, NULL, 0, NULL) < 0) {
TRACE(TRACE_ERROR, "PA", "pa_context_connect() failed: %s",
pa_strerror(pa_context_errno(ctx)));
pa_threaded_mainloop_unlock(mainloop);
return NULL;
}
pa_threaded_mainloop_unlock(mainloop);
return &pulseaudio_audio_class;
}
int voice_init_voip_source(struct userdata *u, const char *name) {
pa_source_new_data data;
pa_assert(u);
pa_assert(u->master_source);
pa_source_new_data_init(&data);
data.driver = __FILE__;
data.module = u->module;
pa_source_new_data_set_name(&data, name);
pa_proplist_setf(data.proplist, PA_PROP_DEVICE_DESCRIPTION, "%s source connected to %s", name, u->raw_source->name);
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_MASTER_DEVICE, u->raw_source->name);
pa_proplist_sets(data.proplist, "module-suspend-on-idle.timeout", "0");
pa_proplist_sets(data.proplist, PA_PROP_SOURCE_API_EXTENSION_PROPERTY_NAME,
PA_PROP_SOURCE_API_EXTENSION_PROPERTY_VALUE);
pa_source_new_data_set_sample_spec(&data, &u->aep_sample_spec);
pa_source_new_data_set_channel_map(&data, &u->aep_channel_map);
u->voip_source = pa_source_new(u->core, &data, u->master_source->flags &
(PA_SOURCE_LATENCY|PA_SOURCE_DYNAMIC_LATENCY));
pa_source_new_data_done(&data);
if (!u->voip_source) {
pa_log("Failed to create source");
return -1;
}
u->voip_source->parent.process_msg = voip_source_process_msg;
u->voip_source->set_state = voip_source_set_state;
u->raw_source->update_requested_latency = voip_source_update_requested_latency;
u->voip_source->userdata = u;
pa_source_set_asyncmsgq(u->voip_source, u->master_source->asyncmsgq);
pa_source_set_rtpoll(u->voip_source, u->master_source->thread_info.rtpoll);
return 0;
}
static pa_hook_result_t process(struct userdata *u, pa_object *o, pa_bool_t is_sink_input) {
const char *want;
pa_proplist *pl, *parent_pl;
if (is_sink_input) {
pl = PA_SINK_INPUT(o)->proplist;
parent_pl = PA_SINK_INPUT(o)->sink->proplist;
} else {
pl = PA_SOURCE_OUTPUT(o)->proplist;
parent_pl = PA_SOURCE_OUTPUT(o)->source->proplist;
}
/* If the stream already specifies what it must have, then let it be. */
if (!pa_proplist_gets(pl, PA_PROP_FILTER_HEURISTICS) && pa_proplist_gets(pl, PA_PROP_FILTER_APPLY))
return PA_HOOK_OK;
/* On phone sinks, make sure we're not applying echo cancellation */
if (pa_str_in_list_spaces(pa_proplist_gets(parent_pl, PA_PROP_DEVICE_INTENDED_ROLES), "phone")) {
const char *apply = pa_proplist_gets(pl, PA_PROP_FILTER_APPLY);
if (apply && pa_streq(apply, "echo-cancel")) {
pa_proplist_unset(pl, PA_PROP_FILTER_APPLY);
pa_proplist_unset(pl, PA_PROP_FILTER_HEURISTICS);
}
return PA_HOOK_OK;
}
want = pa_proplist_gets(pl, PA_PROP_FILTER_WANT);
if (want) {
/* There's a filter that we want, ask module-filter-apply to apply it, and remember that we're managing filter.apply */
pa_proplist_sets(pl, PA_PROP_FILTER_APPLY, want);
pa_proplist_sets(pl, PA_PROP_FILTER_HEURISTICS, "1");
}
return PA_HOOK_OK;
}
int pa_sink_input_ext_set_policy_group(struct pa_sink_input *sinp,
const char *group)
{
int ret;
assert(sinp);
if (group)
ret = pa_proplist_sets(sinp->proplist, PA_PROP_POLICY_GROUP, group);
else
ret = pa_proplist_unset(sinp->proplist, PA_PROP_POLICY_GROUP);
return ret;
}
int voice_init_raw_source(struct userdata *u, const char *name) {
pa_source_new_data data;
ENTER();
pa_assert(u);
pa_assert(u->master_source);
pa_source_new_data_init(&data);
data.driver = __FILE__;
data.module = u->module;
pa_source_new_data_set_name(&data, name);
pa_proplist_setf(data.proplist, PA_PROP_DEVICE_DESCRIPTION, "%s source connected to %s", name, u->master_source->name);
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_MASTER_DEVICE, u->master_source->name);
pa_proplist_sets(data.proplist, "module-suspend-on-idle.timeout", "1");
pa_source_new_data_set_sample_spec(&data, &u->hw_mono_sample_spec);
pa_source_new_data_set_channel_map(&data, &u->mono_map);
u->raw_source = pa_source_new(u->core, &data, 0);
pa_source_new_data_done(&data);
if (!u->raw_source) {
pa_log_error("Failed to create source.");
return -1;
}
u->raw_source->parent.process_msg = raw_source_process_msg;
u->raw_source->set_state = raw_source_set_state;
u->raw_source->userdata = u;
u->raw_source->flags = 0; // PA_SOURCE_CAN_SUSPEND
pa_source_set_asyncmsgq(u->raw_source, u->master_source->asyncmsgq);
pa_source_set_rtpoll(u->raw_source, u->master_source->rtpoll);
return 0;
}
PulseAudioSystem::PulseAudioSystem() {
pasInput = pasOutput = pasSpeaker = NULL;
bSourceDone=bSinkDone=bServerDone = false;
iDelayCache = 0;
bPositionalCache = false;
bAttenuating = false;
iRemainingOperations = 0;
bPulseIsGood = false;
iSinkId = -1;
pam = pa_threaded_mainloop_new();
pa_mainloop_api *api = pa_threaded_mainloop_get_api(pam);
pa_proplist *proplist;
proplist = pa_proplist_new();
pa_proplist_sets(proplist, PA_PROP_APPLICATION_NAME, "Mumble");
pa_proplist_sets(proplist, PA_PROP_APPLICATION_ID, "net.sourceforge.mumble.mumble");
pa_proplist_sets(proplist, PA_PROP_APPLICATION_ICON_NAME, "mumble");
pa_proplist_sets(proplist, PA_PROP_MEDIA_ROLE, "game");
pacContext = pa_context_new_with_proplist(api, NULL, proplist);
pa_proplist_free(proplist);
pa_context_set_subscribe_callback(pacContext, subscribe_callback, this);
pa_context_set_state_callback(pacContext, context_state_callback, this);
pa_context_connect(pacContext, NULL, PA_CONTEXT_NOAUTOSPAWN, NULL);
pade = api->defer_new(api, defer_event_callback, this);
api->defer_enable(pade, false);
pa_threaded_mainloop_start(pam);
bRunning = true;
}
void pa_format_info_set_prop_int_range(pa_format_info *f, const char *key, int min, int max) {
json_object *o;
pa_assert(f);
pa_assert(key);
o = json_object_new_object();
json_object_object_add(o, PA_JSON_MIN_KEY, json_object_new_int(min));
json_object_object_add(o, PA_JSON_MAX_KEY, json_object_new_int(max));
pa_proplist_sets(f->plist, key, json_object_to_json_string(o));
json_object_put(o);
}
static pa_scache_entry* scache_add_item(pa_core *c, const char *name) {
pa_scache_entry *e;
pa_assert(c);
pa_assert(name);
if ((e = pa_namereg_get(c, name, PA_NAMEREG_SAMPLE))) {
if (e->memchunk.memblock)
pa_memblock_unref(e->memchunk.memblock);
pa_xfree(e->filename);
pa_proplist_clear(e->proplist);
pa_assert(e->core == c);
pa_subscription_post(c, PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE|PA_SUBSCRIPTION_EVENT_CHANGE, e->index);
} else {
e = pa_xnew(pa_scache_entry, 1);
if (!pa_namereg_register(c, name, PA_NAMEREG_SAMPLE, e, TRUE)) {
pa_xfree(e);
return NULL;
}
e->name = pa_xstrdup(name);
e->core = c;
e->proplist = pa_proplist_new();
pa_idxset_put(c->scache, e, &e->index);
pa_subscription_post(c, PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE|PA_SUBSCRIPTION_EVENT_NEW, e->index);
}
e->last_used_time = 0;
pa_memchunk_reset(&e->memchunk);
e->filename = NULL;
e->lazy = FALSE;
e->last_used_time = 0;
pa_sample_spec_init(&e->sample_spec);
pa_channel_map_init(&e->channel_map);
pa_cvolume_init(&e->volume);
e->volume_is_set = FALSE;
pa_proplist_sets(e->proplist, PA_PROP_MEDIA_ROLE, "event");
return e;
}
void pa_format_info_set_prop_string_array(pa_format_info *f, const char *key, const char **values, int n_values) {
json_object *o;
int i;
pa_assert(f);
pa_assert(key);
o = json_object_new_array();
for (i = 0; i < n_values; i++)
json_object_array_add(o, json_object_new_string(values[i]));
pa_proplist_sets(f->plist, key, json_object_to_json_string(o));
json_object_put(o);
}
/* 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);
}
static void source_set_name(pa_modargs *ma, pa_source_new_data *data, const char *module_id) {
const char *tmp;
pa_assert(ma);
pa_assert(data);
if ((tmp = pa_modargs_get_value(ma, "source_name", NULL))) {
pa_source_new_data_set_name(data, tmp);
data->namereg_fail = true;
pa_proplist_sets(data->proplist, PA_PROP_DEVICE_DESCRIPTION, "Droid source");
} else {
char *tt;
pa_assert(module_id);
tt = pa_sprintf_malloc("source.%s", module_id);
pa_source_new_data_set_name(data, tt);
pa_xfree(tt);
data->namereg_fail = false;
pa_proplist_setf(data->proplist, PA_PROP_DEVICE_DESCRIPTION, "Droid source %s", module_id);
}
}
