From f578f49e3265bfed6bd7e37391e66506f9a4bc91 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Thu, 11 May 2006 20:14:38 +0000 Subject: * implement device probing for GstPolypMixer git-svn-id: file:///home/lennart/svn/public/gst-pulse/trunk@25 bb39ca4e-bce3-0310-b5d4-eea78a553289 --- src/polypprobe.c | 322 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 322 insertions(+) create mode 100644 src/polypprobe.c (limited to 'src/polypprobe.c') diff --git a/src/polypprobe.c b/src/polypprobe.c new file mode 100644 index 0000000..cd057e0 --- /dev/null +++ b/src/polypprobe.c @@ -0,0 +1,322 @@ +/* $Id$ */ + +/*** + This file is part of gst-polyp. + + gst-polyp is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as + published by the Free Software Foundation; either version 2.1 of the + License, or (at your option) any later version. + + gst-polyp is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with gst-polyp; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + USA. +***/ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "polypprobe.h" +#include "polyputil.h" + +GST_DEBUG_CATEGORY_EXTERN(polyp_debug); +#define GST_CAT_DEFAULT polyp_debug + +static void gst_polypprobe_context_state_cb(pa_context *context, void *userdata) { + GstPolypProbe *c = (GstPolypProbe*) userdata; + + /* Called from the background thread! */ + + switch (pa_context_get_state(context)) { + case PA_CONTEXT_READY: + case PA_CONTEXT_TERMINATED: + case PA_CONTEXT_FAILED: + pa_threaded_mainloop_signal(c->mainloop, 0); + break; + + case PA_CONTEXT_UNCONNECTED: + case PA_CONTEXT_CONNECTING: + case PA_CONTEXT_AUTHORIZING: + case PA_CONTEXT_SETTING_NAME: + break; + } +} + +static void gst_polypprobe_sink_info_cb(pa_context *context, const pa_sink_info *i, int eol, void *userdata) { + GstPolypProbe *c = (GstPolypProbe*) userdata; + + /* Called from the background thread! */ + + if (eol || !i) { + c->operation_success = eol > 0; + pa_threaded_mainloop_signal(c->mainloop, 0); + } + + if (i) + c->devices = g_list_append(c->devices, g_strdup(i->name)); + +} + +static void gst_polypprobe_source_info_cb(pa_context *context, const pa_source_info *i, int eol, void *userdata) { + GstPolypProbe *c = (GstPolypProbe*) userdata; + + /* Called from the background thread! */ + + if (eol || !i) { + c->operation_success = eol > 0; + pa_threaded_mainloop_signal(c->mainloop, 0); + } + + if (i) + c->devices = g_list_append(c->devices, g_strdup(i->name)); +} + +static void gst_polypprobe_invalidate(GstPolypProbe *c) { + g_list_foreach(c->devices, (GFunc) g_free, NULL); + g_list_free(c->devices); + c->devices = NULL; + c->devices_valid = 0; +} + +static gboolean gst_polypprobe_open(GstPolypProbe *c) { + int e; + gchar *name = gst_polyp_client_name(); + + g_assert(c); + + c->mainloop = pa_threaded_mainloop_new(); + g_assert(c->mainloop); + + e = pa_threaded_mainloop_start(c->mainloop); + g_assert(e == 0); + + pa_threaded_mainloop_lock(c->mainloop); + + if (!(c->context = pa_context_new(pa_threaded_mainloop_get_api(c->mainloop), name))) { + GST_WARNING("Failed to create context"); + goto unlock_and_fail; + } + + pa_context_set_state_callback(c->context, gst_polypprobe_context_state_cb, c); + + if (pa_context_connect(c->context, c->server, 0, NULL) < 0) { + GST_WARNING("Failed to connect context: %s", pa_strerror(pa_context_errno(c->context))); + goto unlock_and_fail; + } + + /* Wait until the context is ready */ + pa_threaded_mainloop_wait(c->mainloop); + + if (pa_context_get_state(c->context) != PA_CONTEXT_READY) { + GST_WARNING("Failed to connect context: %s", pa_strerror(pa_context_errno(c->context))); + goto unlock_and_fail; + } + + pa_threaded_mainloop_unlock(c->mainloop); + g_free(name); + + gst_polypprobe_invalidate(c); + + return TRUE; + +unlock_and_fail: + + if (c->mainloop) + pa_threaded_mainloop_unlock(c->mainloop); + + g_free(name); + + return FALSE; +} + +#define CHECK_DEAD_GOTO(c, label) do { \ +if (!(c)->context || pa_context_get_state((c)->context) != PA_CONTEXT_READY) { \ + GST_WARNING("Not connected: %s", (c)->context ? pa_strerror(pa_context_errno((c)->context)) : "NULL"); \ + goto label; \ +} \ +} while(0); + +static gboolean gst_polypprobe_enumerate(GstPolypProbe *c) { + pa_operation *o = NULL; + + pa_threaded_mainloop_lock(c->mainloop); + + if (c->enumerate_sinks) { + /* Get sink info */ + + if (!(o = pa_context_get_sink_info_list(c->context, gst_polypprobe_sink_info_cb, c))) { + GST_WARNING("Failed to get sink info: %s", pa_strerror(pa_context_errno(c->context))); + goto unlock_and_fail; + } + + c->operation_success = 0; + while (pa_operation_get_state(o) != PA_OPERATION_DONE) { + pa_threaded_mainloop_wait(c->mainloop); + CHECK_DEAD_GOTO(c, unlock_and_fail); + } + + if (!c->operation_success) { + GST_WARNING("Failed to get sink info: %s", pa_strerror(pa_context_errno(c->context))); + goto unlock_and_fail; + } + + pa_operation_unref(o); + o = NULL; + } + + if (c->enumerate_sources) { + /* Get source info */ + + if (!(o = pa_context_get_source_info_list(c->context, gst_polypprobe_source_info_cb, c))) { + GST_WARNING("Failed to get source info: %s", pa_strerror(pa_context_errno(c->context))); + goto unlock_and_fail; + } + + c->operation_success = 0; + while (pa_operation_get_state(o) != PA_OPERATION_DONE) { + pa_threaded_mainloop_wait(c->mainloop); + CHECK_DEAD_GOTO(c, unlock_and_fail); + } + + if (!c->operation_success) { + GST_WARNING("Failed to get sink info: %s", pa_strerror(pa_context_errno(c->context))); + goto unlock_and_fail; + } + + pa_operation_unref(o); + o = NULL; + } + + c->devices_valid = 1; + + pa_threaded_mainloop_unlock(c->mainloop); + + return TRUE; + +unlock_and_fail: + + if (o) + pa_operation_unref(o); + + pa_threaded_mainloop_unlock(c->mainloop); + + return FALSE; +} + +static void gst_polypprobe_close(GstPolypProbe *c) { + g_assert(c); + + if (c->mainloop) + pa_threaded_mainloop_stop(c->mainloop); + + if (c->context) { + pa_context_disconnect(c->context); + pa_context_unref(c->context); + c->context = NULL; + } + + if (c->mainloop) { + pa_threaded_mainloop_free(c->mainloop); + c->mainloop = NULL; + } +} + +GstPolypProbe* gst_polypprobe_new(GObjectClass *klass, guint prop_id, const gchar *server, gboolean sinks, gboolean sources) { + GstPolypProbe *c = NULL; + + c = g_new(GstPolypProbe, 1); + c->server = g_strdup(server); + c->enumerate_sinks = sinks; + c->enumerate_sources = sources; + + c->mainloop = NULL; + c->context = NULL; + + c->prop_id = prop_id; + c->properties = g_list_append(NULL, g_object_class_find_property(klass, "device")); + c->devices = NULL; + c->devices_valid = 0; + + return c; +} + +void gst_polypprobe_free(GstPolypProbe* c) { + g_assert(c); + + gst_polypprobe_close(c); + + g_list_free(c->properties); + g_free(c->server); + + g_list_foreach(c->devices, (GFunc) g_free, NULL); + g_list_free(c->devices); + + g_free(c); +} + +const GList* gst_polypprobe_get_properties(GstPolypProbe *c) { + return c->properties; +} + +gboolean gst_polypprobe_needs_probe(GstPolypProbe *c, guint prop_id, const GParamSpec *pspec) { + + if (prop_id == c->prop_id) + return !c->devices_valid; + + G_OBJECT_WARN_INVALID_PROPERTY_ID(c, prop_id, pspec); + return FALSE; +} + +void gst_polypprobe_probe_property(GstPolypProbe *c, guint prop_id, const GParamSpec *pspec) { + + if (prop_id != c->prop_id) { + G_OBJECT_WARN_INVALID_PROPERTY_ID(c, prop_id, pspec); + return; + } + + if (gst_polypprobe_open(c)) { + gst_polypprobe_enumerate(c); + gst_polypprobe_close(c); + } +} + +GValueArray *gst_polypprobe_get_values(GstPolypProbe *c, guint prop_id, const GParamSpec *pspec) { + GValueArray *array; + GValue value = { 0 }; + GList *item; + + if (prop_id != c->prop_id) { + G_OBJECT_WARN_INVALID_PROPERTY_ID(c, prop_id, pspec); + return NULL; + } + + if (!c->devices_valid) + return NULL; + + array = g_value_array_new(g_list_length(c->devices)); + g_value_init(&value, G_TYPE_STRING); + for (item = c->devices; item != NULL; item = item->next) { + GST_WARNING("device found: %s", (const gchar *) item->data); + g_value_set_string(&value, (const gchar *) item->data); + g_value_array_append(array, &value); + } + g_value_unset (&value); + + return array; +} + +void gst_polypprobe_set_server(GstPolypProbe *c, const gchar *server) { + g_assert(c); + + gst_polypprobe_invalidate(c); + + g_free(c->server); + c->server = g_strdup(server); +} -- cgit