Weekly update

1 files changed, 793 insertions, 92 deletions

diff --git a/backends/pulse/pulse-stream.c b/backends/pulse/pulse-stream.c
index a9e01d1..529f2c9 100644
--- a/backends/pulse/pulse-stream.c
+++ b/backends/pulse/pulse-stream.c
@@ -17,69 +17,178 @@
 
 #include <glib.h>
 #include <glib-object.h>
+#include <string.h>
 
+#include <libmatemixer/matemixer-device.h>
+#include <libmatemixer/matemixer-enums.h>
 #include <libmatemixer/matemixer-stream.h>
 #include <libmatemixer/matemixer-port.h>
 
 #include <pulse/pulseaudio.h>
 
 #include "pulse-connection.h"
+#include "pulse-helpers.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;
+struct _PulseStreamPrivate
+{
+    guint32                index;
+    guint32                index_device;
+    gchar                 *name;
+    gchar                 *description;
+    gchar                 *icon;
+    MateMixerDevice       *device;
+    MateMixerStreamFlags   flags;
+    MateMixerStreamStatus  status;
+    gboolean               mute;
+    pa_cvolume             volume;
+    pa_volume_t            volume_base;
+    guint32                volume_steps;
+    pa_channel_map         channel_map;
+    gdouble                balance;
+    gdouble                fade;
+    GList                 *ports;
+    MateMixerPort         *port;
+    PulseConnection       *connection;
 };
 
 enum
 {
     PROP_0,
-    PROP_INDEX,
     PROP_NAME,
     PROP_DESCRIPTION,
     PROP_ICON,
-    PROP_CHANNELS,
-    PROP_VOLUME,
+    PROP_DEVICE,
+    PROP_FLAGS,
+    PROP_STATUS,
     PROP_MUTE,
+    PROP_NUM_CHANNELS,
+    PROP_VOLUME,
+    PROP_VOLUME_DB,
+    PROP_BALANCE,
+    PROP_FADE,
+    PROP_ACTIVE_PORT,
+    PROP_INDEX,
+    PROP_CONNECTION,
     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,
+static void mate_mixer_stream_interface_init (MateMixerStreamInterface  *iface);
+static void pulse_stream_class_init          (PulseStreamClass          *klass);
+static void pulse_stream_init                (PulseStream               *stream);
+static void pulse_stream_dispose             (GObject                   *object);
+static void pulse_stream_finalize            (GObject                   *object);
+
+/* Interface implementation */
+static const gchar *            stream_get_name               (MateMixerStream          *stream);
+static const gchar *            stream_get_description        (MateMixerStream          *stream);
+static const gchar *            stream_get_icon               (MateMixerStream          *stream);
+static MateMixerDevice *        stream_get_device             (MateMixerStream          *stream);
+static MateMixerStreamFlags     stream_get_flags              (MateMixerStream          *stream);
+static MateMixerStreamStatus    stream_get_status             (MateMixerStream          *stream);
+static gboolean                 stream_get_mute               (MateMixerStream          *stream);
+static gboolean                 stream_set_mute               (MateMixerStream          *stream,
+                                                               gboolean                  mute);
+static guint                    stream_get_num_channels       (MateMixerStream          *stream);
+static gint64                   stream_get_volume             (MateMixerStream          *stream);
+static gboolean                 stream_set_volume             (MateMixerStream          *stream,
+                                                               gint64                    volume);
+static gdouble                  stream_get_volume_db          (MateMixerStream          *stream);
+static gboolean                 stream_set_volume_db          (MateMixerStream          *stream,
+                                                               gdouble                   volume_db);
+static MateMixerChannelPosition stream_get_channel_position   (MateMixerStream          *stream,
+                                                               guint                     channel);
+static gint64                   stream_get_channel_volume     (MateMixerStream          *stream,
+                                                               guint                     channel);
+static gboolean                 stream_set_channel_volume     (MateMixerStream          *stream,
+                                                               guint                     channel,
+                                                               gint64                    volume);
+static gdouble                  stream_get_channel_volume_db  (MateMixerStream          *stream,
+                                                               guint                     channel);
+static gboolean                 stream_set_channel_volume_db  (MateMixerStream          *stream,
+                                                               guint                     channel,
+                                                               gdouble                   volume_db);
+static gboolean                 stream_has_position           (MateMixerStream          *stream,
+                                                               MateMixerChannelPosition  position);
+static gint64                   stream_get_position_volume    (MateMixerStream          *stream,
+                                                               MateMixerChannelPosition  position);
+static gboolean                 stream_set_position_volume    (MateMixerStream          *stream,
+                                                               MateMixerChannelPosition  position,
+                                                               gint64                    volume);
+static gdouble                  stream_get_position_volume_db (MateMixerStream          *stream,
+                                                               MateMixerChannelPosition  position);
+static gboolean                 stream_set_position_volume_db (MateMixerStream          *stream,
+                                                               MateMixerChannelPosition  position,
+                                                               gdouble                   volume_db);
+static gdouble                  stream_get_balance            (MateMixerStream          *stream);
+static gboolean                 stream_set_balance            (MateMixerStream          *stream,
+                                                               gdouble                   balance);
+static gdouble                  stream_get_fade               (MateMixerStream          *stream);
+static gboolean                 stream_set_fade               (MateMixerStream          *stream,
+                                                               gdouble                   fade);
+static gboolean                 stream_suspend                (MateMixerStream          *stream);
+static gboolean                 stream_resume                 (MateMixerStream          *stream);
+static const GList *            stream_list_ports             (MateMixerStream          *stream);
+static MateMixerPort *          stream_get_active_port        (MateMixerStream          *stream);
+static gboolean                 stream_set_active_port        (MateMixerStream          *stream,
+                                                               const gchar              *port);
+static gint64                   stream_get_min_volume         (MateMixerStream          *stream);
+static gint64                   stream_get_max_volume         (MateMixerStream          *stream);
+static gint64                   stream_get_normal_volume      (MateMixerStream          *stream);
+
+G_DEFINE_ABSTRACT_TYPE_WITH_CODE (PulseStream, 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;
+    iface->get_name                 = stream_get_name;
+    iface->get_description          = stream_get_description;
+    iface->get_icon                 = stream_get_icon;
+    iface->get_device               = stream_get_device;
+    iface->get_flags                = stream_get_flags;
+    iface->get_status               = stream_get_status;
+    iface->get_mute                 = stream_get_mute;
+    iface->set_mute                 = stream_set_mute;
+    iface->get_num_channels         = stream_get_num_channels;
+    iface->get_volume               = stream_get_volume;
+    iface->set_volume               = stream_set_volume;
+    iface->get_volume_db            = stream_get_volume_db;
+    iface->set_volume_db            = stream_set_volume_db;
+    iface->get_channel_position     = stream_get_channel_position;
+    iface->get_channel_volume       = stream_get_channel_volume;
+    iface->set_channel_volume       = stream_set_channel_volume;
+    iface->get_channel_volume_db    = stream_get_channel_volume_db;
+    iface->set_channel_volume_db    = stream_set_channel_volume_db;
+    iface->has_position             = stream_has_position;
+    iface->get_position_volume      = stream_get_position_volume;
+    iface->set_position_volume      = stream_set_position_volume;
+    iface->get_position_volume_db   = stream_get_position_volume_db;
+    iface->set_position_volume_db   = stream_set_position_volume_db;
+    iface->get_balance              = stream_get_balance;
+    iface->set_balance              = stream_set_balance;
+    iface->get_fade                 = stream_get_fade;
+    iface->set_fade                 = stream_set_fade;
+    iface->suspend                  = stream_suspend;
+    iface->resume                   = stream_resume;
+    iface->list_ports               = stream_list_ports;
+    iface->get_active_port          = stream_get_active_port;
+    iface->set_active_port          = stream_set_active_port;
+    iface->get_min_volume           = stream_get_min_volume;
+    iface->get_max_volume           = stream_get_max_volume;
+    iface->get_normal_volume        = stream_get_normal_volume;
 }
 
 static void
-mate_mixer_pulse_stream_get_property (GObject     *object,
-                                      guint        param_id,
-                                      GValue      *value,
-                                      GParamSpec  *pspec)
+pulse_stream_get_property (GObject    *object,
+                           guint       param_id,
+                           GValue     *value,
+                           GParamSpec *pspec)
 {
-    MateMixerPulseStream *stream;
+    PulseStream *stream;
 
-    stream = MATE_MIXER_PULSE_STREAM (object);
+    stream = PULSE_STREAM (object);
 
     switch (param_id) {
     case PROP_NAME:
@@ -91,6 +200,42 @@ mate_mixer_pulse_stream_get_property (GObject     *object,
     case PROP_ICON:
         g_value_set_string (value, stream->priv->icon);
         break;
+    case PROP_DEVICE:
+        g_value_set_object (value, stream->priv->device);
+        break;
+    case PROP_FLAGS:
+        g_value_set_flags (value, stream->priv->flags);
+        break;
+    case PROP_STATUS:
+        g_value_set_enum (value, stream->priv->status);
+        break;
+    case PROP_MUTE:
+        g_value_set_boolean (value, stream->priv->mute);
+        break;
+    case PROP_NUM_CHANNELS:
+        g_value_set_uint (value, stream_get_num_channels (MATE_MIXER_STREAM (stream)));
+        break;
+    case PROP_VOLUME:
+        g_value_set_int64 (value, stream_get_volume (MATE_MIXER_STREAM (stream)));
+        break;
+    case PROP_VOLUME_DB:
+        g_value_set_double (value, stream_get_volume_db (MATE_MIXER_STREAM (stream)));
+        break;
+    case PROP_BALANCE:
+        g_value_set_double (value, stream->priv->balance);
+        break;
+    case PROP_FADE:
+        g_value_set_double (value, stream->priv->fade);
+        break;
+    case PROP_ACTIVE_PORT:
+        g_value_set_object (value, stream->priv->port);
+        break;
+    case PROP_INDEX:
+        g_value_set_uint (value, stream->priv->index);
+        break;
+    case PROP_CONNECTION:
+        g_value_set_object (value, stream->priv->connection);
+        break;
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
         break;
@@ -98,18 +243,18 @@ mate_mixer_pulse_stream_get_property (GObject     *object,
 }
 
 static void
-mate_mixer_pulse_stream_set_property (GObject       *object,
-                                      guint          param_id,
-                                      const GValue  *value,
-                                      GParamSpec    *pspec)
+pulse_stream_set_property (GObject      *object,
+                           guint         param_id,
+                           const GValue *value,
+                           GParamSpec   *pspec)
 {
-    MateMixerPulseStream *stream;
+    PulseStream *stream;
 
-    stream = MATE_MIXER_PULSE_STREAM (object);
+    stream = PULSE_STREAM (object);
 
     switch (param_id) {
     case PROP_NAME:
-        stream->priv->name = g_strdup (g_value_get_string (value));
+        stream->priv->name = g_strdup (g_value_dup_string (value));
         break;
     case PROP_DESCRIPTION:
         stream->priv->description = g_strdup (g_value_get_string (value));
@@ -117,6 +262,28 @@ mate_mixer_pulse_stream_set_property (GObject       *object,
     case PROP_ICON:
         stream->priv->icon = g_strdup (g_value_get_string (value));
         break;
+    case PROP_DEVICE:
+        // XXX may be NULL and the device may become known after the stream,
+        // figure this out..
+        // stream->priv->device = g_object_ref (g_value_get_object (value));
+        break;
+    case PROP_FLAGS:
+        stream->priv->flags = g_value_get_flags (value);
+        break;
+    case PROP_STATUS:
+        stream->priv->status = g_value_get_enum (value);
+        break;
+    case PROP_MUTE:
+        stream->priv->mute = g_value_get_boolean (value);
+        break;
+    case PROP_INDEX:
+        stream->priv->index = g_value_get_uint (value);
+        break;
+    case PROP_CONNECTION:
+        stream->priv->connection = g_value_dup_object (value);
+        break;
+    case PROP_ACTIVE_PORT:
+        break;
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
         break;
@@ -124,136 +291,670 @@ mate_mixer_pulse_stream_set_property (GObject       *object,
 }
 
 static void
-mate_mixer_pulse_stream_class_init (MateMixerPulseStreamClass *klass)
+pulse_stream_class_init (PulseStreamClass *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;
+    object_class->dispose      = pulse_stream_dispose;
+    object_class->finalize     = pulse_stream_finalize;
+    object_class->get_property = pulse_stream_get_property;
+    object_class->set_property = pulse_stream_set_property;
+
+    g_object_class_install_property (object_class,
+                                     PROP_INDEX,
+                                     g_param_spec_uint ("index",
+                                                        "Index",
+                                                        "Stream index",
+                                                        0,
+                                                        G_MAXUINT,
+                                                        0,
+                                                        G_PARAM_CONSTRUCT_ONLY |
+                                                        G_PARAM_READWRITE |
+                                                        G_PARAM_STATIC_STRINGS));
+    g_object_class_install_property (object_class,
+                                     PROP_CONNECTION,
+                                     g_param_spec_object ("connection",
+                                                          "Connection",
+                                                          "PulseAudio connection",
+                                                          PULSE_TYPE_CONNECTION,
+                                                          G_PARAM_CONSTRUCT_ONLY |
+                                                          G_PARAM_READWRITE |
+                                                          G_PARAM_STATIC_STRINGS));
 
     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));
+    g_object_class_override_property (object_class, PROP_DEVICE, "device");
+    g_object_class_override_property (object_class, PROP_FLAGS, "flags");
+    g_object_class_override_property (object_class, PROP_STATUS, "status");
+    g_object_class_override_property (object_class, PROP_MUTE, "mute");
+    g_object_class_override_property (object_class, PROP_NUM_CHANNELS, "num-channels");
+    g_object_class_override_property (object_class, PROP_VOLUME, "volume");
+    g_object_class_override_property (object_class, PROP_VOLUME_DB, "volume-db");
+    g_object_class_override_property (object_class, PROP_BALANCE, "balance");
+    g_object_class_override_property (object_class, PROP_FADE, "fade");
+    g_object_class_override_property (object_class, PROP_ACTIVE_PORT, "active-port");
+
+    g_type_class_add_private (object_class, sizeof (PulseStreamPrivate));
 }
 
 static void
-mate_mixer_pulse_stream_init (MateMixerPulseStream *stream)
+pulse_stream_init (PulseStream *stream)
 {
-    stream->priv = G_TYPE_INSTANCE_GET_PRIVATE (
-        stream,
-        MATE_MIXER_TYPE_PULSE_STREAM,
-        MateMixerPulseStreamPrivate);
+    stream->priv = G_TYPE_INSTANCE_GET_PRIVATE (stream,
+                                                PULSE_TYPE_STREAM,
+                                                PulseStreamPrivate);
 }
 
 static void
-mate_mixer_pulse_stream_dispose (GObject *object)
+pulse_stream_dispose (GObject *object)
 {
-    MateMixerPulseStream *stream;
+    PulseStream *stream;
 
-    stream = MATE_MIXER_PULSE_STREAM (object);
+    stream = 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->port);
+    g_clear_object (&stream->priv->device);
     g_clear_object (&stream->priv->connection);
 
-    G_OBJECT_CLASS (mate_mixer_pulse_stream_parent_class)->dispose (object);
+    G_OBJECT_CLASS (pulse_stream_parent_class)->dispose (object);
 }
 
 static void
-mate_mixer_pulse_stream_finalize (GObject *object)
+pulse_stream_finalize (GObject *object)
 {
-    MateMixerPulseStream *stream;
+    PulseStream *stream;
 
-    stream = MATE_MIXER_PULSE_STREAM (object);
+    stream = 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);
+    G_OBJECT_CLASS (pulse_stream_parent_class)->finalize (object);
+}
+
+guint32
+pulse_stream_get_index (PulseStream *stream)
+{
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    return stream->priv->index;
 }
 
-MateMixerPulseConnection *
-mate_mixer_pulse_stream_get_connection (MateMixerPulseStream *stream)
+PulseConnection *
+pulse_stream_get_connection (PulseStream *stream)
 {
-    g_return_val_if_fail (MATE_MIXER_IS_PULSE_STREAM (stream), NULL);
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), NULL);
 
     return stream->priv->connection;
 }
 
-guint32
-mate_mixer_pulse_stream_get_index (MateMixerPulseStream *stream)
+gboolean
+pulse_stream_update_name (PulseStream *stream, const gchar *name)
 {
-    g_return_val_if_fail (MATE_MIXER_IS_PULSE_STREAM (stream), FALSE);
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
 
-    return stream->priv->index;
+    /* Allow the name to be NULL */
+    if (g_strcmp0 (name, stream->priv->name)) {
+        g_free (stream->priv->name);
+        stream->priv->name = g_strdup (name);
+
+        g_object_notify (G_OBJECT (stream), "name");
+    }
+    return TRUE;
+}
+
+gboolean
+pulse_stream_update_description (PulseStream *stream, const gchar *description)
+{
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    /* Allow the description to be NULL */
+    if (g_strcmp0 (description, stream->priv->description)) {
+        g_free (stream->priv->description);
+        stream->priv->description = g_strdup (description);
+
+        g_object_notify (G_OBJECT (stream), "description");
+    }
+    return TRUE;
 }
 
-const gchar *
-mate_mixer_pulse_stream_get_name (MateMixerStream *stream)
+gboolean
+pulse_stream_update_flags (PulseStream *stream, MateMixerStreamFlags flags)
 {
-    g_return_val_if_fail (MATE_MIXER_IS_PULSE_STREAM (stream), FALSE);
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
 
-    return MATE_MIXER_PULSE_STREAM (stream)->priv->name;
+    if (stream->priv->flags != flags) {
+        stream->priv->flags = flags;
+        g_object_notify (G_OBJECT (stream), "flags");
+    }
+    return TRUE;
 }
 
-const gchar *
-mate_mixer_pulse_stream_get_description (MateMixerStream *stream)
+gboolean
+pulse_stream_update_status (PulseStream *stream, MateMixerStreamStatus status)
 {
-    g_return_val_if_fail (MATE_MIXER_IS_PULSE_STREAM (stream), FALSE);
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
 
-    return MATE_MIXER_PULSE_STREAM (stream)->priv->description;
+    if (stream->priv->status != status) {
+        stream->priv->status = status;
+        g_object_notify (G_OBJECT (stream), "status");
+    }
+    return TRUE;
 }
 
-const gchar *
-mate_mixer_pulse_stream_get_icon (MateMixerStream *stream)
+gboolean
+pulse_stream_update_mute (PulseStream *stream, gboolean mute)
 {
-    g_return_val_if_fail (MATE_MIXER_IS_PULSE_STREAM (stream), FALSE);
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
 
-    return MATE_MIXER_PULSE_STREAM (stream)->priv->icon;
+    if (stream->priv->mute != mute) {
+        stream->priv->mute = mute;
+        g_object_notify (G_OBJECT (stream), "mute");
+    }
+    return TRUE;
 }
 
-MateMixerPort *
-mate_mixer_pulse_stream_get_active_port (MateMixerStream *stream)
+gboolean
+pulse_stream_update_volume (PulseStream *stream, const pa_cvolume *volume)
 {
-    g_return_val_if_fail (MATE_MIXER_IS_PULSE_STREAM (stream), FALSE);
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
 
-    return MATE_MIXER_PULSE_STREAM (stream)->priv->port;
+    if (!pa_cvolume_equal (&stream->priv->volume, volume)) {
+        stream->priv->volume = *volume;
+
+        g_object_notify (G_OBJECT (stream), "volume");
+
+        // XXX probably should notify about volume-db too but the flags may
+        // be known later
+    }
+    return TRUE;
 }
 
-const GList *
-mate_mixer_pulse_stream_list_ports (MateMixerStream *stream)
+gboolean
+pulse_stream_update_volume_extended (PulseStream      *stream,
+                                     const pa_cvolume *volume,
+                                     pa_volume_t       volume_base,
+                                     guint32           volume_steps)
 {
-    g_return_val_if_fail (MATE_MIXER_IS_PULSE_STREAM (stream), FALSE);
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    // XXX use volume_base and volume_steps
+
+    if (!pa_cvolume_equal (&stream->priv->volume, volume)) {
+        stream->priv->volume = *volume;
+
+        g_object_notify (G_OBJECT (stream), "volume");
 
-    return MATE_MIXER_PULSE_STREAM (stream)->priv->ports;
+        // XXX probably should notify about volume-db too but the flags may
+        // be known later
+    }
+
+    stream->priv->volume_base  = volume_base;
+    stream->priv->volume_steps = volume_steps;
+    return TRUE;
 }
 
 gboolean
-mate_mixer_pulse_stream_set_volume (MateMixerStream *stream, guint32 volume)
+pulse_stream_update_channel_map (PulseStream *stream, const pa_channel_map *map)
 {
-    g_return_val_if_fail (MATE_MIXER_IS_PULSE_STREAM (stream), FALSE);
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
 
-    return MATE_MIXER_PULSE_STREAM_GET_CLASS (stream)->set_volume (stream, volume);
+    if (!pa_channel_map_equal (&stream->priv->channel_map, map))
+        stream->priv->channel_map = *map;
+
+    return TRUE;
 }
 
 gboolean
-mate_mixer_pulse_stream_set_mute (MateMixerStream *stream, gboolean mute)
+pulse_stream_update_ports (PulseStream *stream, GList *ports)
 {
-    g_return_val_if_fail (MATE_MIXER_IS_PULSE_STREAM (stream), FALSE);
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
 
-    return MATE_MIXER_PULSE_STREAM_GET_CLASS (stream)->set_mute (stream, mute);
+    /* Right now we do not change the list of ports during update */
+    g_warn_if_fail (stream->priv->ports == NULL);
+
+    stream->priv->ports = ports;
+    return TRUE;
 }
 
 gboolean
-mate_mixer_pulse_stream_set_active_port (MateMixerStream *stream, MateMixerPort *port)
+pulse_stream_update_active_port (PulseStream *stream, const gchar *port_name)
 {
+    GList         *list;
+    MateMixerPort *port = NULL;
+
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    list = stream->priv->ports;
+    while (list) {
+        port = MATE_MIXER_PORT (list->data);
+
+        if (!g_strcmp0 (mate_mixer_port_get_name (port), port_name))
+            break;
+
+        port = NULL;
+        list = list->next;
+    }
+
+    if (stream->priv->port != port) {
+        if (stream->priv->port)
+            g_clear_object (&stream->priv->port);
+        if (port)
+            stream->priv->port = g_object_ref (port);
+
+        g_object_notify (G_OBJECT (stream), "active-port");
+    }
     return TRUE;
 }
+
+static const gchar *
+stream_get_name (MateMixerStream *stream)
+{
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    return PULSE_STREAM (stream)->priv->name;
+}
+
+static const gchar *
+stream_get_description (MateMixerStream *stream)
+{
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    return PULSE_STREAM (stream)->priv->description;
+}
+
+static const gchar *
+stream_get_icon (MateMixerStream *stream)
+{
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    return PULSE_STREAM (stream)->priv->icon;
+}
+
+static MateMixerDevice *
+stream_get_device (MateMixerStream *stream)
+{
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    return PULSE_STREAM (stream)->priv->device;
+}
+
+static MateMixerStreamFlags
+stream_get_flags (MateMixerStream *stream)
+{
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    return PULSE_STREAM (stream)->priv->flags;
+}
+
+static MateMixerStreamStatus
+stream_get_status (MateMixerStream *stream)
+{
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    return PULSE_STREAM (stream)->priv->status;
+}
+
+static gboolean
+stream_get_mute (MateMixerStream *stream)
+{
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    return PULSE_STREAM (stream)->priv->mute;
+}
+
+static gboolean
+stream_set_mute (MateMixerStream *stream, gboolean mute)
+{
+    PulseStream *ps;
+
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    ps = PULSE_STREAM (stream);
+
+    if (ps->priv->mute == mute)
+        return TRUE;
+
+    return PULSE_STREAM_GET_CLASS (stream)->set_mute (stream, mute);
+}
+
+static guint
+stream_get_num_channels (MateMixerStream *stream)
+{
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    return PULSE_STREAM (stream)->priv->volume.channels;
+}
+
+static gint64
+stream_get_volume (MateMixerStream *stream)
+{
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    return (gint64) pa_cvolume_max (&PULSE_STREAM (stream)->priv->volume);
+}
+
+static gboolean
+stream_set_volume (MateMixerStream *stream, gint64 volume)
+{
+    pa_cvolume             cvolume;
+    PulseStream  *ps;
+
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    ps = PULSE_STREAM (stream);
+    cvolume = ps->priv->volume;
+
+    if (pa_cvolume_scale (&cvolume, (pa_volume_t) volume) == NULL) {
+        g_warning ("Invalid PulseAudio volume value %" G_GINT64_FORMAT, volume);
+        return FALSE;
+    }
+
+    /* This is the only function which passes a volume request to the real class, so
+     * all the pa_cvolume validations are only done here */
+
+
+
+    return PULSE_STREAM_GET_CLASS (stream)->set_volume (stream, &cvolume);
+}
+
+static gdouble
+stream_get_volume_db (MateMixerStream *stream)
+{
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), 0.0);
+
+    if (!(mate_mixer_stream_get_flags (stream) & MATE_MIXER_STREAM_HAS_DECIBEL_VOLUME))
+        return FALSE;
+
+    return pa_sw_volume_to_dB (stream_get_volume (stream));
+}
+
+static gboolean
+stream_set_volume_db (MateMixerStream *stream, gdouble volume_db)
+{
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    if (!(mate_mixer_stream_get_flags (stream) & MATE_MIXER_STREAM_HAS_DECIBEL_VOLUME))
+        return FALSE;
+
+    return stream_set_volume (stream, pa_sw_volume_from_dB (volume_db));
+}
+
+static MateMixerChannelPosition
+stream_get_channel_position (MateMixerStream *stream, guint channel)
+{
+    PulseStream *ps;
+
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    ps = PULSE_STREAM (stream);
+
+    if (channel >= ps->priv->channel_map.channels) {
+        g_warning ("Invalid channel %u of stream %s", channel, ps->priv->name);
+        return MATE_MIXER_CHANNEL_UNKNOWN_POSITION;
+    }
+    return pulse_convert_position_to_pulse (ps->priv->channel_map.map[channel]);
+}
+
+static gint64
+stream_get_channel_volume (MateMixerStream *stream, guint channel)
+{
+    PulseStream *ps;
+
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    ps = PULSE_STREAM (stream);
+
+    if (channel >= ps->priv->volume.channels) {
+        g_warning ("Invalid channel %u of stream %s", channel, ps->priv->name);
+        return stream_get_min_volume (stream);
+    }
+    return (gint64) ps->priv->volume.values[channel];
+}
+
+static gboolean
+stream_set_channel_volume (MateMixerStream *stream, guint channel, gint64 volume)
+{
+    pa_cvolume             cvolume;
+    PulseStream  *pstream;
+
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    pstream = PULSE_STREAM (stream);
+    cvolume = pstream->priv->volume;
+
+    if (channel >= pstream->priv->volume.channels) {
+        g_warning ("Invalid channel %u of stream %s", channel, pstream->priv->name);
+        return FALSE;
+    }
+
+    cvolume.values[channel] = (pa_volume_t) volume;
+
+    if (!pa_cvolume_valid (&cvolume)) {
+        g_warning ("Invalid PulseAudio volume value %" G_GINT64_FORMAT, volume);
+        return FALSE;
+    }
+    return PULSE_STREAM_GET_CLASS (stream)->set_volume (stream, &cvolume);
+}
+
+static gdouble
+stream_get_channel_volume_db (MateMixerStream *stream, guint channel)
+{
+    PulseStream *pstream;
+
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), 0.0);
+
+    pstream = PULSE_STREAM (stream);
+
+    if (channel >= pstream->priv->volume.channels) {
+        g_warning ("Invalid channel %u of stream %s", channel, pstream->priv->name);
+        return 0.0;
+    }
+    return pa_sw_volume_to_dB (pstream->priv->volume.values[channel]);
+}
+
+static gboolean
+stream_set_channel_volume_db (MateMixerStream *stream,
+                              guint            channel,
+                              gdouble          volume_db)
+{
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    return stream_set_channel_volume (stream,
+                                      channel,
+                                      pa_sw_volume_from_dB (volume_db));
+}
+
+static gboolean
+stream_has_position (MateMixerStream *stream, MateMixerChannelPosition position)
+{
+    PulseStreamPrivate *priv;
+
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    priv = PULSE_STREAM (stream)->priv;
+
+    return pa_channel_map_has_position (&priv->channel_map,
+                                        pulse_convert_position_to_pulse (position));
+}
+
+static gint64
+stream_get_position_volume (MateMixerStream          *stream,
+                            MateMixerChannelPosition  position)
+{
+    PulseStreamPrivate *priv;
+
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), 0);
+
+    priv = PULSE_STREAM (stream)->priv;
+
+    return pa_cvolume_get_position (&priv->volume,
+                                    &priv->channel_map,
+                                    pulse_convert_position_to_pulse (position));
+}
+
+static gboolean
+stream_set_position_volume (MateMixerStream          *stream,
+                            MateMixerChannelPosition  position,
+                            gint64                    volume)
+{
+    PulseStreamPrivate *priv;
+    pa_cvolume cvolume;
+
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    priv = PULSE_STREAM (stream)->priv;
+    cvolume = priv->volume;
+
+    if (!pa_cvolume_set_position (&cvolume,
+                                  &priv->channel_map,
+                                  pulse_convert_position_to_pulse (position),
+                                  (pa_volume_t) volume)) {
+        return FALSE;
+    }
+    return PULSE_STREAM_GET_CLASS (stream)->set_volume (stream, &cvolume);
+}
+
+static gdouble
+stream_get_position_volume_db (MateMixerStream          *stream,
+                               MateMixerChannelPosition  position)
+{
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), 0.0);
+
+    return pa_sw_volume_to_dB (stream_get_position_volume (stream, position));
+}
+
+static gboolean
+stream_set_position_volume_db (MateMixerStream          *stream,
+                               MateMixerChannelPosition  position,
+                               gdouble                   volume_db)
+{
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    return stream_set_position_volume (stream, position, pa_sw_volume_from_dB (volume_db));
+}
+
+static gdouble
+stream_get_balance (MateMixerStream *stream)
+{
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), 0.0);
+
+    return PULSE_STREAM (stream)->priv->balance;
+}
+
+static gboolean
+stream_set_balance (MateMixerStream *stream, gdouble balance)
+{
+    PulseStream *pstream;
+    pa_cvolume            cvolume;
+
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    pstream = PULSE_STREAM (stream);
+    cvolume = pstream->priv->volume;
+
+    if (balance == pstream->priv->balance)
+        return TRUE;
+
+    if (pa_cvolume_set_balance (&cvolume,
+                                &pstream->priv->channel_map,
+                                (float) balance) == NULL) {
+        return FALSE;
+    }
+    return PULSE_STREAM_GET_CLASS (stream)->set_volume (stream, &cvolume);
+}
+
+static gdouble
+stream_get_fade (MateMixerStream *stream)
+{
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    return PULSE_STREAM (stream)->priv->fade;
+}
+
+static gboolean
+stream_set_fade (MateMixerStream *stream, gdouble fade)
+{
+    pa_cvolume   cvolume;
+    PulseStream *pstream;
+
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    pstream = PULSE_STREAM (stream);
+    cvolume = pstream->priv->volume;
+
+    if (fade == pstream->priv->fade)
+        return TRUE;
+
+    if (pa_cvolume_set_fade (&cvolume,
+                             &pstream->priv->channel_map,
+                             (float) fade) == NULL) {
+        return FALSE;
+    }
+    return PULSE_STREAM_GET_CLASS (stream)->set_volume (stream, &cvolume);
+}
+
+static gboolean
+stream_suspend (MateMixerStream *stream)
+{
+    // TODO
+    return TRUE;
+}
+
+static gboolean
+stream_resume (MateMixerStream *stream)
+{
+    // TODO
+    return TRUE;
+}
+
+static const GList *
+stream_list_ports (MateMixerStream *stream)
+{
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    return (const GList *) PULSE_STREAM (stream)->priv->ports;
+}
+
+static MateMixerPort *
+stream_get_active_port (MateMixerStream *stream)
+{
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+
+    return PULSE_STREAM (stream)->priv->port;
+}
+
+static gboolean
+stream_set_active_port (MateMixerStream *stream, const gchar *port_name)
+{
+    g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+    g_return_val_if_fail (port_name != NULL, FALSE);
+
+    return PULSE_STREAM_GET_CLASS (stream)->set_active_port (stream, port_name);
+}
+
+static gint64
+stream_get_min_volume (MateMixerStream *stream)
+{
+    return (gint64) PA_VOLUME_MUTED;
+}
+
+static gint64
+stream_get_max_volume (MateMixerStream *stream)
+{
+    return (gint64) PA_VOLUME_UI_MAX;
+}
+
+static gint64
+stream_get_normal_volume (MateMixerStream *stream)
+{
+    return (gint64) PA_VOLUME_NORM;
+}