mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-12-13 08:56:39 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add monitor interface

Browse source 
Add an interface to monitor devices and helper program
Add v4l2 monitor
Add simple dictionary with key/value pairs
This commit is contained in:
Wim Taymans 2016-09-15 11:49:34 +02:00
parent 140f360cc0
commit 9f53eda6cb
29 changed files with 921 additions and 51 deletions
Download patch file Download diff file Expand all files Collapse all files

4
pinos/modules/spa/spa-alsa-sink.c
View file

@ -76,11 +76,11 @@ make_node (SpaNode **node, const char *lib, const char *name)
continue;
handle = calloc (1, factory->size);
if ((res = factory->init (factory, handle)) < 0) {
if ((res = spa_handle_factory_init (factory, handle, NULL)) < 0) {
g_error ("can't make factory instance: %d", res);
return res;
}
if ((res = handle->get_interface (handle, SPA_INTERFACE_ID_NODE, &iface)) < 0) {
if ((res = spa_handle_get_interface (handle, SPA_INTERFACE_ID_NODE, &iface)) < 0) {
g_error ("can't get interface %d", res);
return res;
}

4
pinos/modules/spa/spa-audiotestsrc.c
View file

@ -69,11 +69,11 @@ make_node (SpaNode **node, const char *lib, const char *name)
continue;
handle = calloc (1, factory->size);
if ((res = factory->init (factory, handle)) < 0) {
if ((res = spa_handle_factory_init (factory, handle, NULL)) < 0) {
g_error ("can't make factory instance: %d", res);
return res;
}
if ((res = handle->get_interface (handle, SPA_INTERFACE_ID_NODE, &iface)) < 0) {
if ((res = spa_handle_get_interface (handle, SPA_INTERFACE_ID_NODE, &iface)) < 0) {
g_error ("can't get interface %d", res);
return res;
}

4
pinos/modules/spa/spa-v4l2-source.c
View file

@ -79,11 +79,11 @@ make_node (SpaNode **node, const char *lib, const char *name)
continue;
handle = calloc (1, factory->size);
if ((res = factory->init (factory, handle)) < 0) {
if ((res = spa_handle_factory_init (factory, handle, NULL)) < 0) {
g_error ("can't make factory instance: %d", res);
return res;
}
if ((res = handle->get_interface (handle, SPA_INTERFACE_ID_NODE, &iface)) < 0) {
if ((res = spa_handle_get_interface (handle, SPA_INTERFACE_ID_NODE, &iface)) < 0) {
g_error ("can't get interface %d", res);
return res;
}

2
pinos/server/client-node.c
View file

@ -249,7 +249,7 @@ make_node (SpaNode **node, const char *lib, const char *name)
continue;
handle = calloc (1, factory->size);
if ((res = factory->init (factory, handle)) < 0) {
if ((res = factory->init (factory, handle, NULL)) < 0) {
g_error ("can't make factory instance: %d", res);
return res;
}

6
spa/include/spa/clock.h
View file

@ -57,6 +57,12 @@ struct _SpaClock {
/* the total size of this clock. This can be used to expand this
* structure in the future */
size_t size;
/**
* SpaClock::info
*
* Extra information about the clock
*/
const SpaDict *info;
/**
* SpaClock::state:
*

2
spa/include/spa/debug.h
View file

@ -29,12 +29,14 @@ extern "C" {
#include <spa/buffer.h>
#include <spa/props.h>
#include <spa/format.h>
#include <spa/dict.h>
SpaResult spa_debug_port_info (const SpaPortInfo *info);
SpaResult spa_debug_buffer (const SpaBuffer *buffer);
SpaResult spa_debug_props (const SpaProps *props, bool print_ranges);
SpaResult spa_debug_format (const SpaFormat *format);
SpaResult spa_debug_dump_mem (const void *data, size_t size);
SpaResult spa_debug_dict (const SpaDict *dict);
#ifdef __cplusplus
} /* extern "C" */

45
spa/include/spa/dict.h Normal file
View file

@ -0,0 +1,45 @@
/* Simple Plugin API
* Copyright (C) 2016 Wim Taymans <wim.taymans@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef __SPA_DICT_H__
#define __SPA_DICT_H__
#ifdef __cplusplus
extern "C" {
#endif
typedef struct _SpaDict SpaDict;
#include <spa/defs.h>
typedef struct {
const char *key;
const char *value;
} SpaDictItem;
struct _SpaDict {
unsigned int n_items;
SpaDictItem *items;
};
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_DICT_H__ */

150
spa/include/spa/monitor.h Normal file
View file

@ -0,0 +1,150 @@
/* Simple Plugin API
* Copyright (C) 2016 Wim Taymans <wim.taymans@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef __SPA_MONITOR_H__
#define __SPA_MONITOR_H__
#ifdef __cplusplus
extern "C" {
#endif
typedef struct _SpaMonitor SpaMonitor;
#include <spa/defs.h>
#include <spa/dict.h>
#include <spa/plugin.h>
typedef enum {
SPA_MONITOR_ITEM_FLAG_NONE = 0,
} SpaMonitorItemFlags;
/**
* SpaMonitorItemState:
* @SPA_MONITOR_ITEM_STATE_AVAILABLE: The item is available
* @SPA_MONITOR_ITEM_STATE_DISABLED: the item is disabled
* @SPA_MONITOR_ITEM_STATE_UNAVAILABLE: the item is unavailable
*/
typedef enum {
SPA_MONITOR_ITEM_STATE_AVAILABLE,
SPA_MONITOR_ITEM_STATE_DISABLED,
SPA_MONITOR_ITEM_STATE_UNAVAILABLE,
} SpaMonitorItemState;
typedef struct {
const char *id;
SpaMonitorItemFlags flags;
SpaMonitorItemState state;
const char *name;
const char *klass;
const SpaDict *info;
const SpaHandleFactory *factory;
const void *config;
} SpaMonitorItem;
/**
* SpaMonitorEventType:
* @SPA_MONITOR_EVENT_TYPE_INVALID: invalid event
* @SPA_MONITOR_EVENT_TYPE_ADDED: an item was added, data points to #SpaMonitorItem
* @SPA_MONITOR_EVENT_TYPE_REMOVED: an item was removed, data points to #SpaMonitorItem
* @SPA_MONITOR_EVENT_TYPE_CHANGED: an item was changed, data points to #SpaMonitorItem
* @SPA_MONITOR_EVENT_TYPE_ADD_POLL: add fd for polling, data points to #SpaPollItem
* @SPA_MONITOR_EVENT_TYPE_UPDATE_POLL: update fd for polling, data points to #SpaPollItem
* @SPA_MONITOR_EVENT_TYPE_REMOVE_POLL: remov fd for polling, data points to #SpaPollItem
*/
typedef enum {
SPA_MONITOR_EVENT_TYPE_INVALID = 0,
SPA_MONITOR_EVENT_TYPE_ADDED,
SPA_MONITOR_EVENT_TYPE_REMOVED,
SPA_MONITOR_EVENT_TYPE_CHANGED,
SPA_MONITOR_EVENT_TYPE_ADD_POLL,
SPA_MONITOR_EVENT_TYPE_UPDATE_POLL,
SPA_MONITOR_EVENT_TYPE_REMOVE_POLL,
} SpaMonitorEventType;
typedef struct {
SpaMonitorEventType type;
void *data;
size_t size;
} SpaMonitorEvent;
/**
* SpaMonitorCallback:
* @node: a #SpaMonitor emiting the event
* @event: the event that was emited
* @user_data: user data provided when registering the callback
*
* This will be called when a monitor event is notified
* on @monitor.
*/
typedef void (*SpaMonitorEventCallback) (SpaMonitor *monitor,
SpaMonitorEvent *event,
void *user_data);
#define SPA_INTERFACE_ID_MONITOR 2
#define SPA_INTERFACE_ID_MONITOR_NAME "Monitor interface"
#define SPA_INTERFACE_ID_MONITOR_DESCRIPTION "Device Monitor interface"
/**
* SpaMonitor:
*
* The device monitor interface.
*/
struct _SpaMonitor {
/* pointer to the handle owning this interface */
SpaHandle *handle;
/**
* SpaMonitor::info
*
* Extra information about the monitor
*/
const SpaDict * info;
/* the total size of this monitor. This can be used to expand this
* structure in the future */
size_t size;
/**
* SpaMonitor::set_event_callback:
* @monitor: a #SpaMonitor
* @callback: a #SpaMonitorEventCallback
* @user_data: extra user data
*
* Set an event callback to receive asynchronous notifications from
* the monitor.
*
* Returns: #SPA_RESULT_OK on success
*/
SpaResult (*set_event_callback) (SpaMonitor *monitor,
SpaMonitorEventCallback callback,
void *user_data);
SpaResult (*enum_items) (SpaMonitor *monitor,
SpaMonitorItem **item,
void **state);
};
#define spa_monitor_set_event_callback(m,...) (m)->set_event_callback((m),__VA_ARGS__)
#define spa_monitor_enum_items(m,...) (m)->enum_items((m),__VA_ARGS__)
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_MONITOR_H__ */

9
spa/include/spa/plugin.h
View file

@ -25,7 +25,7 @@ extern "C" {
#endif
#include <spa/defs.h>
#include <spa/props.h>
#include <spa/dict.h>
typedef struct _SpaHandle SpaHandle;
typedef struct _SpaHandleFactory SpaHandleFactory;
@ -90,7 +90,7 @@ struct _SpaHandleFactory {
*
* Extra information about the handles of this factory.
*/
const SpaProps * info;
const SpaDict * info;
/**
* SpaHandleFactory::size
*
@ -102,6 +102,8 @@ struct _SpaHandleFactory {
* SpaHandleFactory::init
* @factory: a #SpaHandleFactory
* @handle: a pointer to memory
* @config: extra handle specific config information, usually obtained from
* a #SpaMonitor.
*
* Initialize an instance of this factory. The caller should allocate
* memory at least SpaHandleFactory::size bytes and pass this as @handle.
@ -111,7 +113,8 @@ struct _SpaHandleFactory {
* #SPA_RESULT_INVALID_ARGUMENTS when factory or handle are %NULL
*/
SpaResult (*init) (const SpaHandleFactory *factory,
SpaHandle *handle);
SpaHandle *handle,
const void *config);
/**
* SpaHandle::enum_interface_info:

2
spa/include/spa/props.h
View file

@ -158,7 +158,7 @@ typedef struct {
* properties. Can be %NULL when unspecified.
* @unset_mask: mask of unset properties. For each property in @prop_info there
* is a corresponding bit that specifies if the property is currently
* unset. When more that 32 properties are present, more uint32_t
* unset. When more than 32 properties are present, more uint32_t
* fields follow this one.
*
* Generic propertiers.

14
spa/lib/debug.c
View file

@ -497,3 +497,17 @@ spa_debug_format (const SpaFormat *format)
}
return SPA_RESULT_OK;
}
SpaResult
spa_debug_dict (const SpaDict *dict)
{
unsigned int i;
if (dict == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
for (i = 0; i < dict->n_items; i++)
fprintf (stderr, " %s = \"%s\"\n", dict->items[i].key, dict->items[i].value);
return SPA_RESULT_OK;
}

1
spa/meson.build
View file

@ -8,6 +8,7 @@ avcodec_dep = dependency('libavcodec')
avformat_dep = dependency('libavformat')
avfilter_dep = dependency('libavfilter')
libva_dep = dependency('libva')
libudev_dep = dependency('libudev')
cc = meson.get_compiler('c')

3
spa/plugins/alsa/alsa-sink.c
View file

@ -702,7 +702,8 @@ alsa_sink_clear (SpaHandle *handle)
static SpaResult
alsa_sink_init (const SpaHandleFactory *factory,
SpaHandle *handle)
SpaHandle *handle,
const void *config)
{
SpaALSASink *this;

3
spa/plugins/audiomixer/audiomixer.c
View file

@ -780,7 +780,8 @@ spa_audiomixer_clear (SpaHandle *handle)
static SpaResult
spa_audiomixer_init (const SpaHandleFactory *factory,
SpaHandle *handle)
SpaHandle *handle,
const void *config)
{
SpaAudioMixer *this;

3
spa/plugins/audiotestsrc/audiotestsrc.c
View file

@ -841,7 +841,8 @@ audiotestsrc_clear (SpaHandle *handle)
static SpaResult
audiotestsrc_init (const SpaHandleFactory *factory,
SpaHandle *handle)
SpaHandle *handle,
const void *config)
{
SpaAudioTestSrc *this;

6
spa/plugins/ffmpeg/ffmpeg.c
View file

@ -30,7 +30,8 @@ SpaResult spa_ffmpeg_enc_init (SpaHandle *handle);
static SpaResult
ffmpeg_dec_init (const SpaHandleFactory *factory,
SpaHandle *handle)
SpaHandle *handle,
const void *config)
{
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
@ -40,7 +41,8 @@ ffmpeg_dec_init (const SpaHandleFactory *factory,
static SpaResult
ffmpeg_enc_init (const SpaHandleFactory *factory,
SpaHandle *handle)
SpaHandle *handle,
const void *config)
{
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;

3
spa/plugins/remote/proxy.c
View file

@ -1152,7 +1152,8 @@ proxy_clear (SpaHandle *handle)
static SpaResult
proxy_init (const SpaHandleFactory *factory,
SpaHandle *handle)
SpaHandle *handle,
const void *config)
{
SpaProxy *this;

3
spa/plugins/v4l2/meson.build
View file

@ -1,9 +1,10 @@
v4l2_sources = ['v4l2.c',
'v4l2-monitor.c',
'v4l2-source.c']
v4l2lib = shared_library('spa-v4l2',
v4l2_sources,
include_directories : inc,
dependencies : v4l2_dep,
dependencies : [ v4l2_dep, libudev_dep ],
link_with : spalib,
install : true)

405
spa/plugins/v4l2/v4l2-monitor.c Normal file
View file

@ -0,0 +1,405 @@
/* Spa V4l2 Monitor
* Copyright (C) 2016 Wim Taymans <wim.taymans@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include <stddef.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <poll.h>
#include <libudev.h>
#include <spa/poll.h>
#include <spa/monitor.h>
#include <spa/memory.h>
#include <spa/debug.h>
typedef struct _SpaV4l2Monitor SpaV4l2Monitor;
typedef struct {
SpaMonitorItem item;
struct udev_device *udevice;
SpaDict info;
SpaDictItem info_items[32];
} V4l2Item;
struct _SpaV4l2Monitor {
SpaHandle handle;
SpaMonitor monitor;
SpaMonitorEventCallback event_cb;
void *user_data;
struct udev* udev;
struct udev_monitor *umonitor;
struct udev_enumerate *enumerate;
V4l2Item uitem;
int fd;
SpaPollFd fds[1];
SpaPollItem poll;
};
static SpaResult
v4l2_udev_open (SpaV4l2Monitor *this)
{
if (this->udev != NULL)
return SPA_RESULT_OK;
this->udev = udev_new ();
return SPA_RESULT_OK;
}
static void
fill_item (V4l2Item *item, struct udev_device *udevice)
{
unsigned int i;
const char *str;
if (item->udevice)
udev_device_unref (item->udevice);
item->udevice = udevice;
if (udevice == NULL)
return;
item->item.id = udev_device_get_devnode (item->udevice);
item->item.flags = 0;
item->item.state = SPA_MONITOR_ITEM_STATE_AVAILABLE;
item->item.klass = "Video/Source";
item->item.info = &item->info;
item->item.factory = NULL;
item->item.config = NULL;
item->info.items = item->info_items;
i = 0;
item->info_items[i].key = "udev-probed";
item->info_items[i++].value = "1";
item->info_items[i].key = "device.api";
item->info_items[i++].value = "v4l2";
item->info_items[i].key = "device.path";
item->info_items[i++].value = udev_device_get_devnode (item->udevice);
str = udev_device_get_property_value (item->udevice, "ID_PATH");
if (!(str && *str))
str = udev_device_get_syspath (item->udevice);
if (str && *str) {
item->info_items[i].key = "device.bus_path";
item->info_items[i++].value = str;
}
if ((str = udev_device_get_syspath (item->udevice)) && *str) {
item->info_items[i].key = "sysfs.path";
item->info_items[i++].value = str;
}
if ((str = udev_device_get_property_value (item->udevice, "ID_ID")) && *str) {
item->info_items[i].key = "udev.id";
item->info_items[i++].value = str;
}
if ((str = udev_device_get_property_value (item->udevice, "ID_BUS")) && *str) {
item->info_items[i].key = "device.bus";
item->info_items[i++].value = str;
}
if ((str = udev_device_get_property_value (item->udevice, "SUBSYSTEM")) && *str) {
item->info_items[i].key = "device.subsystem";
item->info_items[i++].value = str;
}
if ((str = udev_device_get_property_value (item->udevice, "ID_VENDOR_ID")) && *str) {
item->info_items[i].key = "device.vendor.id";
item->info_items[i++].value = str;
}
str = udev_device_get_property_value (item->udevice, "ID_VENDOR_FROM_DATABASE");
if (!(str && *str)) {
str = udev_device_get_property_value (item->udevice, "ID_VENDOR_ENC");
if (!(str && *str)) {
str = udev_device_get_property_value (item->udevice, "ID_VENDOR");
}
}
if (str && *str) {
item->info_items[i].key = "device.vendor.name";
item->info_items[i++].value = str;
}
if ((str = udev_device_get_property_value (item->udevice, "ID_MODEL_ID")) && *str) {
item->info_items[i].key = "device.product.id";
item->info_items[i++].value = str;
}
str = udev_device_get_property_value (item->udevice, "ID_V4L_PRODUCT");
if (!(str && *str)) {
str = udev_device_get_property_value (item->udevice, "ID_MODEL_FROM_DATABASE");
if (!(str && *str)) {
str = udev_device_get_property_value (item->udevice, "ID_MODEL_ENC");
if (!(str && *str)) {
str = udev_device_get_property_value (item->udevice, "ID_MODEL");
}
}
}
if (str && *str) {
item->info_items[i].key = "device.product.name";
item->info_items[i++].value = str;
item->item.name = str;
} else {
item->item.name = "Unknown";
}
if ((str = udev_device_get_property_value (item->udevice, "ID_SERIAL")) && *str) {
item->info_items[i].key = "device.serial";
item->info_items[i++].value = str;
}
if ((str = udev_device_get_property_value (item->udevice, "ID_V4L_CAPABILITIES")) && *str) {
item->info_items[i].key = "device.capabilities";
item->info_items[i++].value = str;
}
item->info.n_items = i;
}
static int
v4l2_on_fd_events (SpaPollNotifyData *data)
{
SpaV4l2Monitor *this = data->user_data;
struct udev_device *dev;
const char *action;
SpaMonitorEvent event;
dev = udev_monitor_receive_device (this->umonitor);
fill_item (&this->uitem, dev);
if (dev == NULL)
return 0;
if ((action = udev_device_get_action (dev)) == NULL)
action = "change";
if (strcmp (action, "add") == 0) {
event.type = SPA_MONITOR_EVENT_TYPE_ADDED;
} else if (strcmp (action, "change") == 0) {
event.type = SPA_MONITOR_EVENT_TYPE_CHANGED;
} else if (strcmp (action, "remove") == 0) {
event.type = SPA_MONITOR_EVENT_TYPE_REMOVED;
}
event.data = &this->uitem.item;
event.size = sizeof (this->uitem);
this->event_cb (&this->monitor, &event, this->user_data);
return 0;
}
static SpaResult
spa_v4l2_monitor_set_event_callback (SpaMonitor *monitor,
SpaMonitorEventCallback callback,
void *user_data)
{
SpaResult res;
SpaV4l2Monitor *this;
SpaMonitorEvent event;
if (monitor == NULL || monitor->handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = (SpaV4l2Monitor *) monitor->handle;
this->event_cb = callback;
this->user_data = user_data;
if (callback) {
if ((res = v4l2_udev_open (this)) < 0)
return res;
this->umonitor = udev_monitor_new_from_netlink (this->udev, "udev");
if (!this->umonitor)
return SPA_RESULT_ERROR;
udev_monitor_filter_add_match_subsystem_devtype (this->umonitor,
"video4linux",
NULL);
udev_monitor_enable_receiving (this->umonitor);
this->fd = udev_monitor_get_fd (this->umonitor);;
event.type = SPA_MONITOR_EVENT_TYPE_ADD_POLL;
event.data = &this->poll;
event.size = sizeof (this->poll);
this->fds[0].fd = this->fd;
this->fds[0].events = POLLIN | POLLPRI | POLLERR;
this->fds[0].revents = 0;
this->poll.id = 0;
this->poll.enabled = true;
this->poll.fds = this->fds;
this->poll.n_fds = 1;
this->poll.idle_cb = NULL;
this->poll.before_cb = NULL;
this->poll.after_cb = v4l2_on_fd_events;
this->poll.user_data = this;
this->event_cb (&this->monitor, &event, this->user_data);
} else {
event.type = SPA_MONITOR_EVENT_TYPE_REMOVE_POLL;
event.data = &this->poll;
event.size = sizeof (this->poll);
this->event_cb (&this->monitor, &event, this->user_data);
}
return SPA_RESULT_OK;
}
static SpaResult
spa_v4l2_monitor_enum_items (SpaMonitor *monitor,
SpaMonitorItem **item,
void **state)
{
SpaResult res;
SpaV4l2Monitor *this;
struct udev_list_entry *devices;
struct udev_device *dev;
if (monitor == NULL || monitor->handle == NULL || item == NULL || state == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = (SpaV4l2Monitor *) monitor->handle;
if ((res = v4l2_udev_open (this)) < 0)
return res;
if (*state == NULL) {
if (this->enumerate)
udev_enumerate_unref (this->enumerate);
this->enumerate = udev_enumerate_new (this->udev);
udev_enumerate_add_match_subsystem (this->enumerate, "video4linux");
udev_enumerate_scan_devices (this->enumerate);
devices = udev_enumerate_get_list_entry (this->enumerate);
if (devices == NULL)
return SPA_RESULT_ENUM_END;
} else {
devices = *state;
}
if (*state == (void*)1) {
fill_item (&this->uitem, NULL);
return SPA_RESULT_ENUM_END;
}
dev = udev_device_new_from_syspath (this->udev,
udev_list_entry_get_name (devices));
fill_item (&this->uitem, dev);
if (dev == NULL)
return SPA_RESULT_ENUM_END;
*item = &this->uitem.item;
if ((*state = udev_list_entry_get_next (devices)) == NULL)
*state = (void*)1;
return SPA_RESULT_OK;
}
static const SpaMonitor v4l2monitor = {
NULL,
NULL,
sizeof (SpaMonitor),
spa_v4l2_monitor_set_event_callback,
spa_v4l2_monitor_enum_items,
};
static SpaResult
spa_v4l2_monitor_get_interface (SpaHandle *handle,
uint32_t interface_id,
void **interface)
{
SpaV4l2Monitor *this;
if (handle == NULL || interface == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = (SpaV4l2Monitor *) handle;
switch (interface_id) {
case SPA_INTERFACE_ID_MONITOR:
*interface = &this->monitor;
break;
default:
return SPA_RESULT_UNKNOWN_INTERFACE;
}
return SPA_RESULT_OK;
}
static SpaResult
v4l2_monitor_clear (SpaHandle *handle)
{
return SPA_RESULT_OK;
}
static SpaResult
v4l2_monitor_init (const SpaHandleFactory *factory,
SpaHandle *handle,
const void *config)
{
SpaV4l2Monitor *this;
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
handle->get_interface = spa_v4l2_monitor_get_interface;
handle->clear = v4l2_monitor_clear,
this = (SpaV4l2Monitor *) handle;
this->monitor = v4l2monitor;
this->monitor.handle = handle;
return SPA_RESULT_OK;
}
static const SpaInterfaceInfo v4l2_monitor_interfaces[] =
{
{ SPA_INTERFACE_ID_MONITOR,
SPA_INTERFACE_ID_MONITOR_NAME,
SPA_INTERFACE_ID_MONITOR_DESCRIPTION,
},
};
static SpaResult
v4l2_monitor_enum_interface_info (const SpaHandleFactory *factory,
const SpaInterfaceInfo **info,
void **state)
{
int index;
if (factory == NULL || info == NULL || state == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
index = (*state == NULL ? 0 : *(int*)state);
if (index < 0 || index >= SPA_N_ELEMENTS (v4l2_monitor_interfaces))
return SPA_RESULT_ENUM_END;
*info = &v4l2_monitor_interfaces[index];
*(int*)state = ++index;
return SPA_RESULT_OK;
}
const SpaHandleFactory spa_v4l2_monitor_factory =
{ "v4l2-monitor",
NULL,
sizeof (SpaV4l2Monitor),
v4l2_monitor_init,
v4l2_monitor_enum_interface_info,
};

5
spa/plugins/v4l2/v4l2-source.c
View file

@ -44,6 +44,7 @@ static void
reset_v4l2_source_props (SpaV4l2SourceProps *props)
{
strncpy (props->device, default_device, 64);
props->props.unset_mask = 7;
}
#define MAX_BUFFERS 256
@ -793,6 +794,7 @@ spa_v4l2_source_clock_get_time (SpaClock *clock,
static const SpaClock v4l2source_clock = {
NULL,
sizeof (SpaClock),
NULL,
SPA_CLOCK_STATE_STOPPED,
spa_v4l2_source_clock_get_props,
spa_v4l2_source_clock_set_props,
@ -832,7 +834,8 @@ v4l2_source_clear (SpaHandle *handle)
static SpaResult
v4l2_source_init (const SpaHandleFactory *factory,
SpaHandle *handle)
SpaHandle *handle,
const void *config)
{
SpaV4l2Source *this;

5
spa/plugins/v4l2/v4l2-utils.c
View file

@ -31,6 +31,11 @@ spa_v4l2_open (SpaV4l2Source *this)
if (state->opened)
return 0;
if (props->props.unset_mask & 1) {
fprintf(stderr, "Device property not set\n");
return -1;
}
fprintf (stderr, "Playback device is '%s'\n", props->device);
if (stat (props->device, &st) < 0) {

4
spa/plugins/v4l2/v4l2.c
View file

@ -21,6 +21,7 @@
#include <spa/node.h>
extern const SpaHandleFactory spa_v4l2_source_factory;
extern const SpaHandleFactory spa_v4l2_monitor_factory;
SpaResult
spa_enum_handle_factory (const SpaHandleFactory **factory,
@ -37,6 +38,9 @@ spa_enum_handle_factory (const SpaHandleFactory **factory,
case 0:
*factory = &spa_v4l2_source_factory;
break;
case 1:
*factory = &spa_v4l2_monitor_factory;
break;
default:
return SPA_RESULT_ENUM_END;
}

3
spa/plugins/volume/volume.c
View file

@ -676,7 +676,8 @@ volume_clear (SpaHandle *handle)
static SpaResult
volume_init (const SpaHandleFactory *factory,
SpaHandle *handle)
SpaHandle *handle,
const void *config)
{
SpaVolume *this;

3
spa/plugins/xv/xv-sink.c
View file

@ -555,7 +555,8 @@ xv_sink_clear (SpaHandle *handle)
static SpaResult
xv_sink_init (const SpaHandleFactory *factory,
SpaHandle *handle)
SpaHandle *handle,
const void *config)
{
SpaXvSink *this;

4
spa/tests/test-mixer.c
View file

@ -74,11 +74,11 @@ make_node (SpaNode **node, const char *lib, const char *name)
continue;
handle = calloc (1, factory->size);
if ((res = factory->init (factory, handle)) < 0) {
if ((res = spa_handle_factory_init (factory, handle, NULL)) < 0) {
printf ("can't make factory instance: %d\n", res);
return res;
}
if ((res = handle->get_interface (handle, SPA_INTERFACE_ID_NODE, &iface)) < 0) {
if ((res = spa_handle_get_interface (handle, SPA_INTERFACE_ID_NODE, &iface)) < 0) {
printf ("can't get interface %d\n", res);
return res;
}

23
spa/tests/test-v4l2.c
View file

@ -95,11 +95,11 @@ make_node (SpaNode **node, const char *lib, const char *name)
continue;
handle = calloc (1, factory->size);
if ((res = factory->init (factory, handle)) < 0) {
if ((res = spa_handle_factory_init (factory, handle, NULL)) < 0) {
printf ("can't make factory instance: %d\n", res);
return res;
}
if ((res = handle->get_interface (handle, SPA_INTERFACE_ID_NODE, &iface)) < 0) {
if ((res = spa_handle_get_interface (handle, SPA_INTERFACE_ID_NODE, &iface)) < 0) {
printf ("can't get interface %d\n", res);
return res;
}
@ -402,7 +402,6 @@ run_async_source (AppData *data)
{
SpaResult res;
SpaNodeCommand cmd;
bool done = false;
int err;
cmd.type = SPA_NODE_COMMAND_START;
@ -415,23 +414,7 @@ run_async_source (AppData *data)
data->running = false;
}
while (!done) {
SDL_Event event;
while (SDL_PollEvent (&event)) {
switch (event.type) {
case SDL_KEYDOWN:
if (event.key.keysym.sym == SDLK_ESCAPE) {
done = SDL_TRUE;
}
break;
case SDL_QUIT:
done = SDL_TRUE;
break;
}
sleep (1);
}
}
sleep (10);
if (data->running) {
data->running = false;

6
spa/tools/meson.build
View file

@ -3,3 +3,9 @@ executable('spa-inspect', 'spa-inspect.c',
dependencies : [dl_lib],
link_with : spalib,
install : true)
executable('spa-monitor', 'spa-monitor.c',
include_directories : inc,
dependencies : [dl_lib],
link_with : spalib,
install : true)

21
spa/tools/spa-inspect.c
View file

@ -35,18 +35,18 @@ inspect_node (SpaNode *node)
SpaFormat *format;
void *state = NULL;
if ((res = node->get_props (node, &props)) < 0)
if ((res = spa_node_get_props (node, &props)) < 0)
printf ("can't get properties: %d\n", res);
else
spa_debug_props (props, true);
if ((res = node->get_n_ports (node, &n_input, &max_input, &n_output, &max_output)) < 0)
if ((res = spa_node_get_n_ports (node, &n_input, &max_input, &n_output, &max_output)) < 0)
printf ("can't get n_ports: %d\n", res);
else
printf ("supported ports %d %d %d %d\n", n_input, max_input, n_output, max_output);
while (true) {
if ((res = node->port_enum_formats (node, 0, &format, NULL, &state)) < 0) {
if ((res = spa_node_port_enum_formats (node, 0, &format, NULL, &state)) < 0) {
if (res != SPA_RESULT_ENUM_END)
printf ("got error %d\n", res);
break;
@ -54,7 +54,7 @@ inspect_node (SpaNode *node)
if (format)
spa_debug_format (format);
}
if ((res = node->port_get_props (node, 0, &props)) < 0)
if ((res = spa_node_port_get_props (node, 0, &props)) < 0)
printf ("port_get_props error: %d\n", res);
else
spa_debug_props (props, true);
@ -71,12 +71,12 @@ inspect_factory (const SpaHandleFactory *factory)
printf ("factory name:\t\t'%s'\n", factory->name);
printf ("factory info:\n");
if (factory->info)
spa_debug_props (factory->info, true);
spa_debug_dict (factory->info);
else
printf (" none\n");
handle = calloc (1, factory->size);
if ((res = factory->init (factory, handle)) < 0) {
if ((res = spa_handle_factory_init (factory, handle, NULL)) < 0) {
printf ("can't make factory instance: %d\n", res);
return;
}
@ -86,7 +86,7 @@ inspect_factory (const SpaHandleFactory *factory)
while (true) {
const SpaInterfaceInfo *info;
if ((res = factory->enum_interface_info (factory, &info, &state)) < 0) {
if ((res = spa_handle_factory_enum_interface_info (factory, &info, &state)) < 0) {
if (res == SPA_RESULT_ENUM_END)
break;
else
@ -94,7 +94,7 @@ inspect_factory (const SpaHandleFactory *factory)
}
printf (" interface: (%d) '%s' : '%s'\n", info->interface_id, info->name, info->description);
if ((res = handle->get_interface (handle, info->interface_id, &interface)) < 0) {
if ((res = spa_handle_get_interface (handle, info->interface_id, &interface)) < 0) {
printf ("can't get interface: %d\n", res);
continue;
}
@ -118,6 +118,11 @@ main (int argc, char *argv[])
SpaEnumHandleFactoryFunc enum_func;
void *state = NULL;
if (argc < 2) {
printf ("usage: %s <plugin.so>\n", argv[0]);
return -1;
}
if ((handle = dlopen (argv[1], RTLD_NOW)) == NULL) {
printf ("can't load %s\n", argv[1]);
return -1;

229
spa/tools/spa-monitor.c Normal file
View file

@ -0,0 +1,229 @@
/* Pinos
* Copyright (C) 2016 Wim Taymans <wim.taymans@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <dlfcn.h>
#include <errno.h>
#include <poll.h>
#include <spa/monitor.h>
#include <spa/poll.h>
#include <spa/debug.h>
static void
inspect_item (SpaMonitorItem *item)
{
fprintf (stderr, " name: %s\n", item->name);
fprintf (stderr, " class: %s\n", item->klass);
if (item->info)
spa_debug_dict (item->info);
}
typedef struct {
unsigned int n_poll;
SpaPollItem poll[16];
bool rebuild_fds;
SpaPollFd fds[16];
unsigned int n_fds;
} PollData;
static void
on_monitor_event (SpaMonitor *monitor,
SpaMonitorEvent *event,
void *user_data)
{
PollData *data = user_data;
switch (event->type) {
case SPA_MONITOR_EVENT_TYPE_ADDED:
{
SpaMonitorItem *item = event->data;
fprintf (stderr, "added:\n");
inspect_item (item);
break;
}
case SPA_MONITOR_EVENT_TYPE_REMOVED:
{
SpaMonitorItem *item = event->data;
fprintf (stderr, "removed:\n");
inspect_item (item);
break;
}
case SPA_MONITOR_EVENT_TYPE_CHANGED:
{
SpaMonitorItem *item = event->data;
fprintf (stderr, "changed:\n");
inspect_item (item);
break;
}
case SPA_MONITOR_EVENT_TYPE_ADD_POLL:
{
SpaPollItem *item = event->data;
data->poll[data->n_poll] = *item;
data->n_poll++;
if (item->n_fds)
data->rebuild_fds = true;
break;
}
case SPA_MONITOR_EVENT_TYPE_UPDATE_POLL:
break;
case SPA_MONITOR_EVENT_TYPE_REMOVE_POLL:
break;
default:
break;
}
}
static void
handle_monitor (SpaMonitor *monitor)
{
SpaResult res;
void *state = NULL;
PollData data = { 0, };
if (monitor->info)
spa_debug_dict (monitor->info);
while (true) {
SpaMonitorItem *item;
if ((res = spa_monitor_enum_items (monitor, &item, &state)) < 0) {
if (res != SPA_RESULT_ENUM_END)
printf ("spa_monitor_enum_items: got error %d\n", res);
break;
}
inspect_item (item);
}
spa_monitor_set_event_callback (monitor, on_monitor_event, &data);
while (true) {
SpaPollNotifyData ndata;
int i, j, r;
/* rebuild */
if (data.rebuild_fds) {
data.n_fds = 0;
for (i = 0; i < data.n_poll; i++) {
SpaPollItem *p = &data.poll[i];
if (!p->enabled)
continue;
for (j = 0; j < p->n_fds; j++)
data.fds[data.n_fds + j] = p->fds[j];
p->fds = &data.fds[data.n_fds];
data.n_fds += p->n_fds;
}
data.rebuild_fds = false;
}
r = poll ((struct pollfd *) data.fds, data.n_fds, -1);
if (r < 0) {
if (errno == EINTR)
continue;
break;
}
if (r == 0) {
fprintf (stderr, "monitor %p: select timeout", monitor);
break;
}
/* after */
for (i = 0; i < data.n_poll; i++) {
SpaPollItem *p = &data.poll[i];
if (p->enabled && p->after_cb) {
ndata.fds = p->fds;
ndata.n_fds = p->n_fds;
ndata.user_data = p->user_data;
p->after_cb (&ndata);
}
}
}
}
int
main (int argc, char *argv[])
{
SpaResult res;
void *handle;
SpaEnumHandleFactoryFunc enum_func;
void *fstate = NULL;
if (argc < 2) {
printf ("usage: %s <plugin.so>\n", argv[0]);
return -1;
}
if ((handle = dlopen (argv[1], RTLD_NOW)) == NULL) {
printf ("can't load %s\n", argv[1]);
return -1;
}
if ((enum_func = dlsym (handle, "spa_enum_handle_factory")) == NULL) {
printf ("can't find function\n");
return -1;
}
while (true) {
const SpaHandleFactory *factory;
void *istate = NULL;
if ((res = enum_func (&factory, &fstate)) < 0) {
if (res != SPA_RESULT_ENUM_END)
printf ("can't enumerate factories: %d\n", res);
break;
}
while (true) {
const SpaInterfaceInfo *info;
if ((res = spa_handle_factory_enum_interface_info (factory, &info, &istate)) < 0) {
if (res != SPA_RESULT_ENUM_END)
printf ("can't enumerate interfaces: %d\n", res);
break;
}
if (info->interface_id == SPA_INTERFACE_ID_MONITOR) {
SpaHandle *handle;
void *interface;
handle = calloc (1, factory->size);
if ((res = spa_handle_factory_init (factory, handle, NULL)) < 0) {
printf ("can't make factory instance: %d\n", res);
continue;
}
if ((res = spa_handle_get_interface (handle, info->interface_id, &interface)) < 0) {
printf ("can't get interface: %d\n", res);
continue;
}
handle_monitor (interface);
}
}
}
return 0;
}