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.
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
Make some more varargs error functions
Make pw_resource_error always just send the error to the resource id.
Make sure we send errors to the right destination.
Add proxy error event and emit it when the core finds an error for
the given proxy id.
The client error is supposed to be sent to all resources of a client
for the given global.
An unquoted $@ will break for arguments with spaces in their names. Unquoted $@ will work until it doesn't, and then it can be tricky to track down exactly what went wrong. Using "$@" will save someone some headache in the future.
On some toolchains/architectures, a char with -1 value is not equal
to the integer -1, resulting in this code to think that it got
an unrecognized command line option
meson < 0.46 does not allow two targets to share the same name;
meson >= 0.46 relaxes that requirement, but I see no reason to require
a new version of meson just for this
If these optional plugins are enabled in meson options,
then the dependencies should be required to proceed.
It is not cool to compile with let's say bluez5 explicitly
enabled and after compilation discover that bluez was not
found and meson silently skipped that plugin.
This allows finding dependencies conditionally, only
when the enabled features actually need them.
Also, make sure to require those dependencies when the enabled
features do need them, instead of using "required: false" and
failing later
These files help editors choose the correct coding style
conventions, mostly useful for the indentation style
Pipewire uses tab characters of size 8 in all of its codebase
except in the meson files and in the gstreamer plugins,
which use 2-space indentation
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.
Allocate a per node a piece of shared memory where we place the
activation structure with the graph state and io_position.
We can then give this info to nodes so that they can get the position
in the graph directly but also later, activate the next node in
the graph.
This will make it possible to select the right graph before we
start processing. The idea is that graph updates happen in a new
version and that the switch will to the new updated graph is done
when the period starts.
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.
If the link is destroyed, remove the listeners. Only remove the
resource listener when we actually have one.
If the resource is destroyed first, destroy the global.
If the global is destroyed first, make sure we don't destroy it
again when the resource is destroyed.
