summaryrefslogtreecommitdiff
path: root/backends/pulse/pulse-backend.c
diff options
context:
space:
mode:
Diffstat (limited to 'backends/pulse/pulse-backend.c')
-rw-r--r--backends/pulse/pulse-backend.c1104
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);
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-03 06:15:10 +0000