Use an adapter instead of the client-stream. This means we run
the audioconverters and resamplers in the client instead of the
pipewire daemon. It also allows us to implement the audio mixing
correctly in the capture client.
The only pending piece is that we now wake up the client with the
period of the server. Maybe we can later optimize that and
accumulate/split buffers before waking the client.
This probably needs fixing with video..
Define a set of standard factory names and document what they
contain. This makes it possible to change the implementation by
mapping the factory-name to a different shared library.
Move the epoll functions to the system functions and make the loop
use those. Use simple mask for events instead of enum.
Add the used system api in pw_loop.
Add System API to spa_support and use it where possible.
Pass the system API used in the realtime loops in spa_support as
well and use this in the realtime paths.
Improve bootstrapping, load only the log and cpu interfaces because
those can/need to be shared between instances. Let the core load
the other interfaces.
Add keys to configure the System and Loop implementations used in
pw_loop.
Remove override for resources, it can't work in general.
Rename method to add_object_listener to add a listener for
events/methods from the remote object.
Rename some methods to _call to call the interface and _notify
to notify the listeners.
Remove unused client event to be notified of resource
implementations.
The interface struct has the type,version and methods of the
interface.
Make spa interfaces extend from spa_interface and make a
separate structure for the methods.
Pass a generic void* as the first argument of methods, like
we don in PipeWire.
Bundle the methods + implementation in a versioned inteface
and use that to invoke methods. This way we can do version
checks on the methods.
Make resource and proxy interfaces that we can can call. We
can then make the core interfaces independent on proxy/resource and
hide them in the lower layers.
Add add_listener method to methods of core interfaces, just
like SPA.
Pass a message around to make things more extensible later.
Keep fds per message if we ever want to write individual
messages.
Pass number of fds in the message header. We might need this to
close the fds when the proxy is gone.
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.
Output controls can be linked to many input controls and many input
controls can receive input from many output controls. Keep the control
link information inside the link.
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.
When we have a client driver node, it will have prepared the io
areas for us before sending the ready signal. We then need to run
the converters before signaling ready.
