PulseAudio fixes and API updates

author: Michal Ratajsky <[email protected]> 2014-07-18 15:41:59 +0200
committer: Michal Ratajsky <[email protected]> 2014-07-18 15:41:59 +0200
commit: 56c76128b0144a5c61e77d2a7aec07a337cfb66d (patch)
tree: f67ce44025881578cf6de3332064c214da176a23
parent: 85070f3b97a3213d75a7bebf86ad973aaa21c55b (diff)
download: libmatemixer-56c76128b0144a5c61e77d2a7aec07a337cfb66d.tar.bz2
libmatemixer-56c76128b0144a5c61e77d2a7aec07a337cfb66d.tar.xz
53 files changed, 5138 insertions, 2841 deletions
diff --git a/backends/null/null-backend.h b/backends/null/null-backend.h
index ae5f087..505dd80 100644
--- a/backends/null/null-backend.h
+++ b/backends/null/null-backend.h
@@ -15,13 +15,13 @@
 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef MATEMIXER_NULL_BACKEND_H
-#define MATEMIXER_NULL_BACKEND_H
+#ifndef NULL_BACKEND_H
+#define NULL_BACKEND_H
 
 #include <glib.h>
 #include <glib-object.h>
 
-#include <libmatemixer/matemixer-backend.h>
+#include <libmatemixer/matemixer-backend-module.h>
 
 #define NULL_TYPE_BACKEND \
 (null_backend_get_type ())
@@ -55,4 +55,4 @@ GType null_backend_get_type (void) G_GNUC_CONST;
 void backend_module_init (GTypeModule *module);
 const MateMixerBackendInfo *backend_module_get_info (void);
 
-#endif /* MATEMIXER_NULL_H */
+#endif /* NULL_BACKEND_H */
diff --git a/backends/pulse/Makefile.am b/backends/pulse/Makefile.am
index 3b632a5..0e5a4d6 100644
--- a/backends/pulse/Makefile.am
+++ b/backends/pulse/Makefile.am
@@ -22,6 +22,8 @@ libmatemixer_pulse_la_SOURCES = \
 pulse-enums.h \
 pulse-enum-types.c \
 pulse-enum-types.h \
+ pulse-ext-stream.c \
+ pulse-ext-stream.h \
 pulse-helpers.c \
 pulse-helpers.h \
 pulse-monitor.c \
diff --git a/backends/pulse/pulse-backend.c b/backends/pulse/pulse-backend.c
index da73396..0494545 100644
--- a/backends/pulse/pulse-backend.c
+++ b/backends/pulse/pulse-backend.c
@@ -24,11 +24,13 @@
 #include <libmatemixer/matemixer-stream.h>
 
 #include <pulse/pulseaudio.h>
+#include <pulse/ext-stream-restore.h>
 
 #include "pulse-backend.h"
 #include "pulse-connection.h"
 #include "pulse-device.h"
 #include "pulse-enums.h"
+#include "pulse-ext-stream.h"
 #include "pulse-stream.h"
 #include "pulse-sink.h"
 #include "pulse-sink-input.h"
@@ -50,10 +52,8 @@ struct _PulseBackendPrivate
 MateMixerStream *default_sink;
 MateMixerStream *default_source;
 GHashTable *devices;
- GHashTable *sinks;
- GHashTable *sink_inputs;
- GHashTable *sources;
- GHashTable *source_outputs;
+ GHashTable *streams;
+ GHashTable *ext_streams;
 MateMixerState state;
 PulseConnection *connection;
 };
@@ -85,90 +85,102 @@ G_DEFINE_DYNAMIC_TYPE_EXTENDED (PulseBackend, pulse_backend,
 G_IMPLEMENT_INTERFACE_DYNAMIC (MATE_MIXER_TYPE_BACKEND,
 mate_mixer_backend_interface_init))
 
-static gboolean backend_open (MateMixerBackend *backend);
-static void backend_close (MateMixerBackend *backend);
-
-static MateMixerState backend_get_state (MateMixerBackend *backend);
-
-static void backend_set_data (MateMixerBackend *backend,
- const MateMixerBackendData *data);
-
-static GList * backend_list_devices (MateMixerBackend *backend);
-static GList * backend_list_streams (MateMixerBackend *backend);
-
-static MateMixerStream *backend_get_default_input_stream (MateMixerBackend *backend);
-static gboolean backend_set_default_input_stream (MateMixerBackend *backend,
- MateMixerStream *stream);
-
-static MateMixerStream *backend_get_default_output_stream (MateMixerBackend *backend);
-static gboolean backend_set_default_output_stream (MateMixerBackend *backend,
- MateMixerStream *stream);
-
-static void backend_connection_state_cb (PulseConnection *connection,
- GParamSpec *pspec,
- PulseBackend *pulse);
-
-static void backend_server_info_cb (PulseConnection *connection,
- const pa_server_info *info,
- PulseBackend *pulse);
-
-static void backend_card_info_cb (PulseConnection *connection,
- const pa_card_info *info,
- PulseBackend *pulse);
-static void backend_card_removed_cb (PulseConnection *connection,
- guint index,
- PulseBackend *pulse);
-static void backend_sink_info_cb (PulseConnection *connection,
- const pa_sink_info *info,
- PulseBackend *pulse);
-static void backend_sink_removed_cb (PulseConnection *connection,
- guint index,
- PulseBackend *pulse);
-static void backend_sink_input_info_cb (PulseConnection *connection,
- const pa_sink_input_info *info,
- PulseBackend *pulse);
-static void backend_sink_input_removed_cb (PulseConnection *connection,
- guint index,
- PulseBackend *pulse);
-static void backend_source_info_cb (PulseConnection *connection,
- const pa_source_info *info,
- PulseBackend *pulse);
-static void backend_source_removed_cb (PulseConnection *connection,
- guint index,
- PulseBackend *pulse);
-static void backend_source_output_info_cb (PulseConnection *connection,
- const pa_source_output_info *info,
- PulseBackend *pulse);
-static void backend_source_output_removed_cb (PulseConnection *connection,
- guint index,
- PulseBackend *pulse);
-
-static gboolean backend_try_reconnect (PulseBackend *pulse);
-static void backend_remove_connect_source (PulseBackend *pulse);
-
-static void backend_mark_hanging (PulseBackend *pulse);
-static void backend_mark_hanging_hash (GHashTable *hash);
-
-static void backend_remove_hanging (PulseBackend *pulse);
-static void backend_remove_hanging_hash (PulseBackend *pulse,
- GHashTable *hash);
-
-static void backend_remove_device (PulseBackend *pulse,
- PulseDevice *device);
-static void backend_remove_stream (PulseBackend *pulse,
- GHashTable *hash,
- PulseStream *stream);
-
-static void backend_change_state (PulseBackend *backend,
- MateMixerState state);
-
-static gint backend_compare_devices (gconstpointer a,
- gconstpointer b);
-static gint backend_compare_streams (gconstpointer a,
- gconstpointer b);
-static gboolean backend_compare_stream_names (gpointer key,
- gpointer value,
- gpointer user_data);
+static gboolean pulse_backend_open (MateMixerBackend *backend);
+static void pulse_backend_close (MateMixerBackend *backend);
+
+static MateMixerState pulse_backend_get_state (MateMixerBackend *backend);
+
+static void pulse_backend_set_data (MateMixerBackend *backend,
+ const MateMixerBackendData *data);
+
+static GList * pulse_backend_list_devices (MateMixerBackend *backend);
+static GList * pulse_backend_list_streams (MateMixerBackend *backend);
+static GList * pulse_backend_list_cached_streams (MateMixerBackend *backend);
+
+static MateMixerStream *pulse_backend_get_default_input_stream (MateMixerBackend *backend);
+static gboolean pulse_backend_set_default_input_stream (MateMixerBackend *backend,
+ MateMixerStream *stream);
+
+static MateMixerStream *pulse_backend_get_default_output_stream (MateMixerBackend *backend);
+static gboolean pulse_backend_set_default_output_stream (MateMixerBackend *backend,
+ MateMixerStream *stream);
+
+static void on_connection_state_notify (PulseConnection *connection,
+ GParamSpec *pspec,
+ PulseBackend *pulse);
+
+static void on_connection_server_info (PulseConnection *connection,
+ const pa_server_info *info,
+ PulseBackend *pulse);
+
+static void on_connection_card_info (PulseConnection *connection,
+ const pa_card_info *info,
+ PulseBackend *pulse);
+static void on_connection_card_removed (PulseConnection *connection,
+ guint index,
+ PulseBackend *pulse);
+static void on_connection_sink_info (PulseConnection *connection,
+ const pa_sink_info *info,
+ PulseBackend *pulse);
+static void on_connection_sink_removed (PulseConnection *connection,
+ guint index,
+ PulseBackend *pulse);
+static void on_connection_sink_input_info (PulseConnection *connection,
+ const pa_sink_input_info *info,
+ PulseBackend *pulse);
+static void on_connection_sink_input_removed (PulseConnection *connection,
+ guint index,
+ PulseBackend *pulse);
+static void on_connection_source_info (PulseConnection *connection,
+ const pa_source_info *info,
+ PulseBackend *pulse);
+static void on_connection_source_removed (PulseConnection *connection,
+ guint index,
+ PulseBackend *pulse);
+static void on_connection_source_output_info (PulseConnection *connection,
+ const pa_source_output_info *info,
+ PulseBackend *pulse);
+static void on_connection_source_output_removed (PulseConnection *connection,
+ guint index,
+ PulseBackend *pulse);
+static void on_connection_ext_stream_loading (PulseConnection *connection,
+ PulseBackend *pulse);
+static void on_connection_ext_stream_loaded (PulseConnection *connection,
+ PulseBackend *pulse);
+static void on_connection_ext_stream_info (PulseConnection *connection,
+ const pa_ext_stream_restore_info *info,
+ PulseBackend *pulse);
+
+static gboolean connect_source_reconnect (PulseBackend *pulse);
+static void connect_source_remove (PulseBackend *pulse);
+
+static void check_pending_sink (PulseBackend *pulse,
+ PulseStream *stream);
+static void check_pending_source (PulseBackend *pulse,
+ PulseStream *stream);
+
+static void mark_hanging (PulseBackend *pulse);
+static void mark_hanging_hash (GHashTable *hash);
+
+static void unmark_hanging (PulseBackend *pulse,
+ GObject *object);
+
+static void remove_hanging (PulseBackend *pulse);
+static void remove_device (PulseBackend *pulse,
+ PulseDevice *device);
+static void remove_stream (PulseBackend *pulse,
+ PulseStream *stream);
+
+static void change_state (PulseBackend *backend,
+ MateMixerState state);
+
+static gint compare_devices (gconstpointer a,
+ gconstpointer b);
+static gint compare_streams (gconstpointer a,
+ gconstpointer b);
+static gboolean compare_stream_names (gpointer key,
+ gpointer value,
+ gpointer user_data);
 
 static MateMixerBackendInfo info;
 
@@ -192,16 +204,17 @@ backend_module_get_info (void)
 static void
 mate_mixer_backend_interface_init (MateMixerBackendInterface *iface)
 {
- iface->open = backend_open;
- iface->close = backend_close;
- iface->get_state = backend_get_state;
- iface->set_data = backend_set_data;
- iface->list_devices = backend_list_devices;
- iface->list_streams = backend_list_streams;
- iface->get_default_input_stream = backend_get_default_input_stream;
- iface->set_default_input_stream = backend_set_default_input_stream;
- iface->get_default_output_stream = backend_get_default_output_stream;
- iface->set_default_output_stream = backend_set_default_output_stream;
+ iface->open = pulse_backend_open;
+ iface->close = pulse_backend_close;
+ iface->get_state = pulse_backend_get_state;
+ iface->set_data = pulse_backend_set_data;
+ iface->list_devices = pulse_backend_list_devices;
+ iface->list_streams = pulse_backend_list_streams;
+ iface->list_cached_streams = pulse_backend_list_cached_streams;
+ iface->get_default_input_stream = pulse_backend_get_default_input_stream;
+ iface->set_default_input_stream = pulse_backend_set_default_input_stream;
+ iface->get_default_output_stream = pulse_backend_get_default_output_stream;
+ iface->set_default_output_stream = pulse_backend_set_default_output_stream;
 }
 
 static void
@@ -260,40 +273,28 @@ pulse_backend_init (PulseBackend *pulse)
 PULSE_TYPE_BACKEND,
 PulseBackendPrivate);
 
- /* These hash tables store PulseDevice and PulseStream instances, the key
- * is the PulseAudio index which is not unique across different stream
- * types, hence the separate hash tables */
+ /* These hash tables store PulseDevice and PulseStream instances */
 pulse->priv->devices =
 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,
+ pulse->priv->streams =
+ g_hash_table_new_full (g_int64_hash,
+ g_int64_equal,
+ g_free,
 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,
+ pulse->priv->ext_streams =
+ g_hash_table_new_full (g_str_hash,
+ g_str_equal,
+ g_free,
 g_object_unref);
 }
 
 static void
 pulse_backend_dispose (GObject *object)
 {
- backend_close (MATE_MIXER_BACKEND (object));
+ pulse_backend_close (MATE_MIXER_BACKEND (object));
 
 G_OBJECT_CLASS (pulse_backend_parent_class)->dispose (object);
 }
@@ -312,16 +313,14 @@ pulse_backend_finalize (GObject *object)
 g_free (pulse->priv->server_address);
 
 g_hash_table_destroy (pulse->priv->devices);
- g_hash_table_destroy (pulse->priv->sinks);
- g_hash_table_destroy (pulse->priv->sink_inputs);
- g_hash_table_destroy (pulse->priv->sources);
- g_hash_table_destroy (pulse->priv->source_outputs);
+ g_hash_table_destroy (pulse->priv->streams);
+ g_hash_table_destroy (pulse->priv->ext_streams);
 
 G_OBJECT_CLASS (pulse_backend_parent_class)->finalize (object);
 }
 
 static gboolean
-backend_open (MateMixerBackend *backend)
+pulse_backend_open (MateMixerBackend *backend)
 {
 PulseBackend *pulse;
 PulseConnection *connection;
@@ -345,75 +344,87 @@ backend_open (MateMixerBackend *backend)
 * but it sets up the PulseAudio structures, which might fail in an
 * unlikely case */
 if (G_UNLIKELY (connection == NULL)) {
- backend_change_state (pulse, MATE_MIXER_STATE_FAILED);
+ change_state (pulse, MATE_MIXER_STATE_FAILED);
 return FALSE;
 }
 
- g_signal_connect (connection,
+ g_signal_connect (G_OBJECT (connection),
 "notify::state",
- G_CALLBACK (backend_connection_state_cb),
+ G_CALLBACK (on_connection_state_notify),
 pulse);
- g_signal_connect (connection,
+ g_signal_connect (G_OBJECT (connection),
 "server-info",
- G_CALLBACK (backend_server_info_cb),
+ G_CALLBACK (on_connection_server_info),
 pulse);
- g_signal_connect (connection,
+ g_signal_connect (G_OBJECT (connection),
 "card-info",
- G_CALLBACK (backend_card_info_cb),
+ G_CALLBACK (on_connection_card_info),
 pulse);
- g_signal_connect (connection,
+ g_signal_connect (G_OBJECT (connection),
 "card-removed",
- G_CALLBACK (backend_card_removed_cb),
+ G_CALLBACK (on_connection_card_removed),
 pulse);
- g_signal_connect (connection,
+ g_signal_connect (G_OBJECT (connection),
 "sink-info",
- G_CALLBACK (backend_sink_info_cb),
+ G_CALLBACK (on_connection_sink_info),
 pulse);
- g_signal_connect (connection,
+ g_signal_connect (G_OBJECT (connection),
 "sink-removed",
- G_CALLBACK (backend_sink_removed_cb),
+ G_CALLBACK (on_connection_sink_removed),
 pulse);
- g_signal_connect (connection,
+ g_signal_connect (G_OBJECT (connection),
 "sink-input-info",
- G_CALLBACK (backend_sink_input_info_cb),
+ G_CALLBACK (on_connection_sink_input_info),
 pulse);
- g_signal_connect (connection,
+ g_signal_connect (G_OBJECT (connection),
 "sink-input-removed",
- G_CALLBACK (backend_sink_input_removed_cb),
+ G_CALLBACK (on_connection_sink_input_removed),
 pulse);
- g_signal_connect (connection,
+ g_signal_connect (G_OBJECT (connection),
 "source-info",
- G_CALLBACK (backend_source_info_cb),
+ G_CALLBACK (on_connection_source_info),
 pulse);
- g_signal_connect (connection,
+ g_signal_connect (G_OBJECT (connection),
 "source-removed",
- G_CALLBACK (backend_source_removed_cb),
+ G_CALLBACK (on_connection_source_removed),
 pulse);
- g_signal_connect (connection,
+ g_signal_connect (G_OBJECT (connection),
 "source-output-info",
- G_CALLBACK (backend_source_output_info_cb),
+ G_CALLBACK (on_connection_source_output_info),
 pulse);
- g_signal_connect (connection,
+ g_signal_connect (G_OBJECT (connection),
 "source-output-removed",
- G_CALLBACK (backend_source_output_removed_cb),
+ G_CALLBACK (on_connection_source_output_removed),
+ pulse);
+ g_signal_connect (G_OBJECT (connection),
+ "ext-stream-loading",
+ G_CALLBACK (on_connection_ext_stream_loading),
+ pulse);
+ g_signal_connect (G_OBJECT (connection),
+ "ext-stream-loaded",
+ G_CALLBACK (on_connection_ext_stream_loaded),
 pulse);
+ g_signal_connect (G_OBJECT (connection),
+ "ext-stream-info",
+ G_CALLBACK (on_connection_ext_stream_info),
+ pulse);
+
+ change_state (pulse, MATE_MIXER_STATE_CONNECTING);
 
 /* Connect to the PulseAudio server, this might fail either instantly or
 * asynchronously, for example when remote connection timeouts */
- if (!pulse_connection_connect (connection, FALSE)) {
+ if (pulse_connection_connect (connection, FALSE) == FALSE) {
 g_object_unref (connection);
- backend_change_state (pulse, MATE_MIXER_STATE_FAILED);
+ change_state (pulse, MATE_MIXER_STATE_FAILED);
 return FALSE;
 }
 
 pulse->priv->connection = connection;
-
- backend_change_state (pulse, MATE_MIXER_STATE_CONNECTING);
 return TRUE;
 }
 
 static void
-backend_close (MateMixerBackend *backend)
+pulse_backend_close (MateMixerBackend *backend)
 {
 PulseBackend *pulse;
 
@@ -421,24 +432,29 @@ backend_close (MateMixerBackend *backend)
 
 pulse = PULSE_BACKEND (backend);
 
- backend_remove_connect_source (pulse);
+ connect_source_remove (pulse);
+
+ if (pulse->priv->connection != NULL) {
+ g_signal_handlers_disconnect_by_data (G_OBJECT (pulse->priv->connection),
+ pulse);
+
+ g_clear_object (&pulse->priv->connection);
+ }
 
- // XXX disconnect from notifies
- g_clear_object (&pulse->priv->connection);
 g_clear_object (&pulse->priv->default_sink);
 g_clear_object (&pulse->priv->default_source);
 
 g_hash_table_remove_all (pulse->priv->devices);
- g_hash_table_remove_all (pulse->priv->sinks);
- g_hash_table_remove_all (pulse->priv->sink_inputs);
- g_hash_table_remove_all (pulse->priv->sources);
- g_hash_table_remove_all (pulse->priv->source_outputs);
+ g_hash_table_remove_all (pulse->priv->streams);
+ g_hash_table_remove_all (pulse->priv->ext_streams);
 
- backend_change_state (pulse, MATE_MIXER_STATE_IDLE);
+ pulse->priv->connected_once = FALSE;
+
+ change_state (pulse, MATE_MIXER_STATE_IDLE);
 }
 
 static MateMixerState
-backend_get_state (MateMixerBackend *backend)
+pulse_backend_get_state (MateMixerBackend *backend)
 {
 g_return_val_if_fail (PULSE_IS_BACKEND (backend), MATE_MIXER_STATE_UNKNOWN);
 
@@ -446,7 +462,7 @@ backend_get_state (MateMixerBackend *backend)
 }
 
 static void
-backend_set_data (MateMixerBackend *backend, const MateMixerBackendData *data)
+pulse_backend_set_data (MateMixerBackend *backend, const MateMixerBackendData *data)
 {
 PulseBackend *pulse;
 
@@ -469,45 +485,61 @@ backend_set_data (MateMixerBackend *backend, const MateMixerBackendData *data)
 }
 
 static GList *
-backend_list_devices (MateMixerBackend *backend)
+pulse_backend_list_devices (MateMixerBackend *backend)
 {
 GList *list;
 
 g_return_val_if_fail (PULSE_IS_BACKEND (backend), NULL);
 
- /* Always create a new current list, caching is done in the main library */
+ /* Convert the hash table to a sorted linked list, this list is expected
+ * to be cached in the main library */
 list = g_hash_table_get_values (PULSE_BACKEND (backend)->priv->devices);
+ if (list != NULL) {
+ g_list_foreach (list, (GFunc) g_object_ref, NULL);
 
- g_list_foreach (list, (GFunc) g_object_ref, NULL);
-
- return g_list_sort (list, backend_compare_devices);
+ return g_list_sort (list, compare_devices);
+ }
+ return NULL;
 }
 
 static GList *
-backend_list_streams (MateMixerBackend *backend)
+pulse_backend_list_streams (MateMixerBackend *backend)
 {
- GList *list;
- PulseBackend *pulse;
+ GList *list;
 
 g_return_val_if_fail (PULSE_IS_BACKEND (backend), NULL);
 
- pulse = PULSE_BACKEND (backend);
+ /* Convert the hash table to a sorted linked list, this list is expected
+ * to be cached in the main library */
+ list = g_hash_table_get_values (PULSE_BACKEND (backend)->priv->streams);
+ if (list != NULL) {
+ g_list_foreach (list, (GFunc) g_object_ref, NULL);
+
+ return g_list_sort (list, compare_streams);
+ }
+ return NULL;
+}
 
- /* Always create a new current list, caching is done in the main library */
- list = g_list_concat (g_hash_table_get_values (pulse->priv->sinks),
- g_hash_table_get_values (pulse->priv->sink_inputs));
- list = g_list_concat (list,
- g_hash_table_get_values (pulse->priv->sources));
- list = g_list_concat (list,
- g_hash_table_get_values (pulse->priv->source_outputs));
+static GList *
+pulse_backend_list_cached_streams (MateMixerBackend *backend)
+{
+ GList *list;
 
- g_list_foreach (list, (GFunc) g_object_ref, NULL);
+ g_return_val_if_fail (PULSE_IS_BACKEND (backend), NULL);
+
+ /* Convert the hash table to a sorted linked list, this list is expected
+ * to be cached in the main library */
+ list = g_hash_table_get_values (PULSE_BACKEND (backend)->priv->ext_streams);
+ if (list != NULL) {
+ g_list_foreach (list, (GFunc) g_object_ref, NULL);
 
- return g_list_sort (list, backend_compare_streams);
+ return g_list_sort (list, compare_streams);
+ }
+ return NULL;
 }
 
 static MateMixerStream *
-backend_get_default_input_stream (MateMixerBackend *backend)
+pulse_backend_get_default_input_stream (MateMixerBackend *backend)
 {
 g_return_val_if_fail (PULSE_IS_BACKEND (backend), NULL);
 
@@ -515,30 +547,38 @@ backend_get_default_input_stream (MateMixerBackend *backend)
 }
 
 static gboolean
-backend_set_default_input_stream (MateMixerBackend *backend, MateMixerStream *stream)
+pulse_backend_set_default_input_stream (MateMixerBackend *backend,
+ MateMixerStream *stream)
 {
 PulseBackend *pulse;
+ const gchar *name;
 
 g_return_val_if_fail (PULSE_IS_BACKEND (backend), FALSE);
- g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+ g_return_val_if_fail (PULSE_IS_SOURCE (stream), FALSE);
 
 pulse = PULSE_BACKEND (backend);
 
- if (G_UNLIKELY (!PULSE_IS_SOURCE (stream))) {
- g_warn_if_reached ();
+ name = mate_mixer_stream_get_name (stream);
+ if (pulse_connection_set_default_source (pulse->priv->connection, name) == FALSE)
 return FALSE;
- }
 
- if (!pulse_connection_set_default_source (pulse->priv->connection,
- mate_mixer_stream_get_name (stream)))
- return FALSE;
+ if (pulse->priv->default_source != NULL)
+ g_object_unref (pulse->priv->default_source);
+
+ pulse->priv->default_source = g_object_ref (stream);
+
+ /* We might be in the process of setting a default source for which the details
+ * are not yet known, make sure the change does not happen */
+ g_object_set_data (G_OBJECT (pulse),
+ "backend-pending-source",
+ NULL);
 
 g_object_notify (G_OBJECT (pulse), "default-input");
 return TRUE;
 }
 
 static MateMixerStream *
-backend_get_default_output_stream (MateMixerBackend *backend)
+pulse_backend_get_default_output_stream (MateMixerBackend *backend)
 {
 g_return_val_if_fail (PULSE_IS_BACKEND (backend), NULL);
 
@@ -546,55 +586,64 @@ backend_get_default_output_stream (MateMixerBackend *backend)
 }
 
 static gboolean
-backend_set_default_output_stream (MateMixerBackend *backend, MateMixerStream *stream)
+pulse_backend_set_default_output_stream (MateMixerBackend *backend,
+ MateMixerStream *stream)
 {
 PulseBackend *pulse;
+ const gchar *name;
 
 g_return_val_if_fail (PULSE_IS_BACKEND (backend), FALSE);
- g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+ g_return_val_if_fail (PULSE_IS_SINK (stream), FALSE);
 
 pulse = PULSE_BACKEND (backend);
 
- if (G_UNLIKELY (!PULSE_IS_SINK (stream))) {
- g_warn_if_reached ();
+ name = mate_mixer_stream_get_name (stream);
+ if (pulse_connection_set_default_sink (pulse->priv->connection, name) == FALSE)
 return FALSE;
- }
 
- if (!pulse_connection_set_default_sink (pulse->priv->connection,
- mate_mixer_stream_get_name (stream)))
- return FALSE;
+ if (pulse->priv->default_sink != NULL)
+ g_object_unref (pulse->priv->default_sink);
+
+ pulse->priv->default_sink = g_object_ref (stream);
+
+ /* We might be in the process of setting a default sink for which the details
+ * are not yet known, make sure the change does not happen */
+ g_object_set_data (G_OBJECT (pulse),
+ "backend-pending-sink",
+ NULL);
 
 g_object_notify (G_OBJECT (pulse), "default-output");
 return TRUE;
 }
 
 static void
-backend_connection_state_cb (PulseConnection *connection,
- GParamSpec *pspec,
- PulseBackend *pulse)
+on_connection_state_notify (PulseConnection *connection,
+ GParamSpec *pspec,
+ PulseBackend *pulse)
 {
 PulseConnectionState state = pulse_connection_get_state (connection);
 
 switch (state) {
 case PULSE_CONNECTION_DISCONNECTED:
- if (pulse->priv->connected_once) {
+ if (pulse->priv->connected_once == TRUE) {
 /* We managed to connect once before, try to reconnect and if it
 * fails immediately, use a timeout source.
 * All current devices and streams are marked as hanging as it is
- * unknown whether they are still available, stream callbacks will
- * unmark them and remaining unavailable streams will be removed
- * when the CONNECTED state is reached. */
- backend_mark_hanging (pulse);
- backend_change_state (pulse, MATE_MIXER_STATE_CONNECTING);
-
- if (!pulse->priv->connect_source &&
- !pulse_connection_connect (connection, TRUE)) {
+ * unknown whether they are still available.
+ * Stream callbacks will unmark available streams and remaining
+ * unavailable streams will be removed when the CONNECTED state
+ * is reached. */
+ mark_hanging (pulse);
+ change_state (pulse, MATE_MIXER_STATE_CONNECTING);
+
+ if (pulse->priv->connect_source == NULL &&
+ pulse_connection_connect (connection, TRUE) == FALSE) {
 pulse->priv->connect_source = g_timeout_source_new (200);
 
 g_source_set_callback (pulse->priv->connect_source,
- (GSourceFunc) backend_try_reconnect,
+ (GSourceFunc) connect_source_reconnect,
 pulse,
- (GDestroyNotify) backend_remove_connect_source);
+ (GDestroyNotify) connect_source_remove);
 
 g_source_attach (pulse->priv->connect_source,
 g_main_context_get_thread_default ());
@@ -603,30 +652,30 @@ backend_connection_state_cb (PulseConnection *connection,
 }
 
 /* First connection attempt has failed */
- backend_change_state (pulse, MATE_MIXER_STATE_FAILED);
+ change_state (pulse, MATE_MIXER_STATE_FAILED);
 break;
 
 case PULSE_CONNECTION_CONNECTING:
 case PULSE_CONNECTION_AUTHORIZING:
 case PULSE_CONNECTION_LOADING:
- backend_change_state (pulse, MATE_MIXER_STATE_CONNECTING);
+ change_state (pulse, MATE_MIXER_STATE_CONNECTING);
 break;
 
 case PULSE_CONNECTION_CONNECTED:
- if (pulse->priv->connected_once)
- backend_remove_hanging (pulse);
+ if (pulse->priv->connected_once == TRUE)
+ remove_hanging (pulse);
 else
 pulse->priv->connected_once = TRUE;
 
- backend_change_state (pulse, MATE_MIXER_STATE_READY);
+ change_state (pulse, MATE_MIXER_STATE_READY);
 break;
 }
 }
 
 static void
-backend_server_info_cb (PulseConnection *connection,
- const pa_server_info *info,
- PulseBackend *pulse)
+on_connection_server_info (PulseConnection *connection,
+ const pa_server_info *info,
+ PulseBackend *pulse)
 {
 const gchar *name_source = NULL;
 const gchar *name_sink = NULL;
@@ -634,55 +683,94 @@ backend_server_info_cb (PulseConnection *connection,
 if (pulse->priv->default_source != NULL)
 name_source = mate_mixer_stream_get_name (pulse->priv->default_source);
 
- // XXX
- // default input might be monitor !!!
-
- if (g_strcmp0 (name_source, info->default_source_name)) {
+ if (g_strcmp0 (name_source, info->default_source_name) != 0) {
 if (pulse->priv->default_source != NULL)
 g_clear_object (&pulse->priv->default_source);
 
 if (info->default_source_name != NULL) {
- MateMixerStream *stream = g_hash_table_find (pulse->priv->sources,
- backend_compare_stream_names,
+ MateMixerStream *stream = g_hash_table_find (pulse->priv->streams,
+ compare_stream_names,
 (gpointer) info->default_source_name);
 
- /* It is theoretically possible to receive a server info notification
- * before the stream lists are fully downloaded, this should not be
- * a problem as a newer notification will arrive later after the
- * streams are read.
- * Of course this will only work if Pulse delivers notifications in
- * the correct order, but it seems it does. */
- if (G_LIKELY (stream != NULL)) {
+ /* It is possible that we are unaware of the default stream, either
+ * because the stream details have not arrived yet, or because we chose
+ * to ignore the stream.
+ * When this happens, remember the name of the stream and wait for the
+ * stream info callback. */
+ if (stream != NULL) {
 pulse->priv->default_source = g_object_ref (stream);
- g_debug ("Default input stream changed to %s", info->default_source_name);
+ g_object_set_data (G_OBJECT (pulse),
+ "backend-pending-source",
+ NULL);
 
- g_object_notify (G_OBJECT (pulse), "default-input");
- } else
- g_debug ("Default input stream %s not yet known",
+ g_debug ("Default input stream changed to %s", info->default_source_name);
+ } else {
+ g_debug ("Default input stream changed to unknown stream %s",
 info->default_source_name);
- }
+
+ g_object_set_data_full (G_OBJECT (pulse),
+ "backend-pending-source",
+ g_strdup (info->default_source_name),
+ g_free);
+
+ /* In most cases (for example changing profile) the stream info
+ * arrives by itself, but do not rely on it and request it explicitely.
+ * In the meantime, keep the default stream set to NULL, which is
+ * important as we cannot guarantee that the info arrives and we use it. */
+ pulse_connection_load_source_info_name (pulse->priv->connection,
+ info->default_source_name);
+ }
+ } else
+ g_debug ("Default input stream unset");
+
+ g_object_notify (G_OBJECT (pulse), "default-input");
 }
 
 if (pulse->priv->default_sink != NULL)
 name_sink = mate_mixer_stream_get_name (pulse->priv->default_sink);
 
- if (g_strcmp0 (name_sink, info->default_sink_name)) {
+ if (g_strcmp0 (name_sink, info->default_sink_name) != 0) {
 if (pulse->priv->default_sink != NULL)
 g_clear_object (&pulse->priv->default_sink);
 
 if (info->default_sink_name != NULL) {
- MateMixerStream *stream = g_hash_table_find (pulse->priv->sinks,
- backend_compare_stream_names,
+ MateMixerStream *stream = g_hash_table_find (pulse->priv->streams,
+ compare_stream_names,
 (gpointer) info->default_sink_name);
- if (G_LIKELY (stream != NULL)) {
+
+ /* It is possible that we are unaware of the default stream, either
+ * because the stream details have not arrived yet, or because we chose
+ * to ignore the stream.
+ * When this happens, remember the name of the stream and wait for the
+ * stream info callback. */
+ if (stream != NULL) {
 pulse->priv->default_sink = g_object_ref (stream);
+ g_object_set_data (G_OBJECT (pulse),
+ "backend-pending-sink",
+ NULL);
+
 g_debug ("Default output stream changed to %s", info->default_sink_name);
 
- g_object_notify (G_OBJECT (pulse), "default-output");
- } else
- g_debug ("Default output stream %s not yet known",
+ } else {
+ g_debug ("Default output stream changed to unknown stream %s",
 info->default_sink_name);
- }
+
+ g_object_set_data_full (G_OBJECT (pulse),
+ "backend-pending-sink",
+ g_strdup (info->default_sink_name),
+ g_free);
+
+ /* In most cases (for example changing profile) the stream info
+ * arrives by itself, but do not rely on it and request it explicitely.
+ * In the meantime, keep the default stream set to NULL, which is
+ * important as we cannot guarantee that the info arrives and we use it. */
+ pulse_connection_load_sink_info_name (pulse->priv->connection,
+ info->default_sink_name);
+ }
+ } else
+ g_debug ("Default output stream unset");
+
+ g_object_notify (G_OBJECT (pulse), "default-output");
 }
 
 if (pulse->priv->state != MATE_MIXER_STATE_READY)
@@ -693,401 +781,533 @@ backend_server_info_cb (PulseConnection *connection,
 }
 
 static void
-backend_card_info_cb (PulseConnection *connection,
- const pa_card_info *info,
- PulseBackend *pulse)
+on_connection_card_info (PulseConnection *connection,
+ const pa_card_info *info,
+ PulseBackend *pulse)
 {
- gpointer p;
 PulseDevice *device;
 
- p = g_hash_table_lookup (pulse->priv->devices, GINT_TO_POINTER (info->index));
- if (p == NULL) {
+ device = g_hash_table_lookup (pulse->priv->devices, GUINT_TO_POINTER (info->index));
+ if (device == NULL) {
 device = pulse_device_new (connection, info);
-
 if (G_UNLIKELY (device == NULL))
 return;
 
- g_hash_table_insert (pulse->priv->devices,
- GINT_TO_POINTER (info->index),
- device);
+ g_hash_table_insert (pulse->priv->devices, GUINT_TO_POINTER (info->index), device);
+
+ g_signal_emit_by_name (G_OBJECT (pulse),
+ "device-added",
+ mate_mixer_device_get_name (MATE_MIXER_DEVICE (device)));
 } else {
- device = PULSE_DEVICE (p);
 pulse_device_update (device, info);
- }
 
- if (pulse->priv->connected_once) {
 /* The object might be hanging if reconnecting is in progress, remove the
 * hanging flag to prevent it from being removed when connected */
- if (pulse->priv->state != MATE_MIXER_STATE_READY)
- g_object_steal_data (G_OBJECT (device), "hanging");
-
- g_signal_emit_by_name (G_OBJECT (pulse),
- (p == NULL)
- ? "device-added"
- : "device-changed",
- mate_mixer_device_get_name (MATE_MIXER_DEVICE (device)));
+ unmark_hanging (pulse, G_OBJECT (device));
 }
 }
 
 static void
-backend_card_removed_cb (PulseConnection *connection,
- guint index,
- PulseBackend *pulse)
+on_connection_card_removed (PulseConnection *connection,
+ guint index,
+ PulseBackend *pulse)
 {
- gpointer p;
+ PulseDevice *device;
 
- p = g_hash_table_lookup (pulse->priv->devices, GINT_TO_POINTER (index));
- if (G_UNLIKELY (p == NULL))
+ device = g_hash_table_lookup (pulse->priv->devices, GUINT_TO_POINTER (index));
+ if (G_UNLIKELY (device == NULL))
 return;
 
- backend_remove_device (pulse, PULSE_DEVICE (p));
+ remove_device (pulse, device);
 }
 
+/* PulseAudio uses 32-bit integers as indices for sinks, sink inputs, sources and
+ * source inputs, these indices are not unique among the different kinds of streams,
+ * but we want to keep all of them in a single hash table. Allow this by using 64-bit
+ * hash table keys, use the lower 32 bits for the PulseAudio index and some of the
+ * higher bits to indicate what kind of stream it is. */
+enum {
+ HASH_BIT_SINK = (1ULL << 63),
+ HASH_BIT_SINK_INPUT = (1ULL << 62),
+ HASH_BIT_SOURCE = (1ULL << 61),
+ HASH_BIT_SOURCE_OUTPUT = (1ULL << 60)
+};
+#define HASH_ID_SINK(idx) (((idx) & 0xffffffff) | HASH_BIT_SINK)
+#define HASH_ID_SINK_INPUT(idx) (((idx) & 0xffffffff) | HASH_BIT_SINK_INPUT)
+#define HASH_ID_SOURCE(idx) (((idx) & 0xffffffff) | HASH_BIT_SOURCE)
+#define HASH_ID_SOURCE_OUTPUT(idx) (((idx) & 0xffffffff) | HASH_BIT_SOURCE_OUTPUT)
+
 static void
-backend_sink_info_cb (PulseConnection *connection,
- const pa_sink_info *info,
- PulseBackend *pulse)
+on_connection_sink_info (PulseConnection *connection,
+ const pa_sink_info *info,
+ PulseBackend *pulse)
 {
 PulseDevice *device = NULL;
 PulseStream *stream;
- gpointer p = NULL;
+ gint64 index = HASH_ID_SINK (info->index);
 
 if (info->card != PA_INVALID_INDEX)
- p = g_hash_table_lookup (pulse->priv->devices, GINT_TO_POINTER (info->card));
- if (p)
- device = PULSE_DEVICE (p);
+ device = g_hash_table_lookup (pulse->priv->devices, GUINT_TO_POINTER (info->card));
 
- p = g_hash_table_lookup (pulse->priv->sinks, GINT_TO_POINTER (info->index));
- if (p == NULL) {
+ stream = g_hash_table_lookup (pulse->priv->streams, &index);
+ if (stream == NULL) {
 stream = pulse_sink_new (connection, info, device);
-
 if (G_UNLIKELY (stream == NULL))
 return;
 
- g_hash_table_insert (pulse->priv->sinks,
- GINT_TO_POINTER (info->index),
- stream);
+ g_hash_table_insert (pulse->priv->streams, g_memdup (&index, 8), stream);
+
+ g_signal_emit_by_name (G_OBJECT (pulse),
+ "stream-added",
+ mate_mixer_stream_get_name (MATE_MIXER_STREAM (stream)));
+
+ /* We might be waiting for this sink to set it as the default */
+ check_pending_sink (pulse, stream);
 } else {
- stream = PULSE_STREAM (p);
 pulse_sink_update (stream, info, device);
- }
 
- if (pulse->priv->connected_once) {
 /* The object might be hanging if reconnecting is in progress, remove the
 * hanging flag to prevent it from being removed when connected */
- if (pulse->priv->state != MATE_MIXER_STATE_READY)
- g_object_steal_data (G_OBJECT (stream), "hanging");
-
- g_signal_emit_by_name (G_OBJECT (pulse),
- (p == NULL)
- ? "stream-added"
- : "stream-changed",
- mate_mixer_stream_get_name (MATE_MIXER_STREAM (stream)));
+ unmark_hanging (pulse, G_OBJECT (stream));
 }
 }
 
 static void
-backend_sink_removed_cb (PulseConnection *connection,
- guint index,
- PulseBackend *pulse)
+on_connection_sink_removed (PulseConnection *connection,
+ guint idx,
+ PulseBackend *pulse)
 {
- gpointer p;
+ PulseStream *stream;
+ gint64 index = HASH_ID_SINK (idx);
 
- p = g_hash_table_lookup (pulse->priv->sinks, GINT_TO_POINTER (index));
- if (G_UNLIKELY (p == NULL))
+ stream = g_hash_table_lookup (pulse->priv->streams, &index);
+ if (G_UNLIKELY (stream == NULL))
 return;
 
- backend_remove_stream (pulse, pulse->priv->sinks, PULSE_STREAM (p));
+ remove_stream (pulse, stream);
 }
 
 static void
-backend_sink_input_info_cb (PulseConnection *connection,
- const pa_sink_input_info *info,
- PulseBackend *pulse)
+on_connection_sink_input_info (PulseConnection *connection,
+ const pa_sink_input_info *info,
+ PulseBackend *pulse)
 {
 PulseStream *stream;
- gpointer p;
- gpointer parent = NULL;
+ PulseStream *parent = NULL;
+ gint64 index;
+
+ if (G_LIKELY (info->sink != PA_INVALID_INDEX)) {
+ index = HASH_ID_SINK (info->sink);
 
- if (G_LIKELY (info->sink)) {
- parent = g_hash_table_lookup (pulse->priv->sinks, GINT_TO_POINTER (info->sink));
+ parent = g_hash_table_lookup (pulse->priv->streams, &index);
 if (G_UNLIKELY (parent == NULL))
 g_debug ("Unknown parent %d of PulseAudio sink input %s",
 info->sink,
 info->name);
 }
 
- p = g_hash_table_lookup (pulse->priv->sink_inputs, GINT_TO_POINTER (info->index));
- if (p == NULL) {
- stream = pulse_sink_input_new (connection, info, parent);
+ index = HASH_ID_SINK_INPUT (info->index);
 
+ stream = g_hash_table_lookup (pulse->priv->streams, &index);
+ if (stream == NULL) {
+ stream = pulse_sink_input_new (connection, info, parent);
 if (G_UNLIKELY (stream == NULL))
 return;
 
- g_hash_table_insert (pulse->priv->sink_inputs,
- GINT_TO_POINTER (info->index),
- stream);
+ g_hash_table_insert (pulse->priv->streams, g_memdup (&index, 8), stream);
+
+ g_signal_emit_by_name (G_OBJECT (pulse),
+ "stream-added",
+ mate_mixer_stream_get_name (MATE_MIXER_STREAM (stream)));
 } else {
- stream = PULSE_STREAM (p);
 pulse_sink_input_update (stream, info, parent);
- }
 
- if (pulse->priv->connected_once) {
 /* The object might be hanging if reconnecting is in progress, remove the
 * hanging flag to prevent it from being removed when connected */
- if (pulse->priv->state != MATE_MIXER_STATE_READY)
- g_object_steal_data (G_OBJECT (stream), "hanging");
-
- g_signal_emit_by_name (G_OBJECT (pulse),
- (p == NULL)
- ? "stream-added"
- : "stream-changed",
- mate_mixer_stream_get_name (MATE_MIXER_STREAM (stream)));
+ unmark_hanging (pulse, G_OBJECT (stream));
 }
 }
 
 static void
-backend_sink_input_removed_cb (PulseConnection *connection,
- guint index,
- PulseBackend *pulse)
+on_connection_sink_input_removed (PulseConnection *connection,
+ guint idx,
+ PulseBackend *pulse)
 {
- gpointer p;
+ PulseStream *stream;
+ gint64 index = HASH_ID_SINK_INPUT (idx);
 
- p = g_hash_table_lookup (pulse->priv->sink_inputs, GINT_TO_POINTER (index));
- if (G_UNLIKELY (p == NULL))
+ stream = g_hash_table_lookup (pulse->priv->streams, &index);
+ if (G_UNLIKELY (stream == NULL))
 return;
 
- backend_remove_stream (pulse, pulse->priv->sink_inputs, PULSE_STREAM (p));
+ remove_stream (pulse, stream);
 }
 
 static void
-backend_source_info_cb (PulseConnection *connection,
- const pa_source_info *info,
- PulseBackend *pulse)
+on_connection_source_info (PulseConnection *connection,
+ const pa_source_info *info,
+ PulseBackend *pulse)
 {
 PulseDevice *device = NULL;
 PulseStream *stream;
- gpointer p = NULL;
+ gint64 index = HASH_ID_SOURCE (info->index);
 
 /* Skip monitor streams */
 if (info->monitor_of_sink != PA_INVALID_INDEX)
 return;
 
 if (info->card != PA_INVALID_INDEX)
- p = g_hash_table_lookup (pulse->priv->devices, GINT_TO_POINTER (info->card));
- if (p)
- device = PULSE_DEVICE (p);
+ device = g_hash_table_lookup (pulse->priv->devices, GUINT_TO_POINTER (info->card));
 
- p = g_hash_table_lookup (pulse->priv->sources, GINT_TO_POINTER (info->index));
- if (p == NULL) {
+ stream = g_hash_table_lookup (pulse->priv->streams, &index);
+ if (stream == NULL) {
 stream = pulse_source_new (connection, info, device);
-
 if (G_UNLIKELY (stream == NULL))
 return;
 
- g_hash_table_insert (pulse->priv->sources,
- GINT_TO_POINTER (info->index),
- stream);
+ g_hash_table_insert (pulse->priv->streams, g_memdup (&index, 8), stream);
+
+ g_signal_emit_by_name (G_OBJECT (pulse),
+ "stream-added",
+ mate_mixer_stream_get_name (MATE_MIXER_STREAM (stream)));
+
+ /* We might be waiting for this source to set it as the default */
+ check_pending_source (pulse, stream);
 } else {
- stream = PULSE_STREAM (p);
 pulse_source_update (stream, info, device);
- }
 
- if (pulse->priv->connected_once) {
 /* The object might be hanging if reconnecting is in progress, remove the
 * hanging flag to prevent it from being removed when connected */
- if (pulse->priv->state != MATE_MIXER_STATE_READY)
- g_object_steal_data (G_OBJECT (stream), "hanging");
-
- g_signal_emit_by_name (G_OBJECT (pulse),
- (p == NULL)
- ? "stream-added"
- : "stream-changed",
- mate_mixer_stream_get_name (MATE_MIXER_STREAM (stream)));
+ unmark_hanging (pulse, G_OBJECT (stream));
 }
 }
 
 static void
-backend_source_removed_cb (PulseConnection *connection,
- guint index,
- PulseBackend *pulse)
+on_connection_source_removed (PulseConnection *connection,
+ guint idx,
+ PulseBackend *pulse)
 {
- gpointer p;
+ PulseStream *stream;
+ gint64 index = HASH_ID_SOURCE (idx);
 
- p = g_hash_table_lookup (pulse->priv->sources, GINT_TO_POINTER (index));
- if (G_UNLIKELY (p == NULL))
+ stream = g_hash_table_lookup (pulse->priv->streams, &index);
+ if (G_UNLIKELY (stream == NULL))
 return;
 
- backend_remove_stream (pulse, pulse->priv->sources, PULSE_STREAM (p));
+ remove_stream (pulse, stream);
 }
 
 static void
-backend_source_output_info_cb (PulseConnection *connection,
- const pa_source_output_info *info,
- PulseBackend *pulse)
+on_connection_source_output_info (PulseConnection *connection,
+ const pa_source_output_info *info,
+ PulseBackend *pulse)
 {
 PulseStream *stream;
- gpointer p;
- gpointer parent = NULL;
+ PulseStream *parent = NULL;
+ gint64 index;
 
- if (G_LIKELY (info->source)) {
- parent = g_hash_table_lookup (pulse->priv->sources, GINT_TO_POINTER (info->source));
+ if (G_LIKELY (info->source != PA_INVALID_INDEX)) {
+ index = HASH_ID_SOURCE (info->source);
 
- /* Probably a monitor source that we have skipped */
+ /* Most likely a monitor source that we have skipped */
+ parent = g_hash_table_lookup (pulse->priv->streams, &index);
 if (parent == NULL)
 return;
 }
 
- p = g_hash_table_lookup (pulse->priv->source_outputs, GINT_TO_POINTER (info->index));
- if (p == NULL) {
+ index = HASH_ID_SOURCE_OUTPUT (info->index);
+
+ stream = g_hash_table_lookup (pulse->priv->streams, &index);
+ if (stream == NULL) {
 stream = pulse_source_output_new (connection, info, parent);
 if (G_UNLIKELY (stream == NULL))
 return;
 
- g_hash_table_insert (pulse->priv->source_outputs,
- GINT_TO_POINTER (info->index),
- stream);
+ g_hash_table_insert (pulse->priv->streams, g_memdup (&index, 8), stream);
+
+ g_signal_emit_by_name (G_OBJECT (pulse),
+ "stream-added",
+ mate_mixer_stream_get_name (MATE_MIXER_STREAM (stream)));
 } else {
- stream = PULSE_STREAM (p);
 pulse_source_output_update (stream, info, parent);
- }
 
- if (pulse->priv->connected_once) {
 /* The object might be hanging if reconnecting is in progress, remove the
 * hanging flag to prevent it from being removed when connected */
- if (pulse->priv->state != MATE_MIXER_STATE_READY)
- g_object_steal_data (G_OBJECT (stream), "hanging");
+ unmark_hanging (pulse, G_OBJECT (stream));
+ }
+}
+
+static void
+on_connection_source_output_removed (PulseConnection *connection,
+ guint idx,
+ PulseBackend *pulse)
+{
+ PulseStream *stream;
+ gint64 index = HASH_ID_SOURCE_OUTPUT (idx);
+
+ stream = g_hash_table_lookup (pulse->priv->streams, &index);
+ if (G_UNLIKELY (stream == NULL))
+ return;
+
+ remove_stream (pulse, stream);
+}
+
+static void
+on_connection_ext_stream_info (PulseConnection *connection,
+ const pa_ext_stream_restore_info *info,
+ PulseBackend *pulse)
+{
+ PulseStream *stream;
+ PulseStream *parent = NULL;
+
+ if (G_LIKELY (info->device != NULL))
+ parent = g_hash_table_find (pulse->priv->streams, compare_stream_names,
+ (gpointer) info->device);
+
+ stream = g_hash_table_lookup (pulse->priv->ext_streams, info->name);
+ if (stream == NULL) {
+ stream = pulse_ext_stream_new (connection, info, parent);
+ if (G_UNLIKELY (stream == NULL))
+ return;
+
+ g_hash_table_insert (pulse->priv->ext_streams, g_strdup (info->name), stream);
 
 g_signal_emit_by_name (G_OBJECT (pulse),
- (p == NULL)
- ? "stream-added"
- : "stream-changed",
+ "cached-stream-added",
 mate_mixer_stream_get_name (MATE_MIXER_STREAM (stream)));
+ } else {
+ pulse_ext_stream_update (stream, info, parent);
+
+ /* The object might be hanging if ext-streams are being loaded, remove
+ * the hanging flag to prevent it from being removed */
+ unmark_hanging (pulse, G_OBJECT (stream));
 }
 }
 
 static void
-backend_source_output_removed_cb (PulseConnection *connection,
- guint index,
- PulseBackend *pulse)
+on_connection_ext_stream_loading (PulseConnection *connection, PulseBackend *pulse)
 {
- gpointer p;
+ mark_hanging_hash (pulse->priv->ext_streams);
+}
 
- p = g_hash_table_lookup (pulse->priv->source_outputs, GINT_TO_POINTER (index));
- if (G_UNLIKELY (p == NULL))
- return;
+static void
+on_connection_ext_stream_loaded (PulseConnection *connection, PulseBackend *pulse)
+{
+ GHashTableIter iter;
+ gpointer value;
+
+ g_hash_table_iter_init (&iter, pulse->priv->ext_streams);
 
- backend_remove_stream (pulse, pulse->priv->source_outputs, PULSE_STREAM (p));
+ while (g_hash_table_iter_next (&iter, NULL, &value) == TRUE) {
+ guint hanging =
+ GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (value), "backend-hanging"));
+
+ if (hanging == 1) {
+ gchar *name = g_strdup ((const gchar *) value);
+
+ g_hash_table_remove (pulse->priv->ext_streams, (gconstpointer) name);
+ g_signal_emit_by_name (G_OBJECT (pulse),
+ "cached-stream-removed",
+ name);
+ g_free (name);
+ }
+ }
 }
 
 static gboolean
-backend_try_reconnect (PulseBackend *pulse)
+connect_source_reconnect (PulseBackend *pulse)
 {
 /* When the connect call succeeds, return FALSE to remove the idle source
 * and wait for the connection state notifications, otherwise this function
 * will be called again */
- return !pulse_connection_connect (pulse->priv->connection, TRUE);
+ if (pulse_connection_connect (pulse->priv->connection, TRUE) == TRUE) {
+ connect_source_remove (pulse);
+ return FALSE;
+ }
+ return TRUE;
 }
 
 static void
-backend_remove_connect_source (PulseBackend *pulse)
+connect_source_remove (PulseBackend *pulse)
 {
 g_clear_pointer (&pulse->priv->connect_source, g_source_unref);
 }
 
 static void
-backend_mark_hanging (PulseBackend *pulse)
+check_pending_sink (PulseBackend *pulse, PulseStream *stream)
 {
- backend_mark_hanging_hash (pulse->priv->devices);
- backend_mark_hanging_hash (pulse->priv->sinks);
- backend_mark_hanging_hash (pulse->priv->sink_inputs);
- backend_mark_hanging_hash (pulse->priv->sources);
- backend_mark_hanging_hash (pulse->priv->source_outputs);
+ const gchar *pending;
+ const gchar *name;
+
+ /* See if the currently added sream matches the default input stream
+ * we are waiting for */
+ pending = g_object_get_data (G_OBJECT (pulse), "backend-pending-sink");
+ if (pending == NULL)
+ return;
+
+ name = mate_mixer_stream_get_name (MATE_MIXER_STREAM (stream));
+ if (g_strcmp0 (pending, name) != 0)
+ return;
+
+ pulse->priv->default_sink = g_object_ref (stream);
+ g_object_set_data (G_OBJECT (pulse),
+ "backend-pending-sink",
+ NULL);
+
+ g_debug ("Default output stream changed to pending stream %s", name);
+
+ g_object_notify (G_OBJECT (pulse), "default-output");
 }
 
 static void
-backend_mark_hanging_hash (GHashTable *hash)
+check_pending_source (PulseBackend *pulse, PulseStream *stream)
 {
- GHashTableIter iter;
- gpointer value;
+ const gchar *pending;
+ const gchar *name;
 
- g_hash_table_iter_init (&iter, hash);
+ /* See if the currently added sream matches the default input stream
+ * we are waiting for */
+ pending = g_object_get_data (G_OBJECT (pulse), "backend-pending-source");
+ if (pending == NULL)
+ return;
+
+ name = mate_mixer_stream_get_name (MATE_MIXER_STREAM (stream));
+ if (g_strcmp0 (pending, name) != 0)
+ return;
 
- while (g_hash_table_iter_next (&iter, NULL, &value))
- g_object_set_data (G_OBJECT (value), "hanging", GINT_TO_POINTER (1));
+ pulse->priv->default_source = g_object_ref (stream);
+ g_object_set_data (G_OBJECT (pulse),
+ "backend-pending-source",
+ NULL);
+
+ g_debug ("Default input stream changed to pending stream %s", name);
+
+ g_object_notify (G_OBJECT (pulse), "default-input");
+}
+
+static void
+mark_hanging (PulseBackend *pulse)
+{
+ /* Mark devices and streams as hanging, ext-streams are handled separately */
+ mark_hanging_hash (pulse->priv->devices);
+ mark_hanging_hash (pulse->priv->streams);
 }
 
 static void
-backend_remove_hanging (PulseBackend *pulse)
+mark_hanging_hash (GHashTable *hash)
 {
 GHashTableIter iter;
 gpointer value;
 
- g_hash_table_iter_init (&iter, pulse->priv->devices);
+ g_hash_table_iter_init (&iter, hash);
 
- while (g_hash_table_iter_next (&iter, NULL, &value))
- if (g_object_get_data (G_OBJECT (value), "hanging"))
- backend_remove_device (pulse, PULSE_DEVICE (value));
+ while (g_hash_table_iter_next (&iter, NULL, &value) == TRUE)
+ g_object_set_data (G_OBJECT (value), "backend-hanging", GUINT_TO_POINTER (1));
+}
+
+static void
+unmark_hanging (PulseBackend *pulse, GObject *object)
+{
+ if (pulse->priv->connected_once == FALSE)
+ return;
+ if (pulse->priv->state == MATE_MIXER_STATE_READY)
+ return;
 
- backend_remove_hanging_hash (pulse, pulse->priv->sinks);
- backend_remove_hanging_hash (pulse, pulse->priv->sink_inputs);
- backend_remove_hanging_hash (pulse, pulse->priv->sources);
- backend_remove_hanging_hash (pulse, pulse->priv->source_outputs);
+ g_object_steal_data (object, "backend-hanging");
 }
 
 static void
-backend_remove_hanging_hash (PulseBackend *pulse, GHashTable *hash)
+remove_hanging (PulseBackend *pulse)
 {
 GHashTableIter iter;
 gpointer value;
 
- g_hash_table_iter_init (&iter, hash);
+ g_hash_table_iter_init (&iter, pulse->priv->devices);
+
+ while (g_hash_table_iter_next (&iter, NULL, &value) == TRUE) {
+ guint hanging =
+ GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (value), "backend-hanging"));
 
- while (g_hash_table_iter_next (&iter, NULL, &value))
- if (g_object_get_data (G_OBJECT (value), "hanging"))
- backend_remove_stream (pulse, hash, PULSE_STREAM (value));
+ if (hanging == 1)
+ remove_device (pulse, PULSE_DEVICE (value));
+ }
+
+ g_hash_table_iter_init (&iter, pulse->priv->streams);
+
+ while (g_hash_table_iter_next (&iter, NULL, &value) == TRUE) {
+ guint hanging =
+ GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (value), "backend-hanging"));
+
+ if (hanging == 1)
+ remove_stream (pulse, PULSE_STREAM (value));
+ }
 }
 
 static void
-backend_remove_device (PulseBackend *pulse, PulseDevice *device)
+remove_device (PulseBackend *pulse, PulseDevice *device)
 {
 gchar *name;
 
 name = g_strdup (mate_mixer_device_get_name (MATE_MIXER_DEVICE (device)));
 
 g_hash_table_remove (pulse->priv->devices,
- GINT_TO_POINTER (pulse_device_get_index (device)));
+ GUINT_TO_POINTER (pulse_device_get_index (device)));
 
 g_signal_emit_by_name (G_OBJECT (pulse), "device-removed", name);
 g_free (name);
 }
 
 static void
-backend_remove_stream (PulseBackend *pulse, GHashTable *hash, PulseStream *stream)
+remove_stream (PulseBackend *pulse, PulseStream *stream)
 {
- gchar *name;
-
- /* Make sure we do not end up with invalid default streams, but this is
- * very unlikely to happen */
- if (G_UNLIKELY (MATE_MIXER_STREAM (stream) == pulse->priv->default_sink)) {
+ gchar *name;
+ guint32 idx;
+ gint64 index;
+ gboolean reload = FALSE;
+
+ /* The removed stream might be one of the default streams, this happens
+ * especially when switching profiles, after which PulseAudio removes the
+ * old streams and creates new ones with different names */
+ if (MATE_MIXER_STREAM (stream) == pulse->priv->default_sink) {
 g_clear_object (&pulse->priv->default_sink);
+
 g_object_notify (G_OBJECT (pulse), "default-output");
+ reload = TRUE;
 }
- else if (G_UNLIKELY (MATE_MIXER_STREAM (stream) == pulse->priv->default_source)) {
+ else if (MATE_MIXER_STREAM (stream) == pulse->priv->default_source) {
 g_clear_object (&pulse->priv->default_source);
+
 g_object_notify (G_OBJECT (pulse), "default-input");
+ reload = TRUE;
 }
 
+ idx = pulse_stream_get_index (stream);
+
+ if (PULSE_IS_SINK (stream))
+ index = HASH_ID_SINK (idx);
+ else if (PULSE_IS_SINK_INPUT (stream))
+ index = HASH_ID_SINK_INPUT (idx);
+ else if (PULSE_IS_SOURCE (stream))
+ index = HASH_ID_SOURCE (idx);
+ else
+ index = HASH_ID_SOURCE_OUTPUT (idx);
+
 name = g_strdup (mate_mixer_stream_get_name (MATE_MIXER_STREAM (stream)));
 
- g_hash_table_remove (hash, GINT_TO_POINTER (pulse_stream_get_index (stream)));
+ g_hash_table_remove (pulse->priv->streams, &index);
+
+ /* PulseAudio usually sends a server info update by itself when default
+ * stream changes, but there is at least one case when it does not - setting
+ * a card profile to off, so to be sure request an update explicitely */
+ if (reload == TRUE)
+ pulse_connection_load_server_info (pulse->priv->connection);
 
 g_signal_emit_by_name (G_OBJECT (pulse), "stream-removed", name);
 g_free (name);
 }
 
 static void
-backend_change_state (PulseBackend *backend, MateMixerState state)
+change_state (PulseBackend *backend, MateMixerState state)
 {
 if (backend->priv->state == state)
 return;
@@ -1098,21 +1318,21 @@ backend_change_state (PulseBackend *backend, MateMixerState state)
 }
 
 static gint
-backend_compare_devices (gconstpointer a, gconstpointer b)
+compare_devices (gconstpointer a, gconstpointer b)
 {
 return strcmp (mate_mixer_device_get_name (MATE_MIXER_DEVICE (a)),
 mate_mixer_device_get_name (MATE_MIXER_DEVICE (b)));
 }
 
 static gint
-backend_compare_streams (gconstpointer a, gconstpointer b)
+compare_streams (gconstpointer a, gconstpointer b)
 {
 return strcmp (mate_mixer_stream_get_name (MATE_MIXER_STREAM (a)),
 mate_mixer_stream_get_name (MATE_MIXER_STREAM (b)));
 }
 
 static gboolean
-backend_compare_stream_names (gpointer key, gpointer value, gpointer user_data)
+compare_stream_names (gpointer key, gpointer value, gpointer user_data)
 {
 MateMixerStream *stream = MATE_MIXER_STREAM (value);
 
diff --git a/backends/pulse/pulse-backend.h b/backends/pulse/pulse-backend.h
index 48fffc6..bd1face 100644
--- a/backends/pulse/pulse-backend.h
+++ b/backends/pulse/pulse-backend.h
@@ -21,7 +21,7 @@
 #include <glib.h>
 #include <glib-object.h>
 
-#include <libmatemixer/matemixer-backend.h>
+#include <libmatemixer/matemixer-backend-module.h>
 
 #define PULSE_TYPE_BACKEND \
 (pulse_backend_get_type ())
diff --git a/backends/pulse/pulse-client-stream.c b/backends/pulse/pulse-client-stream.c
index 8c9312a..d725146 100644
--- a/backends/pulse/pulse-client-stream.c
+++ b/backends/pulse/pulse-client-stream.c
@@ -15,11 +15,12 @@
 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <string.h>
 #include <glib.h>
 #include <glib-object.h>
-#include <string.h>
 
 #include <libmatemixer/matemixer-client-stream.h>
+#include <libmatemixer/matemixer-enums.h>
 #include <libmatemixer/matemixer-stream.h>
 
 #include <pulse/pulseaudio.h>
@@ -29,24 +30,33 @@
 
 struct _PulseClientStreamPrivate
 {
- gchar *app_name;
- gchar *app_id;
- gchar *app_version;
- gchar *app_icon;
- MateMixerStream *parent;
+ gchar *app_name;
+ gchar *app_id;
+ gchar *app_version;
+ gchar *app_icon;
+ MateMixerStream *parent;
+ MateMixerClientStreamFlags flags;
+ MateMixerClientStreamRole role;
 };
 
-enum
-{
+enum {
 PROP_0,
+ PROP_CLIENT_FLAGS,
+ PROP_ROLE,
 PROP_PARENT,
 PROP_APP_NAME,
 PROP_APP_ID,
 PROP_APP_VERSION,
- PROP_APP_ICON,
- N_PROPERTIES
+ PROP_APP_ICON
 };
 
+enum {
+ REMOVED,
+ N_SIGNALS
+};
+
+static guint signals[N_SIGNALS] = { 0, };
+
 static void mate_mixer_client_stream_interface_init (MateMixerClientStreamInterface *iface);
 
 static void pulse_client_stream_class_init (PulseClientStreamClass *klass);
@@ -64,26 +74,32 @@ G_DEFINE_ABSTRACT_TYPE_WITH_CODE (PulseClientStream, pulse_client_stream, PULSE_
 G_IMPLEMENT_INTERFACE (MATE_MIXER_TYPE_CLIENT_STREAM,
 mate_mixer_client_stream_interface_init))
 
-static MateMixerStream *client_stream_get_parent (MateMixerClientStream *client);
-static gboolean client_stream_set_parent (MateMixerClientStream *client,
- MateMixerStream *parent);
-static gboolean client_stream_remove (MateMixerClientStream *client);
+static MateMixerClientStreamFlags pulse_client_stream_get_flags (MateMixerClientStream *client);
+static MateMixerClientStreamRole pulse_client_stream_get_role (MateMixerClientStream *client);
+
+static MateMixerStream * pulse_client_stream_get_parent (MateMixerClientStream *client);
+static gboolean pulse_client_stream_set_parent (MateMixerClientStream *client,
+ MateMixerStream *parent);
 
-static const gchar * client_stream_get_app_name (MateMixerClientStream *client);
-static const gchar * client_stream_get_app_id (MateMixerClientStream *client);
-static const gchar * client_stream_get_app_version (MateMixerClientStream *client);
-static const gchar * client_stream_get_app_icon (MateMixerClientStream *client);
+static gboolean pulse_client_stream_remove (MateMixerClientStream *client);
+
+static const gchar * pulse_client_stream_get_app_name (MateMixerClientStream *client);
+static const gchar * pulse_client_stream_get_app_id (MateMixerClientStream *client);
+static const gchar * pulse_client_stream_get_app_version (MateMixerClientStream *client);
+static const gchar * pulse_client_stream_get_app_icon (MateMixerClientStream *client);
 
 static void
 mate_mixer_client_stream_interface_init (MateMixerClientStreamInterface *iface)
 {
- iface->get_parent = client_stream_get_parent;
- iface->set_parent = client_stream_set_parent;
- iface->remove = client_stream_remove;
- iface->get_app_name = client_stream_get_app_name;
- iface->get_app_id = client_stream_get_app_id;
- iface->get_app_version = client_stream_get_app_version;
- iface->get_app_icon = client_stream_get_app_icon;
+ iface->get_flags = pulse_client_stream_get_flags;
+ iface->get_role = pulse_client_stream_get_role;
+ iface->get_parent = pulse_client_stream_get_parent;
+ iface->set_parent = pulse_client_stream_set_parent;
+ iface->remove = pulse_client_stream_remove;
+ iface->get_app_name = pulse_client_stream_get_app_name;
+ iface->get_app_id = pulse_client_stream_get_app_id;
+ iface->get_app_version = pulse_client_stream_get_app_version;
+ iface->get_app_icon = pulse_client_stream_get_app_icon;
 }
 
 static void
@@ -96,6 +112,20 @@ pulse_client_stream_class_init (PulseClientStreamClass *klass)
 object_class->finalize = pulse_client_stream_finalize;
 object_class->get_property = pulse_client_stream_get_property;
 
+ signals[REMOVED] =
+ g_signal_new ("removed",
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (PulseClientStreamClass, removed),
+ NULL,
+ NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE,
+ 0,
+ G_TYPE_NONE);
+
+ g_object_class_override_property (object_class, PROP_CLIENT_FLAGS, "client-flags");
+ g_object_class_override_property (object_class, PROP_ROLE, "role");
 g_object_class_override_property (object_class, PROP_PARENT, "parent");
 g_object_class_override_property (object_class, PROP_APP_NAME, "app-name");
 g_object_class_override_property (object_class, PROP_APP_ID, "app-id");
@@ -116,6 +146,12 @@ pulse_client_stream_get_property (GObject *object,
 client = PULSE_CLIENT_STREAM (object);
 
 switch (param_id) {
+ case PROP_CLIENT_FLAGS:
+ g_value_set_flags (value, client->priv->flags);
+ break;
+ case PROP_ROLE:
+ g_value_set_enum (value, client->priv->role);
+ break;
 case PROP_PARENT:
 g_value_set_object (value, client->priv->parent);
 break;
@@ -173,79 +209,123 @@ pulse_client_stream_finalize (GObject *object)
 }
 
 gboolean
-pulse_client_stream_update_parent (PulseClientStream *client, MateMixerStream *parent)
+pulse_client_stream_update_flags (PulseClientStream *pclient,
+ MateMixerClientStreamFlags flags)
 {
- g_return_val_if_fail (PULSE_IS_CLIENT_STREAM (client), FALSE);
+ g_return_val_if_fail (PULSE_IS_CLIENT_STREAM (pclient), FALSE);
+
+ if (pclient->priv->flags != flags) {
+ pclient->priv->flags = flags;
+
+ g_object_notify (G_OBJECT (pclient), "client-flags");
+ }
+ return TRUE;
+}
 
- if (client->priv->parent != parent) {
- g_clear_object (&client->priv->parent);
+gboolean
+pulse_client_stream_update_parent (PulseClientStream *pclient, MateMixerStream *parent)
+{
+ g_return_val_if_fail (PULSE_IS_CLIENT_STREAM (pclient), FALSE);
+
+ if (pclient->priv->parent != parent) {
+ g_clear_object (&pclient->priv->parent);
 
 if (G_LIKELY (parent != NULL))
- client->priv->parent = g_object_ref (parent);
+ pclient->priv->parent = g_object_ref (parent);
 
- g_object_notify (G_OBJECT (client), "parent");
+ g_object_notify (G_OBJECT (pclient), "parent");
 }
 return TRUE;
 }
 
 gboolean
-pulse_client_stream_update_app_name (PulseClientStream *client, const gchar *app_name)
+pulse_client_stream_update_role (PulseClientStream *pclient,
+ MateMixerClientStreamRole role)
 {
- g_return_val_if_fail (PULSE_IS_CLIENT_STREAM (client), FALSE);
+ g_return_val_if_fail (PULSE_IS_CLIENT_STREAM (pclient), FALSE);
 
- if (g_strcmp0 (client->priv->app_name, app_name)) {
- g_free (client->priv->app_name);
- client->priv->app_name = g_strdup (app_name);
+ if (pclient->priv->role != role) {
+ pclient->priv->role = role;
 
- g_object_notify (G_OBJECT (client), "app-name");
+ g_object_notify (G_OBJECT (pclient), "role");
 }
 return TRUE;
 }
 
 gboolean
-pulse_client_stream_update_app_id (PulseClientStream *client, const gchar *app_id)
+pulse_client_stream_update_app_name (PulseClientStream *pclient, const gchar *app_name)
 {
- g_return_val_if_fail (PULSE_IS_CLIENT_STREAM (client), FALSE);
+ g_return_val_if_fail (PULSE_IS_CLIENT_STREAM (pclient), FALSE);
 
- if (g_strcmp0 (client->priv->app_id, app_id)) {
- g_free (client->priv->app_id);
- client->priv->app_id = g_strdup (app_id);
+ if (g_strcmp0 (pclient->priv->app_name, app_name) != 0) {
+ g_free (pclient->priv->app_name);
+ pclient->priv->app_name = g_strdup (app_name);
 
- g_object_notify (G_OBJECT (client), "app-id");
+ g_object_notify (G_OBJECT (pclient), "app-name");
 }
 return TRUE;
 }
 
 gboolean
-pulse_client_stream_update_app_version (PulseClientStream *client, const gchar *app_version)
+pulse_client_stream_update_app_id (PulseClientStream *pclient, const gchar *app_id)
 {
- g_return_val_if_fail (PULSE_IS_CLIENT_STREAM (client), FALSE);
+ g_return_val_if_fail (PULSE_IS_CLIENT_STREAM (pclient), FALSE);
 
- if (g_strcmp0 (client->priv->app_version, app_version)) {
- g_free (client->priv->app_version);
- client->priv->app_version = g_strdup (app_version);
+ if (g_strcmp0 (pclient->priv->app_id, app_id) != 0) {
+ g_free (pclient->priv->app_id);
+ pclient->priv->app_id = g_strdup (app_id);
 
- g_object_notify (G_OBJECT (client), "app-version");
+ g_object_notify (G_OBJECT (pclient), "app-id");
 }
 return TRUE;
 }
 
 gboolean
-pulse_client_stream_update_app_icon (PulseClientStream *client, const gchar *app_icon)
+pulse_client_stream_update_app_version (PulseClientStream *pclient, const gchar *app_version)
 {
- g_return_val_if_fail (PULSE_IS_CLIENT_STREAM (client), FALSE);
+ g_return_val_if_fail (PULSE_IS_CLIENT_STREAM (pclient), FALSE);
 
- if (g_strcmp0 (client->priv->app_icon, app_icon)) {
- g_free (client->priv->app_icon);
- client->priv->app_icon = g_strdup (app_icon);
+ if (g_strcmp0 (pclient->priv->app_version, app_version) != 0) {
+ g_free (pclient->priv->app_version);
+ pclient->priv->app_version = g_strdup (app_version);
 
- g_object_notify (G_OBJECT (client), "app-icon");
+ g_object_notify (G_OBJECT (pclient), "app-version");
 }
 return TRUE;
 }
 
+gboolean
+pulse_client_stream_update_app_icon (PulseClientStream *pclient, const gchar *app_icon)
+{
+ g_return_val_if_fail (PULSE_IS_CLIENT_STREAM (pclient), FALSE);
+
+ if (g_strcmp0 (pclient->priv->app_icon, app_icon) != 0) {
+ g_free (pclient->priv->app_icon);
+ pclient->priv->app_icon = g_strdup (app_icon);
+
+ g_object_notify (G_OBJECT (pclient), "app-icon");
+ }
+ return TRUE;
+}
+
+static MateMixerClientStreamFlags
+pulse_client_stream_get_flags (MateMixerClientStream *client)
+{
+ g_return_val_if_fail (PULSE_IS_CLIENT_STREAM (client), MATE_MIXER_CLIENT_STREAM_NO_FLAGS);
+
+ return PULSE_CLIENT_STREAM (client)->priv->flags;
+}
+
+static MateMixerClientStreamRole
+pulse_client_stream_get_role (MateMixerClientStream *client)
+{
+ g_return_val_if_fail (PULSE_IS_CLIENT_STREAM (client), MATE_MIXER_CLIENT_STREAM_ROLE_NONE);
+
+ return PULSE_CLIENT_STREAM (client)->priv->role;
+}
+
 static MateMixerStream *
-client_stream_get_parent (MateMixerClientStream *client)
+pulse_client_stream_get_parent (MateMixerClientStream *client)
 {
 g_return_val_if_fail (PULSE_IS_CLIENT_STREAM (client), NULL);
 
@@ -253,23 +333,58 @@ client_stream_get_parent (MateMixerClientStream *client)
 }
 
 static gboolean
-client_stream_set_parent (MateMixerClientStream *client, MateMixerStream *parent)
+pulse_client_stream_set_parent (MateMixerClientStream *client, MateMixerStream *parent)
 {
+ PulseClientStream *pclient;
+ PulseClientStreamClass *klass;
+
 g_return_val_if_fail (PULSE_IS_CLIENT_STREAM (client), FALSE);
+ g_return_val_if_fail (PULSE_IS_STREAM (parent), FALSE);
+
+ pclient = PULSE_CLIENT_STREAM (client);
+ klass = PULSE_CLIENT_STREAM_GET_CLASS (pclient);
+
+ if (pclient->priv->parent == parent)
+ return TRUE;
+
+ if (klass->set_parent (pclient, PULSE_STREAM (parent)) == FALSE)
+ return FALSE;
+
+ if (pclient->priv->parent != NULL)
+ g_object_unref (pclient->priv->parent);
+
+ /* It is allowed for the parent to be NULL when the instance is created, but
+ * changing the parent requires a valid parent stream */
+ pclient->priv->parent = g_object_ref (parent);
 
- return PULSE_CLIENT_STREAM_GET_CLASS (client)->set_parent (client, parent);
+ g_object_notify (G_OBJECT (client), "parent");
+ return TRUE;
 }
 
 static gboolean
-client_stream_remove (MateMixerClientStream *client)
+pulse_client_stream_remove (MateMixerClientStream *client)
 {
+ PulseClientStream *pclient;
+ PulseClientStreamClass *klass;
+
 g_return_val_if_fail (PULSE_IS_CLIENT_STREAM (client), FALSE);
 
- return PULSE_CLIENT_STREAM_GET_CLASS (client)->remove (client);
+ pclient = PULSE_CLIENT_STREAM (client);
+ klass = PULSE_CLIENT_STREAM_GET_CLASS (pclient);
+
+ if (klass->remove (pclient) == FALSE)
+ return FALSE;
+
+ // XXX handle this in the backend
+ g_signal_emit (G_OBJECT (client),
+ signals[REMOVED],
+ 0);
+
+ return TRUE;
 }
 
 static const gchar *
-client_stream_get_app_name (MateMixerClientStream *client)
+pulse_client_stream_get_app_name (MateMixerClientStream *client)
 {
 g_return_val_if_fail (PULSE_IS_CLIENT_STREAM (client), NULL);
 
@@ -277,7 +392,7 @@ client_stream_get_app_name (MateMixerClientStream *client)
 }
 
 static const gchar *
-client_stream_get_app_id (MateMixerClientStream *client)
+pulse_client_stream_get_app_id (MateMixerClientStream *client)
 {
 g_return_val_if_fail (PULSE_IS_CLIENT_STREAM (client), NULL);
 
@@ -285,7 +400,7 @@ client_stream_get_app_id (MateMixerClientStream *client)
 }
 
 static const gchar *
-client_stream_get_app_version (MateMixerClientStream *client)
+pulse_client_stream_get_app_version (MateMixerClientStream *client)
 {
 g_return_val_if_fail (PULSE_IS_CLIENT_STREAM (client), NULL);
 
@@ -293,7 +408,7 @@ client_stream_get_app_version (MateMixerClientStream *client)
 }
 
 static const gchar *
-client_stream_get_app_icon (MateMixerClientStream *client)
+pulse_client_stream_get_app_icon (MateMixerClientStream *client)
 {
 g_return_val_if_fail (PULSE_IS_CLIENT_STREAM (client), NULL);
 
diff --git a/backends/pulse/pulse-client-stream.h b/backends/pulse/pulse-client-stream.h
index 61e9c4d..fe24dc3 100644
--- a/backends/pulse/pulse-client-stream.h
+++ b/backends/pulse/pulse-client-stream.h
@@ -22,6 +22,7 @@
 #include <glib-object.h>
 
 #include <libmatemixer/matemixer-client-stream.h>
+#include <libmatemixer/matemixer-enums.h>
 #include <libmatemixer/matemixer-stream.h>
 
 #include "pulse-stream.h"
@@ -57,24 +58,36 @@ struct _PulseClientStreamClass
 {
 PulseStreamClass parent_class;
 
- gboolean (*set_parent) (MateMixerClientStream *client,
- MateMixerStream *stream);
- gboolean (*remove) (MateMixerClientStream *client);
+ /*< private >*/
+ /* Virtual table */
+ gboolean (*set_parent) (PulseClientStream *pclient,
+ PulseStream *pstream);
+
+ gboolean (*remove) (PulseClientStream *pclient);
+
+ /* Signals */
+ void (*removed) (PulseClientStream *pclient);
 };
 
 GType pulse_client_stream_get_type (void) G_GNUC_CONST;
 
-gboolean pulse_client_stream_update_parent (PulseClientStream *client,
- MateMixerStream *parent);
-
-gboolean pulse_client_stream_update_app_name (PulseClientStream *client,
- const gchar *app_name);
-gboolean pulse_client_stream_update_app_id (PulseClientStream *client,
- const gchar *app_id);
-gboolean pulse_client_stream_update_app_version (PulseClientStream *client,
- const gchar *app_version);
-gboolean pulse_client_stream_update_app_icon (PulseClientStream *client,
- const gchar *app_icon);
+gboolean pulse_client_stream_update_flags (PulseClientStream *pclient,
+ MateMixerClientStreamFlags flags);
+
+gboolean pulse_client_stream_update_role (PulseClientStream *pclient,
+ MateMixerClientStreamRole role);
+
+gboolean pulse_client_stream_update_parent (PulseClientStream *pclient,
+ MateMixerStream *parent);
+
+gboolean pulse_client_stream_update_app_name (PulseClientStream *pclient,
+ const gchar *app_name);
+gboolean pulse_client_stream_update_app_id (PulseClientStream *pclient,
+ const gchar *app_id);
+gboolean pulse_client_stream_update_app_version (PulseClientStream *pclient,
+ const gchar *app_version);
+gboolean pulse_client_stream_update_app_icon (PulseClientStream *pclient,
+ const gchar *app_icon);
 
 G_END_DECLS
 
diff --git a/backends/pulse/pulse-connection.c b/backends/pulse/pulse-connection.c
index 9002f09..cc39caf 100644
--- a/backends/pulse/pulse-connection.c
+++ b/backends/pulse/pulse-connection.c
@@ -15,13 +15,14 @@
 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <unistd.h>
+#include <sys/types.h>
 #include <glib.h>
 #include <glib-object.h>
-#include <sys/types.h>
-#include <unistd.h>
 
 #include <pulse/pulseaudio.h>
 #include <pulse/glib-mainloop.h>
+#include <pulse/ext-stream-restore.h>
 
 #include "pulse-connection.h"
 #include "pulse-enums.h"
@@ -35,6 +36,8 @@ struct _PulseConnectionPrivate
 pa_context *context;
 pa_proplist *proplist;
 pa_glib_mainloop *mainloop;
+ gboolean ext_streams_loading;
+ gboolean ext_streams_dirty;
 PulseConnectionState state;
 };
 
@@ -59,6 +62,9 @@ enum {
 SINK_INPUT_REMOVED,
 SOURCE_OUTPUT_INFO,
 SOURCE_OUTPUT_REMOVED,
+ EXT_STREAM_LOADING,
+ EXT_STREAM_LOADED,
+ EXT_STREAM_INFO,
 N_SIGNALS
 };
 
@@ -80,47 +86,53 @@ static void pulse_connection_finalize (GObject *object);
 
 G_DEFINE_TYPE (PulseConnection, pulse_connection, G_TYPE_OBJECT);
 
-static gchar *connection_get_app_name (void);
-
-static gboolean connection_load_lists (PulseConnection *connection);
-
-static void connection_state_cb (pa_context *c,
- void *userdata);
-static void connection_subscribe_cb (pa_context *c,
- pa_subscription_event_type_t t,
- uint32_t idx,
- void *userdata);
-static void connection_server_info_cb (pa_context *c,
- const pa_server_info *info,
- void *userdata);
-static void connection_card_info_cb (pa_context *c,
- const pa_card_info *info,
- int eol,
- void *userdata);
-static void connection_sink_info_cb (pa_context *c,
- const pa_sink_info *info,
- int eol,
- void *userdata);
-static void connection_source_info_cb (pa_context *c,
- const pa_source_info *info,
- int eol,
- void *userdata);
-static void connection_sink_input_info_cb (pa_context *c,
- const pa_sink_input_info *info,
- int eol,
- void *userdata);
-static void connection_source_output_info_cb (pa_context *c,
- const pa_source_output_info *info,
- int eol,
- void *userdata);
-
-static void connection_change_state (PulseConnection *connection,
- PulseConnectionState state);
-
-static void connection_list_loaded (PulseConnection *connection);
-
-static gboolean connection_process_operation (PulseConnection *connection,
- pa_operation *op);
+static gchar *create_app_name (void);
+
+static gboolean load_lists (PulseConnection *connection);
+static gboolean load_list_finished (PulseConnection *connection);
+
+static void pulse_state_cb (pa_context *c,
+ void *userdata);
+static void pulse_subscribe_cb (pa_context *c,
+ pa_subscription_event_type_t t,
+ uint32_t idx,
+ void *userdata);
+
+static void pulse_restore_subscribe_cb (pa_context *c,
+ void *userdata);
+static void pulse_server_info_cb (pa_context *c,
+ const pa_server_info *info,
+ void *userdata);
+static void pulse_card_info_cb (pa_context *c,
+ const pa_card_info *info,
+ int eol,
+ void *userdata);
+static void pulse_sink_info_cb (pa_context *c,
+ const pa_sink_info *info,
+ int eol,
+ void *userdata);
+static void pulse_source_info_cb (pa_context *c,
+ const pa_source_info *info,
+ int eol,
+ void *userdata);
+static void pulse_sink_input_info_cb (pa_context *c,
+ const pa_sink_input_info *info,
+ int eol,
+ void *userdata);
+static void pulse_source_output_info_cb (pa_context *c,
+ const pa_source_output_info *info,
+ int eol,
+ void *userdata);
+static void pulse_ext_stream_restore_cb (pa_context *c,
+ const pa_ext_stream_restore_info *info,
+ int eol,
+ void *userdata);
+
+static void change_state (PulseConnection *connection,
+ PulseConnectionState state);
+
+static gboolean process_pulse_operation (PulseConnection *connection,
+ pa_operation *op);
 
 static void
 pulse_connection_class_init (PulseConnectionClass *klass)
@@ -150,6 +162,8 @@ pulse_connection_class_init (PulseConnectionClass *klass)
 G_PARAM_READABLE |
 G_PARAM_STATIC_STRINGS);
 
+ g_object_class_install_properties (object_class, N_PROPERTIES, properties);
+
 signals[SERVER_INFO] =
 g_signal_new ("server-info",
 G_TYPE_FROM_CLASS (object_class),
@@ -282,7 +296,41 @@ pulse_connection_class_init (PulseConnectionClass *klass)
 1,
 G_TYPE_UINT);
 
- g_object_class_install_properties (object_class, N_PROPERTIES, properties);
+ signals[EXT_STREAM_LOADING] =
+ g_signal_new ("ext-stream-loading",
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (PulseConnectionClass, ext_stream_loading),
+ NULL,
+ NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE,
+ 0,
+ G_TYPE_NONE);
+
+ signals[EXT_STREAM_LOADED] =
+ g_signal_new ("ext-stream-loaded",
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (PulseConnectionClass, ext_stream_loaded),
+ NULL,
+ NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE,
+ 0,
+ G_TYPE_NONE);
+
+ signals[EXT_STREAM_INFO] =
+ g_signal_new ("ext-stream-info",
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (PulseConnectionClass, ext_stream_info),
+ NULL,
+ NULL,
+ g_cclosure_marshal_VOID__POINTER,
+ G_TYPE_NONE,
+ 1,
+ G_TYPE_POINTER);
 
 g_type_class_add_private (object_class, sizeof (PulseConnectionPrivate));
 }
@@ -382,7 +430,7 @@ pulse_connection_new (const gchar *app_name,
 pa_proplist_sets (proplist, PA_PROP_APPLICATION_NAME, app_name);
 } else {
 /* Set a sensible default name when application does not provide one */
- gchar *name = connection_get_app_name ();
+ gchar *name = create_app_name ();
 
 pa_proplist_sets (proplist, PA_PROP_APPLICATION_NAME, name);
 g_free (name);
@@ -427,9 +475,9 @@ pulse_connection_connect (PulseConnection *connection, gboolean wait_for_daemon)
 
 /* Set function to monitor status changes */
 pa_context_set_state_callback (context,
- connection_state_cb,
+ pulse_state_cb,
 connection);
- if (wait_for_daemon)
+ if (wait_for_daemon == TRUE)
 flags = PA_CONTEXT_NOFAIL;
 
 /* Initiate a connection, state changes will be delivered asynchronously */
@@ -438,7 +486,7 @@ pulse_connection_connect (PulseConnection *connection, gboolean wait_for_daemon)
 flags,
 NULL) == 0) {
 connection->priv->context = context;
- connection_change_state (connection, PULSE_CONNECTION_CONNECTING);
+ change_state (connection, PULSE_CONNECTION_CONNECTING);
 return TRUE;
 }
 
@@ -458,8 +506,10 @@ pulse_connection_disconnect (PulseConnection *connection)
 
 connection->priv->context = NULL;
 connection->priv->outstanding = 0;
+ connection->priv->ext_streams_loading = FALSE;
+ connection->priv->ext_streams_dirty = FALSE;
 
- connection_change_state (connection, PULSE_CONNECTION_DISCONNECTED);
+ change_state (connection, PULSE_CONNECTION_DISCONNECTED);
 }
 
 PulseConnectionState
@@ -470,6 +520,248 @@ pulse_connection_get_state (PulseConnection *connection)
 return connection->priv->state;
 }
 
+gboolean
+pulse_connection_load_server_info (PulseConnection *connection)
+{
+ pa_operation *op;
+
+ g_return_val_if_fail (PULSE_IS_CONNECTION (connection), FALSE);
+
+ if (connection->priv->state != PULSE_CONNECTION_LOADING &&
+ connection->priv->state != PULSE_CONNECTION_CONNECTED)
+ return FALSE;
+
+ op = pa_context_get_server_info (connection->priv->context,
+ pulse_server_info_cb,
+ connection);
+
+ return process_pulse_operation (connection, op);
+}
+
+gboolean
+pulse_connection_load_card_info (PulseConnection *connection, guint32 index)
+{
+ pa_operation *op;
+
+ g_return_val_if_fail (PULSE_IS_CONNECTION (connection), FALSE);
+
+ if (connection->priv->state != PULSE_CONNECTION_LOADING &&
+ connection->priv->state != PULSE_CONNECTION_CONNECTED)
+ return FALSE;
+
+ if (index == PA_INVALID_INDEX)
+ op = pa_context_get_card_info_by_index (connection->priv->context,
+ index,
+ pulse_card_info_cb,
+ connection);
+ else
+ op = pa_context_get_card_info_list (connection->priv->context,
+ pulse_card_info_cb,
+ connection);
+
+ return process_pulse_operation (connection, op);
+}
+
+gboolean
+pulse_connection_load_card_info_name (PulseConnection *connection, const gchar *name)
+{
+ pa_operation *op;
+
+ g_return_val_if_fail (PULSE_IS_CONNECTION (connection), FALSE);
+ g_return_val_if_fail (name != NULL, FALSE);
+
+ if (connection->priv->state != PULSE_CONNECTION_LOADING &&
+ connection->priv->state != PULSE_CONNECTION_CONNECTED)
+ return FALSE;
+
+ op = pa_context_get_card_info_by_name (connection->priv->context,
+ name,
+ pulse_card_info_cb,
+ connection);
+
+ return process_pulse_operation (connection, op);
+}
+
+gboolean
+pulse_connection_load_sink_info (PulseConnection *connection, guint32 index)
+{
+ pa_operation *op;
+
+ g_return_val_if_fail (PULSE_IS_CONNECTION (connection), FALSE);
+
+ if (connection->priv->state != PULSE_CONNECTION_LOADING &&
+ connection->priv->state != PULSE_CONNECTION_CONNECTED)
+ return FALSE;
+
+ if (index == PA_INVALID_INDEX)
+ op = pa_context_get_sink_info_by_index (connection->priv->context,
+ index,
+ pulse_sink_info_cb,
+ connection);
+ else
+ op = pa_context_get_sink_info_list (connection->priv->context,
+ pulse_sink_info_cb,
+ connection);
+
+ return process_pulse_operation (connection, op);
+}
+
+gboolean
+pulse_connection_load_sink_info_name (PulseConnection *connection, const gchar *name)
+{
+ pa_operation *op;
+
+ g_return_val_if_fail (PULSE_IS_CONNECTION (connection), FALSE);
+ g_return_val_if_fail (name != NULL, FALSE);
+
+ if (connection->priv->state != PULSE_CONNECTION_LOADING &&
+ connection->priv->state != PULSE_CONNECTION_CONNECTED)
+ return FALSE;
+
+ op = pa_context_get_sink_info_by_name (connection->priv->context,
+ name,
+ pulse_sink_info_cb,
+ connection);
+
+ return process_pulse_operation (connection, op);
+}
+
+gboolean
+pulse_connection_load_sink_input_info (PulseConnection *connection, guint32 index)
+{
+ pa_operation *op;
+
+ g_return_val_if_fail (PULSE_IS_CONNECTION (connection), FALSE);
+
+ if (connection->priv->state != PULSE_CONNECTION_LOADING &&
+ connection->priv->state != PULSE_CONNECTION_CONNECTED)
+ return FALSE;
+
+ if (index == PA_INVALID_INDEX)
+ op = pa_context_get_sink_input_info (connection->priv->context,
+ index,
+ pulse_sink_input_info_cb,
+ connection);
+ else
+ op = pa_context_get_sink_input_info_list (connection->priv->context,
+ pulse_sink_input_info_cb,
+ connection);
+
+ return process_pulse_operation (connection, op);
+}
+
+gboolean
+pulse_connection_load_source_info (PulseConnection *connection, guint32 index)
+{
+ pa_operation *op;
+
+ g_return_val_if_fail (PULSE_IS_CONNECTION (connection), FALSE);
+
+ if (connection->priv->state != PULSE_CONNECTION_LOADING &&
+ connection->priv->state != PULSE_CONNECTION_CONNECTED)
+ return FALSE;
+
+ if (index == PA_INVALID_INDEX)
+ op = pa_context_get_source_info_by_index (connection->priv->context,
+ index,
+ pulse_source_info_cb,
+ connection);
+ else
+ op = pa_context_get_source_info_list (connection->priv->context,
+ pulse_source_info_cb,
+ connection);
+
+ return process_pulse_operation (connection, op);
+}
+
+gboolean
+pulse_connection_load_source_info_name (PulseConnection *connection, const gchar *name)
+{
+ pa_operation *op;
+
+ g_return_val_if_fail (PULSE_IS_CONNECTION (connection), FALSE);
+ g_return_val_if_fail (name != NULL, FALSE);
+
+ if (connection->priv->state != PULSE_CONNECTION_LOADING &&
+ connection->priv->state != PULSE_CONNECTION_CONNECTED)
+ return FALSE;
+
+ op = pa_context_get_source_info_by_name (connection->priv->context,
+ name,
+ pulse_source_info_cb,
+ connection);
+
+ return process_pulse_operation (connection, op);
+}
+
+gboolean
+pulse_connection_load_source_output_info (PulseConnection *connection, guint32 index)
+{
+ pa_operation *op;
+
+ g_return_val_if_fail (PULSE_IS_CONNECTION (connection), FALSE);
+
+ if (connection->priv->state != PULSE_CONNECTION_LOADING &&
+ connection->priv->state != PULSE_CONNECTION_CONNECTED)
+ return FALSE;
+
+ if (index == PA_INVALID_INDEX)
+ op = pa_context_get_source_output_info (connection->priv->context,
+ index,
+ pulse_source_output_info_cb,
+ connection);
+ else
+ op = pa_context_get_source_output_info_list (connection->priv->context,
+ pulse_source_output_info_cb,
+ connection);
+
+ return process_pulse_operation (connection, op);
+}
+
+gboolean
+pulse_connection_load_ext_stream_info (PulseConnection *connection)
+{
+ pa_operation *op;
+
+ g_return_val_if_fail (PULSE_IS_CONNECTION (connection), FALSE);
+
+ if (connection->priv->state != PULSE_CONNECTION_LOADING &&
+ connection->priv->state != PULSE_CONNECTION_CONNECTED)
+ return FALSE;
+
+ /* When we receive a request to load the list of ext-streams, see if
+ * loading is already in progress and if it is, wait until the current
+ * loading finishes.
+ * The PulseBackend class relies on this behaviour to ensure it always
+ * contains a correct list of ext-streams, also PulseAudio always sends
+ * a list of all streams in the database and these requests may arrive
+ * very often, so this also optimizaes the amount of traffic. */
+ if (connection->priv->ext_streams_loading == TRUE) {
+ connection->priv->ext_streams_dirty = TRUE;
+ return TRUE;
+ }
+
+ connection->priv->ext_streams_dirty = FALSE;
+ connection->priv->ext_streams_loading = TRUE;
+ g_signal_emit (G_OBJECT (connection),
+ signals[EXT_STREAM_LOADING],
+ 0);
+
+ op = pa_ext_stream_restore_read (connection->priv->context,
+ pulse_ext_stream_restore_cb,
+ connection);
+
+ if (process_pulse_operation (connection, op) == FALSE) {
+ connection->priv->ext_streams_loading = FALSE;
+
+ g_signal_emit (G_OBJECT (connection),
+ signals[EXT_STREAM_LOADED],
+ 0);
+ return FALSE;
+ }
+ return TRUE;
+}
+
 PulseMonitor *
 pulse_connection_create_monitor (PulseConnection *connection,
 guint32 index_source,
@@ -482,13 +774,11 @@ pulse_connection_create_monitor (PulseConnection *connection,
 
 return pulse_monitor_new (connection->priv->context,
 connection->priv->proplist,
+ NULL,
 index_source,
 index_sink_input);
 }
 
-// XXX watch for some operation failures and eventually reload data
-// to restore the previous state
-
 gboolean
 pulse_connection_set_default_sink (PulseConnection *connection,
 const gchar *name)
@@ -504,7 +794,7 @@ pulse_connection_set_default_sink (PulseConnection *connection,
 name,
 NULL, NULL);
 
- return connection_process_operation (connection, op);
+ return process_pulse_operation (connection, op);
 }
 
 gboolean
@@ -522,7 +812,7 @@ pulse_connection_set_default_source (PulseConnection *connection,
 name,
 NULL, NULL);
 
- return connection_process_operation (connection, op);
+ return process_pulse_operation (connection, op);
 }
 
 gboolean
@@ -542,7 +832,7 @@ pulse_connection_set_card_profile (PulseConnection *connection,
 profile,
 NULL, NULL);
 
- return connection_process_operation (connection, op);
+ return process_pulse_operation (connection, op);
 }
 
 gboolean
@@ -562,7 +852,7 @@ pulse_connection_set_sink_mute (PulseConnection *connection,
 (int) mute,
 NULL, NULL);
 
- return connection_process_operation (connection, op);
+ return process_pulse_operation (connection, op);
 }
 
 gboolean
@@ -582,7 +872,7 @@ pulse_connection_set_sink_volume (PulseConnection *connection,
 volume,
 NULL, NULL);
 
- return connection_process_operation (connection, op);
+ return process_pulse_operation (connection, op);
 }
 
 gboolean
@@ -602,7 +892,7 @@ pulse_connection_set_sink_port (PulseConnection *connection,
 port,
 NULL, NULL);
 
- return connection_process_operation (connection, op);
+ return process_pulse_operation (connection, op);
 }
 
 gboolean
@@ -622,7 +912,7 @@ pulse_connection_set_sink_input_mute (PulseConnection *connection,
 (int) mute,
 NULL, NULL);
 
- return connection_process_operation (connection, op);
+ return process_pulse_operation (connection, op);
 }
 
 gboolean
@@ -642,7 +932,7 @@ pulse_connection_set_sink_input_volume (PulseConnection *connection,
 volume,
 NULL, NULL);
 
- return connection_process_operation (connection, op);
+ return process_pulse_operation (connection, op);
 }
 
 gboolean
@@ -662,7 +952,7 @@ pulse_connection_set_source_mute (PulseConnection *connection,
 (int) mute,
 NULL, NULL);
 
- return connection_process_operation (connection, op);
+ return process_pulse_operation (connection, op);
 }
 
 gboolean
@@ -682,7 +972,7 @@ pulse_connection_set_source_volume (PulseConnection *connection,
 volume,
 NULL, NULL);
 
- return connection_process_operation (connection, op);
+ return process_pulse_operation (connection, op);
 }
 
 gboolean
@@ -702,7 +992,7 @@ pulse_connection_set_source_port (PulseConnection *connection,
 port,
 NULL, NULL);
 
- return connection_process_operation (connection, op);
+ return process_pulse_operation (connection, op);
 }
 
 gboolean
@@ -723,7 +1013,7 @@ pulse_connection_set_source_output_mute (PulseConnection *connection,
 (int) mute,
 NULL, NULL);
 
- return connection_process_operation (connection, op);
+ return process_pulse_operation (connection, op);
 #else
 return FALSE;
 #endif
@@ -747,7 +1037,7 @@ pulse_connection_set_source_output_volume (PulseConnection *connection,
 volume,
 NULL, NULL);
 
- return connection_process_operation (connection, op);
+ return process_pulse_operation (connection, op);
 #else
 return FALSE;
 #endif
@@ -770,7 +1060,7 @@ pulse_connection_suspend_sink (PulseConnection *connection,
 (int) suspend,
 NULL, NULL);
 
- return connection_process_operation (connection, op);
+ return process_pulse_operation (connection, op);
 }
 
 gboolean
@@ -790,7 +1080,7 @@ pulse_connection_suspend_source (PulseConnection *connection,
 (int) suspend,
 NULL, NULL);
 
- return connection_process_operation (connection, op);
+ return process_pulse_operation (connection, op);
 }
 
 gboolean
@@ -810,7 +1100,7 @@ pulse_connection_move_sink_input (PulseConnection *connection,
 sink_index,
 NULL, NULL);
 
- return connection_process_operation (connection, op);
+ return process_pulse_operation (connection, op);
 }
 
 gboolean
@@ -830,7 +1120,7 @@ pulse_connection_move_source_output (PulseConnection *connection,
 source_index,
 NULL, NULL);
 
- return connection_process_operation (connection, op);
+ return process_pulse_operation (connection, op);
 }
 
 gboolean
@@ -848,7 +1138,7 @@ pulse_connection_kill_sink_input (PulseConnection *connection,
 index,
 NULL, NULL);
 
- return connection_process_operation (connection, op);
+ return process_pulse_operation (connection, op);
 }
 
 gboolean
@@ -866,14 +1156,59 @@ pulse_connection_kill_source_output (PulseConnection *connection,
 index,
 NULL, NULL);
 
- return connection_process_operation (connection, op);
+ return process_pulse_operation (connection, op);
+}
+
+gboolean
+pulse_connection_write_ext_stream (PulseConnection *connection,
+ const pa_ext_stream_restore_info *info)
+{
+ pa_operation *op;
+
+ g_return_val_if_fail (PULSE_IS_CONNECTION (connection), FALSE);
+
+ if (connection->priv->state != PULSE_CONNECTION_CONNECTED)
+ return FALSE;
+
+ op = pa_ext_stream_restore_write (connection->priv->context,
+ PA_UPDATE_REPLACE,
+ info, 1,
+ TRUE,
+ NULL, NULL);
+
+ return process_pulse_operation (connection, op);
+}
+
+gboolean
+pulse_connection_delete_ext_stream (PulseConnection *connection,
+ const gchar *name)
+{
+ pa_operation *op;
+ gchar **names;
+
+ g_return_val_if_fail (PULSE_IS_CONNECTION (connection), FALSE);
+
+ if (connection->priv->state != PULSE_CONNECTION_CONNECTED)
+ return FALSE;
+
+ names = g_new (gchar *, 2);
+ names[0] = (gchar *) name;
+ names[1] = NULL;
+
+ op = pa_ext_stream_restore_delete (connection->priv->context,
+ (const char * const *) names,
+ NULL, NULL);
+
+ g_strfreev (names);
+
+ return process_pulse_operation (connection, op);
 }
 
 static gchar *
-connection_get_app_name (void)
+create_app_name (void)
 {
- const char *name_app;
- char name_buf[256];
+ const gchar *name_app;
+ char name_buf[256];
 
 /* Inspired by GStreamer's pulse plugin */
 name_app = g_get_application_name ();
@@ -887,9 +1222,9 @@ connection_get_app_name (void)
 }
 
 static gboolean
-connection_load_lists (PulseConnection *connection)
+load_lists (PulseConnection *connection)
 {
- GList *ops = NULL;
+ GSList *ops = NULL;
 pa_operation *op;
 
 if (G_UNLIKELY (connection->priv->outstanding > 0)) {
@@ -898,60 +1233,95 @@ connection_load_lists (PulseConnection *connection)
 }
 
 op = pa_context_get_card_info_list (connection->priv->context,
- connection_card_info_cb,
+ pulse_card_info_cb,
 connection);
 if (G_UNLIKELY (op == NULL))
 goto error;
 
- ops = g_list_prepend (ops, op);
+ ops = g_slist_prepend (ops, op);
 
 op = pa_context_get_sink_info_list (connection->priv->context,
- connection_sink_info_cb,
+ pulse_sink_info_cb,
 connection);
 if (G_UNLIKELY (op == NULL))
 goto error;
 
- ops = g_list_prepend (ops, op);
+ ops = g_slist_prepend (ops, op);
 
 op = pa_context_get_sink_input_info_list (connection->priv->context,
- connection_sink_input_info_cb,
+ pulse_sink_input_info_cb,
 connection);
 if (G_UNLIKELY (op == NULL))
 goto error;
 
- ops = g_list_prepend (ops, op);
+ ops = g_slist_prepend (ops, op);
 
 op = pa_context_get_source_info_list (connection->priv->context,
- connection_source_info_cb,
+ pulse_source_info_cb,
 connection);
 if (G_UNLIKELY (op == NULL))
 goto error;
 
- ops = g_list_prepend (ops, op);
+ ops = g_slist_prepend (ops, op);
 
 op = pa_context_get_source_output_info_list (connection->priv->context,
- connection_source_output_info_cb,
+ pulse_source_output_info_cb,
 connection);
 if (G_UNLIKELY (op == NULL))
 goto error;
 
- ops = g_list_prepend (ops, op);
-
- g_list_foreach (ops, (GFunc) pa_operation_unref, NULL);
- g_list_free (ops);
+ ops = g_slist_prepend (ops, op);
 
 connection->priv->outstanding = 5;
+
+ /* This might not always be supported */
+ op = pa_ext_stream_restore_read (connection->priv->context,
+ pulse_ext_stream_restore_cb,
+ connection);
+ if (op != NULL) {
+ ops = g_slist_prepend (ops, op);
+ connection->priv->outstanding++;
+ }
+
+ g_slist_foreach (ops, (GFunc) pa_operation_unref, NULL);
+ g_slist_free (ops);
+
 return TRUE;
 
 error:
- g_list_foreach (ops, (GFunc) pa_operation_cancel, NULL);
- g_list_foreach (ops, (GFunc) pa_operation_unref, NULL);
- g_list_free (ops);
+ g_slist_foreach (ops, (GFunc) pa_operation_cancel, NULL);
+ g_slist_foreach (ops, (GFunc) pa_operation_unref, NULL);
+ g_slist_free (ops);
 return FALSE;
 }
 
+static gboolean
+load_list_finished (PulseConnection *connection)
+{
+ /* Decrement the number of outstanding requests as a list has just been
+ * downloaded; when the number reaches 0, server information is requested
+ * as the final step in the connection process */
+ connection->priv->outstanding--;
+
+ if (G_UNLIKELY (connection->priv->outstanding < 0)) {
+ g_warn_if_reached ();
+ connection->priv->outstanding = 0;
+ }
+
+ if (connection->priv->outstanding == 0) {
+ gboolean ret = pulse_connection_load_server_info (connection);
+
+ if (G_UNLIKELY (ret == FALSE)) {
+ pulse_connection_disconnect (connection);
+ return FALSE;
+ }
+ }
+
+ return TRUE;
+}
+
 static void
-connection_state_cb (pa_context *c, void *userdata)
+pulse_state_cb (pa_context *c, void *userdata)
 {
 PulseConnection *connection;
 pa_context_state_t state;
@@ -971,6 +1341,20 @@ connection_state_cb (pa_context *c, void *userdata)
 
 /* We are connected, let's subscribe to notifications and load the
 * initial lists */
+ pa_context_set_subscribe_callback (connection->priv->context,
+ pulse_subscribe_cb,
+ connection);
+ pa_ext_stream_restore_set_subscribe_cb (connection->priv->context,
+ pulse_restore_subscribe_cb,
+ connection);
+
+ op = pa_ext_stream_restore_subscribe (connection->priv->context,
+ TRUE,
+ NULL, NULL);
+
+ /* Keep going if this operation fails */
+ process_pulse_operation (connection, op);
+
 op = pa_context_subscribe (connection->priv->context,
 PA_SUBSCRIPTION_MASK_SERVER |
 PA_SUBSCRIPTION_MASK_CARD |
@@ -979,26 +1363,14 @@ connection_state_cb (pa_context *c, void *userdata)
 PA_SUBSCRIPTION_MASK_SINK_INPUT |
 PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT,
 NULL, NULL);
- if (op != NULL) {
- pa_context_set_subscribe_callback (connection->priv->context,
- connection_subscribe_cb,
- connection);
- pa_operation_unref (op);
-
- if (connection_load_lists (connection) == TRUE) {
- connection_change_state (connection, PULSE_CONNECTION_LOADING);
- return;
- }
 
- /* Treat as a connection failure */
- state = PA_CONTEXT_FAILED;
- } else {
- g_warning ("Failed to subscribe to PulseAudio notifications: %s",
- pa_strerror (pa_context_errno (connection->priv->context)));
+ if (process_pulse_operation (connection, op) == TRUE) {
+ change_state (connection, PULSE_CONNECTION_LOADING);
 
- /* Treat as a connection failure */
+ if (load_lists (connection) == FALSE)
+ state = PA_CONTEXT_FAILED;
+ } else
 state = PA_CONTEXT_FAILED;
- }
 }
 
 if (state == PA_CONTEXT_TERMINATED || state == PA_CONTEXT_FAILED) {
@@ -1008,105 +1380,93 @@ connection_state_cb (pa_context *c, void *userdata)
 }
 
 if (state == PA_CONTEXT_CONNECTING)
- connection_change_state (connection, PULSE_CONNECTION_CONNECTING);
+ change_state (connection, PULSE_CONNECTION_CONNECTING);
 else if (state == PA_CONTEXT_AUTHORIZING ||
 state == PA_CONTEXT_SETTING_NAME)
- connection_change_state (connection, PULSE_CONNECTION_AUTHORIZING);
+ change_state (connection, PULSE_CONNECTION_AUTHORIZING);
 }
 
 static void
-connection_subscribe_cb (pa_context *c,
- pa_subscription_event_type_t t,
- uint32_t idx,
- void *userdata)
+pulse_subscribe_cb (pa_context *c,
+ pa_subscription_event_type_t t,
+ uint32_t idx,
+ void *userdata)
 {
 PulseConnection *connection;
- pa_operation *op;
 
 connection = PULSE_CONNECTION (userdata);
 
 switch (t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) {
+ case PA_SUBSCRIPTION_EVENT_SERVER:
+ pulse_connection_load_server_info (connection);
+ break;
+
 case PA_SUBSCRIPTION_EVENT_CARD:
- if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
+ if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE)
 g_signal_emit (G_OBJECT (connection),
 signals[CARD_REMOVED],
 0,
 idx);
- } else {
- op = pa_context_get_card_info_by_index (connection->priv->context,
- idx,
- connection_card_info_cb,
- connection);
- connection_process_operation (connection, op);
- }
+ else
+ pulse_connection_load_card_info (connection, idx);
 break;
 
 case PA_SUBSCRIPTION_EVENT_SINK:
- if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
+ if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE)
 g_signal_emit (G_OBJECT (connection),
 signals[SINK_REMOVED],
 0,
 idx);
- } else {
- op = pa_context_get_sink_info_by_index (connection->priv->context,
- idx,
- connection_sink_info_cb,
- connection);
- connection_process_operation (connection, op);
- }
+ else
+ pulse_connection_load_sink_info (connection, idx);
 break;
 
 case PA_SUBSCRIPTION_EVENT_SINK_INPUT:
- if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
+ if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE)
 g_signal_emit (G_OBJECT (connection),
 signals[SINK_INPUT_REMOVED],
 0,
 idx);
- } else {
- op = pa_context_get_sink_input_info (connection->priv->context,
- idx,
- connection_sink_input_info_cb,
- connection);
- connection_process_operation (connection, op);
- }
+ else
+ pulse_connection_load_sink_input_info (connection, idx);
 break;
 
 case PA_SUBSCRIPTION_EVENT_SOURCE:
- if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
+ if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE)
 g_signal_emit (G_OBJECT (connection),
 signals[SOURCE_REMOVED],
 0,
 idx);
- } else {
- op = pa_context_get_source_info_by_index (connection->priv->context,
- idx,
- connection_source_info_cb,
- connection);
- connection_process_operation (connection, op);
- }
+ else
+ pulse_connection_load_source_info (connection, idx);
 break;
 
 case PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT:
- if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) {
+ if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE)
 g_signal_emit (G_OBJECT (connection),
 signals[SOURCE_OUTPUT_REMOVED],
 0,
 idx);
- } else {
- op = pa_context_get_source_output_info (connection->priv->context,
- idx,
- connection_source_output_info_cb,
- connection);
- connection_process_operation (connection, op);
- }
+ else
+ pulse_connection_load_source_output_info (connection, idx);
 break;
 }
 }
 
 static void
-connection_server_info_cb (pa_context *c,
- const pa_server_info *info,
- void *userdata)
+pulse_restore_subscribe_cb (pa_context *c, void *userdata)
+{
+ PulseConnection *connection;
+
+ connection = PULSE_CONNECTION (userdata);
+
+ pulse_connection_load_ext_stream_info (connection);
+}
+
+static void
+pulse_server_info_cb (pa_context *c,
+ const pa_server_info *info,
+ void *userdata)
 {
 PulseConnection *connection;
 
@@ -1120,14 +1480,14 @@ connection_server_info_cb (pa_context *c,
 /* This notification may arrive at any time, but it also finalizes the
 * connection process */
 if (connection->priv->state == PULSE_CONNECTION_LOADING)
- connection_change_state (connection, PULSE_CONNECTION_CONNECTED);
+ change_state (connection, PULSE_CONNECTION_CONNECTED);
 }
 
 static void
-connection_card_info_cb (pa_context *c,
- const pa_card_info *info,
- int eol,
- void *userdata)
+pulse_card_info_cb (pa_context *c,
+ const pa_card_info *info,
+ int eol,
+ void *userdata)
 {
 PulseConnection *connection;
 
@@ -1135,7 +1495,7 @@ connection_card_info_cb (pa_context *c,
 
 if (eol) {
 if (connection->priv->state == PULSE_CONNECTION_LOADING)
- connection_list_loaded (connection);
+ load_list_finished (connection);
 return;
 }
 
@@ -1146,10 +1506,10 @@ connection_card_info_cb (pa_context *c,
 }
 
 static void
-connection_sink_info_cb (pa_context *c,
- const pa_sink_info *info,
- int eol,
- void *userdata)
+pulse_sink_info_cb (pa_context *c,
+ const pa_sink_info *info,
+ int eol,
+ void *userdata)
 {
 PulseConnection *connection;
 
@@ -1157,7 +1517,7 @@ connection_sink_info_cb (pa_context *c,
 
 if (eol) {
 if (connection->priv->state == PULSE_CONNECTION_LOADING)
- connection_list_loaded (connection);
+ load_list_finished (connection);
 return;
 }
 
@@ -1168,10 +1528,10 @@ connection_sink_info_cb (pa_context *c,
 }
 
 static void
-connection_sink_input_info_cb (pa_context *c,
- const pa_sink_input_info *info,
- int eol,
- void *userdata)
+pulse_sink_input_info_cb (pa_context *c,
+ const pa_sink_input_info *info,
+ int eol,
+ void *userdata)
 {
 PulseConnection *connection;
 
@@ -1179,7 +1539,7 @@ connection_sink_input_info_cb (pa_context *c,
 
 if (eol) {
 if (connection->priv->state == PULSE_CONNECTION_LOADING)
- connection_list_loaded (connection);
+ load_list_finished (connection);
 return;
 }
 
@@ -1190,10 +1550,10 @@ connection_sink_input_info_cb (pa_context *c,
 }
 
 static void
-connection_source_info_cb (pa_context *c,
- const pa_source_info *info,
- int eol,
- void *userdata)
+pulse_source_info_cb (pa_context *c,
+ const pa_source_info *info,
+ int eol,
+ void *userdata)
 {
 PulseConnection *connection;
 
@@ -1201,7 +1561,7 @@ connection_source_info_cb (pa_context *c,
 
 if (eol) {
 if (connection->priv->state == PULSE_CONNECTION_LOADING)
- connection_list_loaded (connection);
+ load_list_finished (connection);
 return;
 }
 
@@ -1212,10 +1572,10 @@ connection_source_info_cb (pa_context *c,
 }
 
 static void
-connection_source_output_info_cb (pa_context *c,
- const pa_source_output_info *info,
- int eol,
- void *userdata)
+pulse_source_output_info_cb (pa_context *c,
+ const pa_source_output_info *info,
+ int eol,
+ void *userdata)
 {
 PulseConnection *connection;
 
@@ -1223,7 +1583,7 @@ connection_source_output_info_cb (pa_context *c,
 
 if (eol) {
 if (connection->priv->state == PULSE_CONNECTION_LOADING)
- connection_list_loaded (connection);
+ load_list_finished (connection);
 return;
 }
 
@@ -1234,43 +1594,51 @@ connection_source_output_info_cb (pa_context *c,
 }
 
 static void
-connection_change_state (PulseConnection *connection, PulseConnectionState state)
+pulse_ext_stream_restore_cb (pa_context *c,
+ const pa_ext_stream_restore_info *info,
+ int eol,
+ void *userdata)
 {
- if (connection->priv->state == state)
- return;
+ PulseConnection *connection;
 
- connection->priv->state = state;
+ connection = PULSE_CONNECTION (userdata);
 
- g_object_notify_by_pspec (G_OBJECT (connection), properties[PROP_STATE]);
-}
+ if (eol) {
+ connection->priv->ext_streams_loading = FALSE;
+ g_signal_emit (G_OBJECT (connection),
+ signals[EXT_STREAM_LOADED],
+ 0);
 
-static void
-connection_list_loaded (PulseConnection *connection)
-{
- /* Decrement the number of outstanding requests as a list has just been
- * downloaded; when the number reaches 0, server information is requested
- * as the final step in the connection process */
- connection->priv->outstanding--;
+ if (connection->priv->state == PULSE_CONNECTION_LOADING) {
+ if (load_list_finished (connection) == FALSE)
+ return;
+ }
 
- if (G_UNLIKELY (connection->priv->outstanding < 0)) {
- g_warn_if_reached ();
- connection->priv->outstanding = 0;
+ if (connection->priv->ext_streams_dirty == TRUE)
+ pulse_connection_load_ext_stream_info (connection);
+
+ return;
 }
 
- if (connection->priv->outstanding == 0) {
- pa_operation *op;
+ g_signal_emit (G_OBJECT (connection),
+ signals[EXT_STREAM_INFO],
+ 0,
+ info);
+}
+
+static void
+change_state (PulseConnection *connection, PulseConnectionState state)
+{
+ if (connection->priv->state == state)
+ return;
 
- op = pa_context_get_server_info (connection->priv->context,
- connection_server_info_cb,
- connection);
+ connection->priv->state = state;
 
- if (G_UNLIKELY (connection_process_operation (connection, op) == FALSE))
- pulse_connection_disconnect (connection);
- }
+ g_object_notify_by_pspec (G_OBJECT (connection), properties[PROP_STATE]);
 }
 
 static gboolean
-connection_process_operation (PulseConnection *connection, pa_operation *op)
+process_pulse_operation (PulseConnection *connection, pa_operation *op)
 {
 if (G_UNLIKELY (op == NULL)) {
 g_warning ("PulseAudio operation failed: %s",
diff --git a/backends/pulse/pulse-connection.h b/backends/pulse/pulse-connection.h
index ae7b3d3..b9119fd 100644
--- a/backends/pulse/pulse-connection.h
+++ b/backends/pulse/pulse-connection.h
@@ -22,6 +22,7 @@
 #include <glib-object.h>
 
 #include <pulse/pulseaudio.h>
+#include <pulse/ext-stream-restore.h>
 
 #include "pulse-enums.h"
 #include "pulse-monitor.h"
@@ -57,110 +58,152 @@ struct _PulseConnectionClass
 {
 GObjectClass parent_class;
 
+ /*< private >*/
 /* Signals */
- void (*server_info) (PulseConnection *connection,
- const pa_server_info *info);
- void (*card_info) (PulseConnection *connection,
- const pa_card_info *info);
- void (*card_removed) (PulseConnection *connection,
- guint32 index);
- void (*sink_info) (PulseConnection *connection,
- const pa_sink_info *info);
- void (*sink_removed) (PulseConnection *connection,
- guint32 index);
- void (*sink_input_info) (PulseConnection *connection,
- const pa_sink_input_info *info);
- void (*sink_input_removed) (PulseConnection *connection,
- guint32 index);
- void (*source_info) (PulseConnection *connection,
- const pa_source_info *info);
- void (*source_removed) (PulseConnection *connection,
- guint32 index);
- void (*source_output_info) (PulseConnection *connection,
- const pa_source_output_info *info);
- void (*source_output_removed) (PulseConnection *connection,
- guint32 index);
+ void (*server_info) (PulseConnection *connection,
+ const pa_server_info *info);
+
+ void (*card_info) (PulseConnection *connection,
+ const pa_card_info *info);
+ void (*card_removed) (PulseConnection *connection,
+ guint32 index);
+
+ void (*sink_info) (PulseConnection *connection,
+ const pa_sink_info *info);
+ void (*sink_removed) (PulseConnection *connection,
+ guint32 index);
+
+ void (*sink_input_info) (PulseConnection *connection,
+ const pa_sink_input_info *info);
+ void (*sink_input_removed) (PulseConnection *connection,
+ guint32 index);
+
+ void (*source_info) (PulseConnection *connection,
+ const pa_source_info *info);
+ void (*source_removed) (PulseConnection *connection,
+ guint32 index);
+
+ void (*source_output_info) (PulseConnection *connection,
+ const pa_source_output_info *info);
+ void (*source_output_removed) (PulseConnection *connection,
+ guint32 index);
+
+ void (*ext_stream_loading) (PulseConnection *connection);
+ void (*ext_stream_loaded) (PulseConnection *connection);
+ void (*ext_stream_info) (PulseConnection *connection,
+ const pa_ext_stream_restore_info *info);
 };
 
 GType pulse_connection_get_type (void) G_GNUC_CONST;
 
-PulseConnection * pulse_connection_new (const gchar *app_name,
- const gchar *app_id,
- const gchar *app_version,
- const gchar *app_icon,
- const gchar *server_address);
-
-gboolean pulse_connection_connect (PulseConnection *connection,
- gboolean wait_for_daemon);
-void pulse_connection_disconnect (PulseConnection *connection);
-
-PulseConnectionState pulse_connection_get_state (PulseConnection *connection);
-
-PulseMonitor * pulse_connection_create_monitor (PulseConnection *connection,
- guint32 index_source,
- guint32 index_sink_input);
-
-gboolean pulse_connection_set_default_sink (PulseConnection *connection,
- const gchar *name);
-gboolean pulse_connection_set_default_source (PulseConnection *connection,
- const gchar *name);
-
-gboolean pulse_connection_set_card_profile (PulseConnection *connection,
- const gchar *device,
- const gchar *profile);
-
-gboolean pulse_connection_set_sink_mute (PulseConnection *connection,
- guint32 index,
- gboolean mute);
-gboolean pulse_connection_set_sink_volume (PulseConnection *connection,
- guint32 index,
- const pa_cvolume *volume);
-gboolean pulse_connection_set_sink_port (PulseConnection *connection,
- guint32 index,
- const gchar *port);
-
-gboolean pulse_connection_set_sink_input_mute (PulseConnection *connection,
- guint32 index,
- gboolean mute);
-gboolean pulse_connection_set_sink_input_volume (PulseConnection *connection,
- guint32 index,
- const pa_cvolume *volume);
-
-gboolean pulse_connection_set_source_mute (PulseConnection *connection,
- guint32 index,
- gboolean mute);
-gboolean pulse_connection_set_source_volume (PulseConnection *connection,
- guint32 index,
- const pa_cvolume *volume);
-gboolean pulse_connection_set_source_port (PulseConnection *connection,
- guint32 index,
- const gchar *port);
-
-gboolean pulse_connection_set_source_output_mute (PulseConnection *connection,
- guint32 index,
- gboolean mute);
-gboolean pulse_connection_set_source_output_volume (PulseConnection *connection,
- guint32 index,
- const pa_cvolume *volume);
-
-gboolean pulse_connection_suspend_sink (PulseConnection *connection,
- guint32 index,
- gboolean suspend);
-gboolean pulse_connection_suspend_source (PulseConnection *connection,
- guint32 index,
- gboolean suspend);
-
-gboolean pulse_connection_move_sink_input (PulseConnection *connection,
- guint32 index,
- guint32 sink_index);
-gboolean pulse_connection_move_source_output (PulseConnection *connection,
- guint32 index,
- guint32 source_index);
-
-gboolean pulse_connection_kill_sink_input (PulseConnection *connection,
- guint32 index);
-gboolean pulse_connection_kill_source_output (PulseConnection *connection,
- guint32 index);
+PulseConnection * pulse_connection_new (const gchar *app_name,
+ const gchar *app_id,
+ const gchar *app_version,
+ const gchar *app_icon,
+ const gchar *server_address);
+
+gboolean pulse_connection_connect (PulseConnection *connection,
+ gboolean wait_for_daemon);
+void pulse_connection_disconnect (PulseConnection *connection);
+
+PulseConnectionState pulse_connection_get_state (PulseConnection *connection);
+
+gboolean pulse_connection_load_server_info (PulseConnection *connection);
+
+gboolean pulse_connection_load_card_info (PulseConnection *connection,
+ guint32 index);
+gboolean pulse_connection_load_card_info_name (PulseConnection *connection,
+ const gchar *name);
+
+gboolean pulse_connection_load_sink_info (PulseConnection *connection,
+ guint32 index);
+gboolean pulse_connection_load_sink_info_name (PulseConnection *connection,
+ const gchar *name);
+
+gboolean pulse_connection_load_sink_input_info (PulseConnection *connection,
+ guint32 index);
+
+gboolean pulse_connection_load_source_info (PulseConnection *connection,
+ guint32 index);
+gboolean pulse_connection_load_source_info_name (PulseConnection *connection,
+ const gchar *name);
+
+gboolean pulse_connection_load_source_output_info (PulseConnection *connection,
+ guint32 index);
+
+gboolean pulse_connection_load_ext_stream_info (PulseConnection *connection);
+
+PulseMonitor * pulse_connection_create_monitor (PulseConnection *connection,
+ guint32 index_source,
+ guint32 index_sink_input);
+
+gboolean pulse_connection_set_default_sink (PulseConnection *connection,
+ const gchar *name);
+gboolean pulse_connection_set_default_source (PulseConnection *connection,
+ const gchar *name);
+
+gboolean pulse_connection_set_card_profile (PulseConnection *connection,
+ const gchar *device,
+ const gchar *profile);
+
+gboolean pulse_connection_set_sink_mute (PulseConnection *connection,
+ guint32 index,
+ gboolean mute);
+gboolean pulse_connection_set_sink_volume (PulseConnection *connection,
+ guint32 index,
+ const pa_cvolume *volume);
+gboolean pulse_connection_set_sink_port (PulseConnection *connection,
+ guint32 index,
+ const gchar *port);
+
+gboolean pulse_connection_set_sink_input_mute (PulseConnection *connection,
+ guint32 index,
+ gboolean mute);
+gboolean pulse_connection_set_sink_input_volume (PulseConnection *connection,
+ guint32 index,
+ const pa_cvolume *volume);
+
+gboolean pulse_connection_set_source_mute (PulseConnection *connection,
+ guint32 index,
+ gboolean mute);
+gboolean pulse_connection_set_source_volume (PulseConnection *connection,
+ guint32 index,
+ const pa_cvolume *volume);
+gboolean pulse_connection_set_source_port (PulseConnection *connection,
+ guint32 index,
+ const gchar *port);
+
+gboolean pulse_connection_set_source_output_mute (PulseConnection *connection,
+ guint32 index,
+ gboolean mute);
+gboolean pulse_connection_set_source_output_volume (PulseConnection *connection,
+ guint32 index,
+ const pa_cvolume *volume);
+
+gboolean pulse_connection_suspend_sink (PulseConnection *connection,
+ guint32 index,
+ gboolean suspend);
+gboolean pulse_connection_suspend_source (PulseConnection *connection,
+ guint32 index,
+ gboolean suspend);
+
+gboolean pulse_connection_move_sink_input (PulseConnection *connection,
+ guint32 index,
+ guint32 sink_index);
+gboolean pulse_connection_move_source_output (PulseConnection *connection,
+ guint32 index,
+ guint32 source_index);
+
+gboolean pulse_connection_kill_sink_input (PulseConnection *connection,
+ guint32 index);
+gboolean pulse_connection_kill_source_output (PulseConnection *connection,
+ guint32 index);
+
+gboolean pulse_connection_write_ext_stream (PulseConnection *connection,
+ const pa_ext_stream_restore_info *info);
+
+gboolean pulse_connection_delete_ext_stream (PulseConnection *connection,
+ const gchar *name);
 
 G_END_DECLS
 
diff --git a/backends/pulse/pulse-device.c b/backends/pulse/pulse-device.c
index 368d85b..96e06c8 100644
--- a/backends/pulse/pulse-device.c
+++ b/backends/pulse/pulse-device.c
@@ -15,14 +15,16 @@
 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <string.h>
 #include <glib.h>
 #include <glib-object.h>
-#include <string.h>
 
 #include <libmatemixer/matemixer-device.h>
 #include <libmatemixer/matemixer-device-profile.h>
+#include <libmatemixer/matemixer-device-profile-private.h>
 #include <libmatemixer/matemixer-enums.h>
 #include <libmatemixer/matemixer-port.h>
+#include <libmatemixer/matemixer-port-private.h>
 
 #include <pulse/pulseaudio.h>
 
@@ -34,27 +36,23 @@ struct _PulseDevicePrivate
 guint32 index;
 gchar *name;
 gchar *description;
- GList *profiles;
- GList *ports;
- GList *streams;
- gboolean streams_sorted;
 gchar *icon;
+ GHashTable *ports;
+ GList *ports_list;
+ GHashTable *profiles;
+ GList *profiles_list;
 PulseConnection *connection;
 MateMixerDeviceProfile *profile;
 };
 
-enum
-{
+enum {
 PROP_0,
 PROP_NAME,
 PROP_DESCRIPTION,
 PROP_ICON,
- PROP_PORTS,
- PROP_PROFILES,
 PROP_ACTIVE_PROFILE,
 PROP_INDEX,
- PROP_CONNECTION,
- N_PROPERTIES
+ PROP_CONNECTION
 };
 
 static void mate_mixer_device_interface_init (MateMixerDeviceInterface *iface);
@@ -78,35 +76,50 @@ G_DEFINE_TYPE_WITH_CODE (PulseDevice, pulse_device, G_TYPE_OBJECT,
 G_IMPLEMENT_INTERFACE (MATE_MIXER_TYPE_DEVICE,
 mate_mixer_device_interface_init))
 
-static const gchar * device_get_name (MateMixerDevice *device);
-static const gchar * device_get_description (MateMixerDevice *device);
-static const gchar * device_get_icon (MateMixerDevice *device);
+#if PA_CHECK_VERSION (5, 0, 0)
+typedef pa_card_profile_info2 _pa_card_profile_info;
+#else
+typedef pa_card_profile_info _pa_card_profile_info;
+#endif
+
+static const gchar * pulse_device_get_name (MateMixerDevice *device);
+static const gchar * pulse_device_get_description (MateMixerDevice *device);
+static const gchar * pulse_device_get_icon (MateMixerDevice *device);
 
-static const GList * device_list_ports (MateMixerDevice *device);
-static const GList * device_list_profiles (MateMixerDevice *device);
+static MateMixerPort * pulse_device_get_port (MateMixerDevice *device,
+ const gchar *name);
+static MateMixerDeviceProfile *pulse_device_get_profile (MateMixerDevice *device,
+ const gchar *name);
 
-static MateMixerDeviceProfile *device_get_active_profile (MateMixerDevice *device);
-static gboolean device_set_active_profile (MateMixerDevice *device,
- const gchar *profile);
+static const GList * pulse_device_list_ports (MateMixerDevice *device);
+static const GList * pulse_device_list_profiles (MateMixerDevice *device);
 
-static gint device_compare_ports (gconstpointer a,
- gconstpointer b);
-static gint device_compare_profiles (gconstpointer a,
- gconstpointer b);
+static MateMixerDeviceProfile *pulse_device_get_active_profile (MateMixerDevice *device);
+static gboolean pulse_device_set_active_profile (MateMixerDevice *device,
+ MateMixerDeviceProfile *profile);
 
-static void device_free_ports (PulseDevice *device);
-static void device_free_profiles (PulseDevice *device);
+static void update_port (PulseDevice *device,
+ pa_card_port_info *p_info);
+static void update_profile (PulseDevice *device,
+ _pa_card_profile_info *p_info);
+
+static gint compare_ports (gconstpointer a,
+ gconstpointer b);
+static gint compare_profiles (gconstpointer a,
+ gconstpointer b);
 
 static void
 mate_mixer_device_interface_init (MateMixerDeviceInterface *iface)
 {
- iface->get_name = device_get_name;
- iface->get_description = device_get_description;
- iface->get_icon = device_get_icon;
- iface->list_ports = device_list_ports;
- iface->list_profiles = device_list_profiles;
- iface->get_active_profile = device_get_active_profile;
- iface->set_active_profile = device_set_active_profile;
+ iface->get_name = pulse_device_get_name;
+ iface->get_description = pulse_device_get_description;
+ iface->get_icon = pulse_device_get_icon;
+ iface->get_port = pulse_device_get_port;
+ iface->get_profile = pulse_device_get_profile;
+ iface->list_ports = pulse_device_list_ports;
+ iface->list_profiles = pulse_device_list_profiles;
+ iface->get_active_profile = pulse_device_get_active_profile;
+ iface->set_active_profile = pulse_device_set_active_profile;
 }
 
 static void
@@ -144,8 +157,6 @@ pulse_device_class_init (PulseDeviceClass *klass)
 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_PORTS, "ports");
- g_object_class_override_property (object_class, PROP_PROFILES, "profiles");
 g_object_class_override_property (object_class, PROP_ACTIVE_PROFILE, "active-profile");
 
 g_type_class_add_private (object_class, sizeof (PulseDevicePrivate));
@@ -171,12 +182,6 @@ pulse_device_get_property (GObject *object,
 case PROP_ICON:
 g_value_set_string (value, device->priv->icon);
 break;
- case PROP_PORTS:
- g_value_set_pointer (value, device->priv->ports);
- break;
- case PROP_PROFILES:
- g_value_set_pointer (value, device->priv->profiles);
- break;
 case PROP_ACTIVE_PROFILE:
 g_value_set_object (value, device->priv->profile);
 break;
@@ -222,6 +227,16 @@ pulse_device_init (PulseDevice *device)
 device->priv = G_TYPE_INSTANCE_GET_PRIVATE (device,
 PULSE_TYPE_DEVICE,
 PulseDevicePrivate);
+
+ device->priv->ports = g_hash_table_new_full (g_str_hash,
+ g_str_equal,
+ g_free,
+ g_object_unref);
+
+ device->priv->profiles = g_hash_table_new_full (g_str_hash,
+ g_str_equal,
+ g_free,
+ g_object_unref);
 }
 
 static void
@@ -231,9 +246,19 @@ pulse_device_dispose (GObject *object)
 
 device = PULSE_DEVICE (object);
 
- device_free_ports (device);
- device_free_profiles (device);
+ if (device->priv->ports_list != NULL) {
+ g_list_free_full (device->priv->ports_list, g_object_unref);
+ device->priv->ports_list = NULL;
+ }
+ g_hash_table_remove_all (device->priv->ports);
 
+ if (device->priv->profiles_list != NULL) {
+ g_list_free_full (device->priv->profiles_list, g_object_unref);
+ device->priv->profiles_list = NULL;
+ }
+ g_hash_table_remove_all (device->priv->profiles);
+
+ g_clear_object (&device->priv->profile);
 g_clear_object (&device->priv->connection);
 
 G_OBJECT_CLASS (pulse_device_parent_class)->dispose (object);
@@ -250,6 +275,9 @@ pulse_device_finalize (GObject *object)
 g_free (device->priv->description);
 g_free (device->priv->icon);
 
+ g_hash_table_destroy (device->priv->ports);
+ g_hash_table_destroy (device->priv->profiles);
+
 G_OBJECT_CLASS (pulse_device_parent_class)->finalize (object);
 }
 
@@ -276,6 +304,7 @@ pulse_device_new (PulseConnection *connection, const pa_card_info *info)
 gboolean
 pulse_device_update (PulseDevice *device, const pa_card_info *info)
 {
+ MateMixerDeviceProfile *profile = NULL;
 const gchar *prop;
 guint32 i;
 
@@ -286,7 +315,7 @@ pulse_device_update (PulseDevice *device, const pa_card_info *info)
 g_object_freeze_notify (G_OBJECT (device));
 
 /* Name */
- if (g_strcmp0 (device->priv->name, info->name)) {
+ if (g_strcmp0 (device->priv->name, info->name) != 0) {
 g_free (device->priv->name);
 device->priv->name = g_strdup (info->name);
 
@@ -299,7 +328,7 @@ pulse_device_update (PulseDevice *device, const pa_card_info *info)
 if (G_UNLIKELY (prop == NULL))
 prop = info->name;
 
- if (g_strcmp0 (device->priv->description, prop)) {
+ if (g_strcmp0 (device->priv->description, prop) != 0) {
 g_free (device->priv->description);
 device->priv->description = g_strdup (prop);
 
@@ -312,49 +341,23 @@ pulse_device_update (PulseDevice *device, const pa_card_info *info)
 if (G_UNLIKELY (prop == NULL))
 prop = "audio-card";
 
- if (g_strcmp0 (device->priv->icon, prop)) {
+ if (g_strcmp0 (device->priv->icon, prop) != 0) {
 g_free (device->priv->icon);
 device->priv->icon = g_strdup (prop);
 
 g_object_notify (G_OBJECT (device), "icon");
 }
 
+#if PA_CHECK_VERSION (2, 0, 0)
 /* List of ports */
- device_free_ports (device);
-
 for (i = 0; i < info->n_ports; i++) {
- MateMixerPortFlags flags = MATE_MIXER_PORT_NO_FLAGS;
-
- prop = pa_proplist_gets (info->ports[i]->proplist, "device.icon_name");
-
-#if PA_CHECK_VERSION(2, 0, 0)
- if (info->ports[i]->available == PA_PORT_AVAILABLE_YES)
- flags |= MATE_MIXER_PORT_AVAILABLE;
-
- if (info->ports[i]->direction & PA_DIRECTION_INPUT)
- flags |= MATE_MIXER_PORT_INPUT;
- if (info->ports[i]->direction & PA_DIRECTION_OUTPUT)
- flags |= MATE_MIXER_PORT_OUTPUT;
-#endif
- device->priv->ports =
- g_list_prepend (device->priv->ports,
- mate_mixer_port_new (info->ports[i]->name,
- info->ports[i]->description,
- prop,
- info->ports[i]->priority,
- flags));
+ update_port (device, info->ports[i]);
 }
- device->priv->ports = g_list_sort (device->priv->ports, device_compare_ports);
-
- g_object_notify (G_OBJECT (device), "ports");
+#endif
 
 /* List of profiles */
- device_free_profiles (device);
-
 for (i = 0; i < info->n_profiles; i++) {
- MateMixerDeviceProfile *profile;
-
-#if PA_CHECK_VERSION(5, 0, 0)
+#if PA_CHECK_VERSION (5, 0, 0)
 pa_card_profile_info2 *p_info = info->profiles2[i];
 
 /* PulseAudio 5.0 includes a new pa_card_profile_info2 which only
@@ -366,28 +369,28 @@ pulse_device_update (PulseDevice *device, const pa_card_info *info)
 /* The old profile list is an array of structs, not pointers */
 pa_card_profile_info *p_info = &info->profiles[i];
 #endif
- profile = mate_mixer_device_profile_new (
- p_info->name,
- p_info->description,
- p_info->priority,
- p_info->n_sources,
- p_info->n_sinks);
-
- if (device->priv->profile == NULL) {
-#if PA_CHECK_VERSION(5, 0, 0)
- if (!g_strcmp0 (p_info->name, info->active_profile2->name))
- device->priv->profile = g_object_ref (profile);
+ update_profile (device, p_info);
+ }
+
+ /* Figure out whether the currently active profile has changed */
+ profile = NULL;
+
+#if PA_CHECK_VERSION (5, 0, 0)
+ if (G_LIKELY (info->active_profile2 != NULL))
+ profile = g_hash_table_lookup (device->priv->profiles, info->active_profile2->name);
 #else
- if (!g_strcmp0 (p_info->name, info->active_profile->name))
- device->priv->profile = g_object_ref (profile);
+ if (G_LIKELY (info->active_profile != NULL))
+ profile = g_hash_table_lookup (device->priv->profiles, info->active_profile->name);
 #endif
- }
- device->priv->profiles = g_list_prepend (device->priv->profiles, profile);
- }
- device->priv->profiles = g_list_sort (device->priv->profiles,
- device_compare_profiles);
 
- g_object_notify (G_OBJECT (device), "profiles");
+ if (profile != device->priv->profile) {
+ g_clear_object (&device->priv->profile);
+
+ if (G_LIKELY (profile != NULL))
+ device->priv->profile = g_object_ref (profile);
+
+ g_object_notify (G_OBJECT (device), "active-profile");
+ }
 
 g_object_thaw_notify (G_OBJECT (device));
 return TRUE;
@@ -410,7 +413,7 @@ pulse_device_get_index (PulseDevice *device)
 }
 
 static const gchar *
-device_get_name (MateMixerDevice *device)
+pulse_device_get_name (MateMixerDevice *device)
 {
 g_return_val_if_fail (PULSE_IS_DEVICE (device), NULL);
 
@@ -418,7 +421,7 @@ device_get_name (MateMixerDevice *device)
 }
 
 static const gchar *
-device_get_description (MateMixerDevice *device)
+pulse_device_get_description (MateMixerDevice *device)
 {
 g_return_val_if_fail (PULSE_IS_DEVICE (device), NULL);
 
@@ -426,31 +429,77 @@ device_get_description (MateMixerDevice *device)
 }
 
 static const gchar *
-device_get_icon (MateMixerDevice *device)
+pulse_device_get_icon (MateMixerDevice *device)
 {
 g_return_val_if_fail (PULSE_IS_DEVICE (device), NULL);
 
 return PULSE_DEVICE (device)->priv->icon;
 }
 
+static MateMixerPort *
+pulse_device_get_port (MateMixerDevice *device, const gchar *name)
+{
+ g_return_val_if_fail (PULSE_IS_DEVICE (device), NULL);
+ g_return_val_if_fail (name != NULL, NULL);
+
+ return g_hash_table_lookup (PULSE_DEVICE (device)->priv->ports, name);
+}
+
+static MateMixerDeviceProfile *
+pulse_device_get_profile (MateMixerDevice *device, const gchar *name)
+{
+ g_return_val_if_fail (PULSE_IS_DEVICE (device), NULL);
+ g_return_val_if_fail (name != NULL, NULL);
+
+ return g_hash_table_lookup (PULSE_DEVICE (device)->priv->profiles, name);
+}
+
 static const GList *
-device_list_ports (MateMixerDevice *device)
+pulse_device_list_ports (MateMixerDevice *device)
 {
+ PulseDevice *pulse;
+
 g_return_val_if_fail (PULSE_IS_DEVICE (device), NULL);
 
- return (const GList *) PULSE_DEVICE (device)->priv->ports;
+ pulse = PULSE_DEVICE (device);
+
+ if (pulse->priv->ports_list == NULL) {
+ GList *list = g_hash_table_get_values (pulse->priv->ports);
+
+ if (list != NULL) {
+ g_list_foreach (list, (GFunc) g_object_ref, NULL);
+
+ pulse->priv->ports_list = g_list_sort (list, compare_ports);
+ }
+ }
+
+ return (const GList *) pulse->priv->ports_list;
 }
 
 static const GList *
-device_list_profiles (MateMixerDevice *device)
+pulse_device_list_profiles (MateMixerDevice *device)
 {
+ PulseDevice *pulse;
+
 g_return_val_if_fail (PULSE_IS_DEVICE (device), NULL);
 
- return (const GList *) PULSE_DEVICE (device)->priv->profiles;
+ pulse = PULSE_DEVICE (device);
+
+ if (pulse->priv->profiles_list == NULL) {
+ GList *list = g_hash_table_get_values (pulse->priv->profiles);
+
+ if (list != NULL) {
+ g_list_foreach (list, (GFunc) g_object_ref, NULL);
+
+ pulse->priv->profiles_list = g_list_sort (list, compare_profiles);
+ }
+ }
+
+ return (const GList *) pulse->priv->profiles_list;
 }
 
 static MateMixerDeviceProfile *
-device_get_active_profile (MateMixerDevice *device)
+pulse_device_get_active_profile (MateMixerDevice *device)
 {
 g_return_val_if_fail (PULSE_IS_DEVICE (device), NULL);
 
@@ -458,18 +507,103 @@ device_get_active_profile (MateMixerDevice *device)
 }
 
 static gboolean
-device_set_active_profile (MateMixerDevice *device, const gchar *profile)
+pulse_device_set_active_profile (MateMixerDevice *device, MateMixerDeviceProfile *profile)
 {
+ PulseDevice *pulse;
+ const gchar *name;
+ gboolean ret;
+
 g_return_val_if_fail (PULSE_IS_DEVICE (device), FALSE);
- g_return_val_if_fail (profile != NULL, FALSE);
+ g_return_val_if_fail (MATE_MIXER_IS_DEVICE_PROFILE (profile), FALSE);
+
+ pulse = PULSE_DEVICE (device);
+
+ name = mate_mixer_device_profile_get_name (profile);
+
+ /* Make sure the profile belongs to the device */
+ if (g_hash_table_lookup (pulse->priv->profiles, name) == NULL) {
+ g_warning ("Profile %s does not belong to device %s", name, pulse->priv->name);
+ return FALSE;
+ }
+
+ ret = pulse_connection_set_card_profile (pulse->priv->connection,
+ pulse->priv->name,
+ name);
+ if (ret == TRUE) {
+ if (pulse->priv->profile != NULL)
+ g_object_unref (pulse->priv->profile);
+
+ pulse->priv->profile = g_object_ref (profile);
+
+ g_object_notify (G_OBJECT (device), "active-profile");
+ }
+ return ret;
+}
+
+static void
+update_port (PulseDevice *device, pa_card_port_info *p_info)
+{
+ MateMixerPort *port;
+ MateMixerPortFlags flags = MATE_MIXER_PORT_NO_FLAGS;
+ const gchar *icon;
+
+ icon = pa_proplist_gets (p_info->proplist, "device.icon_name");
+
+ if (p_info->available == PA_PORT_AVAILABLE_YES)
+ flags |= MATE_MIXER_PORT_AVAILABLE;
+
+ if (p_info->direction & PA_DIRECTION_INPUT)
+ flags |= MATE_MIXER_PORT_INPUT;
+ if (p_info->direction & PA_DIRECTION_OUTPUT)
+ flags |= MATE_MIXER_PORT_OUTPUT;
+
+ port = g_hash_table_lookup (device->priv->ports, p_info->name);
+
+ if (port != NULL) {
+ /* Update existing port */
+ _mate_mixer_port_update_description (port, p_info->description);
+ _mate_mixer_port_update_icon (port, icon);
+ _mate_mixer_port_update_priority (port, p_info->priority);
+ _mate_mixer_port_update_flags (port, flags);
+ } else {
+ /* Add previously unknown port to the hash table */
+ port = _mate_mixer_port_new (p_info->name,
+ p_info->description,
+ icon,
+ p_info->priority,
+ flags);
+
+ g_hash_table_insert (device->priv->ports, g_strdup (p_info->name), port);
+ }
+}
+
+static void
+update_profile (PulseDevice *device, _pa_card_profile_info *p_info)
+{
+ MateMixerDeviceProfile *profile;
 
- return pulse_connection_set_card_profile (PULSE_DEVICE (device)->priv->connection,
- PULSE_DEVICE (device)->priv->name,
- profile);
+ profile = g_hash_table_lookup (device->priv->profiles, p_info->name);
+
+ if (profile != NULL) {
+ /* Update existing profile */
+ _mate_mixer_device_profile_update_description (profile, p_info->description);
+ _mate_mixer_device_profile_update_priority (profile, p_info->priority);
+ _mate_mixer_device_profile_update_num_input_streams (profile, p_info->n_sources);
+ _mate_mixer_device_profile_update_num_output_streams (profile, p_info->n_sinks);
+ } else {
+ /* Add previously unknown profile to the hash table */
+ profile = _mate_mixer_device_profile_new (p_info->name,
+ p_info->description,
+ p_info->priority,
+ p_info->n_sources,
+ p_info->n_sinks);
+
+ g_hash_table_insert (device->priv->profiles, g_strdup (p_info->name), profile);
+ }
 }
 
 static gint
-device_compare_ports (gconstpointer a, gconstpointer b)
+compare_ports (gconstpointer a, gconstpointer b)
 {
 MateMixerPort *p1 = MATE_MIXER_PORT (a);
 MateMixerPort *p2 = MATE_MIXER_PORT (b);
@@ -484,7 +618,7 @@ device_compare_ports (gconstpointer a, gconstpointer b)
 }
 
 static gint
-device_compare_profiles (gconstpointer a, gconstpointer b)
+compare_profiles (gconstpointer a, gconstpointer b)
 {
 MateMixerDeviceProfile *p1 = MATE_MIXER_DEVICE_PROFILE (a);
 MateMixerDeviceProfile *p2 = MATE_MIXER_DEVICE_PROFILE (b);
@@ -497,27 +631,3 @@ device_compare_profiles (gconstpointer a, gconstpointer b)
 return strcmp (mate_mixer_device_profile_get_name (p1),
 mate_mixer_device_profile_get_name (p2));
 }
-
-static void
-device_free_ports (PulseDevice *device)
-{
- if (device->priv->ports == NULL)
- return;
-
- g_list_free_full (device->priv->ports, g_object_unref);
-
- device->priv->ports = NULL;
-}
-
-static void
-device_free_profiles (PulseDevice *device)
-{
- if (device->priv->profiles == NULL)
- return;
-
- g_list_free_full (device->priv->profiles, g_object_unref);
-
- g_clear_object (&device->priv->profile);
-
- device->priv->profiles = NULL;
-}
diff --git a/backends/pulse/pulse-ext-stream.c b/backends/pulse/pulse-ext-stream.c
new file mode 100644
index 0000000..96164e8
--- /dev/null
+++ b/backends/pulse/pulse-ext-stream.c
@@ -0,0 +1,301 @@
+/*
+ * 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 <string.h>
+#include <glib.h>
+#include <glib-object.h>
+
+#include <libmatemixer/matemixer-client-stream.h>
+#include <libmatemixer/matemixer-enums.h>
+#include <libmatemixer/matemixer-stream.h>
+
+#include <pulse/pulseaudio.h>
+#include <pulse/ext-stream-restore.h>
+
+#include "pulse-connection.h"
+#include "pulse-client-stream.h"
+#include "pulse-ext-stream.h"
+#include "pulse-helpers.h"
+#include "pulse-sink.h"
+#include "pulse-source.h"
+#include "pulse-stream.h"
+
+static void pulse_ext_stream_class_init (PulseExtStreamClass *klass);
+static void pulse_ext_stream_init (PulseExtStream *ext);
+
+G_DEFINE_TYPE (PulseExtStream, pulse_ext_stream, PULSE_TYPE_CLIENT_STREAM);
+
+static void pulse_ext_stream_reload (PulseStream *pstream);
+
+static gboolean pulse_ext_stream_set_mute (PulseStream *pstream,
+ gboolean mute);
+static gboolean pulse_ext_stream_set_volume (PulseStream *pstream,
+ pa_cvolume *cvolume);
+static gboolean pulse_ext_stream_set_parent (PulseClientStream *pclient,
+ PulseStream *parent);
+static gboolean pulse_ext_stream_remove (PulseClientStream *pclient);
+
+static void
+pulse_ext_stream_class_init (PulseExtStreamClass *klass)
+{
+ PulseStreamClass *stream_class;
+ PulseClientStreamClass *client_class;
+
+ stream_class = PULSE_STREAM_CLASS (klass);
+
+ stream_class->reload = pulse_ext_stream_reload;
+ stream_class->set_mute = pulse_ext_stream_set_mute;
+ stream_class->set_volume = pulse_ext_stream_set_volume;
+
+ client_class = PULSE_CLIENT_STREAM_CLASS (klass);
+
+ client_class->set_parent = pulse_ext_stream_set_parent;
+ client_class->remove = pulse_ext_stream_remove;
+}
+
+static void
+pulse_ext_stream_init (PulseExtStream *ext)
+{
+}
+
+PulseStream *
+pulse_ext_stream_new (PulseConnection *connection,
+ const pa_ext_stream_restore_info *info,
+ PulseStream *parent)
+{
+ PulseStream *ext;
+
+ g_return_val_if_fail (PULSE_IS_CONNECTION (connection), NULL);
+ g_return_val_if_fail (info != NULL, NULL);
+
+ ext = g_object_new (PULSE_TYPE_EXT_STREAM,
+ "connection", connection,
+ NULL);
+
+ /* Consider the stream name as unchanging parameter */
+ pulse_stream_update_name (ext, info->name);
+
+ /* Other data may change at any time, so let's make a use of our update function */
+ pulse_ext_stream_update (ext, info, parent);
+
+ return ext;
+}
+
+gboolean
+pulse_ext_stream_update (PulseStream *pstream,
+ const pa_ext_stream_restore_info *info,
+ PulseStream *parent)
+{
+ MateMixerClientStreamRole role = MATE_MIXER_CLIENT_STREAM_ROLE_NONE;
+ MateMixerStreamFlags flags = MATE_MIXER_STREAM_CLIENT |
+ MATE_MIXER_STREAM_HAS_VOLUME |
+ MATE_MIXER_STREAM_HAS_MUTE |
+ MATE_MIXER_STREAM_CAN_SET_VOLUME;
+ MateMixerClientStreamFlags client_flags =
+ MATE_MIXER_CLIENT_STREAM_CACHED;
+
+ PulseClientStream *pclient;
+ gchar *suffix;
+
+ g_return_val_if_fail (PULSE_IS_EXT_STREAM (pstream), FALSE);
+ g_return_val_if_fail (info != NULL, FALSE);
+
+ pclient = PULSE_CLIENT_STREAM (pstream);
+
+ suffix = strchr (info->name, ':');
+ if (suffix != NULL)
+ suffix++;
+
+ /* Let all the information update before emitting notify signals */
+ g_object_freeze_notify (G_OBJECT (pstream));
+
+ if (g_str_has_prefix (info->name, "sink-input"))
+ flags |= MATE_MIXER_STREAM_OUTPUT;
+ else if (g_str_has_prefix (info->name, "source-output"))
+ flags |= MATE_MIXER_STREAM_INPUT;
+ else
+ g_debug ("Unknown ext-stream %s", info->name);
+
+ if (strstr (info->name, "-by-media-role:")) {
+ if (G_LIKELY (suffix != NULL))
+ role = pulse_convert_media_role_name (suffix);
+ }
+ else if (strstr (info->name, "-by-application-name:")) {
+ client_flags |= MATE_MIXER_CLIENT_STREAM_APPLICATION;
+
+ if (G_LIKELY (suffix != NULL))
+ pulse_client_stream_update_app_name (pclient, suffix);
+ }
+ else if (strstr (info->name, "-by-application-id:")) {
+ client_flags |= MATE_MIXER_CLIENT_STREAM_APPLICATION;
+
+ if (G_LIKELY (suffix != NULL))
+ pulse_client_stream_update_app_id (pclient, suffix);
+ }
+
+ /* Flags needed before volume */
+ pulse_stream_update_flags (pstream, flags);
+
+ pulse_stream_update_channel_map (pstream, &info->channel_map);
+ pulse_stream_update_volume (pstream, &info->volume, 0);
+
+ pulse_stream_update_mute (pstream, info->mute ? TRUE : FALSE);
+
+ pulse_client_stream_update_flags (pclient, client_flags);
+ pulse_client_stream_update_role (pclient, role);
+
+ if (parent != NULL)
+ pulse_client_stream_update_parent (pclient, MATE_MIXER_STREAM (parent));
+ else
+ pulse_client_stream_update_parent (pclient, NULL);
+
+ g_object_thaw_notify (G_OBJECT (pstream));
+ return TRUE;
+}
+
+static void
+pulse_ext_stream_reload (PulseStream *pstream)
+{
+ g_return_if_fail (PULSE_IS_EXT_STREAM (pstream));
+
+ pulse_connection_load_ext_stream_info (pulse_stream_get_connection (pstream));
+}
+
+static gboolean
+pulse_ext_stream_set_mute (PulseStream *pstream, gboolean mute)
+{
+ MateMixerStream *parent;
+ const pa_channel_map *map;
+ const pa_cvolume *cvolume;
+ pa_ext_stream_restore_info info;
+
+ g_return_val_if_fail (PULSE_IS_EXT_STREAM (pstream), FALSE);
+
+ info.name = mate_mixer_stream_get_name (MATE_MIXER_STREAM (pstream));
+ info.mute = mute;
+
+ map = pulse_stream_get_channel_map (pstream);
+ if (map != NULL)
+ info.channel_map = *map;
+ else
+ pa_channel_map_init (&info.channel_map);
+
+ cvolume = pulse_stream_get_cvolume (pstream);
+ if (cvolume != NULL)
+ info.volume = *cvolume;
+ else
+ pa_cvolume_init (&info.volume);
+
+ parent = mate_mixer_client_stream_get_parent (MATE_MIXER_CLIENT_STREAM (pstream));
+ if (parent != NULL)
+ info.device = mate_mixer_stream_get_name (parent);
+ else
+ info.device = NULL;
+
+ return pulse_connection_write_ext_stream (pulse_stream_get_connection (pstream), &info);
+}
+
+static gboolean
+pulse_ext_stream_set_volume (PulseStream *pstream, pa_cvolume *cvolume)
+{
+ MateMixerStream *parent;
+ const pa_channel_map *map;
+ pa_ext_stream_restore_info info;
+
+ g_return_val_if_fail (PULSE_IS_EXT_STREAM (pstream), FALSE);
+ g_return_val_if_fail (cvolume != NULL, FALSE);
+
+ info.name = mate_mixer_stream_get_name (MATE_MIXER_STREAM (pstream));
+ info.mute = mate_mixer_stream_get_mute (MATE_MIXER_STREAM (pstream));
+
+ map = pulse_stream_get_channel_map (pstream);
+ if (map != NULL)
+ info.channel_map = *map;
+ else
+ pa_channel_map_init (&info.channel_map);
+
+ parent = mate_mixer_client_stream_get_parent (MATE_MIXER_CLIENT_STREAM (pstream));
+ if (parent != NULL)
+ info.device = mate_mixer_stream_get_name (parent);
+ else
+ info.device = NULL;
+
+ info.volume = *cvolume;
+
+ return pulse_connection_write_ext_stream (pulse_stream_get_connection (pstream), &info);
+}
+
+static gboolean
+pulse_ext_stream_set_parent (PulseClientStream *pclient, PulseStream *parent)
+{
+ MateMixerStreamFlags flags;
+ PulseStream *pstream;
+ const pa_channel_map *map;
+ const pa_cvolume *cvolume;
+ pa_ext_stream_restore_info info;
+
+ g_return_val_if_fail (PULSE_IS_EXT_STREAM (pclient), FALSE);
+ g_return_val_if_fail (PULSE_IS_STREAM (parent), FALSE);
+
+ flags = mate_mixer_stream_get_flags (MATE_MIXER_STREAM (pclient));
+
+ /* Validate the parent stream */
+ if (flags & MATE_MIXER_STREAM_INPUT && !PULSE_IS_SOURCE (parent)) {
+ g_warning ("Could not change stream parent to %s: not a parent input stream",
+ mate_mixer_stream_get_name (MATE_MIXER_STREAM (parent)));
+ return FALSE;
+ } else if (!PULSE_IS_SINK (parent)) {
+ g_warning ("Could not change stream parent to %s: not a parent output stream",
+ mate_mixer_stream_get_name (MATE_MIXER_STREAM (parent)));
+ return FALSE;
+ }
+
+ pstream = PULSE_STREAM (pclient);
+
+ info.name = mate_mixer_stream_get_name (MATE_MIXER_STREAM (pstream));
+ info.mute = mate_mixer_stream_get_mute (MATE_MIXER_STREAM (pstream));
+
+ map = pulse_stream_get_channel_map (pstream);
+ if (map != NULL)
+ info.channel_map = *map;
+ else
+ pa_channel_map_init (&info.channel_map);
+
+ cvolume = pulse_stream_get_cvolume (pstream);
+ if (cvolume != NULL)
+ info.volume = *cvolume;
+ else
+ pa_cvolume_init (&info.volume);
+
+ info.device = mate_mixer_stream_get_name (MATE_MIXER_STREAM (parent));
+
+ return pulse_connection_write_ext_stream (pulse_stream_get_connection (pstream), &info);
+}
+
+static gboolean
+pulse_ext_stream_remove (PulseClientStream *pclient)
+{
+ PulseStream *pstream;
+ const gchar *name;
+
+ g_return_val_if_fail (PULSE_IS_EXT_STREAM (pclient), FALSE);
+
+ pstream = PULSE_STREAM (pclient);
+ name = mate_mixer_stream_get_name (MATE_MIXER_STREAM (pstream));
+
+ return pulse_connection_delete_ext_stream (pulse_stream_get_connection (pstream), name);
+}
diff --git a/backends/pulse/pulse-ext-stream.h b/backends/pulse/pulse-ext-stream.h
new file mode 100644
index 0000000..e8dabb6
--- /dev/null
+++ b/backends/pulse/pulse-ext-stream.h
@@ -0,0 +1,71 @@
+/*
+ * 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 PULSE_EXT_STREAM_H
+#define PULSE_EXT_STREAM_H
+
+#include <glib.h>
+#include <glib-object.h>
+
+#include <pulse/pulseaudio.h>
+#include <pulse/ext-stream-restore.h>
+
+#include "pulse-client-stream.h"
+#include "pulse-connection.h"
+#include "pulse-stream.h"
+
+G_BEGIN_DECLS
+
+#define PULSE_TYPE_EXT_STREAM \
+ (pulse_ext_stream_get_type ())
+#define PULSE_EXT_STREAM(o) \
+ (G_TYPE_CHECK_INSTANCE_CAST ((o), PULSE_TYPE_EXT_STREAM, PulseExtStream))
+#define PULSE_IS_EXT_STREAM(o) \
+ (G_TYPE_CHECK_INSTANCE_TYPE ((o), PULSE_TYPE_EXT_STREAM))
+#define PULSE_EXT_STREAM_CLASS(k) \
+ (G_TYPE_CHECK_CLASS_CAST ((k), PULSE_TYPE_EXT_STREAM, PulseExtStreamClass))
+#define PULSE_IS_EXT_STREAM_CLASS(k) \
+ (G_TYPE_CHECK_CLASS_TYPE ((k), PULSE_TYPE_EXT_STREAM))
+#define PULSE_EXT_STREAM_GET_CLASS(o) \
+ (G_TYPE_INSTANCE_GET_CLASS ((o), PULSE_TYPE_EXT_STREAM, PulseExtStreamClass))
+
+typedef struct _PulseExtStream PulseExtStream;
+typedef struct _PulseExtStreamClass PulseExtStreamClass;
+
+struct _PulseExtStream
+{
+ PulseClientStream parent;
+};
+
+struct _PulseExtStreamClass
+{
+ PulseClientStreamClass parent_class;
+};
+
+GType pulse_ext_stream_get_type (void) G_GNUC_CONST;
+
+PulseStream *pulse_ext_stream_new (PulseConnection *connection,
+ const pa_ext_stream_restore_info *info,
+ PulseStream *parent);
+
+gboolean pulse_ext_stream_update (PulseStream *pstream,
+ const pa_ext_stream_restore_info *info,
+ PulseStream *parent);
+
+G_END_DECLS
+
+#endif /* PULSE_EXT_STREAM_H */
diff --git a/backends/pulse/pulse-helpers.c b/backends/pulse/pulse-helpers.c
index ca39d8f..577f2c6 100644
--- a/backends/pulse/pulse-helpers.c
+++ b/backends/pulse/pulse-helpers.c
@@ -15,9 +15,11 @@
 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <string.h>
 #include <glib.h>
 
 #include <libmatemixer/matemixer-enums.h>
+
 #include <pulse/pulseaudio.h>
 
 #include "pulse-helpers.h"
@@ -28,44 +30,44 @@ typedef struct {
 } PositionMap;
 
 static PositionMap const position_map[] = {
- { MATE_MIXER_CHANNEL_UNKNOWN_POSITION, PA_CHANNEL_POSITION_INVALID },
- { MATE_MIXER_CHANNEL_MONO, PA_CHANNEL_POSITION_MONO },
- { MATE_MIXER_CHANNEL_FRONT_LEFT, PA_CHANNEL_POSITION_FRONT_LEFT },
- { MATE_MIXER_CHANNEL_FRONT_RIGHT, PA_CHANNEL_POSITION_FRONT_RIGHT },
- { MATE_MIXER_CHANNEL_FRONT_CENTER, PA_CHANNEL_POSITION_FRONT_CENTER },
- { MATE_MIXER_CHANNEL_LFE, PA_CHANNEL_POSITION_LFE },
- { MATE_MIXER_CHANNEL_BACK_LEFT, PA_CHANNEL_POSITION_REAR_LEFT },
- { MATE_MIXER_CHANNEL_BACK_RIGHT, PA_CHANNEL_POSITION_REAR_RIGHT },
- { MATE_MIXER_CHANNEL_FRONT_LEFT_CENTER, PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER },
- { MATE_MIXER_CHANNEL_FRONT_RIGHT_CENTER, PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER },
- { MATE_MIXER_CHANNEL_BACK_CENTER, PA_CHANNEL_POSITION_REAR_CENTER },
- { MATE_MIXER_CHANNEL_SIDE_LEFT, PA_CHANNEL_POSITION_SIDE_LEFT },
- { MATE_MIXER_CHANNEL_SIDE_RIGHT, PA_CHANNEL_POSITION_SIDE_RIGHT },
- { MATE_MIXER_CHANNEL_TOP_FRONT_LEFT, PA_CHANNEL_POSITION_TOP_FRONT_LEFT },
- { MATE_MIXER_CHANNEL_TOP_FRONT_RIGHT, PA_CHANNEL_POSITION_TOP_FRONT_RIGHT },
- { MATE_MIXER_CHANNEL_TOP_FRONT_CENTER, PA_CHANNEL_POSITION_TOP_FRONT_CENTER },
- { MATE_MIXER_CHANNEL_TOP_CENTER, PA_CHANNEL_POSITION_TOP_CENTER },
- { MATE_MIXER_CHANNEL_TOP_BACK_LEFT, PA_CHANNEL_POSITION_TOP_REAR_LEFT },
- { MATE_MIXER_CHANNEL_TOP_BACK_RIGHT, PA_CHANNEL_POSITION_TOP_REAR_RIGHT },
- { MATE_MIXER_CHANNEL_TOP_BACK_CENTER, PA_CHANNEL_POSITION_TOP_REAR_CENTER },
+ { MATE_MIXER_CHANNEL_UNKNOWN, PA_CHANNEL_POSITION_INVALID },
+ { MATE_MIXER_CHANNEL_MONO, PA_CHANNEL_POSITION_MONO },
+ { MATE_MIXER_CHANNEL_FRONT_LEFT, PA_CHANNEL_POSITION_FRONT_LEFT },
+ { MATE_MIXER_CHANNEL_FRONT_RIGHT, PA_CHANNEL_POSITION_FRONT_RIGHT },
+ { MATE_MIXER_CHANNEL_FRONT_CENTER, PA_CHANNEL_POSITION_FRONT_CENTER },
+ { MATE_MIXER_CHANNEL_LFE, PA_CHANNEL_POSITION_LFE },
+ { MATE_MIXER_CHANNEL_BACK_LEFT, PA_CHANNEL_POSITION_REAR_LEFT },
+ { MATE_MIXER_CHANNEL_BACK_RIGHT, PA_CHANNEL_POSITION_REAR_RIGHT },
+ { MATE_MIXER_CHANNEL_BACK_CENTER, PA_CHANNEL_POSITION_REAR_CENTER },
+ { MATE_MIXER_CHANNEL_FRONT_LEFT_CENTER, PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER },
+ { MATE_MIXER_CHANNEL_FRONT_RIGHT_CENTER, PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER },
+ { MATE_MIXER_CHANNEL_SIDE_LEFT, PA_CHANNEL_POSITION_SIDE_LEFT },
+ { MATE_MIXER_CHANNEL_SIDE_RIGHT, PA_CHANNEL_POSITION_SIDE_RIGHT },
+ { MATE_MIXER_CHANNEL_TOP_FRONT_LEFT, PA_CHANNEL_POSITION_TOP_FRONT_LEFT },
+ { MATE_MIXER_CHANNEL_TOP_FRONT_RIGHT, PA_CHANNEL_POSITION_TOP_FRONT_RIGHT },
+ { MATE_MIXER_CHANNEL_TOP_FRONT_CENTER, PA_CHANNEL_POSITION_TOP_FRONT_CENTER },
+ { MATE_MIXER_CHANNEL_TOP_CENTER, PA_CHANNEL_POSITION_TOP_CENTER },
+ { MATE_MIXER_CHANNEL_TOP_BACK_LEFT, PA_CHANNEL_POSITION_TOP_REAR_LEFT },
+ { MATE_MIXER_CHANNEL_TOP_BACK_RIGHT, PA_CHANNEL_POSITION_TOP_REAR_RIGHT },
+ { MATE_MIXER_CHANNEL_TOP_BACK_CENTER, PA_CHANNEL_POSITION_TOP_REAR_CENTER },
 };
 
 MateMixerChannelPosition
 pulse_convert_position_from_pulse (pa_channel_position_t position)
 {
- int i;
+ guint i;
 
 for (i = 0; i < G_N_ELEMENTS (position_map); i++) {
 if (position == position_map[i].pa_position)
 return position_map[i].mm_position;
 }
- return MATE_MIXER_CHANNEL_UNKNOWN_POSITION;
+ return MATE_MIXER_CHANNEL_UNKNOWN;
 }
 
 pa_channel_position_t
 pulse_convert_position_to_pulse (MateMixerChannelPosition position)
 {
- int i;
+ guint i;
 
 for (i = 0; i < G_N_ELEMENTS (position_map); i++) {
 if (position == position_map[i].mm_position)
@@ -73,3 +75,43 @@ pulse_convert_position_to_pulse (MateMixerChannelPosition position)
 }
 return PA_CHANNEL_POSITION_INVALID;
 }
+
+MateMixerClientStreamRole
+pulse_convert_media_role_name (const gchar *name)
+{
+ if (!strcmp (name, "video")) {
+ return MATE_MIXER_CLIENT_STREAM_ROLE_VIDEO;
+ }
+ else if (!strcmp (name, "music")) {
+ return MATE_MIXER_CLIENT_STREAM_ROLE_MUSIC;
+ }
+ else if (!strcmp (name, "game")) {
+ return MATE_MIXER_CLIENT_STREAM_ROLE_GAME;
+ }
+ else if (!strcmp (name, "event")) {
+ return MATE_MIXER_CLIENT_STREAM_ROLE_EVENT;
+ }
+ else if (!strcmp (name, "phone")) {
+ return MATE_MIXER_CLIENT_STREAM_ROLE_PHONE;
+ }
+ else if (!strcmp (name, "animation")) {
+ return MATE_MIXER_CLIENT_STREAM_ROLE_ANIMATION;
+ }
+ else if (!strcmp (name, "production")) {
+ return MATE_MIXER_CLIENT_STREAM_ROLE_PRODUCTION;
+ }
+ else if (!strcmp (name, "a11y")) {
+ return MATE_MIXER_CLIENT_STREAM_ROLE_A11Y;
+ }
+ else if (!strcmp (name, "test")) {
+ return MATE_MIXER_CLIENT_STREAM_ROLE_TEST;
+ }
+ else if (!strcmp (name, "abstract")) {
+ return MATE_MIXER_CLIENT_STREAM_ROLE_ABSTRACT;
+ }
+ else if (!strcmp (name, "filter")) {
+ return MATE_MIXER_CLIENT_STREAM_ROLE_FILTER;
+ }
+
+ return MATE_MIXER_CLIENT_STREAM_ROLE_NONE;
+}
diff --git a/backends/pulse/pulse-helpers.h b/backends/pulse/pulse-helpers.h
index efc8fc9..7ccd753 100644
--- a/backends/pulse/pulse-helpers.h
+++ b/backends/pulse/pulse-helpers.h
@@ -26,8 +26,10 @@
 
 G_BEGIN_DECLS
 
-MateMixerChannelPosition pulse_convert_position_from_pulse (pa_channel_position_t position);
-pa_channel_position_t pulse_convert_position_to_pulse (MateMixerChannelPosition position);
+MateMixerChannelPosition pulse_convert_position_from_pulse (pa_channel_position_t position);
+pa_channel_position_t pulse_convert_position_to_pulse (MateMixerChannelPosition position);
+
+MateMixerClientStreamRole pulse_convert_media_role_name (const gchar *name);
 
 G_END_DECLS
 
diff --git a/backends/pulse/pulse-monitor.c b/backends/pulse/pulse-monitor.c
index 041f903..3d5b4a8 100644
--- a/backends/pulse/pulse-monitor.c
+++ b/backends/pulse/pulse-monitor.c
@@ -34,23 +34,44 @@ struct _PulseMonitorPrivate
 };
 
 enum {
+ PROP_0,
+ PROP_ENABLED,
+ PROP_NAME,
+ PROP_INDEX_SOURCE,
+ PROP_INDEX_SINK_INPUT,
+ N_PROPERTIES
+};
+
+static GParamSpec *properties[N_PROPERTIES] = { NULL, };
+
+enum {
 VALUE,
 N_SIGNALS
 };
 
 static guint signals[N_SIGNALS] = { 0, };
 
-static void pulse_monitor_class_init (PulseMonitorClass *klass);
-static void pulse_monitor_init (PulseMonitor *port);
-static void pulse_monitor_finalize (GObject *object);
+static void pulse_monitor_class_init (PulseMonitorClass *klass);
+
+static void pulse_monitor_get_property (GObject *object,
+ guint param_id,
+ GValue *value,
+ GParamSpec *pspec);
+static void pulse_monitor_set_property (GObject *object,
+ guint param_id,
+ const GValue *value,
+ GParamSpec *pspec);
+
+static void pulse_monitor_init (PulseMonitor *monitor);
+static void pulse_monitor_finalize (GObject *object);
 
 G_DEFINE_TYPE (PulseMonitor, pulse_monitor, G_TYPE_OBJECT);
 
-static gboolean monitor_prepare (PulseMonitor *monitor);
-static gboolean monitor_connect_record (PulseMonitor *monitor);
-static void monitor_read_cb (pa_stream *stream,
- size_t length,
- void *userdata);
+static gboolean stream_connect (PulseMonitor *monitor);
+
+static void stream_read_cb (pa_stream *stream,
+ size_t length,
+ void *userdata);
 
 static void
 pulse_monitor_class_init (PulseMonitorClass *klass)
@@ -58,7 +79,50 @@ pulse_monitor_class_init (PulseMonitorClass *klass)
 GObjectClass *object_class;
 
 object_class = G_OBJECT_CLASS (klass);
- object_class->finalize = pulse_monitor_finalize;
+ object_class->finalize = pulse_monitor_finalize;
+ object_class->get_property = pulse_monitor_get_property;
+ object_class->set_property = pulse_monitor_set_property;
+
+ properties[PROP_ENABLED] =
+ g_param_spec_boolean ("enabled",
+ "Enabled",
+ "Monitor enabled",
+ FALSE,
+ G_PARAM_READABLE |
+ G_PARAM_STATIC_STRINGS);
+
+ properties[PROP_NAME] =
+ g_param_spec_string ("name",
+ "Name",
+ "Name of the monitor",
+ NULL,
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT |
+ G_PARAM_STATIC_STRINGS);
+
+ properties[PROP_INDEX_SOURCE] =
+ g_param_spec_uint ("index-source",
+ "Index of source",
+ "Index of the PulseAudio source",
+ 0,
+ G_MAXUINT,
+ 0,
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_STATIC_STRINGS);
+
+ properties[PROP_INDEX_SINK_INPUT] =
+ g_param_spec_uint ("index-sink-input",
+ "Index of sink input",
+ "Index of the PulseAudio sink input",
+ 0,
+ G_MAXUINT,
+ 0,
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_STATIC_STRINGS);
+
+ g_object_class_install_properties (object_class, N_PROPERTIES, properties);
 
 signals[VALUE] =
 g_signal_new ("value",
@@ -76,6 +140,61 @@ pulse_monitor_class_init (PulseMonitorClass *klass)
 }
 
 static void
+pulse_monitor_get_property (GObject *object,
+ guint param_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ PulseMonitor *monitor;
+
+ monitor = PULSE_MONITOR (object);
+
+ switch (param_id) {
+ case PROP_ENABLED:
+ g_value_set_boolean (value, monitor->priv->enabled);
+ break;
+ case PROP_NAME:
+ g_value_set_string (value, monitor->priv->name);
+ break;
+ case PROP_INDEX_SOURCE:
+ g_value_set_uint (value, monitor->priv->index_source);
+ break;
+ case PROP_INDEX_SINK_INPUT:
+ g_value_set_uint (value, monitor->priv->index_sink_input);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+ break;
+ }
+}
+
+static void
+pulse_monitor_set_property (GObject *object,
+ guint param_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ PulseMonitor *monitor;
+
+ monitor = PULSE_MONITOR (object);
+
+ switch (param_id) {
+ case PROP_NAME:
+ pulse_monitor_set_name (monitor, g_value_get_string (value));
+ break;
+ case PROP_INDEX_SOURCE:
+ monitor->priv->index_source = g_value_get_uint (value);
+ break;
+ case PROP_INDEX_SINK_INPUT:
+ monitor->priv->index_sink_input = g_value_get_uint (value);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
+ break;
+ }
+}
+
+static void
 pulse_monitor_init (PulseMonitor *monitor)
 {
 monitor->priv = G_TYPE_INSTANCE_GET_PRIVATE (monitor,
@@ -90,70 +209,46 @@ pulse_monitor_finalize (GObject *object)
 
 monitor = PULSE_MONITOR (object);
 
- if (monitor->priv->stream)
+ /* The pulse stream may exist if the monitor is running */
+ if (monitor->priv->stream != NULL) {
+ pa_stream_disconnect (monitor->priv->stream);
 pa_stream_unref (monitor->priv->stream);
+ }
 
 pa_context_unref (monitor->priv->context);
 pa_proplist_free (monitor->priv->proplist);
 
+ g_free (monitor->priv->name);
+
 G_OBJECT_CLASS (pulse_monitor_parent_class)->finalize (object);
 }
 
 PulseMonitor *
 pulse_monitor_new (pa_context *context,
 pa_proplist *proplist,
+ const gchar *name,
 guint32 index_source,
 guint32 index_sink_input)
 {
 PulseMonitor *monitor;
 
- monitor = g_object_new (PULSE_TYPE_MONITOR, NULL);
+ g_return_val_if_fail (context != NULL, NULL);
+ g_return_val_if_fail (proplist != NULL, NULL);
+
+ monitor = g_object_new (PULSE_TYPE_MONITOR,
+ "name", name,
+ "index-source", index_source,
+ "index-sink-input", index_sink_input,
+ NULL);
 
 monitor->priv->context = pa_context_ref (context);
 monitor->priv->proplist = pa_proplist_copy (proplist);
 
- monitor->priv->index_source = index_source;
- monitor->priv->index_sink_input = index_sink_input;
-
 return monitor;
 }
 
 gboolean
-pulse_monitor_enable (PulseMonitor *monitor)
-{
- g_return_val_if_fail (PULSE_IS_MONITOR (monitor), FALSE);
-
- if (!monitor->priv->enabled) {
- if (monitor->priv->stream == NULL)
- monitor_prepare (monitor);
-
- if (G_LIKELY (monitor->priv->stream != NULL))
- monitor->priv->enabled = monitor_connect_record (monitor);
- }
-
- return monitor->priv->enabled;
-}
-
-void
-pulse_monitor_disable (PulseMonitor *monitor)
-{
- g_return_if_fail (PULSE_IS_MONITOR (monitor));
-
- if (!monitor->priv->enabled)
- return;
-
- pa_stream_disconnect (monitor->priv->stream);
-
- // XXX stream must be destroyed on disable, re-enabling does not work, this
- // is just a quick temporary solution
- pa_stream_unref (monitor->priv->stream);
- monitor->priv->stream = NULL;
-
- monitor->priv->enabled = FALSE;
-}
-
-gboolean
-pulse_monitor_is_enabled (PulseMonitor *monitor)
+pulse_monitor_get_enabled (PulseMonitor *monitor)
 {
 g_return_val_if_fail (PULSE_IS_MONITOR (monitor), FALSE);
 
@@ -161,30 +256,27 @@ pulse_monitor_is_enabled (PulseMonitor *monitor)
 }
 
 gboolean
-pulse_monitor_update_index (PulseMonitor *monitor,
- guint32 index_source,
- guint32 index_sink_input)
+pulse_monitor_set_enabled (PulseMonitor *monitor, gboolean enabled)
 {
 g_return_val_if_fail (PULSE_IS_MONITOR (monitor), FALSE);
 
- if (monitor->priv->index_source == index_source &&
- monitor->priv->index_sink_input == index_sink_input)
+ if (enabled == monitor->priv->enabled)
 return TRUE;
 
- monitor->priv->index_source = index_source;
- monitor->priv->index_sink_input = index_sink_input;
-
- if (pulse_monitor_is_enabled (monitor)) {
- pulse_monitor_disable (monitor);
+ if (enabled) {
+ monitor->priv->enabled = stream_connect (monitor);
 
- /* Unset the Pulse stream to let enabling recreate it */
- g_clear_pointer (&monitor->priv->stream, pa_stream_unref);
+ if (monitor->priv->enabled == FALSE)
+ return FALSE;
+ } else {
+ pa_stream_disconnect (monitor->priv->stream);
+ pa_stream_unref (monitor->priv->stream);
 
- pulse_monitor_enable (monitor);
- } else if (monitor->priv->stream) {
- /* Disabled now but was enabled before and still holds source index */
- g_clear_pointer (&monitor->priv->stream, pa_stream_unref);
+ monitor->priv->stream = NULL;
+ monitor->priv->enabled = FALSE;
 }
+ g_object_notify_by_pspec (G_OBJECT (monitor), properties[PROP_ENABLED]);
+
 return TRUE;
 }
 
@@ -201,21 +293,32 @@ pulse_monitor_set_name (PulseMonitor *monitor, const gchar *name)
 {
 g_return_val_if_fail (PULSE_IS_MONITOR (monitor), FALSE);
 
- g_free (monitor->priv->name);
+ if (g_strcmp0 (name, monitor->priv->name) != 0) {
+ g_free (monitor->priv->name);
+ monitor->priv->name = g_strdup (name);
 
- monitor->priv->name = g_strdup (name);
+ g_object_notify_by_pspec (G_OBJECT (monitor), properties[PROP_NAME]);
+ }
 return TRUE;
 }
 
 static gboolean
-monitor_prepare (PulseMonitor *monitor)
+stream_connect (PulseMonitor *monitor)
 {
 pa_sample_spec spec;
+ pa_buffer_attr attr;
 const gchar *name;
+ gchar *idx;
+ int ret;
 
- spec.channels = 1;
- spec.format = PA_SAMPLE_FLOAT32;
- spec.rate = 25;
+ attr.maxlength = (guint32) -1;
+ attr.tlength = 0;
+ attr.prebuf = 0;
+ attr.minreq = 0;
+ attr.fragsize = sizeof (gfloat);
+ spec.channels = 1;
+ spec.format = PA_SAMPLE_FLOAT32;
+ spec.rate = 25;
 
 if (monitor->priv->name != NULL)
 name = monitor->priv->name;
@@ -230,60 +333,58 @@ monitor_prepare (PulseMonitor *monitor)
 monitor->priv->proplist);
 
 if (G_UNLIKELY (monitor->priv->stream == NULL)) {
- g_warning ("Failed to create PulseAudio monitor: %s",
+ g_warning ("Failed to create peak monitor: %s",
 pa_strerror (pa_context_errno (monitor->priv->context)));
 return FALSE;
 }
 
+ /* Set sink input index for the stream, source outputs are not supported */
 if (monitor->priv->index_sink_input != PA_INVALID_INDEX)
 pa_stream_set_monitor_stream (monitor->priv->stream,
 monitor->priv->index_sink_input);
 
 pa_stream_set_read_callback (monitor->priv->stream,
- monitor_read_cb,
+ stream_read_cb,
 monitor);
- return TRUE;
-}
-
-static gboolean
-monitor_connect_record (PulseMonitor *monitor)
-{
- pa_buffer_attr attr;
- gchar *name;
- int ret;
 
- attr.maxlength = (guint32) -1;
- attr.tlength = 0;
- attr.prebuf = 0;
- attr.minreq = 0;
- attr.fragsize = sizeof (gfloat);
-
- name = g_strdup_printf ("%u", monitor->priv->index_source);
- ret = pa_stream_connect_record (monitor->priv->stream,
- name,
- &attr,
- PA_STREAM_DONT_MOVE |
- PA_STREAM_PEAK_DETECT |
- PA_STREAM_ADJUST_LATENCY |
- PA_STREAM_DONT_INHIBIT_AUTO_SUSPEND);
- g_free (name);
+ /* Source index must be passed as a string */
+ idx = g_strdup_printf ("%u", monitor->priv->index_source);
+ ret = pa_stream_connect_record (monitor->priv->stream,
+ idx,
+ &attr,
+ PA_STREAM_DONT_MOVE |
+ PA_STREAM_PEAK_DETECT |
+ PA_STREAM_ADJUST_LATENCY);
+ g_free (idx);
 
 if (ret < 0) {
- g_warning ("Failed to connect PulseAudio monitor: %s", pa_strerror (ret));
+ g_warning ("Failed to connect peak monitor: %s", pa_strerror (ret));
 return FALSE;
 }
 return TRUE;
 }
 
 static void
-monitor_read_cb (pa_stream *stream, size_t length, void *userdata)
+stream_read_cb (pa_stream *stream, size_t length, void *userdata)
 {
 const void *data;
 
+ /* Read the next fragment from the buffer (for recording streams).
+ *
+ * If there is data at the current read index, data will point to the
+ * actual data and length will contain the size of the data in bytes
+ * (which can be less or more than a complete fragment).
+ *
+ * If there is no data at the current read index, it means that either
+ * the buffer is empty or it contains a hole (that is, the write index
+ * is ahead of the read index but there's no data where the read index
+ * points at). If the buffer is empty, data will be NULL and length will
+ * be 0. If there is a hole, data will be NULL and length will contain
+ * the length of the hole. */
 if (pa_stream_peek (stream, &data, &length) < 0)
 return;
 
- if (data) {
+ if (data != NULL) {
 gdouble v = ((const gfloat *) data)[length / sizeof (gfloat) - 1];
 
 g_signal_emit (G_OBJECT (userdata),
@@ -294,6 +395,6 @@ monitor_read_cb (pa_stream *stream, size_t length, void *userdata)
 
 /* pa_stream_drop() should not be called if the buffer is empty, but it
 * should be called if there is a hole */
- if (length)
+ if (length > 0)
 pa_stream_drop (stream);
 }
diff --git a/backends/pulse/pulse-monitor.h b/backends/pulse/pulse-monitor.h
index b3f6f89..41147f5 100644
--- a/backends/pulse/pulse-monitor.h
+++ b/backends/pulse/pulse-monitor.h
@@ -63,21 +63,18 @@ GType pulse_monitor_get_type (void) G_GNUC_CONST;
 
 PulseMonitor *pulse_monitor_new (pa_context *context,
 pa_proplist *proplist,
+ const gchar *name,
 guint32 index_source,
 guint32 index_sink_input);
 
-gboolean pulse_monitor_enable (PulseMonitor *monitor);
-void pulse_monitor_disable (PulseMonitor *monitor);
-gboolean pulse_monitor_is_enabled (PulseMonitor *monitor);
+gboolean pulse_monitor_get_enabled (PulseMonitor *monitor);
+gboolean pulse_monitor_set_enabled (PulseMonitor *monitor,
+ gboolean enabled);
 
 const gchar * pulse_monitor_get_name (PulseMonitor *monitor);
 gboolean pulse_monitor_set_name (PulseMonitor *monitor,
 const gchar *name);
 
-gboolean pulse_monitor_update_index (PulseMonitor *monitor,
- guint32 index_source,
- guint32 index_sink_input);
-
 G_END_DECLS
 
 #endif /* PULSE_MONITOR_H */
diff --git a/backends/pulse/pulse-sink-input.c b/backends/pulse/pulse-sink-input.c
index 051b351..54cd3b3 100644
--- a/backends/pulse/pulse-sink-input.c
+++ b/backends/pulse/pulse-sink-input.c
@@ -20,12 +20,14 @@
 #include <glib-object.h>
 
 #include <libmatemixer/matemixer-client-stream.h>
+#include <libmatemixer/matemixer-enums.h>
 #include <libmatemixer/matemixer-stream.h>
 
 #include <pulse/pulseaudio.h>
 
 #include "pulse-connection.h"
 #include "pulse-client-stream.h"
+#include "pulse-helpers.h"
 #include "pulse-monitor.h"
 #include "pulse-sink.h"
 #include "pulse-sink-input.h"
@@ -36,14 +38,16 @@ static void pulse_sink_input_init (PulseSinkInput *input);
 
 G_DEFINE_TYPE (PulseSinkInput, pulse_sink_input, PULSE_TYPE_CLIENT_STREAM);
 
-static gboolean sink_input_set_mute (MateMixerStream *stream,
- gboolean mute);
-static gboolean sink_input_set_volume (MateMixerStream *stream,
- pa_cvolume *volume);
-static gboolean sink_input_set_parent (MateMixerClientStream *stream,
- MateMixerStream *parent);
-static gboolean sink_input_remove (MateMixerClientStream *stream);
-static PulseMonitor *sink_input_create_monitor (MateMixerStream *stream);
+static void pulse_sink_input_reload (PulseStream *pstream);
+
+static gboolean pulse_sink_input_set_mute (PulseStream *pstream,
+ gboolean mute);
+static gboolean pulse_sink_input_set_volume (PulseStream *pstream,
+ pa_cvolume *cvolume);
+static gboolean pulse_sink_input_set_parent (PulseClientStream *pclient,
+ PulseStream *parent);
+static gboolean pulse_sink_input_remove (PulseClientStream *pclient);
+static PulseMonitor *pulse_sink_input_create_monitor (PulseStream *pstream);
 
 static void
 pulse_sink_input_class_init (PulseSinkInputClass *klass)
@@ -53,14 +57,15 @@ pulse_sink_input_class_init (PulseSinkInputClass *klass)
 
 stream_class = PULSE_STREAM_CLASS (klass);
 
- stream_class->set_mute = sink_input_set_mute;
- stream_class->set_volume = sink_input_set_volume;
- stream_class->create_monitor = sink_input_create_monitor;
+ stream_class->reload = pulse_sink_input_reload;
+ stream_class->set_mute = pulse_sink_input_set_mute;
+ stream_class->set_volume = pulse_sink_input_set_volume;
+ stream_class->create_monitor = pulse_sink_input_create_monitor;
 
 client_class = PULSE_CLIENT_STREAM_CLASS (klass);
 
- client_class->set_parent = sink_input_set_parent;
- client_class->remove = sink_input_remove;
+ client_class->set_parent = pulse_sink_input_set_parent;
+ client_class->remove = pulse_sink_input_remove;
 }
 
 static void
@@ -91,7 +96,7 @@ pulse_sink_input_new (PulseConnection *connection,
 }
 
 gboolean
-pulse_sink_input_update (PulseStream *stream,
+pulse_sink_input_update (PulseStream *pstream,
 const pa_sink_input_info *info,
 PulseStream *parent)
 {
@@ -99,66 +104,81 @@ pulse_sink_input_update (PulseStream *stream,
 MATE_MIXER_STREAM_CLIENT |
 MATE_MIXER_STREAM_HAS_MUTE |
 MATE_MIXER_STREAM_HAS_MONITOR;
- gchar *name;
+ PulseClientStream *pclient;
+ const gchar *prop;
+ const gchar *description = NULL;
+ gchar *name;
 
- const gchar *prop;
- const gchar *description = NULL;
+ g_return_val_if_fail (PULSE_IS_SINK_INPUT (pstream), FALSE);
+ g_return_val_if_fail (info != NULL, FALSE);
 
- g_return_val_if_fail (PULSE_IS_SINK_INPUT (stream), FALSE);
+ pclient = PULSE_CLIENT_STREAM (pstream);
 
 /* Let all the information update before emitting notify signals */
- g_object_freeze_notify (G_OBJECT (stream));
+ g_object_freeze_notify (G_OBJECT (pstream));
 
 /* Many mixer applications query the Pulse client list and use the client
 * name here, but we use the name only as an identifier, so let's avoid
 * this unnecessary overhead and use a custom name.
- * Also make sure to make the name unique by including the Pulse index. */
+ * Also make sure to make the name unique by including the PulseAudio index. */
 name = g_strdup_printf ("pulse-stream-client-output-%lu", (gulong) info->index);
 
- pulse_stream_update_name (stream, name);
+ pulse_stream_update_name (pstream, name);
 g_free (name);
 
 prop = pa_proplist_gets (info->proplist, PA_PROP_MEDIA_ROLE);
+ if (prop != NULL) {
+ MateMixerClientStreamRole role = pulse_convert_media_role_name (prop);
 
- if (prop != NULL && !strcmp (prop, "event")) {
- /* The event description seems to provide much better readable
- * description for event streams */
- prop = pa_proplist_gets (info->proplist, PA_PROP_EVENT_DESCRIPTION);
+ if (role == MATE_MIXER_CLIENT_STREAM_ROLE_EVENT) {
+ /* The event description seems to provide much better readable
+ * description for event streams */
+ prop = pa_proplist_gets (info->proplist, PA_PROP_EVENT_DESCRIPTION);
 
- if (G_LIKELY (prop != NULL))
- description = prop;
+ if (G_LIKELY (prop != NULL))
+ description = prop;
+ }
+ pulse_client_stream_update_role (pclient, role);
+ } else
+ pulse_client_stream_update_role (pclient, MATE_MIXER_CLIENT_STREAM_ROLE_NONE);
 
- flags |= MATE_MIXER_STREAM_EVENT;
- }
 if (description == NULL)
 description = info->name;
 
- pulse_stream_update_description (stream, description);
- pulse_stream_update_mute (stream, info->mute ? TRUE : FALSE);
+ pulse_stream_update_description (pstream, description);
+ pulse_stream_update_mute (pstream, info->mute ? TRUE : FALSE);
 
 if (info->client != PA_INVALID_INDEX)
- flags |= MATE_MIXER_STREAM_APPLICATION;
+ pulse_client_stream_update_flags (pclient, MATE_MIXER_CLIENT_STREAM_APPLICATION);
+ else
+ pulse_client_stream_update_flags (pclient, MATE_MIXER_CLIENT_STREAM_NO_FLAGS);
+
+ if (G_LIKELY (parent != NULL)) {
+ if (pulse_sink_get_monitor_index (parent) != PA_INVALID_INDEX)
+ flags |= MATE_MIXER_STREAM_HAS_MONITOR;
 
- if (pa_channel_map_can_balance (&info->channel_map))
- flags |= MATE_MIXER_STREAM_CAN_BALANCE;
- if (pa_channel_map_can_fade (&info->channel_map))
- flags |= MATE_MIXER_STREAM_CAN_FADE;
+ pulse_client_stream_update_parent (pclient, MATE_MIXER_STREAM (parent));
+ } else
+ pulse_client_stream_update_parent (pclient, NULL);
 
 #if PA_CHECK_VERSION(1, 0, 0)
- if (info->has_volume)
+ if (info->has_volume) {
 flags |=
 MATE_MIXER_STREAM_HAS_VOLUME |
 MATE_MIXER_STREAM_HAS_DECIBEL_VOLUME;
- if (info->volume_writable)
- flags |= MATE_MIXER_STREAM_CAN_SET_VOLUME;
+
+ if (info->volume_writable)
+ flags |= MATE_MIXER_STREAM_CAN_SET_VOLUME;
+ }
 
 /* Flags needed before volume */
- pulse_stream_update_flags (stream, flags);
+ pulse_stream_update_flags (pstream, flags);
+ pulse_stream_update_channel_map (pstream, &info->channel_map);
 
 if (info->has_volume)
- pulse_stream_update_volume (stream, &info->volume, &info->channel_map, 0);
+ pulse_stream_update_volume (pstream, &info->volume, 0);
 else
- pulse_stream_update_volume (stream, NULL, &info->channel_map, 0);
+ pulse_stream_update_volume (pstream, NULL, 0);
 #else
 /* Pre-1.0 PulseAudio does not include the has_volume and volume_writable
 * fields, but does include the volume info, so let's give it a try */
@@ -168,127 +188,121 @@ pulse_sink_input_update (PulseStream *stream,
 MATE_MIXER_STREAM_CAN_SET_VOLUME;
 
 /* Flags needed before volume */
- pulse_stream_update_flags (stream, flags);
+ pulse_stream_update_flags (pstream, flags);
+ pulse_stream_update_channel_map (pstream, &info->channel_map);
 
- pulse_stream_update_volume (stream, &info->volume, &info->channel_map, 0);
+ pulse_stream_update_volume (pstream, &info->volume, 0);
 #endif
 
 prop = pa_proplist_gets (info->proplist, PA_PROP_APPLICATION_NAME);
 if (prop != NULL)
- pulse_client_stream_update_app_name (PULSE_CLIENT_STREAM (stream), prop);
+ pulse_client_stream_update_app_name (pclient, prop);
 
 prop = pa_proplist_gets (info->proplist, PA_PROP_APPLICATION_ID);
 if (prop != NULL)
- pulse_client_stream_update_app_id (PULSE_CLIENT_STREAM (stream), prop);
+ pulse_client_stream_update_app_id (pclient, prop);
 
 prop = pa_proplist_gets (info->proplist, PA_PROP_APPLICATION_VERSION);
 if (prop != NULL)
- pulse_client_stream_update_app_version (PULSE_CLIENT_STREAM (stream), prop);
+ pulse_client_stream_update_app_version (pclient, prop);
 
 prop = pa_proplist_gets (info->proplist, PA_PROP_APPLICATION_ICON_NAME);
 if (prop != NULL)
- pulse_client_stream_update_app_icon (PULSE_CLIENT_STREAM (stream), prop);
-
- if (G_LIKELY (parent != NULL))
- pulse_client_stream_update_parent (PULSE_CLIENT_STREAM (stream),
- MATE_MIXER_STREAM (parent));
- else
- pulse_client_stream_update_parent (PULSE_CLIENT_STREAM (stream), NULL);
+ pulse_client_stream_update_app_icon (pclient, prop);
 
 // XXX needs to fix monitor if parent changes
 
- g_object_thaw_notify (G_OBJECT (stream));
+ g_object_thaw_notify (G_OBJECT (pstream));
 return TRUE;
 }
 
-static gboolean
-sink_input_set_mute (MateMixerStream *stream, gboolean mute)
+static void
+pulse_sink_input_reload (PulseStream *pstream)
 {
- PulseStream *pulse;
+ g_return_if_fail (PULSE_IS_SINK_INPUT (pstream));
 
- g_return_val_if_fail (PULSE_IS_SINK_INPUT (stream), FALSE);
+ pulse_connection_load_sink_input_info (pulse_stream_get_connection (pstream),
+ pulse_stream_get_index (pstream));
+}
 
- pulse = PULSE_STREAM (stream);
+static gboolean
+pulse_sink_input_set_mute (PulseStream *pstream, gboolean mute)
+{
+ g_return_val_if_fail (PULSE_IS_SINK_INPUT (pstream), FALSE);
 
- return pulse_connection_set_sink_input_mute (pulse_stream_get_connection (pulse),
- pulse_stream_get_index (pulse),
+ return pulse_connection_set_sink_input_mute (pulse_stream_get_connection (pstream),
+ pulse_stream_get_index (pstream),
 mute);
 }
 
 static gboolean
-sink_input_set_volume (MateMixerStream *stream, pa_cvolume *volume)
+pulse_sink_input_set_volume (PulseStream *pstream, pa_cvolume *cvolume)
 {
- PulseStream *pulse;
-
- g_return_val_if_fail (PULSE_IS_SINK_INPUT (stream), FALSE);
- g_return_val_if_fail (volume != NULL, FALSE);
-
- pulse = PULSE_STREAM (stream);
+ g_return_val_if_fail (PULSE_IS_SINK_INPUT (pstream), FALSE);
+ g_return_val_if_fail (cvolume != NULL, FALSE);
 
- return pulse_connection_set_sink_input_volume (pulse_stream_get_connection (pulse),
- pulse_stream_get_index (pulse),
- volume);
+ return pulse_connection_set_sink_input_volume (pulse_stream_get_connection (pstream),
+ pulse_stream_get_index (pstream),
+ cvolume);
 }
 
 static gboolean
-sink_input_set_parent (MateMixerClientStream *stream, MateMixerStream *parent)
+pulse_sink_input_set_parent (PulseClientStream *pclient, PulseStream *parent)
 {
- PulseStream *pulse;
+ PulseStream *pstream;
 
- g_return_val_if_fail (PULSE_IS_SINK_INPUT (stream), FALSE);
+ g_return_val_if_fail (PULSE_IS_SINK_INPUT (pclient), FALSE);
 
- if (G_UNLIKELY (!PULSE_IS_SINK (parent))) {
+ if (!PULSE_IS_SINK (parent)) {
 g_warning ("Could not change stream parent to %s: not a parent output stream",
- mate_mixer_stream_get_name (parent));
+ mate_mixer_stream_get_name (MATE_MIXER_STREAM (parent)));
 return FALSE;
 }
 
- pulse = PULSE_STREAM (stream);
+ pstream = PULSE_STREAM (pclient);
 
- return pulse_connection_move_sink_input (pulse_stream_get_connection (pulse),
- pulse_stream_get_index (pulse),
- pulse_stream_get_index (PULSE_STREAM (parent)));
+ return pulse_connection_move_sink_input (pulse_stream_get_connection (pstream),
+ pulse_stream_get_index (pstream),
+ pulse_stream_get_index (parent));
 }
 
 static gboolean
-sink_input_remove (MateMixerClientStream *stream)
+pulse_sink_input_remove (PulseClientStream *pclient)
 {
- PulseStream *pulse;
+ PulseStream *pstream;
 
- g_return_val_if_fail (PULSE_IS_SINK_INPUT (stream), FALSE);
+ g_return_val_if_fail (PULSE_IS_SINK_INPUT (pclient), FALSE);
 
- pulse = PULSE_STREAM (stream);
+ pstream = PULSE_STREAM (pclient);
 
- return pulse_connection_kill_sink_input (pulse_stream_get_connection (pulse),
- pulse_stream_get_index (pulse));
+ return pulse_connection_kill_sink_input (pulse_stream_get_connection (pstream),
+ pulse_stream_get_index (pstream));
 }
 
 static PulseMonitor *
-sink_input_create_monitor (MateMixerStream *stream)
+pulse_sink_input_create_monitor (PulseStream *pstream)
 {
 MateMixerStream *parent;
- PulseStream *pulse;
 guint32 index;
 
- g_return_val_if_fail (PULSE_IS_SINK_INPUT (stream), NULL);
+ g_return_val_if_fail (PULSE_IS_SINK_INPUT (pstream), NULL);
 
- parent = mate_mixer_client_stream_get_parent (MATE_MIXER_CLIENT_STREAM (stream));
+ parent = mate_mixer_client_stream_get_parent (MATE_MIXER_CLIENT_STREAM (pstream));
 if (G_UNLIKELY (parent == NULL)) {
 g_debug ("Not creating monitor for client stream %s as it is not available",
- mate_mixer_stream_get_name (stream));
+ mate_mixer_stream_get_name (MATE_MIXER_STREAM (pstream)));
 return NULL;
 }
 
- pulse = PULSE_STREAM (stream);
 index = pulse_sink_get_monitor_index (PULSE_STREAM (parent));
 
 if (G_UNLIKELY (index == PA_INVALID_INDEX)) {
 g_debug ("Not creating monitor for client stream %s as it is not available",
- mate_mixer_stream_get_name (stream));
+ mate_mixer_stream_get_name (MATE_MIXER_STREAM (pstream)));
 return NULL;
 }
 
- return pulse_connection_create_monitor (pulse_stream_get_connection (pulse),
+ return pulse_connection_create_monitor (pulse_stream_get_connection (pstream),
 index,
- pulse_stream_get_index (pulse));
+ pulse_stream_get_index (pstream));
 }
diff --git a/backends/pulse/pulse-sink-input.h b/backends/pulse/pulse-sink-input.h
index a498999..1e5004b 100644
--- a/backends/pulse/pulse-sink-input.h
+++ b/backends/pulse/pulse-sink-input.h
@@ -61,7 +61,7 @@ PulseStream *pulse_sink_input_new (PulseConnection *connection,
 const pa_sink_input_info *info,
 PulseStream *parent);
 
-gboolean pulse_sink_input_update (PulseStream *stream,
+gboolean pulse_sink_input_update (PulseStream *pstream,
 const pa_sink_input_info *info,
 PulseStream *parent);
 
diff --git a/backends/pulse/pulse-sink.c b/backends/pulse/pulse-sink.c
index 27d1466..0f828b1 100644
--- a/backends/pulse/pulse-sink.c
+++ b/backends/pulse/pulse-sink.c
@@ -18,6 +18,8 @@
 #include <glib.h>
 #include <glib-object.h>
 
+#include <libmatemixer/matemixer-port.h>
+#include <libmatemixer/matemixer-port-private.h>
 #include <libmatemixer/matemixer-stream.h>
 
 #include <pulse/pulseaudio.h>
@@ -38,15 +40,23 @@ static void pulse_sink_init (PulseSink *sink);
 
 G_DEFINE_TYPE (PulseSink, pulse_sink, PULSE_TYPE_STREAM);
 
-static gboolean sink_set_mute (MateMixerStream *stream,
- gboolean mute);
-static gboolean sink_set_volume (MateMixerStream *stream,
- pa_cvolume *volume);
-static gboolean sink_set_active_port (MateMixerStream *stream,
- const gchar *port);
-static gboolean sink_suspend (MateMixerStream *stream);
-static gboolean sink_resume (MateMixerStream *stream);
-static PulseMonitor *sink_create_monitor (MateMixerStream *stream);
+static void pulse_sink_reload (PulseStream *pstream);
+
+static gboolean pulse_sink_set_mute (PulseStream *pstream,
+ gboolean mute);
+static gboolean pulse_sink_set_volume (PulseStream *pstream,
+ pa_cvolume *cvolume);
+static gboolean pulse_sink_set_active_port (PulseStream *pstream,
+ MateMixerPort *port);
+
+static gboolean pulse_sink_suspend (PulseStream *pstream);
+static gboolean pulse_sink_resume (PulseStream *pstream);
+
+static PulseMonitor *pulse_sink_create_monitor (PulseStream *pstream);
+
+static void update_ports (PulseStream *pstream,
+ pa_sink_port_info **ports,
+ pa_sink_port_info *active);
 
 static void
 pulse_sink_class_init (PulseSinkClass *klass)
@@ -55,12 +65,13 @@ pulse_sink_class_init (PulseSinkClass *klass)
 
 stream_class = PULSE_STREAM_CLASS (klass);
 
- stream_class->set_mute = sink_set_mute;
- stream_class->set_volume = sink_set_volume;
- stream_class->set_active_port = sink_set_active_port;
- stream_class->suspend = sink_suspend;
- stream_class->resume = sink_resume;
- stream_class->create_monitor = sink_create_monitor;
+ stream_class->reload = pulse_sink_reload;
+ stream_class->set_mute = pulse_sink_set_mute;
+ stream_class->set_volume = pulse_sink_set_volume;
+ stream_class->set_active_port = pulse_sink_set_active_port;
+ stream_class->suspend = pulse_sink_suspend;
+ stream_class->resume = pulse_sink_resume;
+ stream_class->create_monitor = pulse_sink_create_monitor;
 
 g_type_class_add_private (klass, sizeof (PulseSinkPrivate));
 }
@@ -98,71 +109,46 @@ pulse_sink_new (PulseConnection *connection,
 }
 
 guint32
-pulse_sink_get_monitor_index (PulseStream *stream)
+pulse_sink_get_monitor_index (PulseStream *pstream)
 {
- g_return_val_if_fail (PULSE_IS_SINK (stream), PA_INVALID_INDEX);
+ g_return_val_if_fail (PULSE_IS_SINK (pstream), PA_INVALID_INDEX);
 
- return PULSE_SINK (stream)->priv->index_monitor;
+ return PULSE_SINK (pstream)->priv->index_monitor;
 }
 
 gboolean
-pulse_sink_update (PulseStream *stream, const pa_sink_info *info, PulseDevice *device)
+pulse_sink_update (PulseStream *pstream, const pa_sink_info *info, PulseDevice *device)
 {
 MateMixerStreamFlags flags = MATE_MIXER_STREAM_OUTPUT |
 MATE_MIXER_STREAM_HAS_MUTE |
 MATE_MIXER_STREAM_HAS_VOLUME |
- MATE_MIXER_STREAM_HAS_MONITOR |
 MATE_MIXER_STREAM_CAN_SET_VOLUME |
 MATE_MIXER_STREAM_CAN_SUSPEND;
 PulseSink *sink;
- GList *ports = NULL;
- guint32 i;
 
- g_return_val_if_fail (PULSE_IS_SINK (stream), FALSE);
+ g_return_val_if_fail (PULSE_IS_SINK (pstream), FALSE);
+ g_return_val_if_fail (info != NULL, FALSE);
 
 /* Let all the information update before emitting notify signals */
- g_object_freeze_notify (G_OBJECT (stream));
+ g_object_freeze_notify (G_OBJECT (pstream));
 
- pulse_stream_update_name (stream, info->name);
- pulse_stream_update_description (stream, info->description);
- pulse_stream_update_mute (stream, info->mute ? TRUE : FALSE);
-
- /* List of ports */
- for (i = 0; i < info->n_ports; i++) {
- MateMixerPortFlags flags = MATE_MIXER_PORT_NO_FLAGS;
-
-#if PA_CHECK_VERSION(2, 0, 0)
- if (info->ports[i]->available == PA_PORT_AVAILABLE_YES)
- flags |= MATE_MIXER_PORT_AVAILABLE;
-#endif
- ports = g_list_prepend (ports,
- mate_mixer_port_new (info->ports[i]->name,
- info->ports[i]->description,
- NULL,
- info->ports[i]->priority,
- flags));
- }
- pulse_stream_update_ports (stream, ports);
-
- /* Active port */
- if (info->active_port)
- pulse_stream_update_active_port (stream, info->active_port->name);
- else
- pulse_stream_update_active_port (stream, NULL);
+ pulse_stream_update_name (pstream, info->name);
+ pulse_stream_update_description (pstream, info->description);
+ pulse_stream_update_mute (pstream, info->mute ? TRUE : FALSE);
 
 /* Stream state */
 switch (info->state) {
 case PA_SINK_RUNNING:
- pulse_stream_update_state (stream, MATE_MIXER_STREAM_RUNNING);
+ pulse_stream_update_state (pstream, MATE_MIXER_STREAM_STATE_RUNNING);
 break;
 case PA_SINK_IDLE:
- pulse_stream_update_state (stream, MATE_MIXER_STREAM_IDLE);
+ pulse_stream_update_state (pstream, MATE_MIXER_STREAM_STATE_IDLE);
 break;
 case PA_SINK_SUSPENDED:
- pulse_stream_update_state (stream, MATE_MIXER_STREAM_SUSPENDED);
+ pulse_stream_update_state (pstream, MATE_MIXER_STREAM_STATE_SUSPENDED);
 break;
 default:
- pulse_stream_update_state (stream, MATE_MIXER_STREAM_UNKNOWN_STATE);
+ pulse_stream_update_state (pstream, MATE_MIXER_STREAM_STATE_UNKNOWN);
 break;
 }
 
@@ -172,132 +158,172 @@ pulse_sink_update (PulseStream *stream, const pa_sink_info *info, PulseDevice *d
 if (info->flags & PA_SINK_FLAT_VOLUME)
 flags |= MATE_MIXER_STREAM_HAS_FLAT_VOLUME;
 
- if (pa_channel_map_can_balance (&info->channel_map))
- flags |= MATE_MIXER_STREAM_CAN_BALANCE;
- if (pa_channel_map_can_fade (&info->channel_map))
- flags |= MATE_MIXER_STREAM_CAN_FADE;
+ sink = PULSE_SINK (pstream);
 
- /* Flags must be updated before volume */
- pulse_stream_update_flags (stream, flags);
-
- pulse_stream_update_volume (stream,
- &info->volume,
- &info->channel_map,
- info->base_volume);
-
- pulse_stream_update_device (stream, MATE_MIXER_DEVICE (device));
+ if (sink->priv->index_monitor == PA_INVALID_INDEX)
+ sink->priv->index_monitor = info->monitor_source;
 
- sink = PULSE_SINK (stream);
+ if (sink->priv->index_monitor != PA_INVALID_INDEX)
+ flags |= MATE_MIXER_STREAM_HAS_MONITOR;
 
- /* Handle change of monitoring source index */
- // XXX probably call this each time to validate
- if (sink->priv->index_monitor != info->monitor_source) {
- PulseMonitor *monitor;
+ /* Flags must be updated before volume */
+ pulse_stream_update_flags (pstream, flags);
 
- monitor = pulse_stream_get_monitor (PULSE_STREAM (stream));
+ pulse_stream_update_channel_map (pstream, &info->channel_map);
+ pulse_stream_update_volume (pstream, &info->volume, info->base_volume);
 
- if (monitor)
- pulse_monitor_update_index (monitor,
- info->monitor_source,
- PA_INVALID_INDEX);
+ pulse_stream_update_device (pstream, MATE_MIXER_DEVICE (device));
 
- sink->priv->index_monitor = info->monitor_source;
+ /* Ports must be updated after device */
+ if (info->ports != NULL) {
+ update_ports (pstream, info->ports, info->active_port);
 }
 
- g_object_thaw_notify (G_OBJECT (stream));
+ g_object_thaw_notify (G_OBJECT (pstream));
 return TRUE;
 }
 
-static gboolean
-sink_set_mute (MateMixerStream *stream, gboolean mute)
+static void
+pulse_sink_reload (PulseStream *pstream)
 {
- PulseStream *pulse;
+ g_return_if_fail (PULSE_IS_SINK (pstream));
 
- g_return_val_if_fail (PULSE_IS_SINK (stream), FALSE);
+ pulse_connection_load_sink_info (pulse_stream_get_connection (pstream),
+ pulse_stream_get_index (pstream));
+}
 
- pulse = PULSE_STREAM (stream);
+static gboolean
+pulse_sink_set_mute (PulseStream *pstream, gboolean mute)
+{
+ g_return_val_if_fail (PULSE_IS_SINK (pstream), FALSE);
 
- return pulse_connection_set_sink_mute (pulse_stream_get_connection (pulse),
- pulse_stream_get_index (pulse),
+ return pulse_connection_set_sink_mute (pulse_stream_get_connection (pstream),
+ pulse_stream_get_index (pstream),
 mute);
 }
 
 static gboolean
-sink_set_volume (MateMixerStream *stream, pa_cvolume *volume)
+pulse_sink_set_volume (PulseStream *pstream, pa_cvolume *cvolume)
 {
- PulseStream *pulse;
-
- g_return_val_if_fail (PULSE_IS_SINK (stream), FALSE);
- g_return_val_if_fail (volume != NULL, FALSE);
+ g_return_val_if_fail (PULSE_IS_SINK (pstream), FALSE);
+ g_return_val_if_fail (cvolume != NULL, FALSE);
 
- pulse = PULSE_STREAM (stream);
-
- return pulse_connection_set_sink_volume (pulse_stream_get_connection (pulse),
- pulse_stream_get_index (pulse),
- volume);
+ return pulse_connection_set_sink_volume (pulse_stream_get_connection (pstream),
+ pulse_stream_get_index (pstream),
+ cvolume);
 }
 
 static gboolean
-sink_set_active_port (MateMixerStream *stream, const gchar *port)
+pulse_sink_set_active_port (PulseStream *pstream, MateMixerPort *port)
 {
- PulseStream *pulse;
-
- g_return_val_if_fail (PULSE_IS_SINK (stream), FALSE);
- g_return_val_if_fail (port != NULL, FALSE);
+ g_return_val_if_fail (PULSE_IS_SINK (pstream), FALSE);
+ g_return_val_if_fail (MATE_MIXER_IS_PORT (port), FALSE);
 
- pulse = PULSE_STREAM (stream);
-
- return pulse_connection_set_sink_port (pulse_stream_get_connection (pulse),
- pulse_stream_get_index (pulse),
- port);
+ return pulse_connection_set_sink_port (pulse_stream_get_connection (pstream),
+ pulse_stream_get_index (pstream),
+ mate_mixer_port_get_name (port));
 }
 
 static gboolean
-sink_suspend (MateMixerStream *stream)
+pulse_sink_suspend (PulseStream *pstream)
 {
- PulseStream *pulse;
-
- g_return_val_if_fail (PULSE_IS_SINK (stream), FALSE);
+ g_return_val_if_fail (PULSE_IS_SINK (pstream), FALSE);
 
- pulse = PULSE_STREAM (stream);
-
- return pulse_connection_suspend_sink (pulse_stream_get_connection (pulse),
- pulse_stream_get_index (pulse),
+ return pulse_connection_suspend_sink (pulse_stream_get_connection (pstream),
+ pulse_stream_get_index (pstream),
 TRUE);
 }
 
 static gboolean
-sink_resume (MateMixerStream *stream)
+pulse_sink_resume (PulseStream *pstream)
 {
- PulseStream *pulse;
-
- g_return_val_if_fail (PULSE_IS_SINK (stream), FALSE);
-
- pulse = PULSE_STREAM (stream);
+ g_return_val_if_fail (PULSE_IS_SINK (pstream), FALSE);
 
- return pulse_connection_suspend_sink (pulse_stream_get_connection (pulse),
- pulse_stream_get_index (pulse),
+ return pulse_connection_suspend_sink (pulse_stream_get_connection (pstream),
+ pulse_stream_get_index (pstream),
 FALSE);
 }
 
 static PulseMonitor *
-sink_create_monitor (MateMixerStream *stream)
+pulse_sink_create_monitor (PulseStream *pstream)
 {
- PulseStream *pulse;
- guint32 index;
+ guint32 index;
 
- g_return_val_if_fail (PULSE_IS_SINK (stream), NULL);
+ g_return_val_if_fail (PULSE_IS_SINK (pstream), NULL);
 
- pulse = PULSE_STREAM (stream);
- index = pulse_sink_get_monitor_index (pulse);
+ index = pulse_sink_get_monitor_index (pstream);
 
 if (G_UNLIKELY (index == PA_INVALID_INDEX)) {
- g_debug ("Not creating monitor for stream %s as it is not available",
- mate_mixer_stream_get_name (stream));
+ g_debug ("Not creating monitor for stream %s: not available",
+ mate_mixer_stream_get_name (MATE_MIXER_STREAM (pstream)));
 return NULL;
 }
 
- return pulse_connection_create_monitor (pulse_stream_get_connection (pulse),
+ return pulse_connection_create_monitor (pulse_stream_get_connection (pstream),
 index,
 PA_INVALID_INDEX);
 }
+
+static void
+update_ports (PulseStream *pstream,
+ pa_sink_port_info **ports,
+ pa_sink_port_info *active)
+{
+ MateMixerPort *port;
+ MateMixerDevice *device;
+ GHashTable *hash;
+
+ hash = pulse_stream_get_ports (pstream);
+
+ while (*ports != NULL) {
+ MateMixerPortFlags flags = MATE_MIXER_PORT_NO_FLAGS;
+ pa_sink_port_info *info = *ports;
+ const gchar *icon = NULL;
+
+ device = mate_mixer_stream_get_device (MATE_MIXER_STREAM (pstream));
+ if (device != NULL) {
+ port = mate_mixer_device_get_port (device, info->name);
+
+ if (port != NULL) {
+ flags = mate_mixer_port_get_flags (port);
+ icon = mate_mixer_port_get_icon (port);
+ }
+ }
+
+#if PA_CHECK_VERSION(2, 0, 0)
+ if (info->available == PA_PORT_AVAILABLE_YES)
+ flags |= MATE_MIXER_PORT_AVAILABLE;
+ else
+ flags &= ~MATE_MIXER_PORT_AVAILABLE;
+#endif
+
+ port = g_hash_table_lookup (hash, info->name);
+
+ if (port != NULL) {
+ /* Update existing port */
+ _mate_mixer_port_update_description (port, info->description);
+ _mate_mixer_port_update_icon (port, icon);
+ _mate_mixer_port_update_priority (port, info->priority);
+ _mate_mixer_port_update_flags (port, flags);
+ } else {
+ /* Add previously unknown port to the hash table */
+ port = _mate_mixer_port_new (info->name,
+ info->description,
+ icon,
+ info->priority,
+ flags);
+
+ g_hash_table_insert (hash, g_strdup (info->name), port);
+ }
+
+ ports++;
+ }
+
+ /* Active port */
+ if (G_LIKELY (active != NULL))
+ port = g_hash_table_lookup (hash, active->name);
+ else
+ port = NULL;
+
+ pulse_stream_update_active_port (pstream, port);
+}
diff --git a/backends/pulse/pulse-sink.h b/backends/pulse/pulse-sink.h
index 7265a7c..c0631ca 100644
--- a/backends/pulse/pulse-sink.h
+++ b/backends/pulse/pulse-sink.h
@@ -65,9 +65,9 @@ PulseStream *pulse_sink_new (PulseConnection *connection,
 const pa_sink_info *info,
 PulseDevice *device);
 
-guint32 pulse_sink_get_monitor_index (PulseStream *stream);
+guint32 pulse_sink_get_monitor_index (PulseStream *pstream);
 
-gboolean pulse_sink_update (PulseStream *stream,
+gboolean pulse_sink_update (PulseStream *pstream,
 const pa_sink_info *info,
 PulseDevice *device);
 
diff --git a/backends/pulse/pulse-source-output.c b/backends/pulse/pulse-source-output.c
index 3f3c3ae..c46b65b 100644
--- a/backends/pulse/pulse-source-output.c
+++ b/backends/pulse/pulse-source-output.c
@@ -26,6 +26,7 @@
 
 #include "pulse-connection.h"
 #include "pulse-client-stream.h"
+#include "pulse-helpers.h"
 #include "pulse-monitor.h"
 #include "pulse-stream.h"
 #include "pulse-source.h"
@@ -36,14 +37,18 @@ static void pulse_source_output_init (PulseSourceOutput *output);
 
 G_DEFINE_TYPE (PulseSourceOutput, pulse_source_output, PULSE_TYPE_CLIENT_STREAM);
 
-static gboolean source_output_set_mute (MateMixerStream *stream,
- gboolean mute);
-static gboolean source_output_set_volume (MateMixerStream *stream,
- pa_cvolume *volume);
-static gboolean source_output_set_parent (MateMixerClientStream *stream,
- MateMixerStream *parent);
-static gboolean source_output_remove (MateMixerClientStream *stream);
-static PulseMonitor *source_output_create_monitor (MateMixerStream *stream);
+static void pulse_source_output_reload (PulseStream *pstream);
+
+static gboolean pulse_source_output_set_mute (PulseStream *pstream,
+ gboolean mute);
+static gboolean pulse_source_output_set_volume (PulseStream *pstream,
+ pa_cvolume *cvolume);
+
+static gboolean pulse_source_output_set_parent (PulseClientStream *pclient,
+ PulseStream *parent);
+static gboolean pulse_source_output_remove (PulseClientStream *pclient);
+
+static PulseMonitor *pulse_source_output_create_monitor (PulseStream *pstream);
 
 static void
 pulse_source_output_class_init (PulseSourceOutputClass *klass)
@@ -53,14 +58,15 @@ pulse_source_output_class_init (PulseSourceOutputClass *klass)
 
 stream_class = PULSE_STREAM_CLASS (klass);
 
- stream_class->set_mute = source_output_set_mute;
- stream_class->set_volume = source_output_set_volume;
- stream_class->create_monitor = source_output_create_monitor;
+ stream_class->reload = pulse_source_output_reload;
+ stream_class->set_mute = pulse_source_output_set_mute;
+ stream_class->set_volume = pulse_source_output_set_volume;
+ stream_class->create_monitor = pulse_source_output_create_monitor;
 
 client_class = PULSE_CLIENT_STREAM_CLASS (klass);
 
- client_class->set_parent = source_output_set_parent;
- client_class->remove = source_output_remove;
+ client_class->set_parent = pulse_source_output_set_parent;
+ client_class->remove = pulse_source_output_remove;
 }
 
 static void
@@ -91,21 +97,24 @@ pulse_source_output_new (PulseConnection *connection,
 }
 
 gboolean
-pulse_source_output_update (PulseStream *stream,
+pulse_source_output_update (PulseStream *pstream,
 const pa_source_output_info *info,
 PulseStream *parent)
 {
 MateMixerStreamFlags flags = MATE_MIXER_STREAM_INPUT |
 MATE_MIXER_STREAM_CLIENT;
- gchar *name;
+ PulseClientStream *pclient;
+ const gchar *prop;
+ const gchar *description = NULL;
+ gchar *name;
 
- const gchar *prop;
- const gchar *description = NULL;
+ g_return_val_if_fail (PULSE_IS_SOURCE_OUTPUT (pstream), FALSE);
+ g_return_val_if_fail (info != NULL, FALSE);
 
- g_return_val_if_fail (PULSE_IS_SOURCE_OUTPUT (stream), FALSE);
+ pclient = PULSE_CLIENT_STREAM (pstream);
 
 /* Let all the information update before emitting notify signals */
- g_object_freeze_notify (G_OBJECT (stream));
+ g_object_freeze_notify (G_OBJECT (pstream));
 
 /* Many other mixer applications query the Pulse client list and use the
 * client name here, but we use the name only as an identifier, so let's avoid
@@ -113,159 +122,168 @@ pulse_source_output_update (PulseStream *stream,
 * Also make sure to make the name unique by including the Pulse index. */
 name = g_strdup_printf ("pulse-stream-client-input-%lu", (gulong) info->index);
 
- pulse_stream_update_name (stream, name);
+ pulse_stream_update_name (pstream, name);
 g_free (name);
 
 prop = pa_proplist_gets (info->proplist, PA_PROP_APPLICATION_NAME);
 if (prop != NULL)
- pulse_client_stream_update_app_name (PULSE_CLIENT_STREAM (stream), prop);
+ pulse_client_stream_update_app_name (pclient, prop);
 
 prop = pa_proplist_gets (info->proplist, PA_PROP_APPLICATION_ID);
 if (prop != NULL)
- pulse_client_stream_update_app_id (PULSE_CLIENT_STREAM (stream), prop);
+ pulse_client_stream_update_app_id (pclient, prop);
 
 prop = pa_proplist_gets (info->proplist, PA_PROP_APPLICATION_VERSION);
 if (prop != NULL)
- pulse_client_stream_update_app_version (PULSE_CLIENT_STREAM (stream), prop);
+ pulse_client_stream_update_app_version (pclient, prop);
 
 prop = pa_proplist_gets (info->proplist, PA_PROP_APPLICATION_ICON_NAME);
 if (prop != NULL)
- pulse_client_stream_update_app_icon (PULSE_CLIENT_STREAM (stream), prop);
+ pulse_client_stream_update_app_icon (pclient, prop);
 
 prop = pa_proplist_gets (info->proplist, PA_PROP_MEDIA_ROLE);
+ if (prop != NULL) {
+ MateMixerClientStreamRole role = pulse_convert_media_role_name (prop);
 
- if (prop != NULL && !strcmp (prop, "event")) {
- /* The event description seems to provide much better readable
- * description for event streams */
- prop = pa_proplist_gets (info->proplist, PA_PROP_EVENT_DESCRIPTION);
+ if (role == MATE_MIXER_CLIENT_STREAM_ROLE_EVENT) {
+ /* The event description seems to provide much better readable
+ * description for event streams */
+ prop = pa_proplist_gets (info->proplist, PA_PROP_EVENT_DESCRIPTION);
 
- if (G_LIKELY (prop != NULL))
- description = prop;
+ if (G_LIKELY (prop != NULL))
+ description = prop;
+ }
+ pulse_client_stream_update_role (pclient, role);
+ } else
+ pulse_client_stream_update_role (pclient, MATE_MIXER_CLIENT_STREAM_ROLE_NONE);
 
- flags |= MATE_MIXER_STREAM_EVENT;
- }
 if (description == NULL)
 description = info->name;
 
- pulse_stream_update_description (stream, description);
+ pulse_stream_update_description (pstream, description);
 
 if (info->client != PA_INVALID_INDEX)
- flags |= MATE_MIXER_STREAM_APPLICATION;
+ pulse_client_stream_update_flags (pclient, MATE_MIXER_CLIENT_STREAM_APPLICATION);
+ else
+ pulse_client_stream_update_flags (pclient, MATE_MIXER_CLIENT_STREAM_NO_FLAGS);
 
- if (pa_channel_map_can_balance (&info->channel_map))
- flags |= MATE_MIXER_STREAM_CAN_BALANCE;
- if (pa_channel_map_can_fade (&info->channel_map))
- flags |= MATE_MIXER_STREAM_CAN_FADE;
+ if (G_LIKELY (parent != NULL)) {
+ pulse_client_stream_update_parent (pclient, MATE_MIXER_STREAM (parent));
+ flags |= MATE_MIXER_STREAM_HAS_MONITOR;
+ } else
+ pulse_client_stream_update_parent (pclient, NULL);
 
 #if PA_CHECK_VERSION(1, 0, 0)
 if (info->has_volume) {
 flags |= MATE_MIXER_STREAM_HAS_VOLUME;
+
 if (info->volume_writable)
 flags |= MATE_MIXER_STREAM_CAN_SET_VOLUME;
 }
+
 flags |= MATE_MIXER_STREAM_HAS_MUTE;
 
- pulse_stream_update_flags (stream, flags);
- pulse_stream_update_mute (stream, info->mute ? TRUE : FALSE);
+ /* Flags needed before volume */
+ pulse_stream_update_flags (pstream, flags);
+ pulse_stream_update_channel_map (pstream, &info->channel_map);
+ pulse_stream_update_mute (pstream, info->mute ? TRUE : FALSE);
 
 if (info->has_volume)
- pulse_stream_update_volume (stream, &info->volume, &info->channel_map, 0);
+ pulse_stream_update_volume (pstream, &info->volume, 0);
 else
- pulse_stream_update_volume (stream, NULL, &info->channel_map, 0);
+ pulse_stream_update_volume (pstream, NULL, 0);
 #else
- pulse_stream_update_flags (stream, flags);
- pulse_stream_update_volume (stream, NULL, &info->channel_map, 0);
-#endif
+ /* Flags needed before volume */
+ pulse_stream_update_flags (pstream, flags);
 
- if (G_LIKELY (parent != NULL))
- pulse_client_stream_update_parent (PULSE_CLIENT_STREAM (stream),
- MATE_MIXER_STREAM (parent));
- else
- pulse_client_stream_update_parent (PULSE_CLIENT_STREAM (stream), NULL);
+ pulse_stream_update_channel_map (pstream, &info->channel_map);
+ pulse_stream_update_volume (pstream, NULL, 0);
+#endif
 
 // XXX needs to fix monitor if parent changes
 
- g_object_thaw_notify (G_OBJECT (stream));
+ g_object_thaw_notify (G_OBJECT (pstream));
 return TRUE;
 }
 
-static gboolean
-source_output_set_mute (MateMixerStream *stream, gboolean mute)
+static void
+pulse_source_output_reload (PulseStream *pstream)
 {
- PulseStream *pulse;
+ g_return_if_fail (PULSE_IS_SOURCE_OUTPUT (pstream));
 
- g_return_val_if_fail (PULSE_IS_SOURCE_OUTPUT (stream), FALSE);
+ pulse_connection_load_source_output_info (pulse_stream_get_connection (pstream),
+ pulse_stream_get_index (pstream));
+}
 
- pulse = PULSE_STREAM (stream);
+static gboolean
+pulse_source_output_set_mute (PulseStream *pstream, gboolean mute)
+{
+ g_return_val_if_fail (PULSE_IS_SOURCE_OUTPUT (pstream), FALSE);
 
- return pulse_connection_set_source_output_mute (pulse_stream_get_connection (pulse),
- pulse_stream_get_index (pulse),
+ return pulse_connection_set_source_output_mute (pulse_stream_get_connection (pstream),
+ pulse_stream_get_index (pstream),
 mute);
 }
 
 static gboolean
-source_output_set_volume (MateMixerStream *stream, pa_cvolume *volume)
+pulse_source_output_set_volume (PulseStream *pstream, pa_cvolume *cvolume)
 {
- PulseStream *pulse;
-
- g_return_val_if_fail (PULSE_IS_SOURCE_OUTPUT (stream), FALSE);
- g_return_val_if_fail (volume != NULL, FALSE);
-
- pulse = PULSE_STREAM (stream);
+ g_return_val_if_fail (PULSE_IS_SOURCE_OUTPUT (pstream), FALSE);
+ g_return_val_if_fail (cvolume != NULL, FALSE);
 
- return pulse_connection_set_source_output_volume (pulse_stream_get_connection (pulse),
- pulse_stream_get_index (pulse),
- volume);
+ return pulse_connection_set_source_output_volume (pulse_stream_get_connection (pstream),
+ pulse_stream_get_index (pstream),
+ cvolume);
 }
 
 static gboolean
-source_output_set_parent (MateMixerClientStream *stream, MateMixerStream *parent)
+pulse_source_output_set_parent (PulseClientStream *pclient, PulseStream *parent)
 {
- PulseStream *pulse;
+ PulseStream *pstream;
 
- g_return_val_if_fail (PULSE_IS_SOURCE_OUTPUT (stream), FALSE);
+ g_return_val_if_fail (PULSE_IS_SOURCE_OUTPUT (pclient), FALSE);
 
- if (G_UNLIKELY (!PULSE_IS_SOURCE (parent))) {
+ if (!PULSE_IS_SOURCE (parent)) {
 g_warning ("Could not change stream parent to %s: not a parent input stream",
- mate_mixer_stream_get_name (parent));
+ mate_mixer_stream_get_name (MATE_MIXER_STREAM (parent)));
 return FALSE;
 }
 
- pulse = PULSE_STREAM (stream);
+ pstream = PULSE_STREAM (pclient);
 
- return pulse_connection_move_sink_input (pulse_stream_get_connection (pulse),
- pulse_stream_get_index (pulse),
- pulse_stream_get_index (PULSE_STREAM (parent)));
+ return pulse_connection_move_sink_input (pulse_stream_get_connection (pstream),
+ pulse_stream_get_index (pstream),
+ pulse_stream_get_index (parent));
 }
 
 static gboolean
-source_output_remove (MateMixerClientStream *stream)
+pulse_source_output_remove (PulseClientStream *pclient)
 {
- PulseStream *pulse;
+ PulseStream *pstream;
 
- g_return_val_if_fail (PULSE_IS_SOURCE_OUTPUT (stream), FALSE);
+ g_return_val_if_fail (PULSE_IS_SOURCE_OUTPUT (pclient), FALSE);
 
- pulse = PULSE_STREAM (stream);
+ pstream = PULSE_STREAM (pclient);
 
- return pulse_connection_kill_source_output (pulse_stream_get_connection (pulse),
- pulse_stream_get_index (pulse));
+ return pulse_connection_kill_source_output (pulse_stream_get_connection (pstream),
+ pulse_stream_get_index (pstream));
 }
 
 static PulseMonitor *
-source_output_create_monitor (MateMixerStream *stream)
+pulse_source_output_create_monitor (PulseStream *pstream)
 {
 MateMixerStream *parent;
 
- g_return_val_if_fail (PULSE_IS_SOURCE_OUTPUT (stream), NULL);
+ g_return_val_if_fail (PULSE_IS_SOURCE_OUTPUT (pstream), NULL);
 
- parent = mate_mixer_client_stream_get_parent (MATE_MIXER_CLIENT_STREAM (stream));
+ parent = mate_mixer_client_stream_get_parent (MATE_MIXER_CLIENT_STREAM (pstream));
 if (G_UNLIKELY (parent == NULL)) {
- g_debug ("Not creating monitor for client stream %s as it is not available",
- mate_mixer_stream_get_name (stream));
+ g_debug ("Not creating monitor for client stream %s: not available",
+ mate_mixer_stream_get_name (MATE_MIXER_STREAM (pstream)));
 return NULL;
 }
 
- return pulse_connection_create_monitor (pulse_stream_get_connection (PULSE_STREAM (stream)),
+ return pulse_connection_create_monitor (pulse_stream_get_connection (pstream),
 pulse_stream_get_index (PULSE_STREAM (parent)),
 PA_INVALID_INDEX);
 }
diff --git a/backends/pulse/pulse-source-output.h b/backends/pulse/pulse-source-output.h
index 69efae0..845d439 100644
--- a/backends/pulse/pulse-source-output.h
+++ b/backends/pulse/pulse-source-output.h
@@ -62,7 +62,7 @@ PulseStream *pulse_source_output_new (PulseConnection *connec
 const pa_source_output_info *info,
 PulseStream *parent);
 
-gboolean pulse_source_output_update (PulseStream *stream,
+gboolean pulse_source_output_update (PulseStream *pstream,
 const pa_source_output_info *info,
 PulseStream *parent);
 
diff --git a/backends/pulse/pulse-source.c b/backends/pulse/pulse-source.c
index b443402..e7dce6f 100644
--- a/backends/pulse/pulse-source.c
+++ b/backends/pulse/pulse-source.c
@@ -18,8 +18,9 @@
 #include <glib.h>
 #include <glib-object.h>
 
-#include <libmatemixer/matemixer-stream.h>
 #include <libmatemixer/matemixer-port.h>
+#include <libmatemixer/matemixer-port-private.h>
+#include <libmatemixer/matemixer-stream.h>
 
 #include <pulse/pulseaudio.h>
 
@@ -34,13 +35,20 @@ static void pulse_source_init (PulseSource *source);
 
 G_DEFINE_TYPE (PulseSource, pulse_source, PULSE_TYPE_STREAM);
 
-static gboolean source_set_mute (MateMixerStream *stream,
- gboolean mute);
-static gboolean source_set_volume (MateMixerStream *stream,
- pa_cvolume *volume);
-static gboolean source_set_active_port (MateMixerStream *stream,
- const gchar *port_name);
-static PulseMonitor *source_create_monitor (MateMixerStream *stream);
+static void pulse_source_reload (PulseStream *pstream);
+
+static gboolean pulse_source_set_mute (PulseStream *pstream,
+ gboolean mute);
+static gboolean pulse_source_set_volume (PulseStream *pstream,
+ pa_cvolume *cvolume);
+static gboolean pulse_source_set_active_port (PulseStream *pstream,
+ MateMixerPort *port);
+
+static PulseMonitor *pulse_source_create_monitor (PulseStream *pstream);
+
+static void update_ports (PulseStream *pstream,
+ pa_source_port_info **ports,
+ pa_source_port_info *active);
 
 static void
 pulse_source_class_init (PulseSourceClass *klass)
@@ -49,10 +57,11 @@ pulse_source_class_init (PulseSourceClass *klass)
 
 stream_class = PULSE_STREAM_CLASS (klass);
 
- stream_class->set_mute = source_set_mute;
- stream_class->set_volume = source_set_volume;
- stream_class->set_active_port = source_set_active_port;
- stream_class->create_monitor = source_create_monitor;
+ stream_class->reload = pulse_source_reload;
+ stream_class->set_mute = pulse_source_set_mute;
+ stream_class->set_volume = pulse_source_set_volume;
+ stream_class->set_active_port = pulse_source_set_active_port;
+ stream_class->create_monitor = pulse_source_create_monitor;
 }
 
 static void
@@ -83,63 +92,40 @@ pulse_source_new (PulseConnection *connection,
 }
 
 gboolean
-pulse_source_update (PulseStream *stream,
+pulse_source_update (PulseStream *pstream,
 const pa_source_info *info,
 PulseDevice *device)
 {
 MateMixerStreamFlags flags = MATE_MIXER_STREAM_INPUT |
 MATE_MIXER_STREAM_HAS_MUTE |
+ MATE_MIXER_STREAM_HAS_MONITOR |
 MATE_MIXER_STREAM_HAS_VOLUME |
 MATE_MIXER_STREAM_CAN_SET_VOLUME |
 MATE_MIXER_STREAM_CAN_SUSPEND;
- GList *ports = NULL;
- guint32 i;
 
- g_return_val_if_fail (PULSE_IS_SOURCE (stream), FALSE);
+ g_return_val_if_fail (PULSE_IS_SOURCE (pstream), FALSE);
+ g_return_val_if_fail (info != NULL, FALSE);
 
 /* Let all the information update before emitting notify signals */
- g_object_freeze_notify (G_OBJECT (stream));
-
- pulse_stream_update_name (stream, info->name);
- pulse_stream_update_description (stream, info->description);
- pulse_stream_update_mute (stream, info->mute ? TRUE : FALSE);
+ g_object_freeze_notify (G_OBJECT (pstream));
 
- /* List of ports */
- for (i = 0; i < info->n_ports; i++) {
- MateMixerPortFlags flags = MATE_MIXER_PORT_NO_FLAGS;
-
-#if PA_CHECK_VERSION(2, 0, 0)
- if (info->ports[i]->available == PA_PORT_AVAILABLE_YES)
- flags |= MATE_MIXER_PORT_AVAILABLE;
-#endif
- ports = g_list_prepend (ports,
- mate_mixer_port_new (info->ports[i]->name,
- info->ports[i]->description,
- NULL,
- info->ports[i]->priority,
- flags));
- }
- pulse_stream_update_ports (stream, ports);
-
- /* Active port */
- if (info->active_port)
- pulse_stream_update_active_port (stream, info->active_port->name);
- else
- pulse_stream_update_active_port (stream, NULL);
+ pulse_stream_update_name (pstream, info->name);
+ pulse_stream_update_description (pstream, info->description);
+ pulse_stream_update_mute (pstream, info->mute ? TRUE : FALSE);
 
 /* Stream state */
 switch (info->state) {
 case PA_SOURCE_RUNNING:
- pulse_stream_update_state (stream, MATE_MIXER_STREAM_RUNNING);
+ pulse_stream_update_state (pstream, MATE_MIXER_STREAM_STATE_RUNNING);
 break;
 case PA_SOURCE_IDLE:
- pulse_stream_update_state (stream, MATE_MIXER_STREAM_IDLE);
+ pulse_stream_update_state (pstream, MATE_MIXER_STREAM_STATE_IDLE);
 break;
 case PA_SOURCE_SUSPENDED:
- pulse_stream_update_state (stream, MATE_MIXER_STREAM_SUSPENDED);
+ pulse_stream_update_state (pstream, MATE_MIXER_STREAM_STATE_SUSPENDED);
 break;
 default:
- pulse_stream_update_state (stream, MATE_MIXER_STREAM_UNKNOWN_STATE);
+ pulse_stream_update_state (pstream, MATE_MIXER_STREAM_STATE_UNKNOWN);
 break;
 }
 
@@ -149,79 +135,134 @@ pulse_source_update (PulseStream *stream,
 if (info->flags & PA_SINK_FLAT_VOLUME)
 flags |= MATE_MIXER_STREAM_HAS_FLAT_VOLUME;
 
- if (pa_channel_map_can_balance (&info->channel_map))
- flags |= MATE_MIXER_STREAM_CAN_BALANCE;
- if (pa_channel_map_can_fade (&info->channel_map))
- flags |= MATE_MIXER_STREAM_CAN_FADE;
-
 /* Flags must be updated before volume */
- pulse_stream_update_flags (stream, flags);
+ pulse_stream_update_flags (pstream, flags);
+
+ pulse_stream_update_channel_map (pstream, &info->channel_map);
+ pulse_stream_update_volume (pstream, &info->volume, info->base_volume);
 
- pulse_stream_update_volume (stream,
- &info->volume,
- &info->channel_map,
- info->base_volume);
+ pulse_stream_update_device (pstream, MATE_MIXER_DEVICE (device));
 
- pulse_stream_update_device (stream, MATE_MIXER_DEVICE (device));
+ /* Ports must be updated after device */
+ if (info->ports != NULL) {
+ update_ports (pstream, info->ports, info->active_port);
+ }
 
- g_object_thaw_notify (G_OBJECT (stream));
+ g_object_thaw_notify (G_OBJECT (pstream));
 return TRUE;
 }
 
-static gboolean
-source_set_mute (MateMixerStream *stream, gboolean mute)
+static void
+pulse_source_reload (PulseStream *pstream)
 {
- PulseStream *pulse;
+ g_return_if_fail (PULSE_IS_SOURCE (pstream));
 
- g_return_val_if_fail (PULSE_IS_SOURCE (stream), FALSE);
+ pulse_connection_load_source_info (pulse_stream_get_connection (pstream),
+ pulse_stream_get_index (pstream));
+}
 
- pulse = PULSE_STREAM (stream);
+static gboolean
+pulse_source_set_mute (PulseStream *pstream, gboolean mute)
+{
+ g_return_val_if_fail (PULSE_IS_SOURCE (pstream), FALSE);
 
- return pulse_connection_set_source_mute (pulse_stream_get_connection (pulse),
- pulse_stream_get_index (pulse),
+ return pulse_connection_set_source_mute (pulse_stream_get_connection (pstream),
+ pulse_stream_get_index (pstream),
 mute);
 }
 
 static gboolean
-source_set_volume (MateMixerStream *stream, pa_cvolume *volume)
+pulse_source_set_volume (PulseStream *pstream, pa_cvolume *cvolume)
 {
- PulseStream *pulse;
-
- g_return_val_if_fail (PULSE_IS_SOURCE (stream), FALSE);
- g_return_val_if_fail (volume != NULL, FALSE);
-
- pulse = PULSE_STREAM (stream);
+ g_return_val_if_fail (PULSE_IS_SOURCE (pstream), FALSE);
+ g_return_val_if_fail (cvolume != NULL, FALSE);
 
- return pulse_connection_set_source_volume (pulse_stream_get_connection (pulse),
- pulse_stream_get_index (pulse),
- volume);
+ return pulse_connection_set_source_volume (pulse_stream_get_connection (pstream),
+ pulse_stream_get_index (pstream),
+ cvolume);
 }
 
 static gboolean
-source_set_active_port (MateMixerStream *stream, const gchar *port_name)
+pulse_source_set_active_port (PulseStream *pstream, MateMixerPort *port)
 {
- PulseStream *pulse;
+ g_return_val_if_fail (PULSE_IS_SOURCE (pstream), FALSE);
+ g_return_val_if_fail (MATE_MIXER_IS_PORT (port), FALSE);
 
- g_return_val_if_fail (PULSE_IS_SOURCE (stream), FALSE);
- g_return_val_if_fail (port_name != NULL, FALSE);
+ return pulse_connection_set_source_port (pulse_stream_get_connection (pstream),
+ pulse_stream_get_index (pstream),
+ mate_mixer_port_get_name (port));
+}
 
- pulse = PULSE_STREAM (stream);
+static PulseMonitor *
+pulse_source_create_monitor (PulseStream *pstream)
+{
+ g_return_val_if_fail (PULSE_IS_SOURCE (pstream), NULL);
 
- return pulse_connection_set_source_port (pulse_stream_get_connection (pulse),
- pulse_stream_get_index (pulse),
- port_name);
+ return pulse_connection_create_monitor (pulse_stream_get_connection (pstream),
+ pulse_stream_get_index (pstream),
+ PA_INVALID_INDEX);
 }
 
-static PulseMonitor *
-source_create_monitor (MateMixerStream *stream)
+static void
+update_ports (PulseStream *pstream,
+ pa_source_port_info **ports,
+ pa_source_port_info *active)
 {
- PulseStream *pulse;
+ MateMixerPort *port;
+ MateMixerDevice *device;
+ GHashTable *hash;
 
- g_return_val_if_fail (PULSE_IS_SOURCE (stream), NULL);
+ hash = pulse_stream_get_ports (pstream);
 
- pulse = PULSE_STREAM (stream);
+ while (*ports != NULL) {
+ MateMixerPortFlags flags = MATE_MIXER_PORT_NO_FLAGS;
+ pa_source_port_info *info = *ports;
+ const gchar *icon = NULL;
 
- return pulse_connection_create_monitor (pulse_stream_get_connection (pulse),
- pulse_stream_get_index (pulse),
- PA_INVALID_INDEX);
+ device = mate_mixer_stream_get_device (MATE_MIXER_STREAM (pstream));
+ if (device != NULL) {
+ port = mate_mixer_device_get_port (device, info->name);
+
+ if (port != NULL) {
+ flags = mate_mixer_port_get_flags (port);
+ icon = mate_mixer_port_get_icon (port);
+ }
+ }
+
+#if PA_CHECK_VERSION(2, 0, 0)
+ if (info->available == PA_PORT_AVAILABLE_YES)
+ flags |= MATE_MIXER_PORT_AVAILABLE;
+ else
+ flags &= ~MATE_MIXER_PORT_AVAILABLE;
+#endif
+
+ port = g_hash_table_lookup (hash, info->name);
+
+ if (port != NULL) {
+ /* Update existing port */
+ _mate_mixer_port_update_description (port, info->description);
+ _mate_mixer_port_update_icon (port, icon);
+ _mate_mixer_port_update_priority (port, info->priority);
+ _mate_mixer_port_update_flags (port, flags);
+ } else {
+ /* Add previously unknown port to the hash table */
+ port = _mate_mixer_port_new (info->name,
+ info->description,
+ icon,
+ info->priority,
+ flags);
+
+ g_hash_table_insert (hash, g_strdup (info->name), port);
+ }
+
+ ports++;
+ }
+
+ /* Active port */
+ if (G_LIKELY (active != NULL))
+ port = g_hash_table_lookup (hash, active->name);
+ else
+ port = NULL;
+
+ pulse_stream_update_active_port (pstream, port);
 }
diff --git a/backends/pulse/pulse-source.h b/backends/pulse/pulse-source.h
index fc64fe7..9abf6d8 100644
--- a/backends/pulse/pulse-source.h
+++ b/backends/pulse/pulse-source.h
@@ -61,7 +61,7 @@ PulseStream *pulse_source_new (PulseConnection *connection,
 const pa_source_info *info,
 PulseDevice *device);
 
-gboolean pulse_source_update (PulseStream *stream,
+gboolean pulse_source_update (PulseStream *pstream,
 const pa_source_info *info,
 PulseDevice *device);
 
diff --git a/backends/pulse/pulse-stream.c b/backends/pulse/pulse-stream.c
index c7ac52a..fb738ad 100644
--- a/backends/pulse/pulse-stream.c
+++ b/backends/pulse/pulse-stream.c
@@ -15,12 +15,6 @@
 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
 */
 
-// XXX
-// - make sure all functions work correctly with flags
-// - make sure all functions notify
-// - figure out whether functions should g_warning on errors
-// - distinguish MateMixer and Pulse variable names
-
 #include <string.h>
 #include <glib.h>
 #include <glib-object.h>
@@ -40,19 +34,20 @@
 struct _PulseStreamPrivate
 {
 guint32 index;
- guint32 index_device;
 gchar *name;
 gchar *description;
 MateMixerDevice *device;
 MateMixerStreamFlags flags;
 MateMixerStreamState state;
 gboolean mute;
- pa_cvolume volume;
+ guint volume;
+ pa_cvolume cvolume;
 pa_volume_t base_volume;
 pa_channel_map channel_map;
 gfloat balance;
 gfloat fade;
- GList *ports;
+ GHashTable *ports;
+ GList *ports_list;
 MateMixerPort *port;
 PulseConnection *connection;
 PulseMonitor *monitor;
@@ -67,142 +62,197 @@ enum {
 PROP_FLAGS,
 PROP_STATE,
 PROP_MUTE,
- PROP_NUM_CHANNELS,
 PROP_VOLUME,
 PROP_BALANCE,
 PROP_FADE,
- PROP_PORTS,
 PROP_ACTIVE_PORT,
 PROP_INDEX,
- PROP_CONNECTION,
- N_PROPERTIES
+ PROP_CONNECTION
 };
 
-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);
+static void mate_mixer_stream_interface_init (MateMixerStreamInterface *iface);
+
+static void pulse_stream_class_init (PulseStreamClass *klass);
+
+static void pulse_stream_get_property (GObject *object,
+ guint param_id,
+ GValue *value,
+ GParamSpec *pspec);
+static void pulse_stream_set_property (GObject *object,
+ guint param_id,
+ const GValue *value,
+ GParamSpec *pspec);
+
+static void pulse_stream_init (PulseStream *pstream);
+static void pulse_stream_dispose (GObject *object);
+static void pulse_stream_finalize (GObject *object);
 
 G_DEFINE_ABSTRACT_TYPE_WITH_CODE (PulseStream, pulse_stream, G_TYPE_OBJECT,
 G_IMPLEMENT_INTERFACE (MATE_MIXER_TYPE_STREAM,
 mate_mixer_stream_interface_init))
 
-/* Interface implementation */
-static const gchar * stream_get_name (MateMixerStream *stream);
-static const gchar * stream_get_description (MateMixerStream *stream);
-static MateMixerDevice * stream_get_device (MateMixerStream *stream);
-static MateMixerStreamFlags stream_get_flags (MateMixerStream *stream);
-static MateMixerStreamState stream_get_state (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 guint stream_get_volume (MateMixerStream *stream);
-static gboolean stream_set_volume (MateMixerStream *stream,
- guint volume);
-static gdouble stream_get_decibel (MateMixerStream *stream);
-static gboolean stream_set_decibel (MateMixerStream *stream,
- gdouble decibel);
-static MateMixerChannelPosition stream_get_channel_position (MateMixerStream *stream,
- guint channel);
-static guint stream_get_channel_volume (MateMixerStream *stream,
- guint channel);
-static gboolean stream_set_channel_volume (MateMixerStream *stream,
- guint channel,
- guint volume);
-static gdouble stream_get_channel_decibel (MateMixerStream *stream,
- guint channel);
-static gboolean stream_set_channel_decibel (MateMixerStream *stream,
- guint channel,
- gdouble decibel);
-static gboolean stream_has_position (MateMixerStream *stream,
- MateMixerChannelPosition position);
-static guint stream_get_position_volume (MateMixerStream *stream,
- MateMixerChannelPosition position);
-static gboolean stream_set_position_volume (MateMixerStream *stream,
- MateMixerChannelPosition position,
- guint volume);
-static gdouble stream_get_position_decibel (MateMixerStream *stream,
- MateMixerChannelPosition position);
-static gboolean stream_set_position_decibel (MateMixerStream *stream,
- MateMixerChannelPosition position,
- gdouble decibel);
-static gfloat stream_get_balance (MateMixerStream *stream);
-static gboolean stream_set_balance (MateMixerStream *stream,
- gfloat balance);
-static gfloat stream_get_fade (MateMixerStream *stream);
-static gboolean stream_set_fade (MateMixerStream *stream,
- gfloat fade);
-static gboolean stream_suspend (MateMixerStream *stream);
-static gboolean stream_resume (MateMixerStream *stream);
-
-static gboolean stream_monitor_start (MateMixerStream *stream);
-static void stream_monitor_stop (MateMixerStream *stream);
-static gboolean stream_monitor_is_running (MateMixerStream *stream);
-static gboolean stream_monitor_set_name (MateMixerStream *stream,
- const gchar *name);
-static void stream_monitor_value (PulseMonitor *monitor,
- gdouble value,
- 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_name);
-
-static guint stream_get_min_volume (MateMixerStream *stream);
-static guint stream_get_max_volume (MateMixerStream *stream);
-static guint stream_get_normal_volume (MateMixerStream *stream);
-static guint stream_get_base_volume (MateMixerStream *stream);
-
-static gboolean stream_set_cvolume (MateMixerStream *stream,
- pa_cvolume *volume);
-static gint stream_compare_ports (gconstpointer a,
- gconstpointer b);
+static const gchar * pulse_stream_get_name (MateMixerStream *stream);
+static const gchar * pulse_stream_get_description (MateMixerStream *stream);
+static MateMixerDevice * pulse_stream_get_device (MateMixerStream *stream);
+static MateMixerStreamFlags pulse_stream_get_flags (MateMixerStream *stream);
+static MateMixerStreamState pulse_stream_get_state (MateMixerStream *stream);
+
+static gboolean pulse_stream_get_mute (MateMixerStream *stream);
+static gboolean pulse_stream_set_mute (MateMixerStream *stream,
+ gboolean mute);
+
+static guint pulse_stream_get_num_channels (MateMixerStream *stream);
+
+static guint pulse_stream_get_volume (MateMixerStream *stream);
+static gboolean pulse_stream_set_volume (MateMixerStream *stream,
+ guint volume);
+
+static gdouble pulse_stream_get_decibel (MateMixerStream *stream);
+static gboolean pulse_stream_set_decibel (MateMixerStream *stream,
+ gdouble decibel);
+
+static guint pulse_stream_get_channel_volume (MateMixerStream *stream,
+ guint channel);
+static gboolean pulse_stream_set_channel_volume (MateMixerStream *stream,
+ guint channel,
+ guint volume);
+
+static gdouble pulse_stream_get_channel_decibel (MateMixerStream *stream,
+ guint channel);
+static gboolean pulse_stream_set_channel_decibel (MateMixerStream *stream,
+ guint channel,
+ gdouble decibel);
+
+static MateMixerChannelPosition pulse_stream_get_channel_position (MateMixerStream *stream,
+ guint channel);
+static gboolean pulse_stream_has_channel_position (MateMixerStream *stream,
+ MateMixerChannelPosition position);
+
+static gfloat pulse_stream_get_balance (MateMixerStream *stream);
+static gboolean pulse_stream_set_balance (MateMixerStream *stream,
+ gfloat balance);
+
+static gfloat pulse_stream_get_fade (MateMixerStream *stream);
+static gboolean pulse_stream_set_fade (MateMixerStream *stream,
+ gfloat fade);
+
+static gboolean pulse_stream_suspend (MateMixerStream *stream);
+static gboolean pulse_stream_resume (MateMixerStream *stream);
+
+static gboolean pulse_stream_monitor_start (MateMixerStream *stream);
+static void pulse_stream_monitor_stop (MateMixerStream *stream);
+static gboolean pulse_stream_monitor_is_running (MateMixerStream *stream);
+static gboolean pulse_stream_monitor_set_name (MateMixerStream *stream,
+ const gchar *name);
+
+static const GList * pulse_stream_list_ports (MateMixerStream *stream);
+
+static MateMixerPort * pulse_stream_get_active_port (MateMixerStream *stream);
+static gboolean pulse_stream_set_active_port (MateMixerStream *stream,
+ MateMixerPort *port);
+
+static guint pulse_stream_get_min_volume (MateMixerStream *stream);
+static guint pulse_stream_get_max_volume (MateMixerStream *stream);
+static guint pulse_stream_get_normal_volume (MateMixerStream *stream);
+static guint pulse_stream_get_base_volume (MateMixerStream *stream);
+
+static void on_monitor_value (PulseMonitor *monitor,
+ gdouble value,
+ PulseStream *pstream);
+
+static gboolean update_balance_fade (PulseStream *pstream);
+
+static gboolean set_cvolume (PulseStream *pstream,
+ pa_cvolume *cvolume);
+
+static gint compare_ports (gconstpointer a,
+ gconstpointer b);
 
 static void
 mate_mixer_stream_interface_init (MateMixerStreamInterface *iface)
 {
- iface->get_name = stream_get_name;
- iface->get_description = stream_get_description;
- iface->get_device = stream_get_device;
- iface->get_flags = stream_get_flags;
- iface->get_state = stream_get_state;
- 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_decibel = stream_get_decibel;
- iface->set_decibel = stream_set_decibel;
- 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_decibel = stream_get_channel_decibel;
- iface->set_channel_decibel = stream_set_channel_decibel;
- 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_decibel = stream_get_position_decibel;
- iface->set_position_decibel = stream_set_position_decibel;
- 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->monitor_start = stream_monitor_start;
- iface->monitor_stop = stream_monitor_stop;
- iface->monitor_is_running = stream_monitor_is_running;
- iface->monitor_set_name = stream_monitor_set_name;
- 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;
- iface->get_base_volume = stream_get_base_volume;
+ iface->get_name = pulse_stream_get_name;
+ iface->get_description = pulse_stream_get_description;
+ iface->get_device = pulse_stream_get_device;
+ iface->get_flags = pulse_stream_get_flags;
+ iface->get_state = pulse_stream_get_state;
+ iface->get_mute = pulse_stream_get_mute;
+ iface->set_mute = pulse_stream_set_mute;
+ iface->get_num_channels = pulse_stream_get_num_channels;
+ iface->get_volume = pulse_stream_get_volume;
+ iface->set_volume = pulse_stream_set_volume;
+ iface->get_decibel = pulse_stream_get_decibel;
+ iface->set_decibel = pulse_stream_set_decibel;
+ iface->get_channel_volume = pulse_stream_get_channel_volume;
+ iface->set_channel_volume = pulse_stream_set_channel_volume;
+ iface->get_channel_decibel = pulse_stream_get_channel_decibel;
+ iface->set_channel_decibel = pulse_stream_set_channel_decibel;
+ iface->get_channel_position = pulse_stream_get_channel_position;
+ iface->has_channel_position = pulse_stream_has_channel_position;
+ iface->get_balance = pulse_stream_get_balance;
+ iface->set_balance = pulse_stream_set_balance;
+ iface->get_fade = pulse_stream_get_fade;
+ iface->set_fade = pulse_stream_set_fade;
+ iface->suspend = pulse_stream_suspend;
+ iface->resume = pulse_stream_resume;
+ iface->monitor_start = pulse_stream_monitor_start;
+ iface->monitor_stop = pulse_stream_monitor_stop;
+ iface->monitor_is_running = pulse_stream_monitor_is_running;
+ iface->monitor_set_name = pulse_stream_monitor_set_name;
+ iface->list_ports = pulse_stream_list_ports;
+ iface->get_active_port = pulse_stream_get_active_port;
+ iface->set_active_port = pulse_stream_set_active_port;
+ iface->get_min_volume = pulse_stream_get_min_volume;
+ iface->get_max_volume = pulse_stream_get_max_volume;
+ iface->get_normal_volume = pulse_stream_get_normal_volume;
+ iface->get_base_volume = pulse_stream_get_base_volume;
+}
+
+static void
+pulse_stream_class_init (PulseStreamClass *klass)
+{
+ GObjectClass *object_class;
+
+ object_class = G_OBJECT_CLASS (klass);
+ 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_DEVICE, "device");
+ g_object_class_override_property (object_class, PROP_FLAGS, "flags");
+ g_object_class_override_property (object_class, PROP_STATE, "state");
+ g_object_class_override_property (object_class, PROP_MUTE, "mute");
+ g_object_class_override_property (object_class, PROP_VOLUME, "volume");
+ 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
@@ -211,52 +261,46 @@ pulse_stream_get_property (GObject *object,
 GValue *value,
 GParamSpec *pspec)
 {
- PulseStream *stream;
+ PulseStream *pstream;
 
- stream = PULSE_STREAM (object);
+ pstream = PULSE_STREAM (object);
 
 switch (param_id) {
 case PROP_NAME:
- g_value_set_string (value, stream->priv->name);
+ g_value_set_string (value, pstream->priv->name);
 break;
 case PROP_DESCRIPTION:
- g_value_set_string (value, stream->priv->description);
+ g_value_set_string (value, pstream->priv->description);
 break;
 case PROP_DEVICE:
- g_value_set_object (value, stream->priv->device);
+ g_value_set_object (value, pstream->priv->device);
 break;
 case PROP_FLAGS:
- g_value_set_flags (value, stream->priv->flags);
+ g_value_set_flags (value, pstream->priv->flags);
 break;
 case PROP_STATE:
- g_value_set_enum (value, stream->priv->state);
+ g_value_set_enum (value, pstream->priv->state);
 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)));
+ g_value_set_boolean (value, pstream->priv->mute);
 break;
 case PROP_VOLUME:
- g_value_set_int64 (value, stream_get_volume (MATE_MIXER_STREAM (stream)));
+ g_value_set_uint (value, pstream->priv->volume);
 break;
 case PROP_BALANCE:
- g_value_set_float (value, stream->priv->balance);
+ g_value_set_float (value, pstream->priv->balance);
 break;
 case PROP_FADE:
- g_value_set_float (value, stream->priv->fade);
- break;
- case PROP_PORTS:
- g_value_set_pointer (value, stream->priv->ports);
+ g_value_set_float (value, pstream->priv->fade);
 break;
 case PROP_ACTIVE_PORT:
- g_value_set_object (value, stream->priv->port);
+ g_value_set_object (value, pstream->priv->port);
 break;
 case PROP_INDEX:
- g_value_set_uint (value, stream->priv->index);
+ g_value_set_uint (value, pstream->priv->index);
 break;
 case PROP_CONNECTION:
- g_value_set_object (value, stream->priv->connection);
+ g_value_set_object (value, pstream->priv->connection);
 break;
 default:
 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
@@ -270,17 +314,17 @@ pulse_stream_set_property (GObject *object,
 const GValue *value,
 GParamSpec *pspec)
 {
- PulseStream *stream;
+ PulseStream *pstream;
 
- stream = PULSE_STREAM (object);
+ pstream = PULSE_STREAM (object);
 
 switch (param_id) {
 case PROP_INDEX:
- stream->priv->index = g_value_get_uint (value);
+ pstream->priv->index = g_value_get_uint (value);
 break;
 case PROP_CONNECTION:
 /* Construct-only object */
- stream->priv->connection = g_value_dup_object (value);
+ pstream->priv->connection = g_value_dup_object (value);
 break;
 default:
 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
@@ -289,78 +333,41 @@ pulse_stream_set_property (GObject *object,
 }
 
 static void
-pulse_stream_class_init (PulseStreamClass *klass)
+pulse_stream_init (PulseStream *pstream)
 {
- GObjectClass *object_class;
-
- object_class = G_OBJECT_CLASS (klass);
- 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));
+ pstream->priv = G_TYPE_INSTANCE_GET_PRIVATE (pstream,
+ PULSE_TYPE_STREAM,
+ PulseStreamPrivate);
 
- 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));
+ pstream->priv->ports = g_hash_table_new_full (g_str_hash,
+ g_str_equal,
+ g_free,
+ g_object_unref);
 
- 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_DEVICE, "device");
- g_object_class_override_property (object_class, PROP_FLAGS, "flags");
- g_object_class_override_property (object_class, PROP_STATE, "state");
- 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_BALANCE, "balance");
- g_object_class_override_property (object_class, PROP_FADE, "fade");
- g_object_class_override_property (object_class, PROP_PORTS, "ports");
- g_object_class_override_property (object_class, PROP_ACTIVE_PORT, "active-port");
-
- g_type_class_add_private (object_class, sizeof (PulseStreamPrivate));
-}
+ /* Initialize empty volume and channel map structures, they will be used
+ * if the stream does not support volume */
+ pa_cvolume_init (&pstream->priv->cvolume);
 
-static void
-pulse_stream_init (PulseStream *stream)
-{
- stream->priv = G_TYPE_INSTANCE_GET_PRIVATE (stream,
- PULSE_TYPE_STREAM,
- PulseStreamPrivate);
+ pa_channel_map_init (&pstream->priv->channel_map);
 }
 
 static void
 pulse_stream_dispose (GObject *object)
 {
- PulseStream *stream;
+ PulseStream *pstream;
 
- stream = PULSE_STREAM (object);
+ pstream = PULSE_STREAM (object);
 
- if (stream->priv->ports) {
- g_list_free_full (stream->priv->ports, g_object_unref);
- stream->priv->ports = NULL;
+ if (pstream->priv->ports_list != NULL) {
+ g_list_free_full (pstream->priv->ports_list, g_object_unref);
+ pstream->priv->ports_list = NULL;
 }
+ g_hash_table_remove_all (pstream->priv->ports);
 
- g_clear_object (&stream->priv->port);
- g_clear_object (&stream->priv->device);
- g_clear_object (&stream->priv->monitor);
- g_clear_object (&stream->priv->connection);
+ g_clear_object (&pstream->priv->port);
+ g_clear_object (&pstream->priv->device);
+ g_clear_object (&pstream->priv->monitor);
+ g_clear_object (&pstream->priv->connection);
 
 G_OBJECT_CLASS (pulse_stream_parent_class)->dispose (object);
 }
@@ -368,220 +375,261 @@ pulse_stream_dispose (GObject *object)
 static void
 pulse_stream_finalize (GObject *object)
 {
- PulseStream *stream;
+ PulseStream *pstream;
 
- stream = PULSE_STREAM (object);
+ pstream = PULSE_STREAM (object);
 
- g_free (stream->priv->name);
- g_free (stream->priv->description);
+ g_free (pstream->priv->name);
+ g_free (pstream->priv->description);
+ g_free (pstream->priv->monitor_name);
+
+ g_hash_table_destroy (pstream->priv->ports);
 
 G_OBJECT_CLASS (pulse_stream_parent_class)->finalize (object);
 }
 
 guint32
-pulse_stream_get_index (PulseStream *stream)
+pulse_stream_get_index (PulseStream *pstream)
 {
- g_return_val_if_fail (PULSE_IS_STREAM (stream), 0);
+ g_return_val_if_fail (PULSE_IS_STREAM (pstream), 0);
 
- return stream->priv->index;
+ return pstream->priv->index;
 }
 
 PulseConnection *
-pulse_stream_get_connection (PulseStream *stream)
+pulse_stream_get_connection (PulseStream *pstream)
 {
- g_return_val_if_fail (PULSE_IS_STREAM (stream), NULL);
+ g_return_val_if_fail (PULSE_IS_STREAM (pstream), NULL);
 
- return stream->priv->connection;
+ return pstream->priv->connection;
 }
 
 PulseMonitor *
-pulse_stream_get_monitor (PulseStream *stream)
+pulse_stream_get_monitor (PulseStream *pstream)
 {
- g_return_val_if_fail (PULSE_IS_STREAM (stream), NULL);
+ g_return_val_if_fail (PULSE_IS_STREAM (pstream), NULL);
 
- return stream->priv->monitor;
+ return pstream->priv->monitor;
+}
+
+const pa_cvolume *
+pulse_stream_get_cvolume (PulseStream *pstream)
+{
+ g_return_val_if_fail (PULSE_IS_STREAM (pstream), NULL);
+
+ return &pstream->priv->cvolume;
+}
+
+const pa_channel_map *
+pulse_stream_get_channel_map (PulseStream *pstream)
+{
+ g_return_val_if_fail (PULSE_IS_STREAM (pstream), NULL);
+
+ return &pstream->priv->channel_map;
+}
+
+GHashTable *
+pulse_stream_get_ports (PulseStream *pstream)
+{
+ g_return_val_if_fail (PULSE_IS_STREAM (pstream), NULL);
+
+ return pstream->priv->ports;
 }
 
 gboolean
-pulse_stream_update_name (PulseStream *stream, const gchar *name)
+pulse_stream_update_name (PulseStream *pstream, const gchar *name)
 {
- g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+ g_return_val_if_fail (PULSE_IS_STREAM (pstream), FALSE);
 
 /* Allow the name to be NULL */
- if (g_strcmp0 (name, stream->priv->name)) {
- g_free (stream->priv->name);
- stream->priv->name = g_strdup (name);
+ if (g_strcmp0 (name, pstream->priv->name) != 0) {
+ g_free (pstream->priv->name);
+ pstream->priv->name = g_strdup (name);
 
- g_object_notify (G_OBJECT (stream), "name");
+ g_object_notify (G_OBJECT (pstream), "name");
+ return TRUE;
 }
- return TRUE;
+ return FALSE;
 }
 
 gboolean
-pulse_stream_update_description (PulseStream *stream, const gchar *description)
+pulse_stream_update_description (PulseStream *pstream, const gchar *description)
 {
- g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+ g_return_val_if_fail (PULSE_IS_STREAM (pstream), 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);
+ if (g_strcmp0 (description, pstream->priv->description) != 0) {
+ g_free (pstream->priv->description);
+ pstream->priv->description = g_strdup (description);
 
- g_object_notify (G_OBJECT (stream), "description");
+ g_object_notify (G_OBJECT (pstream), "description");
+ return TRUE;
 }
- return TRUE;
+ return FALSE;
 }
 
 gboolean
-pulse_stream_update_device (PulseStream *stream, MateMixerDevice *device)
+pulse_stream_update_device (PulseStream *pstream, MateMixerDevice *device)
 {
- g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+ g_return_val_if_fail (PULSE_IS_STREAM (pstream), FALSE);
 
- if (stream->priv->device != device) {
- g_clear_object (&stream->priv->device);
+ if (pstream->priv->device != device) {
+ g_clear_object (&pstream->priv->device);
 
 if (G_LIKELY (device != NULL))
- stream->priv->device = g_object_ref (device);
+ pstream->priv->device = g_object_ref (device);
 
- g_object_notify (G_OBJECT (stream), "device");
+ g_object_notify (G_OBJECT (pstream), "device");
+ return TRUE;
 }
- return TRUE;
+ return FALSE;
 }
 
 gboolean
-pulse_stream_update_flags (PulseStream *stream, MateMixerStreamFlags flags)
+pulse_stream_update_flags (PulseStream *pstream, MateMixerStreamFlags flags)
 {
- g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+ g_return_val_if_fail (PULSE_IS_STREAM (pstream), FALSE);
+
+ if (pstream->priv->flags != flags) {
+ pstream->priv->flags = flags;
 
- if (stream->priv->flags != flags) {
- stream->priv->flags = flags;
- g_object_notify (G_OBJECT (stream), "flags");
+ g_object_notify (G_OBJECT (pstream), "flags");
+ return TRUE;
 }
- return TRUE;
+ return FALSE;
 }
 
 gboolean
-pulse_stream_update_state (PulseStream *stream, MateMixerStreamState state)
+pulse_stream_update_state (PulseStream *pstream, MateMixerStreamState state)
 {
- g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+ g_return_val_if_fail (PULSE_IS_STREAM (pstream), FALSE);
 
- if (stream->priv->state != state) {
- stream->priv->state = state;
- g_object_notify (G_OBJECT (stream), "state");
+ if (pstream->priv->state != state) {
+ pstream->priv->state = state;
+
+ g_object_notify (G_OBJECT (pstream), "state");
+ return TRUE;
 }
- return TRUE;
+ return FALSE;
 }
 
 gboolean
-pulse_stream_update_mute (PulseStream *stream, gboolean mute)
+pulse_stream_update_channel_map (PulseStream *pstream, const pa_channel_map *map)
 {
- g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+ MateMixerStreamFlags flags;
 
- if (stream->priv->mute != mute) {
- stream->priv->mute = mute;
- g_object_notify (G_OBJECT (stream), "mute");
+ g_return_val_if_fail (PULSE_IS_STREAM (pstream), FALSE);
+ g_return_val_if_fail (map != NULL, FALSE);
+
+ flags = pstream->priv->flags;
+
+ if (pa_channel_map_valid (map)) {
+ if (pa_channel_map_can_balance (map))
+ flags |= MATE_MIXER_STREAM_CAN_BALANCE;
+ else
+ flags &= ~MATE_MIXER_STREAM_CAN_BALANCE;
+
+ if (pa_channel_map_can_fade (map))
+ flags |= MATE_MIXER_STREAM_CAN_FADE;
+ else
+ flags &= ~MATE_MIXER_STREAM_CAN_FADE;
+
+ pstream->priv->channel_map = *map;
+ } else {
+ flags &= ~(MATE_MIXER_STREAM_CAN_BALANCE | MATE_MIXER_STREAM_CAN_FADE);
+
+ /* If the channel map is not valid, create an empty channel map, which
+ * also won't validate, but at least we know what it is */
+ pa_channel_map_init (&pstream->priv->channel_map);
 }
+
+ pulse_stream_update_flags (pstream, flags);
 return TRUE;
 }
 
 gboolean
-pulse_stream_update_volume (PulseStream *stream,
- const pa_cvolume *volume,
- const pa_channel_map *map,
- pa_volume_t base_volume)
+pulse_stream_update_volume (PulseStream *pstream,
+ const pa_cvolume *cvolume,
+ pa_volume_t base_volume)
 {
- gfloat fade = 0.0f;
- gfloat balance = 0.0f;
+ MateMixerStreamFlags flags;
 
- g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+ g_return_val_if_fail (PULSE_IS_STREAM (pstream), FALSE);
 
- /* The channel map should be always present, but volume is not always
- * supported and might be NULL */
- if (G_LIKELY (map != NULL)) {
- if (!pa_channel_map_equal (&stream->priv->channel_map, map))
- stream->priv->channel_map = *map;
- }
+ /* The base volume is not a property */
+ pstream->priv->base_volume = base_volume;
 
- if (volume != NULL) {
- if (!pa_cvolume_equal (&stream->priv->volume, volume)) {
- stream->priv->volume = *volume;
+ flags = pstream->priv->flags;
 
- g_object_notify (G_OBJECT (stream), "volume");
- }
+ if (cvolume != NULL && pa_cvolume_valid (cvolume)) {
+ /* Decibel volume and volume settability flags must be provided by
+ * the implementation */
+ flags |= MATE_MIXER_STREAM_HAS_VOLUME;
 
- stream->priv->base_volume = (base_volume > 0)
- ? base_volume
- : PA_VOLUME_NORM;
+ if (pa_cvolume_equal (&pstream->priv->cvolume, cvolume) == 0) {
+ pstream->priv->cvolume = *cvolume;
+ pstream->priv->volume = (guint) pa_cvolume_max (&pstream->priv->cvolume);
 
- /* Fade and balance need a valid channel map and volume, otherwise
- * compare against the default values */
- fade = pa_cvolume_get_fade (volume, &stream->priv->channel_map);
- balance = pa_cvolume_get_balance (volume, &stream->priv->channel_map);
+ g_object_notify (G_OBJECT (pstream), "volume");
+ }
 } else {
- stream->priv->base_volume = PA_VOLUME_NORM;
- }
+ flags &= ~(MATE_MIXER_STREAM_HAS_VOLUME |
+ MATE_MIXER_STREAM_HAS_DECIBEL_VOLUME |
+ MATE_MIXER_STREAM_CAN_SET_VOLUME);
 
- if (stream->priv->balance != balance) {
- stream->priv->balance = balance;
- g_object_notify (G_OBJECT (stream), "balance");
- }
+ /* If the cvolume is not valid, create an empty cvolume, which also
+ * won't validate, but at least we know what it is */
+ pa_cvolume_init (&pstream->priv->cvolume);
+
+ if (pstream->priv->volume != (guint) PA_VOLUME_MUTED) {
+ pstream->priv->volume = (guint) PA_VOLUME_MUTED;
 
- if (stream->priv->fade != fade) {
- stream->priv->fade = fade;
- g_object_notify (G_OBJECT (stream), "fade");
+ g_object_notify (G_OBJECT (pstream), "volume");
+ }
 }
+
+ pulse_stream_update_flags (pstream, flags);
+
+ /* Changing volume may change the balance and fade values as well */
+ update_balance_fade (pstream);
 return TRUE;
 }
 
 gboolean
-pulse_stream_update_ports (PulseStream *stream, GList *ports)
+pulse_stream_update_mute (PulseStream *pstream, gboolean mute)
 {
- g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+ g_return_val_if_fail (PULSE_IS_STREAM (pstream), FALSE);
 
- if (stream->priv->ports)
- g_list_free_full (stream->priv->ports, g_object_unref);
+ if (pstream->priv->mute != mute) {
+ pstream->priv->mute = mute;
 
- if (ports)
- stream->priv->ports = g_list_sort (ports, stream_compare_ports);
- else
- stream->priv->ports = NULL;
-
- g_object_notify (G_OBJECT (stream), "ports");
- return TRUE;
+ g_object_notify (G_OBJECT (pstream), "mute");
+ return TRUE;
+ }
+ return FALSE;
 }
 
 gboolean
-pulse_stream_update_active_port (PulseStream *stream, const gchar *port_name)
+pulse_stream_update_active_port (PulseStream *pstream, MateMixerPort *port)
 {
- GList *list;
- MateMixerPort *port = NULL;
+ g_return_val_if_fail (PULSE_IS_STREAM (pstream), FALSE);
+ g_return_val_if_fail (MATE_MIXER_IS_PORT (port), FALSE);
 
- 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 (pstream->priv->port != port) {
+ if (pstream->priv->port != NULL)
+ g_clear_object (&pstream->priv->port);
 
- if (stream->priv->port != port) {
- if (stream->priv->port)
- g_clear_object (&stream->priv->port);
- if (port)
- stream->priv->port = g_object_ref (port);
+ if (port != NULL)
+ pstream->priv->port = g_object_ref (port);
 
- g_object_notify (G_OBJECT (stream), "active-port");
+ g_object_notify (G_OBJECT (pstream), "active-port");
+ return TRUE;
 }
- return TRUE;
+ return FALSE;
 }
 
 static const gchar *
-stream_get_name (MateMixerStream *stream)
+pulse_stream_get_name (MateMixerStream *stream)
 {
 g_return_val_if_fail (PULSE_IS_STREAM (stream), NULL);
 
@@ -589,7 +637,7 @@ stream_get_name (MateMixerStream *stream)
 }
 
 static const gchar *
-stream_get_description (MateMixerStream *stream)
+pulse_stream_get_description (MateMixerStream *stream)
 {
 g_return_val_if_fail (PULSE_IS_STREAM (stream), NULL);
 
@@ -597,7 +645,7 @@ stream_get_description (MateMixerStream *stream)
 }
 
 static MateMixerDevice *
-stream_get_device (MateMixerStream *stream)
+pulse_stream_get_device (MateMixerStream *stream)
 {
 g_return_val_if_fail (PULSE_IS_STREAM (stream), NULL);
 
@@ -605,7 +653,7 @@ stream_get_device (MateMixerStream *stream)
 }
 
 static MateMixerStreamFlags
-stream_get_flags (MateMixerStream *stream)
+pulse_stream_get_flags (MateMixerStream *stream)
 {
 g_return_val_if_fail (PULSE_IS_STREAM (stream), MATE_MIXER_STREAM_NO_FLAGS);
 
@@ -613,269 +661,253 @@ stream_get_flags (MateMixerStream *stream)
 }
 
 static MateMixerStreamState
-stream_get_state (MateMixerStream *stream)
+pulse_stream_get_state (MateMixerStream *stream)
 {
- g_return_val_if_fail (PULSE_IS_STREAM (stream), MATE_MIXER_STREAM_UNKNOWN_STATE);
+ g_return_val_if_fail (PULSE_IS_STREAM (stream), MATE_MIXER_STREAM_STATE_UNKNOWN);
 
 return PULSE_STREAM (stream)->priv->state;
 }
 
 static gboolean
-stream_get_mute (MateMixerStream *stream)
+pulse_stream_get_mute (MateMixerStream *stream)
 {
+ PulseStream *pstream;
+
 g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
 
- return PULSE_STREAM (stream)->priv->mute;
+ pstream = PULSE_STREAM (stream);
+
+ if (!(pstream->priv->flags & MATE_MIXER_STREAM_HAS_MUTE))
+ return FALSE;
+
+ return pstream->priv->mute;
 }
 
 static gboolean
-stream_set_mute (MateMixerStream *stream, gboolean mute)
+pulse_stream_set_mute (MateMixerStream *stream, gboolean mute)
 {
- PulseStream *pulse;
+ PulseStream *pstream;
 
 g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
 
- pulse = PULSE_STREAM (stream);
+ pstream = PULSE_STREAM (stream);
+
+ if (!(pstream->priv->flags & MATE_MIXER_STREAM_HAS_MUTE))
+ return FALSE;
 
- if (pulse->priv->mute != mute) {
- if (PULSE_STREAM_GET_CLASS (stream)->set_mute (stream, mute) == FALSE)
+ if (pstream->priv->mute != mute) {
+ PulseStreamClass *klass = PULSE_STREAM_GET_CLASS (pstream);
+
+ if (klass->set_mute (pstream, mute) == FALSE)
 return FALSE;
 
- pulse->priv->mute = mute;
+ pstream->priv->mute = mute;
+
 g_object_notify (G_OBJECT (stream), "mute");
 }
 return TRUE;
 }
 
 static guint
-stream_get_num_channels (MateMixerStream *stream)
+pulse_stream_get_num_channels (MateMixerStream *stream)
 {
 g_return_val_if_fail (PULSE_IS_STREAM (stream), 0);
 
- return PULSE_STREAM (stream)->priv->volume.channels;
+ return PULSE_STREAM (stream)->priv->channel_map.channels;
 }
 
 static guint
-stream_get_volume (MateMixerStream *stream)
+pulse_stream_get_volume (MateMixerStream *stream)
 {
- g_return_val_if_fail (PULSE_IS_STREAM (stream), 0);
+ PulseStream *pstream;
+
+ g_return_val_if_fail (PULSE_IS_STREAM (stream), (guint) PA_VOLUME_MUTED);
+
+ pstream = PULSE_STREAM (stream);
 
- return (guint) pa_cvolume_max (&PULSE_STREAM (stream)->priv->volume);
+ if (!(pstream->priv->flags & MATE_MIXER_STREAM_HAS_VOLUME))
+ return (guint) PA_VOLUME_MUTED;
+
+ return pstream->priv->volume;
 }
 
 static gboolean
-stream_set_volume (MateMixerStream *stream, guint volume)
+pulse_stream_set_volume (MateMixerStream *stream, guint volume)
 {
- PulseStream *pulse;
- pa_cvolume cvolume;
+ PulseStream *pstream;
+ pa_cvolume cvolume;
 
 g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
 
- if (!(mate_mixer_stream_get_flags (stream) & MATE_MIXER_STREAM_CAN_SET_VOLUME))
+ pstream = PULSE_STREAM (stream);
+
+ if (!(pstream->priv->flags & MATE_MIXER_STREAM_CAN_SET_VOLUME))
 return FALSE;
 
- pulse = PULSE_STREAM (stream);
- cvolume = pulse->priv->volume;
+ cvolume = pstream->priv->cvolume;
 
 if (pa_cvolume_scale (&cvolume, (pa_volume_t) volume) == NULL)
 return FALSE;
 
- return stream_set_cvolume (stream, &cvolume);
+ return set_cvolume (pstream, &cvolume);
 }
 
 static gdouble
-stream_get_decibel (MateMixerStream *stream)
+pulse_stream_get_decibel (MateMixerStream *stream)
 {
- gdouble value;
+ PulseStream *pstream;
+ gdouble value;
 
 g_return_val_if_fail (PULSE_IS_STREAM (stream), -MATE_MIXER_INFINITY);
 
- if (!(mate_mixer_stream_get_flags (stream) & MATE_MIXER_STREAM_HAS_DECIBEL_VOLUME))
+ pstream = PULSE_STREAM (stream);
+
+ if (!(pstream->priv->flags & MATE_MIXER_STREAM_HAS_DECIBEL_VOLUME))
 return -MATE_MIXER_INFINITY;
 
- value = pa_sw_volume_to_dB (stream_get_volume (stream));
+ value = pa_sw_volume_to_dB (pulse_stream_get_volume (stream));
 
+ /* PA_VOLUME_MUTED is converted to PA_DECIBEL_MININFTY */
 return (value == PA_DECIBEL_MININFTY) ? -MATE_MIXER_INFINITY : value;
 }
 
 static gboolean
-stream_set_decibel (MateMixerStream *stream, gdouble decibel)
+pulse_stream_set_decibel (MateMixerStream *stream, gdouble decibel)
 {
- g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
-
- if (!(mate_mixer_stream_get_flags (stream) & MATE_MIXER_STREAM_HAS_DECIBEL_VOLUME) ||
- !(mate_mixer_stream_get_flags (stream) & MATE_MIXER_STREAM_CAN_SET_VOLUME))
- return FALSE;
-
- return stream_set_volume (stream, pa_sw_volume_from_dB (decibel));
-}
+ PulseStream *pstream;
 
-static MateMixerChannelPosition
-stream_get_channel_position (MateMixerStream *stream, guint channel)
-{
- PulseStream *pulse;
-
- g_return_val_if_fail (PULSE_IS_STREAM (stream), MATE_MIXER_CHANNEL_UNKNOWN_POSITION);
+ g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
 
- pulse = PULSE_STREAM (stream);
+ pstream = PULSE_STREAM (stream);
 
- if (channel >= pulse->priv->channel_map.channels)
- return MATE_MIXER_CHANNEL_UNKNOWN_POSITION;
+ if (!(pstream->priv->flags & MATE_MIXER_STREAM_HAS_DECIBEL_VOLUME) ||
+ !(pstream->priv->flags & MATE_MIXER_STREAM_CAN_SET_VOLUME))
+ return FALSE;
 
- return pulse_convert_position_to_pulse (pulse->priv->channel_map.map[channel]);
+ return pulse_stream_set_volume (stream, pa_sw_volume_from_dB (decibel));
 }
 
 static guint
-stream_get_channel_volume (MateMixerStream *stream, guint channel)
+pulse_stream_get_channel_volume (MateMixerStream *stream, guint channel)
 {
- PulseStream *pulse;
+ PulseStream *pstream;
 
- g_return_val_if_fail (PULSE_IS_STREAM (stream), 0);
+ g_return_val_if_fail (PULSE_IS_STREAM (stream), (guint) PA_VOLUME_MUTED);
+
+ pstream = PULSE_STREAM (stream);
 
- pulse = PULSE_STREAM (stream);
+ if (!(pstream->priv->flags & MATE_MIXER_STREAM_HAS_VOLUME))
+ return (guint) PA_VOLUME_MUTED;
 
- if (channel >= pulse->priv->volume.channels)
- return stream_get_min_volume (stream);
+ if (channel >= pstream->priv->cvolume.channels)
+ return (guint) PA_VOLUME_MUTED;
 
- return (guint) pulse->priv->volume.values[channel];
+ return (guint) pstream->priv->cvolume.values[channel];
 }
 
 static gboolean
-stream_set_channel_volume (MateMixerStream *stream, guint channel, guint volume)
+pulse_stream_set_channel_volume (MateMixerStream *stream, guint channel, guint volume)
 {
- PulseStream *pulse;
- pa_cvolume cvolume;
+ PulseStream *pstream;
+ pa_cvolume cvolume;
 
 g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
 
- pulse = PULSE_STREAM (stream);
- cvolume = pulse->priv->volume;
+ pstream = PULSE_STREAM (stream);
+
+ if (!(pstream->priv->flags & MATE_MIXER_STREAM_CAN_SET_VOLUME))
+ return FALSE;
 
- if (channel >= pulse->priv->volume.channels)
+ if (channel >= pstream->priv->cvolume.channels)
 return FALSE;
 
+ /* This is safe, because the cvolume is validated by set_cvolume() */
+ cvolume = pstream->priv->cvolume;
 cvolume.values[channel] = (pa_volume_t) volume;
 
- return stream_set_cvolume (stream, &cvolume);
+ return set_cvolume (pstream, &cvolume);
 }
 
 static gdouble
-stream_get_channel_decibel (MateMixerStream *stream, guint channel)
+pulse_stream_get_channel_decibel (MateMixerStream *stream, guint channel)
 {
- PulseStream *pulse;
+ PulseStream *pstream;
 gdouble value;
 
 g_return_val_if_fail (PULSE_IS_STREAM (stream), -MATE_MIXER_INFINITY);
 
- if (!(mate_mixer_stream_get_flags (stream) & MATE_MIXER_STREAM_HAS_DECIBEL_VOLUME))
- return -MATE_MIXER_INFINITY;
+ pstream = PULSE_STREAM (stream);
 
- pulse = PULSE_STREAM (stream);
+ if (!(pstream->priv->flags & MATE_MIXER_STREAM_HAS_DECIBEL_VOLUME))
+ return -MATE_MIXER_INFINITY;
 
- if (channel >= pulse->priv->volume.channels)
+ if (channel >= pstream->priv->cvolume.channels)
 return -MATE_MIXER_INFINITY;
 
- value = pa_sw_volume_to_dB (pulse->priv->volume.values[channel]);
+ value = pa_sw_volume_to_dB (pstream->priv->cvolume.values[channel]);
 
 return (value == PA_DECIBEL_MININFTY) ? -MATE_MIXER_INFINITY : value;
 }
 
 static gboolean
-stream_set_channel_decibel (MateMixerStream *stream,
- guint channel,
- gdouble decibel)
+pulse_stream_set_channel_decibel (MateMixerStream *stream,
+ guint channel,
+ gdouble decibel)
 {
+ PulseStream *pstream;
+
 g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
 
- if (!(mate_mixer_stream_get_flags (stream) & MATE_MIXER_STREAM_HAS_DECIBEL_VOLUME) ||
- !(mate_mixer_stream_get_flags (stream) & MATE_MIXER_STREAM_CAN_SET_VOLUME))
+ pstream = PULSE_STREAM (stream);
+
+ if (!(pstream->priv->flags & MATE_MIXER_STREAM_HAS_DECIBEL_VOLUME) ||
+ !(pstream->priv->flags & MATE_MIXER_STREAM_CAN_SET_VOLUME))
 return FALSE;
 
- return stream_set_channel_volume (stream, channel, pa_sw_volume_from_dB (decibel));
+ return pulse_stream_set_channel_volume (stream, channel, pa_sw_volume_from_dB (decibel));
 }
 
-static gboolean
-stream_has_position (MateMixerStream *stream, MateMixerChannelPosition position)
+static MateMixerChannelPosition
+pulse_stream_get_channel_position (MateMixerStream *stream, guint channel)
 {
- PulseStream *pulse;
-
- g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
-
- pulse = PULSE_STREAM (stream);
+ PulseStream *pstream;
 
- return pa_channel_map_has_position (&pulse->priv->channel_map,
- pulse_convert_position_to_pulse (position));
-}
-
-static guint
-stream_get_position_volume (MateMixerStream *stream,
- MateMixerChannelPosition position)
-{
- PulseStream *pulse;
+ g_return_val_if_fail (PULSE_IS_STREAM (stream), MATE_MIXER_CHANNEL_UNKNOWN);
 
- g_return_val_if_fail (PULSE_IS_STREAM (stream), 0);
+ pstream = PULSE_STREAM (stream);
 
- pulse = PULSE_STREAM (stream);
+ if (channel >= pstream->priv->channel_map.channels)
+ return MATE_MIXER_CHANNEL_UNKNOWN;
 
- return pa_cvolume_get_position (&pulse->priv->volume,
- &pulse->priv->channel_map,
- pulse_convert_position_to_pulse (position));
+ return pulse_convert_position_to_pulse (pstream->priv->channel_map.map[channel]);
 }
 
 static gboolean
-stream_set_position_volume (MateMixerStream *stream,
- MateMixerChannelPosition position,
- guint volume)
+pulse_stream_has_channel_position (MateMixerStream *stream,
+ MateMixerChannelPosition position)
 {
- PulseStream *pulse;
- pa_cvolume cvolume;
+ PulseStream *pstream;
+ pa_channel_position_t p;
 
 g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
 
- pulse = PULSE_STREAM (stream);
- cvolume = pulse->priv->volume;
-
- if (!pa_cvolume_set_position (&cvolume,
- &pulse->priv->channel_map,
- pulse_convert_position_to_pulse (position),
- (pa_volume_t) volume))
- return FALSE;
-
- return stream_set_cvolume (stream, &cvolume);
-}
-
-static gdouble
-stream_get_position_decibel (MateMixerStream *stream,
- MateMixerChannelPosition position)
-{
- gdouble value;
-
- g_return_val_if_fail (PULSE_IS_STREAM (stream), -MATE_MIXER_INFINITY);
-
- if (!(mate_mixer_stream_get_flags (stream) & MATE_MIXER_STREAM_HAS_DECIBEL_VOLUME))
- return -MATE_MIXER_INFINITY;
-
- value = pa_sw_volume_to_dB (stream_get_position_volume (stream, position));
+ pstream = PULSE_STREAM (stream);
 
- return (value == PA_DECIBEL_MININFTY) ? -MATE_MIXER_INFINITY : value;
-}
-
-static gboolean
-stream_set_position_decibel (MateMixerStream *stream,
- MateMixerChannelPosition position,
- gdouble decibel)
-{
- g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
+ /* Handle invalid position as a special case, otherwise this function would
+ * return TRUE for e.g. unknown index in a default channel map */
+ p = pulse_convert_position_to_pulse (position);
 
- if (!(mate_mixer_stream_get_flags (stream) & MATE_MIXER_STREAM_HAS_DECIBEL_VOLUME) ||
- !(mate_mixer_stream_get_flags (stream) & MATE_MIXER_STREAM_CAN_SET_VOLUME))
+ if (p == PA_CHANNEL_POSITION_INVALID)
 return FALSE;
 
- return stream_set_position_volume (stream, position, pa_sw_volume_from_dB (decibel));
+ if (pa_channel_map_has_position (&pstream->priv->channel_map, p) != 0)
+ return TRUE;
+ else
+ return FALSE;
 }
 
 static gfloat
-stream_get_balance (MateMixerStream *stream)
+pulse_stream_get_balance (MateMixerStream *stream)
 {
 g_return_val_if_fail (PULSE_IS_STREAM (stream), 0.0f);
 
@@ -883,24 +915,28 @@ stream_get_balance (MateMixerStream *stream)
 }
 
 static gboolean
-stream_set_balance (MateMixerStream *stream, gfloat balance)
+pulse_stream_set_balance (MateMixerStream *stream, gfloat balance)
 {
- PulseStream *pulse;
+ PulseStream *pstream;
 pa_cvolume cvolume;
 
 g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
 
- pulse = PULSE_STREAM (stream);
- cvolume = pulse->priv->volume;
+ pstream = PULSE_STREAM (stream);
+
+ if (!(pstream->priv->flags & MATE_MIXER_STREAM_CAN_BALANCE))
+ return FALSE;
+
+ cvolume = pstream->priv->cvolume;
 
- if (pa_cvolume_set_balance (&cvolume, &pulse->priv->channel_map, balance) == NULL)
+ if (pa_cvolume_set_balance (&cvolume, &pstream->priv->channel_map, balance) == NULL)
 return FALSE;
 
- return stream_set_cvolume (stream, &cvolume);
+ return set_cvolume (pstream, &cvolume);
 }
 
 static gfloat
-stream_get_fade (MateMixerStream *stream)
+pulse_stream_get_fade (MateMixerStream *stream)
 {
 g_return_val_if_fail (PULSE_IS_STREAM (stream), 0.0f);
 
@@ -908,138 +944,178 @@ stream_get_fade (MateMixerStream *stream)
 }
 
 static gboolean
-stream_set_fade (MateMixerStream *stream, gfloat fade)
+pulse_stream_set_fade (MateMixerStream *stream, gfloat fade)
 {
- PulseStream *pulse;
+ PulseStream *pstream;
 pa_cvolume cvolume;
 
 g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
 
- pulse = PULSE_STREAM (stream);
- cvolume = pulse->priv->volume;
+ pstream = PULSE_STREAM (stream);
 
- if (pa_cvolume_set_fade (&cvolume, &pulse->priv->channel_map, fade) == NULL)
+ if (!(pstream->priv->flags & MATE_MIXER_STREAM_CAN_FADE))
 return FALSE;
 
- return stream_set_cvolume (stream, &cvolume);
+ cvolume = pstream->priv->cvolume;
+
+ if (pa_cvolume_set_fade (&cvolume, &pstream->priv->channel_map, fade) == NULL)
+ return FALSE;
+
+ return set_cvolume (pstream, &cvolume);
 }
 
 static gboolean
-stream_suspend (MateMixerStream *stream)
+pulse_stream_suspend (MateMixerStream *stream)
 {
+ PulseStream *pstream;
+ PulseStreamClass *klass;
+
 g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
 
- if (!(PULSE_STREAM (stream)->priv->flags & MATE_MIXER_STREAM_CAN_SUSPEND))
+ pstream = PULSE_STREAM (stream);
+
+ if (!(pstream->priv->flags & MATE_MIXER_STREAM_CAN_SUSPEND))
 return FALSE;
 
- return PULSE_STREAM_GET_CLASS (stream)->suspend (stream);
+ if (pstream->priv->state == MATE_MIXER_STREAM_STATE_SUSPENDED)
+ return FALSE;
+
+ klass = PULSE_STREAM_GET_CLASS (pstream);
+
+ if (klass->suspend (pstream) == FALSE)
+ return FALSE;
+
+ pulse_stream_update_state (pstream, MATE_MIXER_STREAM_STATE_SUSPENDED);
+ return TRUE;
 }
 
 static gboolean
-stream_resume (MateMixerStream *stream)
+pulse_stream_resume (MateMixerStream *stream)
 {
+ PulseStream *pstream;
+ PulseStreamClass *klass;
+
 g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
 
- if (!(PULSE_STREAM (stream)->priv->flags & MATE_MIXER_STREAM_CAN_SUSPEND))
+ pstream = PULSE_STREAM (stream);
+
+ if (!(pstream->priv->flags & MATE_MIXER_STREAM_CAN_SUSPEND))
+ return FALSE;
+
+ if (pstream->priv->state != MATE_MIXER_STREAM_STATE_SUSPENDED)
 return FALSE;
 
- return PULSE_STREAM_GET_CLASS (stream)->resume (stream);
+ klass = PULSE_STREAM_GET_CLASS (pstream);
+
+ if (klass->resume (pstream) == FALSE)
+ return FALSE;
+
+ /* The state when resumed should be either RUNNING or IDLE, let's assume
+ * IDLE for now and request an immediate update */
+ pulse_stream_update_state (pstream, MATE_MIXER_STREAM_STATE_IDLE);
+
+ klass->reload (pstream);
+ return TRUE;
 }
 
 static gboolean
-stream_monitor_start (MateMixerStream *stream)
+pulse_stream_monitor_start (MateMixerStream *stream)
 {
- PulseStream *pulse;
+ PulseStream *pstream;
 
 g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
 
- pulse = PULSE_STREAM (stream);
+ pstream = PULSE_STREAM (stream);
 
- if (!pulse->priv->monitor) {
- pulse->priv->monitor = PULSE_STREAM_GET_CLASS (stream)->create_monitor (stream);
+ if (!(pstream->priv->flags & MATE_MIXER_STREAM_HAS_MONITOR))
+ return FALSE;
+
+ if (pstream->priv->monitor == NULL) {
+ pstream->priv->monitor = PULSE_STREAM_GET_CLASS (pstream)->create_monitor (pstream);
 
- if (G_UNLIKELY (pulse->priv->monitor == NULL))
+ if (G_UNLIKELY (pstream->priv->monitor == NULL))
 return FALSE;
 
- pulse_monitor_set_name (pulse->priv->monitor,
- pulse->priv->monitor_name);
+ pulse_monitor_set_name (pstream->priv->monitor,
+ pstream->priv->monitor_name);
 
- g_signal_connect (G_OBJECT (pulse->priv->monitor),
+ g_signal_connect (G_OBJECT (pstream->priv->monitor),
 "value",
- G_CALLBACK (stream_monitor_value),
- stream);
+ G_CALLBACK (on_monitor_value),
+ pstream);
 }
- g_debug ("Enabling monitor for stream %s", pulse->priv->name);
 
- return pulse_monitor_enable (pulse->priv->monitor);
+ return pulse_monitor_set_enabled (pstream->priv->monitor, TRUE);
 }
 
 static void
-stream_monitor_stop (MateMixerStream *stream)
+pulse_stream_monitor_stop (MateMixerStream *stream)
 {
- PulseStream *pulse;
+ PulseStream *pstream;
 
 g_return_if_fail (PULSE_IS_STREAM (stream));
 
- pulse = PULSE_STREAM (stream);
-
- if (pulse->priv->monitor &&
- pulse_monitor_is_enabled (pulse->priv->monitor)) {
- g_debug ("Disabling monitor for stream %s", pulse->priv->name);
+ pstream = PULSE_STREAM (stream);
 
- pulse_monitor_disable (pulse->priv->monitor);
- }
+ if (pstream->priv->monitor != NULL)
+ pulse_monitor_set_enabled (pstream->priv->monitor, FALSE);
 }
 
 static gboolean
-stream_monitor_is_running (MateMixerStream *stream)
+pulse_stream_monitor_is_running (MateMixerStream *stream)
 {
- PulseStream *pulse;
+ PulseStream *pstream;
 
 g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
 
- pulse = PULSE_STREAM (stream);
+ pstream = PULSE_STREAM (stream);
 
- if (pulse->priv->monitor)
- return pulse_monitor_is_enabled (pulse->priv->monitor);
+ if (pstream->priv->monitor != NULL)
+ return pulse_monitor_get_enabled (pstream->priv->monitor);
 
 return FALSE;
 }
 
 static gboolean
-stream_monitor_set_name (MateMixerStream *stream, const gchar *name)
+pulse_stream_monitor_set_name (MateMixerStream *stream, const gchar *name)
 {
- PulseStream *pulse;
+ PulseStream *pstream;
 
 g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
 
- pulse = PULSE_STREAM (stream);
+ pstream = PULSE_STREAM (stream);
 
- if (pulse->priv->monitor)
- pulse_monitor_set_name (pulse->priv->monitor, name);
+ if (pstream->priv->monitor != NULL)
+ pulse_monitor_set_name (pstream->priv->monitor, name);
 
- pulse->priv->monitor_name = g_strdup (name);
+ pstream->priv->monitor_name = g_strdup (name);
 return TRUE;
 }
 
-static void
-stream_monitor_value (PulseMonitor *monitor, gdouble value, MateMixerStream *stream)
-{
- g_signal_emit_by_name (G_OBJECT (stream),
- "monitor-value",
- value);
-}
-
 static const GList *
-stream_list_ports (MateMixerStream *stream)
+pulse_stream_list_ports (MateMixerStream *stream)
 {
+ PulseStream *pstream;
+
 g_return_val_if_fail (PULSE_IS_STREAM (stream), NULL);
 
- return (const GList *) PULSE_STREAM (stream)->priv->ports;
+ pstream = PULSE_STREAM (stream);
+
+ if (pstream->priv->ports_list == NULL) {
+ GList *list = g_hash_table_get_values (pstream->priv->ports);
+
+ if (list != NULL) {
+ g_list_foreach (list, (GFunc) g_object_ref, NULL);
+
+ pstream->priv->ports_list = g_list_sort (list, compare_ports);
+ }
+ }
+
+ return (const GList *) pstream->priv->ports_list;
 }
 
 static MateMixerPort *
-stream_get_active_port (MateMixerStream *stream)
+pulse_stream_get_active_port (MateMixerStream *stream)
 {
 g_return_val_if_fail (PULSE_IS_STREAM (stream), NULL);
 
@@ -1047,90 +1123,163 @@ stream_get_active_port (MateMixerStream *stream)
 }
 
 static gboolean
-stream_set_active_port (MateMixerStream *stream, const gchar *port_name)
+pulse_stream_set_active_port (MateMixerStream *stream, MateMixerPort *port)
 {
- PulseStream *pulse;
- GList *list;
- MateMixerPort *port = NULL;
+ PulseStream *pstream;
+ PulseStreamClass *klass;
+ const gchar *name;
 
 g_return_val_if_fail (PULSE_IS_STREAM (stream), FALSE);
- g_return_val_if_fail (port_name != NULL, FALSE);
+ g_return_val_if_fail (MATE_MIXER_IS_PORT (port), FALSE);
 
- pulse = PULSE_STREAM (stream);
- list = pulse->priv->ports;
- while (list) {
- port = MATE_MIXER_PORT (list->data);
+ pstream = PULSE_STREAM (stream);
 
- if (!g_strcmp0 (mate_mixer_port_get_name (port), port_name))
- break;
+ /* Make sure the port comes from this stream */
+ name = mate_mixer_port_get_name (port);
 
- port = NULL;
- list = list->next;
+ if (g_hash_table_lookup (pstream->priv->ports, name) == NULL) {
+ g_warning ("Port %s does not belong to stream %s",
+ mate_mixer_port_get_name (port),
+ mate_mixer_stream_get_name (stream));
+ return FALSE;
 }
 
- if (port == NULL ||
- PULSE_STREAM_GET_CLASS (stream)->set_active_port (stream, port_name) == FALSE)
+ klass = PULSE_STREAM_GET_CLASS (pstream);
+
+ /* Change the port */
+ if (klass->set_active_port (pstream, port) == FALSE)
 return FALSE;
 
- if (pulse->priv->port)
- g_object_unref (pulse->priv->port);
+ if (pstream->priv->port != NULL)
+ g_object_unref (pstream->priv->port);
 
- pulse->priv->port = g_object_ref (port);
+ pstream->priv->port = g_object_ref (port);
 
 g_object_notify (G_OBJECT (stream), "active-port");
 return TRUE;
 }
 
 static guint
-stream_get_min_volume (MateMixerStream *stream)
+pulse_stream_get_min_volume (MateMixerStream *stream)
 {
 return (guint) PA_VOLUME_MUTED;
 }
 
 static guint
-stream_get_max_volume (MateMixerStream *stream)
+pulse_stream_get_max_volume (MateMixerStream *stream)
 {
+ PulseStream *pstream;
+
+ g_return_val_if_fail (PULSE_IS_STREAM (stream), (guint) PA_VOLUME_MUTED);
+
+ pstream = PULSE_STREAM (stream);
+
+ if (!(pstream->priv->flags & MATE_MIXER_STREAM_HAS_VOLUME))
+ return (guint) PA_VOLUME_MUTED;
+
 return (guint) PA_VOLUME_UI_MAX;
 }
 
 static guint
-stream_get_normal_volume (MateMixerStream *stream)
+pulse_stream_get_normal_volume (MateMixerStream *stream)
 {
+ PulseStream *pstream;
+
+ g_return_val_if_fail (PULSE_IS_STREAM (stream), (guint) PA_VOLUME_MUTED);
+
+ pstream = PULSE_STREAM (stream);
+
+ if (!(pstream->priv->flags & MATE_MIXER_STREAM_HAS_VOLUME))
+ return (guint) PA_VOLUME_MUTED;
+
 return (guint) PA_VOLUME_NORM;
 }
 
 static guint
-stream_get_base_volume (MateMixerStream *stream)
+pulse_stream_get_base_volume (MateMixerStream *stream)
 {
- g_return_val_if_fail (PULSE_IS_STREAM (stream), 0);
+ PulseStream *pstream;
+
+ g_return_val_if_fail (PULSE_IS_STREAM (stream), (guint) PA_VOLUME_MUTED);
+
+ pstream = PULSE_STREAM (stream);
+
+ if (!(pstream->priv->flags & MATE_MIXER_STREAM_HAS_VOLUME))
+ return (guint) PA_VOLUME_MUTED;
+
+ if (pstream->priv->base_volume > 0)
+ return pstream->priv->base_volume;
+ else
+ return (guint) PA_VOLUME_NORM;
+}
+
+static void
+on_monitor_value (PulseMonitor *monitor, gdouble value, PulseStream *pstream)
+{
+ g_signal_emit_by_name (G_OBJECT (pstream),
+ "monitor-value",
+ value);
+}
+
+static gboolean
+update_balance_fade (PulseStream *pstream)
+{
+ gfloat fade;
+ gfloat balance;
+ gboolean changed = FALSE;
+
+ /* The PulseAudio return the default 0.0f values on errors, so skip checking
+ * validity of the channel map and volume */
+ balance = pa_cvolume_get_balance (&pstream->priv->cvolume,
+ &pstream->priv->channel_map);
+
+ if (pstream->priv->balance != balance) {
+ pstream->priv->balance = balance;
 
- return PULSE_STREAM (stream)->priv->base_volume;
+ g_object_notify (G_OBJECT (pstream), "balance");
+ changed = TRUE;
+ }
+
+ fade = pa_cvolume_get_fade (&pstream->priv->cvolume,
+ &pstream->priv->channel_map);
+
+ if (pstream->priv->fade != fade) {
+ pstream->priv->fade = fade;
+
+ g_object_notify (G_OBJECT (pstream), "fade");
+ changed = TRUE;
+ }
+
+ return changed;
 }
 
 static gboolean
-stream_set_cvolume (MateMixerStream *stream, pa_cvolume *volume)
+set_cvolume (PulseStream *pstream, pa_cvolume *cvolume)
 {
- PulseStream *pulse;
+ PulseStreamClass *klass;
 
- if (!pa_cvolume_valid (volume))
+ if (pa_cvolume_valid (cvolume) == 0)
 return FALSE;
+ if (pa_cvolume_equal (cvolume, &pstream->priv->cvolume) != 0)
+ return TRUE;
 
- pulse = PULSE_STREAM (stream);
+ klass = PULSE_STREAM_GET_CLASS (pstream);
 
- if (!pa_cvolume_equal (volume, &pulse->priv->volume)) {
- if (PULSE_STREAM_GET_CLASS (stream)->set_volume (stream, volume) == FALSE)
- return FALSE;
+ if (klass->set_volume (pstream, cvolume) == FALSE)
+ return FALSE;
 
- pulse->priv->volume = *volume;
- g_object_notify (G_OBJECT (stream), "volume");
+ pstream->priv->cvolume = *cvolume;
+ pstream->priv->volume = (guint) pa_cvolume_max (cvolume);
 
- // XXX notify fade and balance
- }
+ g_object_notify (G_OBJECT (pstream), "volume");
+
+ /* Changing volume may change the balance and fade values as well */
+ update_balance_fade (pstream);
 return TRUE;
 }
 
 static gint
-stream_compare_ports (gconstpointer a, gconstpointer b)
+compare_ports (gconstpointer a, gconstpointer b)
 {
 MateMixerPort *p1 = MATE_MIXER_PORT (a);
 MateMixerPort *p2 = MATE_MIXER_PORT (b);
diff --git a/backends/pulse/pulse-stream.h b/backends/pulse/pulse-stream.h
index aa296ea..e4c6a00 100644
--- a/backends/pulse/pulse-stream.h
+++ b/backends/pulse/pulse-stream.h
@@ -22,6 +22,7 @@
 #include <glib-object.h>
 
 #include <libmatemixer/matemixer-device.h>
+#include <libmatemixer/matemixer-port.h>
 #include <libmatemixer/matemixer-stream.h>
 
 #include <pulse/pulseaudio.h>
@@ -60,51 +61,56 @@ struct _PulseStreamClass
 {
 GObjectClass parent_class;
 
- gboolean (*set_mute) (MateMixerStream *stream,
- gboolean mute);
- gboolean (*set_volume) (MateMixerStream *stream,
- pa_cvolume *volume);
+ /*< private >*/
+ /* Virtual table */
+ void (*reload) (PulseStream *stream);
+
+ gboolean (*set_mute) (PulseStream *stream,
+ gboolean mute);
+ gboolean (*set_volume) (PulseStream *stream,
+ pa_cvolume *volume);
 
- gboolean (*set_active_port) (MateMixerStream *stream,
- const gchar *port_name);
+ gboolean (*set_active_port) (PulseStream *stream,
+ MateMixerPort *port);
 
- gboolean (*suspend) (MateMixerStream *stream);
- gboolean (*resume) (MateMixerStream *stream);
+ gboolean (*suspend) (PulseStream *stream);
+ gboolean (*resume) (PulseStream *stream);
 
- PulseMonitor *(*create_monitor) (MateMixerStream *stream);
+ PulseMonitor *(*create_monitor) (PulseStream *stream);
 };
 
-GType pulse_stream_get_type (void) G_GNUC_CONST;
-
-guint32 pulse_stream_get_index (PulseStream *stream);
-PulseConnection *pulse_stream_get_connection (PulseStream *stream);
-PulseMonitor * pulse_stream_get_monitor (PulseStream *stream);
-
-gboolean pulse_stream_update_name (PulseStream *stream,
- const gchar *name);
-gboolean pulse_stream_update_description (PulseStream *stream,
- const gchar *description);
-gboolean pulse_stream_update_device (PulseStream *stream,
- MateMixerDevice *device);
-gboolean pulse_stream_update_flags (PulseStream *stream,
- MateMixerStreamFlags flags);
-gboolean pulse_stream_update_state (PulseStream *stream,
- MateMixerStreamState state);
-gboolean pulse_stream_update_mute (PulseStream *stream,
- gboolean mute);
-
-gboolean pulse_stream_update_volume (PulseStream *stream,
- const pa_cvolume *volume,
- const pa_channel_map *map,
- pa_volume_t base_volume);
-
-gboolean pulse_stream_update_channel_map (PulseStream *stream,
- const pa_channel_map *map);
-
-gboolean pulse_stream_update_ports (PulseStream *stream,
- GList *ports);
-gboolean pulse_stream_update_active_port (PulseStream *stream,
- const gchar *port_name);
+GType pulse_stream_get_type (void) G_GNUC_CONST;
+
+guint32 pulse_stream_get_index (PulseStream *pstream);
+PulseConnection * pulse_stream_get_connection (PulseStream *pstream);
+PulseMonitor * pulse_stream_get_monitor (PulseStream *pstream);
+GHashTable * pulse_stream_get_ports (PulseStream *pstream);
+
+const pa_cvolume * pulse_stream_get_cvolume (PulseStream *pstream);
+const pa_channel_map *pulse_stream_get_channel_map (PulseStream *pstream);
+
+gboolean pulse_stream_update_name (PulseStream *pstream,
+ const gchar *name);
+gboolean pulse_stream_update_description (PulseStream *pstream,
+ const gchar *description);
+gboolean pulse_stream_update_device (PulseStream *pstream,
+ MateMixerDevice *device);
+gboolean pulse_stream_update_flags (PulseStream *pstream,
+ MateMixerStreamFlags flags);
+gboolean pulse_stream_update_state (PulseStream *pstream,
+ MateMixerStreamState state);
+
+gboolean pulse_stream_update_channel_map (PulseStream *pstream,
+ const pa_channel_map *map);
+gboolean pulse_stream_update_volume (PulseStream *pstream,
+ const pa_cvolume *volume,
+ pa_volume_t base_volume);
+
+gboolean pulse_stream_update_mute (PulseStream *pstream,
+ gboolean mute);
+
+gboolean pulse_stream_update_active_port (PulseStream *pstream,
+ MateMixerPort *port);
 
 G_END_DECLS
 
diff --git a/configure.ac b/configure.ac
index d698330..675667d 100644
--- a/configure.ac
+++ b/configure.ac
@@ -68,8 +68,6 @@ PKG_CHECK_MODULES(GLIB, [
 gobject-2.0 >= $GLIB_REQUIRED_VERSION
 gmodule-2.0 >= $GLIB_REQUIRED_VERSION
 ])
-AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal)
-AC_PATH_PROG(GLIB_MKENUMS, glib-mkenums)
 
 GTK_DOC_CHECK([1.10], [--flavour no-tmpl])
 
diff --git a/docs/reference/Makefile.am b/docs/reference/Makefile.am
index b444738..9c58b70 100644
--- a/docs/reference/Makefile.am
+++ b/docs/reference/Makefile.am
@@ -55,7 +55,9 @@ EXTRA_HFILES=
 IGNORE_HFILES= \
 matemixer-backend.h \
 matemixer-backend-module.h \
+ matemixer-device-profile-private.h \
 matemixer-enum-types.h \
+ matemixer-port-private.h \
 matemixer-private.h
 
 # Images to copy into HTML directory.
diff --git a/docs/reference/libmatemixer-sections.txt b/docs/reference/libmatemixer-sections.txt
index b719470..5807f76 100644
--- a/docs/reference/libmatemixer-sections.txt
+++ b/docs/reference/libmatemixer-sections.txt
@@ -9,8 +9,12 @@ LIBMATEMIXER_CHECK_VERSION
 <SECTION>
 <FILE>matemixer-client-stream</FILE>
 <TITLE>MateMixerClientStream</TITLE>
+MateMixerClientStreamFlags
+MateMixerClientStreamRole
 MateMixerClientStream
 MateMixerClientStreamInterface
+mate_mixer_client_stream_get_flags
+mate_mixer_client_stream_get_role
 mate_mixer_client_stream_get_parent
 mate_mixer_client_stream_set_parent
 mate_mixer_client_stream_remove
@@ -44,8 +48,10 @@ mate_mixer_control_close
 mate_mixer_control_get_state
 mate_mixer_control_get_device
 mate_mixer_control_get_stream
+mate_mixer_control_get_cached_stream
 mate_mixer_control_list_devices
 mate_mixer_control_list_streams
+mate_mixer_control_list_cached_streams
 mate_mixer_control_get_default_input_stream
 mate_mixer_control_set_default_input_stream
 mate_mixer_control_get_default_output_stream
@@ -73,6 +79,8 @@ MateMixerDeviceInterface
 mate_mixer_device_get_name
 mate_mixer_device_get_description
 mate_mixer_device_get_icon
+mate_mixer_device_get_port
+mate_mixer_device_get_profile
 mate_mixer_device_list_ports
 mate_mixer_device_list_profiles
 mate_mixer_device_get_active_profile
@@ -89,7 +97,6 @@ mate_mixer_device_get_type
 <FILE>matemixer-device-profile</FILE>
 <TITLE>MateMixerDeviceProfile</TITLE>
 MateMixerDeviceProfile
-mate_mixer_device_profile_new
 mate_mixer_device_profile_get_name
 mate_mixer_device_profile_get_description
 mate_mixer_device_profile_get_priority
@@ -113,7 +120,6 @@ MateMixerDeviceProfilePrivate
 <TITLE>MateMixerPort</TITLE>
 MateMixerPortFlags
 MateMixerPort
-mate_mixer_port_new
 mate_mixer_port_get_name
 mate_mixer_port_get_description
 mate_mixer_port_get_icon
@@ -158,11 +164,7 @@ mate_mixer_stream_get_channel_volume
 mate_mixer_stream_set_channel_volume
 mate_mixer_stream_get_channel_decibel
 mate_mixer_stream_set_channel_decibel
-mate_mixer_stream_has_position
-mate_mixer_stream_get_position_volume
-mate_mixer_stream_set_position_volume
-mate_mixer_stream_get_position_decibel
-mate_mixer_stream_set_position_decibel
+mate_mixer_stream_has_channel_position
 mate_mixer_stream_get_balance
 mate_mixer_stream_set_balance
 mate_mixer_stream_get_fade
diff --git a/docs/reference/libmatemixer.types b/docs/reference/libmatemixer.types
deleted file mode 100644
index 714c773..0000000
--- a/docs/reference/libmatemixer.types
+++ /dev/null
@@ -1,6 +0,0 @@
-mate_mixer_client_stream_get_type
-mate_mixer_control_get_type
-mate_mixer_device_get_type
-mate_mixer_device_profile_get_type
-mate_mixer_port_get_type
-mate_mixer_stream_get_type
diff --git a/examples/monitor.c b/examples/monitor.c
index e3ab0d6..3267b36 100644
--- a/examples/monitor.c
+++ b/examples/monitor.c
@@ -36,16 +36,58 @@ create_app_string (const gchar *app_name,
 {
 GString *string;
 
- string = g_string_new (app_name);
+ string = g_string_new ("");
 
- if (app_version)
- g_string_append_printf (string, " %s", app_version);
- if (app_id)
- g_string_append_printf (string, " (%s)", app_id);
+ if (app_name != NULL) {
+ g_string_append (string, app_name);
+
+ if (app_version != NULL)
+ g_string_append_printf (string, " %s", app_version);
+ if (app_id != NULL)
+ g_string_append_printf (string, " (%s)", app_id);
+ }
+ else if (app_id != NULL) {
+ g_string_append (string, app_id);
+
+ if (app_version != NULL)
+ g_string_append_printf (string, " %s", app_version);
+ }
 
 return g_string_free (string, FALSE);
 }
 
+static const gchar *
+create_role_string (MateMixerClientStreamRole role)
+{
+ switch (role) {
+ case MATE_MIXER_CLIENT_STREAM_ROLE_NONE:
+ return "None";
+ case MATE_MIXER_CLIENT_STREAM_ROLE_VIDEO:
+ return "Video";
+ case MATE_MIXER_CLIENT_STREAM_ROLE_MUSIC:
+ return "Music";
+ case MATE_MIXER_CLIENT_STREAM_ROLE_GAME:
+ return "Game";
+ case MATE_MIXER_CLIENT_STREAM_ROLE_EVENT:
+ return "Event";
+ case MATE_MIXER_CLIENT_STREAM_ROLE_PHONE:
+ return "Phone";
+ case MATE_MIXER_CLIENT_STREAM_ROLE_ANIMATION:
+ return "Animation";
+ case MATE_MIXER_CLIENT_STREAM_ROLE_PRODUCTION:
+ return "Production";
+ case MATE_MIXER_CLIENT_STREAM_ROLE_A11Y:
+ return "A11y";
+ case MATE_MIXER_CLIENT_STREAM_ROLE_TEST:
+ return "Test";
+ case MATE_MIXER_CLIENT_STREAM_ROLE_ABSTRACT:
+ return "Abstract";
+ case MATE_MIXER_CLIENT_STREAM_ROLE_FILTER:
+ return "Filter";
+ }
+ return "Unknown";
+}
+
 static gchar *
 create_volume_bar (MateMixerStream *stream, double *percent)
 {
@@ -103,7 +145,7 @@ print_devices (void)
 g_print (" |-| Port %s\n"
 " |-| Description : %s\n"
 " |-| Icon Name : %s\n"
- " |-| Priority : %lu\n"
+ " |-| Priority : %u\n"
 " |-| Status : \n\n",
 mate_mixer_port_get_name (port),
 mate_mixer_port_get_description (port),
@@ -150,14 +192,21 @@ print_streams (void)
 streams = mate_mixer_control_list_streams (control);
 
 while (streams) {
- MateMixerStream *stream = MATE_MIXER_STREAM (streams->data);
- gchar *volume_bar;
- gdouble volume;
-
- /* Ignore event streams */
- if (mate_mixer_stream_get_flags (stream) & MATE_MIXER_STREAM_EVENT) {
- streams = streams->next;
- continue;
+ MateMixerStream *stream = MATE_MIXER_STREAM (streams->data);
+ MateMixerClientStream *client = NULL;
+ gchar *volume_bar;
+ gdouble volume;
+
+ if (mate_mixer_stream_get_flags (stream) & MATE_MIXER_STREAM_CLIENT) {
+ /* The application-specific details are accessible through the client
+ * interface, which all client streams implement */
+ client = MATE_MIXER_CLIENT_STREAM (stream);
+
+ /* Ignore event streams */
+ if (mate_mixer_client_stream_get_role (client) == MATE_MIXER_CLIENT_STREAM_ROLE_EVENT) {
+ streams = streams->next;
+ continue;
+ }
 }
 
 volume_bar = create_volume_bar (stream, &volume);
@@ -178,20 +227,19 @@ print_streams (void)
 mate_mixer_stream_get_balance (stream),
 mate_mixer_stream_get_fade (stream));
 
- if (mate_mixer_stream_get_flags (stream) & MATE_MIXER_STREAM_APPLICATION) {
- MateMixerClientStream *client;
- gchar *app;
+ if (client != NULL) {
+ MateMixerClientStreamFlags client_flags;
 
- /* The application-specific details are accessible through the client
- * interface, which all client streams implement */
- client = MATE_MIXER_CLIENT_STREAM (stream);
+ client_flags = mate_mixer_client_stream_get_flags (client);
 
- app = create_app_string (mate_mixer_client_stream_get_app_name (client),
- mate_mixer_client_stream_get_app_id (client),
- mate_mixer_client_stream_get_app_version (client));
+ if (client_flags & MATE_MIXER_CLIENT_STREAM_APPLICATION) {
+ gchar *app = create_app_string (mate_mixer_client_stream_get_app_name (client),
+ mate_mixer_client_stream_get_app_id (client),
+ mate_mixer_client_stream_get_app_version (client));
 
- g_print (" |-| Application : %s\n", app);
- g_free (app);
+ g_print (" |-| Application : %s\n", app);
+ g_free (app);
+ }
 }
 
 g_print ("\n");
@@ -204,7 +252,7 @@ print_streams (void)
 g_print (" |-| Port %s\n"
 " |-| Description : %s\n"
 " |-| Icon Name : %s\n"
- " |-| Priority : %lu\n"
+ " |-| Priority : %u\n"
 " |-| Status : \n\n",
 mate_mixer_port_get_name (port),
 mate_mixer_port_get_description (port),
@@ -219,6 +267,59 @@ print_streams (void)
 }
 
 static void
+print_cached_streams (void)
+{
+ const GList *streams;
+
+ streams = mate_mixer_control_list_cached_streams (control);
+
+ while (streams) {
+ MateMixerStream *stream = MATE_MIXER_STREAM (streams->data);
+ MateMixerClientStream *client;
+ MateMixerClientStreamFlags client_flags;
+ MateMixerClientStreamRole client_role;
+ gchar *volume_bar;
+ gdouble volume;
+
+ client = MATE_MIXER_CLIENT_STREAM (stream);
+ client_flags = mate_mixer_client_stream_get_flags (client);
+ client_role = mate_mixer_client_stream_get_role (client);
+
+ volume_bar = create_volume_bar (stream, &volume);
+
+ g_print ("Cached stream %s\n"
+ " |-| Role : %s\n"
+ " |-| Volume : %s %.1f %%\n"
+ " |-| Muted : %s\n"
+ " |-| Channels : %d\n"
+ " |-| Balance : %.1f\n"
+ " |-| Fade : %.1f\n",
+ mate_mixer_stream_get_name (stream),
+ create_role_string (client_role),
+ volume_bar,
+ volume,
+ mate_mixer_stream_get_mute (stream) ? "Yes" : "No",
+ mate_mixer_stream_get_num_channels (stream),
+ mate_mixer_stream_get_balance (stream),
+ mate_mixer_stream_get_fade (stream));
+
+ if (client_flags & MATE_MIXER_CLIENT_STREAM_APPLICATION) {
+ gchar *app = create_app_string (mate_mixer_client_stream_get_app_name (client),
+ mate_mixer_client_stream_get_app_id (client),
+ mate_mixer_client_stream_get_app_version (client));
+
+ g_print (" |-| Application : %s\n", app);
+ g_free (app);
+ }
+
+ g_print ("\n");
+ g_free (volume_bar);
+
+ streams = streams->next;
+ }
+}
+
+static void
 connected (void)
 {
 g_print ("Connected using the %s backend.\n\n",
@@ -226,6 +327,7 @@ connected (void)
 
 print_devices ();
 print_streams ();
+ print_cached_streams ();
 
 g_print ("Waiting for events. Hit CTRL+C to quit.\n");
 }
@@ -257,12 +359,6 @@ device_added_cb (MateMixerControl *control, const gchar *name)
 }
 
 static void
-device_changed_cb (MateMixerControl *control, const gchar *name)
-{
- g_print ("Device changed: %s\n", name);
-}
-
-static void
 device_removed_cb (MateMixerControl *control, const gchar *name)
 {
 g_print ("Device removed: %s\n", name);
@@ -275,12 +371,6 @@ stream_added_cb (MateMixerControl *control, const gchar *name)
 }
 
 static void
-stream_changed_cb (MateMixerControl *control, const gchar *name)
-{
- g_print ("Stream changed: %s\n", name);
-}
-
-static void
 stream_removed_cb (MateMixerControl *control, const gchar *name)
 {
 g_print ("Stream removed: %s\n", name);
@@ -358,27 +448,19 @@ int main (int argc, char *argv[])
 return 1;
 }
 
- g_signal_connect (control,
+ g_signal_connect (G_OBJECT (control),
 "device-added",
 G_CALLBACK (device_added_cb),
 NULL);
- g_signal_connect (control,
- "device-changed",
- G_CALLBACK (device_changed_cb),
- NULL);
- g_signal_connect (control,
+ g_signal_connect (G_OBJECT (control),
 "device-removed",
 G_CALLBACK (device_removed_cb),
 NULL);
- g_signal_connect (control,
+ g_signal_connect (G_OBJECT (control),
 "stream-added",
 G_CALLBACK (stream_added_cb),
 NULL);
- g_signal_connect (control,
- "stream-changed",
- G_CALLBACK (stream_changed_cb),
- NULL);
- g_signal_connect (control,
+ g_signal_connect (G_OBJECT (control),
 "stream-removed",
 G_CALLBACK (stream_removed_cb),
 NULL);
diff --git a/libmatemixer/Makefile.am b/libmatemixer/Makefile.am
index 538592f..8c219d4 100644
--- a/libmatemixer/Makefile.am
+++ b/libmatemixer/Makefile.am
@@ -32,9 +32,11 @@ libmatemixer_la_SOURCES = \
 matemixer-control.c \
 matemixer-device.c \
 matemixer-device-profile.c \
+ matemixer-device-profile-private.h \
 matemixer-enum-types.c \
 matemixer-enum-types.h \
 matemixer-port.c \
+ matemixer-port-private.h \
 matemixer-stream.c
 
 libmatemixer_la_LIBADD = $(GLIB_LIBS)
diff --git a/libmatemixer/matemixer-backend-module.c b/libmatemixer/matemixer-backend-module.c
index e0707c1..a3146d2 100644
--- a/libmatemixer/matemixer-backend-module.c
+++ b/libmatemixer/matemixer-backend-module.c
@@ -36,24 +36,23 @@ struct _MateMixerBackendModulePrivate
 
 enum {
 PROP_0,
- PROP_PATH,
- N_PROPERTIES
+ PROP_PATH
 };
 
-static void mate_mixer_backend_module_class_init (MateMixerBackendModuleClass *klass);
+static void mate_mixer_backend_module_class_init (MateMixerBackendModuleClass *klass);
 
-static void mate_mixer_backend_module_get_property (GObject *object,
- guint param_id,
- GValue *value,
- GParamSpec *pspec);
-static void mate_mixer_backend_module_set_property (GObject *object,
- guint param_id,
- const GValue *value,
- GParamSpec *pspec);
+static void mate_mixer_backend_module_get_property (GObject *object,
+ guint param_id,
+ GValue *value,
+ GParamSpec *pspec);
+static void mate_mixer_backend_module_set_property (GObject *object,
+ guint param_id,
+ const GValue *value,
+ GParamSpec *pspec);
 
-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 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);
 
 G_DEFINE_TYPE (MateMixerBackendModule, mate_mixer_backend_module, G_TYPE_TYPE_MODULE);
 
@@ -77,7 +76,7 @@ mate_mixer_backend_module_class_init (MateMixerBackendModuleClass *klass)
 g_param_spec_string ("path",
 "Path",
 "File path to the module",
- 0,
+ NULL,
 G_PARAM_CONSTRUCT_ONLY |
 G_PARAM_READWRITE |
 G_PARAM_STATIC_STRINGS));
@@ -145,12 +144,13 @@ mate_mixer_backend_module_dispose (GObject *object)
 
 module = MATE_MIXER_BACKEND_MODULE (object);
 
- if (module->priv->loaded) {
+ if (module->priv->loaded == TRUE) {
 /* Keep the module alive and avoid calling the parent dispose, which
 * would do the same thing and also produce a warning */
 g_object_ref (object);
 return;
 }
+
 G_OBJECT_CLASS (mate_mixer_backend_module_parent_class)->dispose (object);
 }
 
@@ -199,6 +199,7 @@ const MateMixerBackendInfo *
 mate_mixer_backend_module_get_info (MateMixerBackendModule *module)
 {
 g_return_val_if_fail (MATE_MIXER_IS_BACKEND_MODULE (module), NULL);
+ g_return_val_if_fail (module->priv->loaded == TRUE, NULL);
 
 return module->priv->get_info ();
 }
@@ -226,7 +227,7 @@ backend_module_load (GTypeModule *type_module)
 
 module = MATE_MIXER_BACKEND_MODULE (type_module);
 
- if (!module->priv->loaded) {
+ if (module->priv->loaded == FALSE) {
 module->priv->gmodule = g_module_open (module->priv->path,
 G_MODULE_BIND_LAZY |
 G_MODULE_BIND_LOCAL);
@@ -239,12 +240,12 @@ backend_module_load (GTypeModule *type_module)
 }
 
 /* Validate library symbols that each backend module must provide */
- if (!g_module_symbol (module->priv->gmodule,
- "backend_module_init",
- (gpointer *) &module->priv->init) ||
- !g_module_symbol (module->priv->gmodule,
- "backend_module_get_info",
- (gpointer *) &module->priv->get_info)) {
+ if (g_module_symbol (module->priv->gmodule,
+ "backend_module_init",
+ (gpointer *) &module->priv->init) == FALSE ||
+ g_module_symbol (module->priv->gmodule,
+ "backend_module_get_info",
+ (gpointer *) &module->priv->get_info) == FALSE) {
 g_warning ("Failed to load backend module %s: %s",
 module->priv->path,
 g_module_error ());
@@ -283,6 +284,7 @@ backend_module_load (GTypeModule *type_module)
 /* This function was called before, so avoid loading and initialize only */
 module->priv->init (type_module);
 }
+
 return TRUE;
 }
 
diff --git a/libmatemixer/matemixer-backend-module.h b/libmatemixer/matemixer-backend-module.h
index e654413..62b0a43 100644
--- a/libmatemixer/matemixer-backend-module.h
+++ b/libmatemixer/matemixer-backend-module.h
@@ -21,6 +21,8 @@
 #include <glib.h>
 #include <glib-object.h>
 
+#include "matemixer-enums.h"
+
 G_BEGIN_DECLS
 
 typedef struct {
@@ -63,6 +65,7 @@ struct _MateMixerBackendModuleClass
 GType mate_mixer_backend_module_get_type (void) G_GNUC_CONST;
 
 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);
 
diff --git a/libmatemixer/matemixer-backend.c b/libmatemixer/matemixer-backend.c
index 32f7f1b..be5c704 100644
--- a/libmatemixer/matemixer-backend.c
+++ b/libmatemixer/matemixer-backend.c
@@ -25,11 +25,11 @@
 
 enum {
 DEVICE_ADDED,
- DEVICE_CHANGED,
 DEVICE_REMOVED,
 STREAM_ADDED,
- STREAM_CHANGED,
 STREAM_REMOVED,
+ CACHED_STREAM_ADDED,
+ CACHED_STREAM_REMOVED,
 N_SIGNALS
 };
 
@@ -77,11 +77,11 @@ mate_mixer_backend_default_init (MateMixerBackendInterface *iface)
 1,
 G_TYPE_STRING);
 
- signals[DEVICE_CHANGED] =
- g_signal_new ("device-changed",
+ signals[DEVICE_REMOVED] =
+ g_signal_new ("device-removed",
 G_TYPE_FROM_INTERFACE (iface),
 G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (MateMixerBackendInterface, device_changed),
+ G_STRUCT_OFFSET (MateMixerBackendInterface, device_removed),
 NULL,
 NULL,
 g_cclosure_marshal_VOID__STRING,
@@ -89,11 +89,11 @@ mate_mixer_backend_default_init (MateMixerBackendInterface *iface)
 1,
 G_TYPE_STRING);
 
- signals[DEVICE_REMOVED] =
- g_signal_new ("device-removed",
+ signals[STREAM_ADDED] =
+ g_signal_new ("stream-added",
 G_TYPE_FROM_INTERFACE (iface),
 G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (MateMixerBackendInterface, device_removed),
+ G_STRUCT_OFFSET (MateMixerBackendInterface, stream_added),
 NULL,
 NULL,
 g_cclosure_marshal_VOID__STRING,
@@ -101,11 +101,11 @@ mate_mixer_backend_default_init (MateMixerBackendInterface *iface)
 1,
 G_TYPE_STRING);
 
- signals[STREAM_ADDED] =
- g_signal_new ("stream-added",
+ signals[STREAM_REMOVED] =
+ g_signal_new ("stream-removed",
 G_TYPE_FROM_INTERFACE (iface),
 G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (MateMixerBackendInterface, stream_added),
+ G_STRUCT_OFFSET (MateMixerBackendInterface, stream_removed),
 NULL,
 NULL,
 g_cclosure_marshal_VOID__STRING,
@@ -113,11 +113,11 @@ mate_mixer_backend_default_init (MateMixerBackendInterface *iface)
 1,
 G_TYPE_STRING);
 
- signals[STREAM_CHANGED] =
- g_signal_new ("stream-changed",
+ signals[CACHED_STREAM_ADDED] =
+ g_signal_new ("cached-stream-added",
 G_TYPE_FROM_INTERFACE (iface),
 G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (MateMixerBackendInterface, stream_changed),
+ G_STRUCT_OFFSET (MateMixerBackendInterface, cached_stream_added),
 NULL,
 NULL,
 g_cclosure_marshal_VOID__STRING,
@@ -125,11 +125,11 @@ mate_mixer_backend_default_init (MateMixerBackendInterface *iface)
 1,
 G_TYPE_STRING);
 
- signals[STREAM_REMOVED] =
- g_signal_new ("stream-removed",
+ signals[CACHED_STREAM_REMOVED] =
+ g_signal_new ("cached-stream-removed",
 G_TYPE_FROM_INTERFACE (iface),
 G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (MateMixerBackendInterface, stream_removed),
+ G_STRUCT_OFFSET (MateMixerBackendInterface, cached_stream_removed),
 NULL,
 NULL,
 g_cclosure_marshal_VOID__STRING,
@@ -156,6 +156,7 @@ mate_mixer_backend_open (MateMixerBackend *backend)
 {
 g_return_val_if_fail (MATE_MIXER_IS_BACKEND (backend), FALSE);
 
+ /* Implementation required */
 return MATE_MIXER_BACKEND_GET_INTERFACE (backend)->open (backend);
 }
 
@@ -177,6 +178,7 @@ mate_mixer_backend_get_state (MateMixerBackend *backend)
 {
 g_return_val_if_fail (MATE_MIXER_IS_BACKEND (backend), MATE_MIXER_STATE_UNKNOWN);
 
+ /* Implementation required */
 return MATE_MIXER_BACKEND_GET_INTERFACE (backend)->get_state (backend);
 }
 
@@ -210,6 +212,21 @@ mate_mixer_backend_list_streams (MateMixerBackend *backend)
 return NULL;
 }
 
+GList *
+mate_mixer_backend_list_cached_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_cached_streams)
+ return iface->list_cached_streams (backend);
+
+ return NULL;
+}
+
 MateMixerStream *
 mate_mixer_backend_get_default_input_stream (MateMixerBackend *backend)
 {
diff --git a/libmatemixer/matemixer-backend.h b/libmatemixer/matemixer-backend.h
index 559f256..8bedfe0 100644
--- a/libmatemixer/matemixer-backend.h
+++ b/libmatemixer/matemixer-backend.h
@@ -52,6 +52,7 @@ struct _MateMixerBackendInterface
 GTypeInterface parent_iface;
 
 /*< private >*/
+ /* Virtual table */
 void (*set_data) (MateMixerBackend *backend,
 const MateMixerBackendData *data);
 
@@ -62,6 +63,7 @@ struct _MateMixerBackendInterface
 
 GList *(*list_devices) (MateMixerBackend *backend);
 GList *(*list_streams) (MateMixerBackend *backend);
+ GList *(*list_cached_streams) (MateMixerBackend *backend);
 
 MateMixerStream *(*get_default_input_stream) (MateMixerBackend *backend);
 gboolean (*set_default_input_stream) (MateMixerBackend *backend,
@@ -74,16 +76,16 @@ struct _MateMixerBackendInterface
 /* Signals */
 void (*device_added) (MateMixerBackend *backend,
 const gchar *name);
- void (*device_changed) (MateMixerBackend *backend,
- const gchar *name);
 void (*device_removed) (MateMixerBackend *backend,
 const gchar *name);
 void (*stream_added) (MateMixerBackend *backend,
 const gchar *name);
- void (*stream_changed) (MateMixerBackend *backend,
- const gchar *name);
 void (*stream_removed) (MateMixerBackend *backend,
 const gchar *name);
+ void (*cached_stream_added) (MateMixerBackend *backend,
+ const gchar *name);
+ void (*cached_stream_removed) (MateMixerBackend *backend,
+ const gchar *name);
 };
 
 GType mate_mixer_backend_get_type (void) G_GNUC_CONST;
@@ -98,6 +100,7 @@ MateMixerState mate_mixer_backend_get_state (MateMixerBackend
 
 GList * mate_mixer_backend_list_devices (MateMixerBackend *backend);
 GList * mate_mixer_backend_list_streams (MateMixerBackend *backend);
+GList * mate_mixer_backend_list_cached_streams (MateMixerBackend *backend);
 
 MateMixerStream *mate_mixer_backend_get_default_input_stream (MateMixerBackend *backend);
 gboolean mate_mixer_backend_set_default_input_stream (MateMixerBackend *backend,
diff --git a/libmatemixer/matemixer-client-stream.c b/libmatemixer/matemixer-client-stream.c
index 74b3e15..3ff3c54 100644
--- a/libmatemixer/matemixer-client-stream.c
+++ b/libmatemixer/matemixer-client-stream.c
@@ -19,11 +19,13 @@
 #include <glib-object.h>
 
 #include "matemixer-client-stream.h"
+#include "matemixer-enums.h"
+#include "matemixer-enum-types.h"
 #include "matemixer-stream.h"
 
 /**
 * SECTION:matemixer-client-stream
- * @short_description: An interface providing extra functionality for client streams
+ * @short_description: Interface providing extra functionality for client streams
 * @see_also: #MateMixerStream
 * @include: libmatemixer/matemixer.h
 *
@@ -39,6 +41,24 @@ static void
 mate_mixer_client_stream_default_init (MateMixerClientStreamInterface *iface)
 {
 g_object_interface_install_property (iface,
+ g_param_spec_flags ("client-flags",
+ "Client flags",
+ "Capability flags of the client stream",
+ MATE_MIXER_TYPE_CLIENT_STREAM_FLAGS,
+ MATE_MIXER_CLIENT_STREAM_NO_FLAGS,
+ G_PARAM_READABLE |
+ G_PARAM_STATIC_STRINGS));
+
+ g_object_interface_install_property (iface,
+ g_param_spec_enum ("role",
+ "Role",
+ "Role of the client stream",
+ MATE_MIXER_TYPE_CLIENT_STREAM_ROLE,
+ MATE_MIXER_CLIENT_STREAM_ROLE_NONE,
+ G_PARAM_READABLE |
+ G_PARAM_STATIC_STRINGS));
+
+ g_object_interface_install_property (iface,
 g_param_spec_object ("parent",
 "Parent",
 "Parent stream of the client stream",
@@ -80,12 +100,52 @@ mate_mixer_client_stream_default_init (MateMixerClientStreamInterface *iface)
 }
 
 /**
+ * mate_mixer_client_stream_get_flags:
+ * @client: a #MateMixerClientStream
+ *
+ */
+MateMixerClientStreamFlags
+mate_mixer_client_stream_get_flags (MateMixerClientStream *client)
+{
+ MateMixerClientStreamInterface *iface;
+
+ g_return_val_if_fail (MATE_MIXER_IS_CLIENT_STREAM (client), MATE_MIXER_CLIENT_STREAM_NO_FLAGS);
+
+ iface = MATE_MIXER_CLIENT_STREAM_GET_INTERFACE (client);
+
+ if (iface->get_flags)
+ return iface->get_flags (client);
+
+ return MATE_MIXER_CLIENT_STREAM_NO_FLAGS;
+}
+
+/**
+ * mate_mixer_client_stream_get_role:
+ * @client: a #MateMixerClientStream
+ *
+ */
+MateMixerClientStreamRole
+mate_mixer_client_stream_get_role (MateMixerClientStream *client)
+{
+ MateMixerClientStreamInterface *iface;
+
+ g_return_val_if_fail (MATE_MIXER_IS_CLIENT_STREAM (client), MATE_MIXER_CLIENT_STREAM_ROLE_NONE);
+
+ iface = MATE_MIXER_CLIENT_STREAM_GET_INTERFACE (client);
+
+ if (iface->get_role)
+ return iface->get_role (client);
+
+ return MATE_MIXER_CLIENT_STREAM_ROLE_NONE;
+}
+
+/**
 * mate_mixer_client_stream_get_parent:
 * @client: a #MateMixerClientStream
 *
 * Gets the parent stream of the client stream.
 *
- * Returns: a #MateMixerStream or %NULL on failure.
+ * Returns: a #MateMixerStream or %NULL if the parent stream is not known.
 */
 MateMixerStream *
 mate_mixer_client_stream_get_parent (MateMixerClientStream *client)
diff --git a/libmatemixer/matemixer-client-stream.h b/libmatemixer/matemixer-client-stream.h
index 1375cb3..fae5934 100644
--- a/libmatemixer/matemixer-client-stream.h
+++ b/libmatemixer/matemixer-client-stream.h
@@ -21,6 +21,7 @@
 #include <glib.h>
 #include <glib-object.h>
 
+#include <libmatemixer/matemixer-enums.h>
 #include <libmatemixer/matemixer-stream.h>
 
 G_BEGIN_DECLS
@@ -42,26 +43,37 @@ struct _MateMixerClientStreamInterface
 GTypeInterface parent_iface;
 
 /*< private >*/
- MateMixerStream *(*get_parent) (MateMixerClientStream *client);
- gboolean (*set_parent) (MateMixerClientStream *client,
- MateMixerStream *stream);
- gboolean (*remove) (MateMixerClientStream *client);
- const gchar *(*get_app_name) (MateMixerClientStream *client);
- const gchar *(*get_app_id) (MateMixerClientStream *client);
- const gchar *(*get_app_version) (MateMixerClientStream *client);
- const gchar *(*get_app_icon) (MateMixerClientStream *client);
+ /* Virtual table */
+ MateMixerClientStreamFlags (*get_flags) (MateMixerClientStream *client);
+ MateMixerClientStreamRole (*get_role) (MateMixerClientStream *client);
+
+ MateMixerStream *(*get_parent) (MateMixerClientStream *client);
+ gboolean (*set_parent) (MateMixerClientStream *client,
+ MateMixerStream *stream);
+
+ gboolean (*remove) (MateMixerClientStream *client);
+
+ const gchar *(*get_app_name) (MateMixerClientStream *client);
+ const gchar *(*get_app_id) (MateMixerClientStream *client);
+ const gchar *(*get_app_version) (MateMixerClientStream *client);
+ const gchar *(*get_app_icon) (MateMixerClientStream *client);
 };
 
-GType mate_mixer_client_stream_get_type (void) G_GNUC_CONST;
-MateMixerStream *mate_mixer_client_stream_get_parent (MateMixerClientStream *client);
-gboolean mate_mixer_client_stream_set_parent (MateMixerClientStream *client,
- MateMixerStream *parent);
-gboolean mate_mixer_client_stream_remove (MateMixerClientStream *client);
+GType mate_mixer_client_stream_get_type (void) G_GNUC_CONST;
+
+MateMixerClientStreamFlags mate_mixer_client_stream_get_flags (MateMixerClientStream *client);
+MateMixerClientStreamRole mate_mixer_client_stream_get_role (MateMixerClientStream *client);
+
+MateMixerStream * mate_mixer_client_stream_get_parent (MateMixerClientStream *client);
+gboolean mate_mixer_client_stream_set_parent (MateMixerClientStream *client,
+ MateMixerStream *parent);
+
+gboolean mate_mixer_client_stream_remove (MateMixerClientStream *client);
 
-const gchar * mate_mixer_client_stream_get_app_name (MateMixerClientStream *client);
-const gchar * mate_mixer_client_stream_get_app_id (MateMixerClientStream *client);
-const gchar * mate_mixer_client_stream_get_app_version (MateMixerClientStream *client);
-const gchar * mate_mixer_client_stream_get_app_icon (MateMixerClientStream *client);
+const gchar * mate_mixer_client_stream_get_app_name (MateMixerClientStream *client);
+const gchar * mate_mixer_client_stream_get_app_id (MateMixerClientStream *client);
+const gchar * mate_mixer_client_stream_get_app_version (MateMixerClientStream *client);
+const gchar * mate_mixer_client_stream_get_app_icon (MateMixerClientStream *client);
 
 G_END_DECLS
 
diff --git a/libmatemixer/matemixer-control.c b/libmatemixer/matemixer-control.c
index 6aac624..b501f1e 100644
--- a/libmatemixer/matemixer-control.c
+++ b/libmatemixer/matemixer-control.c
@@ -31,6 +31,7 @@
 
 /**
 * SECTION:matemixer-control
+ * @short_description:The main class for interfacing with the library
 * @include: libmatemixer/matemixer.h
 */
 
@@ -38,6 +39,7 @@ struct _MateMixerControlPrivate
 {
 GList *devices;
 GList *streams;
+ GList *cached_streams;
 gboolean backend_chosen;
 MateMixerState state;
 MateMixerBackend *backend;
@@ -63,74 +65,76 @@ static GParamSpec *properties[N_PROPERTIES] = { NULL, };
 
 enum {
 DEVICE_ADDED,
- DEVICE_CHANGED,
 DEVICE_REMOVED,
 STREAM_ADDED,
- STREAM_CHANGED,
 STREAM_REMOVED,
+ CACHED_STREAM_ADDED,
+ CACHED_STREAM_REMOVED,
 N_SIGNALS
 };
 
 static guint signals[N_SIGNALS] = { 0, };
 
-static void mate_mixer_control_class_init (MateMixerControlClass *klass);
+static void mate_mixer_control_class_init (MateMixerControlClass *klass);
 
-static void mate_mixer_control_get_property (GObject *object,
- guint param_id,
- GValue *value,
- GParamSpec *pspec);
-static void mate_mixer_control_set_property (GObject *object,
- guint param_id,
- const GValue *value,
- GParamSpec *pspec);
+static void mate_mixer_control_get_property (GObject *object,
+ guint param_id,
+ GValue *value,
+ GParamSpec *pspec);
+static void mate_mixer_control_set_property (GObject *object,
+ guint param_id,
+ const GValue *value,
+ GParamSpec *pspec);
 
-static void mate_mixer_control_init (MateMixerControl *control);
-static void mate_mixer_control_dispose (GObject *object);
-static void mate_mixer_control_finalize (GObject *object);
+static void mate_mixer_control_init (MateMixerControl *control);
+static void mate_mixer_control_dispose (GObject *object);
+static void mate_mixer_control_finalize (GObject *object);
 
 G_DEFINE_TYPE (MateMixerControl, mate_mixer_control, G_TYPE_OBJECT);
 
-static void control_backend_state_cb (MateMixerBackend *backend,
- GParamSpec *pspec,
- MateMixerControl *control);
-
-static void control_backend_device_added_cb (MateMixerBackend *backend,
- const gchar *name,
- MateMixerControl *control);
-static void control_backend_device_changed_cb (MateMixerBackend *backend,
- const gchar *name,
- MateMixerControl *control);
-static void control_backend_device_removed_cb (MateMixerBackend *backend,
- const gchar *name,
- MateMixerControl *control);
-
-static void control_backend_stream_added_cb (MateMixerBackend *backend,
- const gchar *name,
- MateMixerControl *control);
-static void control_backend_stream_changed_cb (MateMixerBackend *backend,
- const gchar *name,
- MateMixerControl *control);
-static void control_backend_stream_removed_cb (MateMixerBackend *backend,
- const gchar *name,
- MateMixerControl *control);
-
-static void control_backend_default_input_cb (MateMixerBackend *backend,
- GParamSpec *pspec,
- MateMixerControl *control);
-static void control_backend_default_output_cb (MateMixerBackend *backend,
- GParamSpec *pspec,
- MateMixerControl *control);
-
-static gboolean control_try_next_backend (MateMixerControl *control);
-
-static void control_change_state (MateMixerControl *control,
- MateMixerState state);
-
-static void control_close (MateMixerControl *control);
-
-static void control_free_backend (MateMixerControl *control);
-static void control_free_devices (MateMixerControl *control);
-static void control_free_streams (MateMixerControl *control);
+static void on_backend_state_notify (MateMixerBackend *backend,
+ GParamSpec *pspec,
+ MateMixerControl *control);
+
+static void on_backend_device_added (MateMixerBackend *backend,
+ const gchar *name,
+ MateMixerControl *control);
+static void on_backend_device_removed (MateMixerBackend *backend,
+ const gchar *name,
+ MateMixerControl *control);
+
+static void on_backend_stream_added (MateMixerBackend *backend,
+ const gchar *name,
+ MateMixerControl *control);
+static void on_backend_stream_removed (MateMixerBackend *backend,
+ const gchar *name,
+ MateMixerControl *control);
+
+static void on_backend_cached_stream_added (MateMixerBackend *backend,
+ const gchar *name,
+ MateMixerControl *control);
+static void on_backend_cached_stream_removed (MateMixerBackend *backend,
+ const gchar *name,
+ MateMixerControl *control);
+
+static void on_backend_default_input_notify (MateMixerBackend *backend,
+ GParamSpec *pspec,
+ MateMixerControl *control);
+static void on_backend_default_output_notify (MateMixerBackend *backend,
+ GParamSpec *pspec,
+ MateMixerControl *control);
+
+static gboolean try_next_backend (MateMixerControl *control);
+
+static void change_state (MateMixerControl *control,
+ MateMixerState state);
+
+static void close_control (MateMixerControl *control);
+
+static void free_backend (MateMixerControl *control);
+static void free_devices (MateMixerControl *control);
+static void free_streams (MateMixerControl *control);
+static void free_cached_streams (MateMixerControl *control);
 
 static void
 mate_mixer_control_class_init (MateMixerControlClass *klass)
@@ -219,14 +223,14 @@ mate_mixer_control_class_init (MateMixerControlClass *klass)
 "Default input",
 "Default input stream",
 MATE_MIXER_TYPE_STREAM,
- G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 
 properties[PROP_DEFAULT_OUTPUT] =
 g_param_spec_object ("default-output",
 "Default output",
 "Default output stream",
 MATE_MIXER_TYPE_STREAM,
- G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
+ G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 
 g_object_class_install_properties (object_class, N_PROPERTIES, properties);
 
@@ -250,18 +254,17 @@ mate_mixer_control_class_init (MateMixerControlClass *klass)
 G_TYPE_STRING);
 
 /**
- * MateMixerControl::device-changed:
+ * MateMixerControl::device-removed:
 * @control: a #MateMixerControl
- * @name: name of the changed device
+ * @name: name of the removed device
 *
- * The signal is emitted each time a change occurs on one of the known
- * devices.
+ * The signal is emitted each time a device is removed from the system.
 */
- signals[DEVICE_CHANGED] =
- g_signal_new ("device-changed",
+ signals[DEVICE_REMOVED] =
+ g_signal_new ("device-removed",
 G_TYPE_FROM_CLASS (object_class),
 G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (MateMixerControlClass, device_changed),
+ G_STRUCT_OFFSET (MateMixerControlClass, device_removed),
 NULL,
 NULL,
 g_cclosure_marshal_VOID__STRING,
@@ -270,17 +273,17 @@ mate_mixer_control_class_init (MateMixerControlClass *klass)
 G_TYPE_STRING);
 
 /**
- * MateMixerControl::device-removed:
+ * MateMixerControl::stream-added:
 * @control: a #MateMixerControl
- * @name: name of the removed device
+ * @name: name of the added stream
 *
- * The signal is emitted each time a device is removed from the system.
+ * The signal is emitted each time a stream is created.
 */
- signals[DEVICE_REMOVED] =
- g_signal_new ("device-removed",
+ signals[STREAM_ADDED] =
+ g_signal_new ("stream-added",
 G_TYPE_FROM_CLASS (object_class),
 G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (MateMixerControlClass, device_removed),
+ G_STRUCT_OFFSET (MateMixerControlClass, stream_added),
 NULL,
 NULL,
 g_cclosure_marshal_VOID__STRING,
@@ -289,17 +292,17 @@ mate_mixer_control_class_init (MateMixerControlClass *klass)
 G_TYPE_STRING);
 
 /**
- * MateMixerControl::stream-added:
+ * MateMixerControl::stream-removed:
 * @control: a #MateMixerControl
- * @name: name of the added stream
+ * @name: name of the removed stream
 *
- * The signal is emitted each time a stream is added to the system.
+ * The signal is emitted each time a stream is removed.
 */
- signals[STREAM_ADDED] =
- g_signal_new ("stream-added",
+ signals[STREAM_REMOVED] =
+ g_signal_new ("stream-removed",
 G_TYPE_FROM_CLASS (object_class),
 G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (MateMixerControlClass, stream_added),
+ G_STRUCT_OFFSET (MateMixerControlClass, stream_removed),
 NULL,
 NULL,
 g_cclosure_marshal_VOID__STRING,
@@ -308,18 +311,17 @@ mate_mixer_control_class_init (MateMixerControlClass *klass)
 G_TYPE_STRING);
 
 /**
- * MateMixerControl::stream-changed:
+ * MateMixerControl::cached-stream-added:
 * @control: a #MateMixerControl
- * @name: name of the changed stream
+ * @name: name of the added cached stream
 *
- * The signal is emitted each time a change occurs on one of the known
- * streams.
+ * The signal is emitted each time a cached stream is created.
 */
- signals[STREAM_CHANGED] =
- g_signal_new ("stream-changed",
+ signals[CACHED_STREAM_ADDED] =
+ g_signal_new ("cached-stream-added",
 G_TYPE_FROM_CLASS (object_class),
 G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (MateMixerControlClass, stream_changed),
+ G_STRUCT_OFFSET (MateMixerControlClass, cached_stream_added),
 NULL,
 NULL,
 g_cclosure_marshal_VOID__STRING,
@@ -332,13 +334,13 @@ mate_mixer_control_class_init (MateMixerControlClass *klass)
 * @control: a #MateMixerControl
 * @name: name of the removed stream
 *
- * The signal is emitted each time a stream is removed from the system.
+ * The signal is emitted each time a stream is removed.
 */
- signals[STREAM_REMOVED] =
- g_signal_new ("stream-removed",
+ signals[CACHED_STREAM_REMOVED] =
+ g_signal_new ("cached-stream-removed",
 G_TYPE_FROM_CLASS (object_class),
 G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (MateMixerControlClass, stream_removed),
+ G_STRUCT_OFFSET (MateMixerControlClass, cached_stream_removed),
 NULL,
 NULL,
 g_cclosure_marshal_VOID__STRING,
@@ -416,6 +418,12 @@ mate_mixer_control_set_property (GObject *object,
 case PROP_SERVER_ADDRESS:
 mate_mixer_control_set_server_address (control, g_value_get_string (value));
 break;
+ case PROP_DEFAULT_INPUT:
+ mate_mixer_control_set_default_input_stream (control, g_value_get_object (value));
+ break;
+ case PROP_DEFAULT_OUTPUT:
+ mate_mixer_control_set_default_output_stream (control, g_value_get_object (value));
+ break;
 default:
 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 break;
@@ -433,7 +441,7 @@ mate_mixer_control_init (MateMixerControl *control)
 static void
 mate_mixer_control_dispose (GObject *object)
 {
- control_close (MATE_MIXER_CONTROL (object));
+ close_control (MATE_MIXER_CONTROL (object));
 
 G_OBJECT_CLASS (mate_mixer_control_parent_class)->dispose (object);
 }
@@ -465,10 +473,11 @@ mate_mixer_control_finalize (GObject *object)
 MateMixerControl *
 mate_mixer_control_new (void)
 {
- if (!mate_mixer_is_initialized ()) {
+ if (mate_mixer_is_initialized () == FALSE) {
 g_critical ("The library has not been initialized");
 return NULL;
 }
+
 return g_object_new (MATE_MIXER_TYPE_CONTROL, NULL);
 }
 
@@ -504,7 +513,8 @@ mate_mixer_control_set_backend_type (MateMixerControl *control,
 return FALSE;
 
 modules = mate_mixer_get_modules ();
- while (modules) {
+
+ while (modules != NULL) {
 module = MATE_MIXER_BACKEND_MODULE (modules->data);
 info = mate_mixer_backend_module_get_info (module);
 
@@ -540,11 +550,13 @@ mate_mixer_control_set_app_name (MateMixerControl *control, const gchar *app_nam
 control->priv->state == MATE_MIXER_STATE_READY)
 return FALSE;
 
- g_free (control->priv->backend_data.app_name);
+ if (g_strcmp0 (control->priv->backend_data.app_name, app_name) != 0) {
+ g_free (control->priv->backend_data.app_name);
 
- control->priv->backend_data.app_name = g_strdup (app_name);
+ control->priv->backend_data.app_name = g_strdup (app_name);
 
- g_object_notify_by_pspec (G_OBJECT (control), properties[PROP_APP_NAME]);
+ g_object_notify_by_pspec (G_OBJECT (control), properties[PROP_APP_NAME]);
+ }
 return TRUE;
 }
 
@@ -571,11 +583,13 @@ mate_mixer_control_set_app_id (MateMixerControl *control, const gchar *app_id)
 control->priv->state == MATE_MIXER_STATE_READY)
 return FALSE;
 
- g_free (control->priv->backend_data.app_id);
+ if (g_strcmp0 (control->priv->backend_data.app_id, app_id) != 0) {
+ g_free (control->priv->backend_data.app_id);
 
- control->priv->backend_data.app_id = g_strdup (app_id);
+ control->priv->backend_data.app_id = g_strdup (app_id);
 
- g_object_notify_by_pspec (G_OBJECT (control), properties[PROP_APP_ID]);
+ g_object_notify_by_pspec (G_OBJECT (control), properties[PROP_APP_ID]);
+ }
 return TRUE;
 }
 
@@ -602,11 +616,13 @@ mate_mixer_control_set_app_version (MateMixerControl *control, const gchar *app_
 control->priv->state == MATE_MIXER_STATE_READY)
 return FALSE;
 
- g_free (control->priv->backend_data.app_version);
+ if (g_strcmp0 (control->priv->backend_data.app_version, app_version) != 0) {
+ g_free (control->priv->backend_data.app_version);
 
- control->priv->backend_data.app_version = g_strdup (app_version);
+ control->priv->backend_data.app_version = g_strdup (app_version);
 
- g_object_notify_by_pspec (G_OBJECT (control), properties[PROP_APP_VERSION]);
+ g_object_notify_by_pspec (G_OBJECT (control), properties[PROP_APP_VERSION]);
+ }
 return TRUE;
 }
 
@@ -633,11 +649,13 @@ mate_mixer_control_set_app_icon (MateMixerControl *control, const gchar *app_ico
 control->priv->state == MATE_MIXER_STATE_READY)
 return FALSE;
 
- g_free (control->priv->backend_data.app_icon);
+ if (g_strcmp0 (control->priv->backend_data.app_icon, app_icon) != 0) {
+ g_free (control->priv->backend_data.app_icon);
 
- control->priv->backend_data.app_icon = g_strdup (app_icon);
+ control->priv->backend_data.app_icon = g_strdup (app_icon);
 
- g_object_notify_by_pspec (G_OBJECT (control), properties[PROP_APP_ICON]);
+ g_object_notify_by_pspec (G_OBJECT (control), properties[PROP_APP_ICON]);
+ }
 return TRUE;
 }
 
@@ -665,11 +683,13 @@ mate_mixer_control_set_server_address (MateMixerControl *control, const gchar *a
 control->priv->state == MATE_MIXER_STATE_READY)
 return FALSE;
 
- g_free (control->priv->backend_data.server_address);
+ if (g_strcmp0 (control->priv->backend_data.server_address, address) != 0) {
+ g_free (control->priv->backend_data.server_address);
 
- control->priv->backend_data.server_address = g_strdup (address);
+ control->priv->backend_data.server_address = g_strdup (address);
 
- g_object_notify_by_pspec (G_OBJECT (control), properties[PROP_SERVER_ADDRESS]);
+ g_object_notify_by_pspec (G_OBJECT (control), properties[PROP_SERVER_ADDRESS]);
+ }
 return TRUE;
 }
 
@@ -718,7 +738,7 @@ mate_mixer_control_open (MateMixerControl *control)
 modules = mate_mixer_get_modules ();
 
 if (control->priv->backend_type != MATE_MIXER_BACKEND_UNKNOWN) {
- while (modules) {
+ while (modules != NULL) {
 const MateMixerBackendInfo *info;
 
 module = MATE_MIXER_BACKEND_MODULE (modules->data);
@@ -736,7 +756,7 @@ mate_mixer_control_open (MateMixerControl *control)
 }
 if (module == NULL) {
 /* Most likely the selected backend is not installed */
- control_change_state (control, MATE_MIXER_STATE_FAILED);
+ change_state (control, MATE_MIXER_STATE_FAILED);
 return FALSE;
 }
 
@@ -750,19 +770,19 @@ mate_mixer_control_open (MateMixerControl *control)
 
 /* This transitional state is always present, it will change to MATE_MIXER_STATE_READY
 * or MATE_MIXER_STATE_FAILED either instantly or asynchronously */
- control_change_state (control, MATE_MIXER_STATE_CONNECTING);
+ change_state (control, MATE_MIXER_STATE_CONNECTING);
 
 /* The backend initialization might fail in case it is known right now that
 * the backend is unusable */
- if (!mate_mixer_backend_open (control->priv->backend)) {
+ if (mate_mixer_backend_open (control->priv->backend) == FALSE) {
 if (control->priv->backend_type == MATE_MIXER_BACKEND_UNKNOWN) {
 /* User didn't request a specific backend, so try another one */
- return control_try_next_backend (control);
+ return try_next_backend (control);
 }
 
 /* User requested a specific backend and it failed */
- control_close (control);
- control_change_state (control, MATE_MIXER_STATE_FAILED);
+ close_control (control);
+ change_state (control, MATE_MIXER_STATE_FAILED);
 return FALSE;
 }
 
@@ -773,17 +793,20 @@ mate_mixer_control_open (MateMixerControl *control)
 /* This would be a backend bug */
 g_warn_if_reached ();
 
- control_close (control);
- control_change_state (control, MATE_MIXER_STATE_FAILED);
+ if (control->priv->backend_type == MATE_MIXER_BACKEND_UNKNOWN)
+ return try_next_backend (control);
+
+ close_control (control);
+ change_state (control, MATE_MIXER_STATE_FAILED);
 return FALSE;
 }
 
- g_signal_connect (control->priv->backend,
+ g_signal_connect (G_OBJECT (control->priv->backend),
 "notify::state",
- G_CALLBACK (control_backend_state_cb),
+ G_CALLBACK (on_backend_state_notify),
 control);
 
- control_change_state (control, state);
+ change_state (control, state);
 return TRUE;
 }
 
@@ -799,8 +822,8 @@ mate_mixer_control_close (MateMixerControl *control)
 {
 g_return_if_fail (MATE_MIXER_IS_CONTROL (control));
 
- control_close (control);
- control_change_state (control, MATE_MIXER_STATE_IDLE);
+ close_control (control);
+ change_state (control, MATE_MIXER_STATE_IDLE);
 }
 
 /**
@@ -837,10 +860,10 @@ mate_mixer_control_get_device (MateMixerControl *control, const gchar *name)
 g_return_val_if_fail (name != NULL, NULL);
 
 list = mate_mixer_control_list_devices (control);
- while (list) {
+ while (list != NULL) {
 MateMixerDevice *device = MATE_MIXER_DEVICE (list->data);
 
- if (!strcmp (name, mate_mixer_device_get_name (device)))
+ if (strcmp (name, mate_mixer_device_get_name (device)) == 0)
 return device;
 
 list = list->next;
@@ -866,10 +889,36 @@ mate_mixer_control_get_stream (MateMixerControl *control, const gchar *name)
 g_return_val_if_fail (name != NULL, NULL);
 
 list = mate_mixer_control_list_streams (control);
+ while (list != NULL) {
+ MateMixerStream *stream = MATE_MIXER_STREAM (list->data);
+
+ if (strcmp (name, mate_mixer_stream_get_name (stream)) == 0)
+ return stream;
+
+ list = list->next;
+ }
+ return NULL;
+}
+
+/**
+ * mate_mixer_control_get_cached_stream:
+ * @control: a #MateMixerControl
+ * @name: a stream name
+ *
+ */
+MateMixerStream *
+mate_mixer_control_get_cached_stream (MateMixerControl *control, const gchar *name)
+{
+ const GList *list;
+
+ g_return_val_if_fail (MATE_MIXER_IS_CONTROL (control), NULL);
+ g_return_val_if_fail (name != NULL, NULL);
+
+ list = mate_mixer_control_list_cached_streams (control);
 while (list) {
 MateMixerStream *stream = MATE_MIXER_STREAM (list->data);
 
- if (!strcmp (name, mate_mixer_stream_get_name (stream)))
+ if (strcmp (name, mate_mixer_stream_get_name (stream)) == 0)
 return stream;
 
 list = list->next;
@@ -938,6 +987,28 @@ mate_mixer_control_list_streams (MateMixerControl *control)
 }
 
 /**
+ * mate_mixer_control_list_cached_streams:
+ * @control: a #MateMixerControl
+ *
+ */
+const GList *
+mate_mixer_control_list_cached_streams (MateMixerControl *control)
+{
+ g_return_val_if_fail (MATE_MIXER_IS_CONTROL (control), NULL);
+
+ if (control->priv->state != MATE_MIXER_STATE_READY)
+ return NULL;
+
+ /* This list is cached here and invalidated when the backend notifies us
+ * about a change */
+ if (control->priv->cached_streams == NULL)
+ control->priv->cached_streams =
+ mate_mixer_backend_list_cached_streams (MATE_MIXER_BACKEND (control->priv->backend));
+
+ return (const GList *) control->priv->cached_streams;
+}
+
+/**
 * mate_mixer_control_get_default_input_stream:
 * @control: a #MateMixerControl
 *
@@ -1057,7 +1128,7 @@ mate_mixer_control_get_backend_name (MateMixerControl *control)
 {
 g_return_val_if_fail (MATE_MIXER_IS_CONTROL (control), NULL);
 
- if (!control->priv->backend_chosen)
+ if (control->priv->backend_chosen == FALSE)
 return NULL;
 
 return mate_mixer_backend_module_get_info (control->priv->module)->name;
@@ -1077,16 +1148,16 @@ mate_mixer_control_get_backend_type (MateMixerControl *control)
 {
 g_return_val_if_fail (MATE_MIXER_IS_CONTROL (control), MATE_MIXER_BACKEND_UNKNOWN);
 
- if (!control->priv->backend_chosen)
+ if (control->priv->backend_chosen == FALSE)
 return MATE_MIXER_BACKEND_UNKNOWN;
 
 return mate_mixer_backend_module_get_info (control->priv->module)->backend_type;
 }
 
 static void
-control_backend_state_cb (MateMixerBackend *backend,
- GParamSpec *pspec,
- MateMixerControl *control)
+on_backend_state_notify (MateMixerBackend *backend,
+ GParamSpec *pspec,
+ MateMixerControl *control)
 {
 MateMixerState state = mate_mixer_backend_get_state (backend);
 
@@ -1095,19 +1166,20 @@ control_backend_state_cb (MateMixerBackend *backend,
 g_debug ("Backend %s changed state to CONNECTING",
 mate_mixer_backend_module_get_info (control->priv->module)->name);
 
- if (control->priv->backend_chosen) {
+ if (control->priv->backend_chosen == TRUE) {
 /* Invalidate cached data when reconnecting */
- control_free_devices (control);
- control_free_devices (control);
+ free_devices (control);
+ free_streams (control);
+ free_cached_streams (control);
 }
- control_change_state (control, state);
+ change_state (control, state);
 break;
 
 case MATE_MIXER_STATE_READY:
 g_debug ("Backend %s changed state to READY",
 mate_mixer_backend_module_get_info (control->priv->module)->name);
 
- control_change_state (control, state);
+ change_state (control, state);
 break;
 
 case MATE_MIXER_STATE_FAILED:
@@ -1116,11 +1188,11 @@ control_backend_state_cb (MateMixerBackend *backend,
 
 if (control->priv->backend_type == MATE_MIXER_BACKEND_UNKNOWN) {
 /* User didn't request a specific backend, so try another one */
- control_try_next_backend (control);
+ try_next_backend (control);
 } else {
 /* User requested a specific backend and it failed */
- control_close (control);
- control_change_state (control, state);
+ close_control (control);
+ change_state (control, state);
 }
 break;
 
@@ -1130,11 +1202,11 @@ control_backend_state_cb (MateMixerBackend *backend,
 }
 
 static void
-control_backend_device_added_cb (MateMixerBackend *backend,
- const gchar *name,
- MateMixerControl *control)
+on_backend_device_added (MateMixerBackend *backend,
+ const gchar *name,
+ MateMixerControl *control)
 {
- control_free_devices (control);
+ free_devices (control);
 
 g_signal_emit (G_OBJECT (control),
 signals[DEVICE_ADDED],
@@ -1143,107 +1215,110 @@ control_backend_device_added_cb (MateMixerBackend *backend,
 }
 
 static void
-control_backend_device_changed_cb (MateMixerBackend *backend,
- const gchar *name,
- MateMixerControl *control)
+on_backend_device_removed (MateMixerBackend *backend,
+ const gchar *name,
+ MateMixerControl *control)
 {
+ free_devices (control);
+
 g_signal_emit (G_OBJECT (control),
- signals[DEVICE_CHANGED],
+ signals[DEVICE_REMOVED],
 0,
 name);
 }
 
 static void
-control_backend_device_removed_cb (MateMixerBackend *backend,
- const gchar *name,
- MateMixerControl *control)
+on_backend_stream_added (MateMixerBackend *backend,
+ const gchar *name,
+ MateMixerControl *control)
 {
- control_free_devices (control);
+ free_streams (control);
 
 g_signal_emit (G_OBJECT (control),
- signals[DEVICE_REMOVED],
+ signals[STREAM_ADDED],
 0,
 name);
 }
 
 static void
-control_backend_stream_added_cb (MateMixerBackend *backend,
- const gchar *name,
- MateMixerControl *control)
+on_backend_stream_removed (MateMixerBackend *backend,
+ const gchar *name,
+ MateMixerControl *control)
 {
- control_free_streams (control);
+ free_streams (control);
 
 g_signal_emit (G_OBJECT (control),
- signals[STREAM_ADDED],
+ signals[STREAM_REMOVED],
 0,
 name);
 }
 
 static void
-control_backend_stream_changed_cb (MateMixerBackend *backend,
- const gchar *name,
- MateMixerControl *control)
+on_backend_cached_stream_added (MateMixerBackend *backend,
+ const gchar *name,
+ MateMixerControl *control)
 {
+ free_cached_streams (control);
+
 g_signal_emit (G_OBJECT (control),
- signals[STREAM_CHANGED],
+ signals[CACHED_STREAM_ADDED],
 0,
 name);
 }
 
 static void
-control_backend_stream_removed_cb (MateMixerBackend *backend,
- const gchar *name,
- MateMixerControl *control)
+on_backend_cached_stream_removed (MateMixerBackend *backend,
+ const gchar *name,
+ MateMixerControl *control)
 {
- control_free_streams (control);
+ free_cached_streams (control);
 
 g_signal_emit (G_OBJECT (control),
- signals[STREAM_REMOVED],
+ signals[CACHED_STREAM_REMOVED],
 0,
 name);
 }
 
 static void
-control_backend_default_input_cb (MateMixerBackend *backend,
- GParamSpec *pspec,
- MateMixerControl *control)
+on_backend_default_input_notify (MateMixerBackend *backend,
+ GParamSpec *pspec,
+ MateMixerControl *control)
 {
 g_object_notify_by_pspec (G_OBJECT (control), properties[PROP_DEFAULT_INPUT]);
 }
 
 static void
-control_backend_default_output_cb (MateMixerBackend *backend,
- GParamSpec *pspec,
- MateMixerControl *control)
+on_backend_default_output_notify (MateMixerBackend *backend,
+ GParamSpec *pspec,
+ MateMixerControl *control)
 {
 g_object_notify_by_pspec (G_OBJECT (control), properties[PROP_DEFAULT_OUTPUT]);
 }
 
 static gboolean
-control_try_next_backend (MateMixerControl *control)
+try_next_backend (MateMixerControl *control)
 {
 const GList *modules;
 MateMixerBackendModule *module = NULL;
 MateMixerState state;
 
 modules = mate_mixer_get_modules ();
- while (modules) {
+
+ while (modules != NULL) {
 if (control->priv->module == modules->data) {
 /* Found the last tested backend, try to use the next one with a lower
 * priority unless we have reached the end of the list */
- if (modules->next)
+ if (modules->next != NULL)
 module = MATE_MIXER_BACKEND_MODULE (modules->next->data);
 break;
 }
 modules = modules->next;
 }
- control_close (control);
+ close_control (control);
 
 if (module == NULL) {
- /* This shouldn't happen under normal circumstances as the lowest
- * priority module is the "Null" module which never fails to initialize,
- * but in a broken installation this module could be missing */
- control_change_state (control, MATE_MIXER_STATE_FAILED);
+ /* We have tried all the modules and all of them failed */
+ change_state (control, MATE_MIXER_STATE_FAILED);
 return FALSE;
 }
 
@@ -1253,8 +1328,10 @@ control_try_next_backend (MateMixerControl *control)
 
 mate_mixer_backend_set_data (control->priv->backend, &control->priv->backend_data);
 
- if (!mate_mixer_backend_open (control->priv->backend))
- return control_try_next_backend (control);
+ /* Try to open this backend and in case of failure keep trying until we find
+ * one that works or reach the end of the list */
+ if (mate_mixer_backend_open (control->priv->backend) == FALSE)
+ return try_next_backend (control);
 
 state = mate_mixer_backend_get_state (control->priv->backend);
 
@@ -1263,64 +1340,63 @@ control_try_next_backend (MateMixerControl *control)
 /* This would be a backend bug */
 g_warn_if_reached ();
 
- control_close (control);
- return control_try_next_backend (control);
+ return try_next_backend (control);
 }
 
- g_signal_connect (control->priv->backend,
+ g_signal_connect (G_OBJECT (control->priv->backend),
 "notify::state",
- G_CALLBACK (control_backend_state_cb),
+ G_CALLBACK (on_backend_state_notify),
 control);
 
- control_change_state (control, state);
+ change_state (control, state);
 return TRUE;
 }
 
 static void
-control_change_state (MateMixerControl *control, MateMixerState state)
+change_state (MateMixerControl *control, MateMixerState state)
 {
 if (control->priv->state == state)
 return;
 
 control->priv->state = state;
 
- if (state == MATE_MIXER_STATE_READY && !control->priv->backend_chosen) {
+ if (state == MATE_MIXER_STATE_READY && control->priv->backend_chosen == FALSE) {
 /* It is safe to connect to the backend signals after reaching the READY
 * state, because the app is not allowed to query any data before that state;
 * therefore we won't end up in an inconsistent state by caching a list and
 * then missing a notification about a change in the list */
- g_signal_connect (control->priv->backend,
+ g_signal_connect (G_OBJECT (control->priv->backend),
 "device-added",
- G_CALLBACK (control_backend_device_added_cb),
- control);
- g_signal_connect (control->priv->backend,
- "device-changed",
- G_CALLBACK (control_backend_device_changed_cb),
+ G_CALLBACK (on_backend_device_added),
 control);
- g_signal_connect (control->priv->backend,
+ g_signal_connect (G_OBJECT (control->priv->backend),
 "device-removed",
- G_CALLBACK (control_backend_device_removed_cb),
+ G_CALLBACK (on_backend_device_removed),
 control);
- g_signal_connect (control->priv->backend,
+ g_signal_connect (G_OBJECT (control->priv->backend),
 "stream-added",
- G_CALLBACK (control_backend_stream_added_cb),
+ G_CALLBACK (on_backend_stream_added),
 control);
- g_signal_connect (control->priv->backend,
- "stream-changed",
- G_CALLBACK (control_backend_stream_changed_cb),
- control);
- g_signal_connect (control->priv->backend,
+ g_signal_connect (G_OBJECT (control->priv->backend),
 "stream-removed",
- G_CALLBACK (control_backend_stream_removed_cb),
+ G_CALLBACK (on_backend_stream_removed),
+ control);
+ g_signal_connect (G_OBJECT (control->priv->backend),
+ "cached-stream-added",
+ G_CALLBACK (on_backend_cached_stream_added),
+ control);
+ g_signal_connect (G_OBJECT (control->priv->backend),
+ "cached-stream-removed",
+ G_CALLBACK (on_backend_cached_stream_removed),
 control);
 
- g_signal_connect (control->priv->backend,
+ g_signal_connect (G_OBJECT (control->priv->backend),
 "notify::default-input",
- G_CALLBACK (control_backend_default_input_cb),
+ G_CALLBACK (on_backend_default_input_notify),
 control);
- g_signal_connect (control->priv->backend,
+ g_signal_connect (G_OBJECT (control->priv->backend),
 "notify::default-output",
- G_CALLBACK (control_backend_default_output_cb),
+ G_CALLBACK (on_backend_default_output_notify),
 control);
 
 control->priv->backend_chosen = TRUE;
@@ -1330,28 +1406,34 @@ control_change_state (MateMixerControl *control, MateMixerState state)
 }
 
 static void
-control_close (MateMixerControl *control)
+close_control (MateMixerControl *control)
 {
- control_free_backend (control);
- control_free_devices (control);
- control_free_streams (control);
+ free_backend (control);
+ free_devices (control);
+ free_streams (control);
+ free_cached_streams (control);
 
 g_clear_object (&control->priv->module);
+
+ control->priv->backend_chosen = FALSE;
 }
 
 static void
-control_free_backend (MateMixerControl *control)
+free_backend (MateMixerControl *control)
 {
 if (control->priv->backend == NULL)
 return;
 
+ g_signal_handlers_disconnect_by_data (G_OBJECT (control->priv->backend),
+ control);
+
 mate_mixer_backend_close (control->priv->backend);
 
 g_clear_object (&control->priv->backend);
 }
 
 static void
-control_free_devices (MateMixerControl *control)
+free_devices (MateMixerControl *control)
 {
 if (control->priv->devices == NULL)
 return;
@@ -1362,7 +1444,7 @@ control_free_devices (MateMixerControl *control)
 }
 
 static void
-control_free_streams (MateMixerControl *control)
+free_streams (MateMixerControl *control)
 {
 if (control->priv->streams == NULL)
 return;
@@ -1371,3 +1453,14 @@ control_free_streams (MateMixerControl *control)
 
 control->priv->streams = NULL;
 }
+
+static void
+free_cached_streams (MateMixerControl *control)
+{
+ if (control->priv->cached_streams == NULL)
+ return;
+
+ g_list_free_full (control->priv->cached_streams, g_object_unref);
+
+ control->priv->cached_streams = NULL;
+}
diff --git a/libmatemixer/matemixer-control.h b/libmatemixer/matemixer-control.h
index 5598ade..e6d3afa 100644
--- a/libmatemixer/matemixer-control.h
+++ b/libmatemixer/matemixer-control.h
@@ -68,21 +68,29 @@ struct _MateMixerControlClass
 GObjectClass parent_class;
 
 /*< private >*/
- void (*device_added) (MateMixerControl *control,
- const gchar *name);
- void (*device_changed) (MateMixerControl *control,
- const gchar *name);
- void (*device_removed) (MateMixerControl *control,
- const gchar *name);
- void (*stream_added) (MateMixerControl *control,
- const gchar *name);
- void (*stream_changed) (MateMixerControl *control,
- const gchar *name);
- void (*stream_removed) (MateMixerControl *control,
- const gchar *name);
+ /* Signals */
+ void (*device_added) (MateMixerControl *control,
+ const gchar *name);
+ void (*device_changed) (MateMixerControl *control,
+ const gchar *name);
+ void (*device_removed) (MateMixerControl *control,
+ const gchar *name);
+ void (*stream_added) (MateMixerControl *control,
+ const gchar *name);
+ void (*stream_changed) (MateMixerControl *control,
+ const gchar *name);
+ void (*stream_removed) (MateMixerControl *control,
+ const gchar *name);
+ void (*cached_stream_added) (MateMixerControl *control,
+ const gchar *name);
+ void (*cached_stream_changed) (MateMixerControl *control,
+ const gchar *name);
+ void (*cached_stream_removed) (MateMixerControl *control,
+ const gchar *name);
 };
 
 GType mate_mixer_control_get_type (void) G_GNUC_CONST;
+
 MateMixerControl * mate_mixer_control_new (void);
 
 gboolean mate_mixer_control_set_backend_type (MateMixerControl *control,
@@ -97,6 +105,7 @@ gboolean mate_mixer_control_set_app_icon (MateMixerCon
 const gchar *app_icon);
 gboolean mate_mixer_control_set_server_address (MateMixerControl *control,
 const gchar *address);
+
 gboolean mate_mixer_control_open (MateMixerControl *control);
 void mate_mixer_control_close (MateMixerControl *control);
 
@@ -106,9 +115,12 @@ MateMixerDevice * mate_mixer_control_get_device (MateMixerCon
 const gchar *name);
 MateMixerStream * mate_mixer_control_get_stream (MateMixerControl *control,
 const gchar *name);
+MateMixerStream * mate_mixer_control_get_cached_stream (MateMixerControl *control,
+ const gchar *name);
 
 const GList * mate_mixer_control_list_devices (MateMixerControl *control);
 const GList * mate_mixer_control_list_streams (MateMixerControl *control);
+const GList * mate_mixer_control_list_cached_streams (MateMixerControl *control);
 
 MateMixerStream * mate_mixer_control_get_default_input_stream (MateMixerControl *control);
 gboolean mate_mixer_control_set_default_input_stream (MateMixerControl *control,
diff --git a/libmatemixer/matemixer-device-profile-private.h b/libmatemixer/matemixer-device-profile-private.h
new file mode 100644
index 0000000..403c7d7
--- /dev/null
+++ b/libmatemixer/matemixer-device-profile-private.h
@@ -0,0 +1,44 @@
+/*
+ * 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_PRIVATE_H
+#define MATEMIXER_DEVICE_PROFILE_PRIVATE_H
+
+#include <glib.h>
+
+#include "matemixer-device-profile.h"
+
+G_BEGIN_DECLS
+
+MateMixerDeviceProfile *_mate_mixer_device_profile_new (const gchar *name,
+ const gchar *description,
+ guint priority,
+ guint input_streams,
+ guint output_streams);
+
+gboolean _mate_mixer_device_profile_update_description (MateMixerDeviceProfile *profile,
+ const gchar *description);
+gboolean _mate_mixer_device_profile_update_priority (MateMixerDeviceProfile *profile,
+ guint priority);
+gboolean _mate_mixer_device_profile_update_num_input_streams (MateMixerDeviceProfile *profile,
+ guint num);
+gboolean _mate_mixer_device_profile_update_num_output_streams (MateMixerDeviceProfile *profile,
+ guint num);
+
+G_END_DECLS
+
+#endif /* MATEMIXER_DEVICE_PROFILE_PRIVATE_H */
diff --git a/libmatemixer/matemixer-device-profile.c b/libmatemixer/matemixer-device-profile.c
index e229b6a..0485740 100644
--- a/libmatemixer/matemixer-device-profile.c
+++ b/libmatemixer/matemixer-device-profile.c
@@ -19,9 +19,11 @@
 #include <glib-object.h>
 
 #include "matemixer-device-profile.h"
+#include "matemixer-device-profile-private.h"
 
 /**
 * SECTION:matemixer-device-profile
+ * @short_description: Device profile
 * @include: libmatemixer/matemixer.h
 */
 
@@ -46,19 +48,19 @@ enum {
 
 static GParamSpec *properties[N_PROPERTIES] = { NULL, };
 
-static void mate_mixer_device_profile_class_init (MateMixerDeviceProfileClass *klass);
+static void mate_mixer_device_profile_class_init (MateMixerDeviceProfileClass *klass);
 
-static void mate_mixer_device_profile_get_property (GObject *object,
- guint param_id,
- GValue *value,
- GParamSpec *pspec);
-static void mate_mixer_device_profile_set_property (GObject *object,
- guint param_id,
- const GValue *value,
- GParamSpec *pspec);
+static void mate_mixer_device_profile_get_property (GObject *object,
+ guint param_id,
+ GValue *value,
+ GParamSpec *pspec);
+static void mate_mixer_device_profile_set_property (GObject *object,
+ guint param_id,
+ const GValue *value,
+ GParamSpec *pspec);
 
-static void mate_mixer_device_profile_init (MateMixerDeviceProfile *profile);
-static void mate_mixer_device_profile_finalize (GObject *object);
+static void mate_mixer_device_profile_init (MateMixerDeviceProfile *profile);
+static void mate_mixer_device_profile_finalize (GObject *object);
 
 G_DEFINE_TYPE (MateMixerDeviceProfile, mate_mixer_device_profile, G_TYPE_OBJECT);
 
@@ -215,22 +217,10 @@ mate_mixer_device_profile_finalize (GObject *object)
 G_OBJECT_CLASS (mate_mixer_device_profile_parent_class)->finalize (object);
 }
 
-MateMixerDeviceProfile *
-mate_mixer_device_profile_new (const gchar *name,
- const gchar *description,
- guint priority,
- guint input_streams,
- guint output_streams)
-{
- return g_object_new (MATE_MIXER_TYPE_DEVICE_PROFILE,
- "name", name,
- "description", description,
- "priority", priority,
- "num-input-streams", input_streams,
- "num-output-streams", output_streams,
- NULL);
-}
-
+/**
+ * mate_mixer_device_profile_get_name:
+ * @profile: a #MateMixerDeviceProfile
+ */
 const gchar *
 mate_mixer_device_profile_get_name (MateMixerDeviceProfile *profile)
 {
@@ -239,6 +229,10 @@ mate_mixer_device_profile_get_name (MateMixerDeviceProfile *profile)
 return profile->priv->name;
 }
 
+/**
+ * mate_mixer_device_profile_get_description:
+ * @profile: a #MateMixerDeviceProfile
+ */
 const gchar *
 mate_mixer_device_profile_get_description (MateMixerDeviceProfile *profile)
 {
@@ -247,6 +241,10 @@ mate_mixer_device_profile_get_description (MateMixerDeviceProfile *profile)
 return profile->priv->description;
 }
 
+/**
+ * mate_mixer_device_profile_get_priority:
+ * @profile: a #MateMixerDeviceProfile
+ */
 guint
 mate_mixer_device_profile_get_priority (MateMixerDeviceProfile *profile)
 {
@@ -255,6 +253,10 @@ mate_mixer_device_profile_get_priority (MateMixerDeviceProfile *profile)
 return profile->priv->priority;
 }
 
+/**
+ * mate_mixer_device_profile_get_num_input_streams:
+ * @profile: a #MateMixerDeviceProfile
+ */
 guint
 mate_mixer_device_profile_get_num_input_streams (MateMixerDeviceProfile *profile)
 {
@@ -263,6 +265,10 @@ mate_mixer_device_profile_get_num_input_streams (MateMixerDeviceProfile *profile
 return profile->priv->num_input_streams;
 }
 
+/**
+ * mate_mixer_device_profile_get_num_output_streams:
+ * @profile: a #MateMixerDeviceProfile
+ */
 guint
 mate_mixer_device_profile_get_num_output_streams (MateMixerDeviceProfile *profile)
 {
@@ -270,3 +276,85 @@ mate_mixer_device_profile_get_num_output_streams (MateMixerDeviceProfile *profil
 
 return profile->priv->num_output_streams;
 }
+
+MateMixerDeviceProfile *
+_mate_mixer_device_profile_new (const gchar *name,
+ const gchar *description,
+ guint priority,
+ guint input_streams,
+ guint output_streams)
+{
+ return g_object_new (MATE_MIXER_TYPE_DEVICE_PROFILE,
+ "name", name,
+ "description", description,
+ "priority", priority,
+ "num-input-streams", input_streams,
+ "num-output-streams", output_streams,
+ NULL);
+}
+
+gboolean
+_mate_mixer_device_profile_update_description (MateMixerDeviceProfile *profile,
+ const gchar *description)
+{
+ g_return_val_if_fail (MATE_MIXER_IS_DEVICE_PROFILE (profile), FALSE);
+
+ if (g_strcmp0 (profile->priv->description, description) != 0) {
+ g_free (profile->priv->description);
+
+ profile->priv->description = g_strdup (description);
+
+ g_object_notify_by_pspec (G_OBJECT (profile), properties[PROP_DESCRIPTION]);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+gboolean
+_mate_mixer_device_profile_update_priority (MateMixerDeviceProfile *profile,
+ guint priority)
+{
+ g_return_val_if_fail (MATE_MIXER_IS_DEVICE_PROFILE (profile), FALSE);
+
+ if (profile->priv->priority != priority) {
+ profile->priv->priority = priority;
+
+ g_object_notify_by_pspec (G_OBJECT (profile), properties[PROP_PRIORITY]);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+gboolean
+_mate_mixer_device_profile_update_num_input_streams (MateMixerDeviceProfile *profile,
+ guint num)
+{
+ g_return_val_if_fail (MATE_MIXER_IS_DEVICE_PROFILE (profile), FALSE);
+
+ if (profile->priv->num_input_streams != num) {
+ profile->priv->num_input_streams = num;
+
+ g_object_notify_by_pspec (G_OBJECT (profile), properties[PROP_NUM_INPUT_STREAMS]);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+gboolean
+_mate_mixer_device_profile_update_num_output_streams (MateMixerDeviceProfile *profile,
+ guint num)
+{
+ g_return_val_if_fail (MATE_MIXER_IS_DEVICE_PROFILE (profile), FALSE);
+
+ if (profile->priv->num_output_streams != num) {
+ profile->priv->num_output_streams = num;
+
+ g_object_notify_by_pspec (G_OBJECT (profile), properties[PROP_NUM_OUTPUT_STREAMS]);
+ return TRUE;
+ }
+
+ return FALSE;
+}
diff --git a/libmatemixer/matemixer-device-profile.h b/libmatemixer/matemixer-device-profile.h
index 6a4368b..e8fae19 100644
--- a/libmatemixer/matemixer-device-profile.h
+++ b/libmatemixer/matemixer-device-profile.h
@@ -53,19 +53,13 @@ struct _MateMixerDeviceProfileClass
 GObjectClass parent_class;
 };
 
-GType mate_mixer_device_profile_get_type (void) G_GNUC_CONST;
+GType mate_mixer_device_profile_get_type (void) G_GNUC_CONST;
 
-MateMixerDeviceProfile *mate_mixer_device_profile_new (const gchar *name,
- const gchar *description,
- guint priority,
- guint input_streams,
- guint output_streams);
-
-const gchar * mate_mixer_device_profile_get_name (MateMixerDeviceProfile *profile);
-const gchar * mate_mixer_device_profile_get_description (MateMixerDeviceProfile *profile);
-guint mate_mixer_device_profile_get_priority (MateMixerDeviceProfile *profile);
-guint mate_mixer_device_profile_get_num_input_streams (MateMixerDeviceProfile *profile);
-guint mate_mixer_device_profile_get_num_output_streams (MateMixerDeviceProfile *profile);
+const gchar *mate_mixer_device_profile_get_name (MateMixerDeviceProfile *profile);
+const gchar *mate_mixer_device_profile_get_description (MateMixerDeviceProfile *profile);
+guint mate_mixer_device_profile_get_priority (MateMixerDeviceProfile *profile);
+guint mate_mixer_device_profile_get_num_input_streams (MateMixerDeviceProfile *profile);
+guint mate_mixer_device_profile_get_num_output_streams (MateMixerDeviceProfile *profile);
 
 G_END_DECLS
 
diff --git a/libmatemixer/matemixer-device.c b/libmatemixer/matemixer-device.c
index 00a848a..0406709 100644
--- a/libmatemixer/matemixer-device.c
+++ b/libmatemixer/matemixer-device.c
@@ -20,9 +20,11 @@
 
 #include "matemixer-device.h"
 #include "matemixer-device-profile.h"
+#include "matemixer-port.h"
 
 /**
 * SECTION:matemixer-device
+ * @short_description: Hardware or software device in the sound system
 * @include: libmatemixer/matemixer.h
 */
 
@@ -34,7 +36,7 @@ mate_mixer_device_default_init (MateMixerDeviceInterface *iface)
 g_object_interface_install_property (iface,
 g_param_spec_string ("name",
 "Name",
- "Name of the sound device",
+ "Name of the device",
 NULL,
 G_PARAM_READABLE |
 G_PARAM_STATIC_STRINGS));
@@ -42,7 +44,7 @@ mate_mixer_device_default_init (MateMixerDeviceInterface *iface)
 g_object_interface_install_property (iface,
 g_param_spec_string ("description",
 "Description",
- "Description of the sound device",
+ "Description of the device",
 NULL,
 G_PARAM_READABLE |
 G_PARAM_STATIC_STRINGS));
@@ -56,36 +58,31 @@ mate_mixer_device_default_init (MateMixerDeviceInterface *iface)
 G_PARAM_STATIC_STRINGS));
 
 g_object_interface_install_property (iface,
- g_param_spec_pointer ("ports",
- "Ports",
- "GList of the sound device ports",
- G_PARAM_READABLE |
- G_PARAM_STATIC_STRINGS));
-
- g_object_interface_install_property (iface,
- g_param_spec_pointer ("profiles",
- "Profiles",
- "GList of the sound device profiles",
- G_PARAM_READABLE |
- G_PARAM_STATIC_STRINGS));
-
- g_object_interface_install_property (iface,
 g_param_spec_object ("active-profile",
 "Active profile",
- "The currently active profile of the sound device",
+ "The currently active profile of the device",
 MATE_MIXER_TYPE_DEVICE_PROFILE,
 G_PARAM_READABLE |
 G_PARAM_STATIC_STRINGS));
 }
 
+/**
+ * mate_mixer_device_get_name:
+ * @device: a #MateMixerDevice
+ */
 const gchar *
 mate_mixer_device_get_name (MateMixerDevice *device)
 {
 g_return_val_if_fail (MATE_MIXER_IS_DEVICE (device), NULL);
 
+ /* Implementation required */
 return MATE_MIXER_DEVICE_GET_INTERFACE (device)->get_name (device);
 }
 
+/**
+ * mate_mixer_device_get_description:
+ * @device: a #MateMixerDevice
+ */
 const gchar *
 mate_mixer_device_get_description (MateMixerDevice *device)
 {
@@ -101,6 +98,10 @@ mate_mixer_device_get_description (MateMixerDevice *device)
 return NULL;
 }
 
+/**
+ * mate_mixer_device_get_icon:
+ * @device: a #MateMixerDevice
+ */
 const gchar *
 mate_mixer_device_get_icon (MateMixerDevice *device)
 {
@@ -116,6 +117,52 @@ mate_mixer_device_get_icon (MateMixerDevice *device)
 return NULL;
 }
 
+/**
+ * mate_mixer_device_get_port:
+ * @device: a #MateMixerDevice
+ * @name: a port name
+ */
+MateMixerPort *
+mate_mixer_device_get_port (MateMixerDevice *device, const gchar *name)
+{
+ MateMixerDeviceInterface *iface;
+
+ g_return_val_if_fail (MATE_MIXER_IS_DEVICE (device), NULL);
+ g_return_val_if_fail (name != NULL, NULL);
+
+ iface = MATE_MIXER_DEVICE_GET_INTERFACE (device);
+
+ if (iface->get_port)
+ return iface->get_port (device, name);
+
+ return NULL;
+}
+
+/**
+ * mate_mixer_device_get_profile:
+ * @device: a #MateMixerDevice
+ * @name: a profile name
+ */
+MateMixerDeviceProfile *
+mate_mixer_device_get_profile (MateMixerDevice *device, const gchar *name)
+{
+ MateMixerDeviceInterface *iface;
+
+ g_return_val_if_fail (MATE_MIXER_IS_DEVICE (device), NULL);
+ g_return_val_if_fail (name != NULL, NULL);
+
+ iface = MATE_MIXER_DEVICE_GET_INTERFACE (device);
+
+ if (iface->get_profile)
+ return iface->get_profile (device, name);
+
+ return NULL;
+}
+
+/**
+ * mate_mixer_device_list_ports:
+ * @device: a #MateMixerDevice
+ */
 const GList *
 mate_mixer_device_list_ports (MateMixerDevice *device)
 {
@@ -131,6 +178,10 @@ mate_mixer_device_list_ports (MateMixerDevice *device)
 return NULL;
 }
 
+/**
+ * mate_mixer_device_list_profiles:
+ * @device: a #MateMixerDevice
+ */
 const GList *
 mate_mixer_device_list_profiles (MateMixerDevice *device)
 {
@@ -146,6 +197,10 @@ mate_mixer_device_list_profiles (MateMixerDevice *device)
 return NULL;
 }
 
+/**
+ * mate_mixer_device_get_active_profile:
+ * @device: a #MateMixerDevice
+ */
 MateMixerDeviceProfile *
 mate_mixer_device_get_active_profile (MateMixerDevice *device)
 {
@@ -161,13 +216,19 @@ mate_mixer_device_get_active_profile (MateMixerDevice *device)
 return NULL;
 }
 
+/**
+ * mate_mixer_device_set_active_profile:
+ * @device: a #MateMixerDevice
+ * @profile: a #MateMixerDeviceProfile
+ */
 gboolean
-mate_mixer_device_set_active_profile (MateMixerDevice *device, const gchar *profile)
+mate_mixer_device_set_active_profile (MateMixerDevice *device,
+ MateMixerDeviceProfile *profile)
 {
 MateMixerDeviceInterface *iface;
 
 g_return_val_if_fail (MATE_MIXER_IS_DEVICE (device), FALSE);
- g_return_val_if_fail (profile != NULL, FALSE);
+ g_return_val_if_fail (MATE_MIXER_IS_DEVICE_PROFILE (profile), FALSE);
 
 iface = MATE_MIXER_DEVICE_GET_INTERFACE (device);
 
diff --git a/libmatemixer/matemixer-device.h b/libmatemixer/matemixer-device.h
index ef283f1..340496b 100644
--- a/libmatemixer/matemixer-device.h
+++ b/libmatemixer/matemixer-device.h
@@ -22,6 +22,7 @@
 #include <glib-object.h>
 
 #include <libmatemixer/matemixer-device-profile.h>
+#include <libmatemixer/matemixer-port.h>
 
 G_BEGIN_DECLS
 
@@ -42,29 +43,42 @@ struct _MateMixerDeviceInterface
 GTypeInterface parent_iface;
 
 /*< private >*/
- 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);
- MateMixerDeviceProfile *(*get_active_profile) (MateMixerDevice *device);
- gboolean (*set_active_profile) (MateMixerDevice *device,
- const gchar *profile);
+ /* Virtual table */
+ const gchar *(*get_name) (MateMixerDevice *device);
+ const gchar *(*get_description) (MateMixerDevice *device);
+ const gchar *(*get_icon) (MateMixerDevice *device);
+
+ MateMixerPort *(*get_port) (MateMixerDevice *device,
+ const gchar *name);
+ MateMixerDeviceProfile *(*get_profile) (MateMixerDevice *device,
+ const gchar *name);
+
+ const GList *(*list_streams) (MateMixerDevice *device);
+ const GList *(*list_ports) (MateMixerDevice *device);
+ const GList *(*list_profiles) (MateMixerDevice *device);
+
+ MateMixerDeviceProfile *(*get_active_profile) (MateMixerDevice *device);
+ gboolean (*set_active_profile) (MateMixerDevice *device,
+ MateMixerDeviceProfile *profile);
 };
 
 GType mate_mixer_device_get_type (void) G_GNUC_CONST;
 
-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 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);
+
+MateMixerPort * mate_mixer_device_get_port (MateMixerDevice *device,
+ const gchar *name);
+MateMixerDeviceProfile *mate_mixer_device_get_profile (MateMixerDevice *device,
+ const gchar *name);
 
-const GList * mate_mixer_device_list_ports (MateMixerDevice *device);
-const GList * mate_mixer_device_list_profiles (MateMixerDevice *device);
+const GList * mate_mixer_device_list_ports (MateMixerDevice *device);
+const GList * mate_mixer_device_list_profiles (MateMixerDevice *device);
 
-MateMixerDeviceProfile *mate_mixer_device_get_active_profile (MateMixerDevice *device);
-gboolean mate_mixer_device_set_active_profile (MateMixerDevice *device,
- const gchar *profile);
+MateMixerDeviceProfile *mate_mixer_device_get_active_profile (MateMixerDevice *device);
+gboolean mate_mixer_device_set_active_profile (MateMixerDevice *device,
+ MateMixerDeviceProfile *profile);
 
 G_END_DECLS
 
diff --git a/libmatemixer/matemixer-enum-types.c b/libmatemixer/matemixer-enum-types.c
index 0f60a6a..339b673 100644
--- a/libmatemixer/matemixer-enum-types.c
+++ b/libmatemixer/matemixer-enum-types.c
@@ -94,16 +94,14 @@ mate_mixer_stream_flags_get_type (void)
 { 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_APPLICATION, "MATE_MIXER_STREAM_APPLICATION", "application" },
- { MATE_MIXER_STREAM_EVENT, "MATE_MIXER_STREAM_EVENT", "event" },
 { MATE_MIXER_STREAM_HAS_MUTE, "MATE_MIXER_STREAM_HAS_MUTE", "has-mute" },
 { MATE_MIXER_STREAM_HAS_VOLUME, "MATE_MIXER_STREAM_HAS_VOLUME", "has-volume" },
 { MATE_MIXER_STREAM_HAS_DECIBEL_VOLUME, "MATE_MIXER_STREAM_HAS_DECIBEL_VOLUME", "has-decibel-volume" },
 { MATE_MIXER_STREAM_HAS_FLAT_VOLUME, "MATE_MIXER_STREAM_HAS_FLAT_VOLUME", "has-flat-volume" },
 { MATE_MIXER_STREAM_HAS_MONITOR, "MATE_MIXER_STREAM_HAS_MONITOR", "has-monitor" },
+ { MATE_MIXER_STREAM_CAN_SET_VOLUME, "MATE_MIXER_STREAM_CAN_SET_VOLUME", "can-set-volume" },
 { 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_CAN_SET_VOLUME, "MATE_MIXER_STREAM_CAN_SET_VOLUME", "can-set-volume" },
 { MATE_MIXER_STREAM_CAN_SUSPEND, "MATE_MIXER_STREAM_CAN_SUSPEND", "can-suspend" },
 { 0, NULL, NULL }
 };
@@ -121,10 +119,10 @@ mate_mixer_stream_state_get_type (void)
 
 if (etype == 0) {
 static const GEnumValue values[] = {
- { MATE_MIXER_STREAM_UNKNOWN_STATE, "MATE_MIXER_STREAM_UNKNOWN_STATE", "unknown-state" },
- { 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" },
+ { MATE_MIXER_STREAM_STATE_UNKNOWN, "MATE_MIXER_STREAM_STATE_UNKNOWN", "unknown" },
+ { MATE_MIXER_STREAM_STATE_RUNNING, "MATE_MIXER_STREAM_STATE_RUNNING", "running" },
+ { MATE_MIXER_STREAM_STATE_IDLE, "MATE_MIXER_STREAM_STATE_IDLE", "idle" },
+ { MATE_MIXER_STREAM_STATE_SUSPENDED, "MATE_MIXER_STREAM_STATE_SUSPENDED", "suspended" },
 { 0, NULL, NULL }
 };
 etype = g_enum_register_static (
@@ -135,13 +133,60 @@ mate_mixer_stream_state_get_type (void)
 }
 
 GType
+mate_mixer_client_stream_flags_get_type (void)
+{
+ static GType etype = 0;
+
+ if (etype == 0) {
+ static const GFlagsValue values[] = {
+ { MATE_MIXER_CLIENT_STREAM_NO_FLAGS, "MATE_MIXER_CLIENT_STREAM_NO_FLAGS", "no-flags" },
+ { MATE_MIXER_CLIENT_STREAM_APPLICATION, "MATE_MIXER_CLIENT_STREAM_APPLICATION", "application" },
+ { MATE_MIXER_CLIENT_STREAM_CACHED, "MATE_MIXER_CLIENT_STREAM_CACHED", "cached" },
+ { 0, NULL, NULL }
+ };
+ etype = g_flags_register_static (
+ g_intern_static_string ("MateMixerClientStreamFlags"),
+ values);
+ }
+ return etype;
+}
+
+GType
+mate_mixer_client_stream_role_get_type (void)
+{
+ static GType etype = 0;
+
+ if (etype == 0) {
+ static const GEnumValue values[] = {
+ { MATE_MIXER_CLIENT_STREAM_ROLE_NONE, "MATE_MIXER_CLIENT_STREAM_ROLE_NONE", "none" },
+ { MATE_MIXER_CLIENT_STREAM_ROLE_VIDEO, "MATE_MIXER_CLIENT_STREAM_ROLE_VIDEO", "video" },
+ { MATE_MIXER_CLIENT_STREAM_ROLE_MUSIC, "MATE_MIXER_CLIENT_STREAM_ROLE_MUSIC", "music" },
+ { MATE_MIXER_CLIENT_STREAM_ROLE_GAME, "MATE_MIXER_CLIENT_STREAM_ROLE_GAME", "game" },
+ { MATE_MIXER_CLIENT_STREAM_ROLE_EVENT, "MATE_MIXER_CLIENT_STREAM_ROLE_EVENT", "event" },
+ { MATE_MIXER_CLIENT_STREAM_ROLE_PHONE, "MATE_MIXER_CLIENT_STREAM_ROLE_PHONE", "phone" },
+ { MATE_MIXER_CLIENT_STREAM_ROLE_ANIMATION, "MATE_MIXER_CLIENT_STREAM_ROLE_ANIMATION", "animation" },
+ { MATE_MIXER_CLIENT_STREAM_ROLE_PRODUCTION, "MATE_MIXER_CLIENT_STREAM_ROLE_PRODUCTION", "production" },
+ { MATE_MIXER_CLIENT_STREAM_ROLE_A11Y, "MATE_MIXER_CLIENT_STREAM_ROLE_A11Y", "a11y" },
+ { MATE_MIXER_CLIENT_STREAM_ROLE_TEST, "MATE_MIXER_CLIENT_STREAM_ROLE_TEST", "test" },
+ { MATE_MIXER_CLIENT_STREAM_ROLE_ABSTRACT, "MATE_MIXER_CLIENT_STREAM_ROLE_ABSTRACT", "abstract" },
+ { MATE_MIXER_CLIENT_STREAM_ROLE_FILTER, "MATE_MIXER_CLIENT_STREAM_ROLE_FILTER", "filter" },
+ { 0, NULL, NULL }
+ };
+ etype = g_enum_register_static (
+ g_intern_static_string ("MateMixerClientStreamRole"),
+ 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_UNKNOWN, "MATE_MIXER_CHANNEL_UNKNOWN", "unknown" },
 { 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" },
@@ -149,9 +194,9 @@ mate_mixer_channel_position_get_type (void)
 { 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_BACK_CENTER, "MATE_MIXER_STREAM_BACK_CENTER", "back-center" },
+ { MATE_MIXER_CHANNEL_FRONT_LEFT_CENTER, "MATE_MIXER_STREAM_FRONT_LEFT_CENTER", "front-left-center" },
+ { MATE_MIXER_CHANNEL_FRONT_RIGHT_CENTER, "MATE_MIXER_STREAM_FRONT_RIGHT_CENTER", "front-right-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" },
diff --git a/libmatemixer/matemixer-enum-types.h b/libmatemixer/matemixer-enum-types.h
index 7b6fcf0..03c1297 100644
--- a/libmatemixer/matemixer-enum-types.h
+++ b/libmatemixer/matemixer-enum-types.h
@@ -43,6 +43,12 @@ GType mate_mixer_stream_flags_get_type (void) G_GNUC_CONST;
 #define MATE_MIXER_TYPE_STREAM_STATE (mate_mixer_stream_state_get_type ())
 GType mate_mixer_stream_state_get_type (void) G_GNUC_CONST;
 
+#define MATE_MIXER_TYPE_CLIENT_STREAM_FLAGS (mate_mixer_client_stream_flags_get_type ())
+GType mate_mixer_client_stream_flags_get_type (void) G_GNUC_CONST;
+
+#define MATE_MIXER_TYPE_CLIENT_STREAM_ROLE (mate_mixer_client_stream_role_get_type ())
+GType mate_mixer_client_stream_role_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;
 
diff --git a/libmatemixer/matemixer-enums.h b/libmatemixer/matemixer-enums.h
index 4753aaf..a6326ce 100644
--- a/libmatemixer/matemixer-enums.h
+++ b/libmatemixer/matemixer-enums.h
@@ -23,8 +23,16 @@
 * https://bugzilla.gnome.org/show_bug.cgi?id=621942
 */
 
+/**
+ * MateMixerState:
+ * @MATE_MIXER_STATE_IDLE:
+ * @MATE_MIXER_STATE_CONNECTING:
+ * @MATE_MIXER_STATE_READY:
+ * @MATE_MIXER_STATE_FAILED:
+ * @MATE_MIXER_STATE_UNKNOWN:
+ */
 typedef enum {
- MATE_MIXER_STATE_IDLE = 0,
+ MATE_MIXER_STATE_IDLE,
 MATE_MIXER_STATE_CONNECTING,
 MATE_MIXER_STATE_READY,
 MATE_MIXER_STATE_FAILED,
@@ -46,11 +54,18 @@ typedef enum {
 * "real" backends fail to initialize.
 */
 typedef enum {
- MATE_MIXER_BACKEND_UNKNOWN = 0,
+ MATE_MIXER_BACKEND_UNKNOWN,
 MATE_MIXER_BACKEND_PULSEAUDIO,
 MATE_MIXER_BACKEND_NULL
 } MateMixerBackendType;
 
+/**
+ * MateMixerPortFlags:
+ * @MATE_MIXER_PORT_NO_FLAGS:
+ * @MATE_MIXER_PORT_AVAILABLE:
+ * @MATE_MIXER_PORT_INPUT:
+ * @MATE_MIXER_PORT_OUTPUT:
+ */
 typedef enum { /*< flags >*/
 MATE_MIXER_PORT_NO_FLAGS = 0,
 MATE_MIXER_PORT_AVAILABLE = 1 << 0,
@@ -58,33 +73,119 @@ typedef enum { /*< flags >*/
 MATE_MIXER_PORT_OUTPUT = 1 << 2
 } MateMixerPortFlags;
 
+/**
+ * MateMixerStreamFlags:
+ * @MATE_MIXER_STREAM_NO_FLAGS:
+ * @MATE_MIXER_STREAM_INPUT:
+ * @MATE_MIXER_STREAM_OUTPUT:
+ * @MATE_MIXER_STREAM_CLIENT:
+ * @MATE_MIXER_STREAM_HAS_MUTE:
+ * @MATE_MIXER_STREAM_HAS_VOLUME:
+ * @MATE_MIXER_STREAM_HAS_DECIBEL_VOLUME:
+ * @MATE_MIXER_STREAM_HAS_FLAT_VOLUME:
+ * @MATE_MIXER_STREAM_HAS_MONITOR:
+ * @MATE_MIXER_STREAM_CAN_SET_VOLUME:
+ * @MATE_MIXER_STREAM_CAN_BALANCE:
+ * @MATE_MIXER_STREAM_CAN_FADE:
+ * @MATE_MIXER_STREAM_CAN_SUSPEND:
+ */
 typedef enum { /*< flags >*/
 MATE_MIXER_STREAM_NO_FLAGS = 0,
 MATE_MIXER_STREAM_INPUT = 1 << 0,
 MATE_MIXER_STREAM_OUTPUT = 1 << 1,
 MATE_MIXER_STREAM_CLIENT = 1 << 2,
- MATE_MIXER_STREAM_APPLICATION = 1 << 3,
- MATE_MIXER_STREAM_EVENT = 1 << 4,
- MATE_MIXER_STREAM_HAS_MUTE = 1 << 5,
- MATE_MIXER_STREAM_HAS_VOLUME = 1 << 6,
- MATE_MIXER_STREAM_HAS_DECIBEL_VOLUME = 1 << 7,
- MATE_MIXER_STREAM_HAS_FLAT_VOLUME = 1 << 8,
- MATE_MIXER_STREAM_HAS_MONITOR = 1 << 9,
- MATE_MIXER_STREAM_CAN_BALANCE = 1 << 10,
- MATE_MIXER_STREAM_CAN_FADE = 1 << 11,
- MATE_MIXER_STREAM_CAN_SET_VOLUME = 1 << 12,
- MATE_MIXER_STREAM_CAN_SUSPEND = 1 << 13
+ MATE_MIXER_STREAM_HAS_MUTE = 1 << 3,
+ MATE_MIXER_STREAM_HAS_VOLUME = 1 << 4,
+ MATE_MIXER_STREAM_HAS_DECIBEL_VOLUME = 1 << 5,
+ MATE_MIXER_STREAM_HAS_FLAT_VOLUME = 1 << 6,
+ MATE_MIXER_STREAM_HAS_MONITOR = 1 << 7,
+ MATE_MIXER_STREAM_CAN_SET_VOLUME = 1 << 8,
+ MATE_MIXER_STREAM_CAN_BALANCE = 1 << 9,
+ MATE_MIXER_STREAM_CAN_FADE = 1 << 10,
+ MATE_MIXER_STREAM_CAN_SUSPEND = 1 << 11
 } MateMixerStreamFlags;
 
+/**
+ * MateMixerStreamState:
+ * @MATE_MIXER_STREAM_STATE_UNKNOWN:
+ * @MATE_MIXER_STREAM_STATE_RUNNING:
+ * @MATE_MIXER_STREAM_STATE_IDLE:
+ * @MATE_MIXER_STREAM_STATE_SUSPENDED:
+ */
 typedef enum {
- MATE_MIXER_STREAM_UNKNOWN_STATE,
- MATE_MIXER_STREAM_RUNNING,
- MATE_MIXER_STREAM_IDLE,
- MATE_MIXER_STREAM_SUSPENDED
+ MATE_MIXER_STREAM_STATE_UNKNOWN,
+ MATE_MIXER_STREAM_STATE_RUNNING,
+ MATE_MIXER_STREAM_STATE_IDLE,
+ MATE_MIXER_STREAM_STATE_SUSPENDED
 } MateMixerStreamState;
 
+/**
+ * MateMixerClientStreamFlags:
+ * @MATE_MIXER_CLIENT_STREAM_NO_FLAGS:
+ * @MATE_MIXER_CLIENT_STREAM_APPLICATION:
+ * @MATE_MIXER_CLIENT_STREAM_CACHED:
+ */
+typedef enum { /*< flags >*/
+ MATE_MIXER_CLIENT_STREAM_NO_FLAGS = 0,
+ MATE_MIXER_CLIENT_STREAM_APPLICATION = 1 << 0,
+ MATE_MIXER_CLIENT_STREAM_CACHED = 1 << 1,
+} MateMixerClientStreamFlags;
+
+/**
+ * MateMixerClientStreamRole:
+ * @MATE_MIXER_CLIENT_STREAM_ROLE_NONE:
+ * @MATE_MIXER_CLIENT_STREAM_ROLE_VIDEO:
+ * @MATE_MIXER_CLIENT_STREAM_ROLE_MUSIC:
+ * @MATE_MIXER_CLIENT_STREAM_ROLE_GAME:
+ * @MATE_MIXER_CLIENT_STREAM_ROLE_EVENT:
+ * @MATE_MIXER_CLIENT_STREAM_ROLE_PHONE:
+ * @MATE_MIXER_CLIENT_STREAM_ROLE_ANIMATION:
+ * @MATE_MIXER_CLIENT_STREAM_ROLE_PRODUCTION:
+ * @MATE_MIXER_CLIENT_STREAM_ROLE_A11Y:
+ * @MATE_MIXER_CLIENT_STREAM_ROLE_TEST:
+ * @MATE_MIXER_CLIENT_STREAM_ROLE_ABSTRACT:
+ * @MATE_MIXER_CLIENT_STREAM_ROLE_FILTER:
+ */
+typedef enum {
+ MATE_MIXER_CLIENT_STREAM_ROLE_NONE,
+ MATE_MIXER_CLIENT_STREAM_ROLE_VIDEO,
+ MATE_MIXER_CLIENT_STREAM_ROLE_MUSIC,
+ MATE_MIXER_CLIENT_STREAM_ROLE_GAME,
+ MATE_MIXER_CLIENT_STREAM_ROLE_EVENT,
+ MATE_MIXER_CLIENT_STREAM_ROLE_PHONE,
+ MATE_MIXER_CLIENT_STREAM_ROLE_ANIMATION,
+ MATE_MIXER_CLIENT_STREAM_ROLE_PRODUCTION,
+ MATE_MIXER_CLIENT_STREAM_ROLE_A11Y,
+ MATE_MIXER_CLIENT_STREAM_ROLE_TEST,
+ MATE_MIXER_CLIENT_STREAM_ROLE_ABSTRACT,
+ MATE_MIXER_CLIENT_STREAM_ROLE_FILTER
+} MateMixerClientStreamRole;
+
+/**
+ * MateMixerChannelPosition:
+ * @MATE_MIXER_CHANNEL_UNKNOWN:
+ * @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_BACK_CENTER:
+ * @MATE_MIXER_CHANNEL_FRONT_LEFT_CENTER:
+ * @MATE_MIXER_CHANNEL_FRONT_RIGHT_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:
+ */
 typedef enum {
- MATE_MIXER_CHANNEL_UNKNOWN_POSITION,
+ MATE_MIXER_CHANNEL_UNKNOWN,
 MATE_MIXER_CHANNEL_MONO,
 MATE_MIXER_CHANNEL_FRONT_LEFT,
 MATE_MIXER_CHANNEL_FRONT_RIGHT,
@@ -92,9 +193,9 @@ typedef enum {
 MATE_MIXER_CHANNEL_LFE,
 MATE_MIXER_CHANNEL_BACK_LEFT,
 MATE_MIXER_CHANNEL_BACK_RIGHT,
+ MATE_MIXER_CHANNEL_BACK_CENTER,
 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,
diff --git a/libmatemixer/matemixer-port-private.h b/libmatemixer/matemixer-port-private.h
new file mode 100644
index 0000000..a696d27
--- /dev/null
+++ b/libmatemixer/matemixer-port-private.h
@@ -0,0 +1,45 @@
+/*
+ * 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_PRIVATE_H
+#define MATEMIXER_PORT_PRIVATE_H
+
+#include <glib.h>
+
+#include "matemixer-enums.h"
+#include "matemixer-port.h"
+
+G_BEGIN_DECLS
+
+MateMixerPort *_mate_mixer_port_new (const gchar *name,
+ const gchar *description,
+ const gchar *icon,
+ guint priority,
+ MateMixerPortFlags flags);
+
+gboolean _mate_mixer_port_update_description (MateMixerPort *port,
+ const gchar *description);
+gboolean _mate_mixer_port_update_icon (MateMixerPort *port,
+ const gchar *icon);
+gboolean _mate_mixer_port_update_priority (MateMixerPort *port,
+ guint priority);
+gboolean _mate_mixer_port_update_flags (MateMixerPort *port,
+ MateMixerPortFlags flags);
+
+G_END_DECLS
+
+#endif /* MATEMIXER_PORT_PRIVATE_H */
diff --git a/libmatemixer/matemixer-port.c b/libmatemixer/matemixer-port.c
index 3a7670d..f89a8bb 100644
--- a/libmatemixer/matemixer-port.c
+++ b/libmatemixer/matemixer-port.c
@@ -21,6 +21,7 @@
 #include "matemixer-enums.h"
 #include "matemixer-enum-types.h"
 #include "matemixer-port.h"
+#include "matemixer-port-private.h"
 
 /**
 * SECTION:matemixer-port
@@ -32,7 +33,7 @@ struct _MateMixerPortPrivate
 gchar *name;
 gchar *description;
 gchar *icon;
- gulong priority;
+ guint priority;
 MateMixerPortFlags flags;
 };
 
@@ -102,15 +103,15 @@ mate_mixer_port_class_init (MateMixerPortClass *klass)
 G_PARAM_STATIC_STRINGS);
 
 properties[PROP_PRIORITY] =
- g_param_spec_ulong ("priority",
- "Priority",
- "Priority of the port",
- 0,
- G_MAXULONG,
- 0,
- G_PARAM_CONSTRUCT_ONLY |
- G_PARAM_READWRITE |
- G_PARAM_STATIC_STRINGS);
+ g_param_spec_uint ("priority",
+ "Priority",
+ "Priority of the port",
+ 0,
+ G_MAXUINT,
+ 0,
+ G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_READWRITE |
+ G_PARAM_STATIC_STRINGS);
 
 properties[PROP_FLAGS] =
 g_param_spec_flags ("flags",
@@ -148,7 +149,7 @@ mate_mixer_port_get_property (GObject *object,
 g_value_set_string (value, port->priv->icon);
 break;
 case PROP_PRIORITY:
- g_value_set_ulong (value, port->priv->priority);
+ g_value_set_uint (value, port->priv->priority);
 break;
 case PROP_FLAGS:
 g_value_set_flags (value, port->priv->flags);
@@ -183,7 +184,7 @@ mate_mixer_port_set_property (GObject *object,
 port->priv->icon = g_strdup (g_value_get_string (value));
 break;
 case PROP_PRIORITY:
- port->priv->priority = g_value_get_ulong (value);
+ port->priv->priority = g_value_get_uint (value);
 break;
 case PROP_FLAGS:
 port->priv->flags = g_value_get_flags (value);
@@ -216,22 +217,10 @@ mate_mixer_port_finalize (GObject *object)
 G_OBJECT_CLASS (mate_mixer_port_parent_class)->finalize (object);
 }
 
-MateMixerPort *
-mate_mixer_port_new (const gchar *name,
- const gchar *description,
- const gchar *icon,
- gulong priority,
- MateMixerPortFlags flags)
-{
- return g_object_new (MATE_MIXER_TYPE_PORT,
- "name", name,
- "description", description,
- "icon", icon,
- "priority", priority,
- "flags", flags,
- NULL);
-}
-
+/**
+ * mate_mixer_port_get_name:
+ * @port: a #MateMixerPort
+ */
 const gchar *
 mate_mixer_port_get_name (MateMixerPort *port)
 {
@@ -240,6 +229,10 @@ mate_mixer_port_get_name (MateMixerPort *port)
 return port->priv->name;
 }
 
+/**
+ * mate_mixer_port_get_description:
+ * @port: a #MateMixerPort
+ */
 const gchar *
 mate_mixer_port_get_description (MateMixerPort *port)
 {
@@ -248,6 +241,10 @@ mate_mixer_port_get_description (MateMixerPort *port)
 return port->priv->description;
 }
 
+/**
+ * mate_mixer_port_get_icon:
+ * @port: a #MateMixerPort
+ */
 const gchar *
 mate_mixer_port_get_icon (MateMixerPort *port)
 {
@@ -256,7 +253,11 @@ mate_mixer_port_get_icon (MateMixerPort *port)
 return port->priv->icon;
 }
 
-gulong
+/**
+ * mate_mixer_port_get_priority:
+ * @port: a #MateMixerPort
+ */
+guint
 mate_mixer_port_get_priority (MateMixerPort *port)
 {
 g_return_val_if_fail (MATE_MIXER_IS_PORT (port), 0);
@@ -264,6 +265,10 @@ mate_mixer_port_get_priority (MateMixerPort *port)
 return port->priv->priority;
 }
 
+/**
+ * mate_mixer_port_get_flags:
+ * @port: a #MateMixerPort
+ */
 MateMixerPortFlags
 mate_mixer_port_get_flags (MateMixerPort *port)
 {
@@ -271,3 +276,83 @@ mate_mixer_port_get_flags (MateMixerPort *port)
 
 return port->priv->flags;
 }
+
+MateMixerPort *
+_mate_mixer_port_new (const gchar *name,
+ const gchar *description,
+ const gchar *icon,
+ guint priority,
+ MateMixerPortFlags flags)
+{
+ return g_object_new (MATE_MIXER_TYPE_PORT,
+ "name", name,
+ "description", description,
+ "icon", icon,
+ "priority", priority,
+ "flags", flags,
+ NULL);
+}
+
+gboolean
+_mate_mixer_port_update_description (MateMixerPort *port, const gchar *description)
+{
+ g_return_val_if_fail (MATE_MIXER_IS_PORT (port), FALSE);
+
+ if (g_strcmp0 (port->priv->description, description) != 0) {
+ g_free (port->priv->description);
+
+ port->priv->description = g_strdup (description);
+
+ g_object_notify_by_pspec (G_OBJECT (port), properties[PROP_DESCRIPTION]);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+gboolean
+_mate_mixer_port_update_icon (MateMixerPort *port, const gchar *icon)
+{
+ g_return_val_if_fail (MATE_MIXER_IS_PORT (port), FALSE);
+
+ if (g_strcmp0 (port->priv->icon, icon) != 0) {
+ g_free (port->priv->icon);
+
+ port->priv->icon = g_strdup (icon);
+
+ g_object_notify_by_pspec (G_OBJECT (port), properties[PROP_ICON]);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+gboolean
+_mate_mixer_port_update_priority (MateMixerPort *port, guint priority)
+{
+ g_return_val_if_fail (MATE_MIXER_IS_PORT (port), FALSE);
+
+ if (port->priv->priority != priority) {
+ port->priv->priority = priority;
+
+ g_object_notify_by_pspec (G_OBJECT (port), properties[PROP_PRIORITY]);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+gboolean
+_mate_mixer_port_update_flags (MateMixerPort *port, MateMixerPortFlags flags)
+{
+ g_return_val_if_fail (MATE_MIXER_IS_PORT (port), FALSE);
+
+ if (port->priv->flags != flags) {
+ port->priv->flags = flags;
+
+ g_object_notify_by_pspec (G_OBJECT (port), properties[PROP_FLAGS]);
+ return TRUE;
+ }
+
+ return FALSE;
+}
diff --git a/libmatemixer/matemixer-port.h b/libmatemixer/matemixer-port.h
index bda13ad..61f16f5 100644
--- a/libmatemixer/matemixer-port.h
+++ b/libmatemixer/matemixer-port.h
@@ -57,17 +57,11 @@ struct _MateMixerPortClass
 
 GType mate_mixer_port_get_type (void) G_GNUC_CONST;
 
-MateMixerPort * mate_mixer_port_new (const gchar *name,
- const gchar *description,
- const gchar *icon,
- gulong priority,
- MateMixerPortFlags flags);
-
-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);
-gulong mate_mixer_port_get_priority (MateMixerPort *port);
-MateMixerPortFlags mate_mixer_port_get_flags (MateMixerPort *port);
+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);
+guint mate_mixer_port_get_priority (MateMixerPort *port);
+MateMixerPortFlags mate_mixer_port_get_flags (MateMixerPort *port);
 
 G_END_DECLS
 
diff --git a/libmatemixer/matemixer-stream.c b/libmatemixer/matemixer-stream.c
index 6f63217..6bec2be 100644
--- a/libmatemixer/matemixer-stream.c
+++ b/libmatemixer/matemixer-stream.c
@@ -79,7 +79,7 @@ mate_mixer_stream_default_init (MateMixerStreamInterface *iface)
 "State",
 "Current state of the stream",
 MATE_MIXER_TYPE_STREAM_STATE,
- MATE_MIXER_STREAM_UNKNOWN_STATE,
+ MATE_MIXER_STREAM_STATE_UNKNOWN,
 G_PARAM_READABLE |
 G_PARAM_STATIC_STRINGS));
 
@@ -92,16 +92,6 @@ mate_mixer_stream_default_init (MateMixerStreamInterface *iface)
 G_PARAM_STATIC_STRINGS));
 
 g_object_interface_install_property (iface,
- g_param_spec_uint ("num-channels",
- "Number of channels",
- "Number of volume channels in the stream",
- 0,
- G_MAXUINT,
- 0,
- G_PARAM_READABLE |
- G_PARAM_STATIC_STRINGS));
-
- g_object_interface_install_property (iface,
 g_param_spec_uint ("volume",
 "Volume",
 "Volume of the stream",
@@ -132,13 +122,6 @@ mate_mixer_stream_default_init (MateMixerStreamInterface *iface)
 G_PARAM_STATIC_STRINGS));
 
 g_object_interface_install_property (iface,
- g_param_spec_pointer ("ports",
- "Ports",
- "GList of the sound device ports",
- G_PARAM_READABLE |
- G_PARAM_STATIC_STRINGS));
-
- g_object_interface_install_property (iface,
 g_param_spec_object ("active-port",
 "Active port",
 "The currently active port of the stream",
@@ -215,14 +198,14 @@ mate_mixer_stream_get_state (MateMixerStream *stream)
 {
 MateMixerStreamInterface *iface;
 
- g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), MATE_MIXER_STREAM_UNKNOWN_STATE);
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), MATE_MIXER_STREAM_STATE_UNKNOWN);
 
 iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
 
 if (iface->get_state)
 return iface->get_state (stream);
 
- return MATE_MIXER_STREAM_UNKNOWN_STATE;
+ return MATE_MIXER_STREAM_STATE_UNKNOWN;
 }
 
 gboolean
@@ -335,14 +318,14 @@ mate_mixer_stream_get_channel_position (MateMixerStream *stream, guint channel)
 {
 MateMixerStreamInterface *iface;
 
- g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), MATE_MIXER_CHANNEL_UNKNOWN_POSITION);
+ g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), MATE_MIXER_CHANNEL_UNKNOWN);
 
 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;
+ return MATE_MIXER_CHANNEL_UNKNOWN;
 }
 
 guint
@@ -410,83 +393,17 @@ mate_mixer_stream_set_channel_decibel (MateMixerStream *stream,
 }
 
 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;
-}
-
-guint
-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,
- guint 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_decibel (MateMixerStream *stream,
+mate_mixer_stream_has_channel_position (MateMixerStream *stream,
 MateMixerChannelPosition position)
 {
 MateMixerStreamInterface *iface;
 
- g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), -MATE_MIXER_INFINITY);
-
- iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
-
- if (iface->get_position_decibel)
- return iface->get_position_decibel (stream, position);
-
- return -MATE_MIXER_INFINITY;
-}
-
-gboolean
-mate_mixer_stream_set_position_decibel (MateMixerStream *stream,
- MateMixerChannelPosition position,
- gdouble decibel)
-{
- MateMixerStreamInterface *iface;
-
 g_return_val_if_fail (MATE_MIXER_IS_STREAM (stream), FALSE);
 
 iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
 
- if (iface->set_position_decibel)
- return iface->set_position_decibel (stream, position, decibel);
+ if (iface->has_channel_position)
+ return iface->has_channel_position (stream, position);
 
 return FALSE;
 }
@@ -670,12 +587,12 @@ mate_mixer_stream_get_active_port (MateMixerStream *stream)
 }
 
 gboolean
-mate_mixer_stream_set_active_port (MateMixerStream *stream, const gchar *port)
+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 (port != NULL, FALSE);
+ g_return_val_if_fail (MATE_MIXER_IS_PORT (port), FALSE);
 
 iface = MATE_MIXER_STREAM_GET_INTERFACE (stream);
 
diff --git a/libmatemixer/matemixer-stream.h b/libmatemixer/matemixer-stream.h
index 40a4463..e91a2a5 100644
--- a/libmatemixer/matemixer-stream.h
+++ b/libmatemixer/matemixer-stream.h
@@ -51,6 +51,7 @@ struct _MateMixerStreamInterface
 GTypeInterface parent_iface;
 
 /*< private >*/
+ /* Virtual table */
 const gchar * (*get_name) (MateMixerStream *stream);
 const gchar * (*get_description) (MateMixerStream *stream);
 MateMixerDevice * (*get_device) (MateMixerStream *stream);
@@ -78,18 +79,8 @@ struct _MateMixerStreamInterface
 gboolean (*set_channel_decibel) (MateMixerStream *stream,
 guint channel,
 gdouble decibel);
- gboolean (*has_position) (MateMixerStream *stream,
+ gboolean (*has_channel_position) (MateMixerStream *stream,
 MateMixerChannelPosition position);
- guint (*get_position_volume) (MateMixerStream *stream,
- MateMixerChannelPosition position);
- gboolean (*set_position_volume) (MateMixerStream *stream,
- MateMixerChannelPosition position,
- guint volume);
- gdouble (*get_position_decibel) (MateMixerStream *stream,
- MateMixerChannelPosition position);
- gboolean (*set_position_decibel) (MateMixerStream *stream,
- MateMixerChannelPosition position,
- gdouble decibel);
 gfloat (*get_balance) (MateMixerStream *stream);
 gboolean (*set_balance) (MateMixerStream *stream,
 gfloat balance);
@@ -106,7 +97,7 @@ struct _MateMixerStreamInterface
 const GList * (*list_ports) (MateMixerStream *stream);
 MateMixerPort * (*get_active_port) (MateMixerStream *stream);
 gboolean (*set_active_port) (MateMixerStream *stream,
- const gchar *port);
+ MateMixerPort *port);
 guint (*get_min_volume) (MateMixerStream *stream);
 guint (*get_max_volume) (MateMixerStream *stream);
 guint (*get_normal_volume) (MateMixerStream *stream);
@@ -117,86 +108,74 @@ struct _MateMixerStreamInterface
 gdouble value);
 };
 
-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);
-MateMixerDevice * mate_mixer_stream_get_device (MateMixerStream *stream);
-MateMixerStreamFlags mate_mixer_stream_get_flags (MateMixerStream *stream);
-MateMixerStreamState mate_mixer_stream_get_state (MateMixerStream *stream);
-
-gboolean mate_mixer_stream_get_mute (MateMixerStream *stream);
-gboolean mate_mixer_stream_set_mute (MateMixerStream *stream,
- gboolean mute);
+GType mate_mixer_stream_get_type (void) G_GNUC_CONST;
 
-guint mate_mixer_stream_get_num_channels (MateMixerStream *stream);
+const gchar * mate_mixer_stream_get_name (MateMixerStream *stream);
+const gchar * mate_mixer_stream_get_description (MateMixerStream *stream);
+MateMixerDevice * mate_mixer_stream_get_device (MateMixerStream *stream);
+MateMixerStreamFlags mate_mixer_stream_get_flags (MateMixerStream *stream);
+MateMixerStreamState mate_mixer_stream_get_state (MateMixerStream *stream);
 
-guint mate_mixer_stream_get_volume (MateMixerStream *stream);
-gboolean mate_mixer_stream_set_volume (MateMixerStream *stream,
- guint volume);
+gboolean mate_mixer_stream_get_mute (MateMixerStream *stream);
+gboolean mate_mixer_stream_set_mute (MateMixerStream *stream,
+ gboolean mute);
 
-gdouble mate_mixer_stream_get_decibel (MateMixerStream *stream);
-gboolean mate_mixer_stream_set_decibel (MateMixerStream *stream,
- gdouble decibel);
+guint mate_mixer_stream_get_num_channels (MateMixerStream *stream);
 
-MateMixerChannelPosition mate_mixer_stream_get_channel_position (MateMixerStream *stream,
- guint channel);
+guint mate_mixer_stream_get_volume (MateMixerStream *stream);
+gboolean mate_mixer_stream_set_volume (MateMixerStream *stream,
+ guint volume);
 
-guint mate_mixer_stream_get_channel_volume (MateMixerStream *stream,
- guint channel);
-gboolean mate_mixer_stream_set_channel_volume (MateMixerStream *stream,
- guint channel,
- guint volume);
+gdouble mate_mixer_stream_get_decibel (MateMixerStream *stream);
+gboolean mate_mixer_stream_set_decibel (MateMixerStream *stream,
+ gdouble decibel);
 
-gdouble mate_mixer_stream_get_channel_decibel (MateMixerStream *stream,
- guint channel);
-gboolean mate_mixer_stream_set_channel_decibel (MateMixerStream *stream,
- guint channel,
- gdouble decibel);
+MateMixerChannelPosition mate_mixer_stream_get_channel_position (MateMixerStream *stream,
+ guint channel);
 
-gboolean mate_mixer_stream_has_position (MateMixerStream *stream,
- MateMixerChannelPosition position);
+guint mate_mixer_stream_get_channel_volume (MateMixerStream *stream,
+ guint channel);
+gboolean mate_mixer_stream_set_channel_volume (MateMixerStream *stream,
+ guint channel,
+ guint volume);
 
-guint mate_mixer_stream_get_position_volume (MateMixerStream *stream,
- MateMixerChannelPosition position);
-gboolean mate_mixer_stream_set_position_volume (MateMixerStream *stream,
- MateMixerChannelPosition position,
- guint volume);
+gdouble mate_mixer_stream_get_channel_decibel (MateMixerStream *stream,
+ guint channel);
+gboolean mate_mixer_stream_set_channel_decibel (MateMixerStream *stream,
+ guint channel,
+ gdouble decibel);
 
-gdouble mate_mixer_stream_get_position_decibel (MateMixerStream *stream,
- MateMixerChannelPosition position);
-gboolean mate_mixer_stream_set_position_decibel (MateMixerStream *stream,
- MateMixerChannelPosition position,
- gdouble decibel);
+gboolean mate_mixer_stream_has_channel_position (MateMixerStream *stream,
+ MateMixerChannelPosition position);
 
-gfloat mate_mixer_stream_get_balance (MateMixerStream *stream);
-gboolean mate_mixer_stream_set_balance (MateMixerStream *stream,
- gfloat balance);
+gfloat mate_mixer_stream_get_balance (MateMixerStream *stream);
+gboolean mate_mixer_stream_set_balance (MateMixerStream *stream,
+ gfloat balance);
 
-gfloat mate_mixer_stream_get_fade (MateMixerStream *stream);
-gboolean mate_mixer_stream_set_fade (MateMixerStream *stream,
- gfloat fade);
+gfloat mate_mixer_stream_get_fade (MateMixerStream *stream);
+gboolean mate_mixer_stream_set_fade (MateMixerStream *stream,
+ gfloat fade);
 
-gboolean mate_mixer_stream_suspend (MateMixerStream *stream);
-gboolean mate_mixer_stream_resume (MateMixerStream *stream);
+gboolean mate_mixer_stream_suspend (MateMixerStream *stream);
+gboolean mate_mixer_stream_resume (MateMixerStream *stream);
 
-gboolean mate_mixer_stream_monitor_start (MateMixerStream *stream);
-void mate_mixer_stream_monitor_stop (MateMixerStream *stream);
+gboolean mate_mixer_stream_monitor_start (MateMixerStream *stream);
+void mate_mixer_stream_monitor_stop (MateMixerStream *stream);
 
-gboolean mate_mixer_stream_monitor_is_running (MateMixerStream *stream);
-gboolean mate_mixer_stream_monitor_set_name (MateMixerStream *stream,
- const gchar *name);
+gboolean mate_mixer_stream_monitor_is_running (MateMixerStream *stream);
+gboolean mate_mixer_stream_monitor_set_name (MateMixerStream *stream,
+ const gchar *name);
 
-const GList * mate_mixer_stream_list_ports (MateMixerStream *stream);
+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,
- const gchar *port);
+MateMixerPort * mate_mixer_stream_get_active_port (MateMixerStream *stream);
+gboolean mate_mixer_stream_set_active_port (MateMixerStream *stream,
+ MateMixerPort *port);
 
-guint mate_mixer_stream_get_min_volume (MateMixerStream *stream);
-guint mate_mixer_stream_get_max_volume (MateMixerStream *stream);
-guint mate_mixer_stream_get_normal_volume (MateMixerStream *stream);
-guint mate_mixer_stream_get_base_volume (MateMixerStream *stream);
+guint mate_mixer_stream_get_min_volume (MateMixerStream *stream);
+guint mate_mixer_stream_get_max_volume (MateMixerStream *stream);
+guint mate_mixer_stream_get_normal_volume (MateMixerStream *stream);
+guint mate_mixer_stream_get_base_volume (MateMixerStream *stream);
 
 G_END_DECLS
 
diff --git a/libmatemixer/matemixer.c b/libmatemixer/matemixer.c
index 8965599..0ca09b9 100644
--- a/libmatemixer/matemixer.c
+++ b/libmatemixer/matemixer.c
@@ -25,11 +25,19 @@
 #include "matemixer-private.h"
 #include "matemixer-backend-module.h"
 
-static void mixer_load_modules (void);
-static gint mixer_compare_modules (gconstpointer a, gconstpointer b);
+/**
+ * SECTION:matemixer
+ * @short_description: Library initialization and support functions
+ * @title: MateMixer
+ * @include: libmatemixer/matemixer.h
+ */
+
+static void load_modules (void);
+static gint compare_modules (gconstpointer a,
+ gconstpointer b);
 
-static GList *mixer_modules = NULL;
-static gboolean mixer_initialized = FALSE;
+static GList *modules = NULL;
+static gboolean initialized = FALSE;
 
 /**
 * mate_mixer_init:
@@ -43,89 +51,89 @@ static gboolean mixer_initialized = FALSE;
 gboolean
 mate_mixer_init (void)
 {
- if (!mixer_initialized) {
- mixer_load_modules ();
-
- if (mixer_modules) {
- GList *list;
-
- list = mixer_modules;
- while (list) {
- GTypeModule *module = G_TYPE_MODULE (list->data);
- GList *next = list->next;
-
- /* Attempt to load the module and remove it from the list
- * if it isn't usable */
- if (!g_type_module_use (module)) {
- g_object_unref (module);
- mixer_modules = g_list_delete_link (mixer_modules, list);
- }
- list = next;
- }
+ if (initialized == TRUE)
+ return TRUE;
+
+ load_modules ();
+
+ if (modules != NULL) {
+ GList *list = modules;
 
- if (mixer_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");
+ while (list != NULL) {
+ GTypeModule *module = G_TYPE_MODULE (list->data);
+ GList *next = list->next;
+
+ /* Load the plugin and remove it from the list if it fails */
+ if (g_type_module_use (module) == FALSE) {
+ g_object_unref (module);
+ modules = g_list_delete_link (modules, list);
+ }
+ list = next;
 }
- }
 
- return mixer_initialized;
+ if (modules != NULL) {
+ /* Sort the usable modules by priority */
+ modules = g_list_sort (modules, compare_modules);
+ initialized = TRUE;
+ } else
+ g_critical ("No usable backend modules have been found");
+ } else
+ g_critical ("No backend modules have been found");
+
+ return initialized;
 }
 
 /**
 * mate_mixer_is_initialized:
 *
- * Returns TRUE if the library has been initialized.
+ * Returns %TRUE if the library has been initialized.
 *
- * Returns: %TRUE or %FALSE
+ * Returns: %TRUE or %FALSE.
 */
 gboolean
 mate_mixer_is_initialized (void)
 {
- return mixer_initialized;
+ return initialized;
 }
 
 /**
 * mate_mixer_deinit:
 *
- * Deinitializes the library. You should call this function when you do not need
- * to use the library any longer or before exitting the application.
+ * Deinitializes the library. You should call this function when you are done
+ * using the library.
 */
 void
 mate_mixer_deinit (void)
 {
 GList *list;
 
- if (!mixer_initialized)
+ if (initialized == FALSE)
 return;
 
- list = mixer_modules;
- while (list) {
+ list = modules;
+ while (list != NULL) {
 g_type_module_unuse (G_TYPE_MODULE (list->data));
 list = list->next;
 }
- mixer_initialized = FALSE;
+ initialized = FALSE;
 }
 
 /* Internal function: return a list of loaded backend modules */
 const GList *
 mate_mixer_get_modules (void)
 {
- return (const GList *) mixer_modules;
+ return (const GList *) modules;
 }
 
 static void
-mixer_load_modules (void)
+load_modules (void)
 {
 static gboolean loaded = FALSE;
 
- if (loaded)
+ if (loaded == TRUE)
 return;
 
- if (g_module_supported ()) {
+ if (G_LIKELY (g_module_supported () == TRUE)) {
 GDir *dir;
 GError *error = NULL;
 
@@ -138,34 +146,29 @@ mixer_load_modules (void)
 while ((name = g_dir_read_name (dir)) != NULL) {
 gchar *file;
 
- if (!g_str_has_suffix (name, "." G_MODULE_SUFFIX))
+ if (g_str_has_suffix (name, "." G_MODULE_SUFFIX) == FALSE)
 continue;
 
 file = g_build_filename (LIBMATEMIXER_BACKEND_DIR, name, NULL);
- mixer_modules = g_list_prepend (mixer_modules,
- mate_mixer_backend_module_new (file));
+ modules = g_list_prepend (modules, mate_mixer_backend_module_new (file));
 g_free (file);
 }
 
- if (mixer_modules == NULL)
- g_critical ("No backend modules have been found");
-
 g_dir_close (dir);
 } else {
 g_critical ("%s", error->message);
 g_error_free (error);
 }
 } else {
- g_critical ("Unable to load backend modules: GModule is not supported in your system");
+ g_critical ("Unable to load backend modules: not supported");
 }
 
 loaded = TRUE;
 }
 
-/* GCompareFunc function to sort backend modules by the priority, higher number means
- * higher priority */
+/* Backend modules sorting function, higher priority number means higher priority */
 static gint
-mixer_compare_modules (gconstpointer a, gconstpointer b)
+compare_modules (gconstpointer a, gconstpointer b)
 {
 const MateMixerBackendInfo *info1, *info2;
author	Michal Ratajsky <[email protected]>	2014-07-18 15:41:59 +0200
committer	Michal Ratajsky <[email protected]>	2014-07-18 15:41:59 +0200
commit	56c76128b0144a5c61e77d2a7aec07a337cfb66d (patch)
tree	f67ce44025881578cf6de3332064c214da176a23
parent	85070f3b97a3213d75a7bebf86ad973aaa21c55b (diff)
download	libmatemixer-56c76128b0144a5c61e77d2a7aec07a337cfb66d.tar.bz2 libmatemixer-56c76128b0144a5c61e77d2a7aec07a337cfb66d.tar.xz