791a38f3fa
sm_object may be owned by either (i) monitors, created via
sm_media_session_create/export*, or (ii) registry, via
registry_global+bind_object. However, registry adds the objects to its
globals list when their proxy appears, even if it does not own them.
Only owner should call sm_object_destroy which unrefs obj->handle,
because the sm_object structure is stored inside the handle's user_data
and becomes invalid afterward.
The sm_object_destroy call removes the object from the registry globals
map, so if monitor calls first, there is no problem. However, sometimes
the registry wins the race.
Previously, registry did sm_object_destroy regardless of whether it owns
the object or not, possibly causing the monitor's sm_object_destroy to
refer to freed memory. This could cause segfaults, e.g.
CARD=XX:XX:XX:XX:XX:XX
bluetootctl connect $CARD
while true; do pactl set-card-profile bluez_card.$CARD a2dp-sink; pactl set-card-profile bluez_card.$CARD off; done
leads to a race between bluez5_remove_node and registry_global_remove,
and problems appear when the latter wins. (As usual, if it doesn't
segfault, a heisenbug appears instead.)
Fix this by keeping track who owns the objects, and having registry
destroy the objects only if it owns them. Otherwise, it just removes
them from its lists.
Also call pw_proxy_unref unconditionally in sm_object_destroy, so its
asserts catch refcounting errors (although now there shouldn't be any).
***
Another problem is conflict between bound_proxy and register_global,
which generates duplicate objects with the same id. We resolve this by
keeping the object not owned by the registry and discarding the other
one.
This fixes a memory leak, and possible consistency problems in session
modules (due to session_create events for different objects with same
id; now there will be paired session_remove ones in between).
|
||
|---|---|---|
| .gitlab/issue_templates | ||
| doc | ||
| man | ||
| pipewire-alsa | ||
| pipewire-jack | ||
| po | ||
| spa | ||
| src | ||
| .cirrus.yml | ||
| .codespell-ignore | ||
| .editorconfig | ||
| .gitignore | ||
| .gitlab-ci.yml | ||
| _config.yml | ||
| autogen.sh | ||
| check_missing_headers.sh | ||
| CODE_OF_CONDUCT.md | ||
| config.h.meson | ||
| COPYING | ||
| INSTALL.md | ||
| LICENSE | ||
| Makefile.in | ||
| meson.build | ||
| meson_options.txt | ||
| NEWS | ||
| PROTOCOL | ||
| pw-uninstalled.sh | ||
| README.md | ||
| template.test.in | ||
PipeWire
PipeWire is a server and user space API to deal with multimedia pipelines. This includes:
- Making available sources of video (such as from a capture devices or application provided streams) and multiplexing this with clients.
- Accessing sources of video for consumption.
- Generating graphs for audio and video processing.
Nodes in the graph can be implemented as separate processes, communicating with sockets and exchanging multimedia content using fd passing.
Building and installation
The preferred way to install PipeWire is to install it with your distribution package system. This ensures PipeWire is integrated into the rest of your system for the best experience.
If you want to build and install PipeWire yourself, refer to install for instructions.
Usage
The most important purpose of PipeWire is to run your favorite apps.
Some applications use the native PipeWire API, such as most compositors (gnome-shell, wayland, ...) to implement screen sharing. These apps will just work automatically.
Most audio applications can use either ALSA, JACK or PulseAudio as a backend. PipeWire provides support for all 3 backends. Depending on how your distribution has configured things this should just work automatically or with the provided scripts shown below.
PipeWire can use environment variables to control the behaviour of applications:
PIPEWIRE_DEBUG=<level>to increase the debug levelPIPEWIRE_LOG=<filename>to redirect log to filenamePIPEWIRE_LATENCY=<num/denom>to configure latency as a fraction. 10/1000 configures a 10ms latency. Usually this is expressed as a fraction of the samplerate, like 256/48000, which uses 256 samples at a samplerate of 48KHz for a latency of 5.33ms.PIPEWIRE_NODE=<id>to request a link to the specified node
Using tools
pw-cat can be used to play and record audio and midi. Use pw-cat -h to get
some more help. There are some aliases like pw-play and pw-record to make
things easier:
$ pw-play /home/wim/data/01.\ Firepower.wav
Running JACK applications
Depending on how the system was configured, you can either run PipeWire and JACK side-by-side or have PipeWire take over the functionality of JACK completely.
In dual mode, JACK apps will by default use the JACK server. To direct a JACK
app to PipeWire, you can use the pw-jack script like this:
$ pw-jack <appname>
If you replaced JACK with PipeWire completely, pw-jack does not have any
effect and can be omitted.
Running PulseAudio applications
PipeWire can run a PulseAudio compatible replacement server. You can't use both servers at the same time. Usually your package manager will make the server conflict so that you can only install one or the other.
PulseAudio applications still use the regular PulseAudio client libraries and you don't need to do anything else than change the server implementation.
A successful swap of the server can be verified by checking the output of
pactl info
It should include the string:
...
Server Name: PulseAudio (on PipeWire 0.3.x)
...
Running ALSA applications
If the PipeWire alsa module is installed, it can be seen with
$ aplay -L
ALSA applications can then use the pipewire: device to use PipeWire
as the audio system.
Running GStreamer applications
PipeWire includes 2 GStreamer elements called pipewiresrc and
pipewiresink. They can be used in pipelines such as this:
$ gst-launch-1.0 pipewiresrc ! videoconvert ! autovideosink
Or to play a beeping sound:
$ gst-launch-1.0 audiotestsrc ! pipewiresink
PipeWire provides a device monitor as well so that
$ gst-device-monitor-1.0
shows the PipeWire devices and applications like cheese will automatically use the PipeWire video source when possible.
Inspecting the PipeWire state
There is currently no native graphical tool to inspect the PipeWire graph
but we recommend to use one of the excellent JACK tools, such as Carla,
catia, qjackctl, ...
You will not be able to see all features like the video
ports but it is a good start.
pw-mon dumps and monitors the state of the PipeWire daemon.
pw-dot can dump a graph of the pipeline, check out the help for
how to do this.
There is a more complicated tool to inspect the state of the server
with pw-cli. This tools can be used interactively or it can execute
single commands like this to get the server information:
$ pw-cli info 0
Documentation
Find tutorials and design documentation here.
The (incomplete) autogenerated API docs are here.
Contributing
PipeWire is Free Software and is developed in the open. It is licensed under the MIT license.
Contributors are encouraged to submit merge requests or file bugs on gitlab.
Join us on IRC at #pipewire on Freenode.
We adhere to the Contributor Covenant for our code of conduct.