PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("ALSA Card");
PA_MODULE_VERSION(PACKAGE_VERSION);
-PA_MODULE_LOAD_ONCE(FALSE);
+PA_MODULE_LOAD_ONCE(false);
PA_MODULE_USAGE(
"name=<name for the card/sink/source, to be prefixed> "
"card_name=<name for the card> "
pa_alsa_profile_set *profile_set;
/* ucm stuffs */
- pa_bool_t use_ucm;
+ bool use_ucm;
pa_alsa_ucm_config ucm;
/* hooks for modifier action */
PA_IDXSET_FOREACH(m, ap->output_mappings, idx) {
if (u->use_ucm)
- pa_alsa_ucm_add_ports_combination(NULL, &m->ucm_context, TRUE, ports, cp, u->core);
+ pa_alsa_ucm_add_ports_combination(NULL, &m->ucm_context, true, ports, cp, u->core);
else
pa_alsa_path_set_add_ports(m->output_path_set, cp, ports, NULL, u->core);
if (m->channel_map.channels > cp->max_sink_channels)
PA_IDXSET_FOREACH(m, ap->input_mappings, idx) {
if (u->use_ucm)
- pa_alsa_ucm_add_ports_combination(NULL, &m->ucm_context, FALSE, ports, cp, u->core);
+ pa_alsa_ucm_add_ports_combination(NULL, &m->ucm_context, false, ports, cp, u->core);
else
pa_alsa_path_set_add_ports(m->input_path_set, cp, ports, NULL, u->core);
if (m->channel_map.channels > cp->max_source_channels)
uint32_t idx;
pa_alsa_mapping *am;
pa_queue *sink_inputs = NULL, *source_outputs = NULL;
+ int ret = 0;
pa_assert(c);
pa_assert(new_profile);
/* if UCM is available for this card then update the verb */
if (u->use_ucm) {
if (pa_alsa_ucm_set_profile(&u->ucm, nd->profile ? nd->profile->name : NULL,
- od->profile ? od->profile->name : NULL) < 0)
- return -1;
+ od->profile ? od->profile->name : NULL) < 0) {
+ ret = -1;
+ goto finish;
+ }
}
if (nd->profile && nd->profile->output_mappings)
am->sink = pa_alsa_sink_new(c->module, u->modargs, __FILE__, c, am);
if (sink_inputs && am->sink) {
- pa_sink_move_all_finish(am->sink, sink_inputs, FALSE);
+ pa_sink_move_all_finish(am->sink, sink_inputs, false);
sink_inputs = NULL;
}
}
am->source = pa_alsa_source_new(c->module, u->modargs, __FILE__, c, am);
if (source_outputs && am->source) {
- pa_source_move_all_finish(am->source, source_outputs, FALSE);
+ pa_source_move_all_finish(am->source, source_outputs, false);
source_outputs = NULL;
}
}
+finish:
if (sink_inputs)
pa_sink_move_all_fail(sink_inputs);
if (source_outputs)
pa_source_move_all_fail(source_outputs);
- return 0;
+ return ret;
}
static void init_profile(struct userdata *u) {
am->source = pa_alsa_source_new(u->module, u->modargs, __FILE__, u->card, am);
}
-static void report_port_state(pa_device_port *p, struct userdata *u)
-{
+static void report_port_state(pa_device_port *p, struct userdata *u) {
void *state;
pa_alsa_jack *jack;
- pa_port_available_t pa = PA_PORT_AVAILABLE_UNKNOWN;
+ pa_available_t pa = PA_AVAILABLE_UNKNOWN;
pa_device_port *port;
PA_HASHMAP_FOREACH(jack, u->jacks, state) {
- pa_port_available_t cpa;
+ pa_available_t cpa;
if (u->use_ucm)
port = pa_hashmap_get(u->card->ports, jack->name);
cpa = jack->plugged_in ? jack->state_plugged : jack->state_unplugged;
/* "Yes" and "no" trumphs "unknown" if we have more than one jack */
- if (cpa == PA_PORT_AVAILABLE_UNKNOWN)
+ if (cpa == PA_AVAILABLE_UNKNOWN)
continue;
- if ((cpa == PA_PORT_AVAILABLE_NO && pa == PA_PORT_AVAILABLE_YES) ||
- (pa == PA_PORT_AVAILABLE_NO && cpa == PA_PORT_AVAILABLE_YES))
+ if ((cpa == PA_AVAILABLE_NO && pa == PA_AVAILABLE_YES) ||
+ (pa == PA_AVAILABLE_NO && cpa == PA_AVAILABLE_YES))
pa_log_warn("Availability of port '%s' is inconsistent!", p->name);
else
pa = cpa;
pa_device_port_set_available(p, pa);
}
-static int report_jack_state(snd_hctl_elem_t *elem, unsigned int mask)
-{
+static int report_jack_state(snd_hctl_elem_t *elem, unsigned int mask) {
struct userdata *u = snd_hctl_elem_get_callback_private(elem);
snd_ctl_elem_value_t *elem_value;
- pa_bool_t plugged_in;
+ bool plugged_in;
void *state;
pa_alsa_jack *jack;
pa_device_port *port;
pa_assert(port);
}
else {
- pa_assert(jack->path && jack->path->port);
- port = jack->path->port;
+ pa_assert(jack->path);
+ pa_assert_se(port = jack->path->port);
}
report_port_state(port, u);
}
return 0;
}
+static pa_device_port* find_port_with_eld_device(pa_hashmap *ports, int device) {
+ void *state;
+ pa_device_port *p;
+
+ PA_HASHMAP_FOREACH(p, ports, state) {
+ pa_alsa_port_data *data = PA_DEVICE_PORT_DATA(p);
+ pa_assert(data->path);
+ if (device == data->path->eld_device)
+ return p;
+ }
+ return NULL;
+}
+
+static int hdmi_eld_changed(snd_hctl_elem_t *elem, unsigned int mask) {
+ struct userdata *u = snd_hctl_elem_get_callback_private(elem);
+ int device = snd_hctl_elem_get_device(elem);
+ const char *old_monitor_name;
+ pa_device_port *p;
+ pa_hdmi_eld eld;
+ bool changed = false;
+
+ if (mask == SND_CTL_EVENT_MASK_REMOVE)
+ return 0;
+
+ p = find_port_with_eld_device(u->card->ports, device);
+ if (p == NULL) {
+ pa_log_error("Invalid device changed in ALSA: %d", device);
+ return 0;
+ }
+
+ if (pa_alsa_get_hdmi_eld(u->hctl_handle, device, &eld) < 0)
+ memset(&eld, 0, sizeof(eld));
+
+ old_monitor_name = pa_proplist_gets(p->proplist, PA_PROP_DEVICE_PRODUCT_NAME);
+ if (eld.monitor_name[0] == '\0') {
+ changed |= old_monitor_name != NULL;
+ pa_proplist_unset(p->proplist, PA_PROP_DEVICE_PRODUCT_NAME);
+ } else {
+ changed |= (old_monitor_name == NULL) || (strcmp(old_monitor_name, eld.monitor_name) != 0);
+ pa_proplist_sets(p->proplist, PA_PROP_DEVICE_PRODUCT_NAME, eld.monitor_name);
+ }
+
+ if (changed && mask != 0)
+ pa_subscription_post(u->core, PA_SUBSCRIPTION_EVENT_CARD|PA_SUBSCRIPTION_EVENT_CHANGE, u->card->index);
+
+ return 0;
+}
+
+static void init_eld_ctls(struct userdata *u) {
+ void *state;
+ pa_device_port *port;
+
+ if (!u->hctl_handle)
+ return;
+
+ PA_HASHMAP_FOREACH(port, u->card->ports, state) {
+ pa_alsa_port_data *data = PA_DEVICE_PORT_DATA(port);
+ snd_hctl_elem_t* hctl_elem;
+ int device;
+
+ pa_assert(data->path);
+ device = data->path->eld_device;
+ if (device < 0)
+ continue;
+
+ hctl_elem = pa_alsa_find_eld_ctl(u->hctl_handle, device);
+ if (!hctl_elem) {
+ pa_log_debug("No ELD device found for port %s.", port->name);
+ continue;
+ }
+
+ snd_hctl_elem_set_callback_private(hctl_elem, u);
+ snd_hctl_elem_set_callback(hctl_elem, hdmi_eld_changed);
+ hdmi_eld_changed(hctl_elem, 0);
+ }
+}
+
static void init_jacks(struct userdata *u) {
void *state;
pa_alsa_path* path;
jack->hctl_elem = pa_alsa_find_jack(u->hctl_handle, jack->alsa_name);
if (!jack->hctl_elem) {
pa_log_warn("Jack '%s' seems to have disappeared.", jack->alsa_name);
- jack->has_control = FALSE;
+ jack->has_control = false;
continue;
}
snd_hctl_elem_set_callback_private(jack->hctl_elem, u);
if ((n = pa_modargs_get_value(ma, "card_name", NULL))) {
pa_card_new_data_set_name(data, n);
- data->namereg_fail = TRUE;
+ data->namereg_fail = true;
return;
}
if ((n = pa_modargs_get_value(ma, "name", NULL)))
- data->namereg_fail = TRUE;
+ data->namereg_fail = true;
else {
n = device_id;
- data->namereg_fail = FALSE;
+ data->namereg_fail = false;
}
t = pa_sprintf_malloc("alsa_card.%s", n);
int pa__init(pa_module *m) {
pa_card_new_data data;
- pa_modargs *ma;
- pa_bool_t ignore_dB = FALSE;
+ bool ignore_dB = false;
struct userdata *u;
pa_reserve_wrapper *reserve = NULL;
const char *description;
const char *profile = NULL;
char *fn = NULL;
- pa_bool_t namereg_fail = FALSE;
+ bool namereg_fail = false;
pa_alsa_refcnt_inc();
pa_assert(m);
- if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
- pa_log("Failed to parse module arguments");
- goto fail;
- }
-
- if (pa_modargs_get_value_boolean(ma, "ignore_dB", &ignore_dB) < 0) {
- pa_log("Failed to parse ignore_dB argument.");
- goto fail;
- }
-
m->userdata = u = pa_xnew0(struct userdata, 1);
u->core = m->core;
u->module = m;
- u->device_id = pa_xstrdup(pa_modargs_get_value(ma, "device_id", DEFAULT_DEVICE_ID));
- u->modargs = ma;
-
- u->use_ucm = TRUE;
+ u->use_ucm = true;
u->ucm.core = m->core;
+ if (!(u->modargs = pa_modargs_new(m->argument, valid_modargs))) {
+ pa_log("Failed to parse module arguments.");
+ goto fail;
+ }
+
+ u->device_id = pa_xstrdup(pa_modargs_get_value(u->modargs, "device_id", DEFAULT_DEVICE_ID));
+
if ((u->alsa_card_index = snd_card_get_index(u->device_id)) < 0) {
pa_log("Card '%s' doesn't exist: %s", u->device_id, pa_alsa_strerror(u->alsa_card_index));
goto fail;
}
+ if (pa_modargs_get_value_boolean(u->modargs, "ignore_dB", &ignore_dB) < 0) {
+ pa_log("Failed to parse ignore_dB argument.");
+ goto fail;
+ }
+
if (!pa_in_system_mode()) {
char *rname;
}
}
- pa_modargs_get_value_boolean(ma, "use_ucm", &u->use_ucm);
+ pa_modargs_get_value_boolean(u->modargs, "use_ucm", &u->use_ucm);
if (u->use_ucm && !pa_alsa_ucm_query_profiles(&u->ucm, u->alsa_card_index)) {
pa_log_info("Found UCM profiles");
(pa_hook_cb_t) source_output_unlink_hook_callback, u);
}
else {
- u->use_ucm = FALSE;
+ u->use_ucm = false;
#ifdef HAVE_UDEV
fn = pa_udev_get_property(u->alsa_card_index, "PULSE_PROFILE_SET");
#endif
- if (pa_modargs_get_value(ma, "profile_set", NULL)) {
+ if (pa_modargs_get_value(u->modargs, "profile_set", NULL)) {
pa_xfree(fn);
- fn = pa_xstrdup(pa_modargs_get_value(ma, "profile_set", NULL));
+ fn = pa_xstrdup(pa_modargs_get_value(u->modargs, "profile_set", NULL));
}
u->profile_set = pa_alsa_profile_set_new(fn, &u->core->default_channel_map);
pa_xfree(fn);
}
- u->profile_set->ignore_dB = ignore_dB;
-
if (!u->profile_set)
goto fail;
+ u->profile_set->ignore_dB = ignore_dB;
+
pa_alsa_profile_set_probe(u->profile_set, u->device_id, &m->core->default_sample_spec, m->core->default_n_fragments, m->core->default_fragment_size_msec);
pa_alsa_profile_set_dump(u->profile_set);
pa_alsa_init_proplist_card(m->core, data.proplist, u->alsa_card_index);
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->device_id);
- pa_alsa_init_description(data.proplist);
- set_card_name(&data, ma, u->device_id);
+ pa_alsa_init_description(data.proplist, NULL);
+ set_card_name(&data, u->modargs, u->device_id);
/* We need to give pa_modargs_get_value_boolean() a pointer to a local
* variable instead of using &data.namereg_fail directly, because
* data.namereg_fail is a bitfield and taking the address of a bitfield
* variable is impossible. */
namereg_fail = data.namereg_fail;
- if (pa_modargs_get_value_boolean(ma, "namereg_fail", &namereg_fail) < 0) {
+ if (pa_modargs_get_value_boolean(u->modargs, "namereg_fail", &namereg_fail) < 0) {
pa_log("Failed to parse namereg_fail argument.");
pa_card_new_data_done(&data);
goto fail;
add_disabled_profile(data.profiles);
- if (pa_modargs_get_proplist(ma, "card_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
+ if (pa_modargs_get_proplist(u->modargs, "card_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
pa_log("Invalid properties");
pa_card_new_data_done(&data);
goto fail;
}
- if ((profile = pa_modargs_get_value(ma, "profile", NULL)))
+ if ((profile = pa_modargs_get_value(u->modargs, "profile", NULL)))
pa_card_new_data_set_profile(&data, profile);
u->card = pa_card_new(m->core, &data);
u->card->userdata = u;
u->card->set_profile = card_set_profile;
- init_profile(u);
init_jacks(u);
+ init_profile(u);
+ init_eld_ctls(u);
if (reserve)
pa_reserve_wrapper_unref(reserve);
if (u->mixer_handle)
snd_mixer_close(u->mixer_handle);
if (u->jacks)
- pa_hashmap_free(u->jacks, NULL, NULL);
+ pa_hashmap_free(u->jacks);
- if (u->card && u->card->sinks) {
- pa_sink *s;
+ if (u->card && u->card->sinks)
+ pa_idxset_remove_all(u->card->sinks, (pa_free_cb_t) pa_alsa_sink_free);
- while ((s = pa_idxset_steal_first(u->card->sinks, NULL)))
- pa_alsa_sink_free(s);
- }
-
- if (u->card && u->card->sources) {
- pa_source *s;
-
- while ((s = pa_idxset_steal_first(u->card->sources, NULL)))
- pa_alsa_source_free(s);
- }
+ if (u->card && u->card->sources)
+ pa_idxset_remove_all(u->card->sources, (pa_free_cb_t) pa_alsa_source_free);
if (u->card)
pa_card_free(u->card);