1 files changed, 217 insertions, 259 deletions

diff --git a/src/modules/alsa/alsa-source.c b/src/modules/alsa/alsa-source.c
index c176309e..f2e4e234 100644
--- a/src/modules/alsa/alsa-source.c
+++ b/src/modules/alsa/alsa-source.c
@@ -28,10 +28,6 @@
 
 #include <asoundlib.h>
 
-#ifdef HAVE_VALGRIND_MEMCHECK_H
-#include <valgrind/memcheck.h>
-#endif
-
 #include <pulse/xmalloc.h>
 #include <pulse/util.h>
 #include <pulse/timeval.h>
@@ -81,11 +77,8 @@ 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;
 
@@ -102,6 +95,7 @@ struct userdata {
     unsigned nfragments;
 
     char *device_name;
+    char *control_device;
 
     pa_bool_t use_mmap:1, use_tsched:1;
 
@@ -949,239 +943,135 @@ 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 source_get_volume_cb(pa_source *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);
-
-    if (u->mixer_seperate_channels) {
-
-        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_capture_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_capture_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_capture_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 {
+    pa_assert(u->mixer_path);
+    pa_assert(u->mixer_handle);
 
-            if ((err = snd_mixer_selem_get_capture_volume(u->mixer_elem, SND_MIXER_SCHN_MONO, &alsa_vol)) < 0)
-                goto fail;
+    if (pa_alsa_path_get_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
+        return;
 
-            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_source_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_source_set_soft_volume(s, &reset);
     }
-
-    return;
-
-fail:
-    pa_log_error("Unable to read volume: %s", pa_alsa_strerror(err));
 }
 
 static void source_set_volume_cb(pa_source *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);
-
-    if (u->mixer_seperate_channels) {
-
-        r.channels = s->sample_spec.channels;
-
-        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_capture_dB(u->mixer_elem, u->mixer_map[i], alsa_vol, 1)) < 0)
-                    goto fail;
-
-                if ((err = snd_mixer_selem_get_capture_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_capture_volume(u->mixer_elem, u->mixer_map[i], alsa_vol)) < 0)
-                    goto fail;
-
-                if ((err = snd_mixer_selem_get_capture_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_capture_dB_all(u->mixer_elem, alsa_vol, 1)) < 0)
-                goto fail;
-
-            if ((err = snd_mixer_selem_get_capture_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);
+    pa_assert(u->mixer_path);
+    pa_assert(u->mixer_handle);
 
-            if ((err = snd_mixer_selem_set_capture_volume_all(u->mixer_elem, alsa_vol)) < 0)
-                goto fail;
+    /* Shift up by the base volume */
+    pa_sw_cvolume_divide_scalar(&r, &s->virtual_volume, s->base_volume);
 
-            if ((err = snd_mixer_selem_get_capture_volume(u->mixer_elem, SND_MIXER_SCHN_MONO, &alsa_vol)) < 0)
-                goto fail;
+    if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &r) < 0)
+        return;
 
-            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);
 
         pa_log_debug("Requested volume: %s", pa_cvolume_snprint(t, sizeof(t), &s->virtual_volume));
         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 source_get_mute_cb(pa_source *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_capture_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 source_set_mute_cb(pa_source *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_capture_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 source_set_port_cb(pa_source *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 source_update_requested_latency_cb(pa_source *s) {
@@ -1323,77 +1213,127 @@ static void set_source_name(pa_source_new_data *data, pa_modargs *ma, const char
     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_INPUT)))
+            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_INPUT)))
+            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->source->active_port) {
+        pa_alsa_port_data *data;
 
-    if (snd_mixer_selem_has_capture_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_capture_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->source->active_port);
+        u->mixer_path = data->path;
 
-        if (suitable) {
-            if (ignore_dB || snd_mixer_selem_get_capture_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 (u->hw_dB_max > 0) {
-                        u->source->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->source->base_volume));
-                    } else
-                        pa_log_info("No particular base volume set, fixing to 0 dB");
-                }
-            }
+        if (data->setting)
+            pa_alsa_setting_select(data->setting, u->mixer_handle);
 
-            if (!u->hw_dB_supported &&
-                u->hw_volume_max - u->hw_volume_min < 3) {
+    } else {
 
-                pa_log_info("Device has less than 4 volume levels. Falling back to software volume control.");
-                suitable = FALSE;
-            }
-        }
+        if (!u->mixer_path && u->mixer_path_set)
+            u->mixer_path = u->mixer_path_set->paths;
 
-        if (suitable) {
-            u->mixer_seperate_channels = pa_alsa_calc_mixer_map(u->mixer_elem, &u->source->channel_map, u->mixer_map, FALSE) >= 0;
+        if (u->mixer_path) {
+            /* Hmm, we have only a single path, then let's activate it */
 
-            u->source->get_volume = source_get_volume_cb;
-            u->source->set_volume = source_set_volume_cb;
-            u->source->flags |= PA_SOURCE_HW_VOLUME_CTRL | (u->hw_dB_supported ? PA_SOURCE_DECIBEL_VOLUME : 0);
-            pa_log_info("Using hardware volume control. Hardware dB scale %s.", u->hw_dB_supported ? "supported" : "not supported");
+            pa_alsa_path_select(u->mixer_path, u->mixer_handle);
 
-            if (!u->hw_dB_supported)
-                u->source->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 (!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->source->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
+            u->source->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->source->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->source->base_volume = PA_VOLUME_NORM;
+            u->source->n_volume_steps = u->mixer_path->max_volume - u->mixer_path->min_volume + 1;
+        }
+
+        u->source->get_volume = source_get_volume_cb;
+        u->source->set_volume = source_set_volume_cb;
+
+        u->source->flags |= PA_SOURCE_HW_VOLUME_CTRL | (u->mixer_path->has_dB ? PA_SOURCE_DECIBEL_VOLUME : 0);
+        pa_log_info("Using hardware volume control. Hardware dB scale %s.", u->mixer_path->has_dB ? "supported" : "not supported");
     }
 
-    if (snd_mixer_selem_has_capture_switch(u->mixer_elem)) {
+    if (!u->mixer_path->has_mute) {
+        pa_log_info("Driver does not support hardware mute control, falling back to software mute control.");
+    } else {
         u->source->get_mute = source_get_mute_cb;
         u->source->set_mute = source_set_mute_cb;
         u->source->flags |= PA_SOURCE_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();
 
@@ -1402,13 +1342,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_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, pa_card *card, const pa_alsa_profile_info *profile) {
+pa_source *pa_alsa_source_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;
@@ -1419,7 +1361,7 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p
     size_t frame_size;
     pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE;
     pa_source_new_data data;
-    char *control_device = NULL;
+    pa_alsa_profile_set *profile_set = NULL;
 
     pa_assert(m);
     pa_assert(ma);
@@ -1480,7 +1422,6 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p
     u->use_tsched = use_tsched;
     u->rtpoll = pa_rtpoll_new();
     pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
-    u->alsa_rtpoll_item = NULL;
 
     u->smoother = pa_smoother_new(
             DEFAULT_TSCHED_WATERMARK_USEC*2,
@@ -1504,31 +1445,34 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p
     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_CAPTURE,
                       &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_CAPTURE,
                       &nfrags, &period_frames, tsched_frames,
-                      &b, &d, &profile)))
+                      &b, &d, profile_set, &mapping)))
             goto fail;
 
     } else {
@@ -1551,8 +1495,8 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p
         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.");
@@ -1578,7 +1522,7 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p
     /* 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_source_new_data_init(&data);
     data.driver = driver;
@@ -1588,23 +1532,21 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p
     pa_source_new_data_set_sample_spec(&data, &ss);
     pa_source_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, "source_properties", data.proplist, PA_UPDATE_REPLACE) < 0) {
         pa_log("Invalid properties");
@@ -1612,6 +1554,9 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p
         goto fail;
     }
 
+    if (u->mixer_path_set)
+        pa_alsa_add_ports(&data.ports, u->mixer_path_set);
+
     u->source = pa_source_new(m->core, &data, PA_SOURCE_HARDWARE|PA_SOURCE_LATENCY|(u->use_tsched ? PA_SOURCE_DYNAMIC_LATENCY : 0));
     pa_source_new_data_done(&data);
 
@@ -1623,6 +1568,7 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p
     u->source->parent.process_msg = source_process_msg;
     u->source->update_requested_latency = source_update_requested_latency_cb;
     u->source->set_state = source_set_state_cb;
+    u->source->set_port = source_set_port_cb;
     u->source->userdata = u;
 
     pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
@@ -1687,6 +1633,9 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p
 
     pa_source_put(u->source);
 
+    if (profile_set)
+        pa_alsa_profile_set_free(profile_set);
+
     return u->source;
 
 fail:
@@ -1694,6 +1643,9 @@ fail:
     if (u)
         userdata_free(u);
 
+    if (profile_set)
+        pa_alsa_profile_set_free(profile_set);
+
     return NULL;
 }
 
@@ -1719,17 +1671,22 @@ static void userdata_free(struct userdata *u) {
     if (u->rtpoll)
         pa_rtpoll_free(u->rtpoll);
 
+    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->pcm_handle) {
-        snd_pcm_drop(u->pcm_handle);
-        snd_pcm_close(u->pcm_handle);
-    }
-
     if (u->smoother)
         pa_smoother_free(u->smoother);
 
@@ -1737,6 +1694,7 @@ static void userdata_free(struct userdata *u) {
     monitor_done(u);
 
     pa_xfree(u->device_name);
+    pa_xfree(u->control_device);
     pa_xfree(u);
 }