diff options
Diffstat (limited to 'backends/pulse/pulse-backend.c')
| -rw-r--r-- | backends/pulse/pulse-backend.c | 1104 |
1 files changed, 662 insertions, 442 deletions
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); |