mirror of
https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git
synced 2025-11-03 09:01:50 -05:00
alsa: rework mixer logic
Completely rework mixer logic. This now allows controlling a full set of elements from a single sink's volume slider/mute button. This also introduces sink and source "ports" that can be used to choose different input or output ports with the UI. (i.e. "mic"/"line-in" or "speaker"/"headphones". The mixer paths and device maps are now configered in external configuration files and can be tweaked as necessary.
This commit is contained in:
Lennart Poettering
parent
e9c70ac41b
commit
31575f7766
54 changed files with 7029 additions and 1694 deletions
|
|
@ -80,11 +80,9 @@ struct userdata {
|
|||
|
||||
pa_alsa_fdlist *mixer_fdl;
|
||||
snd_mixer_t *mixer_handle;
|
||||
snd_mixer_elem_t *mixer_elem;
|
||||
long hw_volume_max, hw_volume_min;
|
||||
long hw_dB_max, hw_dB_min;
|
||||
pa_bool_t hw_dB_supported:1;
|
||||
pa_bool_t mixer_seperate_channels:1;
|
||||
pa_alsa_path_set *mixer_path_set;
|
||||
pa_alsa_path *mixer_path;
|
||||
|
||||
pa_cvolume hardware_volume;
|
||||
|
||||
size_t
|
||||
|
|
@ -100,7 +98,8 @@ struct userdata {
|
|||
unsigned nfragments;
|
||||
pa_memchunk memchunk;
|
||||
|
||||
char *device_name;
|
||||
char *device_name; /* name of the PCM device */
|
||||
char *control_device; /* name of the control device */
|
||||
|
||||
pa_bool_t use_mmap:1, use_tsched:1;
|
||||
|
||||
|
|
@ -991,191 +990,58 @@ static int mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
static pa_volume_t from_alsa_volume(struct userdata *u, long alsa_vol) {
|
||||
|
||||
return (pa_volume_t) round(((double) (alsa_vol - u->hw_volume_min) * PA_VOLUME_NORM) /
|
||||
(double) (u->hw_volume_max - u->hw_volume_min));
|
||||
}
|
||||
|
||||
static long to_alsa_volume(struct userdata *u, pa_volume_t vol) {
|
||||
long alsa_vol;
|
||||
|
||||
alsa_vol = (long) round(((double) vol * (double) (u->hw_volume_max - u->hw_volume_min))
|
||||
/ PA_VOLUME_NORM) + u->hw_volume_min;
|
||||
|
||||
return PA_CLAMP_UNLIKELY(alsa_vol, u->hw_volume_min, u->hw_volume_max);
|
||||
}
|
||||
|
||||
static void sink_get_volume_cb(pa_sink *s) {
|
||||
struct userdata *u = s->userdata;
|
||||
int err;
|
||||
unsigned i;
|
||||
pa_cvolume r;
|
||||
char t[PA_CVOLUME_SNPRINT_MAX];
|
||||
|
||||
pa_assert(u);
|
||||
pa_assert(u->mixer_elem);
|
||||
pa_assert(u->mixer_path);
|
||||
pa_assert(u->mixer_handle);
|
||||
|
||||
if (u->mixer_seperate_channels) {
|
||||
if (pa_alsa_path_get_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
|
||||
return;
|
||||
|
||||
r.channels = s->sample_spec.channels;
|
||||
|
||||
for (i = 0; i < s->sample_spec.channels; i++) {
|
||||
long alsa_vol;
|
||||
|
||||
if (u->hw_dB_supported) {
|
||||
|
||||
if ((err = snd_mixer_selem_get_playback_dB(u->mixer_elem, u->mixer_map[i], &alsa_vol)) < 0)
|
||||
goto fail;
|
||||
|
||||
#ifdef HAVE_VALGRIND_MEMCHECK_H
|
||||
VALGRIND_MAKE_MEM_DEFINED(&alsa_vol, sizeof(alsa_vol));
|
||||
#endif
|
||||
|
||||
r.values[i] = pa_sw_volume_from_dB((double) (alsa_vol - u->hw_dB_max) / 100.0);
|
||||
} else {
|
||||
|
||||
if ((err = snd_mixer_selem_get_playback_volume(u->mixer_elem, u->mixer_map[i], &alsa_vol)) < 0)
|
||||
goto fail;
|
||||
|
||||
r.values[i] = from_alsa_volume(u, alsa_vol);
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
long alsa_vol;
|
||||
|
||||
if (u->hw_dB_supported) {
|
||||
|
||||
if ((err = snd_mixer_selem_get_playback_dB(u->mixer_elem, SND_MIXER_SCHN_MONO, &alsa_vol)) < 0)
|
||||
goto fail;
|
||||
|
||||
#ifdef HAVE_VALGRIND_MEMCHECK_H
|
||||
VALGRIND_MAKE_MEM_DEFINED(&alsa_vol, sizeof(alsa_vol));
|
||||
#endif
|
||||
|
||||
pa_cvolume_set(&r, s->sample_spec.channels, pa_sw_volume_from_dB((double) (alsa_vol - u->hw_dB_max) / 100.0));
|
||||
|
||||
} else {
|
||||
|
||||
if ((err = snd_mixer_selem_get_playback_volume(u->mixer_elem, SND_MIXER_SCHN_MONO, &alsa_vol)) < 0)
|
||||
goto fail;
|
||||
|
||||
pa_cvolume_set(&r, s->sample_spec.channels, from_alsa_volume(u, alsa_vol));
|
||||
}
|
||||
}
|
||||
/* Shift down by the base volume, so that 0dB becomes maximum volume */
|
||||
pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
|
||||
|
||||
pa_log_debug("Read hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &r));
|
||||
|
||||
if (!pa_cvolume_equal(&u->hardware_volume, &r)) {
|
||||
if (pa_cvolume_equal(&u->hardware_volume, &r))
|
||||
return;
|
||||
|
||||
s->virtual_volume = u->hardware_volume = r;
|
||||
s->virtual_volume = u->hardware_volume = r;
|
||||
|
||||
if (u->hw_dB_supported) {
|
||||
pa_cvolume reset;
|
||||
if (u->mixer_path->has_dB) {
|
||||
pa_cvolume reset;
|
||||
|
||||
/* Hmm, so the hardware volume changed, let's reset our software volume */
|
||||
pa_cvolume_reset(&reset, s->sample_spec.channels);
|
||||
pa_sink_set_soft_volume(s, &reset);
|
||||
}
|
||||
/* Hmm, so the hardware volume changed, let's reset our software volume */
|
||||
pa_cvolume_reset(&reset, s->sample_spec.channels);
|
||||
pa_sink_set_soft_volume(s, &reset);
|
||||
}
|
||||
|
||||
return;
|
||||
|
||||
fail:
|
||||
pa_log_error("Unable to read volume: %s", pa_alsa_strerror(err));
|
||||
}
|
||||
|
||||
static void sink_set_volume_cb(pa_sink *s) {
|
||||
struct userdata *u = s->userdata;
|
||||
int err;
|
||||
unsigned i;
|
||||
pa_cvolume r;
|
||||
char t[PA_CVOLUME_SNPRINT_MAX];
|
||||
|
||||
pa_assert(u);
|
||||
pa_assert(u->mixer_elem);
|
||||
pa_assert(u->mixer_path);
|
||||
pa_assert(u->mixer_handle);
|
||||
|
||||
if (u->mixer_seperate_channels) {
|
||||
/* Shift up by the base volume */
|
||||
pa_sw_cvolume_divide_scalar(&r, &s->virtual_volume, s->base_volume);
|
||||
|
||||
r.channels = s->sample_spec.channels;
|
||||
if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
|
||||
return;
|
||||
|
||||
for (i = 0; i < s->sample_spec.channels; i++) {
|
||||
long alsa_vol;
|
||||
pa_volume_t vol;
|
||||
|
||||
vol = s->virtual_volume.values[i];
|
||||
|
||||
if (u->hw_dB_supported) {
|
||||
|
||||
alsa_vol = (long) (pa_sw_volume_to_dB(vol) * 100);
|
||||
alsa_vol += u->hw_dB_max;
|
||||
alsa_vol = PA_CLAMP_UNLIKELY(alsa_vol, u->hw_dB_min, u->hw_dB_max);
|
||||
|
||||
if ((err = snd_mixer_selem_set_playback_dB(u->mixer_elem, u->mixer_map[i], alsa_vol, 1)) < 0)
|
||||
goto fail;
|
||||
|
||||
if ((err = snd_mixer_selem_get_playback_dB(u->mixer_elem, u->mixer_map[i], &alsa_vol)) < 0)
|
||||
goto fail;
|
||||
|
||||
#ifdef HAVE_VALGRIND_MEMCHECK_H
|
||||
VALGRIND_MAKE_MEM_DEFINED(&alsa_vol, sizeof(alsa_vol));
|
||||
#endif
|
||||
|
||||
r.values[i] = pa_sw_volume_from_dB((double) (alsa_vol - u->hw_dB_max) / 100.0);
|
||||
|
||||
} else {
|
||||
alsa_vol = to_alsa_volume(u, vol);
|
||||
|
||||
if ((err = snd_mixer_selem_set_playback_volume(u->mixer_elem, u->mixer_map[i], alsa_vol)) < 0)
|
||||
goto fail;
|
||||
|
||||
if ((err = snd_mixer_selem_get_playback_volume(u->mixer_elem, u->mixer_map[i], &alsa_vol)) < 0)
|
||||
goto fail;
|
||||
|
||||
r.values[i] = from_alsa_volume(u, alsa_vol);
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
pa_volume_t vol;
|
||||
long alsa_vol;
|
||||
|
||||
vol = pa_cvolume_max(&s->virtual_volume);
|
||||
|
||||
if (u->hw_dB_supported) {
|
||||
alsa_vol = (long) (pa_sw_volume_to_dB(vol) * 100);
|
||||
alsa_vol += u->hw_dB_max;
|
||||
alsa_vol = PA_CLAMP_UNLIKELY(alsa_vol, u->hw_dB_min, u->hw_dB_max);
|
||||
|
||||
if ((err = snd_mixer_selem_set_playback_dB_all(u->mixer_elem, alsa_vol, 1)) < 0)
|
||||
goto fail;
|
||||
|
||||
if ((err = snd_mixer_selem_get_playback_dB(u->mixer_elem, SND_MIXER_SCHN_MONO, &alsa_vol)) < 0)
|
||||
goto fail;
|
||||
|
||||
#ifdef HAVE_VALGRIND_MEMCHECK_H
|
||||
VALGRIND_MAKE_MEM_DEFINED(&alsa_vol, sizeof(alsa_vol));
|
||||
#endif
|
||||
|
||||
pa_cvolume_set(&r, s->sample_spec.channels, pa_sw_volume_from_dB((double) (alsa_vol - u->hw_dB_max) / 100.0));
|
||||
|
||||
} else {
|
||||
alsa_vol = to_alsa_volume(u, vol);
|
||||
|
||||
if ((err = snd_mixer_selem_set_playback_volume_all(u->mixer_elem, alsa_vol)) < 0)
|
||||
goto fail;
|
||||
|
||||
if ((err = snd_mixer_selem_get_playback_volume(u->mixer_elem, SND_MIXER_SCHN_MONO, &alsa_vol)) < 0)
|
||||
goto fail;
|
||||
|
||||
pa_cvolume_set(&r, s->sample_spec.channels, from_alsa_volume(u, alsa_vol));
|
||||
}
|
||||
}
|
||||
/* Shift down by the base volume, so that 0dB becomes maximum volume */
|
||||
pa_sw_cvolume_multiply_scalar(&r, &r, s->base_volume);
|
||||
|
||||
u->hardware_volume = r;
|
||||
|
||||
if (u->hw_dB_supported) {
|
||||
char t[PA_CVOLUME_SNPRINT_MAX];
|
||||
if (u->mixer_path->has_dB) {
|
||||
|
||||
/* Match exactly what the user requested by software */
|
||||
pa_sw_cvolume_divide(&s->soft_volume, &s->virtual_volume, &u->hardware_volume);
|
||||
|
|
@ -1184,45 +1050,75 @@ static void sink_set_volume_cb(pa_sink *s) {
|
|||
pa_log_debug("Got hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &u->hardware_volume));
|
||||
pa_log_debug("Calculated software volume: %s", pa_cvolume_snprint(t, sizeof(t), &s->soft_volume));
|
||||
|
||||
} else
|
||||
} else {
|
||||
pa_log_debug("Wrote hardware volume: %s", pa_cvolume_snprint(t, sizeof(t), &r));
|
||||
|
||||
/* We can't match exactly what the user requested, hence let's
|
||||
* at least tell the user about it */
|
||||
|
||||
s->virtual_volume = r;
|
||||
|
||||
return;
|
||||
|
||||
fail:
|
||||
pa_log_error("Unable to set volume: %s", pa_alsa_strerror(err));
|
||||
}
|
||||
}
|
||||
|
||||
static void sink_get_mute_cb(pa_sink *s) {
|
||||
struct userdata *u = s->userdata;
|
||||
int err, sw = 0;
|
||||
pa_bool_t b;
|
||||
|
||||
pa_assert(u);
|
||||
pa_assert(u->mixer_elem);
|
||||
pa_assert(u->mixer_path);
|
||||
pa_assert(u->mixer_handle);
|
||||
|
||||
if ((err = snd_mixer_selem_get_playback_switch(u->mixer_elem, 0, &sw)) < 0) {
|
||||
pa_log_error("Unable to get switch: %s", pa_alsa_strerror(err));
|
||||
if (pa_alsa_path_get_mute(u->mixer_path, u->mixer_handle, &b) < 0)
|
||||
return;
|
||||
}
|
||||
|
||||
s->muted = !sw;
|
||||
s->muted = b;
|
||||
}
|
||||
|
||||
static void sink_set_mute_cb(pa_sink *s) {
|
||||
struct userdata *u = s->userdata;
|
||||
int err;
|
||||
|
||||
pa_assert(u);
|
||||
pa_assert(u->mixer_elem);
|
||||
pa_assert(u->mixer_path);
|
||||
pa_assert(u->mixer_handle);
|
||||
|
||||
if ((err = snd_mixer_selem_set_playback_switch_all(u->mixer_elem, !s->muted)) < 0) {
|
||||
pa_log_error("Unable to set switch: %s", pa_alsa_strerror(err));
|
||||
return;
|
||||
pa_alsa_path_set_mute(u->mixer_path, u->mixer_handle, s->muted);
|
||||
}
|
||||
|
||||
static int sink_set_port_cb(pa_sink *s, pa_device_port *p) {
|
||||
struct userdata *u = s->userdata;
|
||||
pa_alsa_port_data *data;
|
||||
|
||||
pa_assert(u);
|
||||
pa_assert(p);
|
||||
pa_assert(u->mixer_handle);
|
||||
|
||||
data = PA_DEVICE_PORT_DATA(p);
|
||||
|
||||
pa_assert_se(u->mixer_path = data->path);
|
||||
pa_alsa_path_select(u->mixer_path, u->mixer_handle);
|
||||
|
||||
if (u->mixer_path->has_volume && u->mixer_path->has_dB) {
|
||||
s->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
|
||||
s->n_volume_steps = PA_VOLUME_NORM+1;
|
||||
|
||||
if (u->mixer_path->max_dB > 0.0)
|
||||
pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(s->base_volume));
|
||||
else
|
||||
pa_log_info("No particular base volume set, fixing to 0 dB");
|
||||
} else {
|
||||
s->base_volume = PA_VOLUME_NORM;
|
||||
s->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
|
||||
}
|
||||
|
||||
if (data->setting)
|
||||
pa_alsa_setting_select(data->setting, u->mixer_handle);
|
||||
|
||||
if (s->set_mute)
|
||||
s->set_mute(s);
|
||||
if (s->set_volume)
|
||||
s->set_volume(s);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void sink_update_requested_latency_cb(pa_sink *s) {
|
||||
|
|
@ -1465,77 +1361,127 @@ static void set_sink_name(pa_sink_new_data *data, pa_modargs *ma, const char *de
|
|||
pa_xfree(t);
|
||||
}
|
||||
|
||||
static void find_mixer(struct userdata *u, pa_alsa_mapping *mapping, const char *element, pa_bool_t ignore_dB) {
|
||||
|
||||
if (!mapping && !element)
|
||||
return;
|
||||
|
||||
if (!(u->mixer_handle = pa_alsa_open_mixer_for_pcm(u->pcm_handle, &u->control_device))) {
|
||||
pa_log_info("Failed to find a working mixer device.");
|
||||
return;
|
||||
}
|
||||
|
||||
if (element) {
|
||||
|
||||
if (!(u->mixer_path = pa_alsa_path_synthesize(element, PA_ALSA_DIRECTION_OUTPUT)))
|
||||
goto fail;
|
||||
|
||||
if (pa_alsa_path_probe(u->mixer_path, u->mixer_handle, ignore_dB) < 0)
|
||||
goto fail;
|
||||
|
||||
pa_log_debug("Probed mixer path %s:", u->mixer_path->name);
|
||||
pa_alsa_path_dump(u->mixer_path);
|
||||
} else {
|
||||
|
||||
if (!(u->mixer_path_set = pa_alsa_path_set_new(mapping, PA_ALSA_DIRECTION_OUTPUT)))
|
||||
goto fail;
|
||||
|
||||
pa_alsa_path_set_probe(u->mixer_path_set, u->mixer_handle, ignore_dB);
|
||||
|
||||
pa_log_debug("Probed mixer paths:");
|
||||
pa_alsa_path_set_dump(u->mixer_path_set);
|
||||
}
|
||||
|
||||
return;
|
||||
|
||||
fail:
|
||||
|
||||
if (u->mixer_path_set) {
|
||||
pa_alsa_path_set_free(u->mixer_path_set);
|
||||
u->mixer_path_set = NULL;
|
||||
} else if (u->mixer_path) {
|
||||
pa_alsa_path_free(u->mixer_path);
|
||||
u->mixer_path = NULL;
|
||||
}
|
||||
|
||||
if (u->mixer_handle) {
|
||||
snd_mixer_close(u->mixer_handle);
|
||||
u->mixer_handle = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) {
|
||||
pa_assert(u);
|
||||
|
||||
if (!u->mixer_handle)
|
||||
return 0;
|
||||
|
||||
pa_assert(u->mixer_elem);
|
||||
if (u->sink->active_port) {
|
||||
pa_alsa_port_data *data;
|
||||
|
||||
if (snd_mixer_selem_has_playback_volume(u->mixer_elem)) {
|
||||
pa_bool_t suitable = FALSE;
|
||||
/* We have a list of supported paths, so let's activate the
|
||||
* one that has been chosen as active */
|
||||
|
||||
if (snd_mixer_selem_get_playback_volume_range(u->mixer_elem, &u->hw_volume_min, &u->hw_volume_max) < 0)
|
||||
pa_log_info("Failed to get volume range. Falling back to software volume control.");
|
||||
else if (u->hw_volume_min >= u->hw_volume_max)
|
||||
pa_log_warn("Your kernel driver is broken: it reports a volume range from %li to %li which makes no sense.", u->hw_volume_min, u->hw_volume_max);
|
||||
else {
|
||||
pa_log_info("Volume ranges from %li to %li.", u->hw_volume_min, u->hw_volume_max);
|
||||
suitable = TRUE;
|
||||
}
|
||||
data = PA_DEVICE_PORT_DATA(u->sink->active_port);
|
||||
u->mixer_path = data->path;
|
||||
|
||||
if (suitable) {
|
||||
if (ignore_dB || snd_mixer_selem_get_playback_dB_range(u->mixer_elem, &u->hw_dB_min, &u->hw_dB_max) < 0)
|
||||
pa_log_info("Mixer doesn't support dB information or data is ignored.");
|
||||
else {
|
||||
#ifdef HAVE_VALGRIND_MEMCHECK_H
|
||||
VALGRIND_MAKE_MEM_DEFINED(&u->hw_dB_min, sizeof(u->hw_dB_min));
|
||||
VALGRIND_MAKE_MEM_DEFINED(&u->hw_dB_max, sizeof(u->hw_dB_max));
|
||||
#endif
|
||||
pa_alsa_path_select(data->path, u->mixer_handle);
|
||||
|
||||
if (u->hw_dB_min >= u->hw_dB_max)
|
||||
pa_log_warn("Your kernel driver is broken: it reports a volume range from %0.2f dB to %0.2f dB which makes no sense.", (double) u->hw_dB_min/100.0, (double) u->hw_dB_max/100.0);
|
||||
else {
|
||||
pa_log_info("Volume ranges from %0.2f dB to %0.2f dB.", (double) u->hw_dB_min/100.0, (double) u->hw_dB_max/100.0);
|
||||
u->hw_dB_supported = TRUE;
|
||||
if (data->setting)
|
||||
pa_alsa_setting_select(data->setting, u->mixer_handle);
|
||||
|
||||
if (u->hw_dB_max > 0) {
|
||||
u->sink->base_volume = pa_sw_volume_from_dB(- (double) u->hw_dB_max/100.0);
|
||||
pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u->sink->base_volume));
|
||||
} else
|
||||
pa_log_info("No particular base volume set, fixing to 0 dB");
|
||||
}
|
||||
}
|
||||
} else {
|
||||
|
||||
if (!u->hw_dB_supported &&
|
||||
u->hw_volume_max - u->hw_volume_min < 3) {
|
||||
if (!u->mixer_path && u->mixer_path_set)
|
||||
u->mixer_path = u->mixer_path_set->paths;
|
||||
|
||||
pa_log_info("Device doesn't do dB volume and has less than 4 volume levels. Falling back to software volume control.");
|
||||
suitable = FALSE;
|
||||
}
|
||||
}
|
||||
if (u->mixer_path) {
|
||||
/* Hmm, we have only a single path, then let's activate it */
|
||||
|
||||
if (suitable) {
|
||||
u->mixer_seperate_channels = pa_alsa_calc_mixer_map(u->mixer_elem, &u->sink->channel_map, u->mixer_map, TRUE) >= 0;
|
||||
pa_alsa_path_select(u->mixer_path, u->mixer_handle);
|
||||
|
||||
u->sink->get_volume = sink_get_volume_cb;
|
||||
u->sink->set_volume = sink_set_volume_cb;
|
||||
u->sink->flags |= PA_SINK_HW_VOLUME_CTRL | (u->hw_dB_supported ? PA_SINK_DECIBEL_VOLUME : 0);
|
||||
pa_log_info("Using hardware volume control. Hardware dB scale %s.", u->hw_dB_supported ? "supported" : "not supported");
|
||||
|
||||
if (!u->hw_dB_supported)
|
||||
u->sink->n_volume_steps = u->hw_volume_max - u->hw_volume_min + 1;
|
||||
if (u->mixer_path->settings)
|
||||
pa_alsa_setting_select(u->mixer_path->settings, u->mixer_handle);
|
||||
} else
|
||||
pa_log_info("Using software volume control.");
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (snd_mixer_selem_has_playback_switch(u->mixer_elem)) {
|
||||
if (!u->mixer_path->has_volume)
|
||||
pa_log_info("Driver does not support hardware volume control, falling back to software volume control.");
|
||||
else {
|
||||
|
||||
if (u->mixer_path->has_dB) {
|
||||
pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u->mixer_path->min_dB, u->mixer_path->max_dB);
|
||||
|
||||
u->sink->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
|
||||
u->sink->n_volume_steps = PA_VOLUME_NORM+1;
|
||||
|
||||
if (u->mixer_path->max_dB > 0.0)
|
||||
pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u->sink->base_volume));
|
||||
else
|
||||
pa_log_info("No particular base volume set, fixing to 0 dB");
|
||||
|
||||
} else {
|
||||
pa_log_info("Hardware volume ranges from %li to %li.", u->mixer_path->min_volume, u->mixer_path->max_volume);
|
||||
u->sink->base_volume = PA_VOLUME_NORM;
|
||||
u->sink->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
|
||||
}
|
||||
|
||||
u->sink->get_volume = sink_get_volume_cb;
|
||||
u->sink->set_volume = sink_set_volume_cb;
|
||||
|
||||
u->sink->flags |= PA_SINK_HW_VOLUME_CTRL | (u->mixer_path->has_dB ? PA_SINK_DECIBEL_VOLUME : 0);
|
||||
pa_log_info("Using hardware volume control. Hardware dB scale %s.", u->mixer_path->has_dB ? "supported" : "not supported");
|
||||
}
|
||||
|
||||
if (!u->mixer_path->has_mute) {
|
||||
pa_log_info("Driver does not support hardware mute control, falling back to software mute control.");
|
||||
} else {
|
||||
u->sink->get_mute = sink_get_mute_cb;
|
||||
u->sink->set_mute = sink_set_mute_cb;
|
||||
u->sink->flags |= PA_SINK_HW_MUTE_CTRL;
|
||||
} else
|
||||
pa_log_info("Using software mute control.");
|
||||
pa_log_info("Using hardware mute control.");
|
||||
}
|
||||
|
||||
u->mixer_fdl = pa_alsa_fdlist_new();
|
||||
|
||||
|
|
@ -1544,13 +1490,15 @@ static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) {
|
|||
return -1;
|
||||
}
|
||||
|
||||
snd_mixer_elem_set_callback(u->mixer_elem, mixer_callback);
|
||||
snd_mixer_elem_set_callback_private(u->mixer_elem, u);
|
||||
if (u->mixer_path_set)
|
||||
pa_alsa_path_set_set_callback(u->mixer_path_set, u->mixer_handle, mixer_callback, u);
|
||||
else
|
||||
pa_alsa_path_set_callback(u->mixer_path, u->mixer_handle, mixer_callback, u);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_card *card, const pa_alsa_profile_info *profile) {
|
||||
pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_card *card, pa_alsa_mapping *mapping) {
|
||||
|
||||
struct userdata *u = NULL;
|
||||
const char *dev_id = NULL;
|
||||
|
|
@ -1561,7 +1509,7 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
|
|||
size_t frame_size;
|
||||
pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE;
|
||||
pa_sink_new_data data;
|
||||
char *control_device = NULL;
|
||||
pa_alsa_profile_set *profile_set = NULL;
|
||||
|
||||
pa_assert(m);
|
||||
pa_assert(ma);
|
||||
|
|
@ -1646,32 +1594,35 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
|
|||
b = use_mmap;
|
||||
d = use_tsched;
|
||||
|
||||
if (profile) {
|
||||
if (mapping) {
|
||||
|
||||
if (!(dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
|
||||
pa_log("device_id= not set");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
if (!(u->pcm_handle = pa_alsa_open_by_device_id_profile(
|
||||
if (!(u->pcm_handle = pa_alsa_open_by_device_id_mapping(
|
||||
dev_id,
|
||||
&u->device_name,
|
||||
&ss, &map,
|
||||
SND_PCM_STREAM_PLAYBACK,
|
||||
&nfrags, &period_frames, tsched_frames,
|
||||
&b, &d, profile)))
|
||||
&b, &d, mapping)))
|
||||
|
||||
goto fail;
|
||||
|
||||
} else if ((dev_id = pa_modargs_get_value(ma, "device_id", NULL))) {
|
||||
|
||||
if (!(profile_set = pa_alsa_profile_set_new(NULL, &map)))
|
||||
goto fail;
|
||||
|
||||
if (!(u->pcm_handle = pa_alsa_open_by_device_id_auto(
|
||||
dev_id,
|
||||
&u->device_name,
|
||||
&ss, &map,
|
||||
SND_PCM_STREAM_PLAYBACK,
|
||||
&nfrags, &period_frames, tsched_frames,
|
||||
&b, &d, &profile)))
|
||||
&b, &d, profile_set, &mapping)))
|
||||
|
||||
goto fail;
|
||||
|
||||
|
|
@ -1685,7 +1636,6 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
|
|||
&nfrags, &period_frames, tsched_frames,
|
||||
&b, &d, FALSE)))
|
||||
goto fail;
|
||||
|
||||
}
|
||||
|
||||
pa_assert(u->device_name);
|
||||
|
|
@ -1696,8 +1646,8 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
|
|||
goto fail;
|
||||
}
|
||||
|
||||
if (profile)
|
||||
pa_log_info("Selected configuration '%s' (%s).", profile->description, profile->name);
|
||||
if (mapping)
|
||||
pa_log_info("Selected mapping '%s' (%s).", mapping->description, mapping->name);
|
||||
|
||||
if (use_mmap && !b) {
|
||||
pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
|
||||
|
|
@ -1723,7 +1673,7 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
|
|||
/* ALSA might tweak the sample spec, so recalculate the frame size */
|
||||
frame_size = pa_frame_size(&ss);
|
||||
|
||||
pa_alsa_find_mixer_and_elem(u->pcm_handle, &control_device, &u->mixer_handle, &u->mixer_elem, pa_modargs_get_value(ma, "control", NULL), profile);
|
||||
find_mixer(u, mapping, pa_modargs_get_value(ma, "control", NULL), ignore_dB);
|
||||
|
||||
pa_sink_new_data_init(&data);
|
||||
data.driver = driver;
|
||||
|
|
@ -1733,23 +1683,21 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
|
|||
pa_sink_new_data_set_sample_spec(&data, &ss);
|
||||
pa_sink_new_data_set_channel_map(&data, &map);
|
||||
|
||||
pa_alsa_init_proplist_pcm(m->core, data.proplist, u->pcm_handle, u->mixer_elem);
|
||||
pa_alsa_init_proplist_pcm(m->core, data.proplist, u->pcm_handle);
|
||||
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_STRING, u->device_name);
|
||||
pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_BUFFER_SIZE, "%lu", (unsigned long) (period_frames * frame_size * nfrags));
|
||||
pa_proplist_setf(data.proplist, PA_PROP_DEVICE_BUFFERING_FRAGMENT_SIZE, "%lu", (unsigned long) (period_frames * frame_size));
|
||||
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_ACCESS_MODE, u->use_tsched ? "mmap+timer" : (u->use_mmap ? "mmap" : "serial"));
|
||||
|
||||
if (profile) {
|
||||
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_NAME, profile->name);
|
||||
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_DESCRIPTION, profile->description);
|
||||
if (mapping) {
|
||||
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_NAME, mapping->name);
|
||||
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_PROFILE_DESCRIPTION, mapping->description);
|
||||
}
|
||||
|
||||
pa_alsa_init_description(data.proplist);
|
||||
|
||||
if (control_device) {
|
||||
pa_alsa_init_proplist_ctl(data.proplist, control_device);
|
||||
pa_xfree(control_device);
|
||||
}
|
||||
if (u->control_device)
|
||||
pa_alsa_init_proplist_ctl(data.proplist, u->control_device);
|
||||
|
||||
if (pa_modargs_get_proplist(ma, "sink_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
|
||||
pa_log("Invalid properties");
|
||||
|
|
@ -1757,6 +1705,9 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
|
|||
goto fail;
|
||||
}
|
||||
|
||||
if (u->mixer_path_set)
|
||||
pa_alsa_add_ports(&data.ports, u->mixer_path_set);
|
||||
|
||||
u->sink = pa_sink_new(m->core, &data, PA_SINK_HARDWARE|PA_SINK_LATENCY|(u->use_tsched ? PA_SINK_DYNAMIC_LATENCY : 0));
|
||||
pa_sink_new_data_done(&data);
|
||||
|
||||
|
|
@ -1768,6 +1719,7 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
|
|||
u->sink->parent.process_msg = sink_process_msg;
|
||||
u->sink->update_requested_latency = sink_update_requested_latency_cb;
|
||||
u->sink->set_state = sink_set_state_cb;
|
||||
u->sink->set_port = sink_set_port_cb;
|
||||
u->sink->userdata = u;
|
||||
|
||||
pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
|
||||
|
|
@ -1836,6 +1788,9 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
|
|||
|
||||
pa_sink_put(u->sink);
|
||||
|
||||
if (profile_set)
|
||||
pa_alsa_profile_set_free(profile_set);
|
||||
|
||||
return u->sink;
|
||||
|
||||
fail:
|
||||
|
|
@ -1843,6 +1798,9 @@ fail:
|
|||
if (u)
|
||||
userdata_free(u);
|
||||
|
||||
if (profile_set)
|
||||
pa_alsa_profile_set_free(profile_set);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
|
@ -1871,17 +1829,22 @@ static void userdata_free(struct userdata *u) {
|
|||
if (u->rtpoll)
|
||||
pa_rtpoll_free(u->rtpoll);
|
||||
|
||||
if (u->mixer_fdl)
|
||||
pa_alsa_fdlist_free(u->mixer_fdl);
|
||||
|
||||
if (u->mixer_handle)
|
||||
snd_mixer_close(u->mixer_handle);
|
||||
|
||||
if (u->pcm_handle) {
|
||||
snd_pcm_drop(u->pcm_handle);
|
||||
snd_pcm_close(u->pcm_handle);
|
||||
}
|
||||
|
||||
if (u->mixer_fdl)
|
||||
pa_alsa_fdlist_free(u->mixer_fdl);
|
||||
|
||||
if (u->mixer_path_set)
|
||||
pa_alsa_path_set_free(u->mixer_path_set);
|
||||
else if (u->mixer_path)
|
||||
pa_alsa_path_free(u->mixer_path);
|
||||
|
||||
if (u->mixer_handle)
|
||||
snd_mixer_close(u->mixer_handle);
|
||||
|
||||
if (u->smoother)
|
||||
pa_smoother_free(u->smoother);
|
||||
|
||||
|
|
@ -1889,6 +1852,7 @@ static void userdata_free(struct userdata *u) {
|
|||
monitor_done(u);
|
||||
|
||||
pa_xfree(u->device_name);
|
||||
pa_xfree(u->control_device);
|
||||
pa_xfree(u);
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue