mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-02 09:01:50 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
pipewire/src/modules/module-client-node/remote-node.c

1214 lines
31 KiB
C
Raw Normal View History

remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
/* PipeWire
*
* Copyright © 2018 Wim Taymans
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <errno.h>
#include <sys/mman.h>
#include <spa/pod/parser.h>
node: improve async handling Remove the done and error callbacks. The error callback is in an error message. The done callback is replace with spa_pending. Make enum_params take a callback and data for the results. This allows us to push the results one after another to the app and avoids ownership issues of the passed data. We can then extend this to handle the async case by doing a _wait call with a spa_pending+callback+data that will be called when the _enum_params returns and async result. Add a sync method. All methods can now return SPA_RESULT_IS_ASYNC return values and you can use spa_node_wait() to register a callback when they complete with optional extra parameters. This makes it easier to sync and handle the reply. Make helper methods to simulate the sync enum_params behaviour for sync nodes. Let the transport generate the sequence number for pw_resource_sync() and pw_proxy_sync(). That way we don't need to keep track of numbers ourselves and we can match the reply to the request easily.
2019-02-20 17:51:05 +01:00
#include <spa/node/utils.h>
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
#include <spa/debug/types.h>
#include "pipewire/pipewire.h"
#include "pipewire/private.h"
#include "extensions/protocol-native.h"
#include "extensions/client-node.h"
#define MAX_MIX 4096
/** \cond */
struct mapping {
void *ptr;
struct pw_map_range map;
int prot;
};
struct mem {
uint32_t id;
int fd;
uint32_t flags;
uint32_t ref;
struct mapping map;
};
struct buffer_mem {
uint32_t mem_id;
struct mapping map;
};
struct buffer {
uint32_t id;
struct spa_buffer *buf;
struct buffer_mem *mem;
uint32_t n_mem;
};
struct mix {
struct spa_list link;
struct pw_port *port;
uint32_t mix_id;
struct pw_port_mix mix;
struct pw_array buffers;
bool active;
};
node: implement activation Make an eventfd for each node and listen for events when the node is activated. Reorganize some graphs links to make it possible to activiate nodes by signaling the eventfd Pass the peer node to each remote node and let the remote node directly activate the peer when needed. Let each node signal the driver node when finished. With this we don't need to go through the daemon to schedule the graph, nodes will simply activate eachother. We only go to the server when there is a server node to schedule. Keep stats about the state of each node and the time it was triggered, running and finished.
2019-02-12 17:42:33 +01:00
struct link {
struct spa_graph_link link;
struct pw_node_activation *activation;
int signalfd;
uint32_t mem_id;
};
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
struct node_data {
struct pw_remote *remote;
struct pw_core *core;
uint32_t remote_id;
int rtwritefd;
struct spa_source *rtsocket_source;
struct mix mix_pool[MAX_MIX];
struct spa_list mix[2];
struct spa_list free_mix;
struct pw_array mems;
struct pw_node *node;
struct spa_hook node_listener;
bool do_free;
struct pw_client_node_proxy *node_proxy;
struct spa_hook node_proxy_listener;
struct spa_hook proxy_listener;
struct spa_io_position *position;
node: implement activation Make an eventfd for each node and listen for events when the node is activated. Reorganize some graphs links to make it possible to activiate nodes by signaling the eventfd Pass the peer node to each remote node and let the remote node directly activate the peer when needed. Let each node signal the driver node when finished. With this we don't need to go through the daemon to schedule the graph, nodes will simply activate eachother. We only go to the server when there is a server node to schedule. Keep stats about the state of each node and the time it was triggered, running and finished.
2019-02-12 17:42:33 +01:00
struct pw_array links;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
};
/** \endcond */
static int
do_remove_source(struct spa_loop *loop,
bool async, uint32_t seq, const void *data, size_t size, void *user_data)
{
struct node_data *d = user_data;
if (d->rtsocket_source) {
pw_loop_destroy_source(d->core->data_loop, d->rtsocket_source);
d->rtsocket_source = NULL;
}
return 0;
}
static void unhandle_socket(struct node_data *data)
{
pw_loop_invoke(data->core->data_loop,
do_remove_source, 1, NULL, 0, true, data);
}
static void
on_rtsocket_condition(void *user_data, int fd, enum spa_io mask)
{
struct pw_proxy *proxy = user_data;
struct node_data *data = proxy->user_data;
if (mask & (SPA_IO_ERR | SPA_IO_HUP)) {
pw_log_warn("got error");
unhandle_socket(data);
return;
}
if (mask & SPA_IO_IN) {
uint64_t cmd;
node: implement activation Make an eventfd for each node and listen for events when the node is activated. Reorganize some graphs links to make it possible to activiate nodes by signaling the eventfd Pass the peer node to each remote node and let the remote node directly activate the peer when needed. Let each node signal the driver node when finished. With this we don't need to go through the daemon to schedule the graph, nodes will simply activate eachother. We only go to the server when there is a server node to schedule. Keep stats about the state of each node and the time it was triggered, running and finished.
2019-02-12 17:42:33 +01:00
if (read(fd, &cmd, sizeof(cmd)) != sizeof(cmd) || cmd != 1)
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
pw_log_warn("proxy %p: read %"PRIu64" failed %m", proxy, cmd);
pw_log_trace("remote %p: process %p", data->remote, proxy);
node: implement activation Make an eventfd for each node and listen for events when the node is activated. Reorganize some graphs links to make it possible to activiate nodes by signaling the eventfd Pass the peer node to each remote node and let the remote node directly activate the peer when needed. Let each node signal the driver node when finished. With this we don't need to go through the daemon to schedule the graph, nodes will simply activate eachother. We only go to the server when there is a server node to schedule. Keep stats about the state of each node and the time it was triggered, running and finished.
2019-02-12 17:42:33 +01:00
spa_graph_node_process(&data->node->rt.root);
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
}
static struct mem *find_mem(struct node_data *data, uint32_t id)
{
struct mem *m;
pw_array_for_each(m, &data->mems) {
if (m->id == id)
return m;
}
return NULL;
}
static struct mem *find_mem_ptr(struct node_data *data, void *ptr)
{
struct mem *m;
pw_array_for_each(m, &data->mems) {
if (m->map.ptr == ptr)
return m;
}
return NULL;
}
static void *mem_map(struct node_data *data, struct mapping *map,
int fd, int prot, uint32_t offset, uint32_t size)
{
struct mapping m;
void *ptr;
pw_map_range_init(&m.map, offset, size, data->core->sc_pagesize);
if (map->ptr == NULL || map->map.offset != m.map.offset || map->map.size != m.map.size) {
node: allocate shared mem for activation Allocate a per node a piece of shared memory where we place the activation structure with the graph state and io_position. We can then give this info to nodes so that they can get the position in the graph directly but also later, activate the next node in the graph.
2019-02-07 12:34:54 +01:00
m.ptr = mmap(map->ptr, m.map.size, prot, MAP_SHARED, fd, m.map.offset);
if (m.ptr == MAP_FAILED) {
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
pw_log_error("remote %p: Failed to mmap memory %d: %m", data, size);
return NULL;
}
map->map = m.map;
node: allocate shared mem for activation Allocate a per node a piece of shared memory where we place the activation structure with the graph state and io_position. We can then give this info to nodes so that they can get the position in the graph directly but also later, activate the next node in the graph.
2019-02-07 12:34:54 +01:00
map->ptr = m.ptr;
pw_log_debug("remote %p: fd %d map %d %d %p", data, fd, m.map.offset, m.map.size, m.ptr);
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
ptr = SPA_MEMBER(map->ptr, map->map.start, void);
node: allocate shared mem for activation Allocate a per node a piece of shared memory where we place the activation structure with the graph state and io_position. We can then give this info to nodes so that they can get the position in the graph directly but also later, activate the next node in the graph.
2019-02-07 12:34:54 +01:00
pw_log_debug("remote %p: fd %d ptr %p (%d %d)", data, fd, ptr, offset, size);
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
return ptr;
}
node: allocate shared mem for activation Allocate a per node a piece of shared memory where we place the activation structure with the graph state and io_position. We can then give this info to nodes so that they can get the position in the graph directly but also later, activate the next node in the graph.
2019-02-07 12:34:54 +01:00
static void *mem_unmap(struct node_data *data, struct mapping *map)
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
{
node: allocate shared mem for activation Allocate a per node a piece of shared memory where we place the activation structure with the graph state and io_position. We can then give this info to nodes so that they can get the position in the graph directly but also later, activate the next node in the graph.
2019-02-07 12:34:54 +01:00
if (map->ptr != NULL) {
if (munmap(map->ptr, map->map.size) < 0)
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
pw_log_warn("failed to unmap: %m");
}
return NULL;
}
static void clear_mem(struct node_data *data, struct mem *m)
{
if (m->fd != -1) {
bool has_ref = false;
int fd;
struct mem *m2;
pw_log_debug("remote %p: clear mem %d", data, m->id);
fd = m->fd;
m->fd = -1;
m->id = SPA_ID_INVALID;
pw_array_for_each(m2, &data->mems) {
if (m2->fd == fd) {
has_ref = true;
break;
}
}
if (!has_ref) {
node: allocate shared mem for activation Allocate a per node a piece of shared memory where we place the activation structure with the graph state and io_position. We can then give this info to nodes so that they can get the position in the graph directly but also later, activate the next node in the graph.
2019-02-07 12:34:54 +01:00
m->map.ptr = mem_unmap(data, &m->map);
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
close(fd);
}
}
}
static void clean_transport(struct node_data *data)
{
struct mem *m;
if (data->rtsocket_source == NULL)
return;
unhandle_socket(data);
pw_array_for_each(m, &data->mems)
clear_mem(data, m);
pw_array_clear(&data->mems);
close(data->rtwritefd);
data->remote_id = SPA_ID_INVALID;
}
static void mix_init(struct mix *mix, struct pw_port *port, uint32_t mix_id)
{
mix->port = port;
mix->mix_id = mix_id;
pw_port_init_mix(port, &mix->mix);
mix->active = false;
pw_array_init(&mix->buffers, 32);
pw_array_ensure_size(&mix->buffers, sizeof(struct buffer) * 64);
}
static int
do_deactivate_mix(struct spa_loop *loop,
bool async, uint32_t seq, const void *data, size_t size, void *user_data)
{
struct mix *mix = user_data;
spa_graph_port_remove(&mix->mix.port);
return 0;
}
static int
deactivate_mix(struct node_data *data, struct mix *mix)
{
if (mix->active) {
pw_log_debug("node %p: mix %p deactivate", data, mix);
pw_loop_invoke(data->core->data_loop,
do_deactivate_mix, SPA_ID_INVALID, NULL, 0, true, mix);
mix->active = false;
}
return 0;
}
static int
do_activate_mix(struct spa_loop *loop,
bool async, uint32_t seq, const void *data, size_t size, void *user_data)
{
struct mix *mix = user_data;
spa_graph_port_add(&mix->port->rt.mix_node, &mix->mix.port);
return 0;
}
static int
activate_mix(struct node_data *data, struct mix *mix)
{
if (!mix->active) {
pw_log_debug("node %p: mix %p activate", data, mix);
pw_loop_invoke(data->core->data_loop,
do_activate_mix, SPA_ID_INVALID, NULL, 0, false, mix);
mix->active = true;
}
return 0;
}
static struct mix *find_mix(struct node_data *data,
enum spa_direction direction, uint32_t port_id, uint32_t mix_id)
{
struct mix *mix;
spa_list_for_each(mix, &data->mix[direction], link) {
if (mix->port->port_id == port_id &&
mix->mix_id == mix_id)
return mix;
}
return NULL;
}
static struct mix *ensure_mix(struct node_data *data,
enum spa_direction direction, uint32_t port_id, uint32_t mix_id)
{
struct mix *mix;
struct pw_port *port;
if ((mix = find_mix(data, direction, port_id, mix_id)))
return mix;
if (spa_list_is_empty(&data->free_mix))
return NULL;
port = pw_node_find_port(data->node, direction, port_id);
if (port == NULL)
return NULL;
mix = spa_list_first(&data->free_mix, struct mix, link);
spa_list_remove(&mix->link);
mix_init(mix, port, mix_id);
spa_list_append(&data->mix[direction], &mix->link);
return mix;
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int client_node_add_mem(void *object,
uint32_t mem_id,
uint32_t type, int memfd, uint32_t flags)
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
{
struct pw_proxy *proxy = object;
struct node_data *data = proxy->user_data;
struct mem *m;
m = find_mem(data, mem_id);
if (m) {
pw_log_warn("duplicate mem %u, fd %d, flags %d",
mem_id, memfd, flags);
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return -EINVAL;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
m = pw_array_add(&data->mems, sizeof(struct mem));
pw_log_debug("add mem %u, fd %d, flags %d", mem_id, memfd, flags);
m->id = mem_id;
m->fd = memfd;
m->flags = flags;
m->ref = 0;
m->map.map = PW_MAP_RANGE_INIT;
m->map.ptr = NULL;
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return 0;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int client_node_transport(void *object, uint32_t node_id,
int readfd, int writefd)
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
{
struct pw_proxy *proxy = object;
struct node_data *data = proxy->user_data;
struct pw_remote *remote = proxy->remote;
clean_transport(data);
data->remote_id = node_id;
pw_log_debug("remote-node %p: create transport with fds %d %d for node %u",
proxy, readfd, writefd, node_id);
data->rtwritefd = writefd;
data->rtsocket_source = pw_loop_add_io(remote->core->data_loop,
readfd,
SPA_IO_ERR | SPA_IO_HUP,
true, on_rtsocket_condition, proxy);
if (data->node->active)
pw_client_node_proxy_set_active(data->node_proxy, true);
more async improvements Make the sequence number an int. Keep track of the last received seq number and pass it in error replies. Pass seq in for_each methods.
2019-02-25 16:25:27 +01:00
pw_remote_emit_exported(remote, proxy->id, node_id);
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return 0;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
client-node: pass spa_node_info along Pass the complete spa_node_info to update node information. Remove the redundant max/min port info. Update the remote node based on port and node update events.
2019-03-04 12:30:45 +01:00
static int add_node_update(struct pw_proxy *proxy, uint32_t change_mask)
{
struct node_data *data = proxy->user_data;
struct pw_node *node = data->node;
struct spa_node_info ni = SPA_NODE_INFO_INIT();
uint32_t n_params = 0;
struct spa_pod **params = NULL;
int res;
if (change_mask & PW_CLIENT_NODE_UPDATE_PARAMS) {
uint32_t i, idx, id;
uint8_t buf[2048];
struct spa_pod_builder b = { 0 };
for (i = 0; i < node->info.n_params; i++) {
struct spa_pod *param;
id = node->info.params[i].id;
for (idx = 0;;) {
spa_pod_builder_init(&b, buf, sizeof(buf));
if (spa_node_enum_params_sync(node->node,
id, &idx,
NULL, &param, &b) != 1)
break;
params = realloc(params, sizeof(struct spa_pod *) * (n_params + 1));
params[n_params++] = spa_pod_copy(param);
}
}
}
if (change_mask & PW_CLIENT_NODE_UPDATE_INFO) {
ni.max_input_ports = node->info.max_input_ports;
ni.max_output_ports = node->info.max_output_ports;
ni.change_mask = SPA_NODE_CHANGE_MASK_FLAGS |
SPA_NODE_CHANGE_MASK_PROPS |
SPA_NODE_CHANGE_MASK_PARAMS;
ni.flags = 0;
ni.props = node->info.props;
ni.params = node->info.params;
ni.n_params = node->info.n_params;
}
res = pw_client_node_proxy_update(data->node_proxy,
change_mask,
n_params,
(const struct spa_pod **)params,
&ni);
if (params) {
while (n_params > 0)
free(params[--n_params]);
free(params);
}
return res;
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int add_port_update(struct pw_proxy *proxy, struct pw_port *port, uint32_t change_mask)
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
{
struct node_data *data = proxy->user_data;
node: Add port_info event Add a port_info event. With this, we get updates to ports pushed to us, which is more convenient and also allows for better dynamic add/remove of ports. We don't need to the PortChanged event anymore We can remove the get_port_ids/get_n_ports/port_get_info methods. Update plugins
2019-02-14 17:08:46 +01:00
struct spa_port_info pi = SPA_PORT_INFO_INIT();
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
uint32_t n_params = 0;
struct spa_pod **params = NULL;
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
int res;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
if (change_mask & PW_CLIENT_NODE_PORT_UPDATE_PARAMS) {
client-node: pass spa_node_info along Pass the complete spa_node_info to update node information. Remove the redundant max/min port info. Update the remote node based on port and node update events.
2019-03-04 12:30:45 +01:00
uint32_t i, idx, id;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
uint8_t buf[2048];
struct spa_pod_builder b = { 0 };
node: add port and node params Add a new struct spa_param_info that lists the available params on a node/port and if they are readable/writable/updated. We can use this to replace and improve the PARAM_List and also to notify property change and updates. Update elements and code to deal with this new param stuff. Add port and node info to most elements and signal changes. Use async enum_params in -inspect and use the param info to know which ones to enumerate. Use the port info to know what parameters to update in the remote-node.
2019-02-27 16:43:01 +01:00
for (i = 0; i < port->info.n_params; i++) {
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
struct spa_pod *param;
node: add port and node params Add a new struct spa_param_info that lists the available params on a node/port and if they are readable/writable/updated. We can use this to replace and improve the PARAM_List and also to notify property change and updates. Update elements and code to deal with this new param stuff. Add port and node info to most elements and signal changes. Use async enum_params in -inspect and use the param info to know which ones to enumerate. Use the port info to know what parameters to update in the remote-node.
2019-02-27 16:43:01 +01:00
id = port->info.params[i].id;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
client-node: pass spa_node_info along Pass the complete spa_node_info to update node information. Remove the redundant max/min port info. Update the remote node based on port and node update events.
2019-03-04 12:30:45 +01:00
for (idx = 0;;) {
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
spa_pod_builder_init(&b, buf, sizeof(buf));
node: improve async handling Remove the done and error callbacks. The error callback is in an error message. The done callback is replace with spa_pending. Make enum_params take a callback and data for the results. This allows us to push the results one after another to the app and avoids ownership issues of the passed data. We can then extend this to handle the async case by doing a _wait call with a spa_pending+callback+data that will be called when the _enum_params returns and async result. Add a sync method. All methods can now return SPA_RESULT_IS_ASYNC return values and you can use spa_node_wait() to register a callback when they complete with optional extra parameters. This makes it easier to sync and handle the reply. Make helper methods to simulate the sync enum_params behaviour for sync nodes. Let the transport generate the sequence number for pw_resource_sync() and pw_proxy_sync(). That way we don't need to keep track of numbers ourselves and we can match the reply to the request easily.
2019-02-20 17:51:05 +01:00
if (spa_node_port_enum_params_sync(port->node->node,
Improve async handling Don't use special callback in node to receive the results. Instead, use a generic result callback to receive the result. This makes things a bit more symetric and generic again because then you can choose how to match the result to the request and you have a generic way to handle both the sync and async case. We can then also remove the wait method. This also makes the remote interface and spa interface to objects very similar. Make a helper object to receive and dispatch results. Use this in the helper for enum_params. Make device use the same result callbacks.
2019-02-25 12:29:57 +01:00
port->direction, port->port_id,
client-node: pass spa_node_info along Pass the complete spa_node_info to update node information. Remove the redundant max/min port info. Update the remote node based on port and node update events.
2019-03-04 12:30:45 +01:00
id, &idx,
node: make add_listener method Make struct spa_node_events for events emited from the main thread and keep the spa_node_callbacks for the data thread callbacks. The add_listener method installs the events and it's possible to install multiple handles. Adding a listener first emits the info and port_info events when installed, similar to how the PipeWire proxy bind works. This removes the need for the spa_pending_queue and makes it easier to implement the _sync versions. Add some helpers to make it easier for plugins to emit all the info to new listeners. Use the listeners for devices as well.
2019-03-01 12:00:42 +01:00
NULL, &param, &b) != 1)
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
break;
params = realloc(params, sizeof(struct spa_pod *) * (n_params + 1));
node: improve async handling Remove the done and error callbacks. The error callback is in an error message. The done callback is replace with spa_pending. Make enum_params take a callback and data for the results. This allows us to push the results one after another to the app and avoids ownership issues of the passed data. We can then extend this to handle the async case by doing a _wait call with a spa_pending+callback+data that will be called when the _enum_params returns and async result. Add a sync method. All methods can now return SPA_RESULT_IS_ASYNC return values and you can use spa_node_wait() to register a callback when they complete with optional extra parameters. This makes it easier to sync and handle the reply. Make helper methods to simulate the sync enum_params behaviour for sync nodes. Let the transport generate the sequence number for pw_resource_sync() and pw_proxy_sync(). That way we don't need to keep track of numbers ourselves and we can match the reply to the request easily.
2019-02-20 17:51:05 +01:00
params[n_params++] = spa_pod_copy(param);
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
}
}
if (change_mask & PW_CLIENT_NODE_PORT_UPDATE_INFO) {
node: Add port_info event Add a port_info event. With this, we get updates to ports pushed to us, which is more convenient and also allows for better dynamic add/remove of ports. We don't need to the PortChanged event anymore We can remove the get_port_ids/get_n_ports/port_get_info methods. Update plugins
2019-02-14 17:08:46 +01:00
pi.change_mask = SPA_PORT_CHANGE_MASK_FLAGS |
SPA_PORT_CHANGE_MASK_RATE |
client-node: also send param idss
2019-03-04 17:54:17 +01:00
SPA_PORT_CHANGE_MASK_PROPS |
SPA_PORT_CHANGE_MASK_PARAMS;
node: Add port_info event Add a port_info event. With this, we get updates to ports pushed to us, which is more convenient and also allows for better dynamic add/remove of ports. We don't need to the PortChanged event anymore We can remove the get_port_ids/get_n_ports/port_get_info methods. Update plugins
2019-02-14 17:08:46 +01:00
pi.flags = port->spa_flags;
node: make add_listener method Make struct spa_node_events for events emited from the main thread and keep the spa_node_callbacks for the data thread callbacks. The add_listener method installs the events and it's possible to install multiple handles. Adding a listener first emits the info and port_info events when installed, similar to how the PipeWire proxy bind works. This removes the need for the spa_pending_queue and makes it easier to implement the _sync versions. Add some helpers to make it easier for plugins to emit all the info to new listeners. Use the listeners for devices as well.
2019-03-01 12:00:42 +01:00
pi.rate = SPA_FRACTION(0, 1);
node: Add port_info event Add a port_info event. With this, we get updates to ports pushed to us, which is more convenient and also allows for better dynamic add/remove of ports. We don't need to the PortChanged event anymore We can remove the get_port_ids/get_n_ports/port_get_info methods. Update plugins
2019-02-14 17:08:46 +01:00
pi.props = &port->properties->dict;
node: add max_ports to node info
2019-02-14 17:40:01 +01:00
pi.flags &= ~SPA_PORT_FLAG_CAN_ALLOC_BUFFERS;
client-node: also send param idss
2019-03-04 17:54:17 +01:00
pi.n_params = port->info.n_params;
pi.params = port->info.params;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
res = pw_client_node_proxy_port_update(data->node_proxy,
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
port->direction,
port->port_id,
change_mask,
n_params,
(const struct spa_pod **)params,
&pi);
if (params) {
while (n_params > 0)
free(params[--n_params]);
free(params);
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return res;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int
client_node_set_param(void *object, uint32_t id, uint32_t flags,
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
const struct spa_pod *param)
{
pw_log_warn("set param not implemented");
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return -ENOTSUP;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
client_node_set_io(void *object,
uint32_t id,
uint32_t memid,
uint32_t offset,
uint32_t size)
{
struct pw_proxy *proxy = object;
struct node_data *data = proxy->user_data;
struct mem *m;
void *ptr;
if (memid == SPA_ID_INVALID) {
ptr = NULL;
size = 0;
}
else {
m = find_mem(data, memid);
if (m == NULL) {
pw_log_warn("unknown memory id %u", memid);
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return -EINVAL;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
ptr = mem_map(data, &m->map, m->fd,
PROT_READ|PROT_WRITE, offset, size);
if (ptr == NULL)
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return -errno;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
m->ref++;
}
pw_log_debug("node %p: set io %s %p", proxy,
spa_debug_type_find_name(spa_type_io, id), ptr);
if (id == SPA_IO_Position) {
if (ptr == NULL && data->position) {
m = find_mem_ptr(data, data->position);
if (m && --m->ref == 0)
clear_mem(data, m);
}
data->position = ptr;
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return spa_node_set_io(data->node->node, id, ptr, size);
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int client_node_event(void *object, const struct spa_event *event)
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
{
pw_log_warn("unhandled node event %d", SPA_EVENT_TYPE(event));
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return -ENOTSUP;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
static int
do_pause_source(struct spa_loop *loop,
bool async, uint32_t seq, const void *data, size_t size, void *user_data)
{
struct node_data *d = user_data;
pw_loop_update_io(d->core->data_loop,
d->rtsocket_source,
SPA_IO_ERR | SPA_IO_HUP);
return 0;
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int client_node_command(void *object, const struct spa_command *command)
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
{
struct pw_proxy *proxy = object;
struct node_data *data = proxy->user_data;
struct pw_remote *remote = proxy->remote;
int res;
switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_NODE_COMMAND_Pause:
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
pw_log_debug("node %p: pause", proxy);
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
if (data->rtsocket_source) {
pw_loop_invoke(data->core->data_loop,
do_pause_source, 1, NULL, 0, true, data);
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
if ((res = pw_node_set_state(data->node, PW_NODE_STATE_IDLE)) < 0) {
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
pw_log_warn("node %p: pause failed", proxy);
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
pw_proxy_error(proxy, res, "pause failed");
}
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
break;
case SPA_NODE_COMMAND_Start:
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
pw_log_debug("node %p: start", proxy);
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
node: implement activation Make an eventfd for each node and listen for events when the node is activated. Reorganize some graphs links to make it possible to activiate nodes by signaling the eventfd Pass the peer node to each remote node and let the remote node directly activate the peer when needed. Let each node signal the driver node when finished. With this we don't need to go through the daemon to schedule the graph, nodes will simply activate eachother. We only go to the server when there is a server node to schedule. Keep stats about the state of each node and the time it was triggered, running and finished.
2019-02-12 17:42:33 +01:00
if ((res = pw_node_set_state(data->node, PW_NODE_STATE_RUNNING)) < 0) {
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
pw_log_warn("node %p: start failed", proxy);
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
pw_proxy_error(proxy, res, "start failed");
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
else if (data->rtsocket_source) {
pw_loop_update_io(remote->core->data_loop,
data->rtsocket_source,
SPA_IO_IN | SPA_IO_ERR | SPA_IO_HUP);
}
break;
default:
pw_log_warn("unhandled node command %d", SPA_NODE_COMMAND_ID(command));
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
res = -ENOTSUP;
pw_proxy_error(proxy, res, "command %d not supported", SPA_NODE_COMMAND_ID(command));
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return res;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int
node: add props to add_port
2019-02-18 13:22:46 +01:00
client_node_add_port(void *object, enum spa_direction direction, uint32_t port_id,
const struct spa_dict *props)
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
{
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
struct pw_proxy *proxy = object;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
pw_log_warn("add port not supported");
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
pw_proxy_error(proxy, -ENOTSUP, "add port not supported");
return -ENOTSUP;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int
client_node_remove_port(void *object, enum spa_direction direction, uint32_t port_id)
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
{
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
struct pw_proxy *proxy = object;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
pw_log_warn("remove port not supported");
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
pw_proxy_error(proxy, -ENOTSUP, "remove port not supported");
return -ENOTSUP;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int clear_buffers(struct node_data *data, struct mix *mix)
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
{
struct pw_port *port = mix->port;
struct buffer *b;
uint32_t i;
int res;
pw_log_debug("port %p: clear buffers %d", port, mix->mix_id);
if ((res = pw_port_use_buffers(port, mix->mix_id, NULL, 0)) < 0) {
pw_log_error("port %p: error clear buffers %s", port, spa_strerror(res));
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return res;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
pw_array_for_each(b, &mix->buffers) {
for (i = 0; i < b->n_mem; i++) {
struct buffer_mem *bm = &b->mem[i];
struct mem *m;
pw_log_debug("port %p: clear buffer %d mem %d",
port, b->id, bm->mem_id);
m = find_mem(data, bm->mem_id);
if (m && --m->ref == 0)
clear_mem(data, m);
}
b->n_mem = 0;
free(b->buf);
}
mix->buffers.size = 0;
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return 0;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
client_node_port_set_param(void *object,
enum spa_direction direction, uint32_t port_id,
uint32_t id, uint32_t flags,
const struct spa_pod *param)
{
struct pw_proxy *proxy = object;
struct node_data *data = proxy->user_data;
struct pw_port *port;
int res;
port = pw_node_find_port(data->node, direction, port_id);
if (port == NULL) {
res = -EINVAL;
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
pw_proxy_error(proxy, res, "unknown port");
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
goto done;
}
pw_log_debug("port %p: set param %d %p", port, id, param);
if (id == SPA_PARAM_Format) {
struct mix *mix;
spa_list_for_each(mix, &data->mix[direction], link) {
if (mix->port->port_id == port_id)
clear_buffers(data, mix);
}
}
res = pw_port_set_param(port, SPA_ID_INVALID, id, flags, param);
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
if (res < 0) {
pw_proxy_error(proxy, res, "can't set port param: %s", spa_strerror(res));
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
goto done;
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
}
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
done:
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return res;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
client_node_port_use_buffers(void *object,
enum spa_direction direction, uint32_t port_id, uint32_t mix_id,
uint32_t n_buffers, struct pw_client_node_buffer *buffers)
{
struct pw_proxy *proxy = object;
struct node_data *data = proxy->user_data;
struct buffer *bid;
uint32_t i, j;
struct spa_buffer *b, **bufs;
struct mix *mix;
int res, prot;
mix = ensure_mix(data, direction, port_id, mix_id);
if (mix == NULL) {
res = -EINVAL;
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
pw_proxy_error(proxy, res, "can add mix");
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
goto done;
}
prot = PROT_READ | (direction == SPA_DIRECTION_OUTPUT ? PROT_WRITE : 0);
/* clear previous buffers */
clear_buffers(data, mix);
bufs = alloca(n_buffers * sizeof(struct spa_buffer *));
for (i = 0; i < n_buffers; i++) {
struct buffer_mem bmem = { 0, };
size_t size;
off_t offset;
struct mem *m;
m = find_mem(data, buffers[i].mem_id);
if (m == NULL) {
pw_log_error("unknown memory id %u", buffers[i].mem_id);
res = -EINVAL;
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
pw_proxy_error(proxy, res, "unknown memory %u", buffers[i].mem_id);
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
goto cleanup;
}
bid = pw_array_add(&mix->buffers, sizeof(struct buffer));
bid->id = i;
bmem.mem_id = m->id;
bmem.map.ptr = mem_map(data, &bmem.map, m->fd, prot,
buffers[i].offset, buffers[i].size);
if (bmem.map.ptr == NULL) {
res = -errno;
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
pw_proxy_error(proxy, res, "can't mmap memory: %s", spa_strerror(res));
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
goto cleanup;
}
if (mlock(bmem.map.ptr, bmem.map.map.size) < 0)
pw_log_warn("Failed to mlock memory %u %u: %m",
bmem.map.map.offset, bmem.map.map.size);
size = sizeof(struct spa_buffer);
size += sizeof(struct buffer_mem);
for (j = 0; j < buffers[i].buffer->n_metas; j++)
size += sizeof(struct spa_meta);
for (j = 0; j < buffers[i].buffer->n_datas; j++) {
size += sizeof(struct spa_data);
size += sizeof(struct buffer_mem);
}
b = bid->buf = malloc(size);
if (b == NULL) {
res = -ENOMEM;
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
pw_proxy_error(proxy, res, "can't alloc memory: %s", spa_strerror(res));
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
goto cleanup;
}
memcpy(b, buffers[i].buffer, sizeof(struct spa_buffer));
b->metas = SPA_MEMBER(b, sizeof(struct spa_buffer), struct spa_meta);
b->datas = SPA_MEMBER(b->metas, sizeof(struct spa_meta) * b->n_metas,
struct spa_data);
bid->mem = SPA_MEMBER(b->datas, sizeof(struct spa_data) * b->n_datas,
struct buffer_mem);
bid->n_mem = 0;
bid->mem[bid->n_mem++] = bmem;
m->ref++;
pw_log_debug("add buffer %d %d %u %u", m->id,
bid->id, bmem.map.map.offset, bmem.map.map.size);
offset = 0;
for (j = 0; j < b->n_metas; j++) {
struct spa_meta *m = &b->metas[j];
memcpy(m, &buffers[i].buffer->metas[j], sizeof(struct spa_meta));
m->data = SPA_MEMBER(bmem.map.ptr, offset, void);
offset += SPA_ROUND_UP_N(m->size, 8);
}
for (j = 0; j < b->n_datas; j++) {
struct spa_data *d = &b->datas[j];
memcpy(d, &buffers[i].buffer->datas[j], sizeof(struct spa_data));
d->chunk =
SPA_MEMBER(bmem.map.ptr, offset + sizeof(struct spa_chunk) * j,
struct spa_chunk);
if (d->type == SPA_DATA_MemFd || d->type == SPA_DATA_DmaBuf) {
uint32_t mem_id = SPA_PTR_TO_UINT32(d->data);
struct mem *bm = find_mem(data, mem_id);
struct buffer_mem bm2;
if (bm == NULL) {
pw_log_error("unknown buffer mem %u", mem_id);
res = -EINVAL;
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
pw_proxy_error(proxy, res, "unknown buffer mem %u", mem_id);
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
goto cleanup;
}
d->fd = bm->fd;
bm->ref++;
bm2.mem_id = bm->id;
bm2.map.ptr = NULL;
d->data = bm2.map.ptr;
bid->mem[bid->n_mem++] = bm2;
pw_log_debug(" data %d %u -> fd %d maxsize %d",
j, bm->id, bm->fd, d->maxsize);
} else if (d->type == SPA_DATA_MemPtr) {
int offs = SPA_PTR_TO_INT(d->data);
d->data = SPA_MEMBER(bmem.map.ptr, offs, void);
d->fd = -1;
pw_log_debug(" data %d %u -> mem %p maxsize %d",
j, bid->id, d->data, d->maxsize);
} else {
pw_log_warn("unknown buffer data type %d", d->type);
}
}
bufs[i] = b;
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
if ((res = pw_port_use_buffers(mix->port, mix->mix_id, bufs, n_buffers)) < 0)
pw_proxy_error(proxy, res, "can't use buffers: %s", spa_strerror(res));
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
done:
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return res;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
cleanup:
clear_buffers(data, mix);
goto done;
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
client_node_port_set_io(void *object,
uint32_t direction,
uint32_t port_id,
uint32_t mix_id,
uint32_t id,
uint32_t memid,
uint32_t offset,
uint32_t size)
{
struct pw_proxy *proxy = object;
struct node_data *data = proxy->user_data;
struct mix *mix;
struct mem *m;
void *ptr;
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
int res = 0;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
mix = ensure_mix(data, direction, port_id, mix_id);
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
if (mix == NULL) {
res = -EINVAL;
pw_proxy_error(proxy, res, "can't get mixer: %s", spa_strerror(res));
return res;
}
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
if (memid == SPA_ID_INVALID) {
ptr = NULL;
size = 0;
}
else {
m = find_mem(data, memid);
if (m == NULL) {
pw_log_warn("unknown memory id %u", memid);
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
res = -EINVAL;
pw_proxy_error(proxy, res, "unknown memory id %u", memid);
return res;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
ptr = mem_map(data, &m->map, m->fd,
PROT_READ|PROT_WRITE, offset, size);
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
if (ptr == NULL) {
res = -errno;
pw_proxy_error(proxy, res, "mmap failed: %s", spa_strerror(res));
return res;
}
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
m->ref++;
}
pw_log_debug("port %p: set io %s %p", mix->port,
spa_debug_type_find_name(spa_type_io, id), ptr);
if (id == SPA_IO_Buffers) {
if (ptr == NULL && mix->mix.io) {
deactivate_mix(data, mix);
m = find_mem_ptr(data, mix->mix.io);
if (m && --m->ref == 0)
clear_mem(data, m);
}
mix->mix.io = ptr;
if (ptr)
activate_mix(data, mix);
} else {
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
if ((res = spa_node_port_set_io(mix->port->node->node,
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
direction, port_id,
id,
ptr,
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
size)) < 0)
pw_proxy_error(proxy, res, "set_io failed: %s", spa_strerror(res));
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return res;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
node: implement activation Make an eventfd for each node and listen for events when the node is activated. Reorganize some graphs links to make it possible to activiate nodes by signaling the eventfd Pass the peer node to each remote node and let the remote node directly activate the peer when needed. Let each node signal the driver node when finished. With this we don't need to go through the daemon to schedule the graph, nodes will simply activate eachother. We only go to the server when there is a server node to schedule. Keep stats about the state of each node and the time it was triggered, running and finished.
2019-02-12 17:42:33 +01:00
#if 0
static int link_signal_func(void *user_data)
{
struct link *link = user_data;
uint64_t cmd = 1;
pw_log_trace("link %p: signal", link);
if (write(link->signalfd, &cmd, sizeof(cmd)) != sizeof(cmd))
pw_log_warn("link %p: write failed %m", link);
return 0;
}
#endif
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
static int
node: implement activation Make an eventfd for each node and listen for events when the node is activated. Reorganize some graphs links to make it possible to activiate nodes by signaling the eventfd Pass the peer node to each remote node and let the remote node directly activate the peer when needed. Let each node signal the driver node when finished. With this we don't need to go through the daemon to schedule the graph, nodes will simply activate eachother. We only go to the server when there is a server node to schedule. Keep stats about the state of each node and the time it was triggered, running and finished.
2019-02-12 17:42:33 +01:00
client_node_set_activation(void *object,
uint32_t node_id,
int signalfd,
uint32_t memid,
uint32_t offset,
uint32_t size)
{
struct pw_proxy *proxy = object;
struct node_data *data = proxy->user_data;
struct pw_node *node = data->node;
struct mem *m;
struct pw_node_activation *ptr;
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
int res = 0;
node: implement activation Make an eventfd for each node and listen for events when the node is activated. Reorganize some graphs links to make it possible to activiate nodes by signaling the eventfd Pass the peer node to each remote node and let the remote node directly activate the peer when needed. Let each node signal the driver node when finished. With this we don't need to go through the daemon to schedule the graph, nodes will simply activate eachother. We only go to the server when there is a server node to schedule. Keep stats about the state of each node and the time it was triggered, running and finished.
2019-02-12 17:42:33 +01:00
if (memid == SPA_ID_INVALID) {
ptr = NULL;
size = 0;
}
else {
m = find_mem(data, memid);
if (m == NULL) {
pw_log_warn("unknown memory id %u", memid);
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
res = -EINVAL;
pw_proxy_error(proxy, res, "unknown memory id %u", memid);
return res;
node: implement activation Make an eventfd for each node and listen for events when the node is activated. Reorganize some graphs links to make it possible to activiate nodes by signaling the eventfd Pass the peer node to each remote node and let the remote node directly activate the peer when needed. Let each node signal the driver node when finished. With this we don't need to go through the daemon to schedule the graph, nodes will simply activate eachother. We only go to the server when there is a server node to schedule. Keep stats about the state of each node and the time it was triggered, running and finished.
2019-02-12 17:42:33 +01:00
}
ptr = mem_map(data, &m->map, m->fd,
PROT_READ|PROT_WRITE, offset, size);
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
if (ptr == NULL) {
res = -errno;
pw_proxy_error(proxy, res, "mmap failed: %s", spa_strerror(res));
return res;
}
node: implement activation Make an eventfd for each node and listen for events when the node is activated. Reorganize some graphs links to make it possible to activiate nodes by signaling the eventfd Pass the peer node to each remote node and let the remote node directly activate the peer when needed. Let each node signal the driver node when finished. With this we don't need to go through the daemon to schedule the graph, nodes will simply activate eachother. We only go to the server when there is a server node to schedule. Keep stats about the state of each node and the time it was triggered, running and finished.
2019-02-12 17:42:33 +01:00
m->ref++;
}
pw_log_debug("node %p: set activation %d", node, node_id);
#if 0
if (ptr) {
struct link *link;
link = pw_array_add(&data->links, sizeof(struct link));
link->activation = ptr;
link->signalfd = signalfd;
link->link.signal = link_signal_func;
link->link.signal_data = link;
spa_graph_link_add(&node->rt.root, &link->activation->state[0], &link->link);
pw_log_debug("node %p: required %d, pending %d", node,
link->link.state->required,
link->link.state->pending);
}
#endif
interfaces: improve remote API Add return values to events and method callbacks. This makes it possible to pass any error or async return value. Add sync/done/error in both directions so that both proxy and resource and perform/reply sync and produce errors. Return a SPA_ASYNC from remote method calls (and events), keep the sequence number in the connection. With the core sync/done we can remove the client-node done method and it's internal sequence number along with the seq number in method calls. We can also use the method/event async return value to perform a sync with as the unique sequence number for this method. Add sync method and done/error event to proxy and resource.
2019-02-18 12:31:36 +01:00
return res;
node: implement activation Make an eventfd for each node and listen for events when the node is activated. Reorganize some graphs links to make it possible to activiate nodes by signaling the eventfd Pass the peer node to each remote node and let the remote node directly activate the peer when needed. Let each node signal the driver node when finished. With this we don't need to go through the daemon to schedule the graph, nodes will simply activate eachother. We only go to the server when there is a server node to schedule. Keep stats about the state of each node and the time it was triggered, running and finished.
2019-02-12 17:42:33 +01:00
}
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
static const struct pw_client_node_proxy_events client_node_events = {
PW_VERSION_CLIENT_NODE_PROXY_EVENTS,
.add_mem = client_node_add_mem,
.transport = client_node_transport,
.set_param = client_node_set_param,
.set_io = client_node_set_io,
.event = client_node_event,
.command = client_node_command,
.add_port = client_node_add_port,
.remove_port = client_node_remove_port,
.port_set_param = client_node_port_set_param,
.port_use_buffers = client_node_port_use_buffers,
.port_set_io = client_node_port_set_io,
node: implement activation Make an eventfd for each node and listen for events when the node is activated. Reorganize some graphs links to make it possible to activiate nodes by signaling the eventfd Pass the peer node to each remote node and let the remote node directly activate the peer when needed. Let each node signal the driver node when finished. With this we don't need to go through the daemon to schedule the graph, nodes will simply activate eachother. We only go to the server when there is a server node to schedule. Keep stats about the state of each node and the time it was triggered, running and finished.
2019-02-12 17:42:33 +01:00
.set_activation = client_node_set_activation,
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
};
static void do_node_init(struct pw_proxy *proxy)
{
struct node_data *data = proxy->user_data;
struct pw_port *port;
pw_log_debug("%p: init", data);
client-node: pass spa_node_info along Pass the complete spa_node_info to update node information. Remove the redundant max/min port info. Update the remote node based on port and node update events.
2019-03-04 12:30:45 +01:00
add_node_update(proxy, PW_CLIENT_NODE_UPDATE_PARAMS |
PW_CLIENT_NODE_UPDATE_INFO);
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
spa_list_for_each(port, &data->node->input_ports, link) {
add_port_update(proxy, port,
PW_CLIENT_NODE_PORT_UPDATE_PARAMS |
PW_CLIENT_NODE_PORT_UPDATE_INFO);
}
spa_list_for_each(port, &data->node->output_ports, link) {
add_port_update(proxy, port,
PW_CLIENT_NODE_PORT_UPDATE_PARAMS |
PW_CLIENT_NODE_PORT_UPDATE_INFO);
}
}
static void clear_mix(struct node_data *data, struct mix *mix)
{
clear_buffers(data, mix);
pw_array_clear(&mix->buffers);
deactivate_mix(data, mix);
spa_list_remove(&mix->link);
spa_list_append(&data->free_mix, &mix->link);
}
static void clean_node(struct node_data *d)
{
struct mix *mix, *tmp;
if (d->remote_id != SPA_ID_INVALID) {
spa_list_for_each_safe(mix, tmp, &d->mix[SPA_DIRECTION_INPUT], link)
clear_mix(d, mix);
spa_list_for_each_safe(mix, tmp, &d->mix[SPA_DIRECTION_OUTPUT], link)
clear_mix(d, mix);
}
clean_transport(d);
}
static void node_destroy(void *data)
{
struct node_data *d = data;
struct pw_remote *remote = d->remote;
struct pw_proxy *proxy = (struct pw_proxy*) d->node_proxy;
pw_log_debug("%p: destroy", d);
if (remote->core_proxy)
pw_core_proxy_destroy(remote->core_proxy, proxy);
clean_node(d);
spa_hook_remove(&d->proxy_listener);
}
static void node_info_changed(void *data, const struct pw_node_info *info)
{
struct node_data *d = data;
uint32_t change_mask = 0;
pw_log_debug("info changed %p", d);
client-node: pass spa_node_info along Pass the complete spa_node_info to update node information. Remove the redundant max/min port info. Update the remote node based on port and node update events.
2019-03-04 12:30:45 +01:00
if (info->change_mask & PW_NODE_CHANGE_MASK_PROPS)
change_mask |= PW_CLIENT_NODE_UPDATE_INFO;
if (info->change_mask & PW_NODE_CHANGE_MASK_PARAMS) {
change_mask |= PW_CLIENT_NODE_UPDATE_PARAMS;
change_mask |= PW_CLIENT_NODE_UPDATE_INFO;
}
add_node_update((struct pw_proxy*)d->node_proxy, change_mask);
}
static void node_port_info_changed(void *data, struct pw_port *port,
const struct pw_port_info *info)
{
struct node_data *d = data;
uint32_t change_mask = 0;
pw_log_debug("info changed %p", d);
if (info->change_mask & PW_PORT_CHANGE_MASK_PROPS)
change_mask |= PW_CLIENT_NODE_PORT_UPDATE_INFO;
if (info->change_mask & PW_PORT_CHANGE_MASK_PARAMS) {
change_mask |= PW_CLIENT_NODE_PORT_UPDATE_PARAMS;
change_mask |= PW_CLIENT_NODE_PORT_UPDATE_INFO;
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
client-node: pass spa_node_info along Pass the complete spa_node_info to update node information. Remove the redundant max/min port info. Update the remote node based on port and node update events.
2019-03-04 12:30:45 +01:00
add_port_update((struct pw_proxy*)d->node_proxy, port, change_mask);
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
}
static void node_active_changed(void *data, bool active)
{
struct node_data *d = data;
pw_log_debug("active %d", active);
pw_client_node_proxy_set_active(d->node_proxy, active);
}
static const struct pw_node_events node_events = {
PW_VERSION_NODE_EVENTS,
.destroy = node_destroy,
.info_changed = node_info_changed,
client-node: pass spa_node_info along Pass the complete spa_node_info to update node information. Remove the redundant max/min port info. Update the remote node based on port and node update events.
2019-03-04 12:30:45 +01:00
.port_info_changed = node_port_info_changed,
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
.active_changed = node_active_changed,
};
static void node_proxy_destroy(void *_data)
{
struct node_data *data = _data;
clean_node(data);
spa_hook_remove(&data->node_listener);
if (data->do_free)
pw_node_destroy(data->node);
}
static const struct pw_proxy_events proxy_events = {
PW_VERSION_PROXY_EVENTS,
.destroy = node_proxy_destroy,
};
static struct pw_proxy *node_export(struct pw_remote *remote, void *object, bool do_free)
{
struct pw_node *node = object;
struct pw_proxy *proxy;
struct node_data *data;
int i;
proxy = pw_core_proxy_create_object(remote->core_proxy,
"client-node",
PW_TYPE_INTERFACE_ClientNode,
PW_VERSION_CLIENT_NODE,
&node->properties->dict,
sizeof(struct node_data));
if (proxy == NULL)
return NULL;
data = pw_proxy_get_user_data(proxy);
data->remote = remote;
data->node = node;
data->do_free = do_free;
data->core = pw_node_get_core(node);
data->node_proxy = (struct pw_client_node_proxy *)proxy;
data->remote_id = SPA_ID_INVALID;
node->exported = true;
spa_list_init(&data->free_mix);
spa_list_init(&data->mix[0]);
spa_list_init(&data->mix[1]);
for (i = 0; i < MAX_MIX; i++)
spa_list_append(&data->free_mix, &data->mix_pool[i].link);
pw_array_init(&data->mems, 64);
pw_array_ensure_size(&data->mems, sizeof(struct mem) * 64);
node: implement activation Make an eventfd for each node and listen for events when the node is activated. Reorganize some graphs links to make it possible to activiate nodes by signaling the eventfd Pass the peer node to each remote node and let the remote node directly activate the peer when needed. Let each node signal the driver node when finished. With this we don't need to go through the daemon to schedule the graph, nodes will simply activate eachother. We only go to the server when there is a server node to schedule. Keep stats about the state of each node and the time it was triggered, running and finished.
2019-02-12 17:42:33 +01:00
pw_array_init(&data->links, 64);
pw_array_ensure_size(&data->links, sizeof(struct link) * 64);
remote: move node export code to client-node module Make the code to export objects more generic. Make it possible for modules to register a type to export. Make the client-node also able to export plain spa_nodes. Let the remote signal the global of the exported object if any. We can then remote the (unused) remote_id from the proxy.
2019-01-31 11:02:13 +01:00
pw_proxy_add_listener(proxy, &data->proxy_listener, &proxy_events, data);
pw_node_add_listener(node, &data->node_listener, &node_events, data);
pw_client_node_proxy_add_listener(data->node_proxy,
&data->node_proxy_listener,
&client_node_events,
proxy);
do_node_init(proxy);
return proxy;
}
struct pw_proxy *pw_remote_node_export(struct pw_remote *remote,
uint32_t type, struct pw_properties *props, void *object)
{
return node_export(remote, object, false);
}
struct pw_proxy *pw_remote_spa_node_export(struct pw_remote *remote,
uint32_t type, struct pw_properties *props, void *object)
{
struct pw_node *node;
node = pw_node_new(pw_remote_get_core(remote), NULL, props, 0);
if (node == NULL)
return NULL;
pw_node_set_implementation(node, (struct spa_node*)object);
pw_node_register(node, NULL, NULL, NULL);
pw_node_set_active(node, true);
return node_export(remote, node, true);
}
Reference in a new issue Copy permalink