colin/wireplumber
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

monitor: add a new WpMonitor class

Browse Source 
This class wraps a SPA monitor and creates all
the devices and nodes as they are being discovered
This commit is contained in:
George Kiagiadakis
2019-09-02 12:39:48 -04:00
parent 10b117144a
commit 302e991b28
4 changed files with 624 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
lib/wp/meson.build
View File

@@ -4,6 +4,7 @@ wp_lib_sources = [
'error.c',
'factory.c',
'module.c',
'monitor.c',
'policy.c',
'properties.c',
'proxy.c',
@@ -19,6 +20,7 @@ wp_lib_headers = [
'error.h',
'factory.h',
'module.h',
'monitor.h',
'policy.h',
'properties.h',
'proxy.h',

584
lib/wp/monitor.c Normal file
View File

@@ -0,0 +1,584 @@
/* WirePlumber
*
* Copyright © 2019 Collabora Ltd.
* @author Julian Bouzas <julian.bouzas@collabora.com>
*
* SPDX-License-Identifier: MIT
*/
#include <spa/monitor/monitor.h>
#include <pipewire/pipewire.h>
#include "monitor.h"
#include "error.h"
#include "wpenums.h"
typedef struct {
struct spa_handle *handle;
gpointer interface;
} WpSpaObject;
struct _WpMonitor
{
GObject parent;
/* Props */
GWeakRef core;
gchar *factory_name;
WpMonitorFlags flags;
/* Monitor info */
WpSpaObject *spa_mon;
GList *devices; /* element-type: struct device* */
};
struct device
{
guint32 id;
WpMonitor *self;
WpSpaObject *spa_dev;
WpProxy *proxy;
WpProperties *properties;
GList *nodes; /* element-type: struct node* */
struct spa_hook listener;
};
struct node
{
guint32 id;
WpMonitor *self;
struct pw_node *node;
WpProxy *proxy;
};
enum {
PROP_0,
PROP_CORE,
PROP_FACTORY_NAME,
PROP_FLAGS,
};
enum {
SIG_SETUP_NODE_PROPS,
SIG_SETUP_DEVICE_PROPS,
N_SIGNALS
};
static guint32 signals[N_SIGNALS] = {0};
G_DEFINE_TYPE (WpMonitor, wp_monitor, G_TYPE_OBJECT)
/* spa object */
static void
wp_spa_object_free (WpSpaObject *self)
{
pw_unload_spa_handle (self->handle);
}
static inline WpSpaObject *
wp_spa_object_ref (WpSpaObject *self)
{
return g_rc_box_acquire (self);
}
static inline void
wp_spa_object_unref (WpSpaObject *self)
{
g_rc_box_release_full (self, (GDestroyNotify) wp_spa_object_free);
}
G_DEFINE_AUTOPTR_CLEANUP_FUNC (WpSpaObject, wp_spa_object_unref)
static WpSpaObject *
load_spa_object (WpCore *core, const gchar *factory, guint32 iface_type,
WpProperties *props, GError **error)
{
g_autoptr (WpSpaObject) self = g_rc_box_new0 (WpSpaObject);
gint res;
/* Load the monitor handle */
self->handle = pw_core_load_spa_handle (wp_core_get_pw_core (core),
factory, props ? wp_properties_peek_dict (props) : NULL);
if (!self->handle) {
g_set_error (error, WP_DOMAIN_LIBRARY, WP_LIBRARY_ERROR_OPERATION_FAILED,
"SPA handle '%s' could not be loaded; is it installed?",
factory);
return NULL;
}
/* Get the handle interface */
res = spa_handle_get_interface (self->handle, iface_type, &self->interface);
if (res < 0) {
g_set_error (error, WP_DOMAIN_LIBRARY, WP_LIBRARY_ERROR_OPERATION_FAILED,
"Could not get interface 0x%x from SPA handle", iface_type);
return NULL;
}
return g_steal_pointer (&self);
}
/* common */
static gpointer
find_object (GList *list, guint32 id, GList **link)
{
/*
* The first element of struct device & struct node
* is the guint32 containing the id, so we can directly cast
* the list data to guint32, no matter what the actual structure is
*/
for (; list; list = g_list_next (list)) {
if (id == *((guint32 *) list->data)) {
*link = list;
return list->data;
}
}
return NULL;
}
/* node */
static struct node *
node_new (struct device *dev, uint32_t id,
const struct spa_device_object_info *info)
{
WpMonitor *self = dev->self;
g_autoptr (WpCore) core = NULL;
g_autoptr (WpProperties) props = NULL;
struct pw_proxy *pw_proxy = NULL;
struct pw_node *pw_node = NULL;
struct node *node = NULL;
const gchar *pw_factory_name = "spa-node-factory";
if (info->type != SPA_TYPE_INTERFACE_Node)
return NULL;
g_debug ("WpMonitor:%p:%s new node %u", self, self->factory_name, id);
/* use the adapter instead of spa-node-factory if requested */
if (self->flags & WP_MONITOR_FLAG_USE_ADAPTER)
pw_factory_name = "adapter";
core = g_weak_ref_get (&self->core);
props = wp_properties_new_copy_dict (info->props);
/* pass down the id to the setup function */
wp_properties_setf (props, WP_MONITOR_KEY_OBJECT_ID, "%u", id);
/* the SPA factory name must be set as a property
for the spa-node-factory / adapter */
wp_properties_setf (props, PW_KEY_FACTORY_NAME, info->factory_name);
/* the rest is up to the user */
g_signal_emit (self, signals[SIG_SETUP_NODE_PROPS], 0, dev->properties,
props);
/* and delete the id - it should not appear on the proxy */
wp_properties_set (props, WP_MONITOR_KEY_OBJECT_ID, NULL);
if (self->flags & WP_MONITOR_FLAG_LOCAL_NODES) {
struct pw_factory *factory;
/* create the pipewire node (and the underlying SPA node)
on the wireplumber process and export it */
factory = pw_core_find_factory (wp_core_get_pw_core (core), pw_factory_name);
if (!factory) {
g_warning ("WpMonitor:%p: no '%s' factory found; node '%s' will "
"not be created", self, pw_factory_name, info->factory_name);
return NULL;
}
pw_node = pw_factory_create_object (factory,
NULL,
PW_TYPE_INTERFACE_Node,
PW_VERSION_NODE_PROXY,
wp_properties_to_pw_properties (props),
0);
if (!pw_node) {
g_warning ("WpMonitor:%p: failed to construct pw_node; node '%s' will "
"not be created", self, info->factory_name);
return NULL;
}
pw_proxy = pw_remote_export (wp_core_get_pw_remote (core),
PW_TYPE_INTERFACE_Node,
wp_properties_to_pw_properties (props),
pw_node,
0);
if (!pw_proxy) {
g_warning ("WpMonitor:%p: failed to export node: %s", self,
g_strerror (errno));
pw_node_destroy (pw_node);
return NULL;
}
} else {
/* create the pipewire node (and the underlying SPA node)
on the remote pipewire process */
pw_proxy = pw_core_proxy_create_object (wp_core_get_pw_core_proxy (core),
pw_factory_name,
PW_TYPE_INTERFACE_Node,
PW_VERSION_NODE_PROXY,
wp_properties_peek_dict (props),
0);
}
node = g_slice_new0 (struct node);
node->self = self;
node->id = id;
node->node = pw_node;
node->proxy = wp_proxy_new_wrap (core, pw_proxy, PW_TYPE_INTERFACE_Node,
PW_VERSION_NODE_PROXY);
return node;
}
static void
node_free (struct node *node)
{
g_debug ("WpMonitor:%p:%s free node %u", node->self,
node->self->factory_name, node->id);
g_clear_object (&node->proxy);
g_clear_pointer (&node->node, pw_node_destroy);
g_slice_free (struct node, node);
}
/* device */
static void
device_info (void *data, const struct spa_device_info *info)
{
struct device *dev = data;
/*
* This is emited syncrhonously at the time we add the listener and
* before object_info is emited. It gives us additional properties
* about the device, like the "api.alsa.card.*" ones that are not
* set by the monitor
*/
if (info->change_mask & SPA_DEVICE_CHANGE_MASK_PROPS)
wp_properties_update_from_dict (dev->properties, info->props);
}
static void
device_object_info (void *data, uint32_t id,
const struct spa_device_object_info *info)
{
struct device *dev = data;
struct node *node = NULL;
GList *link = NULL;
/* Find the node */
node = find_object (dev->nodes, id, &link);
if (info && !node) {
if (!(node = node_new (dev, id, info)))
return;
dev->nodes = g_list_append (dev->nodes, node);
} else if (!info && node) {
node_free (node);
dev->nodes = g_list_delete_link (dev->nodes, link);
}
}
static const struct spa_device_events device_events = {
SPA_VERSION_DEVICE_EVENTS,
.info = device_info,
.object_info = device_object_info
};
static struct device *
device_new (WpMonitor *self, uint32_t id,
const struct spa_monitor_object_info *info)
{
g_autoptr (GError) error = NULL;
g_autoptr (WpCore) core = NULL;
g_autoptr (WpProperties) props = NULL;
g_autoptr (WpSpaObject) spa_dev = NULL;
struct pw_proxy *proxy = NULL;
struct device *dev = NULL;
if (info->type != SPA_TYPE_INTERFACE_Device)
return NULL;
g_debug ("WpMonitor:%p:%s new device %u", self, self->factory_name, id);
core = g_weak_ref_get (&self->core);
props = wp_properties_new_copy_dict (info->props);
/* pass down the id to the setup function */
wp_properties_setf (props, WP_MONITOR_KEY_OBJECT_ID, "%u", id);
/* let the handler setup the properties accordingly */
g_signal_emit (self, signals[SIG_SETUP_DEVICE_PROPS], 0, props);
/* and delete the id - it should not appear on the proxy */
wp_properties_set (props, WP_MONITOR_KEY_OBJECT_ID, NULL);
if (!(spa_dev = load_spa_object (core, info->factory_name, info->type, props,
&error))) {
g_warning ("WpMonitor:%p: failed to construct device: %s", self,
error->message);
return NULL;
}
if (!(proxy = pw_remote_export (wp_core_get_pw_remote (core), info->type,
wp_properties_to_pw_properties (props), spa_dev->interface, 0))) {
g_warning ("WpMonitor:%p: failed to export device: %s", self,
g_strerror (errno));
return NULL;
}
/* Create the device */
dev = g_slice_new0 (struct device);
dev->self = self;
dev->id = id;
dev->spa_dev = g_steal_pointer (&spa_dev);
dev->properties = g_steal_pointer (&props);
dev->proxy = wp_proxy_new_wrap (core, proxy, PW_TYPE_INTERFACE_Device,
PW_VERSION_DEVICE_PROXY);
/* Add device listener for events */
spa_device_add_listener ((struct spa_device *) dev->spa_dev->interface,
&dev->listener, &device_events, dev);
return dev;
}
static void
device_free (struct device *dev)
{
g_debug ("WpMonitor:%p:%s free device %u", dev->self,
dev->self->factory_name, dev->id);
spa_hook_remove (&dev->listener);
g_list_free_full (dev->nodes, (GDestroyNotify) node_free);
g_clear_object (&dev->proxy);
g_clear_pointer (&dev->spa_dev, wp_spa_object_unref);
g_clear_pointer (&dev->properties, wp_properties_unref);
g_slice_free (struct device, dev);
}
/* monitor */
static int
monitor_object_info (gpointer data, uint32_t id,
const struct spa_monitor_object_info *info)
{
WpMonitor * self = WP_MONITOR (data);
struct device *dev = NULL;
GList *link = NULL;
/* Find the device */
dev = find_object (self->devices, id, &link);
if (info && !dev) {
if (!(dev = device_new (self, id, info)))
return -ENOMEM;
self->devices = g_list_append (self->devices, dev);
} else if (!info && dev) {
device_free (dev);
self->devices = g_list_delete_link (self->devices, link);
} else if (!info && !dev) {
return -ENODEV;
}
return 0;
}
static const struct spa_monitor_callbacks monitor_callbacks = {
SPA_VERSION_MONITOR_CALLBACKS,
.object_info = monitor_object_info,
};
static void
wp_monitor_init (WpMonitor * self)
{
g_weak_ref_init (&self->core, NULL);
}
static void
wp_monitor_finalize (GObject * object)
{
WpMonitor * self = WP_MONITOR (object);
wp_monitor_stop (self);
g_weak_ref_clear (&self->core);
g_free (self->factory_name);
G_OBJECT_CLASS (wp_monitor_parent_class)->finalize (object);
}
static void
wp_monitor_set_property (GObject * object, guint property_id,
const GValue * value, GParamSpec * pspec)
{
WpMonitor * self = WP_MONITOR (object);
switch (property_id) {
case PROP_CORE:
g_weak_ref_set (&self->core, g_value_get_object (value));
break;
case PROP_FACTORY_NAME:
self->factory_name = g_value_dup_string (value);
break;
case PROP_FLAGS:
self->flags = (WpMonitorFlags) g_value_get_flags (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
wp_monitor_get_property (GObject * object, guint property_id,
GValue * value, GParamSpec * pspec)
{
WpMonitor * self = WP_MONITOR (object);
switch (property_id) {
case PROP_CORE:
g_value_take_object (value, g_weak_ref_get (&self->core));
break;
case PROP_FACTORY_NAME:
g_value_set_string (value, self->factory_name);
break;
case PROP_FLAGS:
g_value_set_flags (value, (guint) self->flags);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
wp_monitor_class_init (WpMonitorClass * klass)
{
GObjectClass *object_class = (GObjectClass *) klass;
object_class->finalize = wp_monitor_finalize;
object_class->set_property = wp_monitor_set_property;
object_class->get_property = wp_monitor_get_property;
/* Install the properties */
g_object_class_install_property (object_class, PROP_CORE,
g_param_spec_object ("core", "core", "The wireplumber core",
WP_TYPE_CORE,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (object_class, PROP_FACTORY_NAME,
g_param_spec_string ("factory-name", "factory-name",
"The factory name of the monitor", NULL,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (object_class, PROP_FLAGS,
g_param_spec_flags ("flags", "flags",
"Additional feature flags", WP_TYPE_MONITOR_FLAGS, 0,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
/**
* WpMonitor::setup-device-props:
* @self: the #WpMonitor
* @device_props: the properties of the device to be created
*
* This signal allows the handler to modify the properties of a device
* object before it is created.
*/
signals[SIG_SETUP_DEVICE_PROPS] = g_signal_new (
"setup-device-props", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST, 0,
NULL, NULL, NULL, G_TYPE_NONE, 1, WP_TYPE_PROPERTIES);
/**
* WpMonitor::setup-node-props:
* @self: the #WpMonitor
* @device_props: the properties of the parent device
* @node_props: the properties of the node to be created
*
* This signal allows the handler to modify the properties of a node
* object before it is created.
*/
signals[SIG_SETUP_NODE_PROPS] = g_signal_new (
"setup-node-props", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_FIRST, 0,
NULL, NULL, NULL, G_TYPE_NONE, 2, WP_TYPE_PROPERTIES, WP_TYPE_PROPERTIES);
}
/**
* wp_monitor_new:
* @core: the wireplumber core
* @factory_name: the factory name of the monitor
*
* Returns: (transfer full): the newly created monitor
*/
WpMonitor *
wp_monitor_new (WpCore * core, const gchar * factory_name, WpMonitorFlags flags)
{
g_return_val_if_fail (WP_IS_CORE (core), NULL);
g_return_val_if_fail (factory_name != NULL && *factory_name != '\0', NULL);
return g_object_new (WP_TYPE_MONITOR,
"core", core,
"factory-name", factory_name,
"flags", flags,
NULL);
}
const gchar *
wp_monitor_get_factory_name (WpMonitor *self)
{
g_return_val_if_fail (WP_IS_MONITOR (self), NULL);
return self->factory_name;
}
gboolean
wp_monitor_start (WpMonitor *self, GError **error)
{
g_autoptr (WpCore) core = NULL;
gint ret = 0;
g_return_val_if_fail (WP_IS_MONITOR (self), FALSE);
core = g_weak_ref_get (&self->core);
g_debug ("WpMonitor:%p:%s starting monitor", self, self->factory_name);
if (!(self->spa_mon = load_spa_object (core, self->factory_name,
SPA_TYPE_INTERFACE_Monitor, NULL, error))) {
return FALSE;
}
/* Actual monitor implementations start their internal processing
when the callbacks are set and if they fail, they return an error
code on this call */
ret = spa_monitor_set_callbacks (
(struct spa_monitor *) self->spa_mon->interface,
&monitor_callbacks, self);
if (ret < 0) {
g_set_error (error, WP_DOMAIN_LIBRARY, WP_LIBRARY_ERROR_OPERATION_FAILED,
"Failed to start monitor '%s': %s", self->factory_name,
g_strerror (-ret));
g_clear_pointer (&self->spa_mon, wp_spa_object_unref);
return FALSE;
}
return TRUE;
}
void
wp_monitor_stop (WpMonitor *self)
{
g_return_if_fail (WP_IS_MONITOR (self));
g_debug ("WpMonitor:%p:%s stopping monitor", self, self->factory_name);
g_list_free_full (self->devices, (GDestroyNotify) device_free);
self->devices = NULL;
g_clear_pointer (&self->spa_mon, wp_spa_object_unref);
}

37
lib/wp/monitor.h Normal file
View File

@@ -0,0 +1,37 @@
/* WirePlumber
*
* Copyright © 2019 Collabora Ltd.
* @author Julian Bouzas <julian.bouzas@collabora.com>
*
* SPDX-License-Identifier: MIT
*/
#ifndef __WIREPLUMBER_MONITOR_H__
#define __WIREPLUMBER_MONITOR_H__
#include "core.h"
G_BEGIN_DECLS
typedef enum { /*< flags, prefix=WP_MONITOR_FLAG_ >*/
WP_MONITOR_FLAG_LOCAL_NODES = (1 << 0),
WP_MONITOR_FLAG_USE_ADAPTER = (1 << 1),
} WpMonitorFlags;
#define WP_MONITOR_KEY_OBJECT_ID "wp.monitor.object.id"
#define WP_TYPE_MONITOR (wp_monitor_get_type ())
G_DECLARE_FINAL_TYPE (WpMonitor, wp_monitor, WP, MONITOR, GObject)
WpMonitor * wp_monitor_new (WpCore * core, const gchar * factory_name,
WpMonitorFlags flags);
const gchar * wp_monitor_get_factory_name (WpMonitor *self);
WpMonitorFlags wp_monitor_get_flags (WpMonitor *self);
gboolean wp_monitor_start (WpMonitor *self, GError **error);
void wp_monitor_stop (WpMonitor *self);
G_END_DECLS
#endif

1
lib/wp/wp.h
View File

@@ -11,6 +11,7 @@
#include "error.h"
#include "factory.h"
#include "module.h"
#include "monitor.h"
#include "policy.h"
#include "properties.h"
#include "proxy.h"