Merge branch 'oss-alsa'

1 files changed, 941 insertions, 0 deletions

diff --git a/backends/alsa/alsa-device.c b/backends/alsa/alsa-device.c
new file mode 100644
index 0000000..5acc6f5
--- /dev/null
+++ b/backends/alsa/alsa-device.c
@@ -0,0 +1,941 @@
+/*
+ * Copyright (C) 2014 Michal Ratajsky <[email protected]>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the licence, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <strings.h>
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <glib-object.h>
+#include <alsa/asoundlib.h>
+#include <libmatemixer/matemixer.h>
+
+#include "alsa-constants.h"
+#include "alsa-device.h"
+#include "alsa-element.h"
+#include "alsa-stream.h"
+#include "alsa-stream-control.h"
+#include "alsa-stream-input-control.h"
+#include "alsa-stream-output-control.h"
+#include "alsa-switch.h"
+#include "alsa-switch-option.h"
+#include "alsa-toggle.h"
+
+#define ALSA_DEVICE_ICON "audio-card"
+
+struct _AlsaDevicePrivate
+{
+    snd_mixer_t  *handle;
+    GMainContext *context;
+    GMutex        mutex;
+    GCond         cond;
+    AlsaStream   *input;
+    AlsaStream   *output;
+    GHashTable   *switches;
+    gboolean      events_pending;
+};
+
+enum {
+    CLOSED,
+    N_SIGNALS
+};
+
+static guint signals[N_SIGNALS] = { 0, };
+
+static void alsa_device_class_init (AlsaDeviceClass *klass);
+static void alsa_device_init       (AlsaDevice      *device);
+static void alsa_device_dispose    (GObject         *object);
+static void alsa_device_finalize   (GObject         *object);
+
+G_DEFINE_TYPE (AlsaDevice, alsa_device, MATE_MIXER_TYPE_DEVICE)
+
+static MateMixerSwitch *alsa_device_get_switch    (MateMixerDevice            *mmd,
+                                                   const gchar                *name);
+
+static GList *          alsa_device_list_streams  (MateMixerDevice            *mmd);
+static GList *          alsa_device_list_switches (MateMixerDevice            *mmd);
+
+static gboolean         add_stream_input_control  (AlsaDevice                 *device,
+                                                   snd_mixer_elem_t           *el);
+static gboolean         add_stream_output_control (AlsaDevice                 *device,
+                                                   snd_mixer_elem_t           *el);
+
+static gboolean         add_switch                (AlsaDevice                 *device,
+                                                   AlsaStream                 *stream,
+                                                   snd_mixer_elem_t           *el);
+
+static gboolean         add_device_switch         (AlsaDevice                 *device,
+                                                   snd_mixer_elem_t           *el);
+
+static gboolean         add_stream_input_switch   (AlsaDevice                 *device,
+                                                   snd_mixer_elem_t           *el);
+static gboolean         add_stream_output_switch  (AlsaDevice                 *device,
+                                                   snd_mixer_elem_t           *el);
+
+static gboolean         add_stream_input_toggle   (AlsaDevice                 *device,
+                                                   snd_mixer_elem_t           *el);
+static gboolean         add_stream_output_toggle  (AlsaDevice                 *device,
+                                                   snd_mixer_elem_t           *el);
+
+static void             load_element              (AlsaDevice                 *device,
+                                                   snd_mixer_elem_t           *el);
+
+static void             load_elements_by_name     (AlsaDevice                 *device,
+                                                   const gchar                *name);
+
+static void             remove_elements_by_name   (AlsaDevice                 *device,
+                                                   const gchar                *name);
+
+static void             handle_poll               (AlsaDevice                 *device);
+
+static gboolean         handle_process_events     (AlsaDevice                 *device);
+
+static int              handle_callback           (snd_mixer_t                *handle,
+                                                   guint                       mask,
+                                                   snd_mixer_elem_t           *el);
+static int              handle_element_callback   (snd_mixer_elem_t           *el,
+                                                   guint                       mask);
+
+static void             close_device              (AlsaDevice                 *device);
+
+static gchar *          get_element_name          (snd_mixer_elem_t           *el);
+static void             get_control_info          (snd_mixer_elem_t           *el,
+                                                   gchar                     **name,
+                                                   gchar                     **label,
+                                                   MateMixerStreamControlRole *role);
+
+static void             get_switch_info           (snd_mixer_elem_t           *el,
+                                                   gchar                     **name,
+                                                   gchar                     **label);
+
+static void
+alsa_device_class_init (AlsaDeviceClass *klass)
+{
+    GObjectClass         *object_class;
+    MateMixerDeviceClass *device_class;
+
+    object_class = G_OBJECT_CLASS (klass);
+    object_class->dispose  = alsa_device_dispose;
+    object_class->finalize = alsa_device_finalize;
+
+    device_class = MATE_MIXER_DEVICE_CLASS (klass);
+    device_class->get_switch    = alsa_device_get_switch;
+    device_class->list_streams  = alsa_device_list_streams;
+    device_class->list_switches = alsa_device_list_switches;
+
+    signals[CLOSED] =
+        g_signal_new ("closed",
+                      G_TYPE_FROM_CLASS (object_class),
+                      G_SIGNAL_RUN_LAST,
+                      G_STRUCT_OFFSET (AlsaDeviceClass, closed),
+                      NULL,
+                      NULL,
+                      g_cclosure_marshal_VOID__VOID,
+                      G_TYPE_NONE,
+                      0,
+                      G_TYPE_NONE);
+
+    g_type_class_add_private (object_class, sizeof (AlsaDevicePrivate));
+}
+
+static void
+alsa_device_init (AlsaDevice *device)
+{
+    device->priv = G_TYPE_INSTANCE_GET_PRIVATE (device,
+                                                ALSA_TYPE_DEVICE,
+                                                AlsaDevicePrivate);
+
+    device->priv->switches = g_hash_table_new_full (g_str_hash,
+                                                    g_str_equal,
+                                                    g_free,
+                                                    g_object_unref);
+
+    device->priv->context = g_main_context_ref_thread_default ();
+
+    g_mutex_init (&device->priv->mutex);
+    g_cond_init (&device->priv->cond);
+}
+
+static void
+alsa_device_dispose (GObject *object)
+{
+    AlsaDevice *device;
+
+    device = ALSA_DEVICE (object);
+
+    g_clear_object (&device->priv->input);
+    g_clear_object (&device->priv->output);
+
+    g_hash_table_remove_all (device->priv->switches);
+
+    G_OBJECT_CLASS (alsa_device_parent_class)->dispose (object);
+}
+
+static void
+alsa_device_finalize (GObject *object)
+{
+    AlsaDevice *device;
+
+    device = ALSA_DEVICE (object);
+
+    g_mutex_clear (&device->priv->mutex);
+    g_cond_clear (&device->priv->cond);
+
+    g_hash_table_unref (device->priv->switches);
+    g_main_context_unref (device->priv->context);
+
+    if (device->priv->handle != NULL)
+        snd_mixer_close (device->priv->handle);
+
+    G_OBJECT_CLASS (alsa_device_parent_class)->dispose (object);
+}
+
+AlsaDevice *
+alsa_device_new (const gchar *name, const gchar *label)
+{
+    AlsaDevice  *device;
+    gchar       *stream_name;
+
+    g_return_val_if_fail (name != NULL, NULL);
+    g_return_val_if_fail (label != NULL, NULL);
+
+    device = g_object_new (ALSA_TYPE_DEVICE,
+                           "name", name,
+                           "label", label,
+                           "icon", ALSA_DEVICE_ICON,
+                           NULL);
+
+    /* Create input and output streams, they will exist the whole time, but
+     * the added and removed signals will be emitted when the first control or
+     * switch is added or the last one removed */
+    stream_name = g_strdup_printf ("alsa-input-%s", name);
+    device->priv->input = alsa_stream_new (stream_name,
+                                           MATE_MIXER_DEVICE (device),
+                                           MATE_MIXER_STREAM_INPUT);
+    g_free (stream_name);
+
+    stream_name = g_strdup_printf ("alsa-output-%s", name);
+    device->priv->output = alsa_stream_new (stream_name,
+                                            MATE_MIXER_DEVICE (device),
+                                            MATE_MIXER_STREAM_OUTPUT);
+    g_free (stream_name);
+
+    return device;
+}
+
+gboolean
+alsa_device_open (AlsaDevice *device)
+{
+    snd_mixer_t *handle;
+    const gchar *name;
+    gint         ret;
+
+    g_return_val_if_fail (ALSA_IS_DEVICE (device), FALSE);
+    g_return_val_if_fail (device->priv->handle == NULL, FALSE);
+
+    name = mate_mixer_device_get_name (MATE_MIXER_DEVICE (device));
+
+    g_debug ("Opening device %s (%s)",
+             name,
+             mate_mixer_device_get_label (MATE_MIXER_DEVICE (device)));
+
+    /* Open the mixer for the current device */
+    ret = snd_mixer_open (&handle, 0);
+    if (ret < 0) {
+        g_warning ("Failed to open mixer: %s", snd_strerror (ret));
+        return FALSE;
+    }
+    ret = snd_mixer_attach (handle, name);
+    if (ret < 0) {
+        g_warning ("Failed to attach mixer to %s: %s",
+                   name,
+                   snd_strerror (ret));
+
+        snd_mixer_close (handle);
+        return FALSE;
+    }
+    ret = snd_mixer_selem_register (handle, NULL, NULL);
+    if (ret < 0) {
+        g_warning ("Failed to register simple element for %s: %s",
+                   name,
+                   snd_strerror (ret));
+
+        snd_mixer_close (handle);
+        return FALSE;
+    }
+    ret = snd_mixer_load (handle);
+    if (ret < 0) {
+        g_warning ("Failed to load mixer elements for %s: %s",
+                   name,
+                   snd_strerror (ret));
+
+        snd_mixer_close (handle);
+        return FALSE;
+    }
+
+    device->priv->handle = handle;
+    return TRUE;
+}
+
+void
+alsa_device_load (AlsaDevice *device)
+{
+    GThread          *thread;
+    GError           *error = NULL;
+    snd_mixer_elem_t *el;
+
+    g_return_if_fail (ALSA_IS_DEVICE (device));
+    g_return_if_fail (device->priv->handle != NULL);
+
+    /* Process the mixer elements */
+    el = snd_mixer_first_elem (device->priv->handle);
+    while (el != NULL) {
+        load_element (device, el);
+
+        el = snd_mixer_elem_next (el);
+    }
+
+    /* Set callback for ALSA events */
+    snd_mixer_set_callback (device->priv->handle, handle_callback);
+    snd_mixer_set_callback_private (device->priv->handle, device);
+
+    /* Start the polling thread */
+    thread = g_thread_try_new ("matemixer-alsa-poll",
+                               (GThreadFunc) handle_poll,
+                               device,
+                               &error);
+    if (thread == NULL) {
+        /* The error is not treated as fatal, because without the polling
+         * thread we still have most of the functionality */
+        g_warning ("Failed to create poll thread: %s", error->message);
+        g_error_free (error);
+    } else
+        g_thread_unref (thread);
+}
+
+AlsaStream *
+alsa_device_get_input_stream (AlsaDevice *device)
+{
+    g_return_val_if_fail (ALSA_IS_DEVICE (device), NULL);
+
+    /* Normally controlless streams should not exist, here we simulate the
+     * behaviour for the owning instance */
+    if (alsa_stream_is_empty (device->priv->input) == FALSE)
+        return device->priv->input;
+
+    return NULL;
+}
+
+AlsaStream *
+alsa_device_get_output_stream (AlsaDevice *device)
+{
+    g_return_val_if_fail (ALSA_IS_DEVICE (device), NULL);
+
+    /* Normally controlless streams should not exist, here we simulate the
+     * behaviour for the owning instance */
+    if (alsa_stream_is_empty (device->priv->output) == FALSE)
+        return device->priv->output;
+
+    return NULL;
+}
+
+static gboolean
+add_element (AlsaDevice *device, AlsaStream *stream, AlsaElement *element)
+{
+    gboolean added = FALSE;
+
+    if (alsa_element_load (element) == FALSE)
+        return FALSE;
+
+    if (stream != NULL) {
+        gboolean empty = FALSE;
+
+        if (alsa_stream_is_empty (stream) == TRUE) {
+            const gchar *name =
+                mate_mixer_stream_get_name (MATE_MIXER_STREAM (stream));
+
+            /* Pretend the stream has just been created now that we are adding
+             * the first control */
+            g_signal_emit_by_name (G_OBJECT (device),
+                                   "stream-added",
+                                   name);
+            empty = TRUE;
+        }
+
+        if (ALSA_IS_STREAM_CONTROL (element)) {
+            alsa_stream_add_control (stream, ALSA_STREAM_CONTROL (element));
+
+            /* If this is the first control, set it as the default one.
+             * The controls often seem to come in the order of importance, but this is
+             * driver specific, so we may later see if there is another control which
+             * better matches the default. */
+            if (empty == TRUE)
+                alsa_stream_set_default_control (stream, ALSA_STREAM_CONTROL (element));
+
+            added = TRUE;
+        } else if (ALSA_IS_SWITCH (element)) {
+            /* Switch belonging to a stream */
+            alsa_stream_add_switch (stream, ALSA_SWITCH (element));
+            added = TRUE;
+        }
+    } else if (ALSA_IS_SWITCH (element)) {
+        /* Switch belonging to the device */
+        const gchar *name =
+            mate_mixer_switch_get_name (MATE_MIXER_SWITCH (element));
+
+        g_hash_table_insert (device->priv->switches,
+                             g_strdup (name),
+                             g_object_ref (element));
+
+        g_signal_emit_by_name (G_OBJECT (device),
+                               "switch-added",
+                               name);
+        added = TRUE;
+    }
+
+    if G_LIKELY (added == TRUE) {
+        snd_mixer_elem_t *el = alsa_element_get_snd_element (element);
+
+        snd_mixer_elem_set_callback (el, handle_element_callback);
+        snd_mixer_elem_set_callback_private (el, device);
+    }
+    return added;
+}
+
+static MateMixerSwitch *
+alsa_device_get_switch (MateMixerDevice *mmd, const gchar *name)
+{
+    g_return_val_if_fail (ALSA_IS_DEVICE (mmd), NULL);
+    g_return_val_if_fail (name != NULL, NULL);
+
+    return g_hash_table_lookup (ALSA_DEVICE (mmd)->priv->switches, name);
+}
+
+static GList *
+alsa_device_list_streams (MateMixerDevice *mmd)
+{
+    AlsaDevice *device;
+    GList      *list = NULL;
+
+    g_return_val_if_fail (ALSA_IS_DEVICE (mmd), NULL);
+
+    device = ALSA_DEVICE (mmd);
+
+    if (device->priv->output != NULL)
+        list = g_list_prepend (list, g_object_ref (device->priv->output));
+    if (device->priv->input != NULL)
+        list = g_list_prepend (list, g_object_ref (device->priv->input));
+
+    return list;
+}
+
+static GList *
+alsa_device_list_switches (MateMixerDevice *mmd)
+{
+    GList *list;
+
+    g_return_val_if_fail (ALSA_IS_DEVICE (mmd), NULL);
+
+    /* Convert the hash table to a linked list, this list is expected to be
+     * cached in the main library */
+    list = g_hash_table_get_values (ALSA_DEVICE (mmd)->priv->switches);
+    if (list != NULL)
+        g_list_foreach (list, (GFunc) g_object_ref, NULL);
+
+    return list;
+}
+
+static gboolean
+add_stream_input_control (AlsaDevice *device, snd_mixer_elem_t *el)
+{
+    AlsaStreamControl         *control;
+    gchar                     *name;
+    gchar                     *label;
+    MateMixerStreamControlRole role;
+
+    get_control_info (el, &name, &label, &role);
+
+    g_debug ("Found device %s input control %s",
+             mate_mixer_device_get_name (MATE_MIXER_DEVICE (device)),
+             label);
+
+    control = alsa_stream_input_control_new (name, label, role);
+    g_free (name);
+    g_free (label);
+
+    alsa_element_set_snd_element (ALSA_ELEMENT (control), el);
+
+    if (add_element (device, device->priv->input, ALSA_ELEMENT (control)) == FALSE) {
+        g_object_unref (control);
+        return FALSE;
+    }
+    return TRUE;
+}
+
+static gboolean
+add_stream_output_control (AlsaDevice *device, snd_mixer_elem_t *el)
+{
+    AlsaStreamControl         *control;
+    gchar                     *label;
+    gchar                     *name;
+    MateMixerStreamControlRole role;
+
+    get_control_info (el, &name, &label, &role);
+
+    g_debug ("Found device %s output control %s",
+             mate_mixer_device_get_name (MATE_MIXER_DEVICE (device)),
+             label);
+
+    control = alsa_stream_output_control_new (name, label, role);
+    g_free (name);
+    g_free (label);
+
+    alsa_element_set_snd_element (ALSA_ELEMENT (control), el);
+
+    if (add_element (device, device->priv->output, ALSA_ELEMENT (control)) == FALSE) {
+        g_object_unref (control);
+        return FALSE;
+    }
+    return TRUE;
+}
+
+static AlsaToggle *
+create_toggle (AlsaDevice *device, snd_mixer_elem_t *el, AlsaToggleType type)
+{
+    AlsaToggle       *toggle;
+    AlsaSwitchOption *on;
+    AlsaSwitchOption *off;
+    gchar            *name;
+    gchar            *label;
+
+    on  = alsa_switch_option_new ("On", _("On"), NULL, 1);
+    off = alsa_switch_option_new ("Off", _("Off"), NULL, 0);
+
+    get_switch_info (el, &name, &label);
+    toggle = alsa_toggle_new (name,
+                              label,
+                              type,
+                              on, off);
+    g_free (name);
+    g_free (label);
+
+    alsa_element_set_snd_element (ALSA_ELEMENT (toggle), el);
+
+    g_object_unref (on);
+    g_object_unref (off);
+
+    return toggle;
+}
+
+static gboolean
+add_switch (AlsaDevice *device, AlsaStream *stream, snd_mixer_elem_t *el)
+{
+    AlsaElement *element = NULL;
+    GList       *options = NULL;
+    gchar       *name;
+    gchar       *label;
+    gchar        item[128];
+    guint        i;
+    gint         count;
+    gint         ret;
+
+    count = snd_mixer_selem_get_enum_items (el);
+    if G_UNLIKELY (count <= 0) {
+        g_debug ("Skipping mixer switch %s with %d items",
+                 snd_mixer_selem_get_name (el),
+                 count);
+        return FALSE;
+    }
+
+    for (i = 0; i < count; i++) {
+        ret = snd_mixer_selem_get_enum_item_name (el, i,
+                                                  sizeof (item),
+                                                  item);
+        if G_LIKELY (ret == 0)
+            options = g_list_prepend (options,
+                                      alsa_switch_option_new (item, item, NULL, i));
+        else
+            g_warning ("Failed to read switch item name: %s", snd_strerror (ret));
+    }
+
+    get_switch_info (el, &name, &label);
+
+    /* Takes ownership of options */
+    element = ALSA_ELEMENT (alsa_switch_new (name, label, g_list_reverse (options)));
+    g_free (name);
+    g_free (label);
+
+    alsa_element_set_snd_element (element, el);
+
+    if (add_element (device, stream, element) == FALSE) {
+        g_object_unref (element);
+        return FALSE;
+    }
+    return TRUE;
+}
+
+static gboolean
+add_device_switch (AlsaDevice *device, snd_mixer_elem_t *el)
+{
+    g_debug ("Reading device %s switch %s (%d items)",
+             mate_mixer_device_get_name (MATE_MIXER_DEVICE (device)),
+             snd_mixer_selem_get_name (el),
+             snd_mixer_selem_get_enum_items (el));
+
+    return add_switch (device, NULL, el);
+}
+
+static gboolean
+add_stream_input_switch (AlsaDevice *device, snd_mixer_elem_t *el)
+{
+    g_debug ("Reading device %s input switch %s (%d items)",
+             mate_mixer_device_get_name (MATE_MIXER_DEVICE (device)),
+             snd_mixer_selem_get_name (el),
+             snd_mixer_selem_get_enum_items (el));
+
+    return add_switch (device, device->priv->input, el);
+}
+
+static gboolean
+add_stream_output_switch (AlsaDevice *device, snd_mixer_elem_t *el)
+{
+    g_debug ("Reading device %s output switch %s (%d items)",
+             mate_mixer_device_get_name (MATE_MIXER_DEVICE (device)),
+             snd_mixer_selem_get_name (el),
+             snd_mixer_selem_get_enum_items (el));
+
+    return add_switch (device, device->priv->output, el);
+}
+
+static gboolean
+add_stream_input_toggle (AlsaDevice *device, snd_mixer_elem_t *el)
+{
+    AlsaToggle *toggle;
+
+    g_debug ("Reading device %s input toggle %s",
+             mate_mixer_device_get_name (MATE_MIXER_DEVICE (device)),
+             snd_mixer_selem_get_name (el));
+
+    toggle = create_toggle (device, el, ALSA_TOGGLE_CAPTURE);
+
+    if (add_element (device, device->priv->input, ALSA_ELEMENT (toggle)) == FALSE) {
+        g_object_unref (toggle);
+        return FALSE;
+    }
+    return TRUE;
+}
+
+static gboolean
+add_stream_output_toggle (AlsaDevice *device, snd_mixer_elem_t *el)
+{
+    AlsaToggle *toggle;
+
+    g_debug ("Reading device %s output toggle %s",
+             mate_mixer_device_get_name (MATE_MIXER_DEVICE (device)),
+             snd_mixer_selem_get_name (el));
+
+    toggle = create_toggle (device, el, ALSA_TOGGLE_PLAYBACK);
+
+    if (add_element (device, device->priv->output, ALSA_ELEMENT (toggle)) == FALSE) {
+        g_object_unref (toggle);
+        return FALSE;
+    }
+    return TRUE;
+}
+
+static void
+load_element (AlsaDevice *device, snd_mixer_elem_t *el)
+{
+    gboolean cvolume = FALSE;
+    gboolean pvolume = FALSE;
+
+    if (snd_mixer_selem_is_enumerated (el) == 1) {
+        gboolean cenum = FALSE;
+        gboolean penum = FALSE;
+
+        if (snd_mixer_selem_is_enum_capture (el) == 1)
+            cenum = TRUE;
+        if (snd_mixer_selem_is_enum_playback (el) == 1)
+            penum = TRUE;
+
+        /* Enumerated controls which are not marked as capture or playback
+         * are considered to be a part of the whole device, although sometimes
+         * this is incorrectly reported by the driver */
+        if (cenum == FALSE && penum == FALSE) {
+            add_device_switch (device, el);
+        }
+        else if (cenum == TRUE)
+            add_stream_input_switch (device, el);
+        else if (penum == TRUE)
+            add_stream_output_switch (device, el);
+    }
+
+    if (snd_mixer_selem_has_capture_volume (el) == 1 ||
+        snd_mixer_selem_has_common_volume (el) == 1)
+        cvolume = TRUE;
+    if (snd_mixer_selem_has_playback_volume (el) == 1 ||
+        snd_mixer_selem_has_common_volume (el) == 1)
+        pvolume = TRUE;
+
+    if (cvolume == FALSE && pvolume == FALSE) {
+        /* Control without volume and with a switch are modelled as toggles */
+        if (snd_mixer_selem_has_capture_switch (el) == 1)
+            add_stream_input_toggle (device, el);
+
+        if (snd_mixer_selem_has_playback_switch (el) == 1)
+            add_stream_output_toggle (device, el);
+    } else {
+        if (cvolume == TRUE)
+            add_stream_input_control (device, el);
+        if (pvolume == TRUE)
+            add_stream_output_control (device, el);
+    }
+}
+
+static void
+load_elements_by_name (AlsaDevice *device, const gchar *name)
+{
+    AlsaElement *element;
+
+    alsa_stream_load_elements (device->priv->input, name);
+    alsa_stream_load_elements (device->priv->output, name);
+
+    element = g_hash_table_lookup (device->priv->switches, name);
+    if (element != NULL)
+        alsa_element_load (element);
+}
+
+static void
+remove_elements_by_name (AlsaDevice *device, const gchar *name)
+{
+    if (alsa_stream_remove_elements (device->priv->input, name) == TRUE) {
+        /* Removing last stream element "removes" the stream */
+        if (alsa_stream_is_empty (device->priv->input) == TRUE) {
+            const gchar *stream_name =
+                mate_mixer_stream_get_name (MATE_MIXER_STREAM (device->priv->input));
+
+            g_signal_emit_by_name (G_OBJECT (device),
+                                   "stream-removed",
+                                   stream_name);
+        }
+    }
+
+    if (alsa_stream_remove_elements (device->priv->output, name) == TRUE) {
+        /* Removing last stream element "removes" the stream */
+        if (alsa_stream_is_empty (device->priv->output) == TRUE) {
+            const gchar *stream_name =
+                mate_mixer_stream_get_name (MATE_MIXER_STREAM (device->priv->output));
+
+            g_signal_emit_by_name (G_OBJECT (device),
+                                   "stream-removed",
+                                   stream_name);
+        }
+    }
+
+    if (g_hash_table_remove (device->priv->switches, name) == TRUE)
+        g_signal_emit_by_name (G_OBJECT (device),
+                               "switch-removed",
+                               name);
+}
+
+static void
+handle_poll (AlsaDevice *device)
+{
+    /* This function is called in a worker thread. It is supposed to wait for
+     * ALSA events and call handle_process_events(). Processing the events might
+     * result in emitting the CLOSED signal and unreffing the instance in the
+     * owner, so keep an extra reference during the lifetime of the thread. */
+    g_object_ref (device);
+
+    while (TRUE) {
+        gint ret = snd_mixer_wait (device->priv->handle, -1);
+        if (ret < 0) {
+            if (ret == EINTR)
+                continue;
+            break;
+        }
+
+        device->priv->events_pending = TRUE;
+
+        /* Process the events in the main thread because most events end up
+         * emitting signals */
+        g_main_context_invoke (device->priv->context,
+                               (GSourceFunc) handle_process_events,
+                               device);
+
+        g_mutex_lock (&device->priv->mutex);
+
+        /* Use a GCond to wait until the events are processed. The processing
+         * function may be called any time later in the main loop and snd_mixer_wait()
+         * returns instantly while there are pending events. Without the wait,
+         * g_main_context_invoke() could be called repeatedly to create idle sources
+         * until the first idle source function is called. */
+        while (device->priv->events_pending == TRUE)
+            g_cond_wait (&device->priv->cond, &device->priv->mutex);
+
+        g_mutex_unlock (&device->priv->mutex);
+
+        /* Exit the thread if the processing function closed the device */
+        if (device->priv->handle == NULL)
+            break;
+    }
+
+    g_debug ("Terminating poll thread for device %s",
+             mate_mixer_device_get_name (MATE_MIXER_DEVICE (device)));
+
+    g_object_unref (device);
+}
+
+static gboolean
+handle_process_events (AlsaDevice *device)
+{
+    g_mutex_lock (&device->priv->mutex);
+
+    if (device->priv->handle != NULL) {
+        gint ret = snd_mixer_handle_events (device->priv->handle);
+        if (ret < 0)
+            close_device (device);
+    }
+
+    device->priv->events_pending = FALSE;
+
+    g_cond_signal (&device->priv->cond);
+    g_mutex_unlock (&device->priv->mutex);
+
+    return G_SOURCE_REMOVE;
+}
+
+/* ALSA has a per-mixer callback and per-element callback, per-mixer callback
+ * is only used for added elements and per-element callback for all the
+ * other messages (no, the documentation doesn't say anything about that). */
+static int
+handle_callback (snd_mixer_t *handle, guint mask, snd_mixer_elem_t *el)
+{
+    if (mask & SND_CTL_EVENT_MASK_ADD) {
+        AlsaDevice *device = snd_mixer_get_callback_private (handle);
+
+        load_element (device, el);
+    }
+    return 0;
+}
+
+static int
+handle_element_callback (snd_mixer_elem_t *el, guint mask)
+{
+    AlsaDevice *device;
+    gchar      *name;
+
+    device = snd_mixer_elem_get_callback_private (el);
+    name = get_element_name (el);
+
+    if (mask == SND_CTL_EVENT_MASK_REMOVE) {
+        /* Make sure this function is not called again with the element */
+        snd_mixer_elem_set_callback_private (el, NULL);
+        snd_mixer_elem_set_callback (el, NULL);
+
+        remove_elements_by_name (device, name);
+    } else {
+        if (mask & SND_CTL_EVENT_MASK_INFO) {
+            remove_elements_by_name (device, name);
+            load_element (device, el);
+        }
+        if (mask & SND_CTL_EVENT_MASK_VALUE)
+            load_elements_by_name (device, name);
+    }
+    g_free (name);
+
+    return 0;
+}
+
+static void
+close_device (AlsaDevice *device)
+{
+    if (device->priv->handle != NULL) {
+        snd_mixer_close (device->priv->handle);
+        device->priv->handle = NULL;
+    }
+
+    /* This signal tells the owner that the device has been closed voluntarily
+     * from within the instance */
+    g_signal_emit (G_OBJECT (device), signals[CLOSED], 0);
+}
+
+static gchar *
+get_element_name (snd_mixer_elem_t *el)
+{
+    return g_strdup_printf ("%s-%d",
+                            snd_mixer_selem_get_name (el),
+                            snd_mixer_selem_get_index (el));
+}
+
+static void
+get_control_info (snd_mixer_elem_t           *el,
+                  gchar                     **name,
+                  gchar                     **label,
+                  MateMixerStreamControlRole *role)
+{
+    MateMixerStreamControlRole r = MATE_MIXER_STREAM_CONTROL_ROLE_UNKNOWN;
+    const gchar               *n;
+    const gchar               *l = NULL;
+    gint                       i;
+
+    n = snd_mixer_selem_get_name (el);
+
+    for (i = 0; alsa_controls[i].name != NULL; i++)
+        if (strcmp (n, alsa_controls[i].name) == 0) {
+            l = alsa_controls[i].label;
+            r = alsa_controls[i].role;
+            break;
+        }
+
+    *name = get_element_name (el);
+    if (l != NULL)
+        *label = g_strdup (l);
+    else
+        *label = g_strdup (n);
+
+    *role = r;
+}
+
+static void
+get_switch_info (snd_mixer_elem_t           *el,
+                 gchar                     **name,
+                 gchar                     **label)
+{
+    // MateMixerStreamControlRole r = MATE_MIXER_STREAM_CONTROL_ROLE_UNKNOWN;
+    const gchar               *n;
+    const gchar               *l = NULL;
+    // gint                       i;
+
+    n = snd_mixer_selem_get_name (el);
+
+    // TODO provide translated label and flags
+
+/*
+    for (i = 0; alsa_controls[i].name != NULL; i++)
+        if (strcmp (n, alsa_controls[i].name) == 0) {
+            l = alsa_controls[i].label;
+            r = alsa_controls[i].role;
+            break;
+        }
+*/
+    *name = get_element_name (el);
+    if (l != NULL)
+        *label = g_strdup (l);
+    else
+        *label = g_strdup (n);
+
+    // *role = r;
+}