Weekly update

50 files changed, 3570 insertions, 1234 deletions

diff --git a/Makefile.am b/Makefile.am
index 57aa03e..0eb7591 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -4,9 +4,9 @@ SUBDIRS =                               \
         libmatemixer                    \
         backends                        \
         data                            \
-        doc
+        docs
 
-EXTRA_DIR = autogen.sh
+EXTRA_DIST = autogen.sh
 
 MAINTAINERCLEANFILES =                  \
     $(srcdir)/aclocal.m4                \
diff --git a/backends/null/Makefile.am b/backends/null/Makefile.am
index b6d92c7..f28bc06 100644
--- a/backends/null/Makefile.am
+++ b/backends/null/Makefile.am
@@ -6,15 +6,13 @@ AM_CPPFLAGS =                                                   \
         -I$(top_srcdir)                                         \
         -DG_LOG_DOMAIN=\"libmatemixer-null\"
 
-libmatemixer_null_la_CFLAGS =                                   \
-        $(GLIB_CFLAGS)
+libmatemixer_null_la_CFLAGS = $(GLIB_CFLAGS)
 
 libmatemixer_null_la_SOURCES =                                  \
         null.c                                                  \
         null.h
 
-libmatemixer_null_la_LIBADD =                                   \
-        $(GLIB_LIBS)
+libmatemixer_null_la_LIBADD = $(GLIB_LIBS)
 
 libmatemixer_null_la_LDFLAGS =                                  \
         -avoid-version                                          \
diff --git a/backends/null/null.c b/backends/null/null.c
index b96c9b0..1e8085d 100644
--- a/backends/null/null.c
+++ b/backends/null/null.c
@@ -26,19 +26,17 @@
 #define BACKEND_NAME      "Null"
 #define BACKEND_PRIORITY   999
 
-/* Support function for dynamic loading of the backend module */
-void  backend_module_init (GTypeModule *module);
-
-const MateMixerBackendModuleInfo *backend_module_get_info (void);
-
 static void mate_mixer_backend_interface_init (MateMixerBackendInterface *iface);
+static void mate_mixer_null_class_init        (MateMixerNullClass        *klass);
+static void mate_mixer_null_class_finalize    (MateMixerNullClass        *klass);
+static void mate_mixer_null_init              (MateMixerNull             *null);
 
 G_DEFINE_DYNAMIC_TYPE_EXTENDED (MateMixerNull, mate_mixer_null,
                                 G_TYPE_OBJECT, 0,
                                 G_IMPLEMENT_INTERFACE_DYNAMIC (MATE_MIXER_TYPE_BACKEND,
                                                                mate_mixer_backend_interface_init))
 
-static MateMixerBackendModuleInfo info;
+static MateMixerBackendInfo info;
 
 void
 backend_module_init (GTypeModule *module)
@@ -48,10 +46,10 @@ backend_module_init (GTypeModule *module)
     info.name         = BACKEND_NAME;
     info.priority     = BACKEND_PRIORITY;
     info.g_type       = MATE_MIXER_TYPE_NULL;
-    info.backend_type = MATE_MIXER_BACKEND_TYPE_NULL;
+    info.backend_type = MATE_MIXER_BACKEND_NULL;
 }
 
-const MateMixerBackendModuleInfo *
+const MateMixerBackendInfo *
 backend_module_get_info (void)
 {
     return &info;
@@ -64,28 +62,18 @@ mate_mixer_backend_interface_init (MateMixerBackendInterface *iface)
 }
 
 static void
-mate_mixer_null_init (MateMixerNull *null)
-{
-}
-
-static void
-mate_mixer_null_finalize (GObject *object)
+mate_mixer_null_class_init (MateMixerNullClass *klass)
 {
-    G_OBJECT_CLASS (mate_mixer_null_parent_class)->finalize (object);
 }
 
+/* Called in the code generated by G_DEFINE_DYNAMIC_TYPE_EXTENDED() */
 static void
-mate_mixer_null_class_init (MateMixerNullClass *klass)
+mate_mixer_null_class_finalize (MateMixerNullClass *klass)
 {
-    GObjectClass *object_class;
-
-    object_class = G_OBJECT_CLASS (klass);
-    object_class->finalize = mate_mixer_null_finalize;
 }
 
-/* Called in the code generated by G_DEFINE_DYNAMIC_TYPE_EXTENDED() */
 static void
-mate_mixer_null_class_finalize (MateMixerNullClass *klass)
+mate_mixer_null_init (MateMixerNull *null)
 {
 }
 
diff --git a/backends/null/null.h b/backends/null/null.h
index d73794e..c9dd501 100644
--- a/backends/null/null.h
+++ b/backends/null/null.h
@@ -51,6 +51,10 @@ struct _MateMixerNullClass
 
 GType mate_mixer_null_get_type (void) G_GNUC_CONST;
 
-gboolean mate_mixer_null_open (MateMixerBackend *backend);
+/* Support function for dynamic loading of the backend module */
+void                        backend_module_init     (GTypeModule      *module);
+const MateMixerBackendInfo *backend_module_get_info (void);
+
+gboolean                    mate_mixer_null_open    (MateMixerBackend *backend);
 
 #endif /* MATEMIXER_NULL_H */
diff --git a/backends/pulse/Makefile.am b/backends/pulse/Makefile.am
index 2f7cd6f..2cc7b5e 100644
--- a/backends/pulse/Makefile.am
+++ b/backends/pulse/Makefile.am
@@ -13,10 +13,20 @@ libmatemixer_pulse_la_CFLAGS =                                  \
 libmatemixer_pulse_la_SOURCES =                                 \
         pulse.c                                                 \
         pulse.h                                                 \
+        pulse-connection.c                                      \
+        pulse-connection.h                                      \
         pulse-device.c                                          \
         pulse-device.h                                          \
-        pulse-track.c                                           \
-        pulse-track.h
+        pulse-stream.c                                          \
+        pulse-stream.h                                          \
+        pulse-sink.c                                            \
+        pulse-sink.h                                            \
+        pulse-sink-input.c                                      \
+        pulse-sink-input.h                                      \
+        pulse-source.c                                          \
+        pulse-source.h                                          \
+        pulse-source-output.c                                   \
+        pulse-source-output.h
 
 libmatemixer_pulse_la_LIBADD =                                  \
         $(GLIB_LIBS)                                            \
diff --git a/backends/pulse/pulse-connection.c b/backends/pulse/pulse-connection.c
new file mode 100644
index 0000000..6c70490
--- /dev/null
+++ b/backends/pulse/pulse-connection.c
@@ -0,0 +1,764 @@
+/*
+ * 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 <glib.h>
+#include <glib-object.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <pulse/pulseaudio.h>
+
+#include "pulse-connection.h"
+
+struct _MateMixerPulseConnectionPrivate
+{
+    gchar                 *server;
+    gboolean               reconnect;
+    gboolean               connected;
+    pa_context            *context;
+    pa_threaded_mainloop  *mainloop;
+};
+
+enum {
+    PROP_0,
+    PROP_SERVER,
+    PROP_RECONNECT,
+    PROP_CONNECTED,
+    N_PROPERTIES
+};
+
+enum {
+    LIST_ITEM_CARD,
+    LIST_ITEM_SINK,
+    LIST_ITEM_SOURCE,
+    LIST_ITEM_SINK_INPUT,
+    LIST_ITEM_SOURCE_OUTPUT,
+    CARD_ADDED,
+    CARD_REMOVED,
+    CARD_CHANGED,
+    SINK_ADDED,
+    SINK_REMOVED,
+    SINK_CHANGED,
+    SOURCE_ADDED,
+    SOURCE_REMOVED,
+    SOURCE_CHANGED,
+    N_SIGNALS
+};
+
+static GParamSpec *properties[N_PROPERTIES] = { NULL, };
+
+static guint signals[N_SIGNALS] = { 0, };
+
+G_DEFINE_TYPE (MateMixerPulseConnection, mate_mixer_pulse_connection, G_TYPE_OBJECT);
+
+static gchar *pulse_connection_get_name (void);
+
+static gboolean pulse_connection_process_operation (MateMixerPulseConnection *connection,
+                                                    pa_operation *o);
+
+static void pulse_connection_state_cb (pa_context *c, void *userdata);
+
+static void pulse_connection_subscribe_cb (pa_context *c,
+                                           pa_subscription_event_type_t t,
+                                            uint32_t idx,
+                                            void *userdata);
+
+static void pulse_connection_card_info_cb (pa_context *c,
+                                           const pa_card_info *info,
+                                           int eol,
+                                           void *userdata);
+
+static void pulse_connection_sink_info_cb (pa_context *c,
+                                            const pa_sink_info *info,
+                                            int eol,
+                                            void *userdata);
+
+static void pulse_connection_source_info_cb (pa_context *c,
+                                             const pa_source_info *info,
+                                             int eol,
+                                             void *userdata);
+
+static void pulse_connection_sink_input_info_cb (pa_context *c,
+                                                const pa_sink_input_info *info,
+                                                int eol,
+                                                void *userdata);
+
+static void pulse_connection_source_output_info_cb (pa_context *c,
+                                                    const pa_source_output_info *info,
+                                                    int eol,
+                                                    void *userdata);
+
+static void
+mate_mixer_pulse_connection_init (MateMixerPulseConnection *connection)
+{
+    connection->priv = G_TYPE_INSTANCE_GET_PRIVATE (
+        connection,
+        MATE_MIXER_TYPE_PULSE_CONNECTION,
+        MateMixerPulseConnectionPrivate);
+}
+
+static void
+mate_mixer_pulse_connection_get_property (GObject     *object,
+                                          guint        param_id,
+                                          GValue      *value,
+                                          GParamSpec  *pspec)
+{
+    MateMixerPulseConnection *connection;
+
+    connection = MATE_MIXER_PULSE_CONNECTION (object);
+
+    switch (param_id) {
+    case PROP_SERVER:
+        g_value_set_string (value, connection->priv->server);
+        break;
+    case PROP_RECONNECT:
+        g_value_set_boolean (value, connection->priv->reconnect);
+        break;
+    case PROP_CONNECTED:
+        g_value_set_boolean (value, connection->priv->connected);
+        break;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+        break;
+    }
+}
+
+static void
+mate_mixer_pulse_connection_set_property (GObject       *object,
+                                          guint          param_id,
+                                          const GValue  *value,
+                                          GParamSpec    *pspec)
+{
+    MateMixerPulseConnection *connection;
+
+    connection = MATE_MIXER_PULSE_CONNECTION (object);
+
+    switch (param_id) {
+    case PROP_SERVER:
+        connection->priv->server = g_strdup (g_value_get_string (value));
+        break;
+    case PROP_RECONNECT:
+        connection->priv->reconnect = g_value_get_boolean (value);
+        break;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+        break;
+    }
+}
+
+static void
+mate_mixer_pulse_connection_finalize (GObject *object)
+{
+    MateMixerPulseConnection *connection;
+
+    connection = MATE_MIXER_PULSE_CONNECTION (object);
+
+    g_free (connection->priv->server);
+
+    G_OBJECT_CLASS (mate_mixer_pulse_connection_parent_class)->finalize (object);
+}
+
+static void
+mate_mixer_pulse_connection_class_init (MateMixerPulseConnectionClass *klass)
+{
+    GObjectClass *object_class;
+
+    object_class = G_OBJECT_CLASS (klass);
+    object_class->finalize     = mate_mixer_pulse_connection_finalize;
+    object_class->get_property = mate_mixer_pulse_connection_get_property;
+    object_class->set_property = mate_mixer_pulse_connection_set_property;
+
+    properties[PROP_SERVER] = g_param_spec_string (
+        "server",
+        "Server",
+        "PulseAudio server to connect to",
+        NULL,
+        G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+    properties[PROP_RECONNECT] = g_param_spec_boolean (
+        "reconnect",
+        "Reconnect",
+        "Try to reconnect when connection to PulseAudio server is lost",
+        TRUE,
+        G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+
+    properties[PROP_CONNECTED] = g_param_spec_boolean (
+        "connected",
+        "Connected",
+        "Connected to a PulseAudio server or not",
+        FALSE,
+        G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+
+    signals[LIST_ITEM_CARD] = g_signal_new (
+        "list-item-card",
+        G_TYPE_FROM_CLASS (object_class),
+        G_SIGNAL_RUN_LAST,
+        G_STRUCT_OFFSET (MateMixerPulseConnectionClass, list_item_card),
+        NULL,
+        NULL,
+        g_cclosure_marshal_VOID__POINTER,
+        G_TYPE_NONE,
+        1,
+        G_TYPE_POINTER);
+
+    signals[LIST_ITEM_SINK] = g_signal_new (
+        "list-item-sink",
+        G_TYPE_FROM_CLASS (object_class),
+        G_SIGNAL_RUN_LAST,
+        G_STRUCT_OFFSET (MateMixerPulseConnectionClass, list_item_sink),
+        NULL,
+        NULL,
+        g_cclosure_marshal_VOID__POINTER,
+        G_TYPE_NONE,
+        1,
+        G_TYPE_POINTER);
+
+    signals[LIST_ITEM_SINK_INPUT] = g_signal_new (
+        "list-item-sink-input",
+        G_TYPE_FROM_CLASS (object_class),
+        G_SIGNAL_RUN_LAST,
+        G_STRUCT_OFFSET (MateMixerPulseConnectionClass, list_item_sink_input),
+        NULL,
+        NULL,
+        g_cclosure_marshal_VOID__POINTER,
+        G_TYPE_NONE,
+        1,
+        G_TYPE_POINTER);
+
+    signals[LIST_ITEM_SOURCE] = g_signal_new (
+        "list-item-source",
+        G_TYPE_FROM_CLASS (object_class),
+        G_SIGNAL_RUN_LAST,
+        G_STRUCT_OFFSET (MateMixerPulseConnectionClass, list_item_source),
+        NULL,
+        NULL,
+        g_cclosure_marshal_VOID__POINTER,
+        G_TYPE_NONE,
+        1,
+        G_TYPE_POINTER);
+
+    signals[LIST_ITEM_SOURCE_OUTPUT] = g_signal_new (
+        "list-item-source-output",
+        G_TYPE_FROM_CLASS (object_class),
+        G_SIGNAL_RUN_LAST,
+        G_STRUCT_OFFSET (MateMixerPulseConnectionClass, list_item_source_output),
+        NULL,
+        NULL,
+        g_cclosure_marshal_VOID__POINTER,
+        G_TYPE_NONE,
+        1,
+        G_TYPE_POINTER);
+
+    g_object_class_install_properties (object_class, N_PROPERTIES, properties);
+
+    g_type_class_add_private (object_class, sizeof (MateMixerPulseConnectionPrivate));
+}
+
+// XXX: pass more info about application, provide API
+
+MateMixerPulseConnection *
+mate_mixer_pulse_connection_new (const gchar *server, const gchar *app_name)
+{
+    pa_threaded_mainloop      *mainloop;
+    pa_context                *context;
+    MateMixerPulseConnection  *connection;
+
+    mainloop = pa_threaded_mainloop_new ();
+    if (G_UNLIKELY (mainloop == NULL)) {
+        g_warning ("Failed to create PulseAudio main loop");
+        return NULL;
+    }
+
+    if (app_name != NULL) {
+        context = pa_context_new (
+            pa_threaded_mainloop_get_api (mainloop),
+            app_name);
+    } else {
+        gchar *name = pulse_connection_get_name ();
+
+        context = pa_context_new (
+            pa_threaded_mainloop_get_api (mainloop),
+            name);
+
+        g_free (name);
+    }
+
+    if (G_UNLIKELY (context == NULL)) {
+        g_warning ("Failed to create PulseAudio context");
+
+        pa_threaded_mainloop_free (mainloop);
+        return NULL;
+    }
+
+    connection = g_object_new (MATE_MIXER_TYPE_PULSE_CONNECTION,
+        "server",    server,
+        "reconnect", TRUE,
+        NULL);
+
+    connection->priv->mainloop = mainloop;
+    connection->priv->context = context;
+
+    return connection;
+}
+
+gboolean
+mate_mixer_pulse_connection_connect (MateMixerPulseConnection *connection)
+{
+    int ret;
+    pa_operation *o;
+
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_CONNECTION (connection), FALSE);
+
+    if (connection->priv->connected)
+        return TRUE;
+
+    /* Initiate a connection, this call does not guarantee the connection
+     * to be established and usable */
+    ret = pa_context_connect (connection->priv->context, NULL, PA_CONTEXT_NOFLAGS, NULL);
+    if (ret < 0) {
+        g_warning ("Failed to connect to PulseAudio server: %s", pa_strerror (ret));
+        return FALSE;
+    }
+
+    pa_threaded_mainloop_lock (connection->priv->mainloop);
+
+    /* Set callback for connection status changes; the callback is not really
+     * used when connecting the first time, it is only needed to signal
+     * a status change */
+    pa_context_set_state_callback (connection->priv->context,
+        pulse_connection_state_cb,
+        connection);
+
+    ret = pa_threaded_mainloop_start (connection->priv->mainloop);
+    if (ret < 0) {
+        g_warning ("Failed to start PulseAudio main loop: %s", pa_strerror (ret));
+
+        pa_context_disconnect (connection->priv->context);
+        pa_threaded_mainloop_unlock (connection->priv->mainloop);
+        return FALSE;
+    }
+
+    while (TRUE) {
+        /* Wait for a connection state which tells us whether the connection
+         * has been established or has failed */
+        pa_context_state_t state =
+            pa_context_get_state (connection->priv->context);
+
+        if (state == PA_CONTEXT_READY)
+            break;
+
+        if (state == PA_CONTEXT_FAILED ||
+            state == PA_CONTEXT_TERMINATED) {
+            g_warning ("Failed to connect to PulseAudio server: %s",
+                pa_strerror (pa_context_errno (connection->priv->context)));
+
+            pa_context_disconnect (connection->priv->context);
+            pa_threaded_mainloop_unlock (connection->priv->mainloop);
+            return FALSE;
+        }
+        pa_threaded_mainloop_wait (connection->priv->mainloop);
+    }
+
+    pa_context_set_subscribe_callback (connection->priv->context,
+        pulse_connection_subscribe_cb,
+        connection);
+
+    // XXX don't want notifications before the initial lists are downloaded
+
+    o = pa_context_subscribe (connection->priv->context,
+        PA_SUBSCRIPTION_MASK_CARD |
+        PA_SUBSCRIPTION_MASK_SINK |
+        PA_SUBSCRIPTION_MASK_SOURCE |
+        PA_SUBSCRIPTION_MASK_SINK_INPUT |
+        PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT,
+        NULL, NULL);
+    if (o == NULL)
+        g_warning ("Failed to subscribe to PulseAudio notifications: %s",
+            pa_strerror (pa_context_errno (connection->priv->context)));
+    else
+        pa_operation_unref (o);
+
+    pa_threaded_mainloop_unlock (connection->priv->mainloop);
+
+    connection->priv->connected = TRUE;
+
+    g_object_notify_by_pspec (G_OBJECT (connection), properties[PROP_CONNECTED]);
+    return TRUE;
+}
+
+void
+mate_mixer_pulse_connection_disconnect (MateMixerPulseConnection *connection)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_CONNECTION (connection), FALSE);
+
+    if (!connection->priv->connected)
+        return;
+
+    pa_context_disconnect (connection->priv->context);
+
+    connection->priv->connected = FALSE;
+
+    g_object_notify_by_pspec (G_OBJECT (connection), properties[PROP_CONNECTED]);
+}
+
+gboolean
+mate_mixer_pulse_connection_get_server_info (MateMixerPulseConnection *connection)
+{
+    // TODO
+    return TRUE;
+}
+
+gboolean
+mate_mixer_pulse_connection_get_card_list (MateMixerPulseConnection *connection)
+{
+    pa_operation *o;
+    gboolean ret;
+
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_CONNECTION (connection), FALSE);
+
+    pa_threaded_mainloop_lock (connection->priv->mainloop);
+
+    o = pa_context_get_card_info_list (
+        connection->priv->context,
+        pulse_connection_card_info_cb,
+        connection);
+
+    ret = pulse_connection_process_operation (connection, o);
+
+    pa_threaded_mainloop_unlock (connection->priv->mainloop);
+    return ret;
+}
+
+gboolean
+mate_mixer_pulse_connection_get_sink_list (MateMixerPulseConnection *connection)
+{
+    pa_operation *o;
+    gboolean ret;
+
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_CONNECTION (connection), FALSE);
+
+    pa_threaded_mainloop_lock (connection->priv->mainloop);
+
+    o = pa_context_get_sink_info_list (
+        connection->priv->context,
+        pulse_connection_sink_info_cb,
+        connection);
+
+    ret = pulse_connection_process_operation (connection, o);
+
+    pa_threaded_mainloop_unlock (connection->priv->mainloop);
+    return ret;
+}
+
+gboolean
+mate_mixer_pulse_connection_get_sink_input_list (MateMixerPulseConnection *connection)
+{
+    pa_operation *o;
+    gboolean ret;
+
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_CONNECTION (connection), FALSE);
+
+    pa_threaded_mainloop_lock (connection->priv->mainloop);
+
+    o = pa_context_get_sink_input_info_list (
+        connection->priv->context,
+        pulse_connection_sink_input_info_cb,
+        connection);
+
+    ret = pulse_connection_process_operation (connection, o);
+
+    pa_threaded_mainloop_unlock (connection->priv->mainloop);
+    return ret;
+}
+
+gboolean
+mate_mixer_pulse_connection_get_source_list (MateMixerPulseConnection *connection)
+{
+    pa_operation  *o;
+    gboolean       ret;
+
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_CONNECTION (connection), FALSE);
+
+    pa_threaded_mainloop_lock (connection->priv->mainloop);
+
+    o = pa_context_get_source_info_list (
+        connection->priv->context,
+        pulse_connection_source_info_cb,
+        connection);
+
+    ret = pulse_connection_process_operation (connection, o);
+
+    pa_threaded_mainloop_unlock (connection->priv->mainloop);
+    return ret;
+}
+
+gboolean
+mate_mixer_pulse_connection_get_source_output_list (MateMixerPulseConnection *connection)
+{
+    pa_operation *o;
+    gboolean ret;
+
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_CONNECTION (connection), FALSE);
+
+    pa_threaded_mainloop_lock (connection->priv->mainloop);
+
+    o = pa_context_get_source_output_info_list (
+        connection->priv->context,
+        pulse_connection_source_output_info_cb,
+        connection);
+
+    ret = pulse_connection_process_operation (connection, o);
+
+    pa_threaded_mainloop_unlock (connection->priv->mainloop);
+    return ret;
+}
+
+gboolean
+mate_mixer_pulse_connection_set_card_profile (MateMixerPulseConnection *connection,
+                                              const gchar              *card,
+                                              const gchar              *profile)
+{
+    pa_operation *o;
+    gboolean ret;
+
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_CONNECTION (connection), FALSE);
+
+    pa_threaded_mainloop_lock (connection->priv->mainloop);
+
+    o = pa_context_set_card_profile_by_name (
+        connection->priv->context,
+        card,
+        profile,
+        NULL, NULL);
+
+    // XXX maybe shouldn't wait for the completion
+
+    ret = pulse_connection_process_operation (connection, o);
+
+    pa_threaded_mainloop_unlock (connection->priv->mainloop);
+    return ret;
+}
+
+gboolean
+mate_mixer_pulse_connection_set_sink_mute (MateMixerPulseConnection *connection,
+                                           guint32 index,
+                                           gboolean mute)
+{
+    pa_operation *o;
+    gboolean ret;
+
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_CONNECTION (connection), FALSE);
+
+    pa_threaded_mainloop_lock (connection->priv->mainloop);
+
+    o = pa_context_set_sink_mute_by_index (
+        connection->priv->context,
+        index,
+        (int) mute,
+        NULL, NULL);
+
+    // XXX maybe shouldn't wait for the completion
+
+    ret = pulse_connection_process_operation (connection, o);
+
+    pa_threaded_mainloop_unlock (connection->priv->mainloop);
+    return ret;
+}
+
+static gboolean
+pulse_connection_process_operation (MateMixerPulseConnection *connection,
+                                    pa_operation *o)
+{
+    if (o == NULL) {
+        g_warning ("Failed to process PulseAudio operation: %s",
+            pa_strerror (pa_context_errno (connection->priv->context)));
+
+        return FALSE;
+    }
+
+    while (pa_operation_get_state (o) == PA_OPERATION_RUNNING)
+        pa_threaded_mainloop_wait (connection->priv->mainloop);
+
+    pa_operation_unref (o);
+    return TRUE;
+}
+
+static gchar *
+pulse_connection_get_name (void)
+{
+    const char *name_app;
+    char        name_buf[256];
+
+    /* Inspired by GStreamer's pulse plugin */
+    name_app = g_get_application_name ();
+    if (name_app != NULL)
+        return g_strdup (name_app);
+
+    if (pa_get_binary_name (name_buf, sizeof (name_buf)) != NULL)
+        return g_strdup (name_buf);
+
+    return g_strdup_printf ("libmatemixer-%lu", (gulong) getpid ());
+}
+
+static void
+pulse_connection_state_cb (pa_context *c, void *userdata)
+{
+    MateMixerPulseConnection  *connection;
+    pa_context_state_t         state;
+
+    connection = MATE_MIXER_PULSE_CONNECTION (userdata);
+
+    state = pa_context_get_state (c);
+    switch (state) {
+    case PA_CONTEXT_READY:
+        /* The connection is established, the context is ready to
+         * execute operations. */
+        if (!connection->priv->connected) {
+            connection->priv->connected = TRUE;
+
+            g_object_notify_by_pspec (
+                G_OBJECT (connection),
+                properties[PROP_CONNECTED]);
+        }
+        break;
+
+    case PA_CONTEXT_TERMINATED:
+        /* The connection was terminated cleanly. */
+        if (connection->priv->connected) {
+            connection->priv->connected = FALSE;
+
+            g_object_notify_by_pspec (
+                G_OBJECT (connection),
+                properties[PROP_CONNECTED]);
+
+            pa_context_disconnect (connection->priv->context);
+        }
+        break;
+
+    case PA_CONTEXT_FAILED:
+        break;
+
+    default:
+        break;
+    }
+
+    pa_threaded_mainloop_signal (connection->priv->mainloop, 0);
+}
+
+static void
+pulse_connection_subscribe_cb (pa_context *c,
+                               pa_subscription_event_type_t t,
+                               uint32_t idx,
+                               void *userdata)
+{
+    // TODO
+}
+
+static void
+pulse_connection_card_info_cb (pa_context *c,
+                               const pa_card_info *info,
+                               int eol,
+                               void *userdata)
+{
+    MateMixerPulseConnection *connection;
+
+    connection = MATE_MIXER_PULSE_CONNECTION (userdata);
+
+    if (!eol)
+        g_signal_emit (G_OBJECT (connection),
+            signals[LIST_ITEM_CARD],
+            0,
+            info);
+
+    pa_threaded_mainloop_signal (connection->priv->mainloop, 0);
+}
+
+static void
+pulse_connection_sink_info_cb (pa_context *c,
+                               const pa_sink_info *info,
+                               int eol,
+                               void *userdata)
+{
+    MateMixerPulseConnection *connection;
+
+    connection = MATE_MIXER_PULSE_CONNECTION (userdata);
+
+    if (!eol)
+        g_signal_emit (G_OBJECT (connection),
+            signals[LIST_ITEM_SINK],
+            0,
+            info);
+
+    pa_threaded_mainloop_signal (connection->priv->mainloop, 0);
+}
+
+static void
+pulse_connection_sink_input_info_cb (pa_context *c,
+                                     const pa_sink_input_info *info,
+                                     int eol,
+                                     void *userdata)
+{
+    MateMixerPulseConnection *connection;
+
+    connection = MATE_MIXER_PULSE_CONNECTION (userdata);
+
+    if (!eol)
+        g_signal_emit (G_OBJECT (connection),
+            signals[LIST_ITEM_SINK_INPUT],
+            0,
+            info);
+
+    pa_threaded_mainloop_signal (connection->priv->mainloop, 0);
+}
+
+static void
+pulse_connection_source_info_cb (pa_context *c,
+                                 const pa_source_info *info,
+                                 int eol,
+                                 void *userdata)
+{
+    MateMixerPulseConnection *connection;
+
+    connection = MATE_MIXER_PULSE_CONNECTION (userdata);
+
+    if (!eol)
+        g_signal_emit (G_OBJECT (connection),
+            signals[LIST_ITEM_SOURCE],
+            0,
+            info);
+
+    pa_threaded_mainloop_signal (connection->priv->mainloop, 0);
+}
+
+static void
+pulse_connection_source_output_info_cb (pa_context *c,
+                                        const pa_source_output_info *info,
+                                        int eol,
+                                        void *userdata)
+{
+    MateMixerPulseConnection *connection;
+
+    connection = MATE_MIXER_PULSE_CONNECTION (userdata);
+
+    if (!eol)
+        g_signal_emit (G_OBJECT (connection),
+            signals[LIST_ITEM_SOURCE_OUTPUT],
+            0,
+            info);
+
+    pa_threaded_mainloop_signal (connection->priv->mainloop, 0);
+}
diff --git a/backends/pulse/pulse-connection.h b/backends/pulse/pulse-connection.h
new file mode 100644
index 0000000..85fd0b7
--- /dev/null
+++ b/backends/pulse/pulse-connection.h
@@ -0,0 +1,102 @@
+/*
+ * 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/>.
+ */
+
+#ifndef MATEMIXER_PULSE_CONNECTION_H
+#define MATEMIXER_PULSE_CONNECTION_H
+
+#include <glib.h>
+#include <glib-object.h>
+
+#include <pulse/pulseaudio.h>
+
+G_BEGIN_DECLS
+
+#define MATE_MIXER_TYPE_PULSE_CONNECTION            \
+        (mate_mixer_pulse_connection_get_type ())
+#define MATE_MIXER_PULSE_CONNECTION(o)              \
+        (G_TYPE_CHECK_INSTANCE_CAST ((o), MATE_MIXER_TYPE_PULSE_CONNECTION, MateMixerPulseConnection))
+#define MATE_MIXER_IS_PULSE_CONNECTION(o)           \
+        (G_TYPE_CHECK_INSTANCE_TYPE ((o), MATE_MIXER_TYPE_PULSE_CONNECTION))
+#define MATE_MIXER_PULSE_CONNECTION_CLASS(k)        \
+        (G_TYPE_CHECK_CLASS_CAST ((k), MATE_MIXER_TYPE_PULSE_CONNECTION, MateMixerPulseConnectionClass))
+#define MATE_MIXER_IS_PULSE_CONNECTION_CLASS(k)     \
+        (G_TYPE_CLASS_CHECK_CLASS_TYPE ((k), MATE_MIXER_TYPE_PULSE_CONNECTION))
+#define MATE_MIXER_PULSE_CONNECTION_GET_CLASS(o)    \
+        (G_TYPE_INSTANCE_GET_CLASS ((o), MATE_MIXER_TYPE_PULSE_CONNECTION, MateMixerPulseConnectionClass))
+
+typedef struct _MateMixerPulseConnection         MateMixerPulseConnection;
+typedef struct _MateMixerPulseConnectionClass    MateMixerPulseConnectionClass;
+typedef struct _MateMixerPulseConnectionPrivate  MateMixerPulseConnectionPrivate;
+
+struct _MateMixerPulseConnection
+{
+    GObject parent;
+
+    MateMixerPulseConnectionPrivate *priv;
+};
+
+struct _MateMixerPulseConnectionClass
+{
+    GObjectClass parent;
+
+    void (*disconnected) (MateMixerPulseConnection *connection);
+    void (*reconnected)  (MateMixerPulseConnection *connection);
+
+    void (*list_item_card) (MateMixerPulseConnection *connection,
+                            const pa_card_info *info);
+    void (*list_item_sink) (MateMixerPulseConnection *connection,
+                            const pa_sink_info *info);
+    void (*list_item_sink_input) (MateMixerPulseConnection *connection,
+                            const pa_sink_input_info *info);
+    void (*list_item_source) (MateMixerPulseConnection *connection,
+                            const pa_source_info *info);
+    void (*list_item_source_output) (MateMixerPulseConnection *connection,
+                            const pa_source_output_info *info);
+};
+
+GType mate_mixer_pulse_connection_get_type (void) G_GNUC_CONST;
+
+MateMixerPulseConnection *mate_mixer_pulse_connection_new (const gchar *server,
+                                                           const gchar *app_name);
+
+gboolean mate_mixer_pulse_connection_connect (MateMixerPulseConnection *connection);
+
+void mate_mixer_pulse_connection_disconnect (MateMixerPulseConnection *connection);
+
+gboolean mate_mixer_pulse_connection_get_server_info (MateMixerPulseConnection *connection);
+
+gboolean mate_mixer_pulse_connection_get_card_list (MateMixerPulseConnection *connection);
+
+gboolean mate_mixer_pulse_connection_get_sink_list (MateMixerPulseConnection *connection);
+
+gboolean mate_mixer_pulse_connection_get_sink_input_list (MateMixerPulseConnection *connection);
+
+gboolean mate_mixer_pulse_connection_get_source_list (MateMixerPulseConnection *connection);
+
+gboolean mate_mixer_pulse_connection_get_source_output_list (MateMixerPulseConnection *connection);
+
+gboolean mate_mixer_pulse_connection_set_card_profile (MateMixerPulseConnection *connection,
+                                                       const gchar              *device,
+                                                       const gchar              *profile);
+
+gboolean mate_mixer_pulse_connection_set_sink_mute (MateMixerPulseConnection *connection,
+                                                    guint32 index,
+                                                    gboolean mute);
+
+G_END_DECLS
+
+#endif /* MATEMIXER_PULSE_CONNECTION_H */
diff --git a/backends/pulse/pulse-device.c b/backends/pulse/pulse-device.c
index dbc287c..a411d7f 100644
--- a/backends/pulse/pulse-device.c
+++ b/backends/pulse/pulse-device.c
@@ -19,30 +19,31 @@
 #include <glib-object.h>
 
 #include <libmatemixer/matemixer-device.h>
-#include <libmatemixer/matemixer-device-port.h>
-#include <libmatemixer/matemixer-device-profile.h>
+#include <libmatemixer/matemixer-port.h>
+#include <libmatemixer/matemixer-profile.h>
 
 #include <pulse/pulseaudio.h>
 
+#include "pulse-connection.h"
 #include "pulse-device.h"
 
 struct _MateMixerPulseDevicePrivate
 {
-    guint32   index;
-    GList    *profiles;
-    GList    *ports;
-    gchar    *identifier;
-    gchar    *name;
-    gchar    *icon;
-
-    MateMixerDeviceProfile *active_profile;
+    guint32                   index;
+    gchar                    *name;
+    gchar                    *description;
+    GList                    *profiles;
+    GList                    *ports;
+    gchar                    *icon;
+    MateMixerProfile         *profile;
+    MateMixerPulseConnection *connection;
 };
 
 enum
 {
     PROP_0,
-    PROP_IDENTIFIER,
     PROP_NAME,
+    PROP_DESCRIPTION,
     PROP_ICON,
     PROP_ACTIVE_PROFILE,
     N_PROPERTIES
@@ -57,9 +58,12 @@ G_DEFINE_TYPE_WITH_CODE (MateMixerPulseDevice, mate_mixer_pulse_device, G_TYPE_O
 static void
 mate_mixer_device_interface_init (MateMixerDeviceInterface *iface)
 {
-    iface->list_tracks = mate_mixer_pulse_device_list_tracks;
-    iface->get_ports = mate_mixer_pulse_device_get_ports;
-    iface->get_profiles = mate_mixer_pulse_device_get_profiles;
+    iface->get_name = mate_mixer_pulse_device_get_name;
+    iface->get_description = mate_mixer_pulse_device_get_description;
+    iface->get_icon = mate_mixer_pulse_device_get_icon;
+    iface->list_streams = mate_mixer_pulse_device_list_streams;
+    iface->list_ports = mate_mixer_pulse_device_list_ports;
+    iface->list_profiles = mate_mixer_pulse_device_list_profiles;
     iface->get_active_profile = mate_mixer_pulse_device_get_active_profile;
     iface->set_active_profile = mate_mixer_pulse_device_set_active_profile;
 }
@@ -67,10 +71,9 @@ mate_mixer_device_interface_init (MateMixerDeviceInterface *iface)
 static void
 mate_mixer_pulse_device_init (MateMixerPulseDevice *device)
 {
-    device->priv = G_TYPE_INSTANCE_GET_PRIVATE (
-        device,
-        MATE_MIXER_TYPE_PULSE_DEVICE,
-        MateMixerPulseDevicePrivate);
+    device->priv = G_TYPE_INSTANCE_GET_PRIVATE (device,
+                                                MATE_MIXER_TYPE_PULSE_DEVICE,
+                                                MateMixerPulseDevicePrivate);
 }
 
 static void
@@ -84,17 +87,17 @@ mate_mixer_pulse_device_get_property (GObject     *object,
     device = MATE_MIXER_PULSE_DEVICE (object);
 
     switch (param_id) {
-    case PROP_IDENTIFIER:
-        g_value_set_string (value, device->priv->identifier);
-        break;
     case PROP_NAME:
         g_value_set_string (value, device->priv->name);
         break;
+    case PROP_DESCRIPTION:
+        g_value_set_string (value, device->priv->description);
+        break;
     case PROP_ICON:
         g_value_set_string (value, device->priv->icon);
         break;
     case PROP_ACTIVE_PROFILE:
-        g_value_set_object (value, device->priv->active_profile);
+        g_value_set_object (value, device->priv->profile);
         break;
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
@@ -113,20 +116,15 @@ mate_mixer_pulse_device_set_property (GObject       *object,
     device = MATE_MIXER_PULSE_DEVICE (object);
 
     switch (param_id) {
-    case PROP_IDENTIFIER:
-        device->priv->identifier = g_strdup (g_value_get_string (value));
-        break;
     case PROP_NAME:
         device->priv->name = g_strdup (g_value_get_string (value));
         break;
+    case PROP_DESCRIPTION:
+        device->priv->description = g_strdup (g_value_get_string (value));
+        break;
     case PROP_ICON:
         device->priv->icon = g_strdup (g_value_get_string (value));
         break;
-    case PROP_ACTIVE_PROFILE:
-        mate_mixer_pulse_device_set_active_profile (
-            MATE_MIXER_DEVICE (device),
-            g_value_get_object (value));
-        break;
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
         break;
@@ -134,24 +132,38 @@ mate_mixer_pulse_device_set_property (GObject       *object,
 }
 
 static void
-mate_mixer_pulse_device_finalize (GObject *object)
+mate_mixer_pulse_device_dispose (GObject *object)
 {
     MateMixerPulseDevice *device;
 
     device = MATE_MIXER_PULSE_DEVICE (object);
 
-    g_free (device->priv->identifier);
-    g_free (device->priv->name);
-    g_free (device->priv->icon);
-
-    if (device->priv->profiles != NULL)
+    if (device->priv->profiles != NULL) {
         g_list_free_full (device->priv->profiles, g_object_unref);
+        device->priv->profiles = NULL;
+    }
 
-    if (device->priv->ports != NULL)
+    if (device->priv->ports != NULL) {
         g_list_free_full (device->priv->ports, g_object_unref);
+        device->priv->ports = NULL;
+    }
+
+    g_clear_object (&device->priv->profile);
+    g_clear_object (&device->priv->connection);
+
+    G_OBJECT_CLASS (mate_mixer_pulse_device_parent_class)->dispose (object);
+}
+
+static void
+mate_mixer_pulse_device_finalize (GObject *object)
+{
+    MateMixerPulseDevice *device;
 
-    if (device->priv->active_profile != NULL)
-        g_object_unref (device->priv->active_profile);
+    device = MATE_MIXER_PULSE_DEVICE (object);
+
+    g_free (device->priv->name);
+    g_free (device->priv->description);
+    g_free (device->priv->icon);
 
     G_OBJECT_CLASS (mate_mixer_pulse_device_parent_class)->finalize (object);
 }
@@ -162,12 +174,13 @@ mate_mixer_pulse_device_class_init (MateMixerPulseDeviceClass *klass)
     GObjectClass *object_class;
 
     object_class = G_OBJECT_CLASS (klass);
+    object_class->dispose      = mate_mixer_pulse_device_dispose;
     object_class->finalize     = mate_mixer_pulse_device_finalize;
     object_class->get_property = mate_mixer_pulse_device_get_property;
     object_class->set_property = mate_mixer_pulse_device_set_property;
 
-    g_object_class_override_property (object_class, PROP_IDENTIFIER, "identifier");
     g_object_class_override_property (object_class, PROP_NAME, "name");
+    g_object_class_override_property (object_class, PROP_DESCRIPTION, "description");
     g_object_class_override_property (object_class, PROP_ICON, "icon");
     g_object_class_override_property (object_class, PROP_ACTIVE_PROFILE, "active-profile");
 
@@ -175,19 +188,19 @@ mate_mixer_pulse_device_class_init (MateMixerPulseDeviceClass *klass)
 }
 
 MateMixerPulseDevice *
-mate_mixer_pulse_device_new (const pa_card_info *info)
+mate_mixer_pulse_device_new (MateMixerPulseConnection *connection, const pa_card_info *info)
 {
-    MateMixerPulseDevice    *device;
-    MateMixerDeviceProfile  *active_profile = NULL;
-    GList                   *profiles = NULL;
-    GList                   *ports = NULL;
-    guint32                  i;
+    MateMixerPulseDevice *device;
+    MateMixerProfile     *active_profile = NULL;
+    GList                *profiles = NULL;
+    GList                *ports = NULL;
+    guint32               i;
 
     g_return_val_if_fail (info != NULL, NULL);
 
     /* Create a list of card profiles */
     for (i = 0; i < info->n_profiles; i++) {
-        MateMixerDeviceProfile *profile;
+        MateMixerProfile *profile;
 
 #if PA_CHECK_VERSION(5, 0, 0)
         pa_card_profile_info2 *p_info = info->profiles2[i];
@@ -199,9 +212,9 @@ mate_mixer_pulse_device_new (const pa_card_info *info)
             continue;
 #else
         /* The old profile list is an array of structs, not pointers */
-        pa_card_profile_info  *p_info = &info->profiles[i];
+        pa_card_profile_info *p_info = &info->profiles[i];
 #endif
-        profile = mate_mixer_device_profile_new (
+        profile = mate_mixer_profile_new (
             p_info->name,
             p_info->description,
             p_info->priority);
@@ -222,28 +235,27 @@ mate_mixer_pulse_device_new (const pa_card_info *info)
 
     /* Create a list of card ports */
     for (i = 0; i < info->n_ports; i++) {
-        MateMixerDevicePort          *port;
-        MateMixerDevicePortDirection  direction = 0;
-        MateMixerDevicePortStatus     status = 0;
-        pa_card_port_info            *p_info = info->ports[i];
-
-        if (p_info->direction & PA_DIRECTION_INPUT)
-            direction |= MATE_MIXER_DEVICE_PORT_DIRECTION_INPUT;
-
-        if (p_info->direction & PA_DIRECTION_OUTPUT)
-            direction |= MATE_MIXER_DEVICE_PORT_DIRECTION_OUTPUT;
+        MateMixerPort       *port;
+        MateMixerPortStatus  status = MATE_MIXER_PORT_UNKNOWN_STATUS;
+        pa_card_port_info   *p_info = info->ports[i];
 
 #if PA_CHECK_VERSION(2, 0, 0)
-        if (p_info->available == PA_PORT_AVAILABLE_YES)
-            status |= MATE_MIXER_DEVICE_PORT_STATUS_AVAILABLE;
+        switch (p_info->available) {
+        case PA_PORT_AVAILABLE_YES:
+            status = MATE_MIXER_PORT_AVAILABLE;
+            break;
+        case PA_PORT_AVAILABLE_NO:
+            status = MATE_MIXER_PORT_UNAVAILABLE;
+            break;
+        default:
+            break;
+        }
 #endif
-        port = mate_mixer_device_port_new (
-            p_info->name,
-            p_info->description,
-            pa_proplist_gets (p_info->proplist, "device.icon_name"),
-            p_info->priority,
-            direction,
-            status);
+        port = mate_mixer_port_new (p_info->name,
+                                    p_info->description,
+                                    pa_proplist_gets (p_info->proplist, "device.icon_name"),
+                                    p_info->priority,
+                                    status);
 
         ports = g_list_prepend (ports, port);
     }
@@ -253,15 +265,21 @@ mate_mixer_pulse_device_new (const pa_card_info *info)
         ports = g_list_reverse (ports);
 
     device = g_object_new (MATE_MIXER_TYPE_PULSE_DEVICE,
-        "identifier",      info->name,
-        "name",            pa_proplist_gets (info->proplist, "device.description"),
-        "icon",            pa_proplist_gets (info->proplist, "device.icon_name"),
-        "active-profile",  active_profile,
-        NULL);
+                           "name", info->name,
+                           "description", pa_proplist_gets (info->proplist, "device.description"),
+                           "icon", pa_proplist_gets (info->proplist, "device.icon_name"),
+                           NULL);
+
+    if (profiles) {
+        device->priv->profiles = profiles;
+
+        if (G_LIKELY (active_profile))
+            device->priv->profile = g_object_ref (active_profile);
+    }
 
     device->priv->index = info->index;
-    device->priv->profiles = profiles;
     device->priv->ports = ports;
+    device->priv->connection = g_object_ref (connection);
 
     return device;
 }
@@ -276,45 +294,104 @@ mate_mixer_pulse_device_update (MateMixerPulseDevice *device, const pa_card_info
     return TRUE;
 }
 
+MateMixerPulseConnection *
+mate_mixer_pulse_device_get_connection (MateMixerPulseDevice *device)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_DEVICE (device), NULL);
+
+    return device->priv->connection;
+}
+
+guint32
+mate_mixer_pulse_device_get_index (MateMixerPulseDevice *device)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_DEVICE (device), 0);
+
+    return device->priv->index;
+}
+
+const gchar *
+mate_mixer_pulse_device_get_name (MateMixerDevice *device)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_DEVICE (device), NULL);
+
+    return MATE_MIXER_PULSE_DEVICE (device)->priv->name;
+}
+
+const gchar *
+mate_mixer_pulse_device_get_description (MateMixerDevice *device)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_DEVICE (device), NULL);
+
+    return MATE_MIXER_PULSE_DEVICE (device)->priv->description;
+}
+
+const gchar *
+mate_mixer_pulse_device_get_icon (MateMixerDevice *device)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_DEVICE (device), NULL);
+
+    return MATE_MIXER_PULSE_DEVICE (device)->priv->icon;
+}
+
 const GList *
-mate_mixer_pulse_device_list_tracks (MateMixerDevice *device)
+mate_mixer_pulse_device_list_streams (MateMixerDevice *device)
 {
     // TODO
     return NULL;
 }
 
 const GList *
-mate_mixer_pulse_device_get_ports (MateMixerDevice *device)
+mate_mixer_pulse_device_list_ports (MateMixerDevice *device)
 {
     g_return_val_if_fail (MATE_MIXER_IS_PULSE_DEVICE (device), NULL);
 
-    return MATE_MIXER_PULSE_DEVICE (device)->priv->ports;
+    return (const GList *) MATE_MIXER_PULSE_DEVICE (device)->priv->ports;
 }
 
 const GList *
-mate_mixer_pulse_device_get_profiles (MateMixerDevice *device)
+mate_mixer_pulse_device_list_profiles (MateMixerDevice *device)
 {
     g_return_val_if_fail (MATE_MIXER_IS_PULSE_DEVICE (device), NULL);
 
-    return MATE_MIXER_PULSE_DEVICE (device)->priv->profiles;
+    return (const GList *) MATE_MIXER_PULSE_DEVICE (device)->priv->profiles;
 }
 
-MateMixerDeviceProfile *
+MateMixerProfile *
 mate_mixer_pulse_device_get_active_profile (MateMixerDevice *device)
 {
     g_return_val_if_fail (MATE_MIXER_IS_PULSE_DEVICE (device), NULL);
 
-    return MATE_MIXER_PULSE_DEVICE (device)->priv->active_profile;
+    return MATE_MIXER_PULSE_DEVICE (device)->priv->profile;
 }
 
 gboolean
-mate_mixer_pulse_device_set_active_profile (MateMixerDevice *device,
-                                            MateMixerDeviceProfile *profile)
+mate_mixer_pulse_device_set_active_profile (MateMixerDevice *device, const gchar *name)
 {
+    gboolean ret;
+    MateMixerPulseDevicePrivate *priv;
+
     g_return_val_if_fail (MATE_MIXER_IS_PULSE_DEVICE (device), FALSE);
-    g_return_val_if_fail (MATE_MIXER_IS_DEVICE_PROFILE (profile), FALSE);
+    g_return_val_if_fail (name != NULL, FALSE);
 
-    // TODO
-    // pa_context_set_card_profile_by_index ()
-    return TRUE;
+    priv = MATE_MIXER_PULSE_DEVICE (device)->priv;
+    ret  = mate_mixer_pulse_connection_set_card_profile (priv->connection,
+                                                         priv->name,
+                                                         name);
+
+    // XXX decide to either confirm the change during the connection call or
+    // wait for a notification from Pulse
+/*
+    if (ret) {
+        if (priv->profile)
+            g_object_unref (priv->profile);
+
+        priv->profile = g_object_ref (profile);
+
+        g_object_notify_by_pspec (
+            G_OBJECT (device),
+            properties[PROP_ACTIVE_PROFILE]);
+    }
+*/
+    return ret;
 }
diff --git a/backends/pulse/pulse-device.h b/backends/pulse/pulse-device.h
index ab997fe..896b02b 100644
--- a/backends/pulse/pulse-device.h
+++ b/backends/pulse/pulse-device.h
@@ -22,10 +22,12 @@
 #include <glib-object.h>
 
 #include <libmatemixer/matemixer-device.h>
-#include <libmatemixer/matemixer-device-profile.h>
+#include <libmatemixer/matemixer-profile.h>
 
 #include <pulse/pulseaudio.h>
 
+#include "pulse-connection.h"
+
 G_BEGIN_DECLS
 
 #define MATE_MIXER_TYPE_PULSE_DEVICE            \
@@ -54,26 +56,35 @@ struct _MateMixerPulseDevice
 
 struct _MateMixerPulseDeviceClass
 {
-    GObjectClass parent;    
+    GObjectClass parent;
 };
 
 GType mate_mixer_pulse_device_get_type (void) G_GNUC_CONST;
 
-MateMixerPulseDevice    *mate_mixer_pulse_device_new (const pa_card_info *info);
+MateMixerPulseDevice    *mate_mixer_pulse_device_new (MateMixerPulseConnection *connection,
+                                                      const pa_card_info *info);
 
 gboolean                 mate_mixer_pulse_device_update (MateMixerPulseDevice *device,
                                                          const pa_card_info *info);
 
+MateMixerPulseConnection *mate_mixer_pulse_device_get_connection (MateMixerPulseDevice *device);
+
+guint32                  mate_mixer_pulse_device_get_index (MateMixerPulseDevice *device);
+
 /* Interface implementation */
-const GList             *mate_mixer_pulse_device_list_tracks (MateMixerDevice *device);
+const gchar *mate_mixer_pulse_device_get_name (MateMixerDevice *device);
+const gchar *mate_mixer_pulse_device_get_description (MateMixerDevice *device);
+const gchar *mate_mixer_pulse_device_get_icon (MateMixerDevice *device);
+
+const GList             *mate_mixer_pulse_device_list_streams (MateMixerDevice *device);
 
-const GList             *mate_mixer_pulse_device_get_ports (MateMixerDevice *device);
-const GList             *mate_mixer_pulse_device_get_profiles (MateMixerDevice *device);
+const GList             *mate_mixer_pulse_device_list_ports (MateMixerDevice *device);
+const GList             *mate_mixer_pulse_device_list_profiles (MateMixerDevice *device);
 
-MateMixerDeviceProfile  *mate_mixer_pulse_device_get_active_profile (MateMixerDevice *device);
+MateMixerProfile  *mate_mixer_pulse_device_get_active_profile (MateMixerDevice *device);
 
 gboolean                 mate_mixer_pulse_device_set_active_profile (MateMixerDevice *device,
-                                                                     MateMixerDeviceProfile *profile);
+                                                                     const gchar *name);
 
 G_END_DECLS
 
diff --git a/backends/pulse/pulse-track.c b/backends/pulse/pulse-sink-input.c
index e69de29..e69de29 100644
--- a/backends/pulse/pulse-track.c
+++ b/backends/pulse/pulse-sink-input.c
diff --git a/backends/pulse/pulse-track.h b/backends/pulse/pulse-sink-input.h
index e69de29..e69de29 100644
--- a/backends/pulse/pulse-track.h
+++ b/backends/pulse/pulse-sink-input.h
diff --git a/backends/pulse/pulse-sink.c b/backends/pulse/pulse-sink.c
new file mode 100644
index 0000000..64eb4c1
--- /dev/null
+++ b/backends/pulse/pulse-sink.c
@@ -0,0 +1,130 @@
+/*
+ * 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 <glib.h>
+#include <glib-object.h>
+
+#include <libmatemixer/matemixer-stream.h>
+#include <libmatemixer/matemixer-port.h>
+
+#include <pulse/pulseaudio.h>
+
+#include "pulse-connection.h"
+#include "pulse-stream.h"
+#include "pulse-sink.h"
+
+struct _MateMixerPulseSinkPrivate
+{
+    guint32 index_monitor;
+};
+
+G_DEFINE_TYPE (MateMixerPulseSink, mate_mixer_pulse_sink, MATE_MIXER_TYPE_PULSE_STREAM);
+
+static void
+mate_mixer_pulse_sink_init (MateMixerPulseSink *sink)
+{
+    sink->priv = G_TYPE_INSTANCE_GET_PRIVATE (sink,
+                                              MATE_MIXER_TYPE_PULSE_SINK,
+                                              MateMixerPulseSinkPrivate);
+}
+
+static void
+mate_mixer_pulse_sink_class_init (MateMixerPulseSinkClass *klass)
+{
+    MateMixerPulseStreamClass *stream_class;
+
+    stream_class = MATE_MIXER_PULSE_STREAM_CLASS (klass);
+
+    stream_class->set_volume = mate_mixer_pulse_sink_set_volume;
+    stream_class->set_mute = mate_mixer_pulse_sink_set_mute;
+
+    g_type_class_add_private (G_OBJECT (klass), sizeof (MateMixerPulseSinkPrivate));
+}
+
+MateMixerPulseStream *
+mate_mixer_pulse_sink_new (MateMixerPulseConnection *connection, const pa_sink_info *info)
+{
+    MateMixerPulseStream *stream;
+    GList *ports = NULL;
+    int i;
+
+    for (i = 0; i < info->n_ports; i++) {
+        MateMixerPort       *port;
+        MateMixerPortStatus  status = MATE_MIXER_PORT_UNKNOWN_STATUS;
+        pa_sink_port_info   *p_info = info->ports[i];
+
+#if PA_CHECK_VERSION(2, 0, 0)
+        switch (p_info->available) {
+        case PA_PORT_AVAILABLE_YES:
+            status = MATE_MIXER_PORT_AVAILABLE;
+            break;
+        case PA_PORT_AVAILABLE_NO:
+            status = MATE_MIXER_PORT_UNAVAILABLE;
+            break;
+        default:
+            break;
+        }
+#endif
+        port = mate_mixer_port_new (p_info->name,
+                                    p_info->description,
+                                    NULL,
+                                    p_info->priority,
+                                    status);
+
+        ports = g_list_prepend (ports, port);
+    }
+
+    if (ports)
+        ports = g_list_reverse (ports);
+
+    stream = g_object_new (MATE_MIXER_TYPE_PULSE_STREAM,
+                           "connection", connection,
+                           "index", info->index,
+                           "name", info->name,
+                           "description", info->description,
+                           "channels", info->channel_map.channels,
+                           "mute", info->mute ? TRUE : FALSE,
+                           NULL);
+
+    return stream;
+}
+
+gboolean
+mate_mixer_pulse_sink_set_volume (MateMixerStream *stream, guint32 volume)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_STREAM (stream), FALSE);
+
+/*
+    return mate_mixer_pulse_connection_set_sink_volume (mate_mixer_pulse_stream_get_connection (MATE_MIXER_PULSE_STREAM (stream)),
+                                                        volume);
+*/
+    return TRUE;
+}
+
+gboolean
+mate_mixer_pulse_sink_set_mute (MateMixerStream *stream, gboolean mute)
+{
+    MateMixerPulseStream *pulse_stream;
+
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_STREAM (stream), FALSE);
+
+    pulse_stream = MATE_MIXER_PULSE_STREAM (stream);
+
+    return mate_mixer_pulse_connection_set_sink_mute (mate_mixer_pulse_stream_get_connection (pulse_stream),
+                                                      mate_mixer_pulse_stream_get_index (pulse_stream),
+                                                      mute);
+}
diff --git a/backends/pulse/pulse-sink.h b/backends/pulse/pulse-sink.h
new file mode 100644
index 0000000..ef2608f
--- /dev/null
+++ b/backends/pulse/pulse-sink.h
@@ -0,0 +1,69 @@
+/*
+ * 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/>.
+ */
+
+#ifndef MATEMIXER_PULSE_SINK_H
+#define MATEMIXER_PULSE_SINK_H
+
+#include <glib.h>
+#include <glib-object.h>
+
+#include <libmatemixer/matemixer-stream.h>
+
+#include <pulse/pulseaudio.h>
+
+G_BEGIN_DECLS
+
+#define MATE_MIXER_TYPE_PULSE_SINK            \
+        (mate_mixer_pulse_sink_get_type ())
+#define MATE_MIXER_PULSE_SINK(o)              \
+        (G_TYPE_CHECK_INSTANCE_CAST ((o), MATE_MIXER_TYPE_PULSE_SINK, MateMixerPulseSink))
+#define MATE_MIXER_IS_PULSE_SINK(o)           \
+        (G_TYPE_CHECK_INSTANCE_TYPE ((o), MATE_MIXER_TYPE_PULSE_SINK))
+#define MATE_MIXER_PULSE_SINK_CLASS(k)        \
+        (G_TYPE_CHECK_CLASS_CAST ((k), MATE_MIXER_TYPE_PULSE_SINK, MateMixerPulseSinkClass))
+#define MATE_MIXER_IS_PULSE_SINK_CLASS(k)     \
+        (G_TYPE_CLASS_CHECK_CLASS_TYPE ((k), MATE_MIXER_TYPE_PULSE_SINK))
+#define MATE_MIXER_PULSE_SINK_GET_CLASS(o)    \
+        (G_TYPE_INSTANCE_GET_CLASS ((o), MATE_MIXER_TYPE_PULSE_SINK, MateMixerPulseSinkClass))
+
+typedef struct _MateMixerPulseSink         MateMixerPulseSink;
+typedef struct _MateMixerPulseSinkClass    MateMixerPulseSinkClass;
+typedef struct _MateMixerPulseSinkPrivate  MateMixerPulseSinkPrivate;
+
+struct _MateMixerPulseSink
+{
+    GObject parent;
+
+    MateMixerPulseSinkPrivate *priv;
+};
+
+struct _MateMixerPulseSinkClass
+{
+    GObjectClass parent;
+};
+
+GType mate_mixer_pulse_sink_get_type (void) G_GNUC_CONST;
+
+MateMixerPulseStream *mate_mixer_pulse_sink_new (MateMixerPulseConnection *connection,
+                                                const pa_sink_info *info);
+
+gboolean mate_mixer_pulse_sink_set_volume (MateMixerStream *stream, guint32 volume);
+gboolean mate_mixer_pulse_sink_set_mute (MateMixerStream *stream, gboolean mute);
+
+G_END_DECLS
+
+#endif /* MATEMIXER_PULSE_SINK_H */
diff --git a/backends/pulse/pulse-source-output.c b/backends/pulse/pulse-source-output.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/backends/pulse/pulse-source-output.c
diff --git a/backends/pulse/pulse-source-output.h b/backends/pulse/pulse-source-output.h
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/backends/pulse/pulse-source-output.h
diff --git a/backends/pulse/pulse-source.c b/backends/pulse/pulse-source.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/backends/pulse/pulse-source.c
diff --git a/backends/pulse/pulse-source.h b/backends/pulse/pulse-source.h
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/backends/pulse/pulse-source.h
diff --git a/backends/pulse/pulse-stream.c b/backends/pulse/pulse-stream.c
new file mode 100644
index 0000000..a9e01d1
--- /dev/null
+++ b/backends/pulse/pulse-stream.c
@@ -0,0 +1,259 @@
+/*
+ * 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 <glib.h>
+#include <glib-object.h>
+
+#include <libmatemixer/matemixer-stream.h>
+#include <libmatemixer/matemixer-port.h>
+
+#include <pulse/pulseaudio.h>
+
+#include "pulse-connection.h"
+#include "pulse-stream.h"
+
+struct _MateMixerPulseStreamPrivate
+{
+    guint32                   index;
+    gchar                    *name;
+    gchar                    *description;
+    gchar                    *icon;
+    guint                     channels;
+    gboolean                  mute;
+    GList                    *ports;
+    MateMixerPort            *port;
+    MateMixerPulseConnection *connection;
+};
+
+enum
+{
+    PROP_0,
+    PROP_INDEX,
+    PROP_NAME,
+    PROP_DESCRIPTION,
+    PROP_ICON,
+    PROP_CHANNELS,
+    PROP_VOLUME,
+    PROP_MUTE,
+    N_PROPERTIES
+};
+
+static void mate_mixer_stream_interface_init   (MateMixerStreamInterface  *iface);
+static void mate_mixer_pulse_stream_class_init (MateMixerPulseStreamClass *klass);
+static void mate_mixer_pulse_stream_init       (MateMixerPulseStream      *stream);
+static void mate_mixer_pulse_stream_dispose    (GObject                   *object);
+static void mate_mixer_pulse_stream_finalize   (GObject                   *object);
+
+G_DEFINE_ABSTRACT_TYPE_WITH_CODE (MateMixerPulseStream, mate_mixer_pulse_stream, G_TYPE_OBJECT,
+                                  G_IMPLEMENT_INTERFACE (MATE_MIXER_TYPE_STREAM,
+                                                         mate_mixer_stream_interface_init))
+
+static void
+mate_mixer_stream_interface_init (MateMixerStreamInterface *iface)
+{
+    iface->get_name = mate_mixer_pulse_stream_get_name;
+    iface->get_description = mate_mixer_pulse_stream_get_description;
+    iface->get_icon = mate_mixer_pulse_stream_get_icon;
+    iface->list_ports = mate_mixer_pulse_stream_list_ports;
+}
+
+static void
+mate_mixer_pulse_stream_get_property (GObject     *object,
+                                      guint        param_id,
+                                      GValue      *value,
+                                      GParamSpec  *pspec)
+{
+    MateMixerPulseStream *stream;
+
+    stream = MATE_MIXER_PULSE_STREAM (object);
+
+    switch (param_id) {
+    case PROP_NAME:
+        g_value_set_string (value, stream->priv->name);
+        break;
+    case PROP_DESCRIPTION:
+        g_value_set_string (value, stream->priv->description);
+        break;
+    case PROP_ICON:
+        g_value_set_string (value, stream->priv->icon);
+        break;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+        break;
+    }
+}
+
+static void
+mate_mixer_pulse_stream_set_property (GObject       *object,
+                                      guint          param_id,
+                                      const GValue  *value,
+                                      GParamSpec    *pspec)
+{
+    MateMixerPulseStream *stream;
+
+    stream = MATE_MIXER_PULSE_STREAM (object);
+
+    switch (param_id) {
+    case PROP_NAME:
+        stream->priv->name = g_strdup (g_value_get_string (value));
+        break;
+    case PROP_DESCRIPTION:
+        stream->priv->description = g_strdup (g_value_get_string (value));
+        break;
+    case PROP_ICON:
+        stream->priv->icon = g_strdup (g_value_get_string (value));
+        break;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+        break;
+    }
+}
+
+static void
+mate_mixer_pulse_stream_class_init (MateMixerPulseStreamClass *klass)
+{
+    GObjectClass *object_class;
+
+    object_class = G_OBJECT_CLASS (klass);
+    object_class->dispose      = mate_mixer_pulse_stream_dispose;
+    object_class->finalize     = mate_mixer_pulse_stream_finalize;
+    object_class->get_property = mate_mixer_pulse_stream_get_property;
+    object_class->set_property = mate_mixer_pulse_stream_set_property;
+
+    g_object_class_override_property (object_class, PROP_NAME, "name");
+    g_object_class_override_property (object_class, PROP_DESCRIPTION, "description");
+    g_object_class_override_property (object_class, PROP_ICON, "icon");
+
+    g_type_class_add_private (object_class, sizeof (MateMixerPulseStreamPrivate));
+}
+
+static void
+mate_mixer_pulse_stream_init (MateMixerPulseStream *stream)
+{
+    stream->priv = G_TYPE_INSTANCE_GET_PRIVATE (
+        stream,
+        MATE_MIXER_TYPE_PULSE_STREAM,
+        MateMixerPulseStreamPrivate);
+}
+
+static void
+mate_mixer_pulse_stream_dispose (GObject *object)
+{
+    MateMixerPulseStream *stream;
+
+    stream = MATE_MIXER_PULSE_STREAM (object);
+
+    if (stream->priv->ports) {
+        g_list_free_full (stream->priv->ports, g_object_unref);
+        stream->priv->ports = NULL;
+    }
+    g_clear_object (&stream->priv->connection);
+
+    G_OBJECT_CLASS (mate_mixer_pulse_stream_parent_class)->dispose (object);
+}
+
+static void
+mate_mixer_pulse_stream_finalize (GObject *object)
+{
+    MateMixerPulseStream *stream;
+
+    stream = MATE_MIXER_PULSE_STREAM (object);
+
+    g_free (stream->priv->name);
+    g_free (stream->priv->description);
+    g_free (stream->priv->icon);
+
+    G_OBJECT_CLASS (mate_mixer_pulse_stream_parent_class)->finalize (object);
+}
+
+MateMixerPulseConnection *
+mate_mixer_pulse_stream_get_connection (MateMixerPulseStream *stream)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_STREAM (stream), NULL);
+
+    return stream->priv->connection;
+}
+
+guint32
+mate_mixer_pulse_stream_get_index (MateMixerPulseStream *stream)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_STREAM (stream), FALSE);
+
+    return stream->priv->index;
+}
+
+const gchar *
+mate_mixer_pulse_stream_get_name (MateMixerStream *stream)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_STREAM (stream), FALSE);
+
+    return MATE_MIXER_PULSE_STREAM (stream)->priv->name;
+}
+
+const gchar *
+mate_mixer_pulse_stream_get_description (MateMixerStream *stream)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_STREAM (stream), FALSE);
+
+    return MATE_MIXER_PULSE_STREAM (stream)->priv->description;
+}
+
+const gchar *
+mate_mixer_pulse_stream_get_icon (MateMixerStream *stream)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_STREAM (stream), FALSE);
+
+    return MATE_MIXER_PULSE_STREAM (stream)->priv->icon;
+}
+
+MateMixerPort *
+mate_mixer_pulse_stream_get_active_port (MateMixerStream *stream)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_STREAM (stream), FALSE);
+
+    return MATE_MIXER_PULSE_STREAM (stream)->priv->port;
+}
+
+const GList *
+mate_mixer_pulse_stream_list_ports (MateMixerStream *stream)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_STREAM (stream), FALSE);
+
+    return MATE_MIXER_PULSE_STREAM (stream)->priv->ports;
+}
+
+gboolean
+mate_mixer_pulse_stream_set_volume (MateMixerStream *stream, guint32 volume)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_STREAM (stream), FALSE);
+
+    return MATE_MIXER_PULSE_STREAM_GET_CLASS (stream)->set_volume (stream, volume);
+}
+
+gboolean
+mate_mixer_pulse_stream_set_mute (MateMixerStream *stream, gboolean mute)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE_STREAM (stream), FALSE);
+
+    return MATE_MIXER_PULSE_STREAM_GET_CLASS (stream)->set_mute (stream, mute);
+}
+
+gboolean
+mate_mixer_pulse_stream_set_active_port (MateMixerStream *stream, MateMixerPort *port)
+{
+    return TRUE;
+}
diff --git a/backends/pulse/pulse-stream.h b/backends/pulse/pulse-stream.h
new file mode 100644
index 0000000..3d3ee78
--- /dev/null
+++ b/backends/pulse/pulse-stream.h
@@ -0,0 +1,86 @@
+/*
+ * 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/>.
+ */
+
+#ifndef MATEMIXER_PULSE_STREAM_H
+#define MATEMIXER_PULSE_STREAM_H
+
+#include <glib.h>
+#include <glib-object.h>
+
+#include <libmatemixer/matemixer-stream.h>
+#include <libmatemixer/matemixer-port.h>
+
+#include <pulse/pulseaudio.h>
+
+#include "pulse-connection.h"
+
+G_BEGIN_DECLS
+
+#define MATE_MIXER_TYPE_PULSE_STREAM            \
+        (mate_mixer_pulse_stream_get_type ())
+#define MATE_MIXER_PULSE_STREAM(o)              \
+        (G_TYPE_CHECK_INSTANCE_CAST ((o), MATE_MIXER_TYPE_PULSE_STREAM, MateMixerPulseStream))
+#define MATE_MIXER_IS_PULSE_STREAM(o)           \
+        (G_TYPE_CHECK_INSTANCE_TYPE ((o), MATE_MIXER_TYPE_PULSE_STREAM))
+#define MATE_MIXER_PULSE_STREAM_CLASS(k)        \
+        (G_TYPE_CHECK_CLASS_CAST ((k), MATE_MIXER_TYPE_PULSE_STREAM, MateMixerPulseStreamClass))
+#define MATE_MIXER_IS_PULSE_STREAM_CLASS(k)     \
+        (G_TYPE_CLASS_CHECK_CLASS_TYPE ((k), MATE_MIXER_TYPE_PULSE_STREAM))
+#define MATE_MIXER_PULSE_STREAM_GET_CLASS(o)    \
+        (G_TYPE_INSTANCE_GET_CLASS ((o), MATE_MIXER_TYPE_PULSE_STREAM, MateMixerPulseStreamClass))
+
+typedef struct _MateMixerPulseStream         MateMixerPulseStream;
+typedef struct _MateMixerPulseStreamClass    MateMixerPulseStreamClass;
+typedef struct _MateMixerPulseStreamPrivate  MateMixerPulseStreamPrivate;
+
+struct _MateMixerPulseStream
+{
+    GObject parent;
+
+    MateMixerPulseStreamPrivate *priv;
+};
+
+struct _MateMixerPulseStreamClass
+{
+    GObjectClass parent;
+
+    gboolean (*set_volume) (MateMixerStream *stream, guint32 volume);
+    gboolean (*set_mute)   (MateMixerStream *stream, gboolean mute);
+};
+
+GType mate_mixer_pulse_stream_get_type (void) G_GNUC_CONST;
+
+MateMixerPulseConnection * mate_mixer_pulse_stream_get_connection  (MateMixerPulseStream *stream);
+guint32                    mate_mixer_pulse_stream_get_index       (MateMixerPulseStream *stream);
+
+/* Interface implementation */
+const gchar *              mate_mixer_pulse_stream_get_name        (MateMixerStream      *stream);
+const gchar *              mate_mixer_pulse_stream_get_description (MateMixerStream      *stream);
+const gchar *              mate_mixer_pulse_stream_get_icon (MateMixerStream *stream);
+
+MateMixerPort *            mate_mixer_pulse_stream_get_active_port (MateMixerStream *stream);
+gboolean                   mate_mixer_pulse_stream_set_active_port (MateMixerStream *stream,
+                                                                    MateMixerPort   *port);
+const GList *              mate_mixer_pulse_stream_list_ports      (MateMixerStream      *stream);
+gboolean                   mate_mixer_pulse_stream_set_mute        (MateMixerStream      *stream,
+                                                                    gboolean              mute);
+gboolean                   mate_mixer_pulse_stream_set_volume      (MateMixerStream      *stream,
+                                                                    guint32               volume);
+
+G_END_DECLS
+
+#endif /* MATEMIXER_PULSE_STREAM_H */
diff --git a/backends/pulse/pulse.c b/backends/pulse/pulse.c
index d306577..59c5935 100644
--- a/backends/pulse/pulse.c
+++ b/backends/pulse/pulse.c
@@ -17,8 +17,6 @@
 
 #include <glib.h>
 #include <glib-object.h>
-#include <sys/types.h>
-#include <unistd.h>
 
 #include <libmatemixer/matemixer-backend.h>
 #include <libmatemixer/matemixer-backend-module.h>
@@ -27,47 +25,59 @@
 #include <pulse/thread-mainloop.h>
 
 #include "pulse.h"
+#include "pulse-connection.h"
 #include "pulse-device.h"
+#include "pulse-stream.h"
+#include "pulse-sink.h"
 
 #define BACKEND_NAME      "PulseAudio"
 #define BACKEND_PRIORITY   0
 
 struct _MateMixerPulsePrivate
 {
-    pa_threaded_mainloop  *mainloop;
-    pa_context            *context;
-    GHashTable            *devices;
+    GHashTable               *devices;
+    gboolean                  lists_loaded;
+    GHashTable               *cards;
+    GHashTable               *sinks;
+    GHashTable               *sink_inputs;
+    GHashTable               *sources;
+    GHashTable               *source_outputs;
+    MateMixerPulseConnection *connection;
 };
 
 /* Support function for dynamic loading of the backend module */
 void  backend_module_init (GTypeModule *module);
 
-const MateMixerBackendModuleInfo *backend_module_get_info (void);
+const MateMixerBackendInfo *backend_module_get_info (void);
 
-static void    mate_mixer_backend_interface_init (MateMixerBackendInterface *iface);
+static void mate_mixer_backend_interface_init (MateMixerBackendInterface *iface);
 
-static void    pulse_card_info_cb (pa_context *c,
-                                   const pa_card_info *info,
-                                   int eol,
-                                   void *userdata);
+static void pulse_card_cb (MateMixerPulseConnection *connection,
+                            const pa_card_info *info,
+                            MateMixerPulse *pulse);
 
-static void    pulse_card_update  (MateMixerPulse *pulse, const pa_card_info *i);
+static void pulse_sink_cb (MateMixerPulseConnection *connection,
+                            const pa_sink_info *info,
+                            MateMixerPulse *pulse);
 
-static void    pulse_state_cb     (pa_context *c, void *userdata);
+static void pulse_sink_input_cb (MateMixerPulseConnection *connection,
+                            const pa_sink_input_info *info,
+                            MateMixerPulse *pulse);
 
-static void    pulse_subscribe_cb (pa_context *c,
-                                   pa_subscription_event_type_t t,
-                                   uint32_t idx,
-                                   void *userdata);
+static void pulse_source_cb (MateMixerPulseConnection *connection,
+                            const pa_source_info *info,
+                            MateMixerPulse *pulse);
 
-static gchar  *pulse_get_app_name (void);
+static void pulse_source_output_cb (MateMixerPulseConnection *connection,
+                            const pa_source_output_info *info,
+                            MateMixerPulse *pulse);
 
 G_DEFINE_DYNAMIC_TYPE_EXTENDED (MateMixerPulse, mate_mixer_pulse,
                                 G_TYPE_OBJECT, 0,
                                 G_IMPLEMENT_INTERFACE_DYNAMIC (MATE_MIXER_TYPE_BACKEND,
                                                                mate_mixer_backend_interface_init))
 
-static MateMixerBackendModuleInfo info;
+static MateMixerBackendInfo info;
 
 void
 backend_module_init (GTypeModule *module)
@@ -77,10 +87,10 @@ backend_module_init (GTypeModule *module)
     info.name         = BACKEND_NAME;
     info.priority     = BACKEND_PRIORITY;
     info.g_type       = MATE_MIXER_TYPE_PULSE;
-    info.backend_type = MATE_MIXER_BACKEND_TYPE_PULSE;
+    info.backend_type = MATE_MIXER_BACKEND_PULSE;
 }
 
-const MateMixerBackendModuleInfo *
+const MateMixerBackendInfo *
 backend_module_get_info (void)
 {
     return &info;
@@ -107,18 +117,70 @@ mate_mixer_pulse_init (MateMixerPulse *pulse)
         g_direct_equal,
         NULL,
         g_object_unref);
+
+    pulse->priv->cards = g_hash_table_new_full (
+        g_direct_hash,
+        g_direct_equal,
+        NULL,
+        g_object_unref);
+    pulse->priv->sinks = g_hash_table_new_full (
+        g_direct_hash,
+        g_direct_equal,
+        NULL,
+        g_object_unref);
+    pulse->priv->sink_inputs = g_hash_table_new_full (
+        g_direct_hash,
+        g_direct_equal,
+        NULL,
+        g_object_unref);
+    pulse->priv->sources = g_hash_table_new_full (
+        g_direct_hash,
+        g_direct_equal,
+        NULL,
+        g_object_unref);
+    pulse->priv->source_outputs = g_hash_table_new_full (
+        g_direct_hash,
+        g_direct_equal,
+        NULL,
+        g_object_unref);
 }
 
 static void
-mate_mixer_pulse_finalize (GObject *object)
+mate_mixer_pulse_dispose (GObject *object)
 {
     MateMixerPulse *pulse;
 
     pulse = MATE_MIXER_PULSE (object);
 
-    g_hash_table_destroy (pulse->priv->devices);
+    if (pulse->priv->devices) {
+        g_hash_table_destroy (pulse->priv->devices);
+        pulse->priv->devices = NULL;
+    }
+
+    if (pulse->priv->cards) {
+        g_hash_table_destroy (pulse->priv->cards);
+        pulse->priv->cards = NULL;
+    }
+    if (pulse->priv->sinks) {
+        g_hash_table_destroy (pulse->priv->sinks);
+        pulse->priv->devices = NULL;
+    }
+    if (pulse->priv->sink_inputs) {
+        g_hash_table_destroy (pulse->priv->sink_inputs);
+        pulse->priv->devices = NULL;
+    }
+    if (pulse->priv->sources) {
+        g_hash_table_destroy (pulse->priv->sources);
+        pulse->priv->devices = NULL;
+    }
+    if (pulse->priv->source_outputs) {
+        g_hash_table_destroy (pulse->priv->source_outputs);
+        pulse->priv->source_outputs = NULL;
+    }
+
+    g_clear_object (&pulse->priv->connection);
 
-    G_OBJECT_CLASS (mate_mixer_pulse_parent_class)->finalize (object);
+    G_OBJECT_CLASS (mate_mixer_pulse_parent_class)->dispose (object);
 }
 
 static void
@@ -127,7 +189,7 @@ mate_mixer_pulse_class_init (MateMixerPulseClass *klass)
     GObjectClass *object_class;
 
     object_class = G_OBJECT_CLASS (klass);
-    object_class->finalize = mate_mixer_pulse_finalize;
+    object_class->dispose = mate_mixer_pulse_dispose;
 
     g_type_class_add_private (object_class, sizeof (MateMixerPulsePrivate));
 }
@@ -141,83 +203,48 @@ mate_mixer_pulse_class_finalize (MateMixerPulseClass *klass)
 gboolean
 mate_mixer_pulse_open (MateMixerBackend *backend)
 {
-    int              ret;
-    gchar           *app_name;
-    MateMixerPulse  *pulse;
+    MateMixerPulse            *pulse;
+    MateMixerPulseConnection  *connection;
 
-    g_return_val_if_fail (MATE_MIXER_IS_BACKEND (backend), FALSE);
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE (backend), FALSE);
 
     pulse = MATE_MIXER_PULSE (backend);
 
-    g_return_val_if_fail (pulse->priv->mainloop == NULL, FALSE);
+    g_return_val_if_fail (pulse->priv->connection == NULL, FALSE);
 
-    pulse->priv->mainloop = pa_threaded_mainloop_new ();
-    if (G_UNLIKELY (pulse->priv->mainloop == NULL)) {
-        g_warning ("Failed to created PulseAudio main loop");
+    connection = mate_mixer_pulse_connection_new (NULL, NULL);
+    if (G_UNLIKELY (connection == NULL)) {
+        g_object_unref (connection);
         return FALSE;
     }
 
-    app_name = pulse_get_app_name ();
-
-    pulse->priv->context = pa_context_new (
-        pa_threaded_mainloop_get_api (pulse->priv->mainloop),
-        app_name);
-
-    g_free (app_name);
-
-    if (G_UNLIKELY (pulse->priv->context == NULL)) {
-        g_warning ("Failed to created PulseAudio context");
-
-        pa_threaded_mainloop_free (pulse->priv->mainloop);
-        pulse->priv->mainloop = NULL;
-        return FALSE;
-    }
-
-    // XXX: investigate PA_CONTEXT_NOFAIL
-    ret = pa_context_connect (pulse->priv->context, NULL, PA_CONTEXT_NOFLAGS, NULL);
-    if (ret < 0) {
-        g_warning ("Failed to connect to PulseAudio server: %s", pa_strerror (ret));
-
-        pa_context_unref (pulse->priv->context);
-        pa_threaded_mainloop_free (pulse->priv->mainloop);
-
-        pulse->priv->context = NULL;
-        pulse->priv->mainloop = NULL;
+    if (!mate_mixer_pulse_connection_connect (connection)) {
+        g_object_unref (connection);
         return FALSE;
     }
 
-    g_debug ("Connected to PulseAudio server");
-
-    pa_threaded_mainloop_lock (pulse->priv->mainloop);
-
-    pa_context_set_state_callback (pulse->priv->context,
-        pulse_state_cb,
-        backend);
-    pa_context_set_subscribe_callback (pulse->priv->context,
-        pulse_subscribe_cb,
-        backend);
-
-    ret = pa_threaded_mainloop_start (pulse->priv->mainloop);
-    if (ret < 0) {
-        g_warning ("Failed to start PulseAudio main loop: %s", pa_strerror (ret));
-
-        pa_threaded_mainloop_unlock (pulse->priv->mainloop);
-
-        pa_context_unref (pulse->priv->context);
-        pa_threaded_mainloop_free (pulse->priv->mainloop);
-
-        pulse->priv->context = NULL;
-        pulse->priv->mainloop = NULL;
-        return FALSE;
-    }
-
-    while (pa_context_get_state (pulse->priv->context) != PA_CONTEXT_READY) {
-        // XXX this will get stuck if connection fails
-        pa_threaded_mainloop_wait (pulse->priv->mainloop);
-    }
-
-    pa_threaded_mainloop_unlock (pulse->priv->mainloop);
-
+    g_signal_connect (connection,
+        "list-item-card",
+        G_CALLBACK (pulse_card_cb),
+        pulse);
+    g_signal_connect (connection,
+        "list-item-sink",
+        G_CALLBACK (pulse_sink_cb),
+        pulse);
+    g_signal_connect (connection,
+        "list-item-sink-input",
+        G_CALLBACK (pulse_sink_input_cb),
+        pulse);
+    g_signal_connect (connection,
+        "list-item-source",
+        G_CALLBACK (pulse_source_cb),
+        pulse);
+    g_signal_connect (connection,
+        "list-item-source-output",
+        G_CALLBACK (pulse_source_output_cb),
+        pulse);
+
+    pulse->priv->connection = connection;
     return TRUE;
 }
 
@@ -226,140 +253,118 @@ mate_mixer_pulse_close (MateMixerBackend *backend)
 {
     MateMixerPulse *pulse;
 
-    g_return_if_fail (MATE_MIXER_IS_BACKEND (backend));
+    g_return_if_fail (MATE_MIXER_IS_PULSE (backend));
 
     pulse = MATE_MIXER_PULSE (backend);
 
-    g_return_if_fail (pulse->priv->mainloop != NULL);
-
-    pa_threaded_mainloop_stop (pulse->priv->mainloop);
+    g_clear_object (&pulse->priv->connection);
+}
 
-    pa_context_unref (pulse->priv->context);
-    pa_threaded_mainloop_free (pulse->priv->mainloop);
+static gboolean
+pulse_load_lists (MateMixerPulse *pulse)
+{
+    /* The Pulse server is queried for initial lists, each of the functions
+     * waits until the list is available and then continues with the next.
+     *
+     * One possible improvement would be to load the lists asynchronously right
+     * after we connect to Pulse and when the application calls one of the
+     * list_* () functions, check if the initial list is already available and
+     * eventually wait until it's available. However, this would be
+     * tricky with the way the Pulse API is currently used and might not
+     * be beneficial at all.
+     */
+
+    // XXX figure out how to handle server reconnects, ideally everything
+    // we know should be ditched and read again asynchronously and
+    // the user should only be notified about actual differences
+    // from the state before we were disconnected
+
+    // mate_mixer_pulse_connection_get_server_info (pulse->priv->connection);
+    mate_mixer_pulse_connection_get_card_list (pulse->priv->connection);
+    mate_mixer_pulse_connection_get_sink_list (pulse->priv->connection);
+    mate_mixer_pulse_connection_get_sink_input_list (pulse->priv->connection);
+    mate_mixer_pulse_connection_get_source_list (pulse->priv->connection);
+    mate_mixer_pulse_connection_get_source_output_list (pulse->priv->connection);
 
-    pulse->priv->context = NULL;
-    pulse->priv->mainloop = NULL;
+    return TRUE;
 }
 
 GList *
 mate_mixer_pulse_list_devices (MateMixerBackend *backend)
 {
-    MateMixerPulse  *pulse;
-    pa_operation    *o;
+    MateMixerPulse *pulse;
+    GList          *list;
 
-    g_return_val_if_fail (MATE_MIXER_IS_BACKEND (backend), NULL);
+    g_return_val_if_fail (MATE_MIXER_IS_PULSE (backend), NULL);
 
     pulse = MATE_MIXER_PULSE (backend);
 
-    pa_threaded_mainloop_lock (pulse->priv->mainloop);
+    if (!pulse->priv->lists_loaded)
+        pulse_load_lists (pulse);
 
-    o = pa_context_get_card_info_list (pulse->priv->context, pulse_card_info_cb, pulse);
-    if (o == NULL) {
-        g_warning ("Failed to read card list: %s",
-            pa_strerror (pa_context_errno (pulse->priv->context)));
-
-        pa_threaded_mainloop_unlock (pulse->priv->mainloop);
-        return NULL;
-    }
+    list = g_hash_table_get_values (pulse->priv->devices);
 
-    while (pa_operation_get_state (o) == PA_OPERATION_RUNNING)
-        pa_threaded_mainloop_wait (pulse->priv->mainloop);
-
-    pa_operation_unref (o);
-    pa_threaded_mainloop_unlock (pulse->priv->mainloop);
+    g_list_foreach (list, (GFunc) g_object_ref, NULL);
+    return list;
+}
 
-    return g_hash_table_get_values (pulse->priv->devices);
+GList *
+mate_mixer_pulse_list_streams (MateMixerBackend *backend)
+{
+    // TODO
+    return NULL;
 }
 
 static void
-pulse_card_info_cb (pa_context *c, const pa_card_info *info, int eol, void *userdata)
+pulse_card_cb (MateMixerPulseConnection *connection,
+                const pa_card_info *info,
+                MateMixerPulse *pulse)
 {
-    MateMixerPulse *pulse;
-
-    pulse = MATE_MIXER_PULSE (userdata);
-
-    if (!eol)
-        pulse_card_update (pulse, info);
-
-    pa_threaded_mainloop_signal (pulse->priv->mainloop, 0);
+    MateMixerPulseDevice *device;
+
+    device = mate_mixer_pulse_device_new (connection, info);
+    if (G_LIKELY (device))
+        g_hash_table_insert (
+            pulse->priv->devices,
+            GINT_TO_POINTER (mate_mixer_pulse_device_get_index (device)),
+            device);
 }
 
 static void
-pulse_card_update (MateMixerPulse *pulse, const pa_card_info *info)
+pulse_sink_cb (MateMixerPulseConnection *connection,
+                            const pa_sink_info *info,
+                            MateMixerPulse *pulse)
 {
-    gpointer item;
-
-    item = g_hash_table_lookup (pulse->priv->devices, GINT_TO_POINTER (info->index));
-    if (item) {
-        /* The card is already known, just update the fields that may
-         * have changed */
-        mate_mixer_pulse_device_update (MATE_MIXER_PULSE_DEVICE (item), info);
-    } else {
-        MateMixerPulseDevice *device = mate_mixer_pulse_device_new (info);
-
-        if (G_UNLIKELY (device == NULL))
-            g_warning ("Failed to process PulseAudio sound device");
-        else
-            g_hash_table_insert (
-                pulse->priv->devices,
-                GINT_TO_POINTER (info->index),
-                device);
-    }
+    MateMixerPulseStream *stream;
+
+    stream = mate_mixer_pulse_sink_new (connection, info);
+    if (G_LIKELY (stream))
+        g_hash_table_insert (
+            pulse->priv->sinks,
+            GINT_TO_POINTER (mate_mixer_pulse_stream_get_index (stream)),
+            stream);
 }
 
 static void
-pulse_state_cb (pa_context *c, void *userdata)
+pulse_sink_input_cb (MateMixerPulseConnection *connection,
+                            const pa_sink_input_info *info,
+                            MateMixerPulse *pulse)
 {
-    MateMixerPulse *pulse;
 
-    pulse = MATE_MIXER_PULSE (userdata);
-
-    // TODO: handle errors
-
-    switch (pa_context_get_state (c)) {
-    case PA_CONTEXT_UNCONNECTED:
-        break;
-    case PA_CONTEXT_CONNECTING:
-        break;
-    case PA_CONTEXT_AUTHORIZING:
-        break;
-    case PA_CONTEXT_SETTING_NAME:
-        break;
-    case PA_CONTEXT_READY:
-        break;
-    case PA_CONTEXT_FAILED:
-        break;
-    case PA_CONTEXT_TERMINATED:
-        break;
-    default:
-        break;
-    }
-
-    pa_threaded_mainloop_signal (pulse->priv->mainloop, FALSE);
 }
 
 static void
-pulse_subscribe_cb (pa_context *c,
-                    pa_subscription_event_type_t t,
-                    uint32_t idx,
-                    void *userdata)
+pulse_source_cb (MateMixerPulseConnection *connection,
+                            const pa_source_info *info,
+                            MateMixerPulse *pulse)
 {
-    // TODO
+
 }
 
-static gchar *
-pulse_get_app_name (void)
+static void
+pulse_source_output_cb (MateMixerPulseConnection *connection,
+                            const pa_source_output_info *info,
+                            MateMixerPulse *pulse)
 {
-    const char *name_app;
-    char        name_buf[256];
-
-    /* Inspired by GStreamer's pulse plugin */
-    name_app = g_get_application_name ();
-    if (name_app != NULL)
-        return g_strdup (name_app);
-
-    if (pa_get_binary_name (name_buf, sizeof (name_buf)) != NULL)
-        return g_strdup (name_buf);
 
-    return g_strdup_printf ("libmatemixer-%lu", (gulong) getpid ());
 }
diff --git a/backends/pulse/pulse.h b/backends/pulse/pulse.h
index 2f8414f..d94a543 100644
--- a/backends/pulse/pulse.h
+++ b/backends/pulse/pulse.h
@@ -54,8 +54,10 @@ struct _MateMixerPulseClass
 
 GType mate_mixer_pulse_get_type (void) G_GNUC_CONST;
 
+/* Interface implementation */
 gboolean      mate_mixer_pulse_open          (MateMixerBackend *backend);
 void          mate_mixer_pulse_close         (MateMixerBackend *backend);
 GList        *mate_mixer_pulse_list_devices  (MateMixerBackend *backend);
+GList        *mate_mixer_pulse_list_streams  (MateMixerBackend *backend);
 
 #endif /* MATEMIXER_PULSE_H */
diff --git a/configure.ac b/configure.ac
index fdd632b..e004f47 100644
--- a/configure.ac
+++ b/configure.ac
@@ -138,7 +138,7 @@ backends/null/Makefile
 backends/pulse/Makefile
 data/Makefile
 data/libmatemixer.pc
-doc/Makefile
+docs/Makefile
 ])
 
 AC_OUTPUT
diff --git a/doc/Makefile.am b/docs/Makefile.am
index 9b582ee..9b582ee 100644
--- a/doc/Makefile.am
+++ b/docs/Makefile.am
diff --git a/libmatemixer/Makefile.am b/libmatemixer/Makefile.am
index a269397..0280b27 100644
--- a/libmatemixer/Makefile.am
+++ b/libmatemixer/Makefile.am
@@ -1,7 +1,6 @@
 lib_LTLIBRARIES = libmatemixer.la
 
 AM_CPPFLAGS =                                                   \
-        $(GLIB_CFLAGS)                                          \
         -I$(top_srcdir)                                         \
         -I$(top_srcdir)/libmatemixer                            \
         -DG_LOG_DOMAIN=\"libmatemixer\"                         \
@@ -13,10 +12,12 @@ libmatemixer_include_HEADERS =                                  \
         matemixer.h                                             \
         matemixer-control.h                                     \
         matemixer-device.h                                      \
-        matemixer-device-port.h                                 \
-        matemixer-device-profile.h                              \
         matemixer-enums.h                                       \
-        matemixer-track.h
+        matemixer-port.h                                        \
+        matemixer-profile.h                                     \
+        matemixer-stream.h
+
+libmatemixer_la_CFLAGS = $(GLIB_CFLAGS)
 
 libmatemixer_la_SOURCES =                                       \
         matemixer.c                                             \
@@ -24,13 +25,14 @@ libmatemixer_la_SOURCES =                                       \
         matemixer-backend.c                                     \
         matemixer-backend.h                                     \
         matemixer-backend-module.c                              \
+        matemixer-backend-module.h                              \
         matemixer-control.c                                     \
         matemixer-device.c                                      \
-        matemixer-device-port.c                                 \
-        matemixer-device-profile.c                              \
         matemixer-enum-types.c                                  \
         matemixer-enum-types.h                                  \
-        matemixer-track.c
+        matemixer-port.c                                        \
+        matemixer-profile.c                                     \
+        matemixer-stream.c
 
 libmatemixer_la_LIBADD = $(GLIB_LIBS)
 
diff --git a/libmatemixer/matemixer-backend-module.c b/libmatemixer/matemixer-backend-module.c
index 7846359..5ad2836 100644
--- a/libmatemixer/matemixer-backend-module.c
+++ b/libmatemixer/matemixer-backend-module.c
@@ -33,19 +33,40 @@ struct _MateMixerBackendModulePrivate
     void (*init)   (GTypeModule *type_module);
     void (*deinit) (void);
 
-    const MateMixerBackendModuleInfo *(*get_info) (void);
+    const MateMixerBackendInfo *(*get_info) (void);
 };
 
-static gboolean mate_mixer_backend_module_load   (GTypeModule *gmodule);
-static void     mate_mixer_backend_module_unload (GTypeModule *gmodule);
+static void     mate_mixer_backend_module_class_init (MateMixerBackendModuleClass *klass);
+static void     mate_mixer_backend_module_init       (MateMixerBackendModule      *module);
+static void     mate_mixer_backend_module_dispose    (GObject                     *object);
+static void     mate_mixer_backend_module_finalize   (GObject                     *object);
+
+static gboolean mate_mixer_backend_module_load       (GTypeModule *gmodule);
+static void     mate_mixer_backend_module_unload     (GTypeModule *gmodule);
+
+static void
+mate_mixer_backend_module_class_init (MateMixerBackendModuleClass *klass)
+{
+    GObjectClass     *object_class;
+    GTypeModuleClass *module_class;
+
+    object_class = G_OBJECT_CLASS (klass);
+    object_class->dispose  = mate_mixer_backend_module_dispose;
+    object_class->finalize = mate_mixer_backend_module_finalize;
+
+    module_class = G_TYPE_MODULE_CLASS (klass);
+    module_class->load   = mate_mixer_backend_module_load;
+    module_class->unload = mate_mixer_backend_module_unload;
+
+    g_type_class_add_private (object_class, sizeof (MateMixerBackendModulePrivate));
+}
 
 static void
 mate_mixer_backend_module_init (MateMixerBackendModule *module)
 {
-    module->priv = G_TYPE_INSTANCE_GET_PRIVATE (
-        module,
-        MATE_MIXER_TYPE_BACKEND_MODULE,
-        MateMixerBackendModulePrivate);
+    module->priv = G_TYPE_INSTANCE_GET_PRIVATE (module,
+                                                MATE_MIXER_TYPE_BACKEND_MODULE,
+                                                MateMixerBackendModulePrivate);
 }
 
 static void
@@ -76,23 +97,6 @@ mate_mixer_backend_module_finalize (GObject *object)
     G_OBJECT_CLASS (mate_mixer_backend_module_parent_class)->finalize (object);
 }
 
-static void
-mate_mixer_backend_module_class_init (MateMixerBackendModuleClass *klass)
-{
-    GObjectClass     *object_class;
-    GTypeModuleClass *gtype_class;
-
-    object_class = G_OBJECT_CLASS (klass);
-    object_class->dispose  = mate_mixer_backend_module_dispose;
-    object_class->finalize = mate_mixer_backend_module_finalize;
-
-    gtype_class  = G_TYPE_MODULE_CLASS (klass);
-    gtype_class->load   = mate_mixer_backend_module_load;
-    gtype_class->unload = mate_mixer_backend_module_unload;
-
-    g_type_class_add_private (object_class, sizeof (MateMixerBackendModulePrivate));
-}
-
 static gboolean
 mate_mixer_backend_module_load (GTypeModule *type_module)
 {
@@ -101,28 +105,27 @@ mate_mixer_backend_module_load (GTypeModule *type_module)
     module = MATE_MIXER_BACKEND_MODULE (type_module);
 
     if (!module->priv->loaded) {
-        module->priv->gmodule = g_module_open (
-            module->priv->path,
-            G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL);
-
+        module->priv->gmodule = g_module_open (module->priv->path,
+                                               G_MODULE_BIND_LAZY |
+                                               G_MODULE_BIND_LOCAL);
         if (module->priv->gmodule == NULL) {
             g_warning ("Failed to load backend module %s: %s",
-                module->priv->path,
-                g_module_error ());
+                       module->priv->path,
+                       g_module_error ());
 
             return FALSE;
         }
 
         /* Validate library symbols that each backend module must provide */
         if (!g_module_symbol (module->priv->gmodule,
-                "backend_module_init",
-                (gpointer *) &module->priv->init) ||
+                              "backend_module_init",
+                              (gpointer *) &module->priv->init) ||
             !g_module_symbol (module->priv->gmodule,
-                "backend_module_get_info",
-                (gpointer *) &module->priv->get_info)) {
+                              "backend_module_get_info",
+                              (gpointer *) &module->priv->get_info)) {
             g_warning ("Failed to load backend module %s: %s",
-                module->priv->path,
-                g_module_error ());
+                       module->priv->path,
+                       g_module_error ());
 
             g_module_close (module->priv->gmodule);
             return FALSE;
@@ -130,8 +133,8 @@ mate_mixer_backend_module_load (GTypeModule *type_module)
 
         /* Optional backend functions */
         g_module_symbol (module->priv->gmodule,
-            "backend_module_deinit",
-            (gpointer *) &module->priv->deinit);
+                         "backend_module_deinit",
+                         (gpointer *) &module->priv->deinit);
 
         module->priv->init (type_module);
         module->priv->loaded = TRUE;
@@ -140,7 +143,7 @@ mate_mixer_backend_module_load (GTypeModule *type_module)
          * it in other parts of the library */
         if (G_UNLIKELY (module->priv->get_info () == NULL)) {
             g_warning ("Backend module %s does not provide module information",
-                module->priv->path);
+                       module->priv->path);
 
             /* Close the module but keep the loaded flag to avoid unreffing
              * this instance as the GType has most likely been registered */
@@ -150,7 +153,7 @@ mate_mixer_backend_module_load (GTypeModule *type_module)
 
         /* It is not possible to unref this instance, so let's avoid unloading
          * the module and just let the backend module (de)initialize when
-         * (un)load are called repeatedly */
+         * (de)init functions are called repeatedly */
         g_module_make_resident (module->priv->gmodule);
 
         g_debug ("Loaded backend module %s", module->priv->path);
@@ -189,7 +192,7 @@ mate_mixer_backend_module_new (const gchar *path)
     return module;
 }
 
-const MateMixerBackendModuleInfo *
+const MateMixerBackendInfo *
 mate_mixer_backend_module_get_info (MateMixerBackendModule *module)
 {
     g_return_val_if_fail (MATE_MIXER_IS_BACKEND_MODULE (module), NULL);
diff --git a/libmatemixer/matemixer-backend-module.h b/libmatemixer/matemixer-backend-module.h
index 4cba866..b629bfc 100644
--- a/libmatemixer/matemixer-backend-module.h
+++ b/libmatemixer/matemixer-backend-module.h
@@ -25,6 +25,13 @@
 
 G_BEGIN_DECLS
 
+typedef struct {
+    gchar                *name;
+    guint                 priority;
+    GType                 g_type;
+    MateMixerBackendType  backend_type;
+} MateMixerBackendInfo;
+
 #define MATE_MIXER_TYPE_BACKEND_MODULE          \
         (mate_mixer_backend_module_get_type ())
 #define MATE_MIXER_BACKEND_MODULE(o)            \
@@ -40,18 +47,8 @@ G_BEGIN_DECLS
 
 typedef struct _MateMixerBackendModule         MateMixerBackendModule;
 typedef struct _MateMixerBackendModuleClass    MateMixerBackendModuleClass;
-typedef struct _MateMixerBackendModuleInfo     MateMixerBackendModuleInfo;
 typedef struct _MateMixerBackendModulePrivate  MateMixerBackendModulePrivate;
 
-struct _MateMixerBackendModuleInfo
-{
-    gchar *name;
-    guint  priority;
-    GType  g_type;
-
-    MateMixerBackendType backend_type;
-};
-
 struct _MateMixerBackendModule
 {
     GTypeModule parent;
@@ -66,9 +63,9 @@ struct _MateMixerBackendModuleClass
 
 GType mate_mixer_backend_module_get_type (void) G_GNUC_CONST;
 
-MateMixerBackendModule           *mate_mixer_backend_module_new (const gchar *path);
-const MateMixerBackendModuleInfo *mate_mixer_backend_module_get_info (MateMixerBackendModule *module);
-const gchar                      *mate_mixer_backend_module_get_path (MateMixerBackendModule *module);
+MateMixerBackendModule     *mate_mixer_backend_module_new      (const gchar            *path);
+const MateMixerBackendInfo *mate_mixer_backend_module_get_info (MateMixerBackendModule *module);
+const gchar                *mate_mixer_backend_module_get_path (MateMixerBackendModule *module);
 
 G_END_DECLS
 
diff --git a/libmatemixer/matemixer-backend.c b/libmatemixer/matemixer-backend.c
index 18e622f..890c34b 100644
--- a/libmatemixer/matemixer-backend.c
+++ b/libmatemixer/matemixer-backend.c
@@ -19,6 +19,7 @@
 #include <glib-object.h>
 
 #include "matemixer-backend.h"
+#include "matemixer-stream.h"
 
 G_DEFINE_INTERFACE (MateMixerBackend, mate_mixer_backend, G_TYPE_OBJECT)
 
@@ -32,9 +33,10 @@ mate_mixer_backend_open (MateMixerBackend *backend)
 {
     MateMixerBackendInterface *iface;
 
-    g_return_val_if_fail (MATE_MIXER_IS_BACKEND (backend), NULL);
+    g_return_val_if_fail (MATE_MIXER_IS_BACKEND (backend), FALSE);
 
     iface = MATE_MIXER_BACKEND_GET_INTERFACE (backend);
+
     if (iface->open)
         return iface->open (backend);
 
@@ -46,9 +48,10 @@ mate_mixer_backend_close (MateMixerBackend *backend)
 {
     MateMixerBackendInterface *iface;
 
-    g_return_val_if_fail (MATE_MIXER_IS_BACKEND (backend), NULL);
+    g_return_if_fail (MATE_MIXER_IS_BACKEND (backend));
 
     iface = MATE_MIXER_BACKEND_GET_INTERFACE (backend);
+
     if (iface->close)
         iface->close (backend);
 }
@@ -61,6 +64,7 @@ mate_mixer_backend_list_devices (MateMixerBackend *backend)
     g_return_val_if_fail (MATE_MIXER_IS_BACKEND (backend), NULL);
 
     iface = MATE_MIXER_BACKEND_GET_INTERFACE (backend);
+
     if (iface->list_devices)
         return iface->list_devices (backend);
 
@@ -68,15 +72,46 @@ mate_mixer_backend_list_devices (MateMixerBackend *backend)
 }
 
 GList *
-mate_mixer_backend_list_tracks (MateMixerBackend *backend)
+mate_mixer_backend_list_streams (MateMixerBackend *backend)
+{
+    MateMixerBackendInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_BACKEND (backend), NULL);
+
+    iface = MATE_MIXER_BACKEND_GET_INTERFACE (backend);
+
+    if (iface->list_streams)
+        return iface->list_streams (backend);
+
+    return NULL;
+}
+
+MateMixerStream *
+mate_mixer_backend_get_default_input_stream (MateMixerBackend *backend)
+{
+    MateMixerBackendInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_BACKEND (backend), NULL);
+
+    iface = MATE_MIXER_BACKEND_GET_INTERFACE (backend);
+
+    if (iface->get_default_input_stream)
+        return iface->get_default_input_stream (backend);
+
+    return NULL;
+}
+
+MateMixerStream *
+mate_mixer_backend_get_default_output_stream (MateMixerBackend *backend)
 {
     MateMixerBackendInterface *iface;
 
     g_return_val_if_fail (MATE_MIXER_IS_BACKEND (backend), NULL);
 
     iface = MATE_MIXER_BACKEND_GET_INTERFACE (backend);
-    if (iface->list_tracks)
-        return iface->list_tracks (backend);
+
+    if (iface->get_default_output_stream)
+        return iface->get_default_output_stream (backend);
 
     return NULL;
 }
diff --git a/libmatemixer/matemixer-backend.h b/libmatemixer/matemixer-backend.h
index e5a8585..897641f 100644
--- a/libmatemixer/matemixer-backend.h
+++ b/libmatemixer/matemixer-backend.h
@@ -21,7 +21,7 @@
 #include <glib.h>
 #include <glib-object.h>
 
-#include <libmatemixer/matemixer-enums.h>
+#include "matemixer-stream.h"
 
 G_BEGIN_DECLS
 
@@ -42,19 +42,23 @@ struct _MateMixerBackendInterface
     GTypeInterface parent;
 
     /* Required */
-    gboolean   (*open)          (MateMixerBackend *backend);
+    gboolean         (*open)                      (MateMixerBackend *backend);
 
-    void       (*close)         (MateMixerBackend *backend);
-    GList     *(*list_devices)  (MateMixerBackend *backend);
-    GList     *(*list_tracks)   (MateMixerBackend *backend);
+    void             (*close)                     (MateMixerBackend *backend);
+    GList           *(*list_devices)              (MateMixerBackend *backend);
+    GList           *(*list_streams)              (MateMixerBackend *backend);
+    MateMixerStream *(*get_default_input_stream)  (MateMixerBackend *backend);
+    MateMixerStream *(*get_default_output_stream) (MateMixerBackend *backend);
 };
 
 GType mate_mixer_backend_get_type (void) G_GNUC_CONST;
 
-gboolean  mate_mixer_backend_open          (MateMixerBackend *backend);
-void      mate_mixer_backend_close         (MateMixerBackend *backend);
-GList    *mate_mixer_backend_list_devices  (MateMixerBackend *backend);
-GList    *mate_mixer_backend_list_tracks   (MateMixerBackend *backend);
+gboolean         mate_mixer_backend_open                      (MateMixerBackend *backend);
+void             mate_mixer_backend_close                     (MateMixerBackend *backend);
+GList           *mate_mixer_backend_list_devices              (MateMixerBackend *backend);
+GList           *mate_mixer_backend_list_streams              (MateMixerBackend *backend);
+MateMixerStream *mate_mixer_backend_get_default_input_stream  (MateMixerBackend *backend);
+MateMixerStream *mate_mixer_backend_get_default_output_stream (MateMixerBackend *backend);
 
 G_END_DECLS
 
diff --git a/libmatemixer/matemixer-control.c b/libmatemixer/matemixer-control.c
index cf59ad5..c122a7e 100644
--- a/libmatemixer/matemixer-control.c
+++ b/libmatemixer/matemixer-control.c
@@ -23,64 +23,73 @@
 #include "matemixer-control.h"
 #include "matemixer-enums.h"
 #include "matemixer-private.h"
-#include "matemixer-track.h"
+#include "matemixer-stream.h"
 
 struct _MateMixerControlPrivate
 {
     GList                  *devices;
-    GList                  *tracks;
+    GList                  *streams;
     MateMixerBackend       *backend;
     MateMixerBackendModule *module;
 };
 
 G_DEFINE_TYPE (MateMixerControl, mate_mixer_control, G_TYPE_OBJECT);
 
-static MateMixerBackend *mixer_control_init_module (MateMixerBackendModule *module);
+static void              mate_mixer_control_class_init (MateMixerControlClass  *klass);
+static void              mate_mixer_control_init       (MateMixerControl       *control);
+static void              mate_mixer_control_dispose    (GObject                *object);
+
+static MateMixerBackend *mixer_control_init_module     (MateMixerBackendModule *module);
+
+static void
+mate_mixer_control_class_init (MateMixerControlClass *klass)
+{
+    GObjectClass *object_class;
+
+    object_class = G_OBJECT_CLASS (klass);
+    object_class->dispose = mate_mixer_control_dispose;
+
+    g_type_class_add_private (object_class, sizeof (MateMixerControlPrivate));
+}
 
 static void
 mate_mixer_control_init (MateMixerControl *control)
 {
-    control->priv = G_TYPE_INSTANCE_GET_PRIVATE (
-        control,
-        MATE_MIXER_TYPE_CONTROL,
-        MateMixerControlPrivate);
+    control->priv = G_TYPE_INSTANCE_GET_PRIVATE (control,
+                                                 MATE_MIXER_TYPE_CONTROL,
+                                                 MateMixerControlPrivate);
 }
 
 static void
-mate_mixer_control_finalize (GObject *object)
+mate_mixer_control_dispose (GObject *object)
 {
     MateMixerControl *control;
 
     control = MATE_MIXER_CONTROL (object);
 
-    mate_mixer_backend_close (control->priv->backend);
+    if (control->priv->backend) {
+        mate_mixer_backend_close (control->priv->backend);
+        g_clear_object (&control->priv->backend);
+    }
 
-    g_object_unref (control->priv->backend);
-    g_object_unref (control->priv->module);
+    g_clear_object (&control->priv->module);
 
-    if (control->priv->devices)
+    if (control->priv->devices) {
         g_list_free_full (control->priv->devices, g_object_unref);
-    if (control->priv->tracks)
-        g_list_free_full (control->priv->tracks, g_object_unref);
-
-    G_OBJECT_CLASS (mate_mixer_control_parent_class)->finalize (object);
-}
-
-static void
-mate_mixer_control_class_init (MateMixerControlClass *klass)
-{
-    GObjectClass *object_class;
-
-    object_class = G_OBJECT_CLASS (klass);
-    object_class->finalize = mate_mixer_control_finalize;
+        control->priv->devices = NULL;
+    }
+    if (control->priv->streams) {
+        g_list_free_full (control->priv->streams, g_object_unref);
+        control->priv->streams = NULL;
+    }
 
-    g_type_class_add_private (object_class, sizeof (MateMixerControlPrivate));
+    G_OBJECT_CLASS (mate_mixer_control_parent_class)->dispose (object);
 }
 
 MateMixerControl *
 mate_mixer_control_new (void)
 {
-    GList                  *modules;
+    const GList            *modules;
     MateMixerControl       *control;
     MateMixerBackend       *backend = NULL;
     MateMixerBackendModule *module = NULL;
@@ -101,7 +110,7 @@ mate_mixer_control_new (void)
     }
 
     /* The last module in the priority list is the "null" module which
-     * should always be initialized correctly, but in case "null" is absent
+     * should always be initialized correctly, but in case "null" is absent,
      * all the other modules might fail their initializations */
     if (backend == NULL)
         return NULL;
@@ -117,7 +126,7 @@ mate_mixer_control_new (void)
 MateMixerControl *
 mate_mixer_control_new_backend (MateMixerBackendType backend_type)
 {
-    GList                  *modules;
+    const GList            *modules;
     MateMixerControl       *control;
     MateMixerBackend       *backend = NULL;
     MateMixerBackendModule *module = NULL;
@@ -129,7 +138,7 @@ mate_mixer_control_new_backend (MateMixerBackendType backend_type)
 
     modules = mate_mixer_get_modules ();
     while (modules) {
-        const MateMixerBackendModuleInfo *info;
+        const MateMixerBackendInfo *info;
 
         module = MATE_MIXER_BACKEND_MODULE (modules->data);
         info   = mate_mixer_backend_module_get_info (module);
@@ -158,35 +167,49 @@ mate_mixer_control_list_devices (MateMixerControl *control)
 {
     g_return_val_if_fail (MATE_MIXER_IS_CONTROL (control), NULL);
 
-    /* This list is cached here and invalidated when the backend
-     * notifies us about a change */
+    /* This list is cached here and invalidated when the backend notifies us
+     * about a change */
     if (control->priv->devices == NULL)
-        control->priv->devices = mate_mixer_backend_list_devices (
-            MATE_MIXER_BACKEND (control->priv->backend));
-
-    // TODO: notification signals from backend
+        control->priv->devices =
+            mate_mixer_backend_list_devices (MATE_MIXER_BACKEND (control->priv->backend));
 
     return (const GList *) control->priv->devices;
 }
 
 const GList *
-mate_mixer_control_list_tracks (MateMixerControl *control)
+mate_mixer_control_list_streams (MateMixerControl *control)
 {
     g_return_val_if_fail (MATE_MIXER_IS_CONTROL (control), NULL);
 
-    /* This list is cached here and invalidated when the backend
-     * notifies us about a change */
-    if (control->priv->tracks == NULL)
-        control->priv->tracks = mate_mixer_backend_list_tracks (
-            MATE_MIXER_BACKEND (control->priv->backend));
+    /* This list is cached here and invalidated when the backend notifies us
+     * about a change */
+    if (control->priv->streams == NULL)
+        control->priv->streams =
+            mate_mixer_backend_list_streams (MATE_MIXER_BACKEND (control->priv->backend));
+
+    return (const GList *) control->priv->streams;
+}
+
+MateMixerStream *
+mate_mixer_control_get_default_input_stream (MateMixerControl *control)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_CONTROL (control), NULL);
+
+    return mate_mixer_backend_get_default_input_stream (control->priv->backend);
+}
+
+MateMixerStream *
+mate_mixer_control_get_default_output_stream (MateMixerControl *control)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_CONTROL (control), NULL);
 
-    return (const GList *) control->priv->tracks;
+    return mate_mixer_backend_get_default_output_stream (control->priv->backend);
 }
 
 const gchar *
 mate_mixer_control_get_backend_name (MateMixerControl *control)
 {
-    const MateMixerBackendModuleInfo *info;
+    const MateMixerBackendInfo *info;
 
     g_return_val_if_fail (MATE_MIXER_IS_CONTROL (control), NULL);
 
@@ -198,7 +221,7 @@ mate_mixer_control_get_backend_name (MateMixerControl *control)
 MateMixerBackendType
 mate_mixer_control_get_backend_type (MateMixerControl *control)
 {
-    const MateMixerBackendModuleInfo *info;
+    const MateMixerBackendInfo *info;
 
     g_return_val_if_fail (MATE_MIXER_IS_CONTROL (control), FALSE);
 
@@ -210,8 +233,8 @@ mate_mixer_control_get_backend_type (MateMixerControl *control)
 static MateMixerBackend *
 mixer_control_init_module (MateMixerBackendModule *module)
 {
-    MateMixerBackend                  *backend;
-    const MateMixerBackendModuleInfo  *info;
+    MateMixerBackend           *backend;
+    const MateMixerBackendInfo *info;
 
     info = mate_mixer_backend_module_get_info (module);
     backend = g_object_newv (info->g_type, 0, NULL);
diff --git a/libmatemixer/matemixer-control.h b/libmatemixer/matemixer-control.h
index 739eabd..3482fbb 100644
--- a/libmatemixer/matemixer-control.h
+++ b/libmatemixer/matemixer-control.h
@@ -21,7 +21,8 @@
 #include <glib.h>
 #include <glib-object.h>
 
-#include "matemixer-enums.h"
+#include <libmatemixer/matemixer-enums.h>
+#include <libmatemixer/matemixer-stream.h>
 
 G_BEGIN_DECLS
 
@@ -51,18 +52,19 @@ struct _MateMixerControl
 
 struct _MateMixerControlClass
 {
-    GObjectClass parent;    
+    GObjectClass parent;
 };
 
 GType mate_mixer_control_get_type (void) G_GNUC_CONST;
 
-MateMixerControl     *mate_mixer_control_new (void);
-MateMixerControl     *mate_mixer_control_new_backend  (MateMixerBackendType backend_type);
-const GList          *mate_mixer_control_list_devices (MateMixerControl *control);
-const GList          *mate_mixer_control_list_tracks  (MateMixerControl *control);
-
-const gchar          *mate_mixer_control_get_backend_name (MateMixerControl *control);
-MateMixerBackendType  mate_mixer_control_get_backend_type (MateMixerControl *control);
+MateMixerControl *    mate_mixer_control_new                       (void);
+MateMixerControl *    mate_mixer_control_new_backend               (MateMixerBackendType  backend_type);
+const GList *         mate_mixer_control_list_devices              (MateMixerControl     *control);
+const GList *         mate_mixer_control_list_streams              (MateMixerControl     *control);
+MateMixerStream  *    mate_mixer_control_get_default_input_stream  (MateMixerControl     *control);
+MateMixerStream  *    mate_mixer_control_get_default_output_stream (MateMixerControl     *control);
+const gchar *         mate_mixer_control_get_backend_name          (MateMixerControl     *control);
+MateMixerBackendType  mate_mixer_control_get_backend_type          (MateMixerControl     *control);
 
 G_END_DECLS
 
diff --git a/libmatemixer/matemixer-device-port.c b/libmatemixer/matemixer-device-port.c
deleted file mode 100644
index ca84ef6..0000000
--- a/libmatemixer/matemixer-device-port.c
+++ /dev/null
@@ -1,270 +0,0 @@
-/*
- * 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 <glib.h>
-#include <glib-object.h>
-
-#include "matemixer-device-port.h"
-#include "matemixer-enums.h"
-#include "matemixer-enum-types.h"
-
-struct _MateMixerDevicePortPrivate
-{
-    gchar    *identifier;
-    gchar    *name;
-    gchar    *icon;
-    guint32   priority;
-
-    MateMixerDevicePortDirection  direction;
-    MateMixerDevicePortStatus     status;
-};
-
-enum
-{
-    PROP_0,
-    PROP_IDENTIFIER,
-    PROP_NAME,
-    PROP_ICON,
-    PROP_PRIORITY,
-    PROP_DIRECTION,
-    PROP_STATUS,
-    N_PROPERTIES
-};
-
-static GParamSpec *properties[N_PROPERTIES] = { NULL, };
-
-G_DEFINE_TYPE (MateMixerDevicePort, mate_mixer_device_port, G_TYPE_OBJECT);
-
-static void
-mate_mixer_device_port_init (MateMixerDevicePort *port)
-{
-    port->priv = G_TYPE_INSTANCE_GET_PRIVATE (
-        port,
-        MATE_MIXER_TYPE_DEVICE_PORT,
-        MateMixerDevicePortPrivate);
-}
-
-static void
-mate_mixer_device_port_get_property (GObject     *object,
-                                     guint        param_id,
-                                     GValue      *value,
-                                     GParamSpec  *pspec)
-{
-    MateMixerDevicePort *port;
-
-    port = MATE_MIXER_DEVICE_PORT (object);
-
-    switch (param_id) {
-    case PROP_IDENTIFIER:
-        g_value_set_string (value, port->priv->identifier);
-        break;
-    case PROP_NAME:
-        g_value_set_string (value, port->priv->name);
-        break;
-    case PROP_ICON:
-        g_value_set_string (value, port->priv->icon);
-        break;
-    case PROP_PRIORITY:
-        g_value_set_uint (value, port->priv->priority);
-        break;
-    case PROP_DIRECTION:
-        g_value_set_flags (value, port->priv->direction);
-        break;
-    case PROP_STATUS:
-        g_value_set_flags (value, port->priv->status);
-        break;
-    default:
-        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
-        break;
-    }
-}
-
-static void
-mate_mixer_device_port_set_property (GObject       *object,
-                                     guint          param_id,
-                                     const GValue  *value,
-                                     GParamSpec    *pspec)
-{
-    MateMixerDevicePort *port;
-
-    port = MATE_MIXER_DEVICE_PORT (object);
-
-    switch (param_id) {
-    case PROP_IDENTIFIER:
-        port->priv->identifier = g_strdup (g_value_get_string (value));
-        break;
-    case PROP_NAME:
-        port->priv->name = g_strdup (g_value_get_string (value));
-        break;
-    case PROP_ICON:
-        port->priv->icon = g_strdup (g_value_get_string (value));
-        break;
-    case PROP_PRIORITY:
-        port->priv->priority = g_value_get_uint (value);
-        break;
-    case PROP_DIRECTION:
-        port->priv->direction = g_value_get_flags (value);
-        break;
-    case PROP_STATUS:
-        port->priv->status = g_value_get_flags (value);
-        break;
-    default:
-        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
-        break;
-    }
-}
-
-static void
-mate_mixer_device_port_finalize (GObject *object)
-{
-    MateMixerDevicePort *port;
-
-    port = MATE_MIXER_DEVICE_PORT (object);
-
-    g_free (port->priv->identifier);
-    g_free (port->priv->name);
-    g_free (port->priv->icon);
-
-    G_OBJECT_CLASS (mate_mixer_device_port_parent_class)->finalize (object);
-}
-
-static void
-mate_mixer_device_port_class_init (MateMixerDevicePortClass *klass)
-{
-    GObjectClass *object_class;
-
-    object_class = G_OBJECT_CLASS (klass);
-    object_class->finalize     = mate_mixer_device_port_finalize;
-    object_class->get_property = mate_mixer_device_port_get_property;
-    object_class->set_property = mate_mixer_device_port_set_property;
-
-    properties[PROP_IDENTIFIER] = g_param_spec_string (
-        "identifier",
-        "Identifier",
-        "Identifier of the device port",
-        NULL,
-        G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
-
-    properties[PROP_NAME] = g_param_spec_string (
-        "name",
-        "Name",
-        "Name of the device port",
-        NULL,
-        G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
-
-    properties[PROP_ICON] = g_param_spec_string (
-        "icon",
-        "Icon",
-        "Icon name for the device port",
-        NULL,
-        G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
-
-    properties[PROP_PRIORITY] = g_param_spec_uint (
-        "priority",
-        "Priority",
-        "Priority of the device port",
-        0,
-        G_MAXUINT32,
-        0,
-        G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
-
-    properties[PROP_DIRECTION] = g_param_spec_flags (
-        "direction",
-        "Direction",
-        "Direction(s) for the device port",
-        MATE_MIXER_TYPE_DEVICE_PORT_DIRECTION,
-        0,
-        G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
-
-    properties[PROP_STATUS] = g_param_spec_flags (
-        "status",
-        "Status",
-        "Status for the device port",
-        MATE_MIXER_TYPE_DEVICE_PORT_STATUS,
-        0,
-        G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
-
-    g_object_class_install_properties (object_class, N_PROPERTIES, properties);
-
-    g_type_class_add_private (object_class, sizeof (MateMixerDevicePortPrivate));
-}
-
-MateMixerDevicePort *
-mate_mixer_device_port_new (const gchar                  *identifier,
-                            const gchar                  *name,
-                            const gchar                  *icon,
-                            guint32                       priority,
-                            MateMixerDevicePortDirection  direction,
-                            MateMixerDevicePortStatus     status)
-{
-    return g_object_new (MATE_MIXER_TYPE_DEVICE_PORT,
-        "identifier",       identifier,
-        "name",             name,
-        "icon",             icon,
-        "priority",         priority,
-        "direction",        direction,
-        "status",           status,
-        NULL);
-}
-
-const gchar *
-mate_mixer_device_port_get_identifier (MateMixerDevicePort *port)
-{
-    g_return_val_if_fail (MATE_MIXER_IS_DEVICE_PORT (port), NULL);
-
-    return port->priv->identifier;
-}
-
-const gchar *
-mate_mixer_device_port_get_name (MateMixerDevicePort *port)
-{
-    g_return_val_if_fail (MATE_MIXER_IS_DEVICE_PORT (port), NULL);
-
-    return port->priv->name;
-}
-
-const gchar *
-mate_mixer_device_port_get_icon (MateMixerDevicePort *port)
-{
-    g_return_val_if_fail (MATE_MIXER_IS_DEVICE_PORT (port), NULL);
-
-    return port->priv->icon;
-}
-
-guint32
-mate_mixer_device_port_get_priority (MateMixerDevicePort *port)
-{
-    g_return_val_if_fail (MATE_MIXER_IS_DEVICE_PORT (port), 0);
-
-    return port->priv->priority;
-}
-
-MateMixerDevicePortDirection
-mate_mixer_device_port_get_direction (MateMixerDevicePort *port)
-{
-    g_return_val_if_fail (MATE_MIXER_IS_DEVICE_PORT (port), 0);
-
-    return port->priv->direction;
-}
-
-MateMixerDevicePortStatus
-mate_mixer_device_port_get_status (MateMixerDevicePort *port)
-{
-    g_return_val_if_fail (MATE_MIXER_IS_DEVICE_PORT (port), 0);
-
-    return port->priv->status;
-}
diff --git a/libmatemixer/matemixer-device-port.h b/libmatemixer/matemixer-device-port.h
deleted file mode 100644
index f21caaf..0000000
--- a/libmatemixer/matemixer-device-port.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * 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/>.
- */
-
-#ifndef MATEMIXER_DEVICE_PORT_H
-#define MATEMIXER_DEVICE_PORT_H
-
-#include <glib.h>
-#include <glib-object.h>
-
-#include <libmatemixer/matemixer-enums.h>
-
-G_BEGIN_DECLS
-
-#define MATE_MIXER_TYPE_DEVICE_PORT              \
-        (mate_mixer_device_port_get_type ())
-#define MATE_MIXER_DEVICE_PORT(o)                \
-        (G_TYPE_CHECK_INSTANCE_CAST ((o), MATE_MIXER_TYPE_DEVICE_PORT, MateMixerDevicePort))
-#define MATE_MIXER_IS_DEVICE_PORT(o)             \
-        (G_TYPE_CHECK_INSTANCE_TYPE ((o), MATE_MIXER_TYPE_DEVICE_PORT))
-#define MATE_MIXER_DEVICE_PORT_CLASS(k)          \
-        (G_TYPE_CHECK_CLASS_CAST ((k), MATE_MIXER_TYPE_DEVICE_PORT, MateMixerDevicePortClass))
-#define MATE_MIXER_IS_DEVICE_PORT_CLASS(k)       \
-        (G_TYPE_CLASS_CHECK_CLASS_TYPE ((k), MATE_MIXER_TYPE_DEVICE_PORT))
-#define MATE_MIXER_DEVICE_PORT_GET_CLASS(o)      \
-        (G_TYPE_INSTANCE_GET_CLASS ((o), MATE_MIXER_TYPE_DEVICE_PORT, MateMixerDevicePortClass))
-
-typedef struct _MateMixerDevicePort         MateMixerDevicePort;
-typedef struct _MateMixerDevicePortClass    MateMixerDevicePortClass;
-typedef struct _MateMixerDevicePortPrivate  MateMixerDevicePortPrivate;
-
-struct _MateMixerDevicePort
-{
-    GObject parent;
-
-    MateMixerDevicePortPrivate *priv;
-};
-
-struct _MateMixerDevicePortClass
-{
-    GObjectClass parent;    
-};
-
-GType mate_mixer_device_port_get_type (void) G_GNUC_CONST;
-
-MateMixerDevicePort *mate_mixer_device_port_new (const gchar                  *identifier,
-                                                 const gchar                  *name,
-                                                 const gchar                  *icon,
-                                                 guint32                       priority,
-                                                 MateMixerDevicePortDirection  direction,
-                                                 MateMixerDevicePortStatus     status);
-
-const gchar *mate_mixer_device_port_get_identifier (MateMixerDevicePort *port);
-
-const gchar *mate_mixer_device_port_get_name (MateMixerDevicePort *port);
-
-const gchar *mate_mixer_device_port_get_icon (MateMixerDevicePort *port);
-
-guint32      mate_mixer_device_port_get_priority (MateMixerDevicePort *port);
-
-MateMixerDevicePortDirection mate_mixer_device_port_get_direction (MateMixerDevicePort *port);
-
-MateMixerDevicePortStatus    mate_mixer_device_port_get_status (MateMixerDevicePort *port);
-
-G_END_DECLS
-
-#endif /* MATEMIXER_PORT_H */
diff --git a/libmatemixer/matemixer-device-profile.c b/libmatemixer/matemixer-device-profile.c
deleted file mode 100644
index 975f5ff..0000000
--- a/libmatemixer/matemixer-device-profile.c
+++ /dev/null
@@ -1,189 +0,0 @@
-/*
- * 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 <glib.h>
-#include <glib-object.h>
-
-#include "matemixer-device-profile.h"
-
-struct _MateMixerDeviceProfilePrivate
-{
-    gchar    *identifier;
-    gchar    *name;
-    guint32   priority;
-};
-
-enum
-{
-    PROP_0,
-    PROP_IDENTIFIER,
-    PROP_NAME,
-    PROP_PRIORITY,
-    N_PROPERTIES
-};
-
-static GParamSpec *properties[N_PROPERTIES] = { NULL, };
-
-G_DEFINE_TYPE (MateMixerDeviceProfile, mate_mixer_device_profile, G_TYPE_OBJECT);
-
-static void
-mate_mixer_device_profile_init (MateMixerDeviceProfile *profile)
-{
-    profile->priv = G_TYPE_INSTANCE_GET_PRIVATE (
-        profile,
-        MATE_MIXER_TYPE_DEVICE_PROFILE,
-        MateMixerDeviceProfilePrivate);
-}
-
-static void
-mate_mixer_device_profile_get_property (GObject     *object,
-                                        guint        param_id,
-                                        GValue      *value,
-                                        GParamSpec  *pspec)
-{
-    MateMixerDeviceProfile *profile;
-
-    profile = MATE_MIXER_DEVICE_PROFILE (object);
-
-    switch (param_id) {
-    case PROP_IDENTIFIER:
-        g_value_set_string (value, profile->priv->identifier);
-        break;
-    case PROP_NAME:
-        g_value_set_string (value, profile->priv->name);
-        break;
-    case PROP_PRIORITY:
-        g_value_set_uint (value, profile->priv->priority);
-        break;
-    default:
-        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
-        break;
-    }
-}
-
-static void
-mate_mixer_device_profile_set_property (GObject       *object,
-                                        guint          param_id,
-                                        const GValue  *value,
-                                        GParamSpec    *pspec)
-{
-    MateMixerDeviceProfile *profile;
-
-    profile = MATE_MIXER_DEVICE_PROFILE (object);
-
-    switch (param_id) {
-    case PROP_IDENTIFIER:
-        profile->priv->identifier = g_strdup (g_value_get_string (value));
-        break;
-    case PROP_NAME:
-        profile->priv->name = g_strdup (g_value_get_string (value));
-        break;
-    case PROP_PRIORITY:
-        profile->priv->priority = g_value_get_uint (value);
-        break;
-    default:
-        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
-        break;
-    }
-}
-
-static void
-mate_mixer_device_profile_finalize (GObject *object)
-{
-    MateMixerDeviceProfile *profile;
-
-    profile = MATE_MIXER_DEVICE_PROFILE (object);
-
-    g_free (profile->priv->identifier);
-    g_free (profile->priv->name);
-
-    G_OBJECT_CLASS (mate_mixer_device_profile_parent_class)->finalize (object);
-}
-
-static void
-mate_mixer_device_profile_class_init (MateMixerDeviceProfileClass *klass)
-{
-    GObjectClass *object_class;
-
-    object_class = G_OBJECT_CLASS (klass);
-    object_class->finalize     = mate_mixer_device_profile_finalize;
-    object_class->get_property = mate_mixer_device_profile_get_property;
-    object_class->set_property = mate_mixer_device_profile_set_property;
-
-    properties[PROP_IDENTIFIER] = g_param_spec_string (
-        "identifier",
-        "Identifier",
-        "Identifier of the device profile",
-        NULL,
-        G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
-
-    properties[PROP_NAME] = g_param_spec_string (
-        "name",
-        "Name",
-        "Name of the device profile",
-        NULL,
-        G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
-
-    properties[PROP_PRIORITY] = g_param_spec_uint (
-        "priority",
-        "Priority",
-        "Priority of the device profile",
-        0,
-        G_MAXUINT32,
-        0,
-        G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
-
-    g_object_class_install_properties (object_class, N_PROPERTIES, properties);
-
-    g_type_class_add_private (object_class, sizeof (MateMixerDeviceProfilePrivate));
-}
-
-MateMixerDeviceProfile *
-mate_mixer_device_profile_new (const gchar  *identifier,
-                               const gchar  *name,
-                               guint32       priority)
-{
-    return g_object_new (MATE_MIXER_TYPE_DEVICE_PROFILE,
-        "identifier",    identifier,
-        "name",          name,
-        "priority",      priority,
-        NULL);
-}
-
-const gchar *
-mate_mixer_device_profile_get_identifier (MateMixerDeviceProfile *profile)
-{
-    g_return_val_if_fail (MATE_MIXER_IS_DEVICE_PROFILE (profile), NULL);
-
-    return profile->priv->identifier;
-}
-
-const gchar *
-mate_mixer_device_profile_get_name (MateMixerDeviceProfile *profile)
-{
-    g_return_val_if_fail (MATE_MIXER_IS_DEVICE_PROFILE (profile), NULL);
-
-    return profile->priv->name;
-}
-
-guint32
-mate_mixer_device_profile_get_priority (MateMixerDeviceProfile *profile)
-{
-    g_return_val_if_fail (MATE_MIXER_IS_DEVICE_PROFILE (profile), NULL);
-
-    return profile->priv->priority;
-}
diff --git a/libmatemixer/matemixer-device-profile.h b/libmatemixer/matemixer-device-profile.h
deleted file mode 100644
index 1ac9020..0000000
--- a/libmatemixer/matemixer-device-profile.h
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * 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/>.
- */
-
-#ifndef MATEMIXER_DEVICE_PROFILE_H
-#define MATEMIXER_DEVICE_PROFILE_H
-
-#include <glib.h>
-#include <glib-object.h>
-
-G_BEGIN_DECLS
-
-#define MATE_MIXER_TYPE_DEVICE_PROFILE              \
-        (mate_mixer_device_profile_get_type ())
-#define MATE_MIXER_DEVICE_PROFILE(o)                \
-        (G_TYPE_CHECK_INSTANCE_CAST ((o), MATE_MIXER_TYPE_DEVICE_PROFILE, MateMixerDeviceProfile))
-#define MATE_MIXER_IS_DEVICE_PROFILE(o)             \
-        (G_TYPE_CHECK_INSTANCE_TYPE ((o), MATE_MIXER_TYPE_DEVICE_PROFILE))
-#define MATE_MIXER_DEVICE_PROFILE_CLASS(k)          \
-        (G_TYPE_CHECK_CLASS_CAST ((k), MATE_MIXER_TYPE_DEVICE_PROFILE, MateMixerDeviceProfileClass))
-#define MATE_MIXER_IS_DEVICE_PROFILE_CLASS(k)       \
-        (G_TYPE_CLASS_CHECK_CLASS_TYPE ((k), MATE_MIXER_TYPE_DEVICE_PROFILE))
-#define MATE_MIXER_DEVICE_PROFILE_GET_CLASS(o)      \
-        (G_TYPE_INSTANCE_GET_CLASS ((o), MATE_MIXER_TYPE_DEVICE_PROFILE, MateMixerDeviceProfileClass))
-
-typedef struct _MateMixerDeviceProfile         MateMixerDeviceProfile;
-typedef struct _MateMixerDeviceProfileClass    MateMixerDeviceProfileClass;
-typedef struct _MateMixerDeviceProfilePrivate  MateMixerDeviceProfilePrivate;
-
-struct _MateMixerDeviceProfile
-{
-    GObject parent;
-
-    MateMixerDeviceProfilePrivate *priv;
-};
-
-struct _MateMixerDeviceProfileClass
-{
-    GObjectClass parent;    
-};
-
-GType mate_mixer_device_profile_get_type (void) G_GNUC_CONST;
-
-MateMixerDeviceProfile *mate_mixer_device_profile_new (const gchar  *identifier,
-                                                       const gchar  *name,
-                                                       guint32       priority);
-
-const gchar            *mate_mixer_device_profile_get_identifier (MateMixerDeviceProfile *profile);
-const gchar            *mate_mixer_device_profile_get_name       (MateMixerDeviceProfile *profile);
-guint32                 mate_mixer_device_profile_get_priority   (MateMixerDeviceProfile *profile);
-
-G_END_DECLS
-
-#endif /* MATEMIXER_PROFILE_H */
diff --git a/libmatemixer/matemixer-device.c b/libmatemixer/matemixer-device.c
index 8e6a465..d4a7c39 100644
--- a/libmatemixer/matemixer-device.c
+++ b/libmatemixer/matemixer-device.c
@@ -19,89 +19,141 @@
 #include <glib-object.h>
 
 #include "matemixer-device.h"
-#include "matemixer-device-profile.h"
+#include "matemixer-enum-types.h"
+#include "matemixer-profile.h"
 
 G_DEFINE_INTERFACE (MateMixerDevice, mate_mixer_device, G_TYPE_OBJECT)
 
 static void
 mate_mixer_device_default_init (MateMixerDeviceInterface *iface)
 {
-    g_object_interface_install_property (
-        iface,
-        g_param_spec_string ("identifier",
-                             "Identifier",
-                             "Identifier of the sound device",
-                             NULL,
-                             G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
-
-    g_object_interface_install_property (
-        iface,
-        g_param_spec_string ("name",
-                             "Name",
-                             "Name of the sound device",
-                             NULL,
-                             G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
-
-    g_object_interface_install_property (
-        iface,
-        g_param_spec_string ("icon",
-                             "Icon",
-                             "Name of the sound device icon",
-                             NULL,
-                             G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
-
-    g_object_interface_install_property (
-        iface,
-        g_param_spec_object ("active-profile",
-                             "Active profile",
-                             "Identifier of the currently active profile",
-                             MATE_MIXER_TYPE_DEVICE_PROFILE,
-                             G_PARAM_CONSTRUCT | G_PARAM_READWRITE));
+    g_object_interface_install_property (iface,
+                                         g_param_spec_string ("name",
+                                                              "Name",
+                                                              "Name of the sound device",
+                                                              NULL,
+                                                              G_PARAM_CONSTRUCT_ONLY |
+                                                              G_PARAM_READWRITE |
+                                                              G_PARAM_STATIC_STRINGS));
+
+    g_object_interface_install_property (iface,
+                                         g_param_spec_string ("description",
+                                                              "Description",
+                                                              "Description of the sound device",
+                                                              NULL,
+                                                              G_PARAM_CONSTRUCT_ONLY |
+                                                              G_PARAM_READWRITE |
+                                                              G_PARAM_STATIC_STRINGS));
+
+    g_object_interface_install_property (iface,
+                                         g_param_spec_string ("icon",
+                                                              "Icon",
+                                                              "Name of the sound device icon",
+                                                              NULL,
+                                                              G_PARAM_CONSTRUCT_ONLY |
+                                                              G_PARAM_READWRITE |
+                                                              G_PARAM_STATIC_STRINGS));
+
+    g_object_interface_install_property (iface,
+                                         g_param_spec_object ("active-profile",
+                                                              "Active profile",
+                                                              "Name of the active profile",
+                                                              MATE_MIXER_TYPE_PROFILE,
+                                                              G_PARAM_READABLE |
+                                                              G_PARAM_STATIC_STRINGS));
+}
+
+const gchar *
+mate_mixer_device_get_name (MateMixerDevice *device)
+{
+    MateMixerDeviceInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_DEVICE (device), NULL);
+
+    iface = MATE_MIXER_DEVICE_GET_INTERFACE (device);
+
+    if (iface->get_name)
+        return iface->get_name (device);
+
+    return NULL;
+}
+
+const gchar *
+mate_mixer_device_get_description (MateMixerDevice *device)
+{
+    MateMixerDeviceInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_DEVICE (device), NULL);
+
+    iface = MATE_MIXER_DEVICE_GET_INTERFACE (device);
+
+    if (iface->get_description)
+        return iface->get_description (device);
+
+    return NULL;
+}
+
+const gchar *
+mate_mixer_device_get_icon (MateMixerDevice *device)
+{
+    MateMixerDeviceInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_DEVICE (device), NULL);
+
+    iface = MATE_MIXER_DEVICE_GET_INTERFACE (device);
+
+    if (iface->get_icon)
+        return iface->get_icon (device);
+
+    return NULL;
 }
 
 const GList *
-mate_mixer_device_list_tracks (MateMixerDevice *device)
+mate_mixer_device_list_streams (MateMixerDevice *device)
 {
     MateMixerDeviceInterface *iface;
 
     g_return_val_if_fail (MATE_MIXER_IS_DEVICE (device), NULL);
 
     iface = MATE_MIXER_DEVICE_GET_INTERFACE (device);
-    if (iface->list_tracks)
-        return iface->list_tracks (device);
+
+    if (iface->list_streams)
+        return iface->list_streams (device);
 
     return NULL;
 }
 
 const GList *
-mate_mixer_device_get_ports (MateMixerDevice *device)
+mate_mixer_device_list_ports (MateMixerDevice *device)
 {
     MateMixerDeviceInterface *iface;
 
     g_return_val_if_fail (MATE_MIXER_IS_DEVICE (device), NULL);
 
     iface = MATE_MIXER_DEVICE_GET_INTERFACE (device);
-    if (iface->get_ports)
-        return iface->get_ports (device);
+
+    if (iface->list_ports)
+        return iface->list_ports (device);
 
     return NULL;
 }
 
 const GList *
-mate_mixer_device_get_profiles (MateMixerDevice *device)
+mate_mixer_device_list_profiles (MateMixerDevice *device)
 {
     MateMixerDeviceInterface *iface;
 
     g_return_val_if_fail (MATE_MIXER_IS_DEVICE (device), NULL);
 
     iface = MATE_MIXER_DEVICE_GET_INTERFACE (device);
-    if (iface->get_profiles)
-        return iface->get_profiles (device);
+
+    if (iface->list_profiles)
+        return iface->list_profiles (device);
 
     return NULL;
 }
 
-MateMixerDeviceProfile *
+MateMixerProfile *
 mate_mixer_device_get_active_profile (MateMixerDevice *device)
 {
     MateMixerDeviceInterface *iface;
@@ -109,6 +161,7 @@ mate_mixer_device_get_active_profile (MateMixerDevice *device)
     g_return_val_if_fail (MATE_MIXER_IS_DEVICE (device), NULL);
 
     iface = MATE_MIXER_DEVICE_GET_INTERFACE (device);
+
     if (iface->get_active_profile)
         return iface->get_active_profile (device);
 
@@ -116,17 +169,17 @@ mate_mixer_device_get_active_profile (MateMixerDevice *device)
 }
 
 gboolean
-mate_mixer_device_set_active_profile (MateMixerDevice *device,
-                                      MateMixerDeviceProfile *profile)
+mate_mixer_device_set_active_profile (MateMixerDevice *device, const gchar *name)
 {
     MateMixerDeviceInterface *iface;
 
-    g_return_val_if_fail (MATE_MIXER_IS_DEVICE (device), NULL);
-    g_return_val_if_fail (MATE_MIXER_IS_DEVICE_PROFILE (profile), NULL);
+    g_return_val_if_fail (MATE_MIXER_IS_DEVICE (device), FALSE);
+    g_return_val_if_fail (name != NULL, FALSE);
 
     iface = MATE_MIXER_DEVICE_GET_INTERFACE (device);
+
     if (iface->set_active_profile)
-        return iface->set_active_profile (device, profile);
+        return iface->set_active_profile (device, name);
 
     return FALSE;
 }
diff --git a/libmatemixer/matemixer-device.h b/libmatemixer/matemixer-device.h
index b601f7d..89c0187 100644
--- a/libmatemixer/matemixer-device.h
+++ b/libmatemixer/matemixer-device.h
@@ -21,8 +21,7 @@
 #include <glib.h>
 #include <glib-object.h>
 
-#include <libmatemixer/matemixer-device-port.h>
-#include <libmatemixer/matemixer-device-profile.h>
+#include <libmatemixer/matemixer-profile.h>
 
 G_BEGIN_DECLS
 
@@ -42,25 +41,28 @@ struct _MateMixerDeviceInterface
 {
     GTypeInterface parent;
 
-    const GList *(*list_tracks) (MateMixerDevice *device);
-    const GList *(*get_ports) (MateMixerDevice *device);
-    const GList *(*get_profiles) (MateMixerDevice *device);
-    MateMixerDeviceProfile *(*get_active_profile) (MateMixerDevice *device);
-    gboolean (*set_active_profile) (MateMixerDevice *device, MateMixerDeviceProfile *profile);
+    const gchar      *(*get_name)           (MateMixerDevice *device);
+    const gchar      *(*get_description)    (MateMixerDevice *device);
+    const gchar      *(*get_icon)           (MateMixerDevice *device);
+    const GList      *(*list_streams)       (MateMixerDevice *device);
+    const GList      *(*list_ports)         (MateMixerDevice *device);
+    const GList      *(*list_profiles)      (MateMixerDevice *device);
+    MateMixerProfile *(*get_active_profile) (MateMixerDevice *device);
+    gboolean          (*set_active_profile) (MateMixerDevice *device,
+                                             const gchar     *name);
 };
 
 GType mate_mixer_device_get_type (void) G_GNUC_CONST;
 
-const GList *mate_mixer_device_list_tracks (MateMixerDevice *device);
-
-const GList *mate_mixer_device_get_ports (MateMixerDevice *device);
-
-const GList *mate_mixer_device_get_profiles (MateMixerDevice *device);
-
-MateMixerDeviceProfile *mate_mixer_device_get_active_profile (MateMixerDevice *device);
-
-gboolean mate_mixer_device_set_active_profile (MateMixerDevice *device,
-                                               MateMixerDeviceProfile *profile);
+const gchar *     mate_mixer_device_get_name           (MateMixerDevice *device);
+const gchar *     mate_mixer_device_get_description    (MateMixerDevice *device);
+const gchar *     mate_mixer_device_get_icon           (MateMixerDevice *device);
+const GList *     mate_mixer_device_list_streams       (MateMixerDevice *device);
+const GList *     mate_mixer_device_list_ports         (MateMixerDevice *device);
+const GList *     mate_mixer_device_list_profiles      (MateMixerDevice *device);
+MateMixerProfile *mate_mixer_device_get_active_profile (MateMixerDevice *device);
+gboolean          mate_mixer_device_set_active_profile (MateMixerDevice *device,
+                                                        const gchar     *name);
 
 G_END_DECLS
 
diff --git a/libmatemixer/matemixer-enum-types.c b/libmatemixer/matemixer-enum-types.c
index 390e32d..0d1c57d 100644
--- a/libmatemixer/matemixer-enum-types.c
+++ b/libmatemixer/matemixer-enum-types.c
@@ -30,9 +30,9 @@ mate_mixer_backend_type_get_type (void)
 
     if (etype == 0) {
         static const GEnumValue values[] = {
-            { MATE_MIXER_BACKEND_TYPE_UNKNOWN, "MATE_MIXER_BACKEND_TYPE_UNKNOWN", "unknown" },
-            { MATE_MIXER_BACKEND_TYPE_PULSE, "MATE_MIXER_BACKEND_TYPE_PULSE", "pulse" },
-            { MATE_MIXER_BACKEND_TYPE_NULL, "MATE_MIXER_BACKEND_TYPE_NULL", "null" },
+            { MATE_MIXER_BACKEND_UNKNOWN, "MATE_MIXER_BACKEND_UNKNOWN", "unknown" },
+            { MATE_MIXER_BACKEND_PULSE, "MATE_MIXER_BACKEND_PULSE", "pulse" },
+            { MATE_MIXER_BACKEND_NULL, "MATE_MIXER_BACKEND_NULL", "null" },
             { 0, NULL, NULL }
         };
         etype = g_enum_register_static (
@@ -43,35 +43,99 @@ mate_mixer_backend_type_get_type (void)
 }
 
 GType
-mate_mixer_device_port_direction_get_type (void)
+mate_mixer_port_status_get_type (void)
 {
     static GType etype = 0;
 
     if (etype == 0) {
-        static const GFlagsValue values[] = {
-            { MATE_MIXER_DEVICE_PORT_DIRECTION_INPUT, "MATE_MIXER_DEVICE_PORT_DIRECTION_INPUT", "input" },
-            { MATE_MIXER_DEVICE_PORT_DIRECTION_OUTPUT, "MATE_MIXER_DEVICE_PORT_DIRECTION_OUTPUT", "output" },
+        static const GEnumValue values[] = {
+            { MATE_MIXER_PORT_UNKNOWN_STATUS, "MATE_MIXER_PORT_UNKNOWN_STATUS", "unknown-status" },
+            { MATE_MIXER_PORT_AVAILABLE, "MATE_MIXER_PORT_AVAILABLE", "available" },
+            { MATE_MIXER_PORT_UNAVAILABLE, "MATE_MIXER_PORT_UNAVAILABLE", "unavailable" },
             { 0, NULL, NULL }
         };
-        etype = g_flags_register_static (
-            g_intern_static_string ("MateMixerDevicePortDirection"),
+        etype = g_enum_register_static (
+            g_intern_static_string ("MateMixerPortStatus"),
             values);
     }
     return etype;
 }
 
 GType
-mate_mixer_device_port_status_get_type (void)
+mate_mixer_stream_flags_get_type (void)
 {
     static GType etype = 0;
 
     if (etype == 0) {
         static const GFlagsValue values[] = {
-            { MATE_MIXER_DEVICE_PORT_STATUS_AVAILABLE, "MATE_MIXER_DEVICE_PORT_STATUS_AVAILABLE", "available" },
+            { MATE_MIXER_STREAM_INPUT, "MATE_MIXER_STREAM_INPUT", "input" },
+            { MATE_MIXER_STREAM_OUTPUT, "MATE_MIXER_STREAM_OUTPUT", "output" },
+            { MATE_MIXER_STREAM_CLIENT, "MATE_MIXER_STREAM_CLIENT", "client" },
+            { MATE_MIXER_STREAM_VIRTUAL, "MATE_MIXER_STREAM_VIRTUAL", "virtual" },
+            { MATE_MIXER_STREAM_OUTPUT_MONITOR, "MATE_MIXER_STREAM_OUTPUT_MONITOR", "output-monitor" },
+            { MATE_MIXER_STREAM_CAN_BALANCE, "MATE_MIXER_STREAM_CAN_BALANCE", "can-balance" },
+            { MATE_MIXER_STREAM_CAN_FADE, "MATE_MIXER_STREAM_CAN_FADE", "can-fade" },
+            { MATE_MIXER_STREAM_FLAT_VOLUME, "MATE_MIXER_STREAM_FLAT_VOLUME", "flat-volume" },
             { 0, NULL, NULL }
         };
         etype = g_flags_register_static (
-            g_intern_static_string ("MateMixerDevicePortStatus"),
+            g_intern_static_string ("MateMixerStreamFlags"),
+            values);
+    }
+    return etype;
+}
+
+GType
+mate_mixer_stream_status_get_type (void)
+{
+    static GType etype = 0;
+
+    if (etype == 0) {
+        static const GEnumValue values[] = {
+            { MATE_MIXER_STREAM_UNKNOWN_STATUS, "MATE_MIXER_STREAM_UNKNOWN_STATUS", "unknown-status" },
+            { MATE_MIXER_STREAM_RUNNING, "MATE_MIXER_STREAM_RUNNING", "running" },
+            { MATE_MIXER_STREAM_IDLE, "MATE_MIXER_STREAM_IDLE", "idle" },
+            { MATE_MIXER_STREAM_SUSPENDED, "MATE_MIXER_STREAM_SUSPENDED", "suspended" },
+            { 0, NULL, NULL }
+        };
+        etype = g_enum_register_static (
+            g_intern_static_string ("MateMixerStreamStatus"),
+            values);
+    }
+    return etype;
+}
+
+GType
+mate_mixer_channel_position_get_type (void)
+{
+    static GType etype = 0;
+
+    if (etype == 0) {
+        static const GEnumValue values[] = {
+            { MATE_MIXER_CHANNEL_UNKNOWN_POSITION, "MATE_MIXER_CHANNEL_UNKNOWN_POSITION", "unknown-position" },
+            { MATE_MIXER_CHANNEL_MONO, "MATE_MIXER_CHANNEL_MONO", "mono" },
+            { MATE_MIXER_CHANNEL_FRONT_LEFT, "MATE_MIXER_CHANNEL_FRONT_LEFT", "front-left" },
+            { MATE_MIXER_CHANNEL_FRONT_RIGHT, "MATE_MIXER_CHANNEL_FRONT_RIGHT", "front-right" },
+            { MATE_MIXER_CHANNEL_FRONT_CENTER, "MATE_MIXER_CHANNEL_FRONT_CENTER", "front-center" },
+            { MATE_MIXER_CHANNEL_LFE, "MATE_MIXER_CHANNEL_LFE", "lfe" },
+            { MATE_MIXER_CHANNEL_BACK_LEFT, "MATE_MIXER_CHANNEL_BACK_LEFT", "back-left" },
+            { MATE_MIXER_CHANNEL_BACK_RIGHT, "MATE_MIXER_CHANNEL_BACK_RIGHT", "back-right" },
+            { MATE_MIXER_CHANNEL_FRONT_LEFT_CENTER, "MATE_MIXER_CHANNEL_FRONT_LEFT_CENTER", "front-left-center" },
+            { MATE_MIXER_CHANNEL_FRONT_RIGHT_CENTER, "MATE_MIXER_CHANNEL_FRONT_RIGHT_CENTER", "front-right-center" },
+            { MATE_MIXER_CHANNEL_BACK_CENTER, "MATE_MIXER_CHANNEL_BACK_CENTER", "back-center" },
+            { MATE_MIXER_CHANNEL_SIDE_LEFT, "MATE_MIXER_CHANNEL_SIDE_LEFT", "side-left" },
+            { MATE_MIXER_CHANNEL_SIDE_RIGHT, "MATE_MIXER_CHANNEL_SIDE_RIGHT", "side-right" },
+            { MATE_MIXER_CHANNEL_TOP_FRONT_LEFT, "MATE_MIXER_CHANNEL_TOP_FRONT_LEFT", "top-front-left" },
+            { MATE_MIXER_CHANNEL_TOP_FRONT_RIGHT, "MATE_MIXER_CHANNEL_TOP_FRONT_RIGHT", "top-front-right" },
+            { MATE_MIXER_CHANNEL_TOP_FRONT_CENTER, "MATE_MIXER_CHANNEL_TOP_FRONT_CENTER", "top-front-center" },
+            { MATE_MIXER_CHANNEL_TOP_CENTER, "MATE_MIXER_CHANNEL_TOP_CENTER", "top-center" },
+            { MATE_MIXER_CHANNEL_TOP_BACK_LEFT, "MATE_MIXER_CHANNEL_TOP_BACK_LEFT", "top-back-left" },
+            { MATE_MIXER_CHANNEL_TOP_BACK_RIGHT, "MATE_MIXER_CHANNEL_TOP_BACK_RIGHT", "top-back-right" },
+            { MATE_MIXER_CHANNEL_TOP_BACK_CENTER, "MATE_MIXER_CHANNEL_TOP_BACK_CENTER", "top-back-center" },
+            { 0, NULL, NULL }
+        };
+        etype = g_enum_register_static (
+            g_intern_static_string ("MateMixerChannelPosition"),
             values);
     }
     return etype;
diff --git a/libmatemixer/matemixer-enum-types.h b/libmatemixer/matemixer-enum-types.h
index fa1551a..ccb87a6 100644
--- a/libmatemixer/matemixer-enum-types.h
+++ b/libmatemixer/matemixer-enum-types.h
@@ -18,6 +18,7 @@
 #ifndef MATEMIXER_ENUM_TYPES_H
 #define MATEMIXER_ENUM_TYPES_H
 
+#include <glib.h>
 #include <glib-object.h>
 
 G_BEGIN_DECLS
@@ -30,11 +31,17 @@ G_BEGIN_DECLS
 #define MATE_MIXER_TYPE_BACKEND_TYPE  (mate_mixer_backend_type_get_type ())
 GType mate_mixer_backend_type_get_type (void) G_GNUC_CONST;
 
-#define MATE_MIXER_TYPE_DEVICE_PORT_DIRECTION  (mate_mixer_device_port_direction_get_type ())
-GType mate_mixer_device_port_direction_get_type (void) G_GNUC_CONST;
+#define MATE_MIXER_TYPE_PORT_STATUS  (mate_mixer_port_status_get_type ())
+GType mate_mixer_port_status_get_type (void) G_GNUC_CONST;
 
-#define MATE_MIXER_TYPE_DEVICE_PORT_STATUS  (mate_mixer_device_port_status_get_type ())
-GType mate_mixer_device_port_status_get_type (void) G_GNUC_CONST;
+#define MATE_MIXER_TYPE_STREAM_FLAGS  (mate_mixer_stream_flags_get_type ())
+GType mate_mixer_stream_flags_get_type (void) G_GNUC_CONST;
+
+#define MATE_MIXER_TYPE_STREAM_STATUS  (mate_mixer_stream_status_get_type ())
+GType mate_mixer_stream_status_get_type (void) G_GNUC_CONST;
+
+#define MATE_MIXER_TYPE_CHANNEL_POSITION  (mate_mixer_channel_position_get_type ())
+GType mate_mixer_channel_position_get_type (void) G_GNUC_CONST;
 
 G_END_DECLS
 
diff --git a/libmatemixer/matemixer-enums.h b/libmatemixer/matemixer-enums.h
index d83f283..cccb70d 100644
--- a/libmatemixer/matemixer-enums.h
+++ b/libmatemixer/matemixer-enums.h
@@ -24,18 +24,56 @@
  */
 
 typedef enum {
-    MATE_MIXER_BACKEND_TYPE_UNKNOWN,
-    MATE_MIXER_BACKEND_TYPE_PULSE,
-    MATE_MIXER_BACKEND_TYPE_NULL
+    MATE_MIXER_BACKEND_UNKNOWN,
+    MATE_MIXER_BACKEND_PULSE,
+    MATE_MIXER_BACKEND_NULL
 } MateMixerBackendType;
 
-typedef enum { /*< flags >*/
-    MATE_MIXER_DEVICE_PORT_DIRECTION_INPUT  = 1 << 0,
-    MATE_MIXER_DEVICE_PORT_DIRECTION_OUTPUT = 1 << 1
-} MateMixerDevicePortDirection;
+typedef enum {
+    MATE_MIXER_PORT_UNKNOWN_STATUS,
+    MATE_MIXER_PORT_AVAILABLE,
+    MATE_MIXER_PORT_UNAVAILABLE
+} MateMixerPortStatus;
 
 typedef enum { /*< flags >*/
-    MATE_MIXER_DEVICE_PORT_STATUS_AVAILABLE = 1 << 0
-} MateMixerDevicePortStatus;
+	MATE_MIXER_STREAM_INPUT          = 1 << 0,
+	MATE_MIXER_STREAM_OUTPUT         = 1 << 1,
+	MATE_MIXER_STREAM_CLIENT         = 1 << 2,
+	MATE_MIXER_STREAM_VIRTUAL        = 1 << 3,
+	MATE_MIXER_STREAM_OUTPUT_MONITOR = 1 << 4,
+	MATE_MIXER_STREAM_CAN_BALANCE    = 1 << 5,
+	MATE_MIXER_STREAM_CAN_FADE       = 1 << 6,
+	MATE_MIXER_STREAM_FLAT_VOLUME    = 1 << 7
+} MateMixerStreamFlags;
+
+typedef enum {
+	MATE_MIXER_STREAM_UNKNOWN_STATUS,
+	MATE_MIXER_STREAM_RUNNING,
+	MATE_MIXER_STREAM_IDLE,
+	MATE_MIXER_STREAM_SUSPENDED
+} MateMixerStreamStatus;
+
+typedef enum {
+	MATE_MIXER_CHANNEL_UNKNOWN_POSITION,
+	MATE_MIXER_CHANNEL_MONO,
+	MATE_MIXER_CHANNEL_FRONT_LEFT,
+	MATE_MIXER_CHANNEL_FRONT_RIGHT,
+	MATE_MIXER_CHANNEL_FRONT_CENTER,
+    MATE_MIXER_CHANNEL_LFE,
+    MATE_MIXER_CHANNEL_BACK_LEFT,
+    MATE_MIXER_CHANNEL_BACK_RIGHT,
+    MATE_MIXER_CHANNEL_FRONT_LEFT_CENTER,
+    MATE_MIXER_CHANNEL_FRONT_RIGHT_CENTER,
+    MATE_MIXER_CHANNEL_BACK_CENTER,
+    MATE_MIXER_CHANNEL_SIDE_LEFT,
+    MATE_MIXER_CHANNEL_SIDE_RIGHT,
+	MATE_MIXER_CHANNEL_TOP_FRONT_LEFT,
+	MATE_MIXER_CHANNEL_TOP_FRONT_RIGHT,
+	MATE_MIXER_CHANNEL_TOP_FRONT_CENTER,
+    MATE_MIXER_CHANNEL_TOP_CENTER,
+	MATE_MIXER_CHANNEL_TOP_BACK_LEFT,
+	MATE_MIXER_CHANNEL_TOP_BACK_RIGHT,
+	MATE_MIXER_CHANNEL_TOP_BACK_CENTER
+} MateMixerChannelPosition;
 
 #endif /* MATEMIXER_ENUMS_H */
diff --git a/libmatemixer/matemixer-port.c b/libmatemixer/matemixer-port.c
new file mode 100644
index 0000000..c4b2de3
--- /dev/null
+++ b/libmatemixer/matemixer-port.c
@@ -0,0 +1,256 @@
+/*
+ * 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 <glib.h>
+#include <glib-object.h>
+
+#include "matemixer-enums.h"
+#include "matemixer-enum-types.h"
+#include "matemixer-port.h"
+
+struct _MateMixerPortPrivate
+{
+    gchar               *name;
+    gchar               *description;
+    gchar               *icon;
+    guint32              priority;
+    MateMixerPortStatus  status;
+};
+
+enum
+{
+    PROP_0,
+    PROP_NAME,
+    PROP_DESCRIPTION,
+    PROP_ICON,
+    PROP_PRIORITY,
+    PROP_STATUS,
+    N_PROPERTIES
+};
+
+static GParamSpec *properties[N_PROPERTIES] = { NULL, };
+
+static void mate_mixer_port_class_init (MateMixerPortClass *klass);
+static void mate_mixer_port_init       (MateMixerPort      *port);
+static void mate_mixer_port_finalize   (GObject            *object);
+
+G_DEFINE_TYPE (MateMixerPort, mate_mixer_port, G_TYPE_OBJECT);
+
+static void
+mate_mixer_port_get_property (GObject    *object,
+                              guint       param_id,
+                              GValue     *value,
+                              GParamSpec *pspec)
+{
+    MateMixerPort *port;
+
+    port = MATE_MIXER_PORT (object);
+
+    switch (param_id) {
+    case PROP_NAME:
+        g_value_set_string (value, port->priv->name);
+        break;
+    case PROP_DESCRIPTION:
+        g_value_set_string (value, port->priv->description);
+        break;
+    case PROP_ICON:
+        g_value_set_string (value, port->priv->icon);
+        break;
+    case PROP_PRIORITY:
+        g_value_set_uint (value, port->priv->priority);
+        break;
+    case PROP_STATUS:
+        g_value_set_enum (value, port->priv->status);
+        break;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+        break;
+    }
+}
+
+static void
+mate_mixer_port_set_property (GObject      *object,
+                              guint         param_id,
+                              const GValue *value,
+                              GParamSpec   *pspec)
+{
+    MateMixerPort *port;
+
+    port = MATE_MIXER_PORT (object);
+
+    switch (param_id) {
+    case PROP_NAME:
+        port->priv->name = g_strdup (g_value_get_string (value));
+        break;
+    case PROP_DESCRIPTION:
+        port->priv->description = g_strdup (g_value_get_string (value));
+        break;
+    case PROP_ICON:
+        port->priv->icon = g_strdup (g_value_get_string (value));
+        break;
+    case PROP_PRIORITY:
+        port->priv->priority = g_value_get_uint (value);
+        break;
+    case PROP_STATUS:
+        port->priv->status = g_value_get_enum (value);
+        break;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+        break;
+    }
+}
+
+static void
+mate_mixer_port_class_init (MateMixerPortClass *klass)
+{
+    GObjectClass *object_class;
+
+    object_class = G_OBJECT_CLASS (klass);
+    object_class->finalize     = mate_mixer_port_finalize;
+    object_class->get_property = mate_mixer_port_get_property;
+    object_class->set_property = mate_mixer_port_set_property;
+
+    properties[PROP_NAME] =
+        g_param_spec_string ("name",
+                             "Name",
+                             "Name of the port",
+                             NULL,
+                             G_PARAM_CONSTRUCT_ONLY |
+                             G_PARAM_READWRITE |
+                             G_PARAM_STATIC_STRINGS);
+
+    properties[PROP_DESCRIPTION] =
+        g_param_spec_string ("description",
+                             "Description",
+                             "Description of the port",
+                             NULL,
+                             G_PARAM_CONSTRUCT_ONLY |
+                             G_PARAM_READWRITE |
+                             G_PARAM_STATIC_STRINGS);
+
+    properties[PROP_ICON] =
+        g_param_spec_string ("icon",
+                             "Icon",
+                             "Name of the port icon",
+                             NULL,
+                             G_PARAM_CONSTRUCT_ONLY |
+                             G_PARAM_READWRITE |
+                             G_PARAM_STATIC_STRINGS);
+
+    properties[PROP_PRIORITY] =
+        g_param_spec_uint ("priority",
+                           "Priority",
+                           "Priority of the port",
+                           0,
+                           G_MAXUINT32,
+                           0,
+                           G_PARAM_CONSTRUCT_ONLY |
+                           G_PARAM_READWRITE |
+                           G_PARAM_STATIC_STRINGS);
+
+    properties[PROP_STATUS] =
+        g_param_spec_enum ("status",
+                           "Status",
+                           "Status for the port",
+                           MATE_MIXER_TYPE_PORT_STATUS,
+                           MATE_MIXER_PORT_UNKNOWN_STATUS,
+                           G_PARAM_CONSTRUCT_ONLY |
+                           G_PARAM_READWRITE |
+                           G_PARAM_STATIC_STRINGS);
+
+    g_object_class_install_properties (object_class, N_PROPERTIES, properties);
+
+    g_type_class_add_private (object_class, sizeof (MateMixerPortPrivate));
+}
+
+static void
+mate_mixer_port_init (MateMixerPort *port)
+{
+    port->priv = G_TYPE_INSTANCE_GET_PRIVATE (port,
+                                              MATE_MIXER_TYPE_PORT,
+                                              MateMixerPortPrivate);
+}
+
+static void
+mate_mixer_port_finalize (GObject *object)
+{
+    MateMixerPort *port;
+
+    port = MATE_MIXER_PORT (object);
+
+    g_free (port->priv->name);
+    g_free (port->priv->description);
+    g_free (port->priv->icon);
+
+    G_OBJECT_CLASS (mate_mixer_port_parent_class)->finalize (object);
+}
+
+MateMixerPort *
+mate_mixer_port_new (const gchar         *name,
+                     const gchar         *description,
+                     const gchar         *icon,
+                     guint32              priority,
+                     MateMixerPortStatus  status)
+{
+    return g_object_new (MATE_MIXER_TYPE_PORT,
+                         "name", name,
+                         "description", description,
+                         "icon", icon,
+                         "priority", priority,
+                         "status", status,
+                         NULL);
+}
+
+const gchar *
+mate_mixer_port_get_name (MateMixerPort *port)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PORT (port), NULL);
+
+    return port->priv->name;
+}
+
+const gchar *
+mate_mixer_port_get_description (MateMixerPort *port)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PORT (port), NULL);
+
+    return port->priv->description;
+}
+
+const gchar *
+mate_mixer_port_get_icon (MateMixerPort *port)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PORT (port), NULL);
+
+    return port->priv->icon;
+}
+
+guint32
+mate_mixer_port_get_priority (MateMixerPort *port)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PORT (port), 0);
+
+    return port->priv->priority;
+}
+
+MateMixerPortStatus
+mate_mixer_port_get_status (MateMixerPort *port)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PORT (port), MATE_MIXER_PORT_UNKNOWN_STATUS);
+
+    return port->priv->status;
+}
diff --git a/libmatemixer/matemixer-port.h b/libmatemixer/matemixer-port.h
new file mode 100644
index 0000000..581f4ec
--- /dev/null
+++ b/libmatemixer/matemixer-port.h
@@ -0,0 +1,73 @@
+/*
+ * 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/>.
+ */
+
+#ifndef MATEMIXER_PORT_H
+#define MATEMIXER_PORT_H
+
+#include <glib.h>
+#include <glib-object.h>
+
+#include <libmatemixer/matemixer-enums.h>
+
+G_BEGIN_DECLS
+
+#define MATE_MIXER_TYPE_PORT                    \
+        (mate_mixer_port_get_type ())
+#define MATE_MIXER_PORT(o)                      \
+        (G_TYPE_CHECK_INSTANCE_CAST ((o), MATE_MIXER_TYPE_PORT, MateMixerPort))
+#define MATE_MIXER_IS_PORT(o)                   \
+        (G_TYPE_CHECK_INSTANCE_TYPE ((o), MATE_MIXER_TYPE_PORT))
+#define MATE_MIXER_PORT_CLASS(k)                \
+        (G_TYPE_CHECK_CLASS_CAST ((k), MATE_MIXER_TYPE_PORT, MateMixerPortClass))
+#define MATE_MIXER_IS_PORT_CLASS(k)             \
+        (G_TYPE_CLASS_CHECK_CLASS_TYPE ((k), MATE_MIXER_TYPE_PORT))
+#define MATE_MIXER_PORT_GET_CLASS(o)            \
+        (G_TYPE_INSTANCE_GET_CLASS ((o), MATE_MIXER_TYPE_PORT, MateMixerPortClass))
+
+typedef struct _MateMixerPort         MateMixerPort;
+typedef struct _MateMixerPortClass    MateMixerPortClass;
+typedef struct _MateMixerPortPrivate  MateMixerPortPrivate;
+
+struct _MateMixerPort
+{
+    GObject parent;
+
+    MateMixerPortPrivate *priv;
+};
+
+struct _MateMixerPortClass
+{
+    GObjectClass parent;
+};
+
+GType mate_mixer_port_get_type (void) G_GNUC_CONST;
+
+MateMixerPort *      mate_mixer_port_new             (const gchar         *name,
+                                                      const gchar         *description,
+                                                      const gchar         *icon,
+                                                      guint32              priority,
+                                                      MateMixerPortStatus  status);
+
+const gchar *        mate_mixer_port_get_name        (MateMixerPort *port);
+const gchar *        mate_mixer_port_get_description (MateMixerPort *port);
+const gchar *        mate_mixer_port_get_icon        (MateMixerPort *port);
+guint32              mate_mixer_port_get_priority    (MateMixerPort *port);
+MateMixerPortStatus  mate_mixer_port_get_status      (MateMixerPort *port);
+
+G_END_DECLS
+
+#endif /* MATEMIXER_PORT_H */
diff --git a/libmatemixer/matemixer-private.h b/libmatemixer/matemixer-private.h
index 8f95664..0eb012a 100644
--- a/libmatemixer/matemixer-private.h
+++ b/libmatemixer/matemixer-private.h
@@ -22,8 +22,8 @@
 
 G_BEGIN_DECLS
 
-GList     *mate_mixer_get_modules     (void);
-gboolean   mate_mixer_is_initialized  (void);
+const GList *mate_mixer_get_modules    (void);
+gboolean     mate_mixer_is_initialized (void);
 
 G_END_DECLS
 
diff --git a/libmatemixer/matemixer-profile.c b/libmatemixer/matemixer-profile.c
new file mode 100644
index 0000000..c32489f
--- /dev/null
+++ b/libmatemixer/matemixer-profile.c
@@ -0,0 +1,196 @@
+/*
+ * 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 <glib.h>
+#include <glib-object.h>
+
+#include "matemixer-profile.h"
+
+struct _MateMixerProfilePrivate
+{
+    gchar   *name;
+    gchar   *description;
+    guint32  priority;
+};
+
+enum
+{
+    PROP_0,
+    PROP_NAME,
+    PROP_DESCRIPTION,
+    PROP_PRIORITY,
+    N_PROPERTIES
+};
+
+static GParamSpec *properties[N_PROPERTIES] = { NULL, };
+
+static void mate_mixer_profile_class_init (MateMixerProfileClass *klass);
+static void mate_mixer_profile_init       (MateMixerProfile      *profile);
+static void mate_mixer_profile_finalize   (GObject               *object);
+
+G_DEFINE_TYPE (MateMixerProfile, mate_mixer_profile, G_TYPE_OBJECT);
+
+static void
+mate_mixer_profile_get_property (GObject    *object,
+                                 guint       param_id,
+                                 GValue     *value,
+                                 GParamSpec *pspec)
+{
+    MateMixerProfile *profile;
+
+    profile = MATE_MIXER_PROFILE (object);
+
+    switch (param_id) {
+    case PROP_NAME:
+        g_value_set_string (value, profile->priv->name);
+        break;
+    case PROP_DESCRIPTION:
+        g_value_set_string (value, profile->priv->description);
+        break;
+    case PROP_PRIORITY:
+        g_value_set_uint (value, profile->priv->priority);
+        break;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+        break;
+    }
+}
+
+static void
+mate_mixer_profile_set_property (GObject      *object,
+                                 guint         param_id,
+                                 const GValue *value,
+                                 GParamSpec   *pspec)
+{
+    MateMixerProfile *profile;
+
+    profile = MATE_MIXER_PROFILE (object);
+
+    switch (param_id) {
+    case PROP_NAME:
+        profile->priv->name = g_strdup (g_value_get_string (value));
+        break;
+    case PROP_DESCRIPTION:
+        profile->priv->description = g_strdup (g_value_get_string (value));
+        break;
+    case PROP_PRIORITY:
+        profile->priv->priority = g_value_get_uint (value);
+        break;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+        break;
+    }
+}
+
+static void
+mate_mixer_profile_class_init (MateMixerProfileClass *klass)
+{
+    GObjectClass *object_class;
+
+    object_class = G_OBJECT_CLASS (klass);
+    object_class->finalize     = mate_mixer_profile_finalize;
+    object_class->get_property = mate_mixer_profile_get_property;
+    object_class->set_property = mate_mixer_profile_set_property;
+
+    properties[PROP_NAME] =
+        g_param_spec_string ("name",
+                             "Name",
+                             "Name of the profile",
+                             NULL,
+                             G_PARAM_CONSTRUCT_ONLY |
+                             G_PARAM_READWRITE |
+                             G_PARAM_STATIC_STRINGS);
+
+    properties[PROP_DESCRIPTION] =
+        g_param_spec_string ("description",
+                             "Description",
+                             "Description of the profile",
+                             NULL,
+                             G_PARAM_CONSTRUCT_ONLY |
+                             G_PARAM_READWRITE |
+                             G_PARAM_STATIC_STRINGS);
+
+    properties[PROP_PRIORITY] =
+        g_param_spec_uint ("priority",
+                           "Priority",
+                           "Priority of the profile",
+                           0,
+                           G_MAXUINT32,
+                           0,
+                           G_PARAM_CONSTRUCT_ONLY |
+                           G_PARAM_READWRITE |
+                           G_PARAM_STATIC_STRINGS);
+
+    g_object_class_install_properties (object_class, N_PROPERTIES, properties);
+
+    g_type_class_add_private (object_class, sizeof (MateMixerProfilePrivate));
+}
+
+static void
+mate_mixer_profile_init (MateMixerProfile *profile)
+{
+    profile->priv = G_TYPE_INSTANCE_GET_PRIVATE (profile,
+                                                 MATE_MIXER_TYPE_PROFILE,
+                                                 MateMixerProfilePrivate);
+}
+
+static void
+mate_mixer_profile_finalize (GObject *object)
+{
+    MateMixerProfile *profile;
+
+    profile = MATE_MIXER_PROFILE (object);
+
+    g_free (profile->priv->name);
+    g_free (profile->priv->description);
+
+    G_OBJECT_CLASS (mate_mixer_profile_parent_class)->finalize (object);
+}
+
+MateMixerProfile *
+mate_mixer_profile_new (const gchar *name, const gchar *description, guint32 priority)
+{
+    return g_object_new (MATE_MIXER_TYPE_PROFILE,
+                         "name", name,
+                         "description", description,
+                         "priority", priority,
+                         NULL);
+}
+
+const gchar *
+mate_mixer_profile_get_name (MateMixerProfile *profile)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PROFILE (profile), NULL);
+
+    return profile->priv->name;
+}
+
+const gchar *
+mate_mixer_profile_get_description (MateMixerProfile *profile)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PROFILE (profile), NULL);
+
+    return profile->priv->description;
+}
+
+guint32
+mate_mixer_profile_get_priority (MateMixerProfile *profile)
+{
+    g_return_val_if_fail (MATE_MIXER_IS_PROFILE (profile), G_MAXUINT32);
+
+    return profile->priv->priority;
+}
diff --git a/libmatemixer/matemixer-profile.h b/libmatemixer/matemixer-profile.h
new file mode 100644
index 0000000..7be140b
--- /dev/null
+++ b/libmatemixer/matemixer-profile.h
@@ -0,0 +1,67 @@
+/*
+ * 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/>.
+ */
+
+#ifndef MATEMIXER_PROFILE_H
+#define MATEMIXER_PROFILE_H
+
+#include <glib.h>
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define MATE_MIXER_TYPE_PROFILE                 \
+        (mate_mixer_profile_get_type ())
+#define MATE_MIXER_PROFILE(o)                   \
+        (G_TYPE_CHECK_INSTANCE_CAST ((o), MATE_MIXER_TYPE_PROFILE, MateMixerProfile))
+#define MATE_MIXER_IS_PROFILE(o)                \
+        (G_TYPE_CHECK_INSTANCE_TYPE ((o), MATE_MIXER_TYPE_PROFILE))
+#define MATE_MIXER_PROFILE_CLASS(k)             \
+        (G_TYPE_CHECK_CLASS_CAST ((k), MATE_MIXER_TYPE_PROFILE, MateMixerProfileClass))
+#define MATE_MIXER_IS_PROFILE_CLASS(k)          \
+        (G_TYPE_CLASS_CHECK_CLASS_TYPE ((k), MATE_MIXER_TYPE_PROFILE))
+#define MATE_MIXER_PROFILE_GET_CLASS(o)         \
+        (G_TYPE_INSTANCE_GET_CLASS ((o), MATE_MIXER_TYPE_PROFILE, MateMixerProfileClass))
+
+typedef struct _MateMixerProfile         MateMixerProfile;
+typedef struct _MateMixerProfileClass    MateMixerProfileClass;
+typedef struct _MateMixerProfilePrivate  MateMixerProfilePrivate;
+
+struct _MateMixerProfile
+{
+    GObject parent;
+
+    MateMixerProfilePrivate *priv;
+};
+
+struct _MateMixerProfileClass
+{
+    GObjectClass parent;
+};
+
+GType mate_mixer_profile_get_type (void) G_GNUC_CONST;
+
+MateMixerProfile *mate_mixer_profile_new             (const gchar      *name,
+                                                      const gchar      *description,
+                                                      guint32           priority);
+
+const gchar *     mate_mixer_profile_get_name        (MateMixerProfile *profile);
+const gchar *     mate_mixer_profile_get_description (MateMixerProfile *profile);
+guint32           mate_mixer_profile_get_priority    (MateMixerProfile *profile);
+
+G_END_DECLS
+
+#endif /* MATEMIXER_PROFILE_H */
diff --git a/libmatemixer/matemixer-stream.c b/libmatemixer/matemixer-stream.c
new file mode 100644
index 0000000..62e0d2e
--- /dev/null
+++ b/libmatemixer/matemixer-stream.c
@@ -0,0 +1,531 @@
+/*
+ * 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 <glib.h>
+#include <glib-object.h>
+
+#include "matemixer-device.h"
+#include "matemixer-enums.h"
+#include "matemixer-enum-types.h"
+#include "matemixer-port.h"
+#include "matemixer-stream.h"
+
+G_DEFINE_INTERFACE (MateMixerStream, mate_mixer_stream, G_TYPE_OBJECT)
+
+static void
+mate_mixer_stream_default_init (MateMixerStreamInterface *iface)
+{
+    g_object_interface_install_property (iface,
+                                         g_param_spec_string ("name",
+                                                              "Name",
+                                                              "Name of the stream",
+                                                              NULL,
+                                                              G_PARAM_CONSTRUCT_ONLY |
+                                                              G_PARAM_READWRITE |
+                                                              G_PARAM_STATIC_STRINGS));
+
+    g_object_interface_install_property (iface,
+                                         g_param_spec_string ("description",
+                                                              "Description",
+                                                              "Description of the stream",
+                                                              NULL,
+                                                              G_PARAM_CONSTRUCT_ONLY |
+                                                              G_PARAM_READWRITE |
+                                                              G_PARAM_STATIC_STRINGS));
+
+    g_object_interface_install_property (iface,
+                                         g_param_spec_string ("icon",
+                                                              "Icon",
+                                                              "Name of the stream icon",
+                                                              NULL,
+                                                              G_PARAM_CONSTRUCT_ONLY |
+                                                              G_PARAM_READWRITE |
+                                                              G_PARAM_STATIC_STRINGS));
+
+    g_object_interface_install_property (iface,
+                                         g_param_spec_object ("device",
+                                                              "Device",
+                                                              "Device the stream belongs to",
+                                                              MATE_MIXER_TYPE_DEVICE,
+                                                              G_PARAM_CONSTRUCT_ONLY |
+                                                              G_PARAM_READWRITE |
+                                                              G_PARAM_STATIC_STRINGS));
+
+    g_object_interface_install_property (iface,
+                                         g_param_spec_enum ("status",
+                                                            "Status",
+                                                            "Status of the stream",
+                                                            MATE_MIXER_TYPE_STREAM_STATUS,
+                                                            MATE_MIXER_STREAM_UNKNOWN_STATUS,
+                                                            G_PARAM_CONSTRUCT_ONLY |
+                                                            G_PARAM_READWRITE |
+                                                            G_PARAM_STATIC_STRINGS));
+
+    g_object_interface_install_property (iface,
+                                         g_param_spec_double ("volume",
+                                                              "Volume",
+                                                              "Volume of the stream",
+                                                              -1, 0, 1,
+                                                              G_PARAM_CONSTRUCT_ONLY |
+                                                              G_PARAM_READWRITE |
+                                                              G_PARAM_STATIC_STRINGS));
+
+    g_object_interface_install_property (iface,
+                                         g_param_spec_string ("mute",
+                                                              "Mute",
+                                                              "Mute state of the stream",
+                                                              FALSE,
+                                                              G_PARAM_CONSTRUCT_ONLY |
+                                                              G_PARAM_READWRITE |
+                                                              G_PARAM_STATIC_STRINGS));
+}
+
+const gchar *
+mate_mixer_stream_get_name (MateMixerStream *stream)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), NULL);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->get_name)
+        return iface->get_name (stream);
+
+    return NULL;
+}
+
+const gchar *
+mate_mixer_stream_get_description (MateMixerStream *stream)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), NULL);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->get_description)
+        return iface->get_description (stream);
+
+    return NULL;
+}
+
+const gchar *
+mate_mixer_stream_get_icon (MateMixerStream *stream)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), NULL);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->get_icon)
+        return iface->get_icon (stream);
+
+    return NULL;
+}
+
+MateMixerDevice *
+mate_mixer_stream_get_device (MateMixerStream *stream)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), NULL);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->get_device)
+        return iface->get_device (stream);
+
+    return NULL;
+}
+
+MateMixerStreamStatus
+mate_mixer_stream_get_status (MateMixerStream *stream)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), MATE_MIXER_STREAM_UNKNOWN_STATUS);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->get_status)
+        return iface->get_status (stream);
+
+    return MATE_MIXER_STREAM_UNKNOWN_STATUS;
+}
+
+gboolean
+mate_mixer_stream_get_mute (MateMixerStream *stream)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->get_mute)
+        return iface->get_mute (stream);
+
+    return FALSE;
+}
+
+gboolean
+mate_mixer_stream_set_mute (MateMixerStream *stream, gboolean mute)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->set_mute)
+        return iface->set_mute (stream, mute);
+
+    return FALSE;
+}
+
+guint32
+mate_mixer_stream_get_volume (MateMixerStream *stream)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), 0);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->get_volume)
+        return iface->get_volume (stream);
+
+    return 0;
+}
+
+gboolean
+mate_mixer_stream_set_volume (MateMixerStream *stream, guint32 volume)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->set_volume)
+        return iface->set_volume (stream, volume);
+
+    return FALSE;
+}
+
+gdouble
+mate_mixer_stream_get_volume_db (MateMixerStream *stream)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), 0);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->get_volume_db)
+        return iface->get_volume_db (stream);
+
+    return 0;
+}
+
+gboolean
+mate_mixer_stream_set_volume_db (MateMixerStream *stream, gdouble volume_db)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->set_volume_db)
+        return iface->set_volume_db (stream, volume_db);
+
+    return FALSE;
+}
+
+guint8
+mate_mixer_stream_get_num_channels (MateMixerStream *stream)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), 0);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->get_num_channels)
+        return iface->get_num_channels (stream);
+
+    return 0;
+}
+
+MateMixerChannelPosition
+mate_mixer_stream_get_channel_position (MateMixerStream *stream, guint8 channel)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), MATE_MIXER_CHANNEL_UNKNOWN_POSITION);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->get_channel_position)
+        return iface->get_channel_position (stream, channel);
+
+    return MATE_MIXER_CHANNEL_UNKNOWN_POSITION;
+}
+
+guint32
+mate_mixer_stream_get_channel_volume (MateMixerStream *stream, guint8 channel)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), 0);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->get_channel_volume)
+        return iface->get_channel_volume (stream, channel);
+
+    return 0;
+}
+
+gboolean
+mate_mixer_stream_set_channel_volume (MateMixerStream *stream, guint8 channel, guint32 volume)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->set_channel_volume)
+        return iface->set_channel_volume (stream, channel, volume);
+
+    return FALSE;
+}
+
+gdouble
+mate_mixer_stream_get_channel_volume_db (MateMixerStream *stream, guint8 channel)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), 0);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->get_channel_volume_db)
+        return iface->get_channel_volume_db (stream, channel);
+
+    return 0;
+}
+
+gboolean
+mate_mixer_stream_set_channel_volume_db (MateMixerStream *stream, guint8 channel, gdouble volume_db)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->set_channel_volume_db)
+        return iface->set_channel_volume_db (stream, channel, volume_db);
+
+    return FALSE;
+}
+
+gboolean
+mate_mixer_stream_has_position (MateMixerStream *stream, MateMixerChannelPosition position)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->has_position)
+        return iface->has_position (stream, position);
+
+    return FALSE;
+}
+
+guint32
+mate_mixer_stream_get_position_volume (MateMixerStream *stream, MateMixerChannelPosition position)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), 0);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->get_position_volume)
+        return iface->get_position_volume (stream, position);
+
+    return 0;
+}
+
+gboolean
+mate_mixer_stream_set_position_volume (MateMixerStream *stream, MateMixerChannelPosition position, guint32 volume)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->set_position_volume)
+        return iface->set_position_volume (stream, position, volume);
+
+    return FALSE;
+}
+
+gdouble
+mate_mixer_stream_get_position_volume_db (MateMixerStream *stream, MateMixerChannelPosition position)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), 0);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->get_position_volume_db)
+        return iface->get_position_volume_db (stream, position);
+
+    return 0;
+}
+
+gboolean
+mate_mixer_stream_set_position_volume_db (MateMixerStream *stream, MateMixerChannelPosition position, gdouble volume_db)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->set_position_volume_db)
+        return iface->set_position_volume_db (stream, position, volume_db);
+
+    return FALSE;
+}
+
+gdouble
+mate_mixer_stream_get_balance (MateMixerStream *stream)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), 0);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->get_balance)
+        return iface->get_balance (stream);
+
+    return 0;
+}
+
+gboolean
+mate_mixer_stream_set_balance (MateMixerStream *stream, gdouble balance)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->set_balance)
+        return iface->set_balance (stream, balance);
+
+    return FALSE;
+}
+
+gdouble
+mate_mixer_stream_get_fade (MateMixerStream *stream)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), 0);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->get_fade)
+        return iface->get_fade (stream);
+
+    return 0;
+}
+
+gboolean
+mate_mixer_stream_set_fade (MateMixerStream *stream, gdouble fade)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->set_fade)
+        return iface->set_fade (stream, fade);
+
+    return FALSE;
+}
+
+const GList *
+mate_mixer_stream_list_ports (MateMixerStream *stream)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), NULL);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->list_ports)
+        return iface->list_ports (stream);
+
+    return NULL;
+}
+
+MateMixerPort *
+mate_mixer_stream_get_active_port (MateMixerStream *stream)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), NULL);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->get_active_port)
+        return iface->get_active_port (stream);
+
+    return NULL;
+}
+
+gboolean
+mate_mixer_stream_set_active_port (MateMixerStream *stream, MateMixerPort *port)
+{
+    MateMixerStreamInterface *iface;
+
+    g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE);
+    g_return_val_if_fail (MATE_MIXER_IS_PORT (port), FALSE);
+
+    iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
+
+    if (iface->set_active_port)
+        return iface->set_active_port (stream, port);
+
+    return FALSE;
+}
diff --git a/libmatemixer/matemixer-stream.h b/libmatemixer/matemixer-stream.h
new file mode 100644
index 0000000..f95f13f
--- /dev/null
+++ b/libmatemixer/matemixer-stream.h
@@ -0,0 +1,165 @@
+/*
+ * 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/>.
+ */
+
+#ifndef MATEMIXER_STREAM_H
+#define MATEMIXER_STREAM_H
+
+#include <glib.h>
+#include <glib-object.h>
+
+#include <libmatemixer/matemixer-device.h>
+#include <libmatemixer/matemixer-enums.h>
+#include <libmatemixer/matemixer-port.h>
+
+G_BEGIN_DECLS
+
+#define MATE_MIXER_TYPE_STREAM                  \
+        (mate_mixer_stream_get_type ())
+#define MATE_MIXER_STREAM(o)                    \
+        (G_TYPE_CHECK_INSTANCE_CAST ((o), MATE_MIXER_TYPE_STREAM, MateMixerStream))
+#define MATE_MIXER_IS_STREAM(o)                 \
+        (G_TYPE_CHECK_INSTANCE_TYPE ((o), MATE_MIXER_TYPE_STREAM))
+#define MATE_MIXER_STREAM_GET_INTERFACE(o)      \
+        (G_TYPE_INSTANCE_GET_INTERFACE ((o), MATE_MIXER_TYPE_STREAM, MateMixerStreamInterface))
+
+typedef struct _MateMixerStream           MateMixerStream; /* dummy object */
+typedef struct _MateMixerStreamInterface  MateMixerStreamInterface;
+
+struct _MateMixerStreamInterface
+{
+    GTypeInterface parent;
+
+    const gchar *            (*get_name)               (MateMixerStream          *stream);
+    const gchar *            (*get_description)        (MateMixerStream          *stream);
+    const gchar *            (*get_icon)               (MateMixerStream          *stream);
+    MateMixerDevice *        (*get_device)             (MateMixerStream          *stream);
+    MateMixerStreamStatus    (*get_status)             (MateMixerStream          *stream);
+    gboolean                 (*get_mute)               (MateMixerStream          *stream);
+    gboolean                 (*set_mute)               (MateMixerStream          *stream,
+                                                        gboolean                  mute);
+    guint32                  (*get_volume)             (MateMixerStream          *stream);
+    gboolean                 (*set_volume)             (MateMixerStream          *stream,
+                                                        guint32                   volume);
+    gdouble                  (*get_volume_db)          (MateMixerStream          *stream);
+    gboolean                 (*set_volume_db)          (MateMixerStream          *stream,
+                                                        gdouble                   volume_db);
+    guint8                   (*get_num_channels)       (MateMixerStream          *stream);
+    MateMixerChannelPosition (*get_channel_position)   (MateMixerStream          *stream,
+                                                        guint8                    channel);
+    guint32                  (*get_channel_volume)     (MateMixerStream          *stream,
+                                                        guint8                    channel);
+    gboolean                 (*set_channel_volume)     (MateMixerStream          *stream,
+                                                        guint8                    channel,
+                                                        guint32                   volume);
+    gdouble                  (*get_channel_volume_db)  (MateMixerStream          *stream,
+                                                        guint8                    channel);
+    gboolean                 (*set_channel_volume_db)  (MateMixerStream          *stream,
+                                                        guint8                    channel,
+                                                        gdouble                   volume_db);
+    gboolean                 (*has_position)           (MateMixerStream          *stream,
+                                                        MateMixerChannelPosition  position);
+    guint32                  (*get_position_volume)    (MateMixerStream          *stream,
+                                                        MateMixerChannelPosition  position);
+    gboolean                 (*set_position_volume)    (MateMixerStream          *stream,
+                                                        MateMixerChannelPosition  position,
+                                                        guint32                   volume);
+    gdouble                  (*get_position_volume_db) (MateMixerStream          *stream,
+                                                        MateMixerChannelPosition  position);
+    gboolean                 (*set_position_volume_db) (MateMixerStream          *stream,
+                                                        MateMixerChannelPosition  position,
+                                                        gdouble                   volume);
+    gboolean                 (*get_balance)            (MateMixerStream          *stream);
+    gboolean                 (*set_balance)            (MateMixerStream          *stream,
+                                                        gdouble                   balance);
+    gboolean                 (*get_fade)               (MateMixerStream          *stream);
+    gboolean                 (*set_fade)               (MateMixerStream          *stream,
+                                                        gdouble                   fade);
+    MateMixerPort *          (*get_active_port)        (MateMixerStream          *stream);
+    gboolean                 (*set_active_port)        (MateMixerStream          *stream,
+                                                        MateMixerPort            *port);
+    const GList *            (*list_ports)             (MateMixerStream          *stream);
+};
+
+GType mate_mixer_stream_get_type (void) G_GNUC_CONST;
+
+const gchar *            mate_mixer_stream_get_name               (MateMixerStream          *stream);
+const gchar *            mate_mixer_stream_get_description        (MateMixerStream          *stream);
+const gchar *            mate_mixer_stream_get_icon               (MateMixerStream          *stream);
+MateMixerDevice *        mate_mixer_stream_get_device             (MateMixerStream          *stream);
+MateMixerStreamStatus    mate_mixer_stream_get_status             (MateMixerStream          *stream);
+
+gboolean                 mate_mixer_stream_get_mute               (MateMixerStream          *stream);
+gboolean                 mate_mixer_stream_set_mute               (MateMixerStream          *stream,
+                                                                   gboolean                  mute);
+
+guint32                  mate_mixer_stream_get_volume             (MateMixerStream          *stream);
+gboolean                 mate_mixer_stream_set_volume             (MateMixerStream          *stream,
+                                                                   guint32                   volume);
+
+gdouble                  mate_mixer_stream_get_volume_db          (MateMixerStream          *stream);
+gboolean                 mate_mixer_stream_set_volume_db          (MateMixerStream          *stream,
+                                                                   gdouble                   volume_db);
+
+guint8                   mate_mixer_stream_get_num_channels       (MateMixerStream          *stream);
+
+MateMixerChannelPosition mate_mixer_stream_get_channel_position   (MateMixerStream          *stream,
+                                                                   guint8                    channel);
+
+guint32                  mate_mixer_stream_get_channel_volume     (MateMixerStream          *stream,
+                                                                   guint8                    channel);
+gboolean                 mate_mixer_stream_set_channel_volume     (MateMixerStream          *stream,
+                                                                   guint8                    channel,
+                                                                   guint32                   volume);
+
+gdouble                  mate_mixer_stream_get_channel_volume_db  (MateMixerStream          *stream,
+                                                                   guint8                    channel);
+gboolean                 mate_mixer_stream_set_channel_volume_db  (MateMixerStream          *stream,
+                                                                   guint8                    channel,
+                                                                   gdouble                   volume_db);
+
+gboolean                 mate_mixer_stream_has_position           (MateMixerStream          *stream,
+                                                                   MateMixerChannelPosition  position);
+
+guint32                  mate_mixer_stream_get_position_volume    (MateMixerStream          *stream,
+                                                                   MateMixerChannelPosition  position);
+gboolean                 mate_mixer_stream_set_position_volume    (MateMixerStream          *stream,
+                                                                   MateMixerChannelPosition  position,
+                                                                   guint32                   volume);
+
+gdouble                  mate_mixer_stream_get_position_volume_db (MateMixerStream          *stream,
+                                                                   MateMixerChannelPosition  position);
+gboolean                 mate_mixer_stream_set_position_volume_db (MateMixerStream          *stream,
+                                                                   MateMixerChannelPosition  position,
+                                                                   gdouble                   volume_db);
+
+gdouble                  mate_mixer_stream_get_balance            (MateMixerStream          *stream);
+gboolean                 mate_mixer_stream_set_balance            (MateMixerStream          *stream,
+                                                                   gdouble                   balance);
+
+gdouble                  mate_mixer_stream_get_fade               (MateMixerStream          *stream);
+gboolean                 mate_mixer_stream_set_fade               (MateMixerStream          *stream,
+                                                                   gdouble                   fade);
+
+const GList *            mate_mixer_stream_list_ports             (MateMixerStream          *stream);
+
+MateMixerPort *          mate_mixer_stream_get_active_port        (MateMixerStream          *stream);
+gboolean                 mate_mixer_stream_set_active_port        (MateMixerStream          *stream,
+                                                                   MateMixerPort            *port);
+
+G_END_DECLS
+
+#endif /* MATEMIXER_STREAM_H */
diff --git a/libmatemixer/matemixer-track.c b/libmatemixer/matemixer-track.c
deleted file mode 100644
index f78c4f8..0000000
--- a/libmatemixer/matemixer-track.c
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * 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 <glib.h>
-#include <glib-object.h>
-
-#include "matemixer-track.h"
-
-G_DEFINE_INTERFACE (MateMixerTrack, mate_mixer_track, G_TYPE_OBJECT)
-
-static void
-mate_mixer_track_default_init (MateMixerTrackInterface *iface)
-{
-    // TODO: properties
-}
diff --git a/libmatemixer/matemixer-track.h b/libmatemixer/matemixer-track.h
deleted file mode 100644
index a535b59..0000000
--- a/libmatemixer/matemixer-track.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * 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/>.
- */
-
-#ifndef MATEMIXER_TRACK_H
-#define MATEMIXER_TRACK_H
-
-#include <glib.h>
-#include <glib-object.h>
-
-G_BEGIN_DECLS
-
-#define MATE_MIXER_TYPE_TRACK                  \
-        (mate_mixer_track_get_type ())
-#define MATE_MIXER_TRACK(o)                    \
-        (G_TYPE_CHECK_INSTANCE_CAST ((o), MATE_MIXER_TYPE_TRACK, MateMixerTrack))
-#define MATE_MIXER_IS_TRACK(o)                 \
-        (G_TYPE_CHECK_INSTANCE_TYPE ((o), MATE_MIXER_TYPE_TRACK))
-#define MATE_MIXER_TRACK_GET_INTERFACE(o)      \
-        (G_TYPE_INSTANCE_GET_INTERFACE ((o), MATE_MIXER_TYPE_TRACK, MateMixerTrackInterface))
-
-typedef struct _MateMixerTrack           MateMixerTrack; /* dummy object */
-typedef struct _MateMixerTrackInterface  MateMixerTrackInterface;
-
-struct _MateMixerTrackInterface
-{
-    GTypeInterface parent;
-};
-
-GType mate_mixer_track_get_type (void) G_GNUC_CONST;
-
-G_END_DECLS
-
-#endif /* MATEMIXER_TRACK_H */
diff --git a/libmatemixer/matemixer.c b/libmatemixer/matemixer.c
index cc4b5f1..3c8f643 100644
--- a/libmatemixer/matemixer.c
+++ b/libmatemixer/matemixer.c
@@ -55,11 +55,8 @@ mate_mixer_init (void)
             }
 
             if (mixer_modules) {
-                /* Sort the usable modules by the priority */
-                mixer_modules = g_list_sort (
-                    mixer_modules,
-                    mixer_compare_modules);
-
+                /* Sort the usable modules by their priority */
+                mixer_modules = g_list_sort (mixer_modules, mixer_compare_modules);
                 mixer_initialized = TRUE;
             } else
                 g_critical ("No usable backend modules have been found");
@@ -85,11 +82,11 @@ mate_mixer_deinit (void)
     mixer_initialized = FALSE;
 }
 
-/* Internal function: return a shared list of loaded backend modules */
-GList *
+/* Internal function: return a list of loaded backend modules */
+const GList *
 mate_mixer_get_modules (void)
 {
-    return mixer_modules;
+    return (const GList *) mixer_modules;
 }
 
 /* Internal function: return TRUE if the library has been initialized */
@@ -124,10 +121,8 @@ mixer_load_modules (void)
                     continue;
 
                 file = g_build_filename (LIBMATEMIXER_BACKEND_DIR, name, NULL);
-                mixer_modules = g_list_prepend (
-                    mixer_modules,
-                    mate_mixer_backend_module_new (file));
-
+                mixer_modules = g_list_prepend (mixer_modules,
+                                                mate_mixer_backend_module_new (file));
                 g_free (file);
             }
 
@@ -151,7 +146,7 @@ mixer_load_modules (void)
 static gint
 mixer_compare_modules (gconstpointer a, gconstpointer b)
 {
-    const MateMixerBackendModuleInfo *info1, *info2;
+    const MateMixerBackendInfo *info1, *info2;
 
     info1 = mate_mixer_backend_module_get_info (MATE_MIXER_BACKEND_MODULE (a));
     info2 = mate_mixer_backend_module_get_info (MATE_MIXER_BACKEND_MODULE (b));
diff --git a/libmatemixer/matemixer.h b/libmatemixer/matemixer.h
index 8a62320..b43de79 100644
--- a/libmatemixer/matemixer.h
+++ b/libmatemixer/matemixer.h
@@ -22,7 +22,7 @@
 #include <libmatemixer/matemixer-control.h>
 #include <libmatemixer/matemixer-device.h>
 #include <libmatemixer/matemixer-enums.h>
-#include <libmatemixer/matemixer-track.h>
+#include <libmatemixer/matemixer-stream.h>
 
 G_BEGIN_DECLS