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

1147 lines
29 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>
stream: prepare output before signaling ready Just prepare the output on the port and signal ready. When the graph completes we will be signaled again to recycle the buffer and prepare more output if we can. Improve the bookkeeping a little when activating nodes. Fix race with moving nodes between drivers.
2019-03-07 23:01:32 +01:00
#include <time.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 <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
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
#define MAX_IO 32
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
/** \cond */
struct buffer {
uint32_t id;
struct spa_buffer *buf;
mem: use MemId to pass buffer memory Track memory on buffers in the server and simplify some memory tracking on the client. Don't send internal memblock flags to client. Add read/write flags to memblock.
2019-07-24 10:33:26 +02:00
struct pw_memmap *mem;
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 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 {
remote-node: handle add/remove of activation
2019-03-07 18:34:15 +01:00
uint32_t node_id;
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
struct pw_memmap *map;
scheduling: don't use the graph helpers. Simplify the scheduling by using simple lists and removing the subgraphs etc.. Make the driver node trigger all nodes it manages and when they complete, trigger the driver node to finish the graph.
2019-03-06 20:33:55 +01:00
struct pw_node_target target;
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
int signalfd;
};
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;
mem: Add tag to memmap Add a tag field when creating a memmap so that we can do lookup on it. This makes it easier to implement the tracking of mappings for io areas. Remove custom io memory tracking and use the tags. Add flags to spa_chunk to make data corrupted. The flags on the buffer stay constant for the life of the buffer. Add flags to mark memory readable and writable. Mark memory readonly in v4l2-source. Pass the daemon activation area to the client in the transport event. This never changes and need to be handled differently from the other activation areas. Use the right flags when importing memory. Add the (desired) memory type to mempool_alloc. improve some debug.
2019-07-25 12:10:05 +02:00
struct pw_memmap *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
struct mix mix_pool[MAX_MIX];
struct spa_list mix[2];
struct spa_list free_mix;
struct pw_node *node;
struct spa_hook node_listener;
remote-node: reuse activation logic in pw_node Set the received eventfd as the node eventfd and let existing logic take care of scheduling the node.
2019-04-17 15:23:11 +02:00
int do_free:1;
int have_transport: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
client-node: improve cleanup
2019-08-01 15:04:18 +02:00
struct pw_client_node_proxy *client_node;
struct spa_hook client_node_listener;
struct spa_hook client_node_proxy_listener;
struct pw_proxy *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
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 */
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
static struct link *find_activation(struct pw_array *links, uint32_t node_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
{
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
struct link *l;
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
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
pw_array_for_each(l, links) {
if (l->node_id == node_id)
return l;
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
}
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
return NULL;
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
}
fix some small memory leaks
2019-03-11 15:50:52 +01:00
static void clear_link(struct node_data *data, struct link *link)
{
link->node_id = SPA_ID_INVALID;
link->target.activation = NULL;
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
pw_memmap_free(link->map);
fix some small memory leaks
2019-03-11 15:50:52 +01:00
close(link->signalfd);
spa_list_remove(&link->target.link);
}
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 clean_transport(struct node_data *data)
{
fix some small memory leaks
2019-03-11 15:50:52 +01:00
struct link *l;
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
remote-node: reuse activation logic in pw_node Set the received eventfd as the node eventfd and let existing logic take care of scheduling the node.
2019-04-17 15:23:11 +02:00
if (!data->have_transport)
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;
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
pw_array_for_each(l, &data->links) {
if (l->node_id != SPA_ID_INVALID)
clear_link(data, l);
}
fix some small memory leaks
2019-03-11 15:50:52 +01:00
pw_array_clear(&data->links);
mem: Add tag to memmap Add a tag field when creating a memmap so that we can do lookup on it. This makes it easier to implement the tracking of mappings for io areas. Remove custom io memory tracking and use the tags. Add flags to spa_chunk to make data corrupted. The flags on the buffer stay constant for the life of the buffer. Add flags to mark memory readable and writable. Mark memory readonly in v4l2-source. Pass the daemon activation area to the client in the transport event. This never changes and need to be handled differently from the other activation areas. Use the right flags when importing memory. Add the (desired) memory type to mempool_alloc. improve some debug.
2019-07-25 12:10:05 +02:00
pw_memmap_free(data->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
close(data->rtwritefd);
data->remote_id = SPA_ID_INVALID;
remote-node: reuse activation logic in pw_node Set the received eventfd as the node eventfd and let existing logic take care of scheduling the node.
2019-04-17 15:23:11 +02:00
data->have_transport = false;
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 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;
scheduling: don't use the graph helpers. Simplify the scheduling by using simple lists and removing the subgraphs etc.. Make the driver node trigger all nodes it manages and when they complete, trigger the driver node to finish the graph.
2019-03-06 20:33:55 +01:00
spa_list_remove(&mix->mix.rt_link);
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 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;
scheduling: don't use the graph helpers. Simplify the scheduling by using simple lists and removing the subgraphs etc.. Make the driver node trigger all nodes it manages and when they complete, trigger the driver node to finish the graph.
2019-03-06 20:33:55 +01:00
spa_list_append(&mix->port->rt.mix_list, &mix->mix.rt_link);
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 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_transport(void *object, uint32_t node_id,
mem: Add tag to memmap Add a tag field when creating a memmap so that we can do lookup on it. This makes it easier to implement the tracking of mappings for io areas. Remove custom io memory tracking and use the tags. Add flags to spa_chunk to make data corrupted. The flags on the buffer stay constant for the life of the buffer. Add flags to mark memory readable and writable. Mark memory readonly in v4l2-source. Pass the daemon activation area to the client in the transport event. This never changes and need to be handled differently from the other activation areas. Use the right flags when importing memory. Add the (desired) memory type to mempool_alloc. improve some debug.
2019-07-25 12:10:05 +02:00
int readfd, int writefd, uint32_t mem_id, uint32_t offset, uint32_t 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
{
struct pw_proxy *proxy = object;
struct node_data *data = proxy->user_data;
remote-node: use remote from data proxy could be cleared already when destroyed
2019-08-01 14:04:20 +02:00
struct pw_remote *remote = data->remote;
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
clean_transport(data);
remote-node: use remote from data proxy could be cleared already when destroyed
2019-08-01 14:04:20 +02:00
data->activation = pw_mempool_map_id(data->remote->pool, mem_id,
mem: Add tag to memmap Add a tag field when creating a memmap so that we can do lookup on it. This makes it easier to implement the tracking of mappings for io areas. Remove custom io memory tracking and use the tags. Add flags to spa_chunk to make data corrupted. The flags on the buffer stay constant for the life of the buffer. Add flags to mark memory readable and writable. Mark memory readonly in v4l2-source. Pass the daemon activation area to the client in the transport event. This never changes and need to be handled differently from the other activation areas. Use the right flags when importing memory. Add the (desired) memory type to mempool_alloc. improve some debug.
2019-07-25 12:10:05 +02:00
PW_MEMMAP_FLAG_READWRITE, offset, size, NULL);
if (data->activation == NULL) {
pw_log_debug("remote-node %p: can't map activation: %m", proxy);
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
data->remote_id = node_id;
mem: Add tag to memmap Add a tag field when creating a memmap so that we can do lookup on it. This makes it easier to implement the tracking of mappings for io areas. Remove custom io memory tracking and use the tags. Add flags to spa_chunk to make data corrupted. The flags on the buffer stay constant for the life of the buffer. Add flags to mark memory readable and writable. Mark memory readonly in v4l2-source. Pass the daemon activation area to the client in the transport event. This never changes and need to be handled differently from the other activation areas. Use the right flags when importing memory. Add the (desired) memory type to mempool_alloc. improve some debug.
2019-07-25 12:10:05 +02:00
data->node->rt.activation = data->activation->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
mem: Add tag to memmap Add a tag field when creating a memmap so that we can do lookup on it. This makes it easier to implement the tracking of mappings for io areas. Remove custom io memory tracking and use the tags. Add flags to spa_chunk to make data corrupted. The flags on the buffer stay constant for the life of the buffer. Add flags to mark memory readable and writable. Mark memory readonly in v4l2-source. Pass the daemon activation area to the client in the transport event. This never changes and need to be handled differently from the other activation areas. Use the right flags when importing memory. Add the (desired) memory type to mempool_alloc. improve some debug.
2019-07-25 12:10:05 +02:00
pw_log_debug("remote-node %p: fds:%d %d node:%u activation:%p",
proxy, readfd, writefd, node_id, data->activation->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
data->rtwritefd = writefd;
remote-node: reuse activation logic in pw_node Set the received eventfd as the node eventfd and let existing logic take care of scheduling the node.
2019-04-17 15:23:11 +02:00
close(data->node->source.fd);
data->node->source.fd = readfd;
mem: Add tag to memmap Add a tag field when creating a memmap so that we can do lookup on it. This makes it easier to implement the tracking of mappings for io areas. Remove custom io memory tracking and use the tags. Add flags to spa_chunk to make data corrupted. The flags on the buffer stay constant for the life of the buffer. Add flags to mark memory readable and writable. Mark memory readonly in v4l2-source. Pass the daemon activation area to the client in the transport event. This never changes and need to be handled differently from the other activation areas. Use the right flags when importing memory. Add the (desired) memory type to mempool_alloc. improve some debug.
2019-07-25 12:10:05 +02:00
data->have_transport = true;
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->node->active)
client-node: improve cleanup
2019-08-01 15:04:18 +02:00
pw_client_node_proxy_set_active(data->client_node, true);
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: add get_node method Make a get node method that binds to the server side node of the client-node immediately. use this in the remote_export and always return a node proxy. Use the node proxy to get property updates and signal those in the stream.
2019-03-15 20:29:34 +01:00
pw_remote_emit_exported(remote, data->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;
}
client-node: improve cleanup
2019-08-01 15:04:18 +02:00
res = pw_client_node_proxy_update(data->client_node,
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
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;
Add support for client fd memory Remove the node buffers reply again. We don't need it. Instead add a new method to the client-node to upload an array of buffer datas. This method is called after the client has allocated buffer mem. It will update the buffers on the server side with the client allocated memory. Wait for the async reply of use_buffers when doing alloc_buffers so that we can get the updated buffer mem before we continue. Let the link follow the states of the ports. Add some error code to the port error states. Add PW_STREAM_FLAG_ALLOC_BUFFERS flag to make the client alloc buffer memory.
2019-07-26 15:53:26 +02:00
SPA_FLAG_UNSET(pi.flags, SPA_PORT_FLAG_DYNAMIC_DATA);
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
}
client-node: improve cleanup
2019-08-01 15:04:18 +02:00
res = pw_client_node_proxy_port_update(data->client_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
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)
{
remote-node: implement set_param and port_set_io Implement set_param, just call the node implementation Always call port_set_io on the mixer port.
2019-07-12 09:58:56 +02:00
struct pw_proxy *proxy = object;
struct node_data *data = proxy->user_data;
return spa_node_set_param(data->node->node, id, flags, 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
}
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;
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
struct pw_memmap *mm;
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
void *ptr;
mem: Add tag to memmap Add a tag field when creating a memmap so that we can do lookup on it. This makes it easier to implement the tracking of mappings for io areas. Remove custom io memory tracking and use the tags. Add flags to spa_chunk to make data corrupted. The flags on the buffer stay constant for the life of the buffer. Add flags to mark memory readable and writable. Mark memory readonly in v4l2-source. Pass the daemon activation area to the client in the transport event. This never changes and need to be handled differently from the other activation areas. Use the right flags when importing memory. Add the (desired) memory type to mempool_alloc. improve some debug.
2019-07-25 12:10:05 +02:00
uint32_t tag[5] = { data->remote_id, 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
if (memid == SPA_ID_INVALID) {
remote-node: use remote from data proxy could be cleared already when destroyed
2019-08-01 14:04:20 +02:00
if ((mm = pw_mempool_find_tag(data->remote->pool, tag, sizeof(tag))) != NULL)
mem: Add tag to memmap Add a tag field when creating a memmap so that we can do lookup on it. This makes it easier to implement the tracking of mappings for io areas. Remove custom io memory tracking and use the tags. Add flags to spa_chunk to make data corrupted. The flags on the buffer stay constant for the life of the buffer. Add flags to mark memory readable and writable. Mark memory readonly in v4l2-source. Pass the daemon activation area to the client in the transport event. This never changes and need to be handled differently from the other activation areas. Use the right flags when importing memory. Add the (desired) memory type to mempool_alloc. improve some debug.
2019-07-25 12:10:05 +02:00
pw_memmap_free(mm);
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
mm = ptr = NULL;
mem: Add tag to memmap Add a tag field when creating a memmap so that we can do lookup on it. This makes it easier to implement the tracking of mappings for io areas. Remove custom io memory tracking and use the tags. Add flags to spa_chunk to make data corrupted. The flags on the buffer stay constant for the life of the buffer. Add flags to mark memory readable and writable. Mark memory readonly in v4l2-source. Pass the daemon activation area to the client in the transport event. This never changes and need to be handled differently from the other activation areas. Use the right flags when importing memory. Add the (desired) memory type to mempool_alloc. improve some debug.
2019-07-25 12:10:05 +02:00
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
}
else {
remote-node: use remote from data proxy could be cleared already when destroyed
2019-08-01 14:04:20 +02:00
mm = pw_mempool_map_id(data->remote->pool, memid,
mem: Add tag to memmap Add a tag field when creating a memmap so that we can do lookup on it. This makes it easier to implement the tracking of mappings for io areas. Remove custom io memory tracking and use the tags. Add flags to spa_chunk to make data corrupted. The flags on the buffer stay constant for the life of the buffer. Add flags to mark memory readable and writable. Mark memory readonly in v4l2-source. Pass the daemon activation area to the client in the transport event. This never changes and need to be handled differently from the other activation areas. Use the right flags when importing memory. Add the (desired) memory type to mempool_alloc. improve some debug.
2019-07-25 12:10:05 +02:00
PW_MEMMAP_FLAG_READWRITE, offset, size, tag);
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
if (mm == NULL) {
pw_log_warn("can't map memory id %u: %m", 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 -errno;
remote-node: improve some errors
2019-03-12 09:07:33 +01:00
}
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
ptr = mm->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
}
pw_log_debug("node %p: set io %s %p", proxy,
spa_debug_type_find_name(spa_type_io, id), ptr);
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
switch (id) {
case SPA_IO_Position:
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
data->position = ptr;
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
break;
default:
break;
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
}
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02: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 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
}
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;
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
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
}
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;
int res;
improve debug
2019-08-06 17:05:08 +02:00
pw_log_debug("port %p: clear buffers mix:%d %zd", port, mix->mix_id, mix->buffers.size);
node: add flags to port_use_buffer Remove the CAN_USE_BUFFERS flag, it is redundant. We can know this because of the IO params and buffer params. Add flags to the port_use_buffer call. We also want this call to replace port_alloc_buffer. Together with a new result event we can ask the node to (a)synchronously fill up the buffer data for us. This is part of a plan to let remote nodes provide buffer data.
2019-07-25 13:19:39 +02:00
if ((res = pw_port_use_buffers(port, mix->mix_id, 0, NULL, 0)) < 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_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) {
improve debug
2019-08-06 17:05:08 +02:00
pw_log_debug("port %p: clear buffer %d map %p %p",
port, b->id, b->mem, b->buf);
mem: use MemId to pass buffer memory Track memory on buffers in the server and simplify some memory tracking on the client. Don't send internal memblock flags to client. Add read/write flags to memblock.
2019-07-24 10:33:26 +02:00
pw_memmap_free(b->mem);
improve debug
2019-08-06 17:05:08 +02:00
free(b->buf);
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->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;
improve error handling some more
2019-06-20 11:04:34 +02:00
goto error_exit;
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_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);
}
}
port: simplify states Remove the mix states, we can get rid of them when: The format is the same for all mixer ports. Set the existing format on new mixer ports. When the first format is set, the port becomes READY. When all mixer ports are cleared the port goes back to CONFIGURE. Only output ports allocate and manage buffers, input ports share the buffers of the peer output port on the link.
2019-03-06 09:53:41 +01:00
res = pw_port_set_param(port, id, flags, param);
improve error handling some more
2019-06-20 11:04:34 +02:00
if (res < 0)
goto error_exit;
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
improve error handling some more
2019-06-20 11:04:34 +02:00
error_exit:
pw_log_error("port %p: set_param %d %p: %s", port, id, param, spa_strerror(res));
pw_proxy_error(proxy, res, "port_set_param: %s", 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
}
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,
node: add flags to port_use_buffer Remove the CAN_USE_BUFFERS flag, it is redundant. We can know this because of the IO params and buffer params. Add flags to the port_use_buffer call. We also want this call to replace port_alloc_buffer. Together with a new result event we can ask the node to (a)synchronously fill up the buffer data for us. This is part of a plan to let remote nodes provide buffer data.
2019-07-25 13:19:39 +02:00
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
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) {
improve error handling some more
2019-06-20 11:04:34 +02:00
res = -ENOENT;
goto error_exit;
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
}
mem: Add tag to memmap Add a tag field when creating a memmap so that we can do lookup on it. This makes it easier to implement the tracking of mappings for io areas. Remove custom io memory tracking and use the tags. Add flags to spa_chunk to make data corrupted. The flags on the buffer stay constant for the life of the buffer. Add flags to mark memory readable and writable. Mark memory readonly in v4l2-source. Pass the daemon activation area to the client in the transport event. This never changes and need to be handled differently from the other activation areas. Use the right flags when importing memory. Add the (desired) memory type to mempool_alloc. improve some debug.
2019-07-25 12:10:05 +02:00
prot = PW_MEMMAP_FLAG_READ | (direction == SPA_DIRECTION_OUTPUT ? PW_MEMMAP_FLAG_WRITE : 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
/* clear previous buffers */
clear_buffers(data, mix);
bufs = alloca(n_buffers * sizeof(struct spa_buffer *));
for (i = 0; i < n_buffers; i++) {
size_t size;
off_t offset;
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
struct pw_memmap *mm;
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
remote-node: use remote from data proxy could be cleared already when destroyed
2019-08-01 14:04:20 +02:00
mm = pw_mempool_map_id(data->remote->pool, buffers[i].mem_id,
mem: Add tag to memmap Add a tag field when creating a memmap so that we can do lookup on it. This makes it easier to implement the tracking of mappings for io areas. Remove custom io memory tracking and use the tags. Add flags to spa_chunk to make data corrupted. The flags on the buffer stay constant for the life of the buffer. Add flags to mark memory readable and writable. Mark memory readonly in v4l2-source. Pass the daemon activation area to the client in the transport event. This never changes and need to be handled differently from the other activation areas. Use the right flags when importing memory. Add the (desired) memory type to mempool_alloc. improve some debug.
2019-07-25 12:10:05 +02:00
prot, buffers[i].offset, buffers[i].size, NULL);
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
if (mm == NULL) {
res = -errno;
improve error handling some more
2019-06-20 11:04:34 +02:00
goto error_exit_cleanup;
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
}
bid = pw_array_add(&mix->buffers, sizeof(struct buffer));
improve error handling
2019-06-19 16:22:22 +02:00
if (bid == NULL) {
res = -errno;
improve error handling some more
2019-06-20 11:04:34 +02:00
goto error_exit_cleanup;
improve error handling
2019-06-19 16:22:22 +02: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
bid->id = i;
mem: use MemId to pass buffer memory Track memory on buffers in the server and simplify some memory tracking on the client. Don't send internal memblock flags to client. Add read/write flags to memblock.
2019-07-24 10:33:26 +02:00
bid->mem = mm;
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
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
if (mlock(mm->ptr, mm->size) < 0)
pw_log_warn("Failed to mlock memory %p %u: %m",
mm->ptr, mm->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
size = sizeof(struct spa_buffer);
for (j = 0; j < buffers[i].buffer->n_metas; j++)
size += sizeof(struct spa_meta);
mem: use MemId to pass buffer memory Track memory on buffers in the server and simplify some memory tracking on the client. Don't send internal memblock flags to client. Add read/write flags to memblock.
2019-07-24 10:33:26 +02:00
for (j = 0; j < buffers[i].buffer->n_datas; j++)
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
size += sizeof(struct spa_data);
b = bid->buf = malloc(size);
if (b == NULL) {
improve error handling
2019-06-19 16:22:22 +02:00
res = -errno;
improve error handling some more
2019-06-20 11:04:34 +02:00
goto error_exit_cleanup;
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
}
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);
improve debug
2019-08-06 17:05:08 +02:00
pw_log_debug("add buffer %d %d %u %u %p", mm->block->id,
bid->id, buffers[i].offset, buffers[i].size, bid->buf);
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
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));
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
m->data = SPA_MEMBER(mm->ptr, offset, void);
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
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 =
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
SPA_MEMBER(mm->ptr, offset + sizeof(struct spa_chunk) * j,
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_chunk);
client-node: also track memory on the server Do the same kind of memory tracking on the server side so that we can remove the fd from the client when unused.
2019-07-29 17:10:15 +02:00
if (flags & SPA_NODE_BUFFERS_FLAG_ALLOC)
continue;
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
if (d->type == SPA_DATA_MemId) {
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 mem_id = SPA_PTR_TO_UINT32(d->data);
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
struct pw_memblock *bm;
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
remote-node: use remote from data proxy could be cleared already when destroyed
2019-08-01 14:04:20 +02:00
bm = pw_mempool_find_id(data->remote->pool, 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
if (bm == NULL) {
pw_log_error("unknown buffer mem %u", mem_id);
improve error handling some more
2019-06-20 11:04:34 +02:00
res = -ENODEV;
goto error_exit_cleanup;
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
}
d->fd = bm->fd;
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
d->type = bm->type;
d->data = NULL;
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_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);
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
d->data = SPA_MEMBER(mm->ptr, offs, void);
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
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;
}
Add support for client fd memory Remove the node buffers reply again. We don't need it. Instead add a new method to the client-node to upload an array of buffer datas. This method is called after the client has allocated buffer mem. It will update the buffers on the server side with the client allocated memory. Wait for the async reply of use_buffers when doing alloc_buffers so that we can get the updated buffer mem before we continue. Let the link follow the states of the ports. Add some error code to the port error states. Add PW_STREAM_FLAG_ALLOC_BUFFERS flag to make the client alloc buffer memory.
2019-07-26 15:53:26 +02:00
if ((res = pw_port_use_buffers(mix->port, mix_id, flags, bufs, n_buffers)) < 0)
improve error handling some more
2019-06-20 11:04:34 +02:00
goto error_exit_cleanup;
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
Add support for client fd memory Remove the node buffers reply again. We don't need it. Instead add a new method to the client-node to upload an array of buffer datas. This method is called after the client has allocated buffer mem. It will update the buffers on the server side with the client allocated memory. Wait for the async reply of use_buffers when doing alloc_buffers so that we can get the updated buffer mem before we continue. Let the link follow the states of the ports. Add some error code to the port error states. Add PW_STREAM_FLAG_ALLOC_BUFFERS flag to make the client alloc buffer memory.
2019-07-26 15:53:26 +02:00
if (flags & SPA_NODE_BUFFERS_FLAG_ALLOC) {
client-node: improve cleanup
2019-08-01 15:04:18 +02:00
pw_client_node_proxy_port_buffers(data->client_node,
Add support for client fd memory Remove the node buffers reply again. We don't need it. Instead add a new method to the client-node to upload an array of buffer datas. This method is called after the client has allocated buffer mem. It will update the buffers on the server side with the client allocated memory. Wait for the async reply of use_buffers when doing alloc_buffers so that we can get the updated buffer mem before we continue. Let the link follow the states of the ports. Add some error code to the port error states. Add PW_STREAM_FLAG_ALLOC_BUFFERS flag to make the client alloc buffer memory.
2019-07-26 15:53:26 +02:00
direction, port_id, mix_id,
n_buffers,
bufs);
}
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
improve error handling some more
2019-06-20 11:04:34 +02:00
error_exit_cleanup:
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
clear_buffers(data, mix);
improve error handling some more
2019-06-20 11:04:34 +02:00
error_exit:
improve debug
2019-08-06 17:05:08 +02:00
pw_log_error("port %p: use_buffers: %d %s", mix, res, spa_strerror(res));
improve error handling some more
2019-06-20 11:04:34 +02:00
pw_proxy_error(proxy, res, "port_use_buffers error: %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
}
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;
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
struct pw_memmap *mm;
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
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;
mem: Add tag to memmap Add a tag field when creating a memmap so that we can do lookup on it. This makes it easier to implement the tracking of mappings for io areas. Remove custom io memory tracking and use the tags. Add flags to spa_chunk to make data corrupted. The flags on the buffer stay constant for the life of the buffer. Add flags to mark memory readable and writable. Mark memory readonly in v4l2-source. Pass the daemon activation area to the client in the transport event. This never changes and need to be handled differently from the other activation areas. Use the right flags when importing memory. Add the (desired) memory type to mempool_alloc. improve some debug.
2019-07-25 12:10:05 +02:00
uint32_t tag[5] = { data->remote_id, direction, port_id, mix_id, 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
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) {
improve error handling some more
2019-06-20 11:04:34 +02:00
res = -ENOENT;
goto error_exit;
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
if (memid == SPA_ID_INVALID) {
remote-node: use remote from data proxy could be cleared already when destroyed
2019-08-01 14:04:20 +02:00
if ((mm = pw_mempool_find_tag(data->remote->pool, tag, sizeof(tag))) != NULL)
mem: Add tag to memmap Add a tag field when creating a memmap so that we can do lookup on it. This makes it easier to implement the tracking of mappings for io areas. Remove custom io memory tracking and use the tags. Add flags to spa_chunk to make data corrupted. The flags on the buffer stay constant for the life of the buffer. Add flags to mark memory readable and writable. Mark memory readonly in v4l2-source. Pass the daemon activation area to the client in the transport event. This never changes and need to be handled differently from the other activation areas. Use the right flags when importing memory. Add the (desired) memory type to mempool_alloc. improve some debug.
2019-07-25 12:10:05 +02:00
pw_memmap_free(mm);
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
mm = ptr = NULL;
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
size = 0;
}
else {
remote-node: use remote from data proxy could be cleared already when destroyed
2019-08-01 14:04:20 +02:00
mm = pw_mempool_map_id(data->remote->pool, memid,
mem: Add tag to memmap Add a tag field when creating a memmap so that we can do lookup on it. This makes it easier to implement the tracking of mappings for io areas. Remove custom io memory tracking and use the tags. Add flags to spa_chunk to make data corrupted. The flags on the buffer stay constant for the life of the buffer. Add flags to mark memory readable and writable. Mark memory readonly in v4l2-source. Pass the daemon activation area to the client in the transport event. This never changes and need to be handled differently from the other activation areas. Use the right flags when importing memory. Add the (desired) memory type to mempool_alloc. improve some debug.
2019-07-25 12:10:05 +02:00
PW_MEMMAP_FLAG_READWRITE, offset, size, tag);
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
if (mm == 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
res = -errno;
improve error handling some more
2019-06-20 11:04:34 +02:00
goto error_exit;
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
}
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
ptr = mm->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
}
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
pw_log_debug("port %p: set io:%s new:%p old:%p", mix->port,
client-node: track and free activation memory
2019-07-19 13:50:58 +02:00
spa_debug_type_find_name(spa_type_io, id), ptr, mix->mix.io);
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 (id == SPA_IO_Buffers) {
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
if (ptr == NULL && mix->mix.io)
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
deactivate_mix(data, mix);
mix->mix.io = ptr;
if (ptr)
activate_mix(data, mix);
remote-node: implement set_param and port_set_io Implement set_param, just call the node implementation Always call port_set_io on the mixer port.
2019-07-12 09:58:56 +02:00
}
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
remote-node: implement set_param and port_set_io Implement set_param, just call the node implementation Always call port_set_io on the mixer port.
2019-07-12 09:58:56 +02:00
if ((res = spa_node_port_set_io(mix->port->mix,
direction, mix_id,
id, ptr, size)) < 0) {
if (res == -ENOTSUP)
res = 0;
else
improve error handling some more
2019-06-20 11:04:34 +02:00
goto error_exit;
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;
improve error handling some more
2019-06-20 11:04:34 +02:00
error_exit:
pw_log_error("port %p: set_io: %s", mix, spa_strerror(res));
pw_proxy_error(proxy, res, "port_set_io 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
}
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
static int link_signal_func(void *user_data)
{
struct link *link = user_data;
uint64_t cmd = 1;
stream: prepare output before signaling ready Just prepare the output on the port and signal ready. When the graph completes we will be signaled again to recycle the buffer and prepare more output if we can. Improve the bookkeeping a little when activating nodes. Fix race with moving nodes between drivers.
2019-03-07 23:01:32 +01:00
struct timespec ts;
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_log_trace("link %p: signal", link);
stream: prepare output before signaling ready Just prepare the output on the port and signal ready. When the graph completes we will be signaled again to recycle the buffer and prepare more output if we can. Improve the bookkeeping a little when activating nodes. Fix race with moving nodes between drivers.
2019-03-07 23:01:32 +01:00
clock_gettime(CLOCK_MONOTONIC, &ts);
link->target.activation->status = TRIGGERED;
link->target.activation->signal_time = SPA_TIMESPEC_TO_NSEC(&ts);
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 (write(link->signalfd, &cmd, sizeof(cmd)) != sizeof(cmd))
pw_log_warn("link %p: write failed %m", link);
mem: Add tag to memmap Add a tag field when creating a memmap so that we can do lookup on it. This makes it easier to implement the tracking of mappings for io areas. Remove custom io memory tracking and use the tags. Add flags to spa_chunk to make data corrupted. The flags on the buffer stay constant for the life of the buffer. Add flags to mark memory readable and writable. Mark memory readonly in v4l2-source. Pass the daemon activation area to the client in the transport event. This never changes and need to be handled differently from the other activation areas. Use the right flags when importing memory. Add the (desired) memory type to mempool_alloc. improve some debug.
2019-07-25 12:10:05 +02: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
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
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;
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
struct pw_memmap *mm;
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_node_activation *ptr;
remote-node: handle add/remove of activation
2019-03-07 18:34:15 +01:00
struct link *link;
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;
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
mm = NULL;
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
size = 0;
}
else {
remote-node: use remote from data proxy could be cleared already when destroyed
2019-08-01 14:04:20 +02:00
mm = pw_mempool_map_id(data->remote->pool, memid,
mem: Add tag to memmap Add a tag field when creating a memmap so that we can do lookup on it. This makes it easier to implement the tracking of mappings for io areas. Remove custom io memory tracking and use the tags. Add flags to spa_chunk to make data corrupted. The flags on the buffer stay constant for the life of the buffer. Add flags to mark memory readable and writable. Mark memory readonly in v4l2-source. Pass the daemon activation area to the client in the transport event. This never changes and need to be handled differently from the other activation areas. Use the right flags when importing memory. Add the (desired) memory type to mempool_alloc. improve some debug.
2019-07-25 12:10:05 +02:00
PW_MEMMAP_FLAG_READWRITE, offset, size, NULL);
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
if (mm == NULL) {
improve error handling some more
2019-06-20 11:04:34 +02:00
res = -errno;
goto error_exit;
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
}
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
ptr = mm->ptr;
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: track and free activation memory
2019-07-19 13:50:58 +02:00
pw_log_debug("node %p: set activation %d %p %u %u", node, node_id, ptr, offset, size);
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-node: handle add/remove of activation
2019-03-07 18:34:15 +01:00
if (data->remote_id == node_id) {
pw_log_debug("node %p: our activation %u: %u %u %u %p", node, node_id,
memid, offset, size, ptr);
mem: Add tag to memmap Add a tag field when creating a memmap so that we can do lookup on it. This makes it easier to implement the tracking of mappings for io areas. Remove custom io memory tracking and use the tags. Add flags to spa_chunk to make data corrupted. The flags on the buffer stay constant for the life of the buffer. Add flags to mark memory readable and writable. Mark memory readonly in v4l2-source. Pass the daemon activation area to the client in the transport event. This never changes and need to be handled differently from the other activation areas. Use the right flags when importing memory. Add the (desired) memory type to mempool_alloc. improve some debug.
2019-07-25 12:10:05 +02:00
if (mm)
pw_memmap_free(mm);
remote-node: reuse activation logic in pw_node Set the received eventfd as the node eventfd and let existing logic take care of scheduling the node.
2019-04-17 15:23:11 +02:00
close(signalfd);
remote-node: handle add/remove of activation
2019-03-07 18:34:15 +01:00
return 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 (ptr) {
link = pw_array_add(&data->links, sizeof(struct link));
improve error handling some more
2019-06-20 11:04:34 +02:00
if (link == NULL) {
res = -errno;
goto error_exit;
}
remote-node: handle add/remove of activation
2019-03-07 18:34:15 +01:00
link->node_id = node_id;
mem: improve memory handling Add a memory pool to manage blocks of memory. Make it possible to allocate and import blocks. Add add_mem and remove_mem to the core events to signal a client of a block of memory. Remove the client-node add_mem. Make a global pool for memory and a per client pool where we import and share the memory we need with the client. Use the new memory pool to track and map memory in clients.
2019-07-23 17:41:25 +02:00
link->map = mm;
scheduling: don't use the graph helpers. Simplify the scheduling by using simple lists and removing the subgraphs etc.. Make the driver node trigger all nodes it manages and when they complete, trigger the driver node to finish the graph.
2019-03-06 20:33:55 +01:00
link->target.activation = ptr;
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
link->signalfd = signalfd;
scheduling: don't use the graph helpers. Simplify the scheduling by using simple lists and removing the subgraphs etc.. Make the driver node trigger all nodes it manages and when they complete, trigger the driver node to finish the graph.
2019-03-06 20:33:55 +01:00
link->target.signal = link_signal_func;
link->target.data = link;
remote-node: handle add/remove of activation
2019-03-07 18:34:15 +01:00
link->target.node = NULL;
spa_list_append(&node->rt.target_list, &link->target.link);
client-node: track and free activation memory
2019-07-19 13:50:58 +02:00
pw_log_debug("node %p: link %p: fd:%d id:%u state %p required %d, pending %d",
node, link, signalfd,
link->target.activation->position.clock.id,
remote-node: handle add/remove of activation
2019-03-07 18:34:15 +01:00
&link->target.activation->state[0],
scheduling: don't use the graph helpers. Simplify the scheduling by using simple lists and removing the subgraphs etc.. Make the driver node trigger all nodes it manages and when they complete, trigger the driver node to finish the graph.
2019-03-06 20:33:55 +01:00
link->target.activation->state[0].required,
link->target.activation->state[0].pending);
port: simplify states Remove the mix states, we can get rid of them when: The format is the same for all mixer ports. Set the existing format on new mixer ports. When the first format is set, the port becomes READY. When all mixer ports are cleared the port goes back to CONFIGURE. Only output ports allocate and manage buffers, input ports share the buffers of the peer output port on the link.
2019-03-06 09:53:41 +01:00
} else {
remote-node: handle add/remove of activation
2019-03-07 18:34:15 +01:00
link = find_activation(&data->links, node_id);
if (link == NULL) {
improve error handling some more
2019-06-20 11:04:34 +02:00
res = -ENOENT;
goto error_exit;
remote-node: handle add/remove of activation
2019-03-07 18:34:15 +01:00
}
fix some small memory leaks
2019-03-11 15:50:52 +01:00
clear_link(data, link);
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
}
improve error handling some more
2019-06-20 11:04:34 +02:00
return res;
port: simplify states Remove the mix states, we can get rid of them when: The format is the same for all mixer ports. Set the existing format on new mixer ports. When the first format is set, the port becomes READY. When all mixer ports are cleared the port goes back to CONFIGURE. Only output ports allocate and manage buffers, input ports share the buffers of the peer output port on the link.
2019-03-06 09:53:41 +01:00
improve error handling some more
2019-06-20 11:04:34 +02:00
error_exit:
pw_log_error("node %p: set activation %d: %s", node, node_id, spa_strerror(res));
pw_proxy_error(proxy, res, "set_activation: %s", 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;
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,
.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)
{
deactivate_mix(data, mix);
spa_list_remove(&mix->link);
client-node: improve cleanup
2019-07-16 18:52:40 +02:00
clear_buffers(data, mix);
pw_array_clear(&mix->buffers);
spa_list_remove(&mix->mix.link);
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_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)
client-stream: improve cleanup
2019-03-11 22:07:17 +01:00
{
struct node_data *d = data;
pw_log_debug("%p: destroy", d);
clean_node(d);
}
static void node_free(void *data)
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 *d = data;
client-stream: improve cleanup
2019-03-11 22:07:17 +01:00
pw_log_debug("%p: free", d);
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: improve cleanup
2019-08-01 15:04:18 +02:00
if (d->client_node)
pw_proxy_destroy((struct pw_proxy*)d->client_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
}
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;
}
client-node: improve cleanup
2019-08-01 15:04:18 +02:00
add_node_update((struct pw_proxy*)d->client_node, change_mask);
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 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: improve cleanup
2019-08-01 15:04:18 +02:00
add_port_update((struct pw_proxy*)d->client_node, 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);
client-node: improve cleanup
2019-08-01 15:04:18 +02:00
pw_client_node_proxy_set_active(d->client_node, active);
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_node_events node_events = {
PW_VERSION_NODE_EVENTS,
.destroy = node_destroy,
client-stream: improve cleanup
2019-03-11 22:07:17 +01:00
.free = node_free,
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
.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,
};
client-node: improve cleanup
2019-08-01 15:04:18 +02:00
static void client_node_proxy_destroy(void *_data)
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 = _data;
client-node: improve cleanup
2019-07-16 18:52:40 +02:00
pw_log_debug("%p: destroy", data);
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
clean_node(data);
client-node: improve cleanup
2019-07-16 18:52:40 +02: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
spa_hook_remove(&data->node_listener);
client-node: improve cleanup
2019-07-16 18:52:40 +02:00
client-node: improve cleanup
2019-08-01 15:04:18 +02:00
data->client_node = NULL;
client-node: improve cleanup
2019-07-16 18:52:40 +02:00
client-node: improve cleanup
2019-08-01 15:04:18 +02:00
if (data->proxy)
client-node: improve cleanup
2019-07-16 18:52:40 +02:00
pw_proxy_destroy(data->proxy);
client-node: improve cleanup
2019-08-01 15:04:18 +02: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
if (data->do_free)
pw_node_destroy(data->node);
}
client-node: improve cleanup
2019-08-01 15:04:18 +02:00
static const struct pw_proxy_events client_node_proxy_events = {
PW_VERSION_PROXY_EVENTS,
.destroy = client_node_proxy_destroy,
};
static void proxy_destroy(void *_data)
{
struct node_data *data = _data;
pw_log_debug("%p: destroy", data);
spa_hook_remove(&data->proxy_listener);
data->proxy = NULL;
if (data->client_node)
pw_proxy_destroy((struct pw_proxy*)data->client_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
static const struct pw_proxy_events proxy_events = {
PW_VERSION_PROXY_EVENTS,
client-node: improve cleanup
2019-08-01 15:04:18 +02:00
.destroy = proxy_destroy,
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
};
remote-node: handle driver nodes
2019-03-04 17:55:43 +01:00
static int node_ready(void *d, int status)
{
struct node_data *data = d;
struct pw_node *node = data->node;
stream: prepare output before signaling ready Just prepare the output on the port and signal ready. When the graph completes we will be signaled again to recycle the buffer and prepare more output if we can. Improve the bookkeeping a little when activating nodes. Fix race with moving nodes between drivers.
2019-03-07 23:01:32 +01:00
struct timespec ts;
remote-node: first run the tee and then signal ready We first need to run the tee so that all the io areas are ready before we can start the driver on the daemon.
2019-03-07 18:34:39 +01:00
struct pw_port *p;
remote-node: handle driver nodes
2019-03-04 17:55:43 +01:00
uint64_t cmd = 1;
pw_log_trace("node %p: ready driver:%d exported:%d status:%d", node,
node->driver, node->exported, status);
stream: prepare output before signaling ready Just prepare the output on the port and signal ready. When the graph completes we will be signaled again to recycle the buffer and prepare more output if we can. Improve the bookkeeping a little when activating nodes. Fix race with moving nodes between drivers.
2019-03-07 23:01:32 +01:00
if (status == SPA_STATUS_HAVE_BUFFER) {
spa_list_for_each(p, &node->rt.output_mix, rt.node_link)
spa_node_process(p->mix);
}
clock_gettime(CLOCK_MONOTONIC, &ts);
node->rt.activation->status = TRIGGERED;
node->rt.activation->signal_time = SPA_TIMESPEC_TO_NSEC(&ts);
remote-node: first run the tee and then signal ready We first need to run the tee so that all the io areas are ready before we can start the driver on the daemon.
2019-03-07 18:34:39 +01:00
remote-node: handle driver nodes
2019-03-04 17:55:43 +01:00
if (write(data->rtwritefd, &cmd, sizeof(cmd)) != sizeof(cmd))
pw_log_warn("node %p: write failed %m", node);
return 0;
}
static int node_reuse_buffer(void *data, uint32_t port_id, uint32_t buffer_id)
{
return 0;
}
static const struct spa_node_callbacks node_callbacks = {
SPA_VERSION_NODE_CALLBACKS,
.ready = node_ready,
.reuse_buffer = node_reuse_buffer
};
remote: add option for extra user data for proxy When doing an export, make it possible to add extra data to the resulting proxy for user data.
2019-05-30 16:11:31 +02:00
static struct pw_proxy *node_export(struct pw_remote *remote, void *object, bool do_free,
size_t user_data_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
{
struct pw_node *node = object;
client-node: improve cleanup
2019-08-01 15:04:18 +02:00
struct pw_proxy *client_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
struct node_data *data;
int i;
client-node: improve cleanup
2019-08-01 15:04:18 +02:00
client_node = pw_core_proxy_create_object(remote->core_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
"client-node",
PW_TYPE_INTERFACE_ClientNode,
PW_VERSION_CLIENT_NODE,
&node->properties->dict,
sizeof(struct node_data));
client-node: improve cleanup
2019-08-01 15:04:18 +02:00
if (client_node == NULL)
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 NULL;
client-node: improve cleanup
2019-08-01 15:04:18 +02:00
data = pw_proxy_get_user_data(client_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
data->remote = remote;
data->node = node;
data->do_free = do_free;
data->core = pw_node_get_core(node);
client-node: improve cleanup
2019-08-01 15:04:18 +02:00
data->client_node = (struct pw_client_node_proxy *)client_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
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);
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
client-node: improve cleanup
2019-08-01 15:04:18 +02:00
pw_proxy_add_listener(client_node,
&data->client_node_proxy_listener,
&client_node_proxy_events, data);
remote-node: handle driver nodes
2019-03-04 17:55:43 +01:00
spa_node_set_callbacks(node->node, &node_callbacks, data);
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_node_add_listener(node, &data->node_listener, &node_events, data);
client-node: improve cleanup
2019-08-01 15:04:18 +02:00
pw_client_node_proxy_add_listener(data->client_node,
&data->client_node_listener,
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_events,
client-node: improve cleanup
2019-08-01 15:04:18 +02:00
client_node);
do_node_init(client_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
client-node: improve cleanup
2019-08-01 15:04:18 +02:00
data->proxy = (struct pw_proxy*) pw_client_node_proxy_get_node(data->client_node,
remote: add option for extra user data for proxy When doing an export, make it possible to add extra data to the resulting proxy for user data.
2019-05-30 16:11:31 +02:00
PW_VERSION_NODE_PROXY, user_data_size);
client-node: add get_node method Make a get node method that binds to the server side node of the client-node immediately. use this in the remote_export and always return a node proxy. Use the node proxy to get property updates and signal those in the stream.
2019-03-15 20:29:34 +01:00
client-node: improve cleanup
2019-08-01 15:04:18 +02:00
pw_proxy_add_listener(data->proxy, &data->proxy_listener, &proxy_events, data);
client-node: add get_node method Make a get node method that binds to the server side node of the client-node immediately. use this in the remote_export and always return a node proxy. Use the node proxy to get property updates and signal those in the stream.
2019-03-15 20:29:34 +01:00
return data->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
}
struct pw_proxy *pw_remote_node_export(struct pw_remote *remote,
remote: add option for extra user data for proxy When doing an export, make it possible to add extra data to the resulting proxy for user data.
2019-05-30 16:11:31 +02:00
uint32_t type, struct pw_properties *props, void *object,
size_t user_data_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
{
remote: add option for extra user data for proxy When doing an export, make it possible to add extra data to the resulting proxy for user data.
2019-05-30 16:11:31 +02:00
return node_export(remote, object, false, user_data_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
}
struct pw_proxy *pw_remote_spa_node_export(struct pw_remote *remote,
remote: add option for extra user data for proxy When doing an export, make it possible to add extra data to the resulting proxy for user data.
2019-05-30 16:11:31 +02:00
uint32_t type, struct pw_properties *props, void *object,
size_t user_data_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
{
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);
remote: add option for extra user data for proxy When doing an export, make it possible to add extra data to the resulting proxy for user data.
2019-05-30 16:11:31 +02:00
return node_export(remote, node, true, user_data_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
}
Reference in a new issue Copy permalink